dsh-config-manager 0.1.48 → 0.1.49

package/src/client/api.ts

@@ -82,11 +82,13 @@ export interface DecryptArchiveResponse {
   refs: string[];
 }
 
-/** restore 端点响应：dryRun=true 返回 plan；执行返回 report（与 CLI 一致的诚实报告） */
+/** restore 端点响应：dryRun=true 返回 plan；执行返回 report（与 CLI 一致的诚实报告）。
+ *  runId 仅真实执行时存在（宿主 RunRegistry 登记；/runs + /progress 刷新恢复用）。 */
 export interface RestoreResponse {
   dryRun: boolean;
   plan?: RestorePlan;
   report?: RestoreReport;
+  runId?: string;
 }
 
 /** Star 引导弹窗状态（GET /star-prompt；纯偏好，无 secret） */

package/src/client/config-manager.module.css

@@ -575,6 +575,28 @@
   font-size: 12.5px;
   font-weight: 600;
   color: var(--dsw-alias-label-secondary);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+/* 「↓ 新输出」跳底按钮：用户上滚后有新行时出现（§24 自动滚动纪律）；
+   复用 ghost 语义（L2 描边 + 细圆角），hover 走交互底色，不新增视觉体系 */
+.logJumpButton {
+  font-family: var(--dsw-font-family);
+  font-size: 11px;
+  line-height: 1;
+  color: var(--dsw-alias-label-secondary);
+  background: transparent;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 999px;
+  padding: 3px 8px;
+  cursor: pointer;
+}
+
+.logJumpButton:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
 }
 
 /* 命令日志容器：限高内滚（长日志不把整页撑长；见 DESIGN.md §7.2 logScroll） */

package/src/client/export/ExportView.tsx

@@ -252,12 +252,12 @@ export function ExportView({ api, t }: ExportViewProps) {
       {running && <ProgressBar event={progress} active />}
 
       {error !== null && (
-        <ErrorBanner error={error} onRetry={() => { void runExport() }} retrying={running} />
+        <ErrorBanner error={error} onRetry={() => { void runExport() }} retrying={running} t={api.t} />
       )}
 
       {result !== null && !running && (
         <>
-          <ReportView kind="export" exportReport={result.report} onDownload={() => { void download(result.zipPath) }} downloadBusy={downloading} />
+          <ReportView kind="export" exportReport={result.report} onDownload={() => { void download(result.zipPath) }} downloadBusy={downloading} t={api.t} />
           {downloaded && <Banner kind="ok">{t('export.saved', { name: result.report.file.name })}</Banner>}
         </>
       )}

package/src/client/import/ImportWizardView.tsx

@@ -114,21 +114,26 @@ function ImportLogPanelBase({ lines, t }: { lines: string[]; t: TranslateNS<'con
   const stickRef = useRef(true)
   /** 用户上滚后是否有新行到达（显示「↓ 新输出」；点击跳到底部清除） */
   const [hasNewOutput, setHasNewOutput] = useState(false)
-  /** 上次渲染的行数（memo 外比较用；新行 = 长度增加） */
-  const prevCountRef = useRef(lines.length)
+  /**
+   * 上次渲染的数组引用（新输出 = 引用变化）。依赖 appendLog 的**不可变写入**：
+   * 每次追加都生成新数组（run-registry.ts）——行数封顶后长度恒定，但引用必变，
+   * 以引用判断才能感知截断后的新行（长度比较在 500 行封顶时失效）。
+   */
+  const prevLinesRef = useRef(lines)
 
   useEffect(() => {
     const el = scrollRef.current
     if (el === null) return
+    const hasNew = lines !== prevLinesRef.current
+    prevLinesRef.current = lines
     if (stickRef.current) {
       el.scrollTop = el.scrollHeight
       setHasNewOutput(false)
-    } else if (lines.length > prevCountRef.current) {
+    } else if (hasNew) {
       // 用户已上滚且有新行到达：提示而非强制拉回（§24 自动滚动纪律）
       setHasNewOutput(true)
     }
-    prevCountRef.current = lines.length
-  }, [lines.length])
+  }, [lines])
 
   /** 滚动中更新贴底状态（上滚 → 停止跟随；滚回底部 → 恢复跟随并清除提示） */
   const onScroll = (): void => {
@@ -168,10 +173,11 @@ function ImportLogPanelBase({ lines, t }: { lines: string[]; t: TranslateNS<'con
   )
 }
 
-/** memo：lines 数组为同一引用被 append（RunState.log push 不换引用），浅比较失效 ——
- *  自定义比较以行数 + t 引用为准，长度未变时跳过整个列表重渲染。 */
+/** memo：lines 数组经 appendLog **不可变追加**（每次 append 换新引用，run-registry.ts）——
+ *  自定义比较以「数组引用 + t 引用」为准：引用未变 = 无新输出，跳过整个列表重渲染；
+ *  引用已变 = 有新行（含 500 行封顶后长度不变的情况），必须重渲染。 */
 const ImportLogPanel = memo(ImportLogPanelBase, (prev, next) =>
-  prev.lines.length === next.lines.length && prev.t === next.t,
+  prev.lines === next.lines && prev.t === next.t,
 )
 
 /**
@@ -505,7 +511,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
             {uploading ? <Spinner label={t('import.analyzing')} /> : t(browseLabelKey(selectModel.selectedName !== null))}
           </Button>
         </div>
-        {error !== null && <ErrorBanner error={error} onRetry={resetWizard} />}
+        {error !== null && <ErrorBanner error={error} onRetry={resetWizard} t={api.t} />}
       </div>
     )
   }
@@ -514,7 +520,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
     return (
       <div className={css.viewBody}>
         <ProgressBar event={progress} active />
-        {error !== null && <ErrorBanner error={error} onRetry={resetWizard} />}
+        {error !== null && <ErrorBanner error={error} onRetry={resetWizard} t={api.t} />}
         <ErrorList errors={imp.errors} />
       </div>
     )
@@ -541,7 +547,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
             {analysis.warnings.map((w, i) => <div key={i}>{w}</div>)}
           </Banner>
         )}
-        {error !== null && <ErrorBanner error={error} onRetry={() => { void goPreview() }} />}
+        {error !== null && <ErrorBanner error={error} onRetry={() => { void goPreview() }} t={api.t} />}
         <div className={css.actionRow}>
           <Button variant="ghost" onClick={resetWizard}>{t('import.select.reselect')}</Button>
           <Button variant="primary" onClick={() => { void goPreview() }}>{t('common.next')}</Button>
@@ -568,7 +574,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
         </div>
         {isEncrypted && <Banner kind="warn">{t('import.decrypt.previewHint')}</Banner>}
         {summary.needsRestart && <Banner kind="warn">{t('import.preview.restart')}</Banner>}
-        {error !== null && <ErrorBanner error={error} onRetry={() => { void goPreview() }} />}
+        {error !== null && <ErrorBanner error={error} onRetry={() => { void goPreview() }} t={api.t} />}
         <div className={css.actionRow}>
           <Button variant="ghost" onClick={resetWizard}>{t('import.select.reselect')}</Button>
           <Button
@@ -605,7 +611,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
             setArchiveUnlockError(null)
           }}
         />
-        {archiveUnlockError !== null && <ErrorBanner error={archiveUnlockError} />}
+        {archiveUnlockError !== null && <ErrorBanner error={archiveUnlockError} t={api.t} />}
         <div className={css.actionRow}>
           <Button variant="ghost" onClick={resetWizard}>{t('import.select.reselect')}</Button>
           <Button
@@ -698,7 +704,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
             </Button>
           </div>
         </Card>
-        {error !== null && <ErrorBanner error={error} onRetry={() => { void execute() }} />}
+        {error !== null && <ErrorBanner error={error} onRetry={() => { void execute() }} t={api.t} />}
       </div>
     )
   }
@@ -723,7 +729,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
         )}
         {imp.skipRequested && <div className={css.hint}>{t('import.skipPending')}</div>}
         <div className={css.hint}>{t('import.importing')}</div>
-        {error !== null && <ErrorBanner error={error} />}
+        {error !== null && <ErrorBanner error={error} t={api.t} />}
         <ErrorList errors={imp.errors} />
       </div>
     )
@@ -753,7 +759,7 @@ export function ImportWizardView({ api, t }: ImportWizardViewProps) {
           </div>
         )}
         {result.needsRestart && <Banner kind="warn">{t('report.needsRestart')}</Banner>}
-        {error !== null && <ErrorBanner error={error} />}
+        {error !== null && <ErrorBanner error={error} t={api.t} />}
       </div>
     )
   }

package/src/client/run-store.test.ts

@@ -19,7 +19,8 @@ import assert from 'node:assert/strict'
 
 import { RunStore, STATE_KEY, type StoreStorage } from './run-store.ts'
 import type { RunProgress } from './common/progress-view.ts'
-import type { RunState } from '../core/run-registry.ts'
+import { MAX_RUN_LOG_LINES, type RunState } from '../core/run-registry.ts'
+import type { RestoreReport } from '../core/restore.ts'
 import type { ImportDecisions } from '../core/types.ts'
 import type { ConfigManagerApi } from './api.ts'
 import {
@@ -503,6 +504,9 @@ test('m3-poll: watchRunning 经 /runs 发现进行中 run 并轮询 /progress
   // 发现后转入 /progress 轮询且回填过真实进度（内部计数 + 当前项名）
   assert.ok(progressCalls >= 2, '发现 runId 后轮询 /progress')
   assert.equal(imp.running, false)
+  // 发现活跃 run 时 runId 同步写入 store（fresh run 期间「跳过当前插件」有正确目标，
+  // 不会用上一次导入的陈旧 runId —— run-store patchProgress 同步 runId）
+  assert.equal(imp.runId, RUN_ID, 'watchRunning 发现 run 后 store.runId 立即填充')
 })
 
 test('m3-poll: watchRunning 轮询回填分区/内部计数进度（ProgressBar 徽章数据源）', async () => {
@@ -565,6 +569,48 @@ test('m3-poll: stopRunWatch 停止发现阶段轮询（视图请求结束后）'
   store.stopRunWatch('export')
 })
 
+test('m3-poll: 导入日志超过 MAX_RUN_LOG_LINES 后 store progress.log 仍持续更新（P1-3 封顶不冻结）', async () => {
+  // 模拟导入日志已满 500 行封顶：后续轮询长度恒为 500，但每次 append 都换新数组引用
+  // （run-registry appendLog 不可变写入）。store 的 progress.log 必须持续拿到新引用，
+  // 否则 ImportLogPanel 的 memo 按引用比较会判定「无变化」→ 日志面板冻结。
+  let log: string[] = []
+  for (let i = 0; i < MAX_RUN_LOG_LINES; i++) log = [...log, `line-${i}`]
+  const progressResponses: RunState[] = []
+  for (let i = 0; i < 4; i++) {
+    log = [...log.slice(-(MAX_RUN_LOG_LINES - 1)), `cap-${i}`]
+    progressResponses.push(runningRun('import', { section: 'plugins', item: i + 1, itemTotal: 8, detail: 'plugin:pkg', log }))
+  }
+  progressResponses.push({
+    runId: RUN_ID, kind: 'import', status: 'done',
+    section: null, sectionTotal: null, item: null, itemTotal: null, detail: null, log: [],
+    result: makeImportResult(), createdAt: 1, updatedAt: 3,
+  })
+  let progressCalls = 0
+  const api = makeApi({
+    runs: async () => [runningRun('import')],
+    progress: async () => progressResponses[Math.min(progressCalls++, progressResponses.length - 1)]!,
+  })
+  const store = new RunStore({ storage: null, pollIntervalMs: 5 })
+  await store.resume(api)
+  // 订阅捕获轮询期间的 progress.log 引用
+  const seenRefs = new Set<string[]>()
+  const seenTails = new Set<string>()
+  const unsub = store.subscribe(() => {
+    const p = store.getSnapshot().import.progress
+    const log = p?.log ?? []
+    if (log.length === MAX_RUN_LOG_LINES) {
+      seenRefs.add(log)
+      seenTails.add(log[log.length - 1]!)
+    }
+  })
+  await sleep(150)
+  unsub()
+  assert.equal(store.getSnapshot().import.step, 'result', '轮询收敛到完成')
+  assert.ok(seenRefs.size >= 3, `封顶后轮询仍拿到新数组引用（实际 ${seenRefs.size} 个不同引用）`)
+  assert.ok(seenTails.has('cap-3'), '最新行 cap-3 已到达 store（日志没有冻结在旧行）')
+  assert.ok(!seenTails.has('line-499'), '截断保留最新行（cap-* 覆盖 line-* 尾部）')
+})
+
 test('m3-poll: 同一 kind 重复 watchRunning 不重复启动', async () => {
   let runsCalls = 0
   const api = makeApi({
@@ -873,3 +919,68 @@ test('低频面板: 旧版顶层 syncMode 载荷 → 迁移为 git 通道的 byC
   assert.equal(st.sync.byChannel.git.selectedSnapshotId, 'snap-old')
   assert.equal(st.sync.byChannel.webdav.syncMode, 'default', 'webdav 通道保持缺省')
 })
+
+/* -------------------------------------------------- restore（P1-1）权威状态 */
+
+test('低频面板: 快照恢复 running 为瞬态——不写入 sessionStorage、刷新后复位（以宿主 /runs 为权威）', () => {
+  const { storage, raw } = makeStorage()
+  const first = new RunStore({ storage })
+  first.patch({ panel: 'snapshots', snapshots: { selectedId: 'snap-1', running: true } })
+  const persisted = JSON.parse(raw() ?? '{}') as { snapshots?: { running?: boolean } }
+  assert.equal(persisted.snapshots?.running, false, 'running 恒不落盘（白名单剔除）')
+
+  // 即便旧载荷携带 running=true，applyPersisted 也硬性归零——绝不把浏览器陈旧状态
+  // 当成「恢复仍在执行」的依据（宿主 /runs 是唯一权威，resume() 负责重新置位）
+  storage.setItem(STATE_KEY, JSON.stringify({
+    ...persisted,
+    snapshots: { ...persisted.snapshots, running: true },
+  }))
+  const second = new RunStore({ storage })
+  assert.equal(second.getSnapshot().snapshots.running, false, '刷新后 running 复位（不读存储）')
+  assert.equal(second.getSnapshot().snapshots.selectedId, 'snap-1', '非瞬态字段仍恢复')
+})
+
+test('m2-resume: 活跃 restore run 经 /runs 恢复 running 并轮询到完成回填报告（宿主为权威）', async () => {
+  const report: RestoreReport = {
+    snapshotId: 'snap-1',
+    restored: ['settings.yaml'],
+    removedPlugins: ['@scope/pkg'],
+    manualHints: [],
+    failed: [],
+    skipped: [],
+  }
+  const progressResponses: RunState[] = [
+    runningRun('restore', { section: 'restore', item: 1, itemTotal: 3, detail: '整文件还原 settings.yaml' }),
+    {
+      runId: RUN_ID, kind: 'restore', status: 'done',
+      section: null, sectionTotal: null, item: null, itemTotal: null, detail: null, log: [],
+      result: report, createdAt: 1, updatedAt: 3,
+    },
+  ]
+  let progressCalls = 0
+  const api = makeApi({
+    runs: async () => [runningRun('restore')],
+    progress: async () => progressResponses[Math.min(progressCalls++, progressResponses.length - 1)]!,
+  })
+  const store = new RunStore({ storage: null, pollIntervalMs: 5 })
+  const resumed = await store.resume(api)
+  assert.equal(resumed, true, '发现活跃 restore run')
+  assert.equal(store.getSnapshot().snapshots.running, true, 'running 镜像置位（宿主 /runs 为权威）')
+
+  await sleep(80)
+  const snap = store.getSnapshot().snapshots
+  assert.equal(snap.running, false, '完成后 running 复位')
+  assert.deepEqual(snap.report?.restored, ['settings.yaml'], '恢复报告回填 store')
+  assert.equal(snap.actionError, null)
+})
+
+test('m2-resume: store 镜像显示恢复中但 host 无活跃 restore run → 复位并提示不可恢复', async () => {
+  const api = makeApi({ runs: async () => [] })
+  const store = new RunStore({ storage: null })
+  store.patch({ snapshots: { running: true } })
+  const resumed = await store.resume(api)
+  assert.equal(resumed, false)
+  const snap = store.getSnapshot().snapshots
+  assert.equal(snap.running, false, '无宿主 run 时 running 复位（不残留 UI 假状态）')
+  assert.ok(snap.actionError !== null, '如实提示结果不可恢复')
+})

package/src/client/run-store.ts

@@ -190,10 +190,15 @@ export interface MarketStoreSlice {
   myConfirmDeleteId: string | null
 }
 
-/** 快照恢复面板的切片（无敏感字段；快照列表本身可随时重载，不持久化）。 */
+/** 快照恢复面板的切片（无敏感字段；快照列表本身可随时重载，不持久化）。
+ *  running 为「内存切片瞬态」：切 tab 由模块级单例保留、刷新时被 toPersistedState
+ *  白名单剔除 —— 恢复是否仍在执行以宿主 RunRegistry（/runs + /progress）为权威，
+ *  刷新后经 resume() 重新发现；浏览器持久化绝不作为 destructive operation 的状态源。 */
 export interface SnapshotsStoreSlice {
   selectedId: string | null
   plan: RestorePlan | null
+  /** 真实恢复执行中（瞬态；宿主 /runs 是权威来源，本字段只是镜像） */
+  running: boolean
   report: RestoreReport | null
   actionError: string | null
   error: string | null
@@ -425,6 +430,7 @@ function defaultSnapshotsState(): SnapshotsStoreSlice {
   return {
     selectedId: null,
     plan: null,
+    running: false,
     report: null,
     actionError: null,
     error: null,
@@ -505,6 +511,7 @@ export function toSnapshotsStoreSlice(s: SnapshotsStoreSlice): SnapshotsStoreSli
   return {
     selectedId: s.selectedId,
     plan: s.plan,
+    running: s.running,
     report: s.report,
     actionError: s.actionError,
     error: s.error,
@@ -560,7 +567,13 @@ export function toPersistedState(state: StoreState): PersistedState {
       },
     },
     market: state.market,
-    snapshots: state.snapshots,
+    snapshots: {
+      ...state.snapshots,
+      // 快照恢复 running 为内存切片瞬态：不落盘 —— 恢复是否仍在执行以宿主
+      // RunRegistry（/runs + /progress）为权威，刷新后由 resume() 重新发现；
+      // 持久化「running=true」会把浏览器陈旧状态误当成宿主真实状态（P1-1 原则）。
+      running: false,
+    },
   }
 }
 
@@ -901,7 +914,13 @@ export class RunStore {
         }
       })(),
       market: { ...defaultMarketState(), ...parsed.market },
-      snapshots: { ...defaultSnapshotsState(), ...parsed.snapshots },
+      snapshots: {
+        ...defaultSnapshotsState(),
+        ...parsed.snapshots,
+        // 硬性：恢复执行中为瞬态，绝不从存储恢复（即使旧载荷携带 running=true 也清空）——
+        // 是否仍有恢复在执行以宿主 /runs 为权威，resume() 会重新发现并置 true
+        running: false,
+      },
     }
     // 安全兜底：整体加密备份容器已解锁标志绝不从存储恢复（archiveUnlocked 必为 false）→
     // 刷新后只要仍标记为加密容器且已越过 decrypt-archive 阶段，就强制退回重新解锁。
@@ -1037,6 +1056,25 @@ export class RunStore {
         },
       })
     }
+
+    // 快照恢复（P1-1）：宿主 /runs 是「恢复是否仍在执行」的权威来源。
+    // 刷新/重开面板后若存在活跃 restore run → 恢复 running 并轮询 /progress
+    // （结果经 applySettled 回填 report）；持久化的 running 恒为 false（白名单
+    // 剔除），绝不把浏览器陈旧状态当成宿主真实状态。
+    const restoreRun = active.find((r) => r.kind === 'restore')
+    if (restoreRun !== undefined) {
+      resumed = true
+      this.patch({ snapshots: { running: true, actionError: null } })
+      this.pollRun(restoreRun.runId, 'restore')
+    } else if (this.state.snapshots.running) {
+      // 面板镜像显示恢复中，但 host 无活跃 restore run：请求已结束且响应丢失
+      this.patch({
+        snapshots: {
+          running: false,
+          actionError: '上次恢复任务已结束但结果无法恢复，请重新执行',
+        },
+      })
+    }
     return resumed
   }
 
@@ -1142,7 +1180,13 @@ export class RunStore {
   private patchProgress(kind: RunKind, state: RunState): void {
     const event = mapRunProgress(kind, state)
     if (kind === 'export') this.patch({ export: { progress: event } })
-    else this.patch({ import: { progress: event } })
+    else if (kind === 'restore') this.patch({ snapshots: { running: true } })
+    else {
+      // 同步写入 runId：watchRunning 发现活跃 import run 时立即填充——
+      // 否则 fresh run（非刷新恢复）期间 store.runId 仍是上一次导入的陈旧值
+      // （/execute 响应在整段导入完成后才带 runId），「跳过当前插件」会打到旧 run。
+      this.patch({ import: { progress: event, runId: state.runId } })
+    }
   }
 
   /** run 完成/失败：把 RunState.result 回填 store（并镜像回控制器）。 */
@@ -1173,6 +1217,22 @@ export class RunStore {
       }
       return
     }
+    // restore（P1-1）：完成/失败回填快照面板切片（running 复位 + report/actionError）。
+    // 刷新恢复路径与面板本地状态收敛：applySettled 写入 store，面板挂载时经
+    // initFromStore 读取（切 tab 后回来也能看到结果）。
+    if (kind === 'restore') {
+      const result = state.result as RestoreReport | undefined
+      if (state.status === 'done' && result !== undefined && typeof result === 'object') {
+        this.patch({
+          snapshots: { running: false, report: result, actionError: null },
+        })
+      } else {
+        this.patch({
+          snapshots: { running: false, actionError: state.error ?? '恢复失败（结果不可用）' },
+        })
+      }
+      return
+    }
     // import
     const result = state.result as ImportResult | undefined
     if (state.status === 'done' && result !== undefined && typeof result === 'object') {
@@ -1226,6 +1286,15 @@ export class RunStore {
           error: '任务已结束或超过保留期，进度不可恢复',
         },
       })
+    } else if (kind === 'restore') {
+      // 恢复 run 被清理/丢失：复位 running（宿主侧恢复动作可能仍在执行——
+      // 以 RunRegistry 为准，本提示只说明进度不可恢复，不臆断恢复已停止）
+      this.patch({
+        snapshots: {
+          running: false,
+          actionError: '恢复任务已结束或超过保留期，进度不可恢复',
+        },
+      })
     } else {
       this.importWizardInst?.reset()
       this.patch({

package/src/client/snapshots/SnapshotsPanel.tsx

@@ -98,12 +98,15 @@ function actionKindLabel(kind: string): string {
 /**
  * 从 runStore 恢复上次的快照面板状态（切 tab 回 / 刷新后挂载）。
  * 无敏感字段；plan/report 为纯数据，可安全序列化恢复。
+ * running 来自 store 镜像（刷新后经 runStore.resume() 以宿主 /runs 为权威重新置位——
+ * 持久化白名单恒为 false，绝不把浏览器陈旧状态当成恢复执行中的依据）。
  */
 function initFromStore(): PanelState {
   const s: SnapshotsStoreSlice = runStore.getSnapshot().snapshots
   return {
     ...initial,
     selectedId: s.selectedId,
+    running: s.running,
     plan: s.plan,
     report: s.report,
     actionError: s.actionError,
@@ -183,6 +186,10 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
     if (state.selectedId === null || state.running) return
     patch({ running: true, report: null, actionError: null })
     setConfirmOpen(false)
+    // m3/P1-1：宿主侧权威防重（/restore 经 RunRegistry 登记，同 kind running → 409）；
+    // 前端 running 只是 UX 镜像。watchRunning 轮询宿主 /runs + /progress——
+    // 切 tab（卸载）后轮询继续，完成/失败经 applySettled 写入 store，切回 initFromStore 恢复。
+    runStore.watchRunning('restore', 500)
     api.restoreSnapshot(state.selectedId, false).then(
       (res) => { patch({ running: false, report: res.report ?? null }) },
       (err) => {
@@ -191,7 +198,7 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
           actionError: err instanceof Error ? err.message : String(err),
         })
       },
-    )
+    ).finally(() => { runStore.stopRunWatch('restore') })
   }
 
   const summary = (): string => {
@@ -376,12 +383,17 @@ function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<
   const [lastRunDetail, setLastRunDetail] = useState<string | null>(null)
   const [flash, setFlash] = useState<string | null>(null)
   const [actionError, setActionError] = useState<string | null>(null)
+  /** 挂载守卫：切 tab 卸载后异步回调只更新 store（草稿），不再 setState（React 18 无告警但浪费） */
+  const mountedRef = useRef(true)
+
+  useEffect(() => () => { mountedRef.current = false }, [])
 
   const load = (): void => {
     setStatus('loading')
     setError(null)
     api.backupSchedule().then(
       (schedule) => {
+        if (!mountedRef.current) return
         setSaved(schedule)
         // 有未保存草稿（切 tab 回来）则保留，否则以宿主配置为权威
         setDraft(runStore.getSnapshot().snapshots.backupDraft ?? { enabled: schedule.enabled, interval: schedule.interval })
@@ -390,6 +402,7 @@ function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<
         setStatus('ready')
       },
       (err) => {
+        if (!mountedRef.current) return
         setStatus('error')
         setError(err instanceof Error ? err.message : String(err))
       },
@@ -415,15 +428,18 @@ function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<
     setActionError(null)
     api.saveBackupSchedule(parsed.value).then(
       (schedule) => {
+        // 宿主已保存：无论面板是否仍挂载都清 store 草稿（否则切回会显示陈旧未保存态）
+        runStore.patch({ snapshots: { backupDraft: null } })
+        if (!mountedRef.current) return
         setSaved(schedule)
         setDraft({ enabled: schedule.enabled, interval: schedule.interval })
         setLastRun(schedule.lastRunStatus)
         setLastRunDetail(formatRunTime(schedule.lastRunAt))
-        runStore.patch({ snapshots: { backupDraft: null } })
         setSaving(false)
         setFlash(t('backupSchedule.saved'))
       },
       (err) => {
+        if (!mountedRef.current) return
         setSaving(false)
         setActionError(err instanceof Error ? err.message : String(err))
       },
@@ -437,6 +453,7 @@ function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<
     setActionError(null)
     api.runBackupNow().then(
       (res) => {
+        if (!mountedRef.current) return
         setSaved(res.schedule)
         setLastRun(res.run.status)
         setLastRunDetail(res.run.zip !== undefined && res.run.zip !== ''
@@ -445,6 +462,7 @@ function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<
         setRunning(false)
       },
       (err) => {
+        if (!mountedRef.current) return
         setRunning(false)
         setActionError(err instanceof Error ? err.message : String(err))
       },

package/src/client/sync/SyncHistoryView.tsx

@@ -82,6 +82,7 @@ export function SyncHistoryView(props: SyncHistoryViewProps): ReactNode {
         error={error}
         onRetry={() => { setReloadKey((k) => k + 1) }}
         retrying={loading}
+        t={api.t}
       />
     );
   }

package/src/core/restore.ts

@@ -94,6 +94,9 @@ export interface RestoreOptions {
   pluginUninstaller?: (
     name: string, profileDir: string, profile: string,
   ) => Promise<{ ok: boolean; message?: string }>;
+  /** 每项动作执行回调（宿主路由埋点：更新 RunRegistry 进度；index/1-based、total=计划动作数、
+   * detail=动作描述。dry-run/planRestore 不触发） */
+  onAction?: (info: { index: number; total: number; detail: string }) => void;
   /** 消息翻译器（缺省 zh；宿主按 DSH 应用语言注入） */
   msg?: MsgFunc;
 }
@@ -494,7 +497,11 @@ export async function restore(opts: RestoreOptions): Promise<RestoreReport> {
   };
 
   let seq = 0;
+  const total = plan.actions.length;
+  let actionIndex = 0;
   for (const action of plan.actions) {
+    actionIndex += 1;
+    opts.onAction?.({ index: actionIndex, total, detail: action.description });
     try {
       switch (action.kind) {
         case 'hostFileRestore': {

package/src/core/run-registry.test.ts

@@ -118,6 +118,46 @@ test('appendLog: 日志行数封顶 MAX_RUN_LOG_LINES（超限截断保留最新
   assert.equal(state?.log[state!.log.length - 1], `line-${MAX_RUN_LOG_LINES + 9}`)
 })
 
+test('appendLog: 不可变追加——每次 append 换新数组引用（React memo 感知新行；封顶后长度恒定但引用仍变）', () => {
+  const reg = new RunRegistry()
+  const run = reg.register('import')
+  const initial = reg.get(run.runId)!.log
+  reg.appendLog(run.runId, 'line-1')
+  const second = reg.get(run.runId)!.log
+  assert.notEqual(second, initial, 'append 必须生成新数组引用（不得原地 push）')
+  assert.deepEqual(second, ['line-1'])
+
+  // 500 行封顶后：长度恒定（memo 按长度比较会漏），但每次 append 引用必变
+  const capRun = reg.register('export')
+  const refs = new Set<unknown[]>()
+  for (let i = 0; i < MAX_RUN_LOG_LINES + 5; i++) {
+    reg.appendLog(capRun.runId, `line-${i}`)
+    refs.add(reg.get(capRun.runId)!.log)
+  }
+  assert.equal(reg.get(capRun.runId)!.log.length, MAX_RUN_LOG_LINES)
+  assert.equal(refs.size, MAX_RUN_LOG_LINES + 5, '每次 append 都是新引用（含封顶后）——前端以引用比较不会漏渲染')
+})
+
+test('register: 快照恢复（restore）同 kind 进行中拒绝（P1-1 并发恢复防护）', () => {
+  const reg = new RunRegistry()
+  const first = reg.register('restore')
+  assert.throws(
+    () => reg.register('restore'),
+    (err: unknown) => {
+      assert.ok(err instanceof RunConflictError)
+      assert.equal((err as RunConflictError).runId, first.runId)
+      return true
+    },
+  )
+  // 恢复中允许导出（不同 kind 互不阻塞）
+  const exp = reg.register('export')
+  assert.equal(exp.kind, 'export')
+  // 完成后的 restore 不阻塞新 restore
+  reg.finish(first.runId, {})
+  const second = reg.register('restore')
+  assert.notEqual(second.runId, first.runId)
+})
+
 test('finish/fail: 状态与 result/error 落账', () => {
   const reg = new RunRegistry()
   const done = reg.register('export')