dsh-config-manager 0.1.71 → 0.1.72

package/src/core/session-title.ts

@@ -0,0 +1,189 @@
+/**
+ * 「会话标题」的**日志兜底**（2026-10-12 用户要求：缓存里没有这条会话，就自动读这条会话自己的名字）。
+ *
+ * 两条来源，优先级固定：
+ *  ① `storages/session_projcache.json` 的 `rows.title.val`（`core/session-meta.ts` 的索引，快、覆盖常态）；
+ *  ② **会话日志里的 `session/title` 事件**（本模块）—— DSH 自己写的标题事件，
+ *     `data = { title, messageSeqs, source }`；`source = 'user'` 表示用户显式改过名（它压过自动生成的那条）。
+ *     缓存里没有这条会话（旧会话 / 别的档案写的 / 子代理会话）时，这是**唯一不猜**的名字来源。
+ *
+ * 只读 + 有界 + 诚实：
+ *  · 只读日志**前** {@link SESSION_TITLE_SCAN_BYTES}（1 MiB，覆盖「标题在开头几回合内生成」的常态）；
+ *    超出这个窗口的标题事件读不到 → 返回 null，界面回落显示会话 id（**绝不从首条消息编造标题**）；
+ *  · 同一个会话出现多条标题事件时取**最后一条**（用户改名压过自动标题）；
+ *  · 同一条日志按 `mtime + size` 缓存在进程内：日志增长（新标题落盘）后自动重读，不吃陈旧结论；
+ *  · 一次请求最多补 {@link SESSION_TITLE_MAX_READS} 个会话（台账里几十条缺标题时不把盘读穿）。
+ */
+import { open, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { isSessionLogName } from '../utils/session-log.ts';
+import { decodeZstdFrame, scanZstdFrames, zstdAvailable } from '../utils/zstd-frame.ts';
+
+/** 只扫日志前这么多字节（标题通常在开头几回合内写入；更大的日志只扫前缀，读不到就回落 id）。 */
+export const SESSION_TITLE_SCAN_BYTES = 1024 * 1024;
+
+/** 一次请求最多为几个会话做日志兜底（按 unitId 去重之后）。 */
+export const SESSION_TITLE_MAX_READS = 24;
+
+interface TitleCacheEntry {
+  mtimeMs: number;
+  size: number;
+  title: string | null;
+}
+
+/** 进程内缓存：绝对路径 → （mtime + size + 结论）。日志一增长就失效（不吃陈旧结论）。 */
+const titleCache = new Map<string, TitleCacheEntry>();
+
+/** 清空缓存（单测用；宿主进程内长期有效是刻意的）。 */
+export function clearSessionTitleCache(): void {
+  titleCache.clear();
+}
+
+/** `session/title` 事件行 → 标题（形状不对 / 空标题一律 null，绝不猜）。 */
+function titleOfRow(row: unknown): string | null {
+  if (row === null || typeof row !== 'object' || Array.isArray(row)) return null;
+  const rec = row as Record<string, unknown>;
+  if (rec['type'] !== 'session/title') return null;
+  const data = rec['data'];
+  if (data === null || typeof data !== 'object' || Array.isArray(data)) return null;
+  const title = (data as Record<string, unknown>)['title'];
+  return typeof title === 'string' && title.trim() !== '' ? title.trim() : null;
+}
+
+/** 只读日志**前缀**（最多 `max` 字节；读不出回 null，绝不抛）。 */
+async function readPrefix(absPath: string, max: number): Promise<Buffer | null> {
+  let handle: Awaited<ReturnType<typeof open>>;
+  try {
+    handle = await open(absPath, 'r');
+  } catch {
+    return null;
+  }
+  try {
+    const buffer = Buffer.allocUnsafe(max);
+    const { bytesRead } = await handle.read(buffer, 0, max, 0);
+    return buffer.subarray(0, bytesRead);
+  } catch {
+    return null;
+  } finally {
+    await handle.close().catch(() => undefined);
+  }
+}
+
+/**
+ * 从会话日志字节里取标题：解出每个**完整**帧，逐行先做 `session/title` 子串预筛（省掉整篇 JSON.parse），
+ * 命中才解析该行；多条命中取最后一条。容器损坏 / 无 zstd 能力 → null。
+ */
+function titleFromBytes(bytes: Uint8Array): string | null {
+  let frames: { start: number; end: number }[];
+  try {
+    frames = scanZstdFrames(bytes).frames;
+  } catch {
+    return null;
+  }
+  let found: string | null = null;
+  for (const frame of frames) {
+    let text: string;
+    try {
+      text = decodeZstdFrame(bytes.subarray(frame.start, frame.end)).toString('utf8');
+    } catch {
+      return found;
+    }
+    for (const line of text.split('\n')) {
+      if (line === '' || !line.includes('session/title')) continue;
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const title = titleOfRow(parsed);
+      if (title !== null) found = title;
+    }
+  }
+  return found;
+}
+
+/** 读单个日志文件的标题（带 mtime+size 缓存）。 */
+async function readTitleFromLogFile(absPath: string): Promise<string | null> {
+  if (!zstdAvailable()) return null;
+  const info = await stat(absPath).catch(() => null);
+  if (info === null) return null;
+  const cached = titleCache.get(absPath);
+  if (cached !== undefined && cached.mtimeMs === info.mtimeMs && cached.size === info.size) return cached.title;
+  const prefix = await readPrefix(absPath, SESSION_TITLE_SCAN_BYTES);
+  const title = prefix === null ? null : titleFromBytes(prefix);
+  titleCache.set(absPath, { mtimeMs: info.mtimeMs, size: info.size, title });
+  return title;
+}
+
+/** `unitId`（`<projectKey>/<sessionId>`）→ 目录段；越界 / 形状不符一律 null（绝不拼可疑路径）。 */
+function unitSegments(unitId: string): string[] | null {
+  const parts = unitId.split('/').filter((part) => part !== '');
+  if (parts.length < 2) return null;
+  for (const part of parts) {
+    if (part === '.' || part === '..' || part.includes('\\') || part.includes(':')) return null;
+  }
+  return parts;
+}
+
+/**
+ * 从会话日志里读这条会话自己的名字（`session/title` 事件）。
+ *
+ * @param sessionsDir 会话根目录（`<homeDir>/sessions`）。
+ * @param unitId 台账里的会话单元 id（`<projectKey>/<sessionId>`；缺了就返回 null）。
+ * @returns 标题；读不到 / 没有标题事件 / 形状不符 → null（界面回落显示会话 id）。
+ */
+export async function readSessionTitleFromLog(sessionsDir: string, unitId: string): Promise<string | null> {
+  const parts = unitSegments(unitId);
+  if (parts === null) return null;
+  const dir = join(sessionsDir, ...parts);
+  const names = await readdir(dir).catch(() => [] as string[]);
+  const logs = names.filter((name) => isSessionLogName(name)).sort();
+  if (logs.length === 0) return null;
+  // 与体检同口径：同一会话有多份 generation 时以**最新的一份**（字典序最后）为准
+  const picked = logs[logs.length - 1];
+  if (picked === undefined) return null;
+  return readTitleFromLogFile(join(dir, picked));
+}
+
+/**
+ * 给一批台账行补标题：**已有标题的不动**，缺标题的按 `unitId` 去重后走日志兜底。
+ *
+ * 只读、有界（见 {@link SESSION_TITLE_MAX_READS}）、失败一律原样返回（界面回落显示会话 id）。
+ */
+export async function applySessionLogTitles<
+  T extends { sessionId?: string | null; unitId?: string | null; title?: string },
+>(
+  rows: readonly T[],
+  sessionsDir: string,
+  options: { maxReads?: number } = {},
+): Promise<(T & { title?: string })[]> {
+  const maxReads = Math.max(0, options.maxReads ?? SESSION_TITLE_MAX_READS);
+  const resolved = new Map<string, string | null>();
+  const out: (T & { title?: string })[] = [];
+  let reads = 0;
+  for (const row of rows) {
+    if (typeof row.title === 'string' && row.title.trim() !== '') {
+      out.push(row);
+      continue;
+    }
+    const unitId = typeof row.unitId === 'string' && row.unitId !== '' ? row.unitId : null;
+    if (unitId === null) {
+      out.push(row);
+      continue;
+    }
+    let title = resolved.get(unitId);
+    if (title === undefined) {
+      if (reads >= maxReads) {
+        out.push(row);
+        continue;
+      }
+      reads += 1;
+      title = await readSessionTitleFromLog(sessionsDir, unitId);
+      resolved.set(unitId, title);
+    }
+    out.push(title === null || title === '' ? row : { ...row, title });
+  }
+  return out;
+}

package/src/core/startup-barrier.test.ts

@@ -0,0 +1,69 @@
+/**
+ * issue #87：启动分类 → SAFE MODE 处置的单一判据（纯函数矩阵）。
+ *
+ * 背景：`probeSafeModeSync()` 读的是上一轮留下的 durable 标记，分类结论才是本轮权威。旧实现只做
+ * `safeModeActive = safeModeActive || kind ∈ {RECOVERY_REQUIRED, NEEDS_ATTENTION, UNKNOWN_STATE}` ——
+ * 只会把标志**置真**，于是「崩溃前什么都没写」的残留会让本会话的写操作一直被 423 挡着（界面却说
+ * 「无待处理事项」），且下次启动又从头再来一遍。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveStartupSafeMode, classifyStartup, FAIL_CLOSED_STARTUP } from './startup-barrier.ts';
+
+test('issue #87：NORMAL + 无活锁者 + 陈旧 blocked 标记 → 解除（内存标志与 durable 标记一起复位）', () => {
+  assert.deepEqual(
+    resolveStartupSafeMode({ kind: 'NORMAL', lockState: 'FREE', currentlyBlocked: true }),
+    { blocked: false, clearStaleMarker: true },
+  );
+});
+
+test('issue #87：NORMAL 但没有陈旧标记 → 不动标记（不做无意义写入）', () => {
+  assert.deepEqual(
+    resolveStartupSafeMode({ kind: 'NORMAL', lockState: 'FREE', currentlyBlocked: false }),
+    { blocked: false, clearStaleMarker: false },
+  );
+});
+
+test('issue #87：NORMAL 但锁被别人持有（LOCKED）→ 绝不清标记、保持阻断（不替活锁者解除保护）', () => {
+  assert.deepEqual(
+    resolveStartupSafeMode({ kind: 'NORMAL', lockState: 'LOCKED', currentlyBlocked: true }),
+    { blocked: true, clearStaleMarker: false },
+  );
+});
+
+test('issue #87：残留锁（STALE_LOCK_DETECTED）未显式回收 → 不清标记（仍需用户回收残留锁）', () => {
+  assert.deepEqual(
+    resolveStartupSafeMode({ kind: 'NORMAL', lockState: 'STALE_LOCK_DETECTED', currentlyBlocked: true }),
+    { blocked: true, clearStaleMarker: false },
+  );
+});
+
+test('issue #87：RECOVERY_REQUIRED / NEEDS_ATTENTION / UNKNOWN_STATE → 一律阻断且不清标记', () => {
+  for (const kind of ['RECOVERY_REQUIRED', 'NEEDS_ATTENTION', 'UNKNOWN_STATE'] as const) {
+    assert.deepEqual(
+      resolveStartupSafeMode({ kind, lockState: 'FREE', currentlyBlocked: false }),
+      { blocked: true, clearStaleMarker: false },
+      kind + ' 必须阻断',
+    );
+  }
+});
+
+test('issue #87：fail-closed 结论（FAIL_CLOSED_STARTUP）经同一判据仍然是阻断', () => {
+  const verdict = resolveStartupSafeMode({
+    kind: FAIL_CLOSED_STARTUP.state.kind,
+    lockState: 'FREE',
+    currentlyBlocked: false,
+  });
+  assert.equal(verdict.blocked, true, 'inspect 抛错时绝不因 NORMAL 之外的分支被解除');
+  assert.equal(verdict.clearStaleMarker, false);
+});
+
+test('issue #87：classifyStartup 仍是分类唯一来源（形状自检，防止第二份分类漂移）', () => {
+  const classifier = classifyStartup({
+    store: {} as never,
+    hooks: {} as never,
+    env: { environmentFingerprint: 'fp', isLiveOwner: async () => false },
+    lockState: 'FREE',
+  });
+  assert.equal(typeof classifier.classify, 'function');
+});

package/src/core/startup-barrier.ts

@@ -58,6 +58,33 @@ export function classifyStartup(opts: {
   };
 }
 
+/**
+ * 启动分类结束后如何处置 SAFE MODE（issue #87，单一判据，便于单测；宿主 apply() 只消费结论）。
+ *
+ * 为什么需要它：`probeSafeModeSync()` 读的是**上一轮**留下的 durable 标记，而分类结论才是本轮权威。
+ * 分类判 `NORMAL` ⇒ 没有任何未决 journal 能解释那个标记 ⇒ 它是陈旧标记，必须**同时**复位内存标志与
+ * durable 标记 —— 只复位内存会让本会话的写操作继续被 423 挡着（界面却说「无待处理事项」），只复位标记
+ * 又会在下一次 probe 时重新置起（标记跨重启生效）。
+ *
+ * 为什么要求 `lockState === 'FREE'`：`LOCKED` 且无未决 journal 时分类同样返回 NORMAL，但那只说明
+ * **另一个存活实例**正在持有环境锁 —— 此刻清标记等于替别人解除保护。**只有确认没有活锁者才清。**
+ *
+ * 为什么要求 `currentlyBlocked`（即 probe 读到 durable 标记确实是 'blocked'）：标记为 `'unknown'`
+ * （存在但读不出/布局不可信）时不在这里清 —— 那属于无法判定，既不假装已解除，也不假装没看见；
+ * 它本会话不阻断的语义由 `probeSafeModeSync` 的既有约定承担。
+ */
+export function resolveStartupSafeMode(input: {
+  kind: StartupRecoveryState['kind']
+  lockState: 'LOCKED' | 'STALE_LOCK_DETECTED' | 'UNKNOWN_STATE' | 'FREE'
+  /** 本轮 probe 之前的内存标志（probeSafeModeSync 的结论） */
+  currentlyBlocked: boolean
+}): { blocked: boolean; clearStaleMarker: boolean } {
+  const staleMarker = input.kind === 'NORMAL' && input.lockState === 'FREE' && input.currentlyBlocked
+  if (staleMarker) return { blocked: false, clearStaleMarker: true }
+  const forceBlocked = input.kind === 'RECOVERY_REQUIRED' || input.kind === 'NEEDS_ATTENTION' || input.kind === 'UNKNOWN_STATE'
+  return { blocked: input.currentlyBlocked || forceBlocked, clearStaleMarker: false }
+}
+
 export interface StartupSchedulers {
   start(): void;
 }

package/src/core/transaction-coordinator.ts

@@ -19,6 +19,7 @@ import {
   isTerminalState, generateOperationId, redactJournalText, type OperationJournal,
 } from './journal.ts';
 import type { MutationLockContext, MutationLockPort } from '../utils/env-lock.ts';
+import { engineMsg } from './messages-core.ts';
 
 // ---------- 类型 ----------
 
@@ -109,9 +110,9 @@ export class MutationTransactionCoordinator {
         : 'needs-attention';
       if (recovered === 'recovered' || recovered === 'rolled-back') {
         // 残留已收敛 → 可继续；但本函数语义：先返回，调用方重试 run
-        return { outcome: 'RECOVERY_REQUIRED', operationId: activeCheck.residue, reason: `残留 active transaction ${activeCheck.residue} 待处理，请重试` };
+        return { outcome: 'RECOVERY_REQUIRED', operationId: activeCheck.residue, reason: engineMsg('core.txn.residuePending', { residue: activeCheck.residue }) };
       }
-      return { outcome: 'RECOVERY_REQUIRED', operationId: activeCheck.residue, reason: `存在 unresolved active transaction ${activeCheck.residue}` };
+      return { outcome: 'RECOVERY_REQUIRED', operationId: activeCheck.residue, reason: engineMsg('core.txn.unresolvedActive', { residue: activeCheck.residue }) };
     }
 
     // 3. 创建 journal
@@ -227,7 +228,7 @@ export class MutationTransactionCoordinator {
       if (current !== null && isTerminalState(current.state)) {
         // 已 terminal（如 COMMITTED 后 move 抛错 → 保持 terminal，不回滚）
         const opId = operationId;
-        return { outcome: 'NEEDS_ATTENTION', operationId: opId, reason: `tail/commit 后异常：${msg}`, snapshotId };
+        return { outcome: 'NEEDS_ATTENTION', operationId: opId, reason: engineMsg('core.txn.tailCommitFailed', { message: msg }), snapshotId };
       }
       return await this.finalizeAttention(operationId, msg, snapshotId, context);
     }

package/src/core/types.ts

@@ -140,6 +140,13 @@ export interface ExportUnit {
    * 包里 41 条）。非 sessions 分区 / 非子代理会话一律不设该字段（不猜）。
    */
   parentSessionId?: string;
+  /**
+   * 空白会话（**从未提问过**；只有 sessions 分区的单元可能有值）。
+   *
+   * 用途：DSH 自己给这类会话的标题就是本地化的「新会话」（`session.new`），没有标题可显示。
+   * 只下发**事实**，不下发文案 —— 界面按当前语言显示（与 DSH 同口径），绝不用 uuid 冒充标题。
+   */
+  blank?: boolean;
 }
 
 export interface ValidationResult {
@@ -660,6 +667,8 @@ export interface PlanItem {
   label?: string;
   /** 单元的**二级分组名**（可选，同 `/export-preview` 的 `ExportUnit.group` 语义；纯展示）。 */
   group?: string;
+  /** 空白会话（从未提问；同 `ExportUnit.blank`，只下发事实、文案由界面本地化）。 */
+  blank?: boolean;
   /** 本项对应的**工作区记录拥有的会话 id**（工作区计划项专用；issue #45 勾选联动）。 */
   sessionIds?: string[];
   /** 本工作区计划项 **path 的 cwd 目录键**（`projectKeyOf(path)`；issue #45 勾选联动第二判据）。 */
@@ -941,11 +950,19 @@ export interface SnapshotManifest {
 
 /** 宿主整文件备份登记（M1）：导入前对 $DSH_HOME 关键文件的整文件快照。
  * relPath 相对 $DSH_HOME（如 settings.yaml / cordis.patch.yml / profiles/<p>/cordis.patch.yml），
- * blobPath 为快照内 blob 路径（existed=false 时为空串，表示该文件当时不存在）。 */
+ * blobPath 为快照内 blob 路径（existed=false 时为空串，表示该文件当时确实不存在）。 */
 export interface HostFileBackup {
   relPath: string;
   blobPath: string;
   existed: boolean;
+  /**
+   * 探测到**存在**、但这一次读不出来（EACCES / EBUSY / IO 错）：existed 仍为 true、blobPath 为空串。
+   *
+   * 为什么必须与 existed:false 分开：恢复侧「快照里没有、现在有 → 删掉」这条动作是按 existed 判定的，
+   * 把「没读到」写成「本来不存在」会让恢复**删掉用户真实的文件**（Windows 上 settings.yaml 被占用即触发）。
+   * 存在但读不到的条目一律只跳过并如实告警，绝不参与删除判定（与「读不到 ≠ 没有」同一条口径）。
+   */
+  unreadable?: boolean;
 }
 
 export interface Snapshot {

package/src/core/validator.ts

@@ -4,6 +4,7 @@
 import { validateSectionData } from '../schema/config.ts';
 import { canImport, describeVersion } from '../schema/versions.ts';
 import type { SectionId } from '../schema/types.ts';
+import { engineMsg } from './messages-core.ts';
 import type { CompatibilityInput, CompatibilityReason, CompatibilityScore, ValidationResult } from './types.ts';
 
 export { validateManifest } from '../schema/manifest.ts';
@@ -102,10 +103,10 @@ export function computeCompatibility(input: CompatibilityInput): CompatibilitySc
 /** 兼容性得分的可读描述（UI 报告用） */
 export function describeCompatibility(score: CompatibilityScore): string {
   switch (score) {
-    case 'excellent': return 'Excellent — 完美兼容（同平台、无缺失、schema 支持）';
-    case 'good': return 'Good — 兼容（旧版备份导入新版 DSH）';
-    case 'partial': return 'Partial — 部分兼容（跨平台/分区缺失/版本超前，需人工确认）';
-    case 'unsupported': return 'Unsupported — 不受支持（schema 超出范围）';
+    case 'excellent': return engineMsg('core.compat.excellent');
+    case 'good': return engineMsg('core.compat.good');
+    case 'partial': return engineMsg('core.compat.partial');
+    case 'unsupported': return engineMsg('core.compat.unsupported');
   }
 }
 

package/src/core/verify-recovery.ts

@@ -24,6 +24,7 @@
  *
  * 本模块为纯函数（fs 经 node:fs + HostContext 门面注入），可独立测试。
  */
+import { engineMsg } from './messages-core.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
@@ -58,7 +59,7 @@ function toRelPath(homeDir: string, abs: string): string {
 /** 快照目录内 blob 绝对路径（防 snapshot.json 里伪造 ../ 越界读） */
 function blobAbs(snapshotDir: string, blobPath: string): string {
   const abs = path.resolve(snapshotDir, blobPath);
-  if (!isWithinHome(snapshotDir, abs)) throw new Error(`blob 路径越界: ${blobPath}`);
+  if (!isWithinHome(snapshotDir, abs)) throw new Error(engineMsg('core.verifyRecovery.blobPathEscaped', { path: blobPath }));
   return abs;
 }
 
@@ -99,12 +100,12 @@ export async function verifyRecovery(
   if (val.verdict !== 'TRUSTED_OPERATION_SNAPSHOT') {
     return {
       verdict: 'VERIFICATION_ERROR',
-      details: [`快照重验失败: ${val.verdict}${val.reason ? ` — ${val.reason}` : ''}`],
+      details: [engineMsg('core.verifyRecovery.revalidateFailed', { verdict: val.verdict }) + (val.reason ? ` — ${val.reason}` : '')],
       manualHints: [],
       at,
     };
   }
-  details.push('快照重验通过（TRUSTED_OPERATION_SNAPSHOT）');
+  details.push(engineMsg('core.verifyRecovery.revalidatePassed'));
 
   // 2) 从磁盘重读 snapshot.json 作为权威（不信任传入的 snapshot 对象，防 execute→verify 间替换）。
   let diskSnapshot: Snapshot;
@@ -112,17 +113,17 @@ export async function verifyRecovery(
     const raw = await fs.readFile(path.join(snapshotDir, 'snapshot.json'), 'utf8');
     diskSnapshot = JSON.parse(raw) as Snapshot;
   } catch (err) {
-    return { verdict: 'VERIFICATION_ERROR', details: [...details, `snapshot.json 重读失败: ${err instanceof Error ? err.message : String(err)}`], manualHints: [], at };
+    return { verdict: 'VERIFICATION_ERROR', details: [...details, engineMsg('core.verifyRecovery.snapshotJsonRereadFailed', { reason: err instanceof Error ? err.message : String(err) })], manualHints: [], at };
   }
 
   // 3) environment binding（validateSnapshotForRestore 已查，此处双保险）
   if (diskSnapshot.environmentFingerprint && diskSnapshot.environmentFingerprint !== opts.environmentFingerprint) {
-    return { verdict: 'VERIFICATION_ERROR', details: [...details, 'environmentFingerprint 不匹配（WRONG_ENVIRONMENT）'], manualHints: [], at };
+    return { verdict: 'VERIFICATION_ERROR', details: [...details, engineMsg('core.verifyRecovery.envMismatch')], manualHints: [], at };
   }
 
   // 3b) operation binding（journal.operationId ↔ snapshot.operationId 双向一致；WRONG_OPERATION 拒绝）
   if (opts.expectedOperationId !== undefined && diskSnapshot.operationId !== opts.expectedOperationId) {
-    return { verdict: 'VERIFICATION_ERROR', details: [...details, `operationId 不匹配（WRONG_OPERATION）: snapshot=${diskSnapshot.operationId ?? '(无)'} expected=${opts.expectedOperationId}`], manualHints: [], at };
+    return { verdict: 'VERIFICATION_ERROR', details: [...details, engineMsg('core.verifyRecovery.operationMismatch', { snapshot: diskSnapshot.operationId ?? engineMsg('core.verifyRecovery.none'), expected: opts.expectedOperationId ?? '' })], manualHints: [], at };
   }
 
   let mismatch = false;
@@ -135,12 +136,12 @@ export async function verifyRecovery(
     if (backup.existed) {
       if (backup.blobPath === '') {
         unverifiable = true;
-        details.push(`host file 无 blob 信息: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileNoBlob', { rel }));
         continue;
       }
       if (!(await ctx.fs.exists(rel))) {
         mismatch = true;
-        details.push(`host file 缺失: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileMissing', { rel }));
         continue;
       }
       let blob: Uint8Array;
@@ -148,23 +149,23 @@ export async function verifyRecovery(
         blob = await fs.readFile(blobAbs(snapshotDir, backup.blobPath));
       } catch {
         unverifiable = true;
-        details.push(`host file blob 读取失败: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileBlobReadFailed', { rel }));
         continue;
       }
       const current = await ctx.fs.readFile(rel);
       if (!bufEq(current, blob)) {
         mismatch = true;
-        details.push(`host file 内容不匹配: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileContentMismatch', { rel }));
       } else {
-        details.push(`host file 匹配: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileMatch', { rel }));
       }
     } else {
       // snapshot expects absent → target 必须不存在（删除动作失败 → 残留被检测）
       if (await ctx.fs.exists(rel)) {
         mismatch = true;
-        details.push(`应删除目标仍存在: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileStillPresent', { rel }));
       } else {
-        details.push(`删除目标已不存在: ${rel}`);
+        details.push(engineMsg('core.verifyRecovery.hostFileAlreadyGone', { rel }));
       }
     }
   }
@@ -175,13 +176,13 @@ export async function verifyRecovery(
     const rel = toRelPath(ctx.homeDir, resolveFileAbs(ctx.homeDir, entry.adapter, entry.ref));
     if (rel === '') {
       unverifiable = true;
-      details.push(`file 路径越界: ${entry.adapter}:${entry.ref}`);
+      details.push(engineMsg('core.verifyRecovery.filePathEscaped', { ref: `${entry.adapter}:${entry.ref}` }));
       continue;
     }
     if (entry.existed && entry.copiedTo) {
       if (!(await ctx.fs.exists(rel))) {
         mismatch = true;
-        details.push(`file 缺失: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileMissing', { ref: `${entry.adapter}:${entry.ref}` }));
         continue;
       }
       let blob: Uint8Array;
@@ -189,22 +190,22 @@ export async function verifyRecovery(
         blob = await fs.readFile(blobAbs(snapshotDir, entry.copiedTo));
       } catch {
         unverifiable = true;
-        details.push(`file blob 读取失败: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileBlobReadFailed', { ref: `${entry.adapter}:${entry.ref}` }));
         continue;
       }
       const current = await ctx.fs.readFile(rel);
       if (!bufEq(current, blob)) {
         mismatch = true;
-        details.push(`file 内容不匹配: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileContentMismatch', { ref: `${entry.adapter}:${entry.ref}` }));
       } else {
-        details.push(`file 匹配: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileMatch', { ref: `${entry.adapter}:${entry.ref}` }));
       }
     } else if (!entry.existed) {
       if (await ctx.fs.exists(rel)) {
         mismatch = true;
-        details.push(`应删除 file 目标仍存在: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileStillPresent', { ref: `${entry.adapter}:${entry.ref}` }));
       } else {
-        details.push(`删除 file 目标已不存在: ${entry.adapter}:${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.fileAlreadyGone', { ref: `${entry.adapter}:${entry.ref}` }));
       }
     }
   }
@@ -214,8 +215,8 @@ export async function verifyRecovery(
   const beforePlugins = diskSnapshot.beforePlugins;
   if (beforePlugins === undefined) {
     unverifiable = true;
-    details.push('快照无 beforePlugins 基线，插件状态不可验证');
-    manualHints.push('插件状态无法自动验证（快照无基线），请人工确认已装插件');
+    details.push(engineMsg('core.verifyRecovery.pluginsNoBaseline'));
+    manualHints.push(engineMsg('core.verifyRecovery.pluginsNoBaselineHint'));
   } else {
     try {
       const current = await ctx.plugins.listInstalled();
@@ -223,14 +224,14 @@ export async function verifyRecovery(
       const added = current.filter((p) => !beforeNames.has(p.name));
       if (added.length > 0) {
         mismatch = true;
-        details.push(`导入期间新增插件未移除: ${added.map((p) => p.name).join(', ')}`);
+        details.push(engineMsg('core.verifyRecovery.pluginsAdded', { names: added.map((p) => p.name).join(', ') }));
       } else {
-        details.push('插件状态匹配（无新增插件）');
+        details.push(engineMsg('core.verifyRecovery.pluginsMatch'));
       }
     } catch {
       unverifiable = true;
-      details.push('插件状态无法验证（listInstalled 失败）');
-      manualHints.push('插件状态无法自动验证（listInstalled 失败），请人工确认已装插件');
+      details.push(engineMsg('core.verifyRecovery.pluginsVerifyFailed'));
+      manualHints.push(engineMsg('core.verifyRecovery.pluginsVerifyFailedHint'));
     }
   }
 
@@ -241,14 +242,14 @@ export async function verifyRecovery(
       const current = await ctx.settings.describe(entry.ref);
       if (!isDeepStrictEqual(current.value, entry.before)) {
         mismatch = true;
-        details.push(`settings 不匹配: ${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.settingsMismatch', { ref: entry.ref }));
       } else {
-        details.push(`settings 匹配: ${entry.ref}`);
+        details.push(engineMsg('core.verifyRecovery.settingsMatch', { ref: entry.ref }));
       }
     } catch {
       unverifiable = true;
-      details.push(`settings 无法验证: ${entry.ref}`);
-      manualHints.push(`settings 无法自动验证（${entry.ref}），请人工确认`);
+      details.push(engineMsg('core.verifyRecovery.settingsVerifyFailed', { ref: entry.ref }));
+      manualHints.push(engineMsg('core.verifyRecovery.settingsVerifyFailedHint', { ref: entry.ref }));
     }
   }
 

package/src/foreign/bundle.ts

@@ -19,6 +19,7 @@ import { writeZip } from '../utils/zip.ts';
 import type { ZipWriteEntry } from '../utils/zip.ts';
 import type { Platform, SectionId } from '../schema/types.ts';
 import type { ForeignImportResult, ForeignSkip } from './types.ts';
+import { engineMsg } from './messages.ts';
 
 export interface ForeignBundleOptions {
   result: ForeignImportResult;
@@ -57,7 +58,7 @@ export async function writeForeignBundle(opts: ForeignBundleOptions): Promise<Fo
     if (isFileSection(s.sectionId)) {
       const prefix = SECTION_FILE_PREFIXES[s.sectionId];
       if (prefix === undefined) {
-        throw new Error('外部导入：文件类分区缺少 ZIP 前缀 ' + s.sectionId);
+        throw new Error(engineMsg('foreign.bundleFileSectionPrefixMissing', { section: s.sectionId }));
       }
       const files = s.files ?? [];
       if (files.length === 0) continue;
@@ -67,7 +68,7 @@ export async function writeForeignBundle(opts: ForeignBundleOptions): Promise<Fo
     } else {
       const jsonPath = SECTION_JSON_PATHS[s.sectionId];
       if (jsonPath === undefined) {
-        throw new Error('外部导入：JSON 类分区缺少 ZIP 路径 ' + s.sectionId);
+        throw new Error(engineMsg('foreign.bundleJsonSectionPathMissing', { section: s.sectionId }));
       }
       if (s.data === undefined) continue;
       flags[s.sectionId] = true;

package/src/foreign/continue.ts

@@ -19,6 +19,7 @@
 import { envValue, normalizePlatform } from './platform-paths.ts';
 import { draftFromTranscript, sessionSourceOf } from './session-source.ts';
 import type { RootProbeOptions } from './session-source.ts';
+import { engineMsg } from './messages.ts';
 import { FOREIGN_TRUTH_TABLES } from './truth-table.ts';
 import type { ForeignTruthTableEntry } from './truth-table.ts';
 import type { ForeignSource } from './registry.ts';
@@ -31,7 +32,7 @@ export const CONTINUE_PROVIDER = 'continue';
 
 function truthEntryOf(id: ForeignSourceId): ForeignTruthTableEntry {
   const found = FOREIGN_TRUTH_TABLES.find((entry) => entry.id === id);
-  if (found === undefined) throw new Error('真值表缺少来源定义: ' + id);
+  if (found === undefined) throw new Error(engineMsg('foreign.truthTableMissingSource', { id }));
   return found;
 }
 

package/src/foreign/crush.ts

@@ -18,6 +18,7 @@ import { draftFromTranscript } from './session-source.ts';
 import type { RootProbeOptions, SessionDraft } from './session-source.ts';
 import { sessionSourceOf } from './session-source.ts';
 import type { ForeignSource } from './registry.ts';
+import { engineMsg } from './messages.ts';
 import { FOREIGN_TRUTH_TABLES } from './truth-table.ts';
 import type { ForeignTruthTableEntry } from './truth-table.ts';
 import type { ForeignEvidenceKind, ForeignSourceId } from './types.ts';
@@ -27,7 +28,7 @@ import { crushProjectDbPath, crushRegistryPath, readCrush } from './read-crush.t
 /** 真值表条目（找不到即装配期炸：宁可炸，也不让来源悄悄少一份取证声明 —— 与 registry.ts 同口径） */
 function truthEntryOf(id: ForeignSourceId): ForeignTruthTableEntry {
   const found = FOREIGN_TRUTH_TABLES.find((entry) => entry.id === id);
-  if (found === undefined) throw new Error('真值表缺少来源定义: ' + id);
+  if (found === undefined) throw new Error(engineMsg('foreign.truthTableMissingSource', { id }));
   return found;
 }
 

package/src/foreign/file-budget.test.ts

@@ -244,6 +244,8 @@ test('C 来源形状：共享模块清单是封闭集合（新模块必须显式
   const shared = modules.filter((m) => !isSourceShaped(m));
   const expected = [
     'bundle.ts', 'claude-sessions.ts', 'kernel.ts',
+    /* t6 新增：本域追加消息目录（零 source 形状；中文只在这里，装配期抛错的文案经 engineMsg 取）。 */
+    'messages.ts',
     /* 档 B 新增的 5 个共享地基（零 source 形状，但也不是来源模块）： */
     'platform-paths.ts', 'registry.ts', 'session-ir.ts', 'session-read.ts', 'session-source.ts',
     'source-modules.ts', 'sqlite.ts', 'truth-table.ts', 'types.ts',