dsh-config-manager 0.1.80 → 0.1.82

package/lib/core/import-planning.js

@@ -0,0 +1,305 @@
+/**
+ * 导入「计划期纯函数」集合（P4 拆分）：从 `core/analyzer.ts` 尾部原样外提，**零行为改动**。
+ *
+ * 为什么单独成文件：analyzer 曾 1824 行、装着三段式引擎 + 13 个互不相关的纯函数，
+ * 任何一处（如墓碑过滤）的阅读都得先跳过引擎实现。这里只收「不碰 fs、不改入参」的纯计算，
+ * 引擎类（Analyzer）留在 `analyzer.ts`；两者单向依赖：analyzer → 本模块，本模块不 import analyzer。
+ *
+ * 对外导入面不变：analyzer.ts 仍 re-export 原本导出的 3 个名字（rebaseMapping /
+ * applyMappingsToSections / runSchemaMigration），core/index.ts 与既有测试无需改 import。
+ */
+import { sha256Hex } from '../utils/hashing.js';
+import { isAbsolutePath, applyPrefixMappings } from '../utils/paths.js';
+import { isFileSection } from '../schema/config.js';
+import { validateManifest } from '../schema/manifest.js';
+import { migrateToCurrent } from '../migrations/index.js';
+import { isTombstoned } from '../schema/tombstones.js';
+export async function reportRollbackToJournal(binding, report) {
+    const reporter = binding;
+    await reporter?.recordRollback?.(report);
+}
+/* ---------------- 纯函数辅助 ---------------- */
+/**
+ * G-06：执行 schema 迁移链并把迁移结果重新校验为合法 manifest。
+ *
+ * `migrateToCurrent` 此前在 `src/` 内零引用（迁移链有定义、有单测、从不执行）；
+ * `loadBundle` 只用 isSupported 做判定就直接把旧文档当新格式使用。本函数是迁移链的
+ * **真实接线点**：沿链迁移 → 重新校验结果是合法 manifest（不合法则抛明确错误，
+ * 绝不把半迁移文档当合法 manifest 继续）→ 每个已应用步骤翻译成用户可见告警。
+ *
+ * 显式传入 from/target 使「链式迁移真的被执行」可被直接单测：当前
+ * `MIN_SUPPORTED_SCHEMA_VERSION = CURRENT_SCHEMA_VERSION = 1`，`needsMigration` 恒假，
+ * 因此该分支在真实导入中结构上不可达（loadBundle 仍按 needsMigration 调用本函数）。
+ */
+export function runSchemaMigration(doc, fromVersion, targetVersion, msg) {
+    const result = migrateToCurrent(doc, fromVersion, targetVersion);
+    const issues = validateManifest(result.doc).filter((i) => i.severity === 'error');
+    if (issues.length > 0) {
+        throw new Error(msg('import.migrateInvalidManifest', { issues: issues.map((i) => i.message).join('; ') }));
+    }
+    return {
+        manifest: result.doc,
+        warnings: result.applied.map((step) => msg('import.migrated', { from: String(step.from), to: String(step.to) })),
+    };
+}
+export async function verifyAgainstTable(entries, table) {
+    const mismatches = [];
+    const missing = [];
+    for (const [relPath, expected] of Object.entries(table)) {
+        const data = entries.get(relPath);
+        if (data === undefined) {
+            missing.push(relPath);
+            continue;
+        }
+        if (sha256Hex(data) !== expected)
+            mismatches.push(relPath);
+    }
+    return { ok: mismatches.length === 0 && missing.length === 0, mismatches, missing };
+}
+/**
+ * 冲突决策（applyItemResolution）已抽到 `./conflict-decisions.ts`：
+ * 与恢复/回放路径共用同一份语义（回放侧随灾备快照线下线，语义仍是同一条）。
+ */
+/**
+ * 基础路径重定基规则：导出机 DSH home → 本机 DSH home（issue #45 用户补充）。
+ *
+ * 只在「两边的规范化路径都是绝对路径、且不相同」时生成；两侧都去掉尾部分隔符后比较，
+ * 避免 /opt/.dsh/ 与 /opt/.dsh 被判成不同而白跑一次全量替换。前缀匹配仍由 applyPrefixMappings
+ * 负责（必须落在段边界），所以 /opt/.dsh 不会误伤 /opt/.dsh-extra。
+ *
+ * @returns 映射规则；不需要重定基（缺 sourceHome / 相同 / 相对路径）→ undefined
+ */
+export function rebaseMapping(sourceHome, localHome) {
+    if (sourceHome === undefined || sourceHome === '')
+        return undefined;
+    const strip = (value) => value.replace(/\\/g, '/').replace(/\/+$/, '');
+    const from = strip(sourceHome);
+    const to = strip(localHome ?? '');
+    if (from === '' || to === '' || from === to)
+        return undefined;
+    const isAbsolute = (value) => value.startsWith('/') || /^[a-zA-Z]:[\/]/.test(value);
+    if (!isAbsolute(from) || !isAbsolute(to))
+        return undefined;
+    return { oldPrefix: from, newPrefix: to, appliesTo: [] };
+}
+/**
+ * 会话单元版本查询：探针的单元键（`projectKey/会话目录`）与计划项单元 id
+ * （`sessions:projectKey/会话目录`）是两个键空间，必须两种形态都试。
+ *
+ * 为什么不在探针里直接带上适配器前缀：探针只认「分区内的相对路径」，它不知道也不该知道
+ * 哪个适配器在消费它（core 也不得 import 会话字节工具）。键空间对齐因此落在计划生成期。
+ */
+export function sessionUnitVersion(byUnit, unitId) {
+    const direct = byUnit.get(unitId);
+    if (direct !== undefined)
+        return direct;
+    const prefix = 'sessions:';
+    const bare = unitId.startsWith(prefix) ? unitId.slice(prefix.length) : prefix + unitId;
+    return byUnit.get(bare);
+}
+/** 路径映射合并：只保留「已解析」（newPrefix 非空）的映射用于执行期数据改写；
+ * 未解决项（newPrefix 空）保留在 plan.items 里供 UI 提示，但不参与数据映射。 */
+export function mergePathMappings(items, userMappings) {
+    const merged = new Map();
+    for (const m of userMappings) {
+        if (m.newPrefix !== '')
+            merged.set(m.oldPrefix, m);
+    }
+    return [...merged.values()];
+}
+/**
+ * 把映射应用到分区数据（PathMapper 先行：只替换匹配前缀的字符串叶值）。
+ *
+ * `fileCollectionIds` 里的分区一律跳过：`FileCollectionAdapter` 把 `relativePath` 当落盘路径用，
+ * 它必须逐字保留（issue #45 ④：改写会话文件的相对路径会让目标机下次启动直接报
+ * `corrupt session log`；pluginFiles/skills 等同理——丢位置等于丢归属）。
+ * 映射在这些分区上**没有任何合法作用**：文件内容存的是字节（`Uint8Array` 叶子），不会被改。
+ */
+export function applyMappingsToSections(sections, mappings, fileCollectionIds = new Set()) {
+    if (mappings.length === 0)
+        return;
+    for (const [sectionId, data] of sections) {
+        if (fileCollectionIds.has(sectionId))
+            continue;
+        const appliesTo = sectionId === 'workspaces' ? ['workspaces']
+            : sectionId === 'mcp' ? ['mcp']
+                : sectionId === 'skills' ? ['skills']
+                    : sectionId === 'pluginFiles' ? ['pluginConfig']
+                        : [];
+        const relevant = mappings.filter((m) => m.appliesTo.some((a) => appliesTo.includes(a)) || m.appliesTo.length === 0);
+        if (relevant.length === 0)
+            continue;
+        sections.set(sectionId, applyPrefixMappings(data, relevant));
+    }
+}
+/** 路径形态判定：跨平台盘符/UNIX 冲突 → platformMismatch；其余绝对路径 → missing（需映射） */
+export function detectPathIssues(sourcePlatform, targetPlatform, sections) {
+    const issues = [];
+    const workspaces = sections.get('workspaces');
+    for (const w of workspaces?.workspaces ?? []) {
+        const p = w.path;
+        // section：如实标注来源分区，供导入向导按「本次会写盘的分区」过滤（见 PathIssue.section）
+        if (p && isAbsolutePath(p))
+            issues.push({ ...judgePath(p, sourcePlatform, targetPlatform), section: 'workspaces' });
+    }
+    const mcp = sections.get('mcp');
+    for (const s of mcp?.servers ?? []) {
+        for (const p of [s.cwd, s.command]) {
+            if (p && isAbsolutePath(p))
+                issues.push({ ...judgePath(p, sourcePlatform, targetPlatform), section: 'mcp' });
+        }
+    }
+    // 去重
+    const seen = new Set();
+    return issues.filter((i) => {
+        const key = `${i.kind}:${i.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function judgePath(p, sourcePlatform, targetPlatform) {
+    const isWinStyle = /^[a-zA-Z]:[\\/]/.test(p);
+    const isUnixStyle = p.startsWith('/');
+    if (sourcePlatform !== targetPlatform && ((isWinStyle && targetPlatform !== 'win32') || (isUnixStyle && targetPlatform === 'win32'))) {
+        return { kind: 'platformMismatch', value: p };
+    }
+    return { kind: 'missing', value: p };
+}
+/**
+ * 凭据计划项（MissingSecret / Skip）在**导入路径**上的唯一生成点。
+ *
+ * ref 来源取**并集**：① credentialsStatus 里 configured=true 的 ref（源机声明「有」，
+ * 但普通备份不带值）；② 宿主解密出的归档 ref（`opts.decryptedCredentials`）——
+ * 加密备份携带的是 `.credentials.yaml` **原文**，可能含未被任何 settings namespace 引用的 ref
+ * （如其它插件自用的 key），只认 ① 会让这些值静默丢掉（真机反馈：导入密钥没生效）。
+ *
+ * 规则（与同步侧 sync-engine.appendCredentialPlanItems 同口径：**值的有无**优先于本机状态）：
+ *  - **有值** → MissingSecret「随加密备份恢复」：用户显式勾了「导出密钥」，导入即写回；
+ *    **不因本机已有而跳过**（跳过 = 用户以为密钥导入了、其实没写）。
+ *  - **无值**（只有 ref 名）→ 本机已配置 → Skip（保留本机值、不再索要补录，用户报告
+ *    「已有的重复密钥也会提示」）；本机没有 → MissingSecret「需要补录」。
+ *
+ * 凭据值不可回读，因此无值分支一律不覆盖本机已有值。
+ *
+ * @param decrypted 归档里解出的 ref→值（仅内存；undefined = 未提供密码/无凭据载荷）
+ * @param isConfiguredLocally 目标机是否已配置该 ref（读不到 → false，保守按需补录处理）
+ */
+/**
+ * 凭据值「可用」的**唯一判据**（t14 / core-F2 修）：必须是非空字符串。
+ *
+ * 此前三处各判各的 —— 计划期用 `Map.has()`（空串也算「有值」）、执行期用 `value !== ''`、
+ * 结果期又用 `Map.has()`。于是「归档里该 ref 的值为空串」时：计划项说「随加密备份恢复」，
+ * 执行静默跳过，结果既不报缺失还把该 ref 算成「已从归档写回」—— 用户看到「导入完成」，
+ * 密钥其实没写进去（静默 no-op）。三处必须同源，否则该缺陷会再次以另一种形态复发。
+ */
+export function usableSecretValue(decrypted, inputs, ref) {
+    const fromArchive = decrypted?.get(ref);
+    if (typeof fromArchive === 'string' && fromArchive !== '')
+        return true;
+    const fromInput = inputs?.[ref];
+    return typeof fromInput === 'string' && fromInput !== '';
+}
+export async function buildCredentialPlanItems(items, sections, decrypted, msg, isConfiguredLocally) {
+    const creds = sections.get('credentialsStatus');
+    const declared = [];
+    for (const c of creds?.credentials ?? []) {
+        if (typeof c.ref === 'string' && c.ref !== '' && c.configured === true)
+            declared.push(c.ref);
+    }
+    const refs = [...new Set([...declared, ...(decrypted?.keys() ?? [])])];
+    const existing = new Set(items.map((i) => i.id));
+    for (const ref of refs) {
+        const id = `secret:${ref}`;
+        if (existing.has(id))
+            continue;
+        existing.add(id);
+        const target = { adapter: 'credentialsStatus', ref };
+        if (usableSecretValue(decrypted, undefined, ref)) {
+            items.push({
+                id,
+                kind: 'MissingSecret',
+                adapter: 'credentialsStatus',
+                description: msg('import.secretFromArchive', { ref }),
+                severity: 'warning',
+                target,
+            });
+            continue;
+        }
+        if (await isConfiguredLocally(ref)) {
+            items.push({
+                id,
+                kind: 'Skip',
+                adapter: 'credentialsStatus',
+                description: msg('import.secretAlreadyConfigured', { ref }),
+                severity: 'info',
+                target,
+            });
+            continue;
+        }
+        items.push({
+            id,
+            kind: 'MissingSecret',
+            adapter: 'credentialsStatus',
+            description: msg('import.secretMissingDesc', { ref }),
+            severity: 'warning',
+            target,
+        });
+    }
+}
+/* ---------------- F4 删除墓碑过滤（纯函数，可独立测试） ---------------- */
+/**
+ * 按删除墓碑过滤计划项（F4）：
+ *  - 条目级：插件（Install/Update/Conflict）、技能（skills 文件）、文件类条目（agentPresets 等）命中墓碑 → 剔除；
+ *  - 分区级：墓碑 kind='section' 且 id=分区 id → 整分区跳过（仅记一条 skipped）。
+ * 返回过滤后的 items 与被跳过清单（纯函数：不读文件、不改入参）。
+ */
+export function applyTombstoneFilter(items, tombstones) {
+    if (tombstones.length === 0)
+        return { items, skipped: [] };
+    const tombstonedSections = new Set(tombstones.filter((t) => t.kind === 'section').map((t) => t.id));
+    const skipped = [];
+    const out = [];
+    const reportedSections = new Set();
+    for (const item of items) {
+        // 分区级墓碑优先：整个分区不出现（含 Skip 等非写入项，UI 提示「该分区已删除」）
+        if (tombstonedSections.has(item.adapter)) {
+            if (!reportedSections.has(item.adapter)) {
+                skipped.push({ kind: 'section', id: item.adapter, adapter: item.adapter });
+                reportedSections.add(item.adapter);
+            }
+            continue;
+        }
+        const key = tombstoneKeyForItem(item);
+        if (key !== null && isTombstoned(key.kind, key.id, tombstones)) {
+            skipped.push({ kind: key.kind, id: key.id, adapter: item.adapter });
+            continue;
+        }
+        out.push(item);
+    }
+    return { items: out, skipped };
+}
+/** PlanItem → 墓碑键（{kind,id}）映射；非「将写入」的条目（Skip 等）与配置类项返回 null 不过滤 */
+export function tombstoneKeyForItem(item) {
+    // 插件本体（plugin:<pkg>）：Install / Update / Conflict 均视为「将写入该插件」→ 命中墓碑剔除；
+    // issue #95 的 Create = 「把 host 自带的层声明进 dsh.profile.bundles」，同样是写入该插件，
+    // 必须一起被墓碑剔除（用户删过的插件不得被一份旧备份重新声明回来）。
+    // patch: 行与 plugins:pnpm-workspace 是配置类项，不按插件墓碑过滤（分区级墓碑可覆盖）。
+    if (item.adapter === 'plugins' && item.id.startsWith('plugin:')) {
+        if (item.kind !== 'Install' && item.kind !== 'Update' && item.kind !== 'Conflict' && item.kind !== 'Create')
+            return null;
+        return { kind: 'plugin', id: item.id.slice('plugin:'.length) };
+    }
+    // 文件类分区条目（id = <分区>:<相对路径>）：skills → skill 墓碑；其余文件类（agentPresets/
+    // agentInstructions/pluginFiles/sessions/self）→ 通用 file 墓碑（id 为相对路径）。
+    if (item.kind === 'Create' || item.kind === 'Update' || item.kind === 'Conflict') {
+        const prefix = `${item.adapter}:`;
+        if (item.adapter === 'skills')
+            return { kind: 'skill', id: item.id.slice(prefix.length) };
+        if (isFileSection(item.adapter))
+            return { kind: 'file', id: item.id.slice(prefix.length) };
+    }
+    return null;
+}
+//# sourceMappingURL=import-planning.js.map

package/lib/core/journal.d.ts

@@ -21,6 +21,18 @@ export declare const ALLOWED_TRANSITIONS: Record<JournalState, JournalState[]>;
 export declare function isValidTransition(from: JournalState, to: JournalState): boolean;
 export declare function isTerminalState(s: JournalState): boolean;
 export type StepStatus = 'planned' | 'done' | 'failed' | 'skipped' | 'attention';
+/**
+ * 指纹哨兵：「该路径**本就不该存在**」（删除类动作的期望态）。
+ *
+ * 为什么需要：文件类 step 的 beforeFp/afterFp 一直是「文件内容 sha256」，而**删除**动作的正确
+ * 终态是「文件不存在」—— 没有任何 sha256 能表达它，于是删除项在 crash 后永远无法自证已应用
+ * （reconcile 只能判 none → NEEDS_ATTENTION）。本哨兵把「应不存在」变成可比较的值：
+ *  - beforeFp = ABSENT_FINGERPRINT ⇒ 「留点时不在」
+ *  - afterFp  = ABSENT_FINGERPRINT ⇒ 「做完后不在」
+ * 判定只有一处（phase3-host 的 verifyStepFingerprint）；importer 的指纹永远是十六进制 sha256
+ * 或 null，因此本哨兵对导入链路零影响。
+ */
+export declare const ABSENT_FINGERPRINT = "absent";
 export interface JournalStep {
     adapter: string;
     ref: string;

package/lib/core/journal.js

@@ -71,6 +71,18 @@ export function isValidTransition(from, to) {
 export function isTerminalState(s) {
     return TERMINAL_STATES.has(s);
 }
+/**
+ * 指纹哨兵：「该路径**本就不该存在**」（删除类动作的期望态）。
+ *
+ * 为什么需要：文件类 step 的 beforeFp/afterFp 一直是「文件内容 sha256」，而**删除**动作的正确
+ * 终态是「文件不存在」—— 没有任何 sha256 能表达它，于是删除项在 crash 后永远无法自证已应用
+ * （reconcile 只能判 none → NEEDS_ATTENTION）。本哨兵把「应不存在」变成可比较的值：
+ *  - beforeFp = ABSENT_FINGERPRINT ⇒ 「留点时不在」
+ *  - afterFp  = ABSENT_FINGERPRINT ⇒ 「做完后不在」
+ * 判定只有一处（phase3-host 的 verifyStepFingerprint）；importer 的指纹永远是十六进制 sha256
+ * 或 null，因此本哨兵对导入链路零影响。
+ */
+export const ABSENT_FINGERPRINT = 'absent';
 export function createJournalEntry(operationType, lockCtx, now) {
     return {
         schemaVersion: JOURNAL_SCHEMA_VERSION,

package/lib/core/messages.d.ts

@@ -390,6 +390,7 @@ export declare const zh: {
     readonly 'sync.git.repoUnreachable': '仓库不可达或认证失败: {url}';
     readonly 'sync.git.workDirNotRepo': 'workDir 不是 git 仓库（缺少 .git）且目录非空，无法 clone: {dir}';
     readonly 'sync.git.pullFailed': 'git pull 失败: {err}';
+    readonly 'sync.git.workdirBusy': '同步工作副本 {dir} 正被另一个同步任务占用（另一个 DSH 实例，或上一轮同步还没结束）：已等待超时。请稍后重试。';
     readonly 'sync.git.hostKeyUnverified': 'SSH 主机密钥校验失败：本机 known_hosts 里没有 {host} 的密钥（或密钥已变更），git 因此拒绝连接。请先核对主机指纹，再在本机执行 ssh-keyscan -p <端口> {host} >> ~/.ssh/known_hosts（或直接 ssh {host} 按提示确认）后重试 —— 插件不会自动信任任何主机。';
     readonly 'sync.git.hostKeyUnverifiedNoHost': 'SSH 主机密钥校验失败：本机 known_hosts 里没有该主机的密钥（或密钥已变更），git 因此拒绝连接。请先核对主机指纹，再在本机用 ssh-keyscan 把该主机写入 ~/.ssh/known_hosts（或直接 ssh 该主机按提示确认）后重试 —— 插件不会自动信任任何主机。';
     readonly 'sync.git.historyDiverged': '本地工作副本 {dir} 与远端不是同一条历史（远端换了仓库，或远端历史被重写）：已拒绝合并。请把仓库地址改回原仓库，或在「同步 → 通道配置」里重建工作副本。';
@@ -431,6 +432,7 @@ export declare const zh: {
     readonly 'market.repoUnreachable': '市场仓库不可达: {url}';
     readonly 'market.cloneFailed': '市场仓库拉取（clone）失败: {err}';
     readonly 'market.pullFailed': '市场仓库同步（pull）失败: {err}';
+    readonly 'market.workdirBusy': '市场工作副本 {dir} 正被另一个任务占用（读取或上传还没结束）：已等待超时。请稍后重试。';
     readonly 'market.workDirNotRepo': '市场工作目录非空且不是 git 仓库，无法 clone: {dir}';
     readonly 'market.missingIndex': '市场缺少 index.json: {url}';
     readonly 'market.missingManifest': '条目 {id} 缺少 manifest.json';
@@ -467,6 +469,21 @@ export declare const zh: {
     readonly 'command.rollback.segmentFacts': '段：{facts}';
     readonly 'command.rollback.rewindFailed': '回退失败（{code}）：{id}。{detail}';
     readonly 'command.rollback.mutationLocked': '当前不能写（{reason}），回退未执行：{id}。请先解除 SAFE MODE 或等其它任务结束。';
+    readonly 'restore.resume.noActive': '没有可续跑的恢复记录';
+    readonly 'restore.resume.terminal': '恢复记录 {state} 不能自动续跑（只有「写了几个动作后崩掉」的 APPLYING 才可续）';
+    readonly 'restore.resume.wrongOperation': '这条记录属于另一类操作（{operationType}），不是恢复';
+    readonly 'restore.resume.rollbackInFlight': '上一次恢复已开始回滚（{count} 项），不再向前续跑';
+    readonly 'restore.resume.noSnapshot': '记录绑定的快照（{actual}）不是本次要恢复的快照（{expected}）';
+    readonly 'restore.resume.planDrift': '当前计划与崩溃那次登记的步骤对不上：{detail}';
+    readonly 'restore.resume.untrustedStep': '崩溃记录里有无法信任的步骤：{detail}';
+    readonly 'restore.resume.externalUnproven': '含无法自证的插件卸载（{detail}），请到「事故恢复」里处理';
+    readonly 'restore.resume.stepAttention': '{count} 个动作上次未成功（{detail}），不自动续跑';
+    readonly 'restore.resume.fingerprintDrift': '{path} 的内容既不是执行前也不是执行后（{detail}），不自动续跑';
+    readonly 'restore.resume.detected': '检测到未完成的恢复 {operationId}：已完成 {done} 项、待做 {todo} 项，本次自动续跑';
+    readonly 'restore.resumedSkip': '续跑跳过（上次已完成）：{description}';
+    readonly 'core.phase3.resumeMissing': '续跑失败：找不到 active journal {opId}（可能已被恢复面板收敛）';
+    readonly 'core.phase3.resumeTerminal': '续跑失败：journal {opId} 已处于终态 {state}';
+    readonly 'core.phase3.resumeWrongType': '续跑失败：journal {opId} 的操作类型是 {actual}，本次要求 {expected}';
 };
 export declare const en: Record<keyof typeof zh, string>;
 /**

package/lib/core/messages.js

@@ -384,6 +384,8 @@ export const zh = {
     'sync.git.repoUnreachable': '仓库不可达或认证失败: {url}',
     'sync.git.workDirNotRepo': 'workDir 不是 git 仓库（缺少 .git）且目录非空，无法 clone: {dir}',
     'sync.git.pullFailed': 'git pull 失败: {err}',
+    // 工作副本锁等锁超时（并发同步 / 另一个 DSH 实例正在用同一个工作副本）
+    'sync.git.workdirBusy': '同步工作副本 {dir} 正被另一个同步任务占用（另一个 DSH 实例，或上一轮同步还没结束）：已等待超时。请稍后重试。',
     // issue #79：主机密钥与「换仓库地址」两类失败此前只透出 git 原始 stderr，用户无从下手
     'sync.git.hostKeyUnverified': 'SSH 主机密钥校验失败：本机 known_hosts 里没有 {host} 的密钥（或密钥已变更），git 因此拒绝连接。请先核对主机指纹，再在本机执行 ssh-keyscan -p <端口> {host} >> ~/.ssh/known_hosts（或直接 ssh {host} 按提示确认）后重试 —— 插件不会自动信任任何主机。',
     'sync.git.hostKeyUnverifiedNoHost': 'SSH 主机密钥校验失败：本机 known_hosts 里没有该主机的密钥（或密钥已变更），git 因此拒绝连接。请先核对主机指纹，再在本机用 ssh-keyscan 把该主机写入 ~/.ssh/known_hosts（或直接 ssh 该主机按提示确认）后重试 —— 插件不会自动信任任何主机。',
@@ -430,6 +432,7 @@ export const zh = {
     'market.repoUnreachable': '市场仓库不可达: {url}',
     'market.cloneFailed': '市场仓库拉取（clone）失败: {err}',
     'market.pullFailed': '市场仓库同步（pull）失败: {err}',
+    'market.workdirBusy': '市场工作副本 {dir} 正被另一个任务占用（读取或上传还没结束）：已等待超时。请稍后重试。',
     'market.workDirNotRepo': '市场工作目录非空且不是 git 仓库，无法 clone: {dir}',
     'market.missingIndex': '市场缺少 index.json: {url}',
     'market.missingManifest': '条目 {id} 缺少 manifest.json',
@@ -468,6 +471,22 @@ export const zh = {
     'command.rollback.segmentFacts': '段：{facts}',
     'command.rollback.rewindFailed': '回退失败（{code}）：{id}。{detail}',
     'command.rollback.mutationLocked': '当前不能写（{reason}），回退未执行：{id}。请先解除 SAFE MODE 或等其它任务结束。',
+    // ---------- 恢复续跑（崩溃后再点一次恢复 = 接着做；判定见 core/restore-resume.ts） ----------
+    'restore.resume.noActive': '没有可续跑的恢复记录',
+    'restore.resume.terminal': '恢复记录 {state} 不能自动续跑（只有「写了几个动作后崩掉」的 APPLYING 才可续）',
+    'restore.resume.wrongOperation': '这条记录属于另一类操作（{operationType}），不是恢复',
+    'restore.resume.rollbackInFlight': '上一次恢复已开始回滚（{count} 项），不再向前续跑',
+    'restore.resume.noSnapshot': '记录绑定的快照（{actual}）不是本次要恢复的快照（{expected}）',
+    'restore.resume.planDrift': '当前计划与崩溃那次登记的步骤对不上：{detail}',
+    'restore.resume.untrustedStep': '崩溃记录里有无法信任的步骤：{detail}',
+    'restore.resume.externalUnproven': '含无法自证的插件卸载（{detail}），请到「事故恢复」里处理',
+    'restore.resume.stepAttention': '{count} 个动作上次未成功（{detail}），不自动续跑',
+    'restore.resume.fingerprintDrift': '{path} 的内容既不是执行前也不是执行后（{detail}），不自动续跑',
+    'restore.resume.detected': '检测到未完成的恢复 {operationId}：已完成 {done} 项、待做 {todo} 项，本次自动续跑',
+    'restore.resumedSkip': '续跑跳过（上次已完成）：{description}',
+    'core.phase3.resumeMissing': '续跑失败：找不到 active journal {opId}（可能已被恢复面板收敛）',
+    'core.phase3.resumeTerminal': '续跑失败：journal {opId} 已处于终态 {state}',
+    'core.phase3.resumeWrongType': '续跑失败：journal {opId} 的操作类型是 {actual}，本次要求 {expected}',
 };
 export const en = {
     // ---------- export ----------
@@ -854,6 +873,7 @@ export const en = {
     'sync.git.repoUnreachable': 'Repository unreachable or authentication failed: {url}',
     'sync.git.workDirNotRepo': 'workDir is not a git repository (no .git) and the directory is not empty; cannot clone: {dir}',
     'sync.git.pullFailed': 'git pull failed: {err}',
+    'sync.git.workdirBusy': 'The sync working copy {dir} is in use by another sync task (another DSH instance, or a previous sync that has not finished yet): the wait timed out. Please retry later.',
     // issue #79: host-key and "repository address changed" failures previously leaked raw git stderr
     'sync.git.hostKeyUnverified': 'SSH host key verification failed: this machine has no key for {host} in known_hosts (or the key changed), so git refused to connect. Verify the host fingerprint first, then run ssh-keyscan -p <port> {host} >> ~/.ssh/known_hosts on this machine (or just ssh {host} and confirm the prompt), then retry — the plugin never trusts a host automatically.',
     'sync.git.hostKeyUnverifiedNoHost': 'SSH host key verification failed: this machine has no key for that host in known_hosts (or the key changed), so git refused to connect. Verify the host fingerprint first, then add the host to ~/.ssh/known_hosts with ssh-keyscan (or just ssh the host and confirm the prompt), then retry — the plugin never trusts a host automatically.',
@@ -899,6 +919,7 @@ export const en = {
     'market.repoUnreachable': 'Marketplace repository unreachable: {url}',
     'market.cloneFailed': 'Marketplace repository clone failed: {err}',
     'market.pullFailed': 'Marketplace repository sync (pull) failed: {err}',
+    'market.workdirBusy': 'The marketplace working copy {dir} is in use by another task (a read or upload is still running); timed out waiting. Please retry shortly.',
     'market.workDirNotRepo': 'Marketplace working directory is not a git repo and is not empty; cannot clone: {dir}',
     'market.missingIndex': 'Marketplace is missing index.json: {url}',
     'market.missingManifest': 'Item {id} is missing manifest.json',
@@ -937,6 +958,22 @@ export const en = {
     'command.rollback.segmentFacts': 'segments: {facts}',
     'command.rollback.rewindFailed': 'Rewind failed ({code}): {id}. {detail}',
     'command.rollback.mutationLocked': 'Writing is currently blocked ({reason}); the rewind did not run: {id}. Clear SAFE MODE or wait for the running task to finish.',
+    // ---------- restore resume (crash then click restore again = continue; see core/restore-resume.ts) ----------
+    'restore.resume.noActive': 'No restorable recovery to resume',
+    'restore.resume.terminal': 'Recovery record {state} cannot auto-resume (only an APPLYING run that crashed mid-way can)',
+    'restore.resume.wrongOperation': 'That record belongs to another operation type ({operationType}), not a restore',
+    'restore.resume.rollbackInFlight': 'The previous restore already started rolling back ({count} item(s)); not resuming forward',
+    'restore.resume.noSnapshot': 'The record is bound to snapshot {actual}, not the snapshot being restored ({expected})',
+    'restore.resume.planDrift': 'The current plan does not line up with the steps registered by the crashed run: {detail}',
+    'restore.resume.untrustedStep': 'The crash record contains a step that cannot be trusted: {detail}',
+    'restore.resume.externalUnproven': 'Contains a plugin uninstall that cannot be self-proven ({detail}); handle it in Incident recovery',
+    'restore.resume.stepAttention': '{count} action(s) did not succeed last time ({detail}); not auto-resuming',
+    'restore.resume.fingerprintDrift': '{path} matches neither the pre-run nor the post-run content ({detail}); not auto-resuming',
+    'restore.resume.detected': 'An unfinished restore was found ({operationId}): {done} item(s) done, {todo} to go — resuming automatically',
+    'restore.resumedSkip': 'Resume skipped (already applied last time): {description}',
+    'core.phase3.resumeMissing': 'Resume failed: active journal {opId} not found (it may have been settled from the recovery panel)',
+    'core.phase3.resumeTerminal': 'Resume failed: journal {opId} is already in terminal state {state}',
+    'core.phase3.resumeWrongType': 'Resume failed: journal {opId} has operation type {actual}, expected {expected}',
 };
 /**
  * 构造 MsgFunc：en → en 目录（缺键回退 zh）；其余 → zh。

package/lib/core/model-tools.js

@@ -26,6 +26,7 @@ import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { Exporter } from './exporter.js';
 import { listSnapshots, planRestore, restore as executeRestore } from './restore.js';
+import { probeRestoreResume, runRestoreWithResume } from './restore-resume.js';
 import { createEncryptionProvider } from '../security/encryption.js';
 import { SECTION_IDS } from '../schema/config.js';
 import { parseSyncChannel, readFullSyncConfig, readSyncConfigFor, SYNC_CHANNELS } from '../sync/sync-config.js';
@@ -162,11 +163,22 @@ export function createModelTools(deps) {
                 };
             }
             // Step 3 P0-A：真实 model-restore 在已持锁下创建 journal（不 double-acquire）
-            const doRestore = async () => executeRestore(restoreOpts);
-            const report = await runWithMutationLock(deps.host.mutationLock, { op: 'model-restore', target: snapshotId, isBlocked: () => deps.host.safeModeIsBlocked?.() ?? false }, async (lockCtx) => {
-                if (deps.host.phase3Recovery !== undefined && lockCtx !== null) {
-                    const r = await deps.host.phase3Recovery.runJournaled({ operationType: 'model-restore', lockCtx, fn: doRestore });
-                    return r.result;
+            // ctx = journal 上下文（可选）：交给 restore() 逐动作 WAL，崩溃后 reconcile 可判进度
+            const doRestore = async (ctx) => executeRestore(ctx === undefined ? restoreOpts : { ...restoreOpts, journal: ctx });
+            const phase3 = deps.host.phase3Recovery;
+            // 续跑探测（锁前，只读）：崩溃后再跑一次同一快照的恢复时，「同一个恢复崩在中途」正是 SAFE MODE
+            // 在等的结论 —— 判得出来就放过这道门；真正写盘的决定在锁内由 runRestoreWithResume 再判一次。
+            const resumeProbe = phase3 === undefined
+                ? null
+                : await probeRestoreResume({ store: phase3.store, restoreOpts, allowedOperationTypes: ['model-restore'] });
+            const resumeAllowed = resumeProbe !== null && resumeProbe.ok;
+            const report = await runWithMutationLock(deps.host.mutationLock, { op: 'model-restore', target: snapshotId, isBlocked: () => (deps.host.safeModeIsBlocked?.() ?? false) && !resumeAllowed }, async (lockCtx) => {
+                if (phase3 !== undefined && lockCtx !== null) {
+                    const out = await runRestoreWithResume({
+                        store: phase3.store, restoreOpts, operationType: 'model-restore',
+                        allowedOperationTypes: ['model-restore'], lockCtx, phase3,
+                    });
+                    return out.report;
                 }
                 return doRestore();
             });

package/lib/core/phase3-host.d.ts

@@ -165,6 +165,27 @@ export declare class Phase3Recovery {
         operationId: string;
         result: T;
     }>;
+    /**
+     * 续跑一条已存在的 active journal（崩溃后重做被中断的恢复，见 core/restore-resume.ts 的判定）。
+     *
+     * 与 runJournaled 的差别：**不 create、不做 active ≤ 1 门禁** —— 要续的正是那条 active 记录；
+     * 只有在「上次崩溃前已经写过至少一个动作」这一点被逐项证明后，调用方才允许走到这里。
+     * 所有 reject 分支都抛错（调用方负责转成用户可见的「不续跑」原因），绝不静默重跑。
+     */
+    resumeJournaled<T>(opts: {
+        operationId: string;
+        operationType: string;
+        lockCtx: MutationLockContext;
+        fn: (ctx?: JournalRunContext) => Promise<T>;
+    }): Promise<{
+        operationId: string;
+        result: T;
+    }>;
+    /**
+     * runJournaled / resumeJournaled 共用的收尾：成功推进终态、失败置 SAFE MODE 并分类 durable 状态。
+     * body 抛错即表示「副作用阶段失败」，由本方法决定 NEEDS_ATTENTION / 保持非终态 / ROLLED_BACK。
+     */
+    private runJournalTail;
     /**
      * 把「引擎已就地回滚」写成 durable 终态 ROLLED_BACK（审计 P0-3）。
      *