dsh-config-manager 0.1.47 → 0.1.49

package/src/client/locales.ts

@@ -80,6 +80,7 @@ export const zh = {
   'import.importing': '正在导入…（插件安装较多时可能需要几分钟，请勿关闭页面）',
   'import.log.title': '导入日志',
   'import.log.empty': '等待命令输出…',
+  'import.log.newOutput': '↓ 新输出',
   'import.skipCurrent': '跳过当前插件',
   'import.skipPending': '正在跳过…其余项将继续导入',
   'import.retrySkipped': '重试失败/跳过的项 ({count})',
@@ -126,6 +127,7 @@ export const zh = {
   'snapshots.noActions': '该快照无可用恢复动作（或全部跳过）。',
   'snapshots.execute': '执行恢复',
   'snapshots.executing': '恢复执行中…',
+  'snapshots.confirmTitle': '确认恢复',
   'snapshots.confirmRestore': '确认执行恢复？当前文件会先备份到快照的 pre-restore 目录，插件通过官方 dsh plugin remove 卸载。',
   'snapshots.reportTitle': '恢复报告',
   'snapshots.restored': '已还原',
@@ -133,6 +135,27 @@ export const zh = {
   'snapshots.manualHints': '需人工处理',
   'snapshots.failed': '失败',
   'snapshots.skipped': '跳过',
+  // —— 定时全量备份（快照 tab）——
+  'backupSchedule.title': '定时全量备份',
+  'backupSchedule.hint': '按固定间隔在后台自动导出全量备份 ZIP（恒不含 secret、不加密；要加密请手动导出）。配置存 sync/backup-schedule.json，随 self 分区备份 / 远程同步迁移。',
+  'backupSchedule.enabled': '启用定时备份',
+  'backupSchedule.enabledHint': '开启后 DSH 在后台按间隔自动备份；每次启动时立即执行一次（距上次运行不足 1 小时则跳过启动触发）。',
+  'backupSchedule.interval': '备份间隔',
+  'backupSchedule.interval.6h': '每 6 小时',
+  'backupSchedule.interval.12h': '每 12 小时',
+  'backupSchedule.interval.24h': '每 24 小时',
+  'backupSchedule.interval.7d': '每 7 天',
+  'backupSchedule.save': '保存设置',
+  'backupSchedule.saved': '设置已保存',
+  'backupSchedule.runNow': '立即备份',
+  'backupSchedule.running': '备份中…',
+  'backupSchedule.lastRun': '上次运行',
+  'backupSchedule.never': '从未运行',
+  'backupSchedule.status.success': '成功',
+  'backupSchedule.status.skipped': '已跳过',
+  'backupSchedule.status.failed': '失败',
+  'backupSchedule.loading': '加载定时备份设置…',
+  'backupSchedule.error': '定时备份设置加载失败',
   // —— 报告 ——
   'report.export.title': '导出完成',
   'report.import.title': '导入结果',
@@ -235,6 +258,7 @@ export const en: Record<keyof typeof zh, string> = {
   'import.importing': 'Importing… (installing many plugins may take a few minutes; keep this page open)',
   'import.log.title': 'Import Log',
   'import.log.empty': 'Waiting for command output…',
+  'import.log.newOutput': '↓ New output',
   'import.skipCurrent': 'Skip current plugin',
   'import.skipPending': 'Skipping… the rest of the import continues',
   'import.retrySkipped': 'Retry failed/skipped items ({count})',
@@ -280,6 +304,7 @@ export const en: Record<keyof typeof zh, string> = {
   'snapshots.noActions': 'No restorable actions for this snapshot (or all skipped).',
   'snapshots.execute': 'Restore now',
   'snapshots.executing': 'Restoring…',
+  'snapshots.confirmTitle': 'Confirm restore',
   'snapshots.confirmRestore': 'Confirm restore? Current files are backed up to the snapshot\'s pre-restore folder first; plugins are removed via the official dsh plugin remove.',
   'snapshots.reportTitle': 'Restore Report',
   'snapshots.restored': 'Restored',
@@ -287,6 +312,27 @@ export const en: Record<keyof typeof zh, string> = {
   'snapshots.manualHints': 'Manual action needed',
   'snapshots.failed': 'Failed',
   'snapshots.skipped': 'Skipped',
+  // —— Scheduled full backups (snapshots tab) ——
+  'backupSchedule.title': 'Scheduled Full Backups',
+  'backupSchedule.hint': 'Automatically export a full backup ZIP in the background on a fixed cadence (secrets are never included, never encrypted — use manual export for encryption). Config lives in sync/backup-schedule.json and migrates with the self section.',
+  'backupSchedule.enabled': 'Enable scheduled backups',
+  'backupSchedule.enabledHint': 'When on, DSH backs up automatically on the cadence below; one run fires on every startup (skipped if less than 1h since the last run).',
+  'backupSchedule.interval': 'Backup interval',
+  'backupSchedule.interval.6h': 'Every 6 hours',
+  'backupSchedule.interval.12h': 'Every 12 hours',
+  'backupSchedule.interval.24h': 'Every 24 hours',
+  'backupSchedule.interval.7d': 'Every 7 days',
+  'backupSchedule.save': 'Save settings',
+  'backupSchedule.saved': 'Settings saved',
+  'backupSchedule.runNow': 'Back up now',
+  'backupSchedule.running': 'Backing up…',
+  'backupSchedule.lastRun': 'Last run',
+  'backupSchedule.never': 'Never run',
+  'backupSchedule.status.success': 'Success',
+  'backupSchedule.status.skipped': 'Skipped',
+  'backupSchedule.status.failed': 'Failed',
+  'backupSchedule.loading': 'Loading scheduled backup settings…',
+  'backupSchedule.error': 'Failed to load scheduled backup settings',
   'report.export.title': 'Export Complete',
   'report.import.title': 'Import Result',
   'report.rollback.title': 'Rollback Report',

package/src/client/market/MarketPanel.tsx

@@ -273,14 +273,18 @@ export function MarketPanel({ api, myConfigsApi, importApi, syncApi, t }: Market
     }
   }
 
-  /** 下载 + 校验单条目 → dry-run 详情预览（零写入）。自托管条目（带 repo）必须携带来源仓库。 */
+  /** 下载 + 校验单条目 → dry-run 详情预览（零写入）。自托管条目（带 repo）必须携带来源仓库。
+   *  竞态守卫：下载期间用户可发起另一条目下载（downloadingId 已变），晚到响应一律丢弃，
+   *  防止「弹窗标题是 B、详情是 A」的串扰。 */
   const runDownload = async (item: MarketListItem): Promise<void> => {
     patch({ downloadingId: item.id, error: null })
     try {
       const detail = await api.download(item.id, item.repo)
+      if (stateRef.current.downloadingId !== item.id) return
       // 初始化逐分区批准表：低风险默认勾选，高风险默认不勾选（须逐项显式批准）
       patch({ downloadingId: null, detail, approvals: defaultApprovals(detail.plan) })
     } catch (err) {
+      if (stateRef.current.downloadingId !== item.id) return
       patch({ downloadingId: null, error: err instanceof Error ? err.message : String(err) })
     }
   }
@@ -378,10 +382,10 @@ export function MarketPanel({ api, myConfigsApi, importApi, syncApi, t }: Market
       <Card>
         <span className={css.groupLabel}>{t('config.title')}</span>
         <div className={css.actionRow}>
-          <Button variant="primary" disabled={state.refreshing || state.importing} onClick={() => { void runRefresh() }}>
+          <Button variant="primary" disabled={state.refreshing || state.importing || state.browsing} onClick={() => { void runRefresh() }}>
             {state.refreshing ? <Spinner label={t('config.refreshing')} /> : t('config.refresh')}
           </Button>
-          <Button disabled={state.browsing} onClick={() => { void runBrowse() }}>
+          <Button disabled={state.browsing || state.refreshing || state.importing} onClick={() => { void runBrowse() }}>
             {state.browsing ? <Spinner label={t('list.loading')} /> : t('list.browse')}
           </Button>
         </div>
@@ -598,7 +602,8 @@ export function MarketPanel({ api, myConfigsApi, importApi, syncApi, t }: Market
                         )}
                       </div>
                     </div>
-                    <Button disabled={state.downloadingId === it.id} onClick={() => { openDownload(it) }}>
+                    {/* 下载按钮：任一下载进行中全部禁用（防止并发下载详情串扰 + 防重复点击） */}
+                    <Button disabled={state.downloadingId !== null} onClick={() => { openDownload(it) }}>
                       {state.downloadingId === it.id ? <Spinner label={t('common.loading')} /> : t('list.download')}
                     </Button>
                   </div>

package/src/client/market/MyConfigsView.tsx

@@ -556,18 +556,18 @@ export function MyConfigsView({
 
   /* ------------------------------------------------ 装回本地（复用市场下载 + 逐分区批准链路） */
 
-  /** 装回本地（复用市场下载 + 逐分区批准链路；条目内容在用户自己的公开仓库，必须带 repo 来源） */
+  /** 装回本地（复用市场下载 + 逐分区批准链路；条目内容在用户自己的公开仓库，必须带 repo 来源）
+   *  竞态守卫：下载期间用户可切换装回另一条目（install.itemId 已变），晚到响应一律丢弃，
+   *  防止「会话标题是 B、详情是 A」的串扰。 */
   const runDownload = async (entry: MyItemEntry): Promise<void> => {
     commitInstall({ itemId: entry.id, detail: null, approvals: {}, importing: false, importResult: null, error: null })
     try {
       const detail = await api.download(entry.id, entry.repoUrl)
-      if (installRef.current !== null) {
-        commitInstall({ ...installRef.current, detail, approvals: defaultApprovals(detail.plan) })
-      }
+      if (installRef.current === null || installRef.current.itemId !== entry.id) return
+      commitInstall({ ...installRef.current, detail, approvals: defaultApprovals(detail.plan) })
     } catch (err) {
-      if (installRef.current !== null) {
-        patchInstall({ error: err instanceof Error ? err.message : String(err) })
-      }
+      if (installRef.current === null || installRef.current.itemId !== entry.id) return
+      patchInstall({ error: err instanceof Error ? err.message : String(err) })
     }
   }
 
@@ -956,7 +956,7 @@ export function MyConfigsView({
                 <div className={css.rowActions}>
                   <Button onClick={() => { startUpdate(entry); openUpload() }}>{t('myconfigs.item.update')}</Button>
                   <Button
-                    disabled={install !== null && install.itemId === view.id && install.detail === null}
+                    disabled={install !== null && install.detail === null}
                     onClick={() => { openInstall(entry) }}
                   >
                     {t('myconfigs.item.install')}

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

@@ -38,6 +38,7 @@ import { renderExportReport } from '../ui/report.ts'
 import type { FlowPhase } from '../ui/flow.ts'
 import type { ImportStep } from '../ui/types.ts'
 import type { RunProgress } from './common/progress-view.ts'
+import type { BackupScheduleDraft } from '../ui/backup-schedule.ts'
 import type {
   GlobalConflictStrategy, ImportAnalysis, ImportDecisions, ImportPlan, ImportResult,
   ItemResolution, PathMapping,
@@ -189,13 +190,20 @@ 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
+  /** 定时备份设置草稿（未保存修改切 tab / 刷新保留；null = 无草稿，以宿主配置为准） */
+  backupDraft: BackupScheduleDraft | null
 }
 
 /* ------------------------------------------------- 持久化（非敏感）状态形状 */
@@ -422,9 +430,11 @@ function defaultSnapshotsState(): SnapshotsStoreSlice {
   return {
     selectedId: null,
     plan: null,
+    running: false,
     report: null,
     actionError: null,
     error: null,
+    backupDraft: null,
   }
 }
 
@@ -501,9 +511,11 @@ 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,
+    backupDraft: s.backupDraft,
   }
 }
 
@@ -555,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,
+    },
   }
 }
 
@@ -896,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 阶段，就强制退回重新解锁。
@@ -1032,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
   }
 
@@ -1137,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（并镜像回控制器）。 */
@@ -1168,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') {
@@ -1221,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({