dsh-config-manager 0.1.78 → 0.1.80

package/src/core/phase3-production-integration.test.ts

@@ -130,6 +130,10 @@ test('P0-A：runExternalIntent 记录 external step + COMMITTED', async (t) => {
   assert.ok(j);
   assert.equal(j!.steps['ext']?.external, true);
   assert.equal(j!.state, 'COMMITTED');
+  // 成功路径必须清算 external step：否则 journal 会以「COMMITTED + step 永远 planned」落盘，
+  // 事后读台账的人无法区分「已成功执行」与「根本没跑」（本机 0.1.78 事故现场正是这种形态）。
+  assert.equal(j!.steps['ext']?.status, 'done', '外部步骤成功后必须标 done');
+  assert.equal(typeof j!.steps['ext']?.appliedAt, 'string', '外部步骤成功后必须有 appliedAt');
   assert.deepEqual(await recovery.store.scanActive(), []);
 });
 

package/src/core/plugin-cli.test.ts

@@ -6,6 +6,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
   classifyDshPluginFailure, dshArgv, installAnchorFromProfileContext, installErrorFor, isTransientDshPluginFailure,
+  pluginInstallTarget,
   profileNameFromArgv, profileNameFromDir, profileNameFromProfileContext,
   resolveProcessProfileName, resolveProfileNameFromEnv,
   type DshPluginResult,
@@ -199,6 +200,31 @@ const CARRIER: DesktopCarrier = {
   env: { ELECTRON_RUN_AS_NODE: '1' },
 };
 
+test('pluginInstallTarget：安装目标决策表（issue #101 空转修复）', () => {
+  const cases: { name: string; pkg: string; input: { version?: string | undefined; spec?: string | undefined; tarballPath?: string | undefined }; expected: string }[] = [
+    { name: '备份内 tarball 优先于版本与 spec', pkg: 'p', input: { version: '1.0.0', spec: '^2.0.0', tarballPath: '/h/plugins/p.tgz' }, expected: 'file:/h/plugins/p.tgz' },
+    { name: '空 tarball 视为没有（回落 spec）', pkg: 'p', input: { tarballPath: '', spec: 'github:u/r' }, expected: 'github:u/r' },
+    { name: '非 registry 来源（github:）原样，手里的 version 不再拼', pkg: 'p', input: { version: '1.0.0', spec: 'github:u/r' }, expected: 'github:u/r' },
+    { name: '非 registry 来源（file:）原样', pkg: 'p', input: { spec: 'file:../local-p' }, expected: 'file:../local-p' },
+    {
+      name: '具体 semver → 精确版本（修复升级空转）',
+      pkg: 'dsh-free-search',
+      input: { version: '0.9.5', spec: '0.9.3' },
+      expected: 'dsh-free-search@0.9.5',
+    },
+    { name: '预发布版本同样精确', pkg: 'p', input: { version: '1.0.0-rc.2' }, expected: 'p@1.0.0-rc.2' },
+    { name: '带 build 元数据同样精确', pkg: 'p', input: { version: '1.0.0+build.7' }, expected: 'p@1.0.0+build.7' },
+    { name: 'version 不是具体版本 → 落到 spec', pkg: 'p', input: { version: 'latest', spec: '^1.2.3' }, expected: 'p@^1.2.3' },
+    { name: 'registry 区间 spec 带包名（手交给 pnpm 解析）', pkg: 'dshmarket', input: { spec: '^1.66.38' }, expected: 'dshmarket@^1.66.38' },
+    { name: 'dist-tag spec 带包名', pkg: 'p', input: { spec: 'next' }, expected: 'p@next' },
+    { name: '旧备份：version / spec 全缺 → 裸包名（改造前行为）', pkg: 'p', input: {}, expected: 'p' },
+    { name: '空字符串按缺省处理', pkg: 'p', input: { version: '', spec: '' }, expected: 'p' },
+  ];
+  for (const c of cases) {
+    assert.equal(pluginInstallTarget(c.pkg, c.input), c.expected, c.name);
+  }
+});
+
 test('dshArgv：desktop 档案走桌面端 CLI 载体（普通 dsh CLI 对它硬拒绝）', () => {
   const argv = dshArgv('desktop', CARRIER);
   assert.equal(argv.file, CARRIER.execPath, '必须用 Electron 主程序（Node 模式）启动载体');

package/src/core/plugin-cli.ts

@@ -15,7 +15,8 @@
  * 只依赖 node 内置模块，零 DSH 运行时依赖（M5 的 TDD 可直接单测本模块）。
  */
 
-import { engineMsg } from './messages-core.ts';
+import { engineMsg } from './messages-core.ts'
+import { isConcreteVersion } from './validator.ts';
 import { spawn } from 'node:child_process'
 import type { ChildProcess, SpawnOptions } from 'node:child_process'
 import { readFileSync, rmSync } from 'node:fs'
@@ -414,13 +415,38 @@ 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: 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 function pluginInstallTarget(pkg: string, input: PluginInstallTargetInput = {}): string {
+  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
 }
 

package/src/core/recovery-orchestrator.test.ts

@@ -16,7 +16,9 @@ import path from 'node:path';
 
 import { createRecoveryOrchestrator } from './recovery-orchestrator.ts';
 import type { RecoveryOrchestratorDeps } from './recovery-orchestrator.ts';
-import { JournalStore } from './journal.ts';
+import {
+  JournalStore, createJournalEntry, generateOperationId, transitionJournalState,
+} from './journal.ts';
 import { RunRegistry } from './run-registry.ts';
 import { nullLogger } from '../utils/logger.ts';
 import { zhMsg } from './messages.ts';
@@ -32,15 +34,22 @@ async function makeOrchestrator(opts: {
   lockState?: string;
   lockDetail?: string;
   lockThrows?: boolean;
+  lockOwner?: string;
   recoverResult?: { ok: boolean; removed: boolean; state: string; detail?: string };
-} = {}): Promise<{ orchestrator: ReturnType<typeof createRecoveryOrchestrator>; spy: RecoverSpy }> {
+} = {}): Promise<{
+  orchestrator: ReturnType<typeof createRecoveryOrchestrator>;
+  spy: RecoverSpy;
+  /** 供用例预置 active journal（模拟「正在执行中的操作」）。 */
+  store: JournalStore;
+}> {
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-recovery-orch-'));
   const spy: RecoverSpy = {
     calls: 0,
     result: opts.recoverResult ?? { ok: true, removed: true, state: 'STALE_LOCK_DETECTED', detail: '已移除 stale ownership (op=autosync, pid=24140)' },
   };
+  const store = new JournalStore({ transactionsDir: path.join(dir, 'transactions') });
   const deps: RecoveryOrchestratorDeps = {
-    store: new JournalStore({ transactionsDir: path.join(dir, 'transactions') }),
+    store,
     runs: new RunRegistry(),
     snapshotsDir: path.join(dir, 'snapshots'),
     host: { log: nullLogger() } as unknown as HostContext,
@@ -50,14 +59,18 @@ async function makeOrchestrator(opts: {
     clearSafeMode: async () => undefined,
     inspectLockState: async () => {
       if (opts.lockThrows === true) throw new Error('probe failed');
-      return { state: opts.lockState ?? 'FREE', ...(opts.lockDetail !== undefined ? { detail: opts.lockDetail } : {}) };
+      return {
+        state: opts.lockState ?? 'FREE',
+        ...(opts.lockDetail !== undefined ? { detail: opts.lockDetail } : {}),
+        ...(opts.lockOwner !== undefined ? { ownerInstanceId: opts.lockOwner } : {}),
+      };
     },
     recoverStaleLock: async () => {
       spy.calls += 1;
       return spy.result;
     },
   };
-  return { orchestrator: createRecoveryOrchestrator(deps), spy };
+  return { orchestrator: createRecoveryOrchestrator(deps), spy, store };
 }
 
 // ---------- ① 纯锁残留场景：incidents 为空，但锁事项必须可见 ----------
@@ -190,3 +203,89 @@ test('源码守卫：/recovery/lock/recover 分支先于 operationId 解析，
   assert.ok(ctorBody.includes('inspectLockState:'), 'createRecoveryOrchestrator 必须注入 inspectLockState');
   assert.ok(ctorBody.includes('recoverStaleLock:'), 'createRecoveryOrchestrator 必须注入 recoverStaleLock');
 });
+
+
+// ---------- ④ 正在正常执行的操作 vs 未完成的操作（本轮修复的核心口径） ----------
+
+/**
+ * 事故现场（2026-10-21，本机 0.1.78）：autosync push 的 journal 在执行期间存在于
+ * `transactions/active/`（CREATED→APPLYING），status() 把它当 incident 上报 ⇒
+ * 面板显示「需要人工处理 + 无可信快照」，顶部冒出「已进入安全模式」，「执行恢复」永久灰；
+ * 唯一出口 dismiss 又要 GLOBAL 锁，而锁正被同一个操作持有 ⇒ 点一次 423 一次。
+ * 下面四条把「什么算正在跑」钉死。
+ */
+
+const LIVE_OWNER = '44c2454fe7c1865e8771e294a5955e20';
+
+/** 预置一条 active journal（默认 CREATED，模拟刚开始的外部操作）。 */
+async function seedActiveJournal(
+  store: JournalStore,
+  ownerInstanceId: string,
+  opts: { operationType?: string; needsAttention?: boolean } = {},
+): Promise<string> {
+  await store.ensureDirs();
+  const operationId = generateOperationId();
+  const now = new Date().toISOString();
+  await store.create(createJournalEntry(opts.operationType ?? 'autosync-push', {
+    operationId, ownerInstanceId, lockId: ownerInstanceId,
+    packageVersion: '0.1.78', environmentFingerprint: 'fp-test',
+  }, now));
+  if (opts.needsAttention === true) {
+    await store.update(operationId, (j) => transitionJournalState(j, 'NEEDS_ATTENTION'));
+  }
+  return operationId;
+}
+
+test('status：锁持有者 == journal.ownerInstanceId（正在跑）→ 不进 incidents，单列进 live', async () => {
+  const { orchestrator, store } = await makeOrchestrator({ lockState: 'LOCKED', lockOwner: LIVE_OWNER });
+  const opId = await seedActiveJournal(store, LIVE_OWNER);
+  const r = await orchestrator.status();
+  assert.equal(r.status, 200);
+  assert.deepEqual(r.body['incidents'], [], '正在正常执行的操作不是「未完成的操作」——进 incidents 就会伪造假事故与假 SAFE MODE 横幅');
+  const live = r.body['live'] as Array<Record<string, unknown>>;
+  assert.equal(live.length, 1);
+  assert.equal(live[0]!['operationId'], opId);
+  assert.equal(live[0]!['operationType'], 'autosync-push');
+  assert.equal(live[0]!['state'], 'CREATED');
+  assert.ok(typeof live[0]!['startedAt'] === 'string', 'live 必须带开始时间（面板要显示它跑了多久）');
+  // 锁仍是 LOCKED（活跃持有）→ attention=false，不催用户去「回收」一把活锁
+  assert.deepEqual(r.body['lock'], { state: 'LOCKED', attention: false });
+});
+
+test('status：journal.ownerInstanceId 与锁持有者不一致 → 仍按 incident 上报（保守）', async () => {
+  const { orchestrator, store } = await makeOrchestrator({ lockState: 'LOCKED', lockOwner: 'someone-else' });
+  await seedActiveJournal(store, LIVE_OWNER);
+  const r = await orchestrator.status();
+  const incidents = r.body['incidents'] as Array<Record<string, unknown>>;
+  assert.equal(incidents.length, 1, '归属不一致就不能假定它正在跑（可能是崩溃残骸）');
+  assert.equal(incidents[0]!['operationType'], 'autosync-push');
+  assert.deepEqual(r.body['live'], []);
+});
+
+test('status：锁未持有（FREE）→ 同一 journal 仍按 incident 上报（无人能证明它还在跑）', async () => {
+  const { orchestrator, store } = await makeOrchestrator({ lockState: 'FREE' });
+  await seedActiveJournal(store, LIVE_OWNER);
+  const r = await orchestrator.status();
+  assert.equal((r.body['incidents'] as unknown[]).length, 1);
+  assert.deepEqual(r.body['live'], []);
+});
+
+test('status：NEEDS_ATTENTION 即使归属匹配也不得被吞（它是明确的「需人工处理」）', async () => {
+  const { orchestrator, store } = await makeOrchestrator({ lockState: 'LOCKED', lockOwner: LIVE_OWNER });
+  await seedActiveJournal(store, LIVE_OWNER, { needsAttention: true });
+  const r = await orchestrator.status();
+  const incidents = r.body['incidents'] as Array<Record<string, unknown>>;
+  assert.equal(incidents.length, 1);
+  assert.equal(incidents[0]!['state'], 'NEEDS_ATTENTION');
+  assert.deepEqual(r.body['live'], [], '需人工处理的事项绝不能伪装成「正在跑」');
+});
+
+test('dismiss：正在跑的操作 → 409 operation-in-flight（不 quarantine 在跑的 journal）', async () => {
+  const { orchestrator, store } = await makeOrchestrator({ lockState: 'LOCKED', lockOwner: LIVE_OWNER });
+  const opId = await seedActiveJournal(store, LIVE_OWNER);
+  const r = await orchestrator.dismiss(opId, true);
+  assert.equal(r.status, 409);
+  assert.equal(r.body['code'], 'operation-in-flight');
+  const active = await store.scanActive();
+  assert.deepEqual(active, [opId], '拒绝时必须原地不动：把在跑的 journal 挪走会让执行方后续 transition 失败');
+});

package/src/core/recovery-orchestrator.ts

@@ -76,9 +76,10 @@ 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 }>;
+  inspectLockState: () => Promise<{ state: string; detail?: string; ownerInstanceId?: string }>;
   /**
    * 显式回收 stale 残留锁（EnvironmentLockManager.recoverStaleLock）。
    * **调用方不得先 acquire 锁**：要回收的正是挡住 acquire 的那把锁，先取锁必然失败。
@@ -118,6 +119,35 @@ export function createRecoveryOrchestrator(deps: RecoveryOrchestratorDeps): Reco
   const { store, runs, snapshotsDir, host, snapshotExists, getEnvironmentFingerprint, clearSafeMode, inspectLockState, recoverStaleLock } = deps;
   const safeModeBlocked = deps.safeModeBlocked ?? ((): boolean => 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: OperationJournal, lock: { state: string; ownerInstanceId?: string } | undefined): boolean => {
+    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 流程。
@@ -214,15 +244,44 @@ export function createRecoveryOrchestrator(deps: RecoveryOrchestratorDeps): Reco
       // 「解除安全模式」入口，而不是显示「暂无需要处理的恢复事项」然后继续 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: { state: string; attention: boolean } | undefined;
+      let lockInsp: { state: string; ownerInstanceId?: string } | undefined;
+      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: Array<{
         operationId: string; operationType: string; state: string; decision: string;
         snapshotId: string | null; reason: string; createdAt: string;
       }> = [];
+      /** 正在正常执行的操作（不是 incident）：面板据此解释「为什么现在什么都点不动」。 */
+      const live: Array<{ operationId: string; operationType: string; state: string; startedAt: string }> = [];
       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,
@@ -235,23 +294,10 @@ export function createRecoveryOrchestrator(deps: RecoveryOrchestratorDeps): Reco
         });
       }
       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: { state: string; attention: boolean } | undefined;
-      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) {
@@ -366,6 +412,17 @@ export function createRecoveryOrchestrator(deps: RecoveryOrchestratorDeps): Reco
       if (userConfirmed !== true) return { status: 400, body: { error: 'userConfirmed required' } };
       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: { state: string; ownerInstanceId?: string } | undefined;
+      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') return { status: 400, body: { error: engineMsg('core.recovery.dismissFailed') } };