dsh-config-manager 0.1.78 → 0.1.80

package/src/client/sync/SyncPanel.tsx

@@ -56,13 +56,15 @@ import { copyTextToClipboard } from '../common/clipboard.ts'
 import { sectionLabeler } from '../common/section-labels.ts'
 import { runStore, toSyncStoreSlice, type SyncConfirmDecisions, type SyncStoreSlice } from '../run-store.ts'
 import type {
-  AutosyncInterval, SyncApi, SyncPushPayload, SyncStartResponse, SyncStatusResponse,
+  AutosyncAutoApplyTier, AutosyncConflictPolicy, AutosyncInterval, MergePreviewResponse, SyncApi,
+  SyncPushPayload, SyncStartResponse, SyncStatusResponse,
 } from './sync-api.ts'
+import { resolveSmartSync } from './sync-entry.ts'
 import {
   channelMapOf, channelStateMap, computeGithubLoginView, computeSyncButtons, defaultChannelSyncState,
-  githubPollMessage, isClientChannel, kindLabel, pullReportView, pushReportView, readStoredChannel,
+  githubPollMessage, isClientChannel, pushReportView, readStoredChannel,
   gistSessionsRiskKey,
-  initialSyncSections, normalizeSessionsLimit, severityLabel, syncSectionOptions, writeStoredChannel,
+  initialSyncSections, normalizeSessionsLimit, syncSectionOptions, writeStoredChannel,
 } from './sync-view.ts'
 import type {
   ChannelSyncState, GithubLoginPhase, SyncChannel, SyncSectionOption,
@@ -91,7 +93,11 @@ import { WorkDirCard } from './WorkDirCard.tsx'
 import { Collapse } from '../common/Motion.tsx'
 import { SyncLogList } from './SyncLogList.tsx'
 import { UnreadableSnapshotsBanner } from './UnreadableSnapshotsBanner.tsx'
+import { SyncProbeRow } from './SyncProbeRow.tsx'
+import { deviceLabel } from './remote-device-view.ts'
 import { PushPreviewCard } from './PushPreviewCard.tsx'
+import { MergeModal } from './MergeModal.tsx'
+import { SyncActivityBar } from './SyncActivityBar.tsx'
 import { SyncConfirmView } from './SyncConfirmView.tsx'
 import css from '../config-manager.module.css'
 
@@ -171,9 +177,14 @@ interface SyncUiState {
   savingConfig: boolean
   busy: 'sync' | 'push' | 'pull' | 'rollback' | null
   pushReport: SyncPushReport | null
-  pullReport: SyncPullReport | null
   /** P0-②：push 前只读预览弹窗（preview 结果 + 打开状态；非敏感，切 tab/刷新不丢） */
   pushPreview: PushPreviewSlice
+  /**
+   * 拉取报告（**仅作 run-store 切片的镜像字段**保留）：拉取的 UI 路径已整体移除
+   * （按钮 / runPull / pullView / 报告弹窗 / pullReportView import 全部删除），
+   * 此字段只为满足 SyncStoreSlice 的结构契约；彻底删除需同步改 run-store.ts（已报 lead）。
+   */
+  pullReport: SyncPullReport | null
   /** 一键同步差异确认会话（POST /sync/sync 结果；非空时渲染 SyncConfirmView） */
   confirmSession: SyncStartResponse | null
   /** 一键同步差异确认的逐项决策（adopted/resolution；与 confirmSession 生命周期绑定，切 tab/刷新不丢） */
@@ -288,8 +299,7 @@ function initFromStore(): SyncUiState {
     busy: s.busy,
     savingConfig: s.savingConfig,
     pushReport: s.pushReport,
-    pullReport: s.pullReport,
-    pushPreview: s.pushPreview ?? { preview: null, open: false },
+      pushPreview: s.pushPreview ?? { preview: null, open: false },
     confirmSession: s.confirmSession,
     confirmDecisions: s.confirmDecisions,
     lastRestoreId: s.lastRestoreId,
@@ -311,6 +321,13 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
   const [channelOpen, setChannelOpen] = useState(false)
   /** 待确认断开的通道（null = 未打开确认弹窗）——用户要求：配置过的通道必须能删掉 */
   const [clearTarget, setClearTarget] = useState<SyncChannel | null>(null)
+  /**
+   * 方案 A：一键同步自动分派命中合并路径时的**受控展开种子**。
+   * preview = 那一次只读请求的结果（视图不再二次拉远端快照）；signal 变化 = 重建视图（旧裁决作废）。
+   */
+  const [mergeSeed, setMergeSeed] = useState<{ channel: SyncChannel; preview: MergePreviewResponse } | null>(null)
+  /** 一键同步阶段（null = 空闲）：'preview' 拉远端快照预览、'sync' 差异确认/导入；只驱动文案 */
+  const [syncPhase, setSyncPhase] = useState<'preview' | 'sync' | null>(null)
   /** 同步分区选择弹窗开关（瞬态 UI：模式与勾选在弹窗内即时生效并持久化，关闭即完成） */
   const [sectionPickerOpen, setSectionPickerOpen] = useState(false)
   /**
@@ -501,9 +518,11 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
       const all = await api.autosyncStatusAll()
       patchChannelState('git', {
         autosync: all.git, autosyncEnabled: all.git.enabled, autosyncInterval: all.git.interval,
+        autosyncRealtime: all.git.realtime ?? true,
       })
       patchChannelState('webdav', {
         autosync: all.webdav, autosyncEnabled: all.webdav.enabled, autosyncInterval: all.webdav.interval,
+        autosyncRealtime: all.webdav.realtime ?? true,
       })
     } catch (err) {
       // R-20：读取自动同步状态失败（此前写入页面最底部的共享 error Banner，常滚出视野）
@@ -864,7 +883,7 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
 
   /** P0-②：push 前只读预览（弹窗确认流程第一步）——不写远端，只展示「将推送什么」。 */
   const runPushPreview = async (): Promise<void> => {
-    patch({ busy: 'push', pushReport: null, pullReport: null })
+    patch({ busy: 'push', pushReport: null })
     try {
       // 预览前先把加密密码落库（用户不必手动保存；失败只提示，不阻断预览）
       await persistEncryptPassword()
@@ -879,7 +898,7 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
 
   /** P0-②：确认弹窗里点「确认推送」→ 真正推送（复用既有 push 语义）。 */
   const runPush = async (): Promise<void> => {
-    patch({ busy: 'push', pushReport: null, pullReport: null })
+    patch({ busy: 'push', pushReport: null })
     try {
       // 推送前先把加密密码落库（下次推送不必重输）
       await persistEncryptPassword()
@@ -907,26 +926,6 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
     }
   }
 
-  const runPull = async (): Promise<void> => {
-    patch({ busy: 'pull', pullReport: null, pushReport: null })
-    try {
-      // 解密密码（可选）：先落库再拉取，下次不必重输。留空时由 Host 用本机凭据库里
-      // 已保存的密码 —— 且只在远端快照确实加密时才会被使用（engine.prepareSnapshot 判定）。
-      await persistDecryptPassword()
-      const decrypt =
-        chState.decryptPassword !== '' ? { decryptPassword: chState.decryptPassword } : {}
-      const report = await api.pull({ ...payload(), ...decrypt })
-      patch({ busy: null, pullReport: report, token: '', webdavPassword: '' })
-      patchChannel({ decryptPassword: '' })
-      // 必须按 report.ok 分流（与 runPush 同口径）：校验不通过时宿主仍回 HTTP 200 + ok:false
-      if (report.ok) toast.ok(t('toast.pullDone'))
-      else toast.error(t('toast.pullFailed'))
-    } catch (err) {
-      patch({ busy: null })
-      toast.error(t('toast.pullFailed') + t('common.labelSeparator') + redact(err instanceof Error ? err.message : String(err)))
-    }
-  }
-
   /* ------------------------------------------------ 同步模式（默认/自定义） */
 
   /**
@@ -1051,6 +1050,47 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
     }
   }
 
+  /**
+   * 方案 A 的入口分派：有基线先做**一次**只读合并预览 —— 有变更直接开裁决视图（复用该次结果）；
+   * 全部 skip 提示「已是最新」；无基准 / 请求失败 / ok=false 一律回退老导入确认路径（fail-safe）。
+   */
+  const runSyncSmart = async (channel: SyncChannel): Promise<void> => {
+    // 视觉反馈从**点击那一刻**开始：预览要拉远端快照（整条链最慢的一步），
+    // 此前只有回退分支 runSync() 才设 busy ⇒ 点击后数秒界面毫无动静（用户以为没响应）。
+    // 这里全程占用 busy（顺带挡住并发的 push/切换），并用 syncPhase 区分阶段文案。
+    patch({ busy: 'sync' })
+    setSyncPhase('preview')
+    try {
+      await dispatchSmartSync(channel)
+    } finally {
+      setSyncPhase(null)
+      patch({ busy: null })
+    }
+  }
+
+  /** 一键同步的实际分派（busy/阶段标志由 runSyncSmart 统一持有）。 */
+  const dispatchSmartSync = async (channel: SyncChannel): Promise<void> => {
+    switchChannel(channel)
+    // 与 runSync() 同处置：先清在途的差异确认会话（否则它持有的临时 ZIP 一直留在宿主 syncSessions 里，
+    // 走合并路径时更是没有出口；清掉后 fallback 分支的 runSync() 不会重复 cancel）。
+    const staleConfirm = stateRef.current.confirmSession
+    if (staleConfirm !== null) { try { await api.cancel(staleConfirm.syncSessionId) } catch { /* 尽力清理 */ } patch({ confirmSession: null, confirmDecisions: null }) }
+    const smart = await resolveSmartSync({
+      api,
+      hasBaseline: stateRef.current.statusInfo?.hasBaseline,
+      channelPayload: () => buildSyncChannelBody({ ...formOf(stateRef.current), channel }),
+      decryptPassword: stateRef.current.byChannel[channel].decryptPassword,
+    })
+    if (smart.kind === 'merge') {
+      setMergeSeed({ channel, preview: smart.preview })
+      return
+    }
+    if (smart.kind === 'upToDate') { toast.ok(t('syncflow.upToDate')); return }
+    if (smart.error !== undefined) toast.error(t('merge.toast.previewFailed') + t('common.labelSeparator') + redact(smart.error))
+    setSyncPhase('sync')
+    await runSync()
+  }
+
   /** 用户取消差异确认：清除会话，复位到空闲。 */
   const cancelConfirm = (): void => {
     patch({ confirmSession: null, confirmDecisions: null })
@@ -1099,6 +1139,35 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
     }
   }
 
+  /**
+   * 更新「真·自动同步」的三个策略项（realtime / autoApplyTier / conflictPolicy）。
+   * 只传要改的字段，其余沿用当前通道状态（显式传 enabled+interval，宿主按 read-modify-write 落盘）。
+   */
+  const updateAutosyncOptions = async (
+    channel: SyncChannel,
+    patch: { realtime?: boolean; autoApplyTier?: AutosyncAutoApplyTier; conflictPolicy?: AutosyncConflictPolicy },
+  ): Promise<void> => {
+    const cs = channelStateOf(channel)
+    if (patch.realtime !== undefined) patchChannelOf(channel, { autosyncRealtime: patch.realtime })
+    try {
+      const updated = await api.autosyncUpdate({
+        transport: channel,
+        enabled: cs.autosyncEnabled,
+        interval: cs.autosyncInterval,
+        ...patch,
+      })
+      patchChannelOf(channel, {
+        autosync: updated,
+        autosyncEnabled: updated.enabled,
+        autosyncInterval: updated.interval,
+        autosyncRealtime: updated.realtime ?? true,
+      })
+      toast.ok(t('toast.autosyncUpdated'))
+    } catch (err) {
+      toast.error(t('toast.autosyncUpdateFailed') + t('common.labelSeparator') + redact(err instanceof Error ? err.message : String(err)))
+    }
+  }
+
   /** 远端是否就绪（四通道统一判据在 ui 层：git/webdav=地址非空，s3/gist=表单校验通过）。 */
   const remoteReadyOf = (channel: SyncChannel): boolean => channelRemoteReady({ ...formOf(state), channel })
   /** 云端点表单的校验问题（对话框内联提示用；git/webdav 恒为空表）。 */
@@ -1106,7 +1175,6 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
   /** 激活通道的远端就绪态（弹窗 / 页面级判断用） */
   const remoteReady = remoteReadyOf(state.channel)
   const pushView = pushReportView(state.pushReport, uiT)
-  const pullView = pullReportView(state.pullReport, uiT)
   const githubView = computeGithubLoginView(
     state.github.phase, state.github.userCode, state.github.verificationUri, state.github.error, uiT,
   )
@@ -1191,22 +1259,30 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
         )}
         {ready && (
           <Card>
-            {/* 动作行：**一键同步**是这一行唯一的主操作（§8 定案）。 */}
+            {/* 动作行（方案 A 定案）：用户只面对两个方向 —— 下行「一键同步」/ 上行「推送到远端」。
+                合并裁决并入一键同步（有基线走三方裁决视图、无基线走老导入确认），不再单独占按钮。 */}
             <div className={css.actionRow}>
               <Button
                 variant="primary"
                 disabled={busy}
-                onClick={() => { switchChannel(channel); void runSync() }}
+                loading={state.busy === 'sync'}
+                onClick={() => { void runSyncSmart(channel) }}
               >
-                {state.busy === 'sync' ? <Spinner label={t('syncflow.syncing')} /> : t('syncflow.button')}
+                {state.busy === 'sync'
+                  ? (syncPhase === 'preview' ? t('syncflow.checkingRemote') : t('syncflow.syncing'))
+                  : t('syncflow.button')}
               </Button>
               <Button disabled={!computeSyncButtons(state.busy, ready, uiT).canPush || githubBusy || !hasSelectedSections(cs) || computeEncryptInvalid(cs)} onClick={() => { switchChannel(channel); void runPushPreview() }}>
                 {computeSyncButtons(state.busy, ready, uiT).pushLabel}
               </Button>
-              <Button disabled={!computeSyncButtons(state.busy, ready, uiT).canPull || githubBusy} onClick={() => { switchChannel(channel); void runPull() }}>
-                {computeSyncButtons(state.busy, ready, uiT).pullLabel}
-              </Button>
+              {/* 测试连接（只读自检）：与两个主操作同一行、排在最后；结果走 toast（不再占页面高度） */}
+              <SyncProbeRow
+                t={t} api={api} presentation="action" remoteReady={ready} busy={busy}
+                body={buildSyncChannelBody({ ...formOf(state), channel })}
+              />
             </div>
+            {/* 同步在途的活动条：按钮 Spinner 只在按钮上，这条横条让「正在拉远端快照」在整张卡上可见 */}
+            {syncPhase !== null && <SyncActivityBar phase={syncPhase} t={t} />}
             {/* 选择历史快照（该通道的远端快照；缺省 = 最新）。
                 支持点击/展开即刷新，另有主动刷新按钮 —— 两个入口都保留（v1 行为不变）。 */}
             <div className={css.snapshotPickerRow}>
@@ -1226,7 +1302,10 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
                     { value: '', label: t('syncflow.latestSnapshot') },
                     ...cs.snapshots.map((s) => ({
                       value: s.id,
-                      label: s.id + t('syncflow.snapshotOption', { date: s.createdAt.slice(0, 10), count: String(s.sectionCount) }),
+                      label: s.id
+                        + t('syncflow.snapshotOption', { date: s.createdAt.slice(0, 10), count: String(s.sectionCount) })
+                        // ⑥ 设备身份：只有快照确实带 deviceName 时才追加（旧快照不显示占位空串）
+                        + (deviceLabel(s, (device) => t('syncflow.snapshotDevice', { device })) ?? ''),
                     })),
                   ]}
                 />
@@ -1257,6 +1336,7 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
               busy={busy}
               onToggleAutosync={(enabled) => { void toggleAutosync(channel, enabled) }}
               onUpdateInterval={(interval) => { void updateAutosyncInterval(channel, interval) }}
+              onUpdateOptions={(patch) => { void updateAutosyncOptions(channel, patch) }}
             />
           </Card>
         )}
@@ -1457,57 +1537,20 @@ export function SyncPanel({ api, t, cmT }: SyncPanelProps) {
             </Modal.Footer>
           </Modal>
 
-          {/* 拉取差异预览弹窗（Radix Modal） */}
-          <Modal
-            open={state.pullReport !== null && pullView !== null}
-            onClose={() => { patch({ pullReport: null }) }}
-            title={t('pull.title')}
-            cardStyle={{ width: 'min(720px, 100%)', maxHeight: '85vh' }}
-          >
-            <Modal.Header
-              title={t('pull.title')}
-              closeLabel={t('common.close')}
-              onClose={() => { patch({ pullReport: null }) }}
-            />
-            <Modal.Body scroll style={{ maxHeight: '70vh' }}>
-              {pullView !== null && (<>
-                <Banner kind={pullView.kind === 'ok' ? 'info' : pullView.kind === 'empty' ? 'ok' : 'error'}>
-                  {pullView.headline}
-                </Banner>
-                {pullView.summary !== null && (
-                  <>
-                    <div className={css.statRow}>
-                      <Badge kind="info">{t('change.total', { total: pullView.summary.total })}</Badge>
-                      {pullView.summary.error > 0 && <Badge kind="error">{severityLabel('error', uiT)} × {pullView.summary.error}</Badge>}
-                      {pullView.summary.warning > 0 && <Badge kind="warn">{severityLabel('warning', uiT)} × {pullView.summary.warning}</Badge>}
-                      {pullView.summary.info > 0 && <Badge kind="info">{severityLabel('info', uiT)} × {pullView.summary.info}</Badge>}
-                    </div>
-                    {pullView.summary.needsReview && <Banner kind="warn">{t('pull.needsReview')}</Banner>}
-                    <div className={css.pullScroll}>
-                      <div className={css.reportList}>
-                        {pullView.summary.items.map((c) => (
-                          <div key={c.id} className={css.statRow}>
-                            <span className={css.kindTag}>{kindLabel(c.kind, uiT)}</span>
-                            <Badge kind={c.severity === 'error' ? 'error' : c.severity === 'warning' ? 'warn' : 'info'}>
-                              {severityLabel(c.severity, uiT)}
-                            </Badge>
-                            <span>{c.description}</span>
-                          </div>
-                        ))}
-                      </div>
-                    </div>
-                  </>
-                )}
-                {pullView.previewHint !== '' && <Banner kind="info">{pullView.previewHint}</Banner>}
-              </>)}
-            </Modal.Body>
-            <Modal.Footer>
-              <Button variant="primary" onClick={() => { patch({ pullReport: null }) }}>
-                {t('common.close')}
-              </Button>
-            </Modal.Footer>
-          </Modal>
-
+          {/* 方案 A：一键同步命中合并路径 → **弹窗内**裁决（页面不再内联）。
+              预览来自那一次 /sync/merge-preview（initialPreview，不二次请求）；
+              内容：.mergeScroll 限高内滚 + Modal.Body scroll —— 564×720 画布下不撑出宿主面板滚动条。 */}
+          <MergeModal
+            seed={mergeSeed}
+            onClose={() => { setMergeSeed(null) }}
+            api={api} t={t}
+            busy={state.busy !== null}
+            channelBody={(channel) => buildSyncChannelBody({ ...formOf(stateRef.current), channel })}
+            sectionName={(id) => sectionName(id as SectionId)}
+            decryptPasswordOf={(channel) => stateRef.current.byChannel[channel].decryptPassword}
+            onApplied={() => { void loadStatus() }}
+            onRolledBack={() => { void loadStatus() }}
+          />
           {/* 一键同步差异确认弹窗（Radix Modal；SyncConfirmView 内含取消/确认按钮） */}
           <Modal
             open={state.confirmSession !== null}

package/src/client/sync/SyncProbeRow.tsx

@@ -0,0 +1,162 @@
+/**
+ * cloud-sync 借鉴项 ②：**测试连接**行（只读连通性自检）。
+ *
+ * 为什么要它：同步失败时用户此前只能靠「push/pull 报错」反推通道是否可达 —— 端点写错、
+ * 桶不存在、凭据没配、目标目录不存在，症状都是同一句失败。这里给一个**非破坏性**自检入口，
+ * 并把通道层本地化好的结论直接展示（S3 兼容端点该填哪个 region 这类信息只有通道层知道）。
+ *
+ * 三条纪律：
+ *  1. **失败是正常结论**（HTTP 200 + ok:false）→ 绝不落进 catch 当成崩溃；
+ *  2. 自检**可能写远端**（webdav 幂等 MKCOL 补齐上级目录）→ createdCollections 必须逐条说明，
+ *     绝不静默（「测试连接」把远端目录建出来是用户有权知道的事实）；
+ *  3. hint 是「需要注意但没失败」的信息 → 与主结论分开展示（card 形态用 warn 横幅；
+ *     action 形态追加在同一句 toast 里），不和成功文案混成一句。
+ *
+ * 两种展示形态（presentation）：
+ *  - 'card'（缺省）：动作行 + **内联结果**（Banner / ErrorBanner）—— 独立入口用；
+ *  - 'action'：**只渲染按钮 + ⓘ**（供并入别的动作行），结果改走 toast：主结论 + hint +
+ *    自动创建的目录 + 快照数一句讲完，一条都不省。
+ *
+ * 文案全部走 config-manager-sync 字典；本组件不写任何样式（复用既有原语与卡片内类名）。
+ */
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { ReactNode } from 'react'
+import type { TranslateNS } from '../client-types.ts'
+import type { SyncApi, SyncProbeResult, SyncPushPayload } from './sync-api.ts'
+import { Banner, Button, Spinner } from '../common/ui.tsx'
+import { InfoHint } from '../common/InfoHint.tsx'
+import { projectProbeResult } from './probe-view.ts'
+import { toast } from '../common/toast-store.ts'
+import { ErrorBanner } from '../common/ErrorBanner.tsx'
+import { redact } from '../../security/redaction.ts'
+import css from '../config-manager.module.css'
+
+export interface SyncProbeRowProps {
+  api: SyncApi
+  t: TranslateNS<'config-manager-sync'>
+  /** 与 push/pull 同一份通道请求体（由 SyncPanel 组装） */
+  body: SyncPushPayload
+  /** 该通道远端地址是否就绪（未就绪时按钮禁用） */
+  remoteReady: boolean
+  /** 页面忙（同步/推送在途）时不发请求 */
+  busy: boolean
+  /**
+   * 展示形态（缺省 'card' = 既有行为，向后兼容）：
+   *  - 'card'：动作行 + 内联结果横幅；
+   *  - 'action'：只渲染按钮 + ⓘ（嵌进别的动作行），结果走 toast。
+   */
+  presentation?: 'card' | 'action'
+}
+
+export function SyncProbeRow({ api, t, body, remoteReady, busy, presentation = 'card' }: SyncProbeRowProps): ReactNode {
+  const actionMode = presentation === 'action'
+  const [result, setResult] = useState<SyncProbeResult | null>(null)
+  const [loading, setLoading] = useState(false)
+  const /** 传输层异常（与「自检结论 = 失败」分开：前者是宿主/网络没走通，后者是通道层给出的结论） */
+    [error, setError] = useState<string | null>(null)
+  const seqRef = useRef(0)
+  const mountedRef = useRef(true)
+  useEffect(() => () => { mountedRef.current = false }, [])
+
+  /**
+   * action 形态的结果通道：**一句 toast 讲完**（主结论 + hint + 自动创建的目录 + 快照数）。
+   * createdCollections 绝不省 —— 这是本动作唯一可能写远端的路径，用户有权知道。
+   * 中性态（该通道不提供自检）走 ok 通道 + 同一句里的能力边界说明，绝不渲染成「操作失败」。
+   */
+  const toastResult = useCallback((res: SyncProbeResult): void => {
+    const v = projectProbeResult(res, t('probe.unsupported'))
+    const parts = [redact(v.message)]
+    if (v.hint !== undefined) parts.push(redact(v.hint))
+    if (v.unsupported) parts.push(t('probe.unsupportedHint'))
+    if (v.createdCollections.length > 0) {
+      parts.push(t('probe.createdCollections', { list: v.createdCollections.map((c) => redact(c)).join(t('common.listSeparator')) }))
+    }
+    if (v.snapshotCount !== undefined) parts.push(t('probe.snapshotCount', { count: String(v.snapshotCount) }))
+    const text = parts.join(t('common.labelSeparator'))
+    if (v.tone === 'error') toast.error(text)
+    else toast.ok(text)
+  }, [t])
+
+  const run = useCallback(async (): Promise<void> => {
+    if (!remoteReady) return
+    const seq = ++seqRef.current
+    setLoading(true)
+    try {
+      const res = await api.probe(body)
+      if (!mountedRef.current || seq !== seqRef.current) return
+      setResult(res)
+      setError(null)
+      if (actionMode) toastResult(res)
+    } catch (err) {
+      if (!mountedRef.current || seq !== seqRef.current) return
+      const message = err instanceof Error ? err.message : String(err)
+      setError(message)
+      if (actionMode) toast.error(redact(message))
+    } finally {
+      if (mountedRef.current && seq === seqRef.current) setLoading(false)
+    }
+  }, [api, body, remoteReady, actionMode, toastResult])
+
+  /**
+   * 渲染规则全在纯函数里（可单测）：成功 / hint / 自动创建的目录 / 不支持自检 / 真失败**五态分开**。
+   * 兜底文案只在这里解析（纯模块不碰字典）：宿主没给 error 时用字典键的本地化文案。
+   */
+  const view = result === null ? null : projectProbeResult(result, t('probe.unsupported'))
+
+  const button = (
+    <Button onClick={() => { void run() }} disabled={busy || loading || !remoteReady}>
+      {loading ? <Spinner label={t('probe.running')} /> : t('probe.run')}
+    </Button>
+  )
+  const hintNode = <InfoHint text={t('probe.hint')} label={t('common.infoHint')} />
+
+  return (
+    <>
+      {/* action 形态：直接摊进调用方自己的动作行（不再套一层 .actionRow），结果走 toast */}
+      {actionMode
+        ? <>{button}{hintNode}</>
+        : <div className={css.actionRow}>{button}{hintNode}</div>}
+      {!actionMode && error !== null && (
+        <ErrorBanner
+          error={redact(error)}
+          onRetry={() => { void run() }}
+          retrying={loading}
+          t={api.t}
+        />
+      )}
+      {/* 能力边界**不是**故障：中性 info 横幅 + 一句解释，绝不显示「操作失败」 */}
+      {!actionMode && view !== null && view.tone === 'info' && (
+        <>
+          <Banner kind="info">{redact(view.message)}</Banner>
+          <div className={css.hint}>{t('probe.unsupportedHint')}</div>
+        </>
+      )}
+      {!actionMode && view !== null && (view.tone === 'ok' || view.tone === 'warn') && (
+        <>
+          <Banner kind="ok">{redact(view.message)}</Banner>
+          {view.hint !== undefined && <Banner kind="warn">{redact(view.hint)}</Banner>}
+          {/* 自检期间自动创建了远端目录：逐条列出（这是唯一可能有写副作用的路径，绝不静默） */}
+          {view.createdCollections.length > 0 && (
+            <div className={css.hint}>
+              {t('probe.createdCollections', {
+                list: view.createdCollections.map((c) => redact(c)).join(t('common.listSeparator')),
+              })}
+            </div>
+          )}
+          {view.snapshotCount !== undefined && (
+            <div className={css.hint}>{t('probe.snapshotCount', { count: String(view.snapshotCount) })}</div>
+          )}
+        </>
+      )}
+      {/* 失败 = 诊断结论：ok:false 是**预期结果**，必须当结论展示（绝不是崩溃/未知错误） */}
+      {!actionMode && view !== null && view.tone === 'error' && (
+        <ErrorBanner
+          error={redact(view.message)}
+          onRetry={() => { void run() }}
+          retrying={loading}
+          t={api.t}
+        />
+      )}
+    </>
+  )
+}

package/src/client/sync/SyncSettingsView.test.ts

@@ -65,6 +65,8 @@ test('t42: 组件按职责物理拆分成独立文件（各自导出 + 主文件
     // issue #91：推送预览卡（五条并列提示带：只读 / 首次基线 / 加密 / 含凭据 / 引擎告警）自成文件，
     // 主文件只装配 —— 同样以「抽出去」而不是「抬上限」满足棘轮
     ['PushPreviewCard', 'PushPreviewCard.tsx'],
+    // 一键同步的加载反馈：在途活动条是纯展示（无状态无调用），同样以「抽出去」守住棘轮
+    ['SyncActivityBar', 'SyncActivityBar.tsx'],
   ]
   for (const [name, file] of units) {
     // 主文件：必须 import 并渲染该单元
@@ -100,7 +102,30 @@ test('t42: 组件按职责物理拆分成独立文件（各自导出 + 主文件
   // 1580 → 1585（t3：英文界面零中文）。增量是**装配接线**：分区选择弹窗新增 uiT 注入
   //   （分区描述 / 分组说明改为字典键后，弹窗内需要 ui 字典翻译器才能解析；判定逻辑在 ui 层）。
   //   同一轮把 11 处 toast 的「全角冒号 + 详情」拼接改为 t('common.labelSeparator')，行数不变。
-  assert.ok(viewLines <= 1585, '主文件行数必须保持在拆分后的量级（实际 ' + viewLines + ' 行）')
+  // 1585 → 1595（cloud-sync 借鉴项 ②⑥ + 远程合并裁决入口）：新增的组件各自成文件
+  //   （SyncProbeRow / MergePreviewEntry + 产物库那侧的 deviceLabel），
+  //   主文件只多出 import、挂载点与一处「快照标签追加设备名」的拼接 —— 没有可再下沉的纯逻辑
+  //   （测试连接/设备名的判定与渲染规则在 ui 层，见 probe-view.ts / remote-device-view.ts）。
+  // 1595 → 1620（方案 A：同步页按钮瘦身）。增量逐项都是**装配**，且已按「先抽出去」外移：
+  //   · 一键同步分派：决策与编排分别下沉 merge-view.decideSyncEntry / sync-entry.resolveSmartSync
+  //     （两者都有 node 单测），主文件只留 switchChannel + 一次 resolveSmartSync + 三个分支；
+  //   · 受控展开：合并视图改由 mergeSeed（preview + signal）驱动（MergePreviewEntry 增加
+  //     openSignal / hideEntryButton / initialPreview），主文件只多一个 state 与一次挂载；
+  //   · 按钮瘦身本身是**净减**（主行 3 → 2 个、拉取降级到快照行、测试连接下移到卡片底部）。
+  //   剩下的全是 React 状态与 JSX 位置，没有可再下沉的纯逻辑，故按仓库惯例抬上限并记录理由。
+  // 1620 → **1560**（三项 UI 收口：测试连接并入动作行、移除拉取差异预览、一键同步改弹窗）。
+  //   这一轮是**净减**，因此按棘轮本意把上限**压回去**（而不是继续抬）：
+  //   · 测试连接：结果走 toast，页面不再有它的一整块内联横幅（组件内 presentation='action' 只出按钮）；
+  //   · 拉取差异预览：按钮、runPull、pullView、报告弹窗、pullReportView import 全部删除；
+  //   · 一键同步：裁决视图从页面内联改为**弹窗**装配（Modal + 一次 MergePreviewView），
+  //     页面侧只多一个 mergeSeed 状态、一个 mergeApplying 状态与一个弹窗块。
+  // 1560 不变（加载动画 + 合并弹窗重设计）：新增的在途活动条抽成 SyncActivityBar.tsx，
+  //   裁决弹窗壳/状态/请求抽成 MergeModal.tsx（主文件只留一次挂载），主文件因此仍然回落。
+  // 1560 → 1600（真·自动同步：三项策略开关）。增量逐项都是**装配**，三个控件本身在 AutosyncCard.tsx：
+  //   · updateAutosyncOptions：一次 api.autosyncUpdate + 两处 patchChannelOf（就地回填 autosync/interval/realtime）；
+  //   · 卡片新增 onUpdateOptions 接线与 import 两个类型（realtime / 分档 / 冲突策略都是通道级状态）。
+  //   没有可再下沉的纯逻辑：判定与文案都在 ui 层（sync-settings-view.ts）与字典里，这里只是 state 通道。
+  assert.ok(viewLines <= 1600, '主文件行数必须保持在拆分后的量级（实际 ' + viewLines + ' 行）')
 })
 
 test('t42: 通道卡必须是渲染函数（内联组件 = 每次渲染新类型 → 子树重挂、Select 展开态清零）', () => {
@@ -119,7 +144,7 @@ test('工作副本「重建」按钮必须在请求在途时转加载态（用
   // 重新 clone（可达数十秒），期间用户无从判断是否在执行。守卫钉住三条：在途态由本卡自持、两个出口都转
   // 加载态并互相禁用、失败也必须收掉加载态；任一条回退即变红。
   const src = readSource(fileURLToPath(new URL('./WorkDirCard.tsx', import.meta.url)))
-  assert.match(src, /const \[pending, setPending\] = useState<'relink' \| 'reclone' \| null>\(null\)/, '在途态必须是本卡自持的 relink/reclone 判别式状态')
+  assert.match(src, /const \[pending, setPending\] = useState<'relink' \| 'adopt' \| 'reclone' \| null>\(null\)/, '在途态必须是本卡自持的 relink/reclone 判别式状态')
   assert.match(src, /loading=\{pending === 'reclone'\}/, '重新克隆按钮必须在自身请求在途时显示加载态')
   assert.match(src, /loading=\{pending === 'relink'\}/, '重指向按钮同理')
   assert.match(src, /disabled=\{busy \|\| pending !== null\}/, '在途时必须同时禁用两个出口（防重复点击）')