dsh-config-manager 0.1.69 → 0.1.71

package/src/client/recovery/RecoveryPanel.tsx

@@ -22,7 +22,7 @@ import type { RecoveryPort } from '../../ui/types.ts'
 import type { RecoveryPreview, RecoveryStatus, RecoveryVerifyResult } from '../../ui/types.ts'
 import type { TranslateNS } from '../client-types.ts'
 import { Badge, Banner, Button, Card, Empty, SectionTitle, Spinner } from '../common/ui.tsx'
-import { DiskUsageCard } from '../snapshots/DiskUsageCard.tsx'
+import { DiskUsageCard } from '../environment/maintenance/DiskUsageCard.tsx'
 import { SkeletonList } from '../common/Skeleton.tsx'
 import { ConfirmDialog } from '../common/ConfirmDialog.tsx'
 import { Modal } from '../common/Modal.tsx'
@@ -36,15 +36,38 @@ import {
   sessionHealthRows,
   sessionHealthSummaryView,
   sessionHealthTruncated,
+  sessionRepairBatchEntry,
   sessionRepairCommands,
   sessionRepairEntries,
   sessionRepairReasonKey,
+  sessionRepairVerifyKey,
   type SessionHealthResponse,
+  type SessionRepairBatchEntryView,
   type SessionRepairEntryView,
   type SessionRepairResult,
 } from '../../ui/session-inventory-view.ts'
+import {
+  sessionLayoutApplyItems,
+  sessionLayoutCandidates,
+  sessionLayoutKeepState,
+  sessionLayoutOverallReasonKey,
+  sessionLayoutPlanDisplayRows,
+  sessionLayoutPlanSkippedCount,
+  sessionLayoutPlanSubmittable,
+  sessionLayoutResultCounts,
+  sessionLayoutSectionState,
+  type SessionLayoutApplyView,
+  type SessionLayoutPlanView,
+  type SessionLayoutPort,
+} from '../../ui/session-layout-view.ts'
+import {
+  sessionExportEntryState,
+  sessionExportReasonText,
+  type SessionExportProbe,
+} from '../session-export/session-export-view.ts'
 import { runStore, type RecoveryStoreSlice } from '../run-store.ts'
 import type { CrashReport, IncidentApi, RescueStatus } from './incident-api.ts'
+import { IncompleteCopiesSection } from './IncompleteCopiesSection.tsx'
 import {
   isSnapshotTrusted, isVerdictAttention, isVerdictSuccess, toRecoveryPreviewView,
   toRecoveryView,
@@ -53,12 +76,29 @@ import {
   formatRecoveryTime,
   rescueHintKey,
 } from './recovery-view.ts'
+import { redact } from '../../security/redaction.ts'
 import css from '../config-manager.module.css'
 
+/**
+ * 宿主/错误文本渲染前统一过 redact（AGENTS.md §UI 硬性规则 7；client-F4）。
+ * 单列成一行：plan-text-redaction.test.ts 的「按渲染点」登记表需要一个唯一锚点。
+ */
+const redactErrorText = (err: unknown): string => redact(err instanceof Error ? err.message : String(err))
+
+/**
+ * E2：布局归位端口 = `RecoveryPort` 的**可选**扩展（面板只用 `layoutRepairSessions`）。
+ *
+ * 为什么是 Partial：`src/ui/types.ts` 的 RecoveryPort 契约文件不在本次改动范围内，而注入的实现
+ * （`src/client/recovery/recovery-api.ts` 的 `RecoveryApi`）一定带这个方法。可选形态让所有既有
+ * 调用点（按 RecoveryPort 传值）原样可编译；运行时若真缺失，面板走 `sessions.layout.apiMissing`
+ * 如实提示并且**一条也不执行**，绝不假装有能力。
+ */
+type LayoutRecoveryApi = RecoveryPort & Partial<SessionLayoutPort>
+
 export interface RecoveryPanelProps {
   /** 事故处置（崩溃归因 + 救援模式）API；与 recoveryApi 同属「事故恢复」子 tab */
   incidentApi: IncidentApi
-  recoveryApi: RecoveryPort
+  recoveryApi: LayoutRecoveryApi
   t: TranslateNS<'config-manager-recovery'>
   /**
    * **主字典**（config-manager）翻译器 —— 仅供 CopyButton 这类「共用原语」使用：
@@ -216,7 +256,7 @@ function incidentStateLabel(t: TranslateNS<'config-manager-recovery'>, state: st
  */
 const EMPTY_COPY_T: TranslateNS<'config-manager'> = ((key: string) => key) as TranslateNS<'config-manager'>
 
-function SessionHealthCard({ recoveryApi, t, copyT }: Pick<RecoveryPanelProps, 'recoveryApi' | 't' | 'copyT'>) {
+function SessionHealthCard({ recoveryApi, t, copyT, diskApi }: Pick<RecoveryPanelProps, 'recoveryApi' | 't' | 'copyT' | 'diskApi'>) {
   /** 剪贴板反馈的翻译器（config-manager 命名空间；缺省退到 zhUiT 兜底）。 */
   const clipboardT = copyT ?? EMPTY_COPY_T
   /** 体检结果住**卡片**里：弹窗每次打开重新扫一遍（scanVersion 变化即重扫），关掉不留一屏陈旧数据。 */
@@ -226,6 +266,25 @@ function SessionHealthCard({ recoveryApi, t, copyT }: Pick<RecoveryPanelProps, '
   const [open, setOpen] = useState(false)
   const [scanVersion, setScanVersion] = useState(0)
   const scan = (): void => { setScanVersion((v) => v + 1) }
+  /**
+   * F-2：官方 session.export 端的可用性探测（一次；打开弹窗时顺带探）。
+   *
+   * 为什么**只在打开弹窗时**探：探测要走一次宿主自请求，用户没进这个界面时毫无意义；
+   * 而进程内缓存（setState 在卡片上）保证同一次对话里只探一次 —— 后端能力不会中途变化。
+   * 探测失败（网络/宿主异常）**不写 error**：它是「下载入口的可用性未知」，不是体检失败。
+   */
+  const [zipProbe, setZipProbe] = useState<SessionExportProbe | null>(null)
+  const zipChecked = useRef(false)
+  useEffect(() => {
+    if (!open || zipChecked.current) return
+    zipChecked.current = true
+    let alive = true
+    diskApi.sessionExportProbe()
+      .then((probe) => { if (alive) setZipProbe(probe) })
+      // 探测本身失败（宿主不可达等）→ 落到保守三态：**绝不**改判成不可用而把入口藏掉。
+      .catch(() => { if (alive) setZipProbe({ availability: 'unknown', reason: 'network-error', status: 0, path: '', checkedAt: new Date().toISOString() }) })
+    return () => { alive = false }
+  }, [open, diskApi])
 
   useEffect(() => {
     if (!open) return
@@ -279,6 +338,8 @@ function SessionHealthCard({ recoveryApi, t, copyT }: Pick<RecoveryPanelProps, '
           loading={loading}
           error={error}
           onScan={scan}
+          zipProbe={zipProbe}
+          api={diskApi}
         />
       )}
     </Card>
@@ -292,35 +353,261 @@ function SessionHealthCard({ recoveryApi, t, copyT }: Pick<RecoveryPanelProps, '
  * 交互约定：打开即扫（scanVersion 变化重扫）；修复一律先 dry-run 预览（零写入），有损计划必须再点
  * 「截断并修复」才执行；回滚走 ConfirmDialog（danger）。
  */
-/** 批量修复里的一条结果（成功或被拒；原因是机器可读码，界面映射成文案）。 */
-interface BatchRepairResult {
-  unitId: string
-  sessionId: string
-  ok: boolean
-  /** 被拒原因（机器可读；未知一律走 unknown 文案，绝不渲染裸枚举） */
-  reason?: string
-  /** 被拒是「需要逐个确认的有损修复」 */
-  lossy?: boolean
-  /** 成功时丢弃的行数 */
-  droppedRows?: number
-  /** 传输层失败（HTTP/网络）时的原文（已由 ErrorBanner/http 层脱敏） */
-  transportError?: string
-}
-
 interface SessionHealthDialogProps {
   open: boolean
   onClose: () => void
-  recoveryApi: RecoveryPort
+  recoveryApi: LayoutRecoveryApi
   t: TranslateNS<'config-manager-recovery'>
   clipboardT: TranslateNS<'config-manager'>
   response: SessionHealthResponse | null
   loading: boolean
   error: string | null
   onScan: () => void
+  /** F-2：官方 session.export 的可用性（null = 还没探出来 → 入口显示加载态，不误判禁用）。 */
+  zipProbe: SessionExportProbe | null
+  /** 供「下载原始日志 (ZIP)」拼下载地址（同一份 api 实例，别新起一个）。 */
+  api: import('../api.ts').ConfigManagerApi
+}
+
+/**
+ * E2：面板「会话布局归位 / 重复 id 隔离」写入口（宿主 E1：`POST /recovery/sessions/layout`）。
+ *
+ * 与字节级修复（/repair）的分工：那条改日志**字节**，这条改**位置** —— 把会话目录搬回首帧 cwd
+ * 对应的 projectKey 段，并把重复 id 的其它副本移进隔离目录（可人工找回）。
+ *
+ * 安全口径（键 `sessions.layout.runtimeNote`，必须让用户看见）：本入口在 **DSH 运行时**执行，
+ * 与离线 CLI `dcm sessions repair --fix` 的「须先停 DSH」不同 —— 靠门前置（SAFE MODE / mutation lock /
+ * 逐目标无 session.lock + 不在静止期）+ 索引刷新必须成功 + 失败逐条回滚兜底；宿主没给索引刷新端口时
+ * **一条也不执行**（`reindex-unavailable`，绝不显示成成功）。
+ *
+ * 硬约束：**本组件不做任何业务判断** —— 候选筛选 / keep 完整性 / 可否提交 / 逐条状态与计数全在
+ * `ui/session-layout-view.ts`（含「未执行 / 已回滚不得算成功」的判定），组件只装配与渲染。
+ */
+interface SessionLayoutSectionProps {
+  recoveryApi: LayoutRecoveryApi
+  t: TranslateNS<'config-manager-recovery'>
+  response: SessionHealthResponse | null
+  /** 执行后重扫列表（结果已落盘，列表必须跟着刷新） */
+  onScan: () => void
+}
+
+function SessionLayoutSection({ recoveryApi, t, response, onScan }: SessionLayoutSectionProps) {
+  const [plan, setPlan] = useState<SessionLayoutPlanView | null>(null)
+  const [applied, setApplied] = useState<SessionLayoutApplyView | null>(null)
+  /** sessionId → 用户选定保留的副本 unitId（提交判定在 sessionLayoutKeepState） */
+  const [keep, setKeep] = useState<Record<string, string>>({})
+  const [busy, setBusy] = useState<'preview' | 'apply' | null>(null)
+  /** 客户端/传输层失败（宿主的拒绝走结果里的机器码，不进这里） */
+  const [failure, setFailure] = useState<string | null>(null)
+
+  const candidates = sessionLayoutCandidates(response)
+  const keepState = sessionLayoutKeepState(plan, keep)
+  const submittable = sessionLayoutPlanSubmittable(plan, keepState)
+  const planRows = sessionLayoutPlanDisplayRows(plan)
+  const skippedCount = sessionLayoutPlanSkippedCount(plan)
+  const planReasonKey = sessionLayoutOverallReasonKey(plan?.reason)
+  const appliedReasonKey = sessionLayoutOverallReasonKey(applied?.reason)
+  const appliedItems = sessionLayoutApplyItems(applied)
+  const counts = sessionLayoutResultCounts(appliedItems)
+
+  const preview = (): void => {
+    if (busy !== null) return
+    setBusy('preview')
+    setFailure(null)
+    const request = recoveryApi.layoutRepairSessions?.(false)
+    if (request === undefined) {
+      setFailure(t('sessions.layout.apiMissing'))
+      setBusy(null)
+      return
+    }
+    request
+      .then((next) => {
+        if ('results' in next) { setApplied(next); return }
+        setPlan(next)
+        setKeep({})
+        setApplied(null)
+      })
+      .catch((err) => { setFailure(redactErrorText(err)) })
+      .finally(() => { setBusy(null) })
+  }
+
+  const apply = (): void => {
+    if (busy !== null || !submittable) return
+    setBusy('apply')
+    setFailure(null)
+    const request = recoveryApi.layoutRepairSessions?.(true, keep)
+    if (request === undefined) {
+      setFailure(t('sessions.layout.apiMissing'))
+      setBusy(null)
+      return
+    }
+    request
+      .then((next) => {
+        if ('results' in next) {
+          setApplied(next)
+          // 结果已落盘（含逐条回滚）：重扫列表是唯一权威，结果视图保留到用户关闭
+          onScan()
+          return
+        }
+        setPlan(next)
+        setKeep({})
+        setApplied(null)
+      })
+      .catch((err) => { setFailure(redactErrorText(err)) })
+      .finally(() => { setBusy(null) })
+  }
+
+  // 扫过之后入口**始终可见**（否则本机没有这一档的用户根本找不到它）；只有「还没扫过且手上没计划/结果」才隐藏。
+  const sectionState = sessionLayoutSectionState({ response, plan, applied })
+  if (sectionState === 'hidden') return null
+
+  return (
+    <div className={css.card}>
+      <div className={css.groupLabel}>{t('sessions.layout.title')}</div>
+      <div className={css.hint}>{t('sessions.layout.desc')}</div>
+      {/* 口径：本入口跑在 DSH 运行时 —— 与离线 CLI 的「须先停 DSH」不同，必须让用户看见 */}
+      <div className={css.hint}>{t('sessions.layout.runtimeNote')}</div>
+      <div className={css.hint}>{t('sessions.layout.quarantineNote')}</div>
+      {sectionState === 'empty' && <div className={css.hint}>{t('sessions.layout.noCandidates')}</div>}
+      {candidates.length > 0 && (
+        <div className={css.snapshotList + ' ' + css.reportScroll}>
+          {candidates.map((candidate) => (
+            <div key={candidate.unitId} className={css.snapshotRow}>
+              <span className={css.snapshotRowMain} title={candidate.unitId}>{candidate.sessionId}</span>
+              <span className={css.snapshotRowFacts}>
+                {candidate.issueCodes.join(' · ')} · {candidate.projectKey}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
+      <div className={css.actionRow}>
+        <Button variant="ghost" loading={busy === 'preview'} disabled={busy !== null} onClick={preview}>
+          {busy === 'preview' ? t('sessions.layout.previewing') : t('sessions.layout.preview')}
+        </Button>
+      </div>
+      {failure !== null && <Banner kind="error">{failure}</Banner>}
+      {applied === null && plan !== null && (
+        <>
+          <div className={css.groupLabel}>{t('sessions.layout.planTitle')}</div>
+          {/* 计划只读：确认前零写入 */}
+          <div className={css.hint}>{t('sessions.layout.planReadOnly')}</div>
+          {planReasonKey !== null && <Banner kind="warn">{t(planReasonKey)}</Banner>}
+          <div className={css.hint}>
+            {t('sessions.layout.summary', { move: String(plan.summary.move), quarantine: String(plan.summary.quarantine) })}
+          </div>
+          {planRows.length === 0 && <div className={css.hint}>{t('sessions.layout.planEmpty')}</div>}
+          {planRows.length > 0 && (
+            <div className={css.snapshotList + ' ' + css.reportScroll}>
+              {planRows.map((row) => (
+                <div key={row.unitId} className={css.snapshotRow}>
+              <span className={css.snapshotRowBadges}>
+                <Badge kind="info">{t(row.kindKey)}</Badge>
+                {row.kind === 'skip' && <Badge kind="warn">{t('sessions.layout.onlyReported')}</Badge>}
+              </span>
+              <span className={css.snapshotRowIssues} title={row.unitId}>{row.sessionId}</span>
+              <span className={css.snapshotRowFacts}>
+                {row.toProjectKey !== null ? row.fromProjectKey + ' → ' + row.toProjectKey : row.fromProjectKey}
+                {' · '}
+                {t(row.reasonKey)}
+              </span>
+            </div>
+              ))}
+            </div>
+          )}
+          {skippedCount > 0 && (
+            <div className={css.hint}>{t('sessions.layout.planSkipped', { count: String(skippedCount) })}</div>
+          )}
+          {/* 重复 id：必须选定保留哪一份才可提交（判定在 ui 纯函数层） */}
+          {plan.needsKeep.length > 0 && (
+            <>
+              <div className={css.groupLabel}>{t('sessions.layout.keepTitle')}</div>
+              <div className={css.hint}>{t('sessions.layout.keepHint')}</div>
+              {plan.needsKeep.map((sessionId) => (
+                <div key={sessionId} className={css.conflictChoices} role="radiogroup" aria-label={sessionId}>
+                  {(keepState.candidates[sessionId] ?? []).map((unitId) => {
+                    const selected = keep[sessionId] === unitId
+                    return (
+                      <label key={unitId} className={css.choiceCard} data-selected={selected ? '' : undefined}>
+                        <input
+                          type="radio"
+                          name={'layout-keep-' + sessionId}
+                          checked={selected}
+                          onChange={() => { setKeep((prev) => ({ ...prev, [sessionId]: unitId })) }}
+                        />
+                        <span className={css.choiceTitle}>{unitId}</span>
+                      </label>
+                    )
+                  })}
+                </div>
+              ))}
+              {!keepState.complete && (
+                <div className={css.hint}>{t('sessions.layout.keepMissing', { count: String(keepState.missing.length) })}</div>
+              )}
+            </>
+          )}
+          <div className={css.actionRow}>
+            {/* 未选定 keep / 计划不可用 ⇒ 不可提交（判定在 ui 纯函数层） */}
+            <Button variant="primary" loading={busy === 'apply'} disabled={busy !== null || !submittable} onClick={apply}>
+              {busy === 'apply' ? t('sessions.layout.applying') : t('sessions.layout.apply')}
+            </Button>
+          </div>
+        </>
+      )}
+      {applied !== null && (
+        <>
+          <div className={css.groupLabel}>{t('sessions.layout.resultTitle')}</div>
+          {/* 整体未执行（如 reindex-unavailable）**不是**成功：单独说明，且下面不会有任何成功条目 */}
+          {appliedReasonKey !== null && <Banner kind="warn">{t(appliedReasonKey)}</Banner>}
+          {appliedItems.length > 0 && (
+            <div className={css.hint}>
+              {t('sessions.layout.done', {
+                moved: String(counts.moved),
+                quarantined: String(counts.quarantined),
+                failed: String(counts.failedTotal),
+                skipped: String(counts.skipped),
+              })}
+            </div>
+          )}
+          {appliedItems.length > 0 && (
+            <div className={css.snapshotList + ' ' + css.reportScroll}>
+              {appliedItems.map((item, index) => (
+                <div key={item.unitId + '#' + String(index)} className={css.snapshotRow}>
+              <span className={css.snapshotRowBadges}>
+                <Badge kind={item.badgeKind}>{t(item.statusKey)}</Badge>
+              </span>
+              <span className={css.snapshotRowIssues} title={item.unitId}>{item.sessionId}</span>
+              <span className={css.snapshotRowFacts}>
+                {item.reasonKey !== null ? t(item.reasonKey) : ''}
+                {item.movedUnitId !== null ? ' → ' + item.movedUnitId : ''}
+                {item.quarantineDir !== null ? ' → ' + item.quarantineDir : ''}
+              </span>
+            </div>
+              ))}
+            </div>
+          )}
+          <div className={css.hint}>{t('sessions.layout.refreshHint')}</div>
+          <div className={css.actionRow}>
+            <Button variant="ghost" onClick={() => { setApplied(null); setPlan(null); setKeep({}) }}>
+              {t('sessions.layout.close')}
+            </Button>
+          </div>
+        </>
+      )}
+    </div>
+  )
 }
 
 function SessionHealthDialog(props: SessionHealthDialogProps) {
-  const { open, onClose, recoveryApi, t, clipboardT, response, loading, error, onScan } = props
+  const { open, onClose, recoveryApi, t, clipboardT, response, loading, error, onScan, zipProbe, api } = props
+  /**
+   * F-2：「下载原始日志 (ZIP)」入口的三态判定（**唯一**判定点在 ui/ 纯函数里，组件只映射）。
+   *
+   * 为什么不在组件里判 `status !== 501`（竞品做法）：那条判据在本机 DSH 上**已过时** ——
+   * 服务缺失返的是 500 而不是 501，照抄会让入口几乎恒显示。判定与理由见 session-export-view.ts。
+   */
+  const zipState = sessionExportEntryState(zipProbe)
+  const zipHint = sessionExportReasonText(zipState, t)
   const phase = sessionHealthPhase({ loading, error, response })
   /**
    * 本地的「已修复」行集合：批量/单条修复成功后**就地更新界面**，不再整屏重扫。
@@ -341,8 +628,38 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
   const repairEntries = sessionRepairEntries(response)
   /** 正在预览 / 应用 / 回滚的 unitId（进行中态住组件内；弹窗不跨页签） */
   const [busy, setBusy] = useState<string | null>(null)
+  /**
+   * F-2：正在下载原始日志的会话 id（进行中态住组件内 —— 弹窗不跨页签，无需进 runStore）。
+   *
+   * 为什么必须有：ZIP 可达数百 MB，点下去到浏览器开始落盘之间可能好几秒，
+   * 没有任何反馈会被当成「点了没反应」而反复点击。
+   */
+  const [zipBusy, setZipBusy] = useState<string | null>(null)
+  /** 触发一次 ZIP 下载；**失败必须显式报告**（绝不静默）。 */
+  const downloadZip = (sessionId: string): void => {
+    if (zipBusy !== null) return
+    setZipBusy(sessionId)
+    api.downloadSessionExport(sessionId)
+      .then((result) => { toast.ok(t('sessions.zip.done', { name: result.filename })) })
+      // 错误文本走 toast（与本节其它动作同一口径；http 层已脱敏）。
+      .catch((err) => { toast.error(t('sessions.zip.failed') + ': ' + redactErrorText(err)) })
+      .finally(() => { setZipBusy(null) })
+  }
   /** 预览得到的修复计划（应用前必须显式确认；ok=false 时也在这里显示拒绝原因） */
   const [plan, setPlan] = useState<{ unitId: string; result: SessionRepairResult } | null>(null)
+  /**
+   * 应用成功后的结果（含写后真 codec 复验结论）。
+   *
+   * 为什么必须有：修复「写完了」与「DSH 现在能读它」是两件事 —— 没有复验结论时（如 unavailable）
+   * 把这次修复当成普通成功呈现，正是本轮要消灭的谎报。行已从列表移出，所以结果留在这里。
+   */
+  const [applied, setApplied] = useState<{ unitId: string; result: SessionRepairResult } | null>(null)
+  /**
+   * 复验三态 / 危险态的字典键（**判定全部在 ui 纯函数层**，组件只装配 —— 见 sessionRepairVerifyKey）。
+   * null = 没有复验结论（预览路径）⇒ 不渲染这一行，绝不臆造「已验证」。
+   */
+  const planVerifyKey = plan !== null ? sessionRepairVerifyKey(plan.result.verify, plan.result.rolledBack) : null
+  const appliedVerifyKey = applied !== null ? sessionRepairVerifyKey(applied.result.verify, applied.result.rolledBack) : null
   /** 待确认的回滚目标（ConfirmDialog，danger） */
   const [rollbackTarget, setRollbackTarget] = useState<SessionRepairEntryView | null>(null)
   /**
@@ -352,14 +669,15 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
    * 「哪几条成了、哪几条为什么没成」，绝不只给一个计数。
    */
   const [batchBusy, setBatchBusy] = useState(false)
-  const [batch, setBatch] = useState<{ ok: number; failed: number; results: BatchRepairResult[] } | null>(null)
+  const [batch, setBatch] = useState<{ ok: number; failed: number; results: SessionRepairBatchEntryView[] } | null>(null)
 
   const startRepair = (unitId: string): void => {
     setBusy(unitId)
     setPlan(null)
+    setApplied(null)
     recoveryApi.repairSession(unitId, false)
       .then((result) => { setPlan({ unitId, result }); setBusy(null) })
-      .catch((err) => { toast.error(err instanceof Error ? err.message : String(err)); setBusy(null) })
+      .catch((err) => { toast.error(redactErrorText(err)); setBusy(null) })
   }
 
   /**
@@ -376,7 +694,7 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
     setBatch(null)
     let ok = 0
     let failed = 0
-    const results: BatchRepairResult[] = []
+    const results: SessionRepairBatchEntryView[] = []
     const done: string[] = []
     for (const unitId of targets) {
       setBusy(unitId)
@@ -384,27 +702,53 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
         const plan = await recoveryApi.repairSession(unitId, false)
         if (!plan.ok) {
           failed += 1
-          results.push({ unitId, sessionId: plan.sessionId ?? unitId, ok: false, reason: plan.reason })
+          results.push(sessionRepairBatchEntry({
+            unitId,
+            sessionId: plan.sessionId ?? unitId,
+            ok: false,
+            ...(plan.reason !== undefined ? { reason: plan.reason } : {}),
+          }))
           continue
         }
         if (plan.lossy === true) {
           // 有损（截断）绝不批量代做 —— 逐条确认是硬约束，这里如实说明「需要你逐条确认」
           failed += 1
-          results.push({ unitId, sessionId: plan.sessionId ?? unitId, ok: false, reason: 'lossy-required', lossy: true })
+          results.push(sessionRepairBatchEntry({ unitId, sessionId: plan.sessionId ?? unitId, ok: false, reason: 'lossy-required', lossy: true }))
           continue
         }
         const applied = await recoveryApi.repairSession(unitId, true, plan.expect)
         if (applied.ok) {
           ok += 1
           done.push(unitId)
-          results.push({ unitId, sessionId: applied.sessionId ?? unitId, ok: true, droppedRows: applied.droppedRows ?? 0 })
+          results.push(sessionRepairBatchEntry({
+            unitId,
+            sessionId: applied.sessionId ?? unitId,
+            ok: true,
+            droppedRows: applied.droppedRows ?? 0,
+            ...(applied.verify !== undefined ? { verify: applied.verify } : {}),
+            ...(applied.rolledBack !== undefined ? { rolledBack: applied.rolledBack } : {}),
+          }))
         } else {
           failed += 1
-          results.push({ unitId, sessionId: applied.sessionId ?? unitId, ok: false, reason: applied.reason })
+          // A2-F1：失败分支与成功分支**同源**搬运 —— verify-failed 必带 verify，
+          // rolledBack===false（自动回滚未成功）是危险态，必须在批量视图里可见。
+          results.push(sessionRepairBatchEntry({
+            unitId,
+            sessionId: applied.sessionId ?? unitId,
+            ok: false,
+            ...(applied.reason !== undefined ? { reason: applied.reason } : {}),
+            ...(applied.verify !== undefined ? { verify: applied.verify } : {}),
+            ...(applied.rolledBack !== undefined ? { rolledBack: applied.rolledBack } : {}),
+          }))
         }
       } catch (err) {
         failed += 1
-        results.push({ unitId, sessionId: unitId, ok: false, transportError: err instanceof Error ? err.message : String(err) })
+        results.push(sessionRepairBatchEntry({
+          unitId,
+          sessionId: unitId,
+          ok: false,
+          transportError: err instanceof Error ? err.message : String(err),
+        }))
       }
     }
     setBusy(null)
@@ -425,6 +769,8 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
         if (next.ok) {
           toast.ok(t('sessions.repair.applied', { rows: String(next.droppedRows ?? 0) }))
           setPlan(null)
+          // 结果（含复验三态）留在面板上：绝不把「写完了」说成「已可加载」
+          setApplied({ unitId, result: next })
           setRepairedUnits((prev) => new Set([...prev, unitId]))
         } else {
           // 应用期被拒（指纹变化 / 校验不过 / 写失败）：**就地给出真实原因**，不假装成功
@@ -432,7 +778,7 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
         }
         setBusy(null)
       })
-      .catch((err) => { toast.error(err instanceof Error ? err.message : String(err)); setBusy(null) })
+      .catch((err) => { toast.error(redactErrorText(err)); setBusy(null) })
   }
 
   const doRollback = async (): Promise<void> => {
@@ -450,7 +796,7 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
         setRollbackTarget(null)
       }
     } catch (err) {
-      toast.error(err instanceof Error ? err.message : String(err))
+      toast.error(redactErrorText(err))
       setRollbackTarget(null)
     } finally {
       setBusy(null)
@@ -468,6 +814,15 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
             </Button>
           </div>
 
+          {/*
+            F-2：官方 session.export 通道的**可用性说明**（逐行入口见下方列表）。
+            ZIP 由 DSH 自己打包（含子会话与附件）；体检/修复动的是本机文件，两者不是一回事。
+            不可用时界面给出**可读原因**，绝不静默消失（消失会让用户以为插件根本没做这个功能）。
+          */}
+          {zipHint !== null && (
+            <Banner kind="warn">{zipHint}</Banner>
+          )}
+
           {phase === 'error' && <Banner kind="error">{error ?? t('common.unknownError')}</Banner>}
 
           {phase === 'ready' && response !== null && (
@@ -496,6 +851,14 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
                       <Badge kind="info">{t('sessions.targetFormat', { version: String(summary.targetFormatVersion) })}</Badge>
                     )}
                   </div>
+                  {/* E2：本档（blocksStartup 的 location-mismatch / duplicate-id）的**应用内写入口**。
+                      只在有候选行或手上有计划/结果时渲染；判定与键映射全在 ui/session-layout-view.ts。 */}
+                  <SessionLayoutSection
+                    recoveryApi={recoveryApi}
+                    t={t}
+                    response={response}
+                    onScan={onScan}
+                  />
                   <div className={css.hint}>
                     {summary.repairable > 0
                       ? t('sessions.repair.available', { count: String(summary.repairable) })
@@ -524,25 +887,31 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
                           {t('sessions.repair.allDone', { ok: String(batch.ok), failed: String(batch.failed) })}
                         </span>
                         {/* 逐条留痕：修好了几条、剩下几条为什么没修成 —— 绝不只给一个计数 */}
-                        {batch.results.map((item) => (
-                          <div key={item.unitId} className={css.snapshotRowMeta}>
-                            <span className={css.snapshotRowBadges}>
-                              <Badge kind={item.ok ? 'ok' : 'warn'}>
-                                {item.ok ? t('sessions.repair.batch.ok') : t('sessions.repair.batch.failed')}
-                              </Badge>
-                            </span>
-                            <span className={css.snapshotRowIssues} title={item.unitId}>{item.sessionId}</span>
-                            <span className={css.snapshotRowFacts}>
-                              {item.ok
-                                ? t('sessions.repair.batch.dropped', { rows: String(item.droppedRows ?? 0) })
-                                : item.transportError !== undefined
-                                  ? t('sessions.repair.batch.transportError', { message: item.transportError })
-                                  : item.lossy === true
-                                    ? t('sessions.repair.reason.lossyRequired')
-                                    : t(sessionRepairReasonKey(item.reason))}
-                            </span>
-                          </div>
-                        ))}
+                        {batch.results.map((item) => {
+                          // 一键修复的成功项同样要说出复验结论（三态判定在 ui 纯函数层，组件只查字典）
+                          // 与单条修复路径同一个纯函数、同一套 locale 键（失败项也必须给出复验结论）
+                          const verifyKey = sessionRepairVerifyKey(item.verify, item.rolledBack)
+                          return (
+                            <div key={item.unitId} className={css.snapshotRowMeta}>
+                              <span className={css.snapshotRowBadges}>
+                                <Badge kind={item.ok ? 'ok' : 'warn'}>
+                                  {item.ok ? t('sessions.repair.batch.ok') : t('sessions.repair.batch.failed')}
+                                </Badge>
+                              </span>
+                              <span className={css.snapshotRowIssues} title={item.unitId}>{item.sessionId}</span>
+                              <span className={css.snapshotRowFacts}>
+                                {item.ok
+                                  ? t('sessions.repair.batch.dropped', { rows: String(item.droppedRows ?? 0) })
+                                  : item.transportError !== undefined
+                                    ? t('sessions.repair.batch.transportError', { message: item.transportError })
+                                    : item.lossy === true
+                                      ? t('sessions.repair.reason.lossyRequired')
+                                      : t(sessionRepairReasonKey(item.reason))}
+                                {verifyKey !== null && <> · {t(verifyKey)}</>}
+                              </span>
+                            </div>
+                          )
+                        })}
                       </div>
                     </div>
                   )}
@@ -591,6 +960,20 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
                             </Button>
                           </div>
                         )}
+                        {/* F-2：下载该会话的原始日志 ZIP（**只读**；由 DSH 自己打包，含子会话与附件）。
+                            不可用时**禁用并给出原因**（不静默消失）—— 三态判定在 session-export-view.ts。 */}
+                        <div className={css.actionRow}>
+                          <Button
+                            variant="ghost"
+                            size="sm"
+                            disabled={!zipState.enabled || zipBusy !== null}
+                            loading={zipBusy === row.sessionId}
+                            title={zipHint ?? t('sessions.zip.hint')}
+                            onClick={() => { downloadZip(row.sessionId) }}
+                          >
+                            {t('sessions.zip.action')}
+                          </Button>
+                        </div>
                       </div>
                     ))}
                   </div>
@@ -630,6 +1013,9 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
                           <div className={css.hint}>{t('sessions.repair.rejectedNext')}</div>
                         </>
                       )}
+                      {/* 写后真 codec 复验结论（现役读盘可读 / 迁移链可还原 / 未验证 / 回滚失败）——
+                          key 由 ui 纯函数判定，组件不写三态逻辑 */}
+                      {planVerifyKey !== null && <div className={css.hint}>{t(planVerifyKey)}</div>}
                       <div className={css.actionRow}>
                         {plan.result.ok && (
                           <Button variant="primary" loading={busy !== null} onClick={applyRepair}>
@@ -642,6 +1028,23 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
                       </div>
                     </div>
                   )}
+                  {/* 应用成功后的结果（含真 codec 复验结论）：绝不把「写完了」说成「已可加载」 */}
+                  {applied !== null && (
+                    <div className={css.snapshotRow}>
+                      <div className={css.snapshotRowMain}>
+                        <span title={applied.unitId}>{applied.result.sessionId ?? applied.unitId}</span>
+                      </div>
+                      <div className={css.hint}>
+                        {t('sessions.repair.applied', { rows: String(applied.result.droppedRows ?? 0) })}
+                      </div>
+                      {appliedVerifyKey !== null && <div className={css.hint}>{t(appliedVerifyKey)}</div>}
+                      <div className={css.actionRow}>
+                        <Button variant="ghost" onClick={() => { setApplied(null) }}>
+                          {t('common.close')}
+                        </Button>
+                      </div>
+                    </div>
+                  )}
                   {/* 应用内不动的问题类别：离线出路 */}
                   <div className={css.groupLabel}>{t('sessions.repair.title')}</div>
                   <div className={css.hint}>{t('sessions.repair.desc')}</div>
@@ -781,13 +1184,13 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
     incidentApi.rescueOn().then(
       (res) => {
         setRescueBusy(false)
-        if (!res.ok) { toast.error(res.message ?? t('common.unknownError')); return }
+        if (!res.ok) { toast.error(redact(res.message ?? t('common.unknownError'))); return }
         toast.ok(t('recovery.rescue.on'))
         loadIncident()
       },
       (err) => {
         setRescueBusy(false)
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
       },
     )
   }
@@ -798,13 +1201,13 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
     incidentApi.rescueOff().then(
       (res) => {
         setRescueBusy(false)
-        if (!res.ok) { toast.error(res.message ?? t('common.unknownError')); return }
+        if (!res.ok) { toast.error(redact(res.message ?? t('common.unknownError'))); return }
         toast.ok(t('recovery.rescue.off'))
         loadIncident()
       },
       (err) => {
         setRescueBusy(false)
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
       },
     )
   }
@@ -845,7 +1248,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
         patch({ running: false })
         runStore.stopRunWatch('recovery')
         // 确认弹窗已关闭 → 用 Toast 送达（写 panel state 将无渲染点）
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
         return null
       },
     ).then((verifyResult) => {
@@ -872,7 +1275,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
       (err) => {
         patch({ running: false })
         runStore.stopRunWatch('recovery')
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
         return null
       },
     ).then((verifyResult) => {
@@ -899,7 +1302,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
       },
       (err) => {
         patch({ running: false })
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
       },
     )
   }
@@ -919,7 +1322,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
       },
       (err) => {
         setLockBusy(false)
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
       },
     )
   }
@@ -942,7 +1345,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
       },
       (err) => {
         setSafeModeBusy(false)
-        toast.error(err instanceof Error ? err.message : String(err))
+        toast.error(redactErrorText(err))
       },
     )
   }
@@ -998,13 +1401,37 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
         </Card>
       )}
 
+      {/* t54：中断的档案复制残留（cross-F3）—— 独立形态 + 只给删除；删除走既有 POST /profiles/delete，
+          被 SAFE MODE 拦下（423 mutation-locked）时给原因与本页出口（safe-mode/clear）。 */}
+      {view !== null && view.incompleteCopies.length > 0 && (
+        <IncompleteCopiesSection
+          rows={view.incompleteCopies}
+          t={t}
+          diskApi={props.diskApi}
+          recoveryApi={props.recoveryApi}
+          onChanged={load}
+        />
+      )}
+
+      {/* t89：残留**枚举失败** —— 与上面「有残留」和「暂无残留」都不同形：显式告知「读不到 ≠ 没有」，
+          并给唯一的可行动作（重试 = 重拉 /recovery/status）。判定在 recovery-view.ts 的纯函数里，这里只装配。 */}
+      {view !== null && view.incompleteCopiesNotice === 'unreadable' && (
+        <Card>
+          <SectionTitle title={t('recovery.incomplete.unreadable.title')} />
+          <Banner kind="warn">{t('recovery.incomplete.unreadable.hint')}</Banner>
+          <div className={css.actionRow}>
+            <Button onClick={load}>{t('common.retry')}</Button>
+          </div>
+        </Card>
+      )}
+
       {/* 磁盘占用与清理（m-disk-usage）：§9 固定的第 2 块。
            三条硬边界一字不动（候选集只有可重建区 + 显式勾选的过期导出；snapshots/sync 永不在候选集；
            界面数字由渲染行现算）—— 实现全在 DiskUsageCard 与 ui/disk-usage-view.ts 里。 */}
       <DiskUsageCard api={props.diskApi} infoHintLabel={props.infoHintLabel ?? props.t('common.infoHint')} />
 
       {/* T5：会话体检（只读）—— 与「我的对话去哪了」是同一件事，故与事故恢复同屏 */}
-      <SessionHealthCard recoveryApi={recoveryApi} t={t} copyT={props.copyT} />
+      <SessionHealthCard recoveryApi={recoveryApi} t={t} copyT={props.copyT} diskApi={props.diskApi} />
 
       {/* SAFE MODE / recovery-required 状态提示（正常态不渲染任何横幅——无事项即静默） */}
       {view?.recoveryRequired === true && (