feat(transfer): honor real provider capabilities in the Sync GUI

The Sync panel hardcoded parallel streams (1/3/6/8/8) regardless of
provider, advertising 8 streams on single-lease backends where the
transfer engine runs one file at a time. The GUI now consumes the
get_transfer_capabilities command through a new useTransferCapabilities
hook: speed presets and the parallel-stream selector are clamped to
max(max_file_slots, max_chunk_slots), the pill tooltip shows the real
effective stream count, the advanced selector offers only honourable
options (a single-lease provider lists Sequential only), and an honest
note discloses that SFTP checksum compare runs single-lease without
the session pool. When capabilities are unknown the legacy ceiling of
8 is kept, so pre-connect config and saved profiles are unchanged.

Consumer-side only: no new engine, pool or lease. One new i18n key
across all 47 locales.

Co-Authored-By: aeroftp[bot] <aeroftp[bot]@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

src/components/Sync/SyncAdvancedConfig.tsx

@@ -38,6 +38,10 @@ interface SyncAdvancedConfigProps {
     onSpeedLimitChange: (dl: number, ul: number) => void;
     parallelStreams: number;
     onParallelStreamsChange: (n: number) => void;
+    /** Real backend stream ceiling for the active provider (capability-driven). */
+    streamCap: number;
+    /** True when the active SFTP session has no pooled strategy (single-lease). */
+    sftpPoolUnavailable: boolean;
     compressionMode: CompressionMode;
     onCompressionModeChange: (m: CompressionMode) => void;
     deltaSyncEnabled: boolean;
@@ -116,6 +120,8 @@ export const SyncAdvancedConfig: React.FC<SyncAdvancedConfigProps> = React.memo(
     onSpeedLimitChange,
     parallelStreams,
     onParallelStreamsChange,
+    streamCap,
+    sftpPoolUnavailable,
     compressionMode,
     onCompressionModeChange,
     deltaSyncEnabled,
@@ -281,6 +287,12 @@ export const SyncAdvancedConfig: React.FC<SyncAdvancedConfigProps> = React.memo(
                     </div>
                 </div>
 
+                {sftpPoolUnavailable && options.compare_checksum && (
+                    <div className="mt-2 text-[11px] leading-relaxed text-amber-300/90">
+                        {t('syncPanel.checksumPoolNote')}
+                    </div>
+                )}
+
                 <div className="sync-adv-divider" />
 
                 <div className="sync-compare-options">
@@ -485,19 +497,24 @@ export const SyncAdvancedConfig: React.FC<SyncAdvancedConfigProps> = React.memo(
                         <span className="text-xs text-gray-400">{t('syncPanel.parallelStreams')}:</span>
                         <select
                             className="sync-adv-select"
-                            value={parallelStreams}
+                            value={Math.max(1, Math.min(parallelStreams, streamCap))}
                             onChange={e => onParallelStreamsChange(Number(e.target.value))}
                             disabled={disabled}
                         >
-                            <option value="1">{t('syncPanel.parallelSequential')}</option>
-                            <option value="2">2 {t('syncPanel.parallelStreamLabel')}</option>
-                            <option value="3">3 {t('syncPanel.parallelStreamLabel')}</option>
-                            <option value="4">4 {t('syncPanel.parallelStreamLabel')}</option>
-                            <option value="6">6 {t('syncPanel.parallelStreamLabel')}</option>
-                            <option value="8">8 {t('syncPanel.parallelStreamLabel')}</option>
+                            {/* Only offer stream counts the backend can honor:
+                                a single-lease provider lists Sequential only. */}
+                            {[1, 2, 3, 4, 6, 8]
+                                .filter(v => v <= streamCap)
+                                .map(v => (
+                                    <option key={v} value={v}>
+                                        {v === 1
+                                            ? t('syncPanel.parallelSequential')
+                                            : `${v} ${t('syncPanel.parallelStreamLabel')}`}
+                                    </option>
+                                ))}
                         </select>
                     </label>
-                    {parallelStreams > 1 && (
+                    {parallelStreams > 1 && streamCap > 1 && (
                         <span className="text-[10px] text-yellow-400/70 flex items-center gap-0.5">
                             <Zap size={10} /> {t('syncPanel.parallelTurboLabel')}
                         </span>

src/components/Sync/SyncQuickMode.tsx

@@ -24,6 +24,8 @@ interface SyncQuickModeProps {
     maniacConfirmed: boolean;
     onManiacConfirm: () => void;
     disabled: boolean;
+    /** Real backend stream ceiling for the active provider (capability-driven). */
+    streamCap: number;
 }
 
 // Preset card configuration
@@ -53,6 +55,7 @@ export const SyncQuickMode: React.FC<SyncQuickModeProps> = React.memo(({
     maniacConfirmed,
     onManiacConfirm,
     disabled,
+    streamCap,
 }) => {
     const t = useTranslation();
 
@@ -132,13 +135,20 @@ export const SyncQuickMode: React.FC<SyncQuickModeProps> = React.memo(({
                     {speedModes.map(mode => {
                         const isActive = speedMode === mode;
                         const preset = SPEED_PRESETS[mode];
+                        // Honest tooltip: show the streams the backend will
+                        // actually run for this provider, not the nominal
+                        // preset value (clamped to the real capability).
+                        const effectiveStreams = Math.max(
+                            1,
+                            Math.min(preset.parallelStreams, streamCap),
+                        );
                         return (
                             <button
                                 key={mode}
                                 className={`sync-speed-pill ${mode} ${isActive ? 'active' : ''}`}
                                 onClick={() => handleSpeedChange(mode)}
                                 disabled={disabled}
-                                title={t('syncPanel.speedStreams', { count: preset.parallelStreams })}
+                                title={t('syncPanel.speedStreams', { count: effectiveStreams })}
                             >
                                 {mode === 'maniac' && <Skull size={12} className="mr-1" />}
                                 {t(SPEED_MODE_KEYS[mode])}

src/components/Sync/useTransferCapabilities.ts

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (c) 2024-2026 axpnet: AI-assisted (see AI-TRANSPARENCY.md)
+
+/**
+ * Hook for fetching per-provider transfer capabilities.
+ *
+ * Backed by the `get_transfer_capabilities` Tauri command (single source of
+ * truth: TransferCapabilities::from_provider_hints). The GUI consumes this so
+ * speed presets and parallel-stream controls reflect what the backend can
+ * actually honor instead of advertising parallelism it will never apply.
+ */
+
+import { useState, useEffect } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { TransferCapabilities, Capability, ProviderType } from "../../types";
+
+/** Mirrors Rust Capability::is_available. */
+export function isCapabilityAvailable(c?: Capability | null): boolean {
+  return (
+    c === "supported" || c === "supported_after_probe" || c === "experimental"
+  );
+}
+
+export function useTransferCapabilities(
+  protocol?: ProviderType,
+  refreshKey?: unknown,
+): {
+  caps: TransferCapabilities | null;
+  loading: boolean;
+} {
+  const [caps, setCaps] = useState<TransferCapabilities | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!protocol) {
+      setCaps(null);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+
+    invoke<TransferCapabilities>("get_transfer_capabilities", {
+      providerType: protocol,
+    })
+      .then((c) => {
+        if (!cancelled) setCaps(c);
+      })
+      .catch(() => {
+        if (!cancelled) setCaps(null);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [protocol, refreshKey]);
+
+  return { caps, loading };
+}

src/components/SyncPanel.tsx

@@ -1,7 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (c) 2024-2026 axpnet: AI-assisted (see AI-TRANSPARENCY.md)
 
-import React, { useState, useEffect, useRef, useCallback } from "react";
+import React, {
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  useMemo,
+} from "react";
 import { invoke } from "@tauri-apps/api/core";
 import { save } from "@tauri-apps/plugin-dialog";
 import { writeTextFile } from "@tauri-apps/plugin-fs";
@@ -88,6 +94,10 @@ import { SyncQuickMode } from "./Sync/SyncQuickMode";
 import { SyncAdvancedConfig } from "./Sync/SyncAdvancedConfig";
 import { useSyncProfiles } from "./Sync/useSyncProfiles";
 import { useSyncOptimization } from "./Sync/useSyncOptimization";
+import {
+  useTransferCapabilities,
+  isCapabilityAvailable,
+} from "./Sync/useTransferCapabilities";
 import {
   SpeedMode,
   SPEED_PRESETS,
@@ -323,8 +333,13 @@ export const SyncPanel: React.FC<SyncPanelProps> = ({
 
   // Phase 3A+: Parallel streams (1 = sequential/legacy, 2-8 = turbo)
   const [parallelStreams, setParallelStreamsRaw] = useState(1);
+  // Upper bound for parallel streams: the real backend capability for the
+  // active provider (FTP/FTPS pool = 8, multipart providers = chunk slots,
+  // everything else = single-stream). Defaults to 8 until caps resolve so the
+  // pre-connect config UX is not artificially constrained.
+  const capStreamsRef = useRef(8);
   const setParallelStreams = (n: number) =>
-    setParallelStreamsRaw(Math.max(1, Math.min(8, n)));
+    setParallelStreamsRaw(Math.max(1, Math.min(capStreamsRef.current, n)));
   const [compressionMode, setCompressionMode] =
     useState<CompressionMode>("off");
   const [deltaSyncEnabled, setDeltaSyncEnabled] = useState(false);
@@ -342,6 +357,29 @@ export const SyncPanel: React.FC<SyncPanelProps> = ({
     protocol,
     isConnected,
   );
+
+  // Real per-provider transfer capabilities (single source of truth on the
+  // Rust side). The speed presets and the parallel-streams selector are
+  // clamped to what the backend can actually honor: advertising 8 streams on
+  // a single-lease provider is a silent no-op, not an optimization.
+  const { caps: transferCaps } = useTransferCapabilities(protocol, isConnected);
+  const capabilityMaxStreams = useMemo(() => {
+    if (!transferCaps) return 8;
+    return Math.max(
+      1,
+      transferCaps.max_file_slots ?? 1,
+      transferCaps.max_chunk_slots ?? 1,
+    );
+  }, [transferCaps]);
+  const sftpPoolUnavailable =
+    protocol === "sftp" &&
+    !!transferCaps &&
+    !isCapabilityAvailable(transferCaps.session_pool);
+  useEffect(() => {
+    capStreamsRef.current = capabilityMaxStreams;
+    setParallelStreamsRaw((p) => Math.max(1, Math.min(p, capabilityMaxStreams)));
+  }, [capabilityMaxStreams]);
+
   const deltaEligibilityResolverRef = useRef<
     ((proceed: boolean) => void) | null
   >(null);
@@ -3040,6 +3078,7 @@ export const SyncPanel: React.FC<SyncPanelProps> = ({
                 onSpeedModeChange={handleSpeedModeChange}
                 showManiac={isCyberTheme()}
                 maniacConfirmed={maniacConfirmed}
+                streamCap={capabilityMaxStreams}
                 onManiacConfirm={() => {
                   setManiacConfirmed(true);
                   // Apply maniac overrides ONLY after user confirmation
@@ -3077,6 +3116,8 @@ export const SyncPanel: React.FC<SyncPanelProps> = ({
                 onSpeedLimitChange={handleSpeedLimitChange}
                 parallelStreams={parallelStreams}
                 onParallelStreamsChange={setParallelStreams}
+                streamCap={capabilityMaxStreams}
+                sftpPoolUnavailable={sftpPoolUnavailable}
                 compressionMode={compressionMode}
                 onCompressionModeChange={setCompressionMode}
                 deltaSyncEnabled={deltaSyncEnabled}

src/i18n/locales/bg.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "PowerShell скрипт (.ps1)",
             "templateScriptExportedToast": "Скриптът е експортиран",
             "templateScriptImportedToast": "Метаданните на скрипта са заредени",
-            "templateScriptInvalidToast": "Скриптът не съдържа метаданни на AeroFTP"
+            "templateScriptInvalidToast": "Скриптът не съдържа метаданни на AeroFTP",
+            "checksumPoolNote": "Сравнението на checksum в тази SFTP сесия използва една връзка (без пул от сесии): очаквайте по-бавно сканиране на големи дървета."
         },
         "ui": {
             "syncing": "Синхронизиране...",

src/i18n/locales/bn.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "PowerShell স্ক্রিপ্ট (.ps1)",
             "templateScriptExportedToast": "স্ক্রিপ্ট রপ্তানি করা হয়েছে",
             "templateScriptImportedToast": "স্ক্রিপ্ট মেটাডেটা লোড করা হয়েছে",
-            "templateScriptInvalidToast": "স্ক্রিপ্টে AeroFTP মেটাডেটা নেই"
+            "templateScriptInvalidToast": "স্ক্রিপ্টে AeroFTP মেটাডেটা নেই",
+            "checksumPoolNote": "এই SFTP সেশনে checksum তুলনা একটি একক সংযোগ ব্যবহার করে (কোনো সেশন pool নেই): বড় ট্রিতে ধীর স্ক্যানের আশা করুন।"
         },
         "ui": {
             "syncing": "সিঙ্ক হচ্ছে...",

src/i18n/locales/ca.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "Script PowerShell (.ps1)",
             "templateScriptExportedToast": "Script exportat",
             "templateScriptImportedToast": "Metadades del script carregades",
-            "templateScriptInvalidToast": "L'script no conté metadades d'AeroFTP"
+            "templateScriptInvalidToast": "L'script no conté metadades d'AeroFTP",
+            "checksumPoolNote": "La comparació de checksum en aquesta sessió SFTP utilitza una sola connexió (sense pool de sessions): espereu escaneigs més lents en arbres grans."
         },
         "ui": {
             "syncing": "Sincronitzant...",

src/i18n/locales/cs.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "Skript PowerShell (.ps1)",
             "templateScriptExportedToast": "Skript exportován",
             "templateScriptImportedToast": "Metadata skriptu načtena",
-            "templateScriptInvalidToast": "Skript neobsahuje metadata AeroFTP"
+            "templateScriptInvalidToast": "Skript neobsahuje metadata AeroFTP",
+            "checksumPoolNote": "Porovnání kontrolního součtu v této relaci SFTP používá jediné připojení (bez poolu relací): u velkých stromů očekávejte pomalejší skenování."
         },
         "ui": {
             "syncing": "Synchronizace...",

src/i18n/locales/cy.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "Sgript PowerShell (.ps1)",
             "templateScriptExportedToast": "Sgript wedi ei allforio",
             "templateScriptImportedToast": "Metadata sgript wedi ei lwytho",
-            "templateScriptInvalidToast": "Nid yw'r sgript yn cynnwys metadata AeroFTP"
+            "templateScriptInvalidToast": "Nid yw'r sgript yn cynnwys metadata AeroFTP",
+            "checksumPoolNote": "Mae cymharu checksum yn y sesiwn SFTP hwn yn defnyddio un cysylltiad (dim pwll sesiynau): disgwyliwch sganiau arafach ar goed mawr."
         },
         "ui": {
             "syncing": "Yn cysoni...",

src/i18n/locales/da.json

@@ -2163,7 +2163,8 @@
             "templateFormatPwsh": "PowerShell-script (.ps1)",
             "templateScriptExportedToast": "Script eksporteret",
             "templateScriptImportedToast": "Scriptmetadata indlæst",
-            "templateScriptInvalidToast": "Scriptet indeholder ikke AeroFTP-metadata"
+            "templateScriptInvalidToast": "Scriptet indeholder ikke AeroFTP-metadata",
+            "checksumPoolNote": "Checksum-sammenligning i denne SFTP-session bruger en enkelt forbindelse (ingen sessionspulje): forvent langsommere scanninger på store træer."
         },
         "ui": {
             "syncing": "Synkroniserer...",