dsh-config-manager 0.1.71 → 0.1.72

package/src/core/phase3-host.ts

@@ -22,11 +22,12 @@ import { inspectStartup, type ReconcileProbeHooks, type ReconcileEnv } from './r
 import { OWNERSHIP_FILE, type LockState, type MutationLockContext } from '../utils/env-lock.ts';
 import { sha256Hex } from '../utils/hashing.ts';
 import type { JournalStepRecord } from './types.ts';
+import { engineMsg } from './messages-core.ts';
 
 /** 存在未收敛的 active transaction → 拒绝创建第二个（active≤1）。 */
 export class TransactionRecoveryRequiredError extends Error {
   constructor(opId: string) {
-    super(`active transaction ${opId} 未收敛（待 recover / reconcile），拒绝创建新 transaction`)
+    super(engineMsg('core.phase3.transactionNotConverged', { opId }))
     this.name = 'TransactionRecoveryRequiredError'
   }
 }
@@ -75,6 +76,9 @@ export interface JournalRunContext {
 export function mapLockStateForStartup(state: LockState): 'LOCKED' | 'STALE_LOCK_DETECTED' | 'UNKNOWN_STATE' | 'FREE' {
   if (state === 'STALE_LOCK_DETECTED') return 'STALE_LOCK_DETECTED';
   if (state === 'UNKNOWN_STATE') return 'UNKNOWN_STATE';
+  // issue #79：FREE（ownership 确实不存在）如实透传。此前它落到下面的兜底被映射成 LOCKED ——
+  // 与 inspectLockState 的 missing→LOCKED 一起，把「没有锁」的系统性误报成「有活跃锁」。
+  if (state === 'FREE') return 'FREE';
   return 'LOCKED'; // ACQUIRED / LOCKED / LOCK_IO_ERROR / PERMISSION_ERROR → 保守 LOCKED
 }
 
@@ -209,7 +213,19 @@ export class Phase3Recovery {
         if (step.beforeFp !== null && fp === step.beforeFp) return 'before-match';
         return 'none';
       },
-      probeExternal: async () => 'unknown',
+      // issue #87：external step 的**真实只读探测**（仅在 journal 里确实记录了指纹时才可能得出结论）。
+      // 语义仍是「证不出来就说 unknown」：ref 为空 / 无指纹 / 读失败 / 与两个指纹都不符 → unknown。
+      // 注意：runExternalIntent 目前写入的 external step 恒无指纹（beforeFp/afterFp 皆 null），
+      // 对它们本探测必然返回 unknown —— 那是刻意的，放行判断在 reconcile 的「可自证残留」门（独立判据）。
+      probeExternal: async (step) => {
+        if (step.ref === '' || step.beforeFp === null || step.afterFp === null) return 'unknown'
+        let data: Buffer
+        try { data = await fs.readFile(step.ref) } catch { return 'unknown' }
+        const fp = sha256Hex(data)
+        if (fp === step.afterFp) return 'installed'
+        if (fp === step.beforeFp) return 'not-installed'
+        return 'unknown'
+      },
       snapshotExists: async (snapshotId, binding) => {
         if (snapshotExists === undefined) return false; // 未注入 → 保守 false
         return snapshotExists(snapshotId, binding);
@@ -330,7 +346,7 @@ export class Phase3Recovery {
         const snapId = await snapshotProvider();
         // P1-2 修复：snapshotProvider 返回 null 表示快照创建失败 → 显式 abort（不得在无快照下继续 mutation）
         if (snapId === null) {
-          throw new Error(`snapshotProvider 返回 null（快照创建失败），abort operation ${operationType}`);
+          throw new Error(engineMsg('core.phase3.snapshotProviderNull', { operationType }));
         }
         await journalCtx.bindSnapshot(snapId);
       } else if (deferredSnapshot !== true) {
@@ -446,7 +462,7 @@ export class Phase3Recovery {
       environmentFingerprint: this.environmentFingerprint || 'unknown',
       ownerInstanceId,
       bindSnapshot: async (snapshotId: string) => {
-        if (snapshotId === null || snapshotId === '') throw new Error('bindSnapshot: snapshotId 为空');
+        if (snapshotId === null || snapshotId === '') throw new Error(engineMsg('core.phase3.bindSnapshotEmptyId'));
         // Reviewer A P2①：持久化失败必须传播（fail-closed）——若 journal 无法 durable 绑定 SNAPSHOT_CREATED，
         // 引擎的 await bindSnapshot 抛错 → fn 抛错 → runJournaled catch（NEEDS_ATTENTION），mutation 绝不在无绑定下继续。
         await this.store.update(opId, (j) => {
@@ -454,7 +470,7 @@ export class Phase3Recovery {
           if (next.state === 'CREATED') next = transitionJournalState(next, 'SNAPSHOT_CREATED');
           else if (next.state === 'SNAPSHOT_CREATED') { /* 幂等：已绑定 */ }
           else if (next.state === 'APPLYING') { /* 允许：绑定已晚但幂等记录 */ }
-          else throw new Error(`bindSnapshot 非法 state: ${next.state}`);
+          else throw new Error(engineMsg('core.phase3.bindSnapshotIllegalState', { state: next.state }));
           return next;
         });
       },

package/src/core/phase3-p2b-fingerprint.test.ts

@@ -68,6 +68,28 @@ test('verifyStepFingerprint：本地文件 step 真实磁盘指纹判定', async
   assert.equal(await hooks.verifyStepFingerprint({ adapter: 'plugins', ref: 'plugin:@x', kind: 'Install', external: true, beforeFp: null, afterFp: null, status: 'planned', appliedAt: null }), 'unable');
 });
 
+test('issue #87 probeExternal：有指纹时做真实只读探测；证不出来一律 unknown（默认保守语义不变）', async (t) => {
+  const dir = tmp(t);
+  const recovery = await makeRecovery(dir);
+  const target = path.join(dir, 'artifact.bin');
+  const fpA = sha256Hex(Buffer.from('A'));
+  const fpB = sha256Hex(Buffer.from('B'));
+  const step = (beforeFp: string | null, afterFp: string | null, ref = target): import('./journal.ts').JournalStep => ({
+    adapter: 'plugins', ref, kind: 'Install', external: true, beforeFp, afterFp, status: 'planned', appliedAt: null,
+  });
+  const hooks = recovery.recoveryHooks;
+
+  fssync.writeFileSync(target, 'A');
+  assert.equal(await hooks.probeExternal(step(fpA, fpB)), 'not-installed', '磁盘仍等于 beforeFp → 可自证未装');
+  fssync.writeFileSync(target, 'B');
+  assert.equal(await hooks.probeExternal(step(fpA, fpB)), 'installed', '磁盘等于 afterFp → 已装');
+  fssync.writeFileSync(target, 'C');
+  assert.equal(await hooks.probeExternal(step(fpA, fpB)), 'unknown', '与两个指纹都不符 → unknown（绝不猜）');
+  assert.equal(await hooks.probeExternal(step(null, null)), 'unknown', '无指纹（runExternalIntent 的真实形态）→ unknown');
+  assert.equal(await hooks.probeExternal(step(fpA, fpB, '')), 'unknown', 'ref 为空 → unknown');
+  assert.equal(await hooks.probeExternal(step(fpA, fpB, path.join(dir, 'missing.bin'))), 'unknown', '读失败 → unknown');
+});
+
 // ---------- 2. recordStep 持久化 ----------
 
 test('runJournaled journalCtx.recordStep：文件/外部 step 落 journal', async (t) => {

package/src/core/plugin-cli.ts

@@ -15,6 +15,7 @@
  * 只依赖 node 内置模块，零 DSH 运行时依赖（M5 的 TDD 可直接单测本模块）。
  */
 
+import { engineMsg } from './messages-core.ts';
 import { spawn } from 'node:child_process'
 import type { ChildProcess, SpawnOptions } from 'node:child_process'
 import { readFileSync, rmSync } from 'node:fs'
@@ -609,35 +610,35 @@ export function classifyDshPluginFailure(output: string): DshPluginFailure | nul
     return {
       code: 'hoist-pattern-diff',
       recoverable: true,
-      message: 'profile 的 node_modules 由旧版 pnpm 创建，与当前 pnpm 的默认配置不兼容；在 profile 目录执行一次 pnpm install 重建后重试 / this profile\'s node_modules was created by a different pnpm major; rebuild it (pnpm install) before retrying',
+      message: engineMsg('core.pluginCli.hoistPatternDiff'),
     }
   }
   if (output.includes('ERR_PNPM_ADDING_TO_ROOT')) {
     return {
       code: 'adding-to-root',
       recoverable: true,
-      message: 'profile 是 pnpm workspace，当前 dsh CLI 转发未带 -w 被 pnpm 拒绝；可手动执行 dsh plugin --profile <name> add -w <pkg> / pnpm refused to add at a workspace root (missing -w); run dsh plugin --profile <name> add -w <pkg> by hand',
+      message: engineMsg('core.pluginCli.addingToRoot'),
     }
   }
   if (/--workspace-root may only be used inside a workspace/i.test(output)) {
     return {
       code: 'not-a-workspace',
       recoverable: false,
-      message: 'profile 目录不是 pnpm workspace，却传入了 -w，因此被 pnpm 拒绝 / -w was passed but the profile is not a pnpm workspace, so pnpm refused the operation',
+      message: engineMsg('core.pluginCli.notAWorkspace'),
     }
   }
   if (output.includes('ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION') || output.includes('ERR_PNPM_NO_MATURE_MATCHING_VERSION')) {
     return {
       code: 'release-age-violation',
       recoverable: true,
-      message: 'profile 里有刚发布不久的插件版本，pnpm 的安全等待期检查拒绝了本次改动（即使改的是别的插件）；等待发布期满，或临时以 --config.minimumReleaseAge=0 重试 / a recently-published plugin version in this profile trips pnpm\'s fresh-release safety check, blocking any change (even to other plugins); wait for the release to mature, or retry once with --config.minimumReleaseAge=0',
+      message: engineMsg('core.pluginCli.releaseAgeViolation'),
     }
   }
   if (output.includes('ERR_PNPM_GIT_DEP_PREPARE_NOT_ALLOWED') || /git-hosted package "[^"]+" needs to execute build scripts/i.test(output)) {
     return {
       code: 'git-build-blocked',
       recoverable: false,
-      message: '该 git 插件需要在安装时执行构建脚本，被 pnpm 的 allowBuilds 白名单拦截；把 pnpm 提示的包名加入 profile 的 pnpm-workspace.yaml 的 allowBuilds 后重试 / this git-hosted plugin needs to run its build script at install time, which pnpm blocks until allowed — add the exact package pnpm printed to allowBuilds in the profile\'s pnpm-workspace.yaml, then re-run',
+      message: engineMsg('core.pluginCli.gitBuildBlocked'),
     }
   }
   // issue #35：pnpm-workspace.yaml 的 patchedDependencies 指向不存在的 patch 文件时，
@@ -647,29 +648,27 @@ export function classifyDshPluginFailure(output: string): DshPluginFailure | nul
     // 路径可能含盘符冒号（C:\...），故按整行取、再切掉尾随的 ':' 或 ': <错误文本>'
     const raw = /Failed to read patch file\s+([^\r\n]+)/i.exec(output)?.[1]?.trim()
     const file = raw === undefined ? undefined : raw.split(/:\s/)[0]?.replace(/:\s*$/, '').trim()
-    const zh = file === undefined ? '' : `（${file}）`
-    const en = file === undefined ? '' : ` (${file})`
+    const patchSuffix = file === undefined ? '' : engineMsg('core.pluginCli.parenValue', { value: file })
     return {
       code: 'patch-file-missing',
       recoverable: false,
-      message: `profile 的 pnpm-workspace.yaml 声明了 patchedDependencies，但对应的 patch 文件不存在${zh}；pnpm 因此拒绝任何安装（含与补丁无关的插件）。把缺失的 patch 文件放回 profile 的 patches/ 目录，或从 pnpm-workspace.yaml 删除该条目后重试 / the profile's pnpm-workspace.yaml declares patchedDependencies but the patch file is missing${en}; pnpm then refuses every install (even unrelated plugins). Put the patch file back under the profile's patches/ directory, or remove that entry from pnpm-workspace.yaml and retry`,
+      message: engineMsg('core.pluginCli.patchFileMissing', { patch: patchSuffix }),
     }
   }
   if (output.includes('ERR_PNPM_FETCH_404')) {
     const pkg = /GET\s+\S*\/([^/\s]+):/.exec(output)?.[1]?.replace(/%2[Ff]/g, '/')
-    const zh = pkg === undefined ? '' : `（${pkg}）`
-    const en = pkg === undefined ? '' : ` (${pkg})`
+    const pkgSuffix = pkg === undefined ? '' : engineMsg('core.pluginCli.parenValue', { value: pkg })
     return {
       code: 'fetch-404',
       recoverable: false,
-      message: `有一个依赖在 registry 上不存在${zh}，pnpm 拒绝任何安装操作；它可能是之前失败操作残留在 profile package.json 里的幽灵依赖（手动删除该行），也可能是需要登录的私有包 / a dependency cannot be resolved from the registry${en}; pnpm refuses every install while it is present — it may be a ghost entry left in the profile's package.json by an earlier failed operation (remove that line by hand), or a private package needing registry credentials`,
+      message: engineMsg('core.pluginCli.fetch404', { pkg: pkgSuffix }),
     }
   }
   if (isTransientDshPluginFailure(output)) {
     return {
       code: 'transient-network',
       recoverable: true,
-      message: '拉取依赖时网络临时失败（安装会重放整个依赖树，任何一个既有依赖抖动都会中断本次操作）；稍后直接重试通常即可 / a transient network failure while fetching dependencies (installs replay the whole dependency tree, so any existing dependency can hiccup); a plain retry usually succeeds',
+      message: engineMsg('core.pluginCli.transientNetwork'),
     }
   }
   // 桌面端保留档案：普通 dsh CLI（< 0.2 的旧版尤其）对 `--profile desktop` 直接报
@@ -680,14 +679,14 @@ export function classifyDshPluginFailure(output: string): DshPluginFailure | nul
     return {
       code: 'desktop-profile-reserved',
       recoverable: false,
-      message: 'desktop 是 DeepSeek Harness Desktop 独占管理的保留档案，普通 dsh CLI 拒绝操作它；请在桌面端应用内重试（新版本插件会自动改用桌面端自带的 CLI 载体），或改用其它档案 / the "desktop" profile is managed exclusively by the DeepSeek Harness Desktop application and the plain dsh CLI refuses to touch it; retry from inside the Desktop app (a current version of this plugin switches to the Desktop-bundled CLI carrier) or target another profile',
+      message: engineMsg('core.pluginCli.desktopProfileReserved'),
     }
   }
   if (output.includes('pnpm not found on PATH')) {
     return {
       code: 'pnpm-missing',
       recoverable: false,
-      message: '找不到 pnpm（dsh 转发 pnpm 失败）：请先安装 pnpm（npm install -g pnpm 或 corepack enable pnpm），然后重试 / pnpm is not on PATH (dsh forwards to pnpm): install pnpm (npm install -g pnpm or corepack enable pnpm) and retry',
+      message: engineMsg('core.pluginCli.pnpmMissing'),
     }
   }
   return null
@@ -696,18 +695,18 @@ export function classifyDshPluginFailure(output: string): DshPluginFailure | nul
 /** 安装失败 → 分类后的双语可读 Error；未识别则保留 stderr 尾部摘要。 */
 export function installErrorFor(pkg: string, result: DshPluginResult): Error {
   if (result.spawnError !== undefined && /ENOENT|EINVAL/.test(result.spawnError)) {
-    return new Error(`无法启动 dsh CLI（${result.spawnError}）：请确认 dsh 已安装且在 PATH 上，然后重试安装 ${pkg} / cannot start dsh CLI (${result.spawnError}): make sure dsh is installed and on PATH, then retry installing ${pkg}`)
+    return new Error(engineMsg('core.pluginCli.dshCliStartFailed', { spawnError: result.spawnError, pkg }))
   }
   if (result.timedOut) {
-    return new Error(`安装 ${pkg} 超时（进程已终止，默认 15 分钟）：请检查网络或稍后重试 / install ${pkg} timed out (process killed, default 15 min): check your network and retry later`)
+    return new Error(engineMsg('core.pluginCli.installTimeout', { pkg }))
   }
   const output = `${result.stderr}\n${result.stdout}`
   const failure = classifyDshPluginFailure(output)
   if (failure !== null) {
-    return new Error(`安装 ${pkg} 失败（${failure.code}）：${failure.message}`)
+    return new Error(engineMsg('core.pluginCli.installFailed', { pkg, code: failure.code, message: failure.message }))
   }
   const tail = (result.stderr.trim().split('\n').slice(-8).join('\n')
     || result.stdout.trim().split('\n').slice(-8).join('\n')
-    || '无输出')
-  return new Error(`dsh plugin 安装 ${pkg} 失败（exit ${String(result.exitCode)}）：${tail}`)
+    || engineMsg('core.pluginCli.noOutput'))
+  return new Error(engineMsg('core.pluginCli.installFailedWithTail', { pkg, exitCode: String(result.exitCode), tail }))
 }

package/src/core/reconcile.test.ts

@@ -452,3 +452,120 @@ test('t37：Phase3Recovery.refreshSafeMode 消费三态（unknown → isBlocked
   assert.equal(recovery.lastSafeModeState, 'clear', '标记已清除 → 刷新后仍为 clear');
 });
 
+// ---------- issue #87：可自证的崩溃残留自动放行 ----------
+
+function backupOp(id: string, state: OperationJournal['state'] = 'APPLYING'): OperationJournal {
+  const j = createJournalEntry('backup-schedule', { operationId: id, ownerInstanceId: 'o1', lockId: 'l1', packageVersion: '0.1.71', environmentFingerprint: FP }, '2026-01-01T00:00:00.000Z');
+  j.state = state;
+  return j;
+}
+function backupExtStep(status: JournalStep['status'] = 'planned'): JournalStep {
+  return { adapter: 'backup', ref: 'exports', kind: 'Backup', external: true, beforeFp: null, afterFp: null, status, appliedAt: null };
+}
+const unknownProbe: Partial<ReconcileProbeHooks> = { probeExternal: async () => 'unknown' };
+
+test('issue #87：定时备份残留（planned external backup step + 无快照）→ noop 自动放行，不再永久占 SAFE MODE', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d1';
+  const j = backupOp(id);
+  j.plannedSteps = ['ext'];
+  j.steps = { ext: backupExtStep() };
+  await store.create(j);
+  // 生产形态：external step 无指纹 ⇒ probe 恒 unknown（修复前正是这一条把它顶成 needs-attention）
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'noop');
+  assert.equal(out.safeModeRequired, false);
+  assert.equal(await store.readSafeMode(), false, '不得写 durable SAFE MODE');
+  assert.equal((await store.load(id))?.state, 'RECOVERED');
+  assert.deepEqual(await store.scanActive(), [], '必须规整出 active');
+});
+
+test('issue #87：定时备份残留（一个 step 都没登记）→ noop（该通道先落 step 再调 fn，无 step ⇒ fn 未开始）', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d2';
+  await store.create(backupOp(id));
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'noop');
+  assert.equal(out.safeModeRequired, false);
+});
+
+test('issue #87 对照：同样 external 形状但 operationType 会改用户配置（import-apply）→ 仍 NEEDS_ATTENTION', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d3';
+  const j = op(id, 'APPLYING');
+  j.plannedSteps = ['ext'];
+  j.steps = { ext: backupExtStep() };
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'needs-attention', '只放行 artifact-only 通道，绝不按形状普放');
+  assert.equal(out.safeModeRequired, true);
+});
+
+test('issue #87 对照：定时备份但 step 已 applied/非 planned → 保持保守', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d4';
+  const j = backupOp(id);
+  j.plannedSteps = ['ext'];
+  j.steps = { ext: { ...backupExtStep('done'), appliedAt: '2026-01-01T00:00:01.000Z' } };
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'needs-attention');
+  assert.equal(out.safeModeRequired, true);
+});
+
+test('issue #87 对照：定时备份但 step 不是 backup 适配器（可能装插件）→ 保持保守', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d5';
+  const j = backupOp(id);
+  j.plannedSteps = ['p1'];
+  j.steps = { p1: extStep('planned') };
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'needs-attention');
+  assert.equal(out.safeModeRequired, true);
+});
+
+test('issue #87 对照：定时备份但已有 snapshotId（可回滚）→ 走原 rollback 路径，不判 noop', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d6';
+  const j = backupOp(id);
+  j.snapshotId = '00000000-0000-4000-8000-0000000000aa';
+  j.plannedSteps = ['ext'];
+  j.steps = { ext: backupExtStep() };
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'needs-attention');
+  assert.equal(out.safeModeRequired, true);
+});
+
+test('issue #87 对照：ownership binding 不匹配 → 早于自证门的信任门先拦（不越权接管）', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d7';
+  const j = backupOp(id);
+  j.plannedSteps = ['ext'];
+  j.steps = { ext: backupExtStep() };
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, { ...env, expectedOwnershipInstanceId: 'someone-else' });
+  assert.equal(out.decisions[0]!.kind, 'needs-attention');
+  assert.match(out.decisions[0]!.reason, /binding|ownerInstanceId/i);
+});
+
+test('issue #87 对照：零步骤的 sync-push（非 artifact-only 通道）→ 保持 opaque NEEDS_ATTENTION', async (t) => {
+  const dir = tmp(t);
+  const store = mkStore(dir);
+  const id = '00000000-0000-4000-8000-0000000000d8';
+  const j = createJournalEntry('sync-push', { operationId: id, ownerInstanceId: 'o1', lockId: 'l1', packageVersion: '0.1.71', environmentFingerprint: FP }, '2026-01-01T00:00:00.000Z');
+  j.state = 'APPLYING';
+  await store.create(j);
+  const out = await reconcileActive(store, { ...hooks(), ...unknownProbe }, env);
+  assert.equal(out.decisions[0]!.kind, 'needs-attention');
+  assert.equal(out.safeModeRequired, true);
+});
+

package/src/core/reconcile.ts

@@ -12,6 +12,7 @@
  *  - 若发现 stale lock + incomplete journal → RECOVERY_REQUIRED / SAFE MODE，不自动 recoverStaleLock；
  *  - 用户显式确认后才 prove stale → recover → acquire → reconcile。
  */
+import { engineMsg } from './messages-core.ts';
 import {
   JournalStore, isTerminalState, transitionJournalState,
   type OperationJournal, type JournalStep, type SafeModeMarkerState,
@@ -90,6 +91,55 @@ export interface ReconcileOutcome {
   unresolved: string[];
 }
 
+/**
+ * **唯一**被放行的 operationType（issue #87）：定时备份。
+ *
+ * 为什么只放行它：它整条链路**不可能改用户配置** —— backup-scheduler 的 `doExport` 只做三件事：
+ * 往 `<dataDir>/exports/` 写一个归档 zip、写插件自身的调度状态文件、按保留策略删旧 auto 归档
+ * （src/sync/backup-scheduler.ts）。因此「崩溃前到底跑没跑到」这个不可判定问题，对**用户配置是否半成品**
+ * 完全无关紧要 —— 那才是 SAFE MODE 要防的东西。
+ *
+ * **其它 operationType 一律不得套用**：`autosync-apply` / `import-apply` 之类会真的改用户配置，
+ * 它们「已开始但未登记 step」永远不可证明，必须留在原保守路径（NEEDS_ATTENTION + SAFE MODE）。
+ */
+const ARTIFACT_ONLY_OPERATION_TYPES: ReadonlySet<string> = new Set<string>(['backup-schedule'])
+
+/** 可自证「不可能掩盖半成品配置改动」的残留类型（issue #87）。 */
+export type SelfProvableResidualClass = 'artifact-only' | 'no-steps'
+
+/**
+ * 判定崩溃残留是否**可自证**「没发生」（issue #87）；不可自证 → null，走原保守路径。
+ *
+ * 只回答一个问题：这次残留有没有可能掩盖「半成品用户配置改动」？只放行 artifact-only 通道的两类形状 ——
+ *  - `no-steps`：一个 step 都没登记。该通道（core/phase3-host.ts runExternalIntent）在调用 `fn` **之前**
+ *    就把 external step 落进 journal，没有 step ⇒ `fn` 从未开始 ⇒ 连归档都没产出；
+ *  - `artifact-only`：有 step 且全是 external backup（形状与 runExternalIntent 写的 ext step 逐字一致）。
+ *
+ * 形状门缺一不可：state ∈ {APPLYING, NEEDS_ATTENTION}、无 snapshotId、`commit.at` 为空、
+ * rollback 未尝试且无已补偿条目、recovery 未尝试、所有 step 都是 `planned` 且 `appliedAt` 为空。
+ * ownership / environmentFingerprint 绑定校验由调用方在**更早**的信任门完成，这里不重复也不放松。
+ */
+function selfProvableResidual(j: OperationJournal): { cls: SelfProvableResidualClass; reason: string } | null {
+  if (!ARTIFACT_ONLY_OPERATION_TYPES.has(j.operationType)) return null
+  if (j.state !== 'APPLYING' && j.state !== 'NEEDS_ATTENTION') return null
+  if (j.snapshotId !== null && j.snapshotId !== '') return null
+  if (j.commit.at !== null) return null
+  if (j.rollback.attemptedAt !== null) return null
+  if (Object.keys(j.rollback.entryDone ?? {}).length > 0) return null
+  if (j.recovery.attemptedAt !== null) return null
+  const steps = Object.values(j.steps)
+  if (steps.some((s) => s.status !== 'planned' || s.appliedAt !== null)) return null
+
+  if (steps.length === 0) {
+    if (j.plannedSteps.length > 0) return null // 悬空 plannedSteps：损坏/篡改 → 保守
+    return { cls: 'no-steps', reason: engineMsg('core.reconcile.selfProvenNoSteps') }
+  }
+  if (steps.every((s) => s.external === true && s.adapter === 'backup')) {
+    return { cls: 'artifact-only', reason: engineMsg('core.reconcile.selfProvenArtifactOnly') }
+  }
+  return null
+}
+
 // ---------- Reconcile ----------
 
 /**
@@ -126,7 +176,7 @@ async function reconcileOne(
   const j = await store.loadActive(operationId);
   if (j === null) {
     // 存在但 parse/校验失败 → corrupt → quarantine
-    const reason = `journal ${operationId} 无法解析或 schema 非法（隔离处理）`;
+    const reason = engineMsg('core.reconcile.journalUnparsable', { opId: operationId });
     if (opts.autoQuarantine !== false) {
       try {
         await store.quarantine(operationId, reason);
@@ -138,7 +188,7 @@ async function reconcileOne(
 
   // live owner 检查
   if (await env.isLiveOwner(j)) {
-    return { decision: { operationId, kind: 'live', reason: 'owner 存活，live operation 进行中', snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
+    return { decision: { operationId, kind: 'live', reason: engineMsg('core.reconcile.ownerLive'), snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
   }
 
   // P1-A：ownership binding 强制校验（显式 recovery 捕获的 crashed ownership 证据）。
@@ -147,7 +197,7 @@ async function reconcileOne(
     const bindingOk = j.ownerInstanceId === env.expectedOwnershipInstanceId
       && j.lockId === env.expectedOwnershipInstanceId; // lockId = 同 epoch identity（ownerInstanceId）
     if (!bindingOk) {
-      const reason = `ownership binding 不匹配（journal.ownerInstanceId/lockId 非 crashed ownership ${env.expectedOwnershipInstanceId}），不作 trusted 恢复`;
+      const reason = engineMsg('core.reconcile.bindingMismatch', { instanceId: env.expectedOwnershipInstanceId });
       await store.writeSafeMode(true).catch(() => undefined);
       await store.appendRecoveryHistory('binding-mismatch', { operationId, at: new Date().toISOString(), reason }).catch(() => undefined);
       return { decision: { operationId, kind: 'needs-attention', reason, snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
@@ -156,29 +206,46 @@ async function reconcileOne(
 
   // env fingerprint
   if (env.environmentFingerprint && j.environmentFingerprint && env.environmentFingerprint !== j.environmentFingerprint) {
-    const reason = `environment fingerprint 不匹配（跨机/环境变化），不自动恢复`;
+    const reason = engineMsg('core.reconcile.envMismatch');
     await store.writeSafeMode(true).catch(() => undefined);
     return { decision: { operationId, kind: 'env-mismatch', reason, snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
   }
 
+  // issue #87：自证「没发生」的残留自动放行（APPLYING/NEEDS_ATTENTION → RECOVERED，history = noop）。
+  // 位置刻意放在 live-owner / ownership-binding / env-fingerprint 三道信任门**之后**、terminal 与步态判定
+  // **之前**：只有已通过全部绑定校验、且形状证明副作用不可能已开始的残留才会走到这里；其余一律落回原保守路径。
+  const residual = selfProvableResidual(j)
+  if (residual !== null) {
+    const reason = residual.reason
+    await store.update(operationId, (cur) => {
+      let next = transitionJournalState(cur, 'RECOVERED')
+      next = { ...next, recovery: { ...next.recovery, attemptedAt: new Date().toISOString(), outcome: 'RECOVERED', reason, attempts: next.recovery.attempts + 1 } }
+      return next
+    })
+    await store.moveToCompleted(operationId).catch(() => undefined)
+    await store.appendRecoveryHistory('noop', { operationId, at: new Date().toISOString(), reason }).catch(() => undefined)
+    return { decision: { operationId, kind: 'noop', reason, snapshotId: j.snapshotId }, safeMode: false, unresolved: false }
+  }
+
   // terminal 遗留 active → 规整到 completed（无实质 recovery）
   if (isTerminalState(j.state)) {
     if (j.state === 'NEEDS_ATTENTION') {
       // NEEDS_ATTENTION 是「待用户确认」状态，保持 active 可见（不静默规整），SAFE MODE
       await store.writeSafeMode(true).catch(() => undefined);
-      return { decision: { operationId, kind: 'needs-attention', reason: 'NEEDS_ATTENTION 待用户确认', snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
+      return { decision: { operationId, kind: 'needs-attention', reason: engineMsg('core.reconcile.needsAttentionConfirm'), snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
     }
     // COMMITTED / ROLLED_BACK / RECOVERED 遗留 → 规整
     if (opts.organizeTerminal !== false) {
       try { await store.moveToCompleted(operationId); } catch { /* move 失败不影响 */ }
     }
-    return { decision: { operationId, kind: 'organized', reason: `terminal(${j.state}) journal 规整到 completed`, snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
+    return { decision: { operationId, kind: 'organized', reason: engineMsg('core.reconcile.terminalOrganized', { state: j.state }), snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
   }
 
   // 回滚进行中（ROLLING_BACK）或已部分补偿（entryDone 非空）：**绝不判 RECOVERED**
   // （P0-B：崩溃在回滚中 = 半回滚态，判 recovered 会把破坏状态误报为成功）。
   if (j.state === 'ROLLING_BACK' || Object.keys(j.rollback.entryDone ?? {}).length > 0) {
-    const reason = `回滚中断（${j.state === 'ROLLING_BACK' ? 'ROLLING_BACK' : `entryDone ${Object.keys(j.rollback.entryDone).join(',')}`}），需显式续跑回滚（用户确认）`;
+    const rollbackDetail = j.state === 'ROLLING_BACK' ? 'ROLLING_BACK' : `entryDone ${Object.keys(j.rollback.entryDone).join(',')}`;
+    const reason = engineMsg('core.reconcile.rollbackInterrupted', { detail: rollbackDetail });
     await store.writeSafeMode(true).catch(() => undefined);
     await store.appendRecoveryHistory('rollback-interrupted', { operationId, at: new Date().toISOString(), reason }).catch(() => undefined);
     return { decision: { operationId, kind: 'rollback-continue', reason, snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
@@ -194,7 +261,7 @@ async function reconcileOne(
     const v = j.recoveryVerification;
     const verified = v !== undefined && (v.verdict === 'MATCH' || v.verdict === 'PARTIAL_MATCH');
     if (!verified) {
-      const reason = 'RECOVERING 且 recovery 未验证（无 recoveryVerification 或 verdict 非 MATCH/PARTIAL_MATCH），绝不自动 RECOVERED';
+      const reason = engineMsg('core.reconcile.recoveringUnverified');
       await store.writeSafeMode(true).catch(() => undefined);
       await store.update(operationId, (cur) => {
         let next = transitionJournalState(cur, 'NEEDS_ATTENTION');
@@ -221,7 +288,7 @@ async function reconcileOne(
       // Review D P2：plannedSteps 引用悬空（steps 缺条目）→ 不可证明，绝不能经 noop 判 RECOVERED。
       anyUnprovable = true;
       allDoneConfirmed = false;
-      details.push(`planned step ${stepId} 缺少 steps 条目（损坏/篡改 journal）`);
+      details.push(engineMsg('core.reconcile.danglingPlannedStep', { stepId }));
       continue;
     }
 
@@ -244,9 +311,9 @@ async function reconcileOne(
       let verdict: StepFingerprintVerdict;
       try { verdict = await hooks.verifyStepFingerprint(step); } catch { verdict = 'unable'; }
       if (verdict === 'after-match') { anyApplied = true; continue; }
-      if (verdict === 'before-match') { anyApplied = false; details.push(`step ${step.ref} 未可靠完成（磁盘==before）`); allDoneConfirmed = false; anyUnprovable = true; continue; }
+      if (verdict === 'before-match') { anyApplied = false; details.push(engineMsg('core.reconcile.stepNotReliablyDone', { ref: step.ref })); allDoneConfirmed = false; anyUnprovable = true; continue; }
       anyUnprovable = true; allDoneConfirmed = false;
-      details.push(`step ${step.ref} 指纹 ${verdict}`);
+      details.push(engineMsg('core.reconcile.stepFingerprint', { ref: step.ref, verdict }));
     } else {
       // planned/attention/failed → 未完成
       allDoneConfirmed = false;
@@ -279,13 +346,13 @@ async function reconcileOne(
       });
       await store.moveToCompleted(operationId).catch(() => undefined);
       await store.appendRecoveryHistory('noop', { operationId, at: new Date().toISOString(), reason: 'no mutation started' }).catch(() => undefined);
-      return { decision: { operationId, kind: 'noop', reason: 'mutation 未开始，安全完成', snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
+      return { decision: { operationId, kind: 'noop', reason: engineMsg('core.reconcile.mutationNotStarted'), snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
     }
     // APPLYING（或其它非 terminal）：mutation 可能已开始，无法证明
     if (j.snapshotId !== null && snapshotExists) {
       // 有 trusted bound snapshot → rollback-recommended（需用户确认）
       await store.writeSafeMode(true).catch(() => undefined);
-      const reason = 'opaque APPLYING（空 steps）且 mutation 可能已开始，有 trusted snapshot 可回滚（需用户确认）';
+      const reason = engineMsg('core.reconcile.opaqueRollbackAvailable');
       await store.update(operationId, (cur) => {
         let next = transitionJournalState(cur, 'NEEDS_ATTENTION');
         next = { ...next, error: next.error || reason, recovery: { ...next.recovery, reason, attempts: next.recovery.attempts + 1 } };
@@ -296,7 +363,7 @@ async function reconcileOne(
     }
     // 无 trusted snapshot → NEEDS_ATTENTION（SAFE MODE）
     await store.writeSafeMode(true).catch(() => undefined);
-    const reason = 'opaque APPLYING（空 steps）且 mutation 可能已开始，无 trusted snapshot 可回滚';
+    const reason = engineMsg('core.reconcile.opaqueNoSnapshot');
     await store.update(operationId, (cur) => {
       let next = transitionJournalState(cur, 'NEEDS_ATTENTION');
       next = { ...next, error: next.error || reason, recovery: { ...next.recovery, reason, attempts: next.recovery.attempts + 1 } };
@@ -328,13 +395,14 @@ async function reconcileOne(
     });
     await store.moveToCompleted(operationId).catch(() => undefined);
     await store.appendRecoveryHistory('noop', { operationId, at: new Date().toISOString(), reason: 'no step applied' }).catch(() => undefined);
-    return { decision: { operationId, kind: 'noop', reason: '无副作用可恢复，安全完成', snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
+    return { decision: { operationId, kind: 'noop', reason: engineMsg('core.reconcile.noSideEffects'), snapshotId: j.snapshotId }, safeMode: false, unresolved: false };
   }
 
   if (anyUnprovable || anyExternalUnknown || !snapshotExists) {
     // 不可证明 / 外部未知 / 快照缺失 → NEEDS_ATTENTION（SAFE MODE）
     await store.writeSafeMode(true).catch(() => undefined);
-    const reason = `不可证明步骤: ${details.join('; ') || '外部副作用未知'}` + (snapshotExists ? '' : '；快照缺失');
+    const reason = engineMsg('core.reconcile.unprovableSteps', { details: details.join('; ') || engineMsg('core.reconcile.externalSideEffectsUnknown') })
+      + (snapshotExists ? '' : engineMsg('core.reconcile.snapshotMissingSuffix'));
     await store.update(operationId, (cur) => {
       let next = transitionJournalState(cur, 'NEEDS_ATTENTION');
       next = { ...next, error: next.error || reason, recovery: { ...next.recovery, reason, attempts: next.recovery.attempts + 1 } };
@@ -346,7 +414,7 @@ async function reconcileOne(
 
   // 快照有效 + 已应用部分 + 无不可证明 → rollback 可安全执行（需用户确认）
   await store.writeSafeMode(true).catch(() => undefined);
-  const reason = '部分 step 已应用，可安全回滚（需用户确认）';
+  const reason = engineMsg('core.reconcile.partialApplied');
   return { decision: { operationId, kind: 'rollback-recommended', reason, snapshotId: j.snapshotId }, safeMode: true, unresolved: true };
 }