dsh-config-manager 0.1.78 → 0.1.79

package/lib/core/messages.d.ts

@@ -237,6 +237,17 @@ export declare const zh: {
     readonly 'adapter.mcpCreate': '创建 MCP server {serverName}';
     readonly 'adapter.mcpSame': 'MCP server {serverName} 已一致';
     readonly 'adapter.mcpDiff': 'MCP server {serverName} 与目标不同';
+    readonly 'adapter.mcpConnectorReadFailed': '无法读取 MCP 连接器存储（{reason}），本次备份不含连接器配置';
+    readonly 'adapter.mcpConnectorTargetUnreadable': '目标机的 MCP 连接器存储无法解析（{reason}），已跳过连接器导入，原文件未改动';
+    readonly 'adapter.mcpConnectorNeedsRefill': 'MCP 连接器「{name}」含需重填的凭据，未导入';
+    readonly 'adapter.mcpConnectorCreate': '新增 MCP 连接器「{name}」';
+    readonly 'adapter.mcpConnectorSame': 'MCP 连接器「{name}」已存在且一致';
+    readonly 'adapter.mcpConnectorDiff': 'MCP 连接器「{name}」与目标机不同';
+    readonly 'adapter.mcpConnectorDuplicateName': 'server「{serverName}」同时来自 patch 行与连接器，两份都会保留（不合并）';
+    readonly 'adapter.mcpConnectorOauth': 'OAuth 连接器「{name}」需在市场中重新授权';
+    readonly 'adapter.mcpConnectorMissing': '备份中找不到 MCP 连接器「{name}」';
+    readonly 'adapter.mcpConnectorWritten': '已写入 MCP 连接器「{name}」，重启 DSH 后生效';
+    readonly 'adapter.mcpConnectorInvalid': 'MCP 连接器条目缺少 key 或 serverName';
     readonly 'adapter.pwCreate': '写入 pnpm-workspace.yaml（插件构建白名单/冷静期配置）';
     readonly 'adapter.pwUpdate': '更新 pnpm-workspace.yaml（插件构建白名单/冷静期配置）';
     readonly 'adapter.pluginInstall': '安装插件 {name}@{version}';
@@ -246,6 +257,9 @@ export declare const zh: {
     readonly 'adapter.pluginBundleMember': '（bundle 成员，经聚合包安装）';
     readonly 'adapter.pluginInstallOk': '插件 {name} 已安装{suffix}';
     readonly 'adapter.pluginUpdateTriggered': '插件 {name} 已触发更新（npm 最新版）{suffix}';
+    readonly 'adapter.pluginInstalledAtVersion': '插件 {name} 已安装到 {version}{suffix}';
+    readonly 'adapter.pluginVersionMismatch': '插件 {name} 安装后版本为 {actual}，与备份记录的 {expected} 不一致（该版本可能已从 npm 撤版）；可手动执行：{command}';
+    readonly 'adapter.skillBundledSkipped': '技能 {name} 由插件内置提供（bundled），备份里的副本不完整，已跳过；升级对应插件即可获得最新版本';
     readonly 'adapter.pluginRestartSuffix': '，重启 dsh 后生效';
     readonly 'adapter.pluginHostBundleDeclare': '声明插件层 {name}（由 DSH 自带提供，不安装）';
     readonly 'adapter.pluginHostBundleSame': '插件层 {name} 已在目标机声明（由 DSH 自带提供）';
@@ -384,6 +398,12 @@ export declare const zh: {
     readonly 'sync.workdirNotConfigured': '尚未配置 git 仓库地址，无法重建工作副本。';
     readonly 'sync.workdirRelinked': '工作副本的 origin 已重指向当前仓库地址（工作树与本地提交未改动）。';
     readonly 'sync.workdirRecloned': '工作副本已重新克隆（原有本地提交已丢弃，远端快照已同步回本地副本）。';
+    readonly 'sync.git.adoptDirty': '工作副本 {dir} 里有未提交的改动：请先提交或撤销这些改动，再采纳远端历史（否则冲突会把你的改动卡住）。';
+    readonly 'sync.git.adoptDetached': '工作副本 {dir} 当前不在任何分支上（detached HEAD），无法采纳远端历史。请先切回一个分支（git switch <分支名>）后重试。';
+    readonly 'sync.git.adoptNoRemoteBranch': '远端没有名为 {branch} 的分支（远端现有：{heads}），未做任何合并。请先把仓库地址/分支改对，或改用「重新克隆工作副本」。';
+    readonly 'sync.git.adoptNotSyncRepo': '远端仓库顶层出现了快照布局以外的内容（{entries}）：它看起来不是本插件的同步仓库，已拒绝合并（不会把别的仓库内容搬进工作副本）。';
+    readonly 'sync.git.adoptMergeConflict': '合并远端 {branch} 时发生冲突：已撤销这次合并（merge --abort），工作副本回到操作前的状态。请手工解决冲突后重试，或改用「重新克隆工作副本」。';
+    readonly 'sync.workdirModeInvalidFull': '重建工作副本的模式非法: {mode}（只允许 relink（重指向地址）、adopt（采纳远端历史）或 reclone（重新克隆））';
     readonly 'sync.git.cmdFailed': 'git {args} 失败 (exit {code}): {err}';
     readonly 'sync.git.pushTokenRequired': '推送需要访问令牌：远端是 http(s) 仓库，但本机没有可用的令牌（拉取公开仓库可以匿名完成，推送必须认证）。请在「同步 → 通道配置」里登录 GitHub 或填入访问令牌后重试。';
     readonly 'sync.git.pushAuthFailed': '推送认证失败：{err}。请确认令牌有效且对该仓库有写权限（账号密码推送已被远端禁用）；拉取成功不代表令牌可用 —— 公开仓库匿名即可拉取。可在「同步 → 通道配置」里重新登录或更换令牌。';

package/lib/core/messages.js

@@ -228,6 +228,17 @@ export const zh = {
     'adapter.mcpCreate': '创建 MCP server {serverName}',
     'adapter.mcpSame': 'MCP server {serverName} 已一致',
     'adapter.mcpDiff': 'MCP server {serverName} 与目标不同',
+    'adapter.mcpConnectorReadFailed': '无法读取 MCP 连接器存储（{reason}），本次备份不含连接器配置',
+    'adapter.mcpConnectorTargetUnreadable': '目标机的 MCP 连接器存储无法解析（{reason}），已跳过连接器导入，原文件未改动',
+    'adapter.mcpConnectorNeedsRefill': 'MCP 连接器「{name}」含需重填的凭据，未导入',
+    'adapter.mcpConnectorCreate': '新增 MCP 连接器「{name}」',
+    'adapter.mcpConnectorSame': 'MCP 连接器「{name}」已存在且一致',
+    'adapter.mcpConnectorDiff': 'MCP 连接器「{name}」与目标机不同',
+    'adapter.mcpConnectorDuplicateName': 'server「{serverName}」同时来自 patch 行与连接器，两份都会保留（不合并）',
+    'adapter.mcpConnectorOauth': 'OAuth 连接器「{name}」需在市场中重新授权',
+    'adapter.mcpConnectorMissing': '备份中找不到 MCP 连接器「{name}」',
+    'adapter.mcpConnectorWritten': '已写入 MCP 连接器「{name}」，重启 DSH 后生效',
+    'adapter.mcpConnectorInvalid': 'MCP 连接器条目缺少 key 或 serverName',
     'adapter.pwCreate': '写入 pnpm-workspace.yaml（插件构建白名单/冷静期配置）',
     'adapter.pwUpdate': '更新 pnpm-workspace.yaml（插件构建白名单/冷静期配置）',
     'adapter.pluginInstall': '安装插件 {name}@{version}',
@@ -237,6 +248,9 @@ export const zh = {
     'adapter.pluginBundleMember': '（bundle 成员，经聚合包安装）',
     'adapter.pluginInstallOk': '插件 {name} 已安装{suffix}',
     'adapter.pluginUpdateTriggered': '插件 {name} 已触发更新（npm 最新版）{suffix}',
+    'adapter.pluginInstalledAtVersion': '插件 {name} 已安装到 {version}{suffix}',
+    'adapter.pluginVersionMismatch': '插件 {name} 安装后版本为 {actual}，与备份记录的 {expected} 不一致（该版本可能已从 npm 撤版）；可手动执行：{command}',
+    'adapter.skillBundledSkipped': '技能 {name} 由插件内置提供（bundled），备份里的副本不完整，已跳过；升级对应插件即可获得最新版本',
     'adapter.pluginRestartSuffix': '，重启 dsh 后生效',
     'adapter.pluginHostBundleDeclare': '声明插件层 {name}（由 DSH 自带提供，不安装）',
     'adapter.pluginHostBundleSame': '插件层 {name} 已在目标机声明（由 DSH 自带提供）',
@@ -379,6 +393,14 @@ export const zh = {
     'sync.workdirNotConfigured': '尚未配置 git 仓库地址，无法重建工作副本。',
     'sync.workdirRelinked': '工作副本的 origin 已重指向当前仓库地址（工作树与本地提交未改动）。',
     'sync.workdirRecloned': '工作副本已重新克隆（原有本地提交已丢弃，远端快照已同步回本地副本）。',
+    // issue #104：换仓库/远端历史被重写后「采纳远端历史」（adopt）的可操作文案。
+    // 注意：既有键（含上面的 historyDiverged / workdirModeInvalid）有冻结指纹，只许追加、不许改值。
+    'sync.git.adoptDirty': '工作副本 {dir} 里有未提交的改动：请先提交或撤销这些改动，再采纳远端历史（否则冲突会把你的改动卡住）。',
+    'sync.git.adoptDetached': '工作副本 {dir} 当前不在任何分支上（detached HEAD），无法采纳远端历史。请先切回一个分支（git switch <分支名>）后重试。',
+    'sync.git.adoptNoRemoteBranch': '远端没有名为 {branch} 的分支（远端现有：{heads}），未做任何合并。请先把仓库地址/分支改对，或改用「重新克隆工作副本」。',
+    'sync.git.adoptNotSyncRepo': '远端仓库顶层出现了快照布局以外的内容（{entries}）：它看起来不是本插件的同步仓库，已拒绝合并（不会把别的仓库内容搬进工作副本）。',
+    'sync.git.adoptMergeConflict': '合并远端 {branch} 时发生冲突：已撤销这次合并（merge --abort），工作副本回到操作前的状态。请手工解决冲突后重试，或改用「重新克隆工作副本」。',
+    'sync.workdirModeInvalidFull': '重建工作副本的模式非法: {mode}（只允许 relink（重指向地址）、adopt（采纳远端历史）或 reclone（重新克隆））',
     'sync.git.cmdFailed': 'git {args} 失败 (exit {code}): {err}',
     // 推送认证（真机：公开仓库拉取可匿名成功、推送必失败，git 原文只说「Invalid username or token」）
     'sync.git.pushTokenRequired': '推送需要访问令牌：远端是 http(s) 仓库，但本机没有可用的令牌（拉取公开仓库可以匿名完成，推送必须认证）。请在「同步 → 通道配置」里登录 GitHub 或填入访问令牌后重试。',
@@ -676,6 +698,17 @@ export const en = {
     'adapter.mcpCreate': 'Create MCP server {serverName}',
     'adapter.mcpSame': 'MCP server {serverName} is already identical',
     'adapter.mcpDiff': 'MCP server {serverName} differs from the target',
+    'adapter.mcpConnectorReadFailed': 'Could not read the MCP connector store ({reason}); this backup has no connector config',
+    'adapter.mcpConnectorTargetUnreadable': 'The target MCP connector store cannot be parsed ({reason}); connector import skipped and the file left untouched',
+    'adapter.mcpConnectorNeedsRefill': 'MCP connector "{name}" contains credentials that must be re-entered; not imported',
+    'adapter.mcpConnectorCreate': 'Add MCP connector "{name}"',
+    'adapter.mcpConnectorSame': 'MCP connector "{name}" already exists and matches',
+    'adapter.mcpConnectorDiff': 'MCP connector "{name}" differs from the target',
+    'adapter.mcpConnectorDuplicateName': 'Server "{serverName}" comes from both a patch line and a connector; both are kept (never merged)',
+    'adapter.mcpConnectorOauth': 'OAuth connector "{name}" must be re-authorized in the marketplace',
+    'adapter.mcpConnectorMissing': 'MCP connector "{name}" not found in the backup',
+    'adapter.mcpConnectorWritten': 'MCP connector "{name}" written; takes effect after restarting DSH',
+    'adapter.mcpConnectorInvalid': 'MCP connector entry is missing key or serverName',
     'adapter.pwCreate': 'Write pnpm-workspace.yaml (plugin build whitelist / release-age settings)',
     'adapter.pwUpdate': 'Update pnpm-workspace.yaml (plugin build whitelist / release-age settings)',
     'adapter.pluginInstall': 'Install plugin {name}@{version}',
@@ -685,6 +718,9 @@ export const en = {
     'adapter.pluginBundleMember': ' (bundle member, installed via the aggregate package)',
     'adapter.pluginInstallOk': 'Plugin {name} installed{suffix}',
     'adapter.pluginUpdateTriggered': 'Plugin {name} update triggered (npm latest){suffix}',
+    'adapter.pluginInstalledAtVersion': 'Plugin {name} installed at {version}{suffix}',
+    'adapter.pluginVersionMismatch': 'Plugin {name} is at {actual} after install, not the backed-up {expected} (that version may have been unpublished); run manually: {command}',
+    'adapter.skillBundledSkipped': 'Skill {name} is provided by a plugin (bundled); the copy in the backup is incomplete and was skipped; update that plugin to get the latest version',
     'adapter.pluginRestartSuffix': '; takes effect after restarting dsh',
     'adapter.pluginHostBundleDeclare': 'Declare plugin layer {name} (provided by DSH itself; not installed)',
     'adapter.pluginHostBundleSame': 'Plugin layer {name} is already declared on the target (provided by DSH itself)',
@@ -827,6 +863,14 @@ export const en = {
     'sync.workdirNotConfigured': 'No git repository address is configured, so the working copy cannot be rebuilt.',
     'sync.workdirRelinked': 'The working copy origin now points at the configured repository address (working tree and local commits untouched).',
     'sync.workdirRecloned': 'The working copy was cloned again (local commits were discarded; remote snapshots are back in the local copy).',
+    // issue #104: actionable text for adopting remote history (adopt) after a repository swap / rewritten history.
+    // Existing keys (including historyDiverged / workdirModeInvalid above) have frozen fingerprints: append only.
+    'sync.git.adoptDirty': 'The working copy {dir} has uncommitted changes: commit or discard them before adopting the remote history (otherwise a conflict would trap your changes).',
+    'sync.git.adoptDetached': 'The working copy {dir} is not on any branch (detached HEAD), so the remote history cannot be adopted. Switch back to a branch (git switch <branch>) and retry.',
+    'sync.git.adoptNoRemoteBranch': 'The remote has no branch named {branch} (remote branches: {heads}); nothing was merged. Fix the repository address/branch first, or use "clone the working copy again".',
+    'sync.git.adoptNotSyncRepo': 'The remote repository root contains entries outside the snapshot layout ({entries}): it does not look like this plugin\'s sync repository, so the merge was refused (another repository\'s content is never pulled into the working copy).',
+    'sync.git.adoptMergeConflict': 'Merging remote {branch} produced conflicts: the merge was aborted (merge --abort) and the working copy is back to its previous state. Resolve the conflicts manually and retry, or use "clone the working copy again".',
+    'sync.workdirModeInvalidFull': 'Invalid working-copy rebuild mode: {mode} (only relink (re-point the address), adopt (merge the remote history) or reclone (clone again) are allowed).',
     'sync.git.cmdFailed': 'git {args} failed (exit {code}): {err}',
     'sync.git.pushTokenRequired': 'Push requires an access token, but none is available on this machine (public repositories can be fetched anonymously; pushing always needs authentication). Sign in to GitHub or paste an access token under Sync → Channel configuration, then retry.',
     'sync.git.pushAuthFailed': 'Push authentication failed: {err}. Check that the token is valid and has write access to this repository (password authentication is disabled by the remote); a successful pull does not prove the token works — public repositories can be fetched anonymously. Sign in again or replace the token under Sync → Channel configuration.',

package/lib/core/phase3-host.js

@@ -501,6 +501,15 @@ export class Phase3Recovery {
             }
             await this.store.update(opId, (j) => {
                 let next = j;
+                // ext step 必须随 op 成功一起结算：此前 :556 写入的 `status:'planned'` 永远不会被更新，
+                // ⇒ 一条 COMMITTED 的 journal 里躺着「计划做、没做过」的步骤。后果有两个：
+                //  ① 审计不可信（recovery 面板把 external step 的 planned 当「未执行的意图」转发给用户）；
+                //  ② issue #87 的 `selfProvableResidual` 用「所有 step 都是 planned 且 appliedAt 为空」来
+                //     证明「副作用从未开始」—— 成功 op 落在 completed/ 不参与判定，但同一形状一旦被别的
+                //     路径读到就会被误读成「残留」。结算成 done + appliedAt 后形状语义唯一。
+                if (next.steps.ext !== undefined) {
+                    next = { ...next, steps: { ...next.steps, ext: { ...next.steps.ext, status: 'done', appliedAt: new Date().toISOString() } } };
+                }
                 if (next.state === 'SNAPSHOT_CREATED')
                     next = transitionJournalState(next, 'APPLYING');
                 if (next.state === 'APPLYING')
@@ -524,7 +533,15 @@ export class Phase3Recovery {
             else {
                 const j = await this.store.loadActive(opId);
                 if (j !== null && !isTerminalState(j.state)) {
-                    await this.store.update(opId, (cur) => transitionJournalState(cur, 'NEEDS_ATTENTION')).catch(() => undefined);
+                    await this.store.update(opId, (cur) => {
+                        // 失败时 ext step 不能停在 planned：planned 的含义是「还没开始」，而外部操作已经
+                        // 尝试过了（可能半途炸掉）。落成 attention 让 journal 自己说明「外部步骤结论未知」，
+                        // 而不是留给读取方去猜。appliedAt 保持 null（没有可证明的完成时刻）。
+                        const withStep = cur.steps.ext !== undefined && cur.steps.ext.status === 'planned'
+                            ? { ...cur, steps: { ...cur.steps, ext: { ...cur.steps.ext, status: 'attention' } } }
+                            : cur;
+                        return transitionJournalState(withStep, 'NEEDS_ATTENTION');
+                    }).catch(() => undefined);
                 }
             }
             throw err;

package/lib/core/plugin-cli.d.ts

@@ -144,8 +144,28 @@ export declare function mergeBundleDeclaration(pkgText: string, name: string): {
     text: string;
     changed: boolean;
 } | null;
-/** 安装目标：非 registry spec 按 spec 安装；其余按裸包名（npm 最新版）。 */
-export declare function installSpecFor(pkg: string, spec?: string): string;
+/** `pluginInstallTarget()` 的输入：全部来自备份里的 `PluginEntry`（都可缺省 = 旧备份）。 */
+export interface PluginInstallTargetInput {
+    /** 备份记录的实际安装版本（`PluginEntry.version`）：具体 semver 时精确安装到它（issue #101）。 */
+    version?: string | undefined;
+    /** 备份记录的声明依赖 spec（`PluginEntry.spec`）：非 registry 来源原样，registry 区间带包名。 */
+    spec?: string | undefined;
+    /** 备份内自带 tarball 解包后的绝对路径：优先于 spec（T1 本地源插件迁移）。 */
+    tarballPath?: string | undefined;
+}
+/**
+ * 安装目标：可直接交给 `dsh plugin add` 的**完整参数**（issue #101）。
+ *
+ * 为什么不能只传裸包名：pnpm add 会尊重目标机 `package.json` 里既有的 spec —— 固定版不动、
+ * 已经满足的区间也不动，于是「备份里记着 0.9.5、目标机装着 0.9.3」的升级会**空转却报成功**。
+ * 规则按优先级排列（`src/core/plugin-cli.test.ts` 表驱动钉住）：
+ *  ① 备份内 tarball → `file:<abs>`（换机后原绝对路径必然失效）；
+ *  ② 非 registry 来源（github:/git+/file:/link:）→ spec 原样（裸包名在 registry 上查不到）；
+ *  ③ `version` 是具体 semver → `<pkg>@<version>`（精确版本，pnpm 无法被既有 spec 挡住）；
+ *  ④ 其余 spec（`^1.2.3` / dist-tag）→ `<pkg>@<spec>`（交给 pnpm 解析，至少不会退回裸包名）；
+ *  ⑤ 什么都没有（旧备份 / 无版本记录）→ 裸包名（npm 最新版，改造前行为）。
+ */
+export declare function pluginInstallTarget(pkg: string, input?: PluginInstallTargetInput): string;
 /** 一次 CLI 调用的启动描述（env 只在需要覆写子进程环境时出现）。 */
 export interface DshCliArgv {
     file: string;

package/lib/core/plugin-cli.js

@@ -15,6 +15,7 @@
  * 只依赖 node 内置模块，零 DSH 运行时依赖（M5 的 TDD 可直接单测本模块）。
  */
 import { engineMsg } from './messages-core.js';
+import { isConcreteVersion } from './validator.js';
 import { spawn } from 'node:child_process';
 import { readFileSync, rmSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -405,13 +406,31 @@ const INSTALL_TIMEOUT_MS = Number(process.env.DSH_CONFIG_MANAGER_INSTALL_TIMEOUT
 /**
  * 非 registry 来源的依赖 spec 前缀：这些来源必须把 spec 原样交给 pnpm add，
  * 裸包名在 registry 上查不到（fetch-404 → 幽灵依赖拖垮整个 profile 的安装）。
- * 版本区间（^x / x.y.z）与裸包名走默认语义：npm 最新版（官方机制，见 §34.17 设计决策）。
+ * registry 包由 `pluginInstallTarget()` 拼精确版本或「包名@spec」（issue #101）。
  */
 const NON_REGISTRY_SPEC = /^(github:|gitlab:|bitbucket:|git\+|file:|link:|workspace:|https?:)/i;
-/** 安装目标：非 registry spec 按 spec 安装；其余按裸包名（npm 最新版）。 */
-export function installSpecFor(pkg, spec) {
+/**
+ * 安装目标：可直接交给 `dsh plugin add` 的**完整参数**（issue #101）。
+ *
+ * 为什么不能只传裸包名：pnpm add 会尊重目标机 `package.json` 里既有的 spec —— 固定版不动、
+ * 已经满足的区间也不动，于是「备份里记着 0.9.5、目标机装着 0.9.3」的升级会**空转却报成功**。
+ * 规则按优先级排列（`src/core/plugin-cli.test.ts` 表驱动钉住）：
+ *  ① 备份内 tarball → `file:<abs>`（换机后原绝对路径必然失效）；
+ *  ② 非 registry 来源（github:/git+/file:/link:）→ spec 原样（裸包名在 registry 上查不到）；
+ *  ③ `version` 是具体 semver → `<pkg>@<version>`（精确版本，pnpm 无法被既有 spec 挡住）；
+ *  ④ 其余 spec（`^1.2.3` / dist-tag）→ `<pkg>@<spec>`（交给 pnpm 解析，至少不会退回裸包名）；
+ *  ⑤ 什么都没有（旧备份 / 无版本记录）→ 裸包名（npm 最新版，改造前行为）。
+ */
+export function pluginInstallTarget(pkg, input = {}) {
+    const { version, spec, tarballPath } = input;
+    if (tarballPath !== undefined && tarballPath !== '')
+        return `file:${tarballPath}`;
     if (spec !== undefined && spec !== '' && NON_REGISTRY_SPEC.test(spec))
         return spec;
+    if (version !== undefined && isConcreteVersion(version))
+        return `${pkg}@${version}`;
+    if (spec !== undefined && spec !== '')
+        return `${pkg}@${spec}`;
     return pkg;
 }
 /** Windows 的 npm/corepack/pnpm/dsh 都是 .cmd 垫片：Node 直接 spawn 无法启动（ENOENT/EINVAL）。 */

package/lib/core/recovery-orchestrator.d.ts

@@ -56,11 +56,13 @@ export interface RecoveryOrchestratorDeps {
     /**
      * 只读环境锁状态（issue #31）。**由宿主注入而非本模块 import**：本模块不依赖 env-lock，
      * 无锁环境（测试 mock 端口）可返回保守的 UNKNOWN_STATE。
-     * detail 含 owner pid/op 等内部诊断 → 只用于日志，绝不进响应体。
+     * detail / ownerInstanceId 含 owner pid/op/实例标识等内部诊断 → 只用于日志与
+     * **本模块内部**的 journal↔锁归属匹配，绝不进响应体。
      */
     inspectLockState: () => Promise<{
         state: string;
         detail?: string;
+        ownerInstanceId?: string;
     }>;
     /**
      * 显式回收 stale 残留锁（EnvironmentLockManager.recoverStaleLock）。

package/lib/core/recovery-orchestrator.js

@@ -27,6 +27,37 @@ import { engineMsg } from './messages-core.js';
 export function createRecoveryOrchestrator(deps) {
     const { store, runs, snapshotsDir, host, snapshotExists, getEnvironmentFingerprint, clearSafeMode, inspectLockState, recoverStaleLock } = deps;
     const safeModeBlocked = deps.safeModeBlocked ?? (() => false);
+    /**
+     * 该 active journal 是否属于「正在正常执行中的外部操作」（in-flight），而不是
+     * 「一次未正常完成的操作」（incident）。
+     *
+     * 为什么必须区分：autosync push 的 journal 在整个执行期间存在于 `transactions/active/`
+     * （state=CREATED→APPLYING，成功后直接 moveToCompleted）。旧 status() 把所有非 terminal
+     * 的 active journal 一律当 incident 上报 ⇒ 正在跑的 push 被显示成「需要人工处理」的事故，
+     * 顶部冒出「配置修改已被保护」+「已进入安全模式」，而这类 journal 没有 snapshotId、
+     * decision 恒为 needs-attention ⇒ 「执行恢复」永久灰；唯一出口 dismiss 又要 GLOBAL 锁，
+     * 而锁正被同一个操作持着 ⇒ 点一次 423 一次。用户界面上是个纯粹的死胡同。
+     *
+     * 判据三合一，任一不成立就保守地仍按 incident 上报：
+     *  1. state 非 terminal 且非 NEEDS_ATTENTION（后者是明确的「需人工处理」）；
+     *  2. 环境锁 state === 'LOCKED'（另一任务活跃持有；STALE/UNKNOWN 都不可当作「有人在跑」）；
+     *  3. journal.ownerInstanceId === 锁持有者的 owner.instanceId —— 证明持锁的实例**就是**
+     *     写这条 journal 的实例，即它正在跑，而非上次崩溃的残骸。
+     *
+     * 不用时间窗启发式：op 执行期间 journal 本来就可能长时间不写（外部步骤无中途落盘），
+     * 任何「多久没更新算卡住」的阈值都会误伤慢速 push。
+     */
+    const isLiveInFlight = (j, lock) => {
+        if (lock === undefined || lock.state !== 'LOCKED')
+            return false;
+        if (isTerminalState(j.state) || j.state === 'NEEDS_ATTENTION')
+            return false;
+        const holder = lock.ownerInstanceId;
+        if (holder === undefined || holder === '')
+            return false;
+        const owner = j.ownerInstanceId;
+        return owner !== null && owner !== '' && owner === holder;
+    };
     /**
      * 只读 recovery decision（不修改 journal）。**不用 reconcileActive**：其 §6.5 硬门控会把
      * RECOVERING journal 迁移到 NEEDS_ATTENTION，若 status 轮询时触发会破坏 execute→verify 流程。
@@ -128,14 +159,44 @@ export function createRecoveryOrchestrator(deps) {
             // 「解除安全模式」入口，而不是显示「暂无需要处理的恢复事项」然后继续 423。
             const blocked = safeModeBlocked();
             const clearable = blocked ? await resolveSafeMode(true) : false;
+            // issue #31：附带环境锁分类。**只暴露分类，不暴露 owner pid/op/hostname**（内部诊断）。
+            // attention 只对「需用户显式处理」的状态为 true：STALE_LOCK_DETECTED（残留锁，重试不会自愈）
+            // 与 UNKNOWN_STATE（无法判定）→ 引导用户回收；LOCKED（另一任务活跃持有）会自行释放，
+            // 不该催用户去「回收」，否则又是一个误导。探测失败 → 保守 UNKNOWN_STATE + attention。
+            //
+            // 探测必须**先于** incident 分类：LOCKED 且持有者 == journal.ownerInstanceId 时该 journal
+            // 是「正在跑」，不该进 incidents（解释见 isLiveInFlight）。
+            let lock;
+            let lockInsp;
+            try {
+                const insp = await inspectLockState();
+                lockInsp = insp.ownerInstanceId !== undefined
+                    ? { state: insp.state, ownerInstanceId: insp.ownerInstanceId }
+                    : { state: insp.state };
+                lock = {
+                    state: insp.state,
+                    attention: insp.state === 'STALE_LOCK_DETECTED' || insp.state === 'UNKNOWN_STATE',
+                };
+            }
+            catch {
+                lock = { state: 'UNKNOWN_STATE', attention: true };
+            }
             const activeIds = await store.scanActive();
             const incidents = [];
+            /** 正在正常执行的操作（不是 incident）：面板据此解释「为什么现在什么都点不动」。 */
+            const live = [];
             for (const opId of activeIds) {
                 const j = await store.loadActive(opId);
                 if (j === null)
                     continue;
                 if (isTerminalState(j.state) && j.state !== 'NEEDS_ATTENTION')
                     continue; // COMMITTED/ROLLED_BACK/RECOVERED → 非 incident
+                // 正在跑的操作：既不进 incidents（否则伪装成事故 + 假 SAFE MODE 横幅），
+                // 也不进 running（那是 recovery run），单列进 live 供界面如实说明。
+                if (isLiveInFlight(j, lockInsp)) {
+                    live.push({ operationId: opId, operationType: j.operationType, state: j.state, startedAt: j.createdAt });
+                    continue;
+                }
                 const d = await decision(j);
                 incidents.push({
                     operationId: opId,
@@ -148,24 +209,10 @@ export function createRecoveryOrchestrator(deps) {
                 });
             }
             const running = runs.listActive().filter((r) => r.kind === 'recovery').map((r) => ({ runId: r.runId, status: r.status }));
-            // issue #31：附带环境锁分类。**只暴露分类，不暴露 owner pid/op/hostname**（内部诊断）。
-            // attention 只对「需用户显式处理」的状态为 true：STALE_LOCK_DETECTED（残留锁，重试不会自愈）
-            // 与 UNKNOWN_STATE（无法判定）→ 引导用户回收；LOCKED（另一任务活跃持有）会自行释放，
-            // 不该催用户去「回收」，否则又是一个误导。探测失败 → 保守 UNKNOWN_STATE + attention。
-            let lock;
-            try {
-                const insp = await inspectLockState();
-                lock = {
-                    state: insp.state,
-                    attention: insp.state === 'STALE_LOCK_DETECTED' || insp.state === 'UNKNOWN_STATE',
-                };
-            }
-            catch {
-                lock = { state: 'UNKNOWN_STATE', attention: true };
-            }
             // issue #56：SAFE MODE 阻断态如实回传。`clearable` = 「结案但保护仍开着」
             // （durable 标记在、没有任何未解决 incident）—— 界面据此渲染显式解除入口。
-            return { status: 200, body: { incidents, running, lock, safeMode: { blocked, clearable } } };
+            // live 是**加法字段**：旧客户端读不到就按「无进行中操作」处理，不影响既有渲染。
+            return { status: 200, body: { incidents, running, live, lock, safeMode: { blocked, clearable } } };
         },
         async preview(operationId) {
             if (!isValidOperationId(operationId))
@@ -308,6 +355,18 @@ export function createRecoveryOrchestrator(deps) {
             const j = await store.loadActive(operationId);
             if (j === null)
                 return { status: 404, body: { error: 'operation not found' } };
+            // 正在执行的操作不能「放弃」：它不是事故，quarantine 会把在跑的那条 journal 从 active/
+            // 抽走，让执行方后续 transition 失败。正常情况下这条路径走不到 —— 路由的 GLOBAL 锁
+            // 会先以 423 挡下；这里是防御性判据（锁端口未接线/跨进程判定差异时仍能给出准确原因，
+            // 而不是笼统的「另一个任务正在运行」）。
+            let lockForDismiss;
+            try {
+                lockForDismiss = await inspectLockState();
+            }
+            catch { /* 探测失败 → 不拦（保持旧行为） */ }
+            if (isLiveInFlight(j, lockForDismiss)) {
+                return { status: 409, body: { error: engineMsg('core.recovery.opInFlight', { state: j.state }), code: 'operation-in-flight' } };
+            }
             // dismiss → quarantine（用户放弃；不删除 snapshot/journal evidence，不强行 RECOVERED）
             const result = await executeRecovery(store, { operationId, action: 'dismiss', snapshotId: j.snapshotId }, true);
             if (result === 'failed')

package/lib/core/rollback-activity.d.ts

@@ -0,0 +1,89 @@
+/** 台账文件名（与回滚点库同目录：dataDir/rollback-points/activity.json） */
+export declare const ROLLBACK_ACTIVITY_FILE_NAME = "activity.json";
+/** 同一会话两条活动的间隔 <= 该值就并成一个窗口（缺省 10 分钟） */
+export declare const ROLLBACK_ACTIVITY_DEFAULT_GAP_MS: number;
+/** 窗口条目上限（超出按 to 淘汰最旧）—— 无界增长会把宿主拖垮（见 issue #89 的教训） */
+export declare const ROLLBACK_ACTIVITY_MAX_INTERVALS = 20000;
+/** 一条会话活跃窗口：会话 sessionId 在 [from, to] 之间有过活动 */
+export interface RollbackActivityInterval {
+    sessionId: string;
+    from: number;
+    to: number;
+}
+export interface RollbackActivityOptions {
+    /** 台账文件绝对路径（引擎传 dataDir/rollback-points/activity.json） */
+    file: string;
+    /** 缺省时钟；`noteActivity` 不传 at 时用它（事件时间优先，取数时刻只是兜底） */
+    now?: () => number;
+    /** 同一会话两条活动间隔 <= gapMs 就合并（缺省 ROLLBACK_ACTIVITY_DEFAULT_GAP_MS） */
+    gapMs?: number;
+    /** 窗口总条数上限（缺省 ROLLBACK_ACTIVITY_MAX_INTERVALS），超出淘汰最旧的 */
+    maxIntervals?: number;
+    /** 落盘延迟（毫秒）；<= 0 表示不自动落盘（测试用） */
+    flushDelayMs?: number;
+    /** 读写失败只 warn，绝不抛 */
+    warn?: (line: string) => void;
+}
+/**
+ * 内存窗口表 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**给旧会话回退时，活跃窗口还在（否则新进程只有本次启动后看到的窗口）。
+ * 因此写入是延迟合并的（一次会话事件一行，立即落盘会把 I/O 打成筛子）。
+ */
+export declare class RollbackSessionActivity {
+    private readonly table;
+    private readonly file;
+    private readonly now;
+    private readonly gapMs;
+    private readonly maxIntervals;
+    private readonly flushDelayMs;
+    private readonly warn;
+    private loadPromise;
+    private flushTimer;
+    private writing;
+    /** 内存变更计数：与 lastFlushedRevision 相等 ⇒ 没有未落盘数据（flush 幂等靠它，不靠时间戳） */
+    private revision;
+    private lastFlushedRevision;
+    constructor(options: RollbackActivityOptions);
+    /** 窗口总条数（诊断与测试用；上限见 maxIntervals。等价于「条目」，不是会话数） */
+    get size(): number;
+    /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+    load(): Promise<void>;
+    private read;
+    /**
+     * 记一次活动。窗口只增不减：与上一条间隔 <= gapMs 就并入同一条窗口，否则新开一条。
+     *
+     * `at` 缺省取注入时钟（`options.now`）：引擎把**事件时间**显式传进来时以它为准
+     * （事件时间才是那次活动的真实时刻，取数时刻可能晚很多）。
+     * 空会话 id、非有限数字、负数一律**忽略**（fail-closed：宁可少一个窗口，绝不记错归属）。
+     */
+    noteActivity(sessionId: string, at?: number): void;
+    /** 缺省时钟：注入的 now 抛错或给出非有限值时 fail-closed（返回 NaN，由调用方校验丢弃） */
+    private clockNow;
+    /** 该会话最后一次活动时刻；没记过 = null（**不是 0**，0 会被误当成有效时间戳） */
+    lastActivityAt(sessionId: string): number | null;
+    /** 该会话是否有任何窗口（用于区分「确知没活动」与「根本没采到」） */
+    hasDataFor(sessionId: string): boolean;
+    /** 活跃窗口包含 at（可容忍 toleranceMs，缺省 0）的会话 id，按 id 升序、去重 */
+    sessionsActiveAt(at: number, toleranceMs?: number): string[];
+    /** 单个会话是否活跃（与 sessionsActiveAt 同口径，不另写一套判定） */
+    isActiveAt(sessionId: string, at: number, toleranceMs?: number): boolean;
+    /** 延迟落盘（多次调用只落一次） */
+    scheduleFlush(): void;
+    /** 内存快照（深拷一层：落盘期间的新活动不得改写正在序列化的数据） */
+    private snapshot;
+    /** 淘汰最旧的窗口（按 to 升序删到上限内；条目 = 窗口，不是会话） */
+    private evictOldest;
+    /**
+     * 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛）。
+     *
+     * 幂等：没有未落盘数据（revision == lastFlushedRevision）时**直接返回、不碰磁盘**；
+     * 并发调用共用同一个在飞写入。
+     */
+    flush(): Promise<void>;
+    /**
+     * 关闭：取消待落盘的定时器，并把还没落盘的活动写下去。
+     * 没有未落盘数据时不会重复写（flush 幂等）；写入失败只 warn，不透出（关停路径不得被台账拖垮）。
+     */
+    dispose(): Promise<void>;
+}