@xioflow/kernel 0.1.5 → 0.3.0

package/dist/testing/contract-suite.js

@@ -2,7 +2,8 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { ExecutionDomain, SqliteStore, ProcessSupervisor, RecoveryEngine, ResourceConflictError, UnsupportedCapabilityError, EpochFencedError, } from '../index.js';
+import { spawn } from 'node:child_process';
+import { ExecutionDomain, SqliteStore, ProcessSupervisor, RecoveryEngine, ResourceConflictError, UnsupportedCapabilityError, EpochFencedError, OperationNotActiveError, DuplicateOperationError, OperationIdConflictError, RecoveryRequiredError, computeInputFingerprint, } from '../index.js';
 function ensureTaskAndRun(domain, taskId, runId) {
     const store = domain.getStore();
     if (!store.getTask(taskId)) {
@@ -25,7 +26,7 @@ function ensureTaskAndRun(domain, taskId, runId) {
     }
 }
 export function defineContractTestSuite(consumerName, createContext) {
-    describe(`18-Item Consistency Contract Suite: [${consumerName}]`, () => {
+    describe(`Consistency Contract Suite: [${consumerName}]`, () => {
         let ctx;
         beforeEach(async () => {
             ctx = await createContext();
@@ -103,7 +104,7 @@ export function defineContractTestSuite(consumerName, createContext) {
                     return 'cannot_determine';
                 },
                 async terminate() {
-                    return { stopped: false, scope: 'unknown', errorDetails: 'Cannot confirm exit' };
+                    return { stopped: 'cannot_determine', scope: 'unknown', errorDetails: 'Cannot confirm exit' };
                 },
             };
             const customSupervisor = new ProcessSupervisor(domain, mockUnconfirmedDriver);
@@ -120,7 +121,7 @@ export function defineContractTestSuite(consumerName, createContext) {
             });
             await new Promise((r) => setTimeout(r, 100));
             const cancelRes = await customSupervisor.cancelOperation('op-c3-stubborn');
-            expect(cancelRes.stopped).toBe(false);
+            expect(cancelRes.stopped).toBe('cannot_determine');
             // 核心断言：未确认停止前，排他锁绝不释放！
             expect(domain.isResourceLocked('res:c3-lock')).toBe(true);
             const op = domain.getStore().getOperation('op-c3-stubborn');
@@ -148,11 +149,11 @@ export function defineContractTestSuite(consumerName, createContext) {
             }
             // 2. 带排队等待异步放行
             setTimeout(() => {
-                domain.releaseResources('op-owner-A', ['res:exclusive-port']);
+                domain.internalReleaseResources('op-owner-A', ['res:exclusive-port']);
             }, 50);
             await domain.allocateResourcesWithWait('op-requester-B', ['res:exclusive-port'], 300);
             expect(domain.getResourceOwner('res:exclusive-port')).toBe('op-requester-B');
-            domain.releaseResources('op-requester-B');
+            domain.internalReleaseResources('op-requester-B');
         });
         it('契约 5: 不确定副作用防重放，重启恢复时阻断自动重试并保留隔离', async () => {
             const { domain, driver } = ctx;
@@ -353,7 +354,7 @@ export function defineContractTestSuite(consumerName, createContext) {
             expect(grandchildAliveBefore).toBe(true);
             // 执行整组停止流水线
             const stopRes = await supervisor.cancelOperation('op-c9-group', 1500);
-            expect(stopRes.stopped).toBe(true);
+            expect(stopRes.stopped).toBe('confirmed_stopped');
             expect(domain.isResourceLocked('res:c9-group')).toBe(false);
             // 核心真实断言：整组 kill(-pgid) 广播后，同组孙进程必须确定性死亡，绝不泄漏为 PID 1 孤儿！
             let grandchildAliveAfter = true;
@@ -422,8 +423,8 @@ export function defineContractTestSuite(consumerName, createContext) {
                 expect(escapedAliveBefore).toBe(true);
                 // 调用停止流水线：NodePlatformDriver 真实后代树扫描探测到逃逸残留
                 const cancelRes = await supervisor.cancelOperation('op-c10-escape', 1000);
-                // 真实上报 stopped: false，且 residualPids 包含逃逸孤儿 PID
-                expect(cancelRes.stopped).toBe(false);
+                // 真实上报 stopped: cannot_determine，且 residualPids 包含逃逸孤儿 PID
+                expect(cancelRes.stopped).toBe('cannot_determine');
                 expect(cancelRes.residualPids).toBeDefined();
                 expect(cancelRes.residualPids).toContain(escapedPid);
                 // 核心架构红线：驱动无法确认停止时，必须转入 indeterminate，绝对保留隔离屏障与排他锁！
@@ -538,11 +539,11 @@ export function defineContractTestSuite(consumerName, createContext) {
                 domain.allocateResources('op-second', ['res:op2']);
             }).toThrowError(ResourceConflictError);
             setTimeout(() => {
-                domain.releaseResources('op-first');
+                domain.internalReleaseResources('op-first');
             }, 60);
             await domain.allocateResourcesWithWait('op-second', ['res:op2'], 300);
             expect(domain.getResourceOwner('res:op2')).toBe('op-second');
-            domain.releaseResources('op-second');
+            domain.internalReleaseResources('op-second');
         });
         it('契约 15: 大输出流式落盘转储与 fsync 校验 (Spill to Artifacts)', async () => {
             const { supervisor, domain, tempDir } = ctx;
@@ -695,6 +696,473 @@ export function defineContractTestSuite(consumerName, createContext) {
             expect(throwing.stdout).toBe('captured-anyway');
             expect(throwing.streamCallbackError).toBe('consumer projection failed');
         });
+        it('契约 19: 超时 + 逃逸后代持有管道，操作在有界时间内返回 indeterminate，不挂到逃逸进程退出', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c19', 'run-c19');
+            const subPidFile = path.join(tempDir, 'sub-c19.pid');
+            const runnerScript = `
+        const { spawn } = require('node:child_process');
+        const fs = require('node:fs');
+        const sub = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 8000);'], {
+          detached: true,
+          stdio: ['ignore', 'inherit', 'inherit']
+        });
+        fs.writeFileSync(${JSON.stringify(subPidFile)}, String(sub.pid));
+        setInterval(() => {}, 1000);
+      `;
+            const startedAt = Date.now();
+            const result = await supervisor.executeProcess({
+                runId: 'run-c19',
+                opId: 'op-c19-timeout-bounded',
+                name: 'timeout-bounded-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', runnerScript],
+                    cwd: tempDir,
+                },
+                requiredResources: ['res:c19-bounded'],
+                timeoutMs: 600,
+                drainTimeoutMs: 300,
+            });
+            const duration = Date.now() - startedAt;
+            expect(duration).toBeLessThan(3500);
+            expect(result.status).toBe('indeterminate');
+            expect(domain.isResourceLocked('res:c19-bounded')).toBe(true);
+            // 清理逃逸孙进程
+            if (fs.existsSync(subPidFile)) {
+                try {
+                    const pid = parseInt(fs.readFileSync(subPidFile, 'utf8'), 10);
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch { }
+            }
+        }, 15_000);
+        it('契约 20: 停止不存在或已终结的操作返回显式 OperationNotActiveError', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c20', 'run-c20');
+            // 1. 不存在的操作
+            await expect(supervisor.cancelOperation('op-c20-nonexistent')).rejects.toSatisfy((err) => {
+                expect(err).toBeInstanceOf(OperationNotActiveError);
+                expect(err.reason).toBe('not_found');
+                return true;
+            });
+            // 2. 已终结的操作
+            const completedOpId = 'op-c20-completed';
+            await supervisor.executeProcess({
+                runId: 'run-c20',
+                opId: completedOpId,
+                name: 'completed-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'process.exit(0);'],
+                    cwd: tempDir,
+                },
+                requiredResources: [],
+            });
+            await expect(supervisor.cancelOperation(completedOpId)).rejects.toSatisfy((err) => {
+                expect(err).toBeInstanceOf(OperationNotActiveError);
+                expect(err.reason).toBe('already_completed');
+                return true;
+            });
+        });
+        it('契约 21: 僵尸 leader + 存活后代：恢复按组清场后才结清', async () => {
+            const { domain, driver, tempDir } = ctx;
+            const opId = 'op-c21-zombie';
+            const runId = 'run-c21';
+            ensureTaskAndRun(domain, 'task-c21', runId);
+            domain.registerOperationIntent({
+                id: opId,
+                runId,
+                kind: 'process',
+                name: 'process:zombie-with-orphan',
+                inputFingerprint: 'fp-c21',
+                requiredResources: ['res:c21'],
+                status: 'intent_registered',
+            });
+            const descendant = spawn(process.execPath, ['-e', 'process.on("SIGTERM",()=>{}); setInterval(()=>{},1000)'], { detached: true, stdio: ['ignore', 'inherit', 'inherit'] });
+            const descendantPid = descendant.pid;
+            descendant.unref();
+            domain.getStore().updateOperationStatus(opId, 'active', {
+                pid: descendantPid,
+                pgid: descendantPid,
+                spawnTime: new Date().toISOString(),
+                commandFingerprint: `${process.execPath}:-e`,
+            });
+            domain.getStore().updateOperationStatus(opId, 'stopping');
+            const stored = domain.getStore().getOperation(opId);
+            domain.getStore().updateOperationStatus(opId, 'active', {
+                ...stored.processIdentity,
+                pid: 2_147_483_000,
+            });
+            try {
+                const report = await new RecoveryEngine(domain, driver).recover();
+                expect(report.recoveredOperations).toHaveLength(1);
+                expect(report.recoveredOperations[0].action).toBe('marked_dead');
+                expect(report.recoveredOperations[0].resourcesReleased).toBe(true);
+                expect(domain.isResourceLocked('res:c21')).toBe(false);
+                const result = domain.getStore().getOperation(opId).result;
+                expect(result.status).toBe('failed');
+                expect(result.kind === 'process' ? result.stderr : '').toContain('reaped during recovery');
+            }
+            finally {
+                try {
+                    process.kill(-descendantPid, 'SIGKILL');
+                }
+                catch { }
+            }
+        }, 20_000);
+        it('契约 22: 重复 opId 提交抛出 DuplicateOperationError，原操作租约与可取消性不受影响', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c22', 'run-c22');
+            const opId = 'op-c22-duplicate';
+            const execPromise = supervisor.executeProcess({
+                runId: 'run-c22',
+                opId,
+                name: 'sleep-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'setInterval(() => {}, 1000);'],
+                    cwd: tempDir,
+                },
+                requiredResources: ['res:c22'],
+            });
+            await new Promise((r) => setTimeout(r, 100));
+            // 重复提交相同 opId 必须抛出 DuplicateOperationError
+            await expect(supervisor.executeProcess({
+                runId: 'run-c22',
+                opId,
+                name: 'duplicate-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'process.exit(0);'],
+                    cwd: tempDir,
+                },
+                requiredResources: ['res:c22'],
+            })).rejects.toThrow(DuplicateOperationError);
+            // 原操作排他租约未被破坏
+            expect(domain.isResourceLocked('res:c22')).toBe(true);
+            // 原操作仍可成功取消
+            const stopRes = await supervisor.cancelOperation(opId, 1000);
+            expect(stopRes.stopped).toBe('confirmed_stopped');
+            const opResult = await execPromise;
+            expect(opResult.status).toBe('cancelled');
+        });
+        it('契约 23: 恢复后 Run 状态收敛，无未终结操作时 Run 不停留在 running', async () => {
+            const { domain, driver } = ctx;
+            const taskId = 'task-c23';
+            const runId = 'run-c23';
+            ensureTaskAndRun(domain, taskId, runId);
+            domain.registerOperationIntent({
+                id: 'op-c23-1',
+                runId,
+                kind: 'process',
+                name: 'clean-crashed-op',
+                inputFingerprint: 'f'.repeat(64),
+                requiredResources: ['res:c23-clean'],
+                status: 'intent_registered',
+            });
+            const recovery = new RecoveryEngine(domain, driver);
+            await recovery.recover();
+            const runAfter = domain.getStore().getRun(runId);
+            expect(runAfter?.status).toBe('failed');
+            expect(runAfter?.terminationReason).toBe('crash_detected');
+        });
+        it('契约 24: 人工裁决受审计出口：仅对 indeterminate 生效，写 journal 并受代际栅栏约束', async () => {
+            const { domain } = ctx;
+            const opId = 'op-c24-indet';
+            const runId = 'run-c24';
+            ensureTaskAndRun(domain, 'task-c24', runId);
+            domain.registerOperationIntent({
+                id: opId,
+                runId,
+                kind: 'process',
+                name: 'indet-op',
+                inputFingerprint: 'f'.repeat(64),
+                requiredResources: ['res:c24'],
+                status: 'intent_registered',
+            });
+            // 写入 indeterminate 结果
+            domain.getStore().recordOperationResult(opId, {
+                kind: 'indeterminate',
+                status: 'indeterminate',
+                reason: 'Process cannot be determined',
+                recoveryGuidance: 'Check manually',
+                durationMs: 10,
+                completedAt: new Date().toISOString(),
+            }, false // 不释放租约
+            );
+            expect(domain.isResourceLocked('res:c24')).toBe(true);
+            // 人工裁决 confirmed_stopped 成功释放租约
+            const record = await domain.adjudicate(opId, 'confirmed_stopped', 'admin-user', 'Manual verified dead');
+            expect(record.verdict).toBe('confirmed_stopped');
+            expect(domain.isResourceLocked('res:c24')).toBe(false);
+            const events = domain.getStore().getJournalEvents(domain.domainId);
+            const adjEvent = events.find((e) => e.type === 'OPERATION_ADJUDICATED' && e.operationId === opId);
+            expect(adjEvent).toBeDefined();
+        });
+        it('契约 25: 内存保留 Head + Tail，截断点落在 UTF-8 边界', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c25', 'run-c25');
+            const result = await supervisor.executeProcess({
+                runId: 'run-c25',
+                opId: 'op-c25-head-tail',
+                name: 'head-tail-op',
+                command: {
+                    execPath: process.execPath,
+                    args: [
+                        '-e',
+                        'process.stdout.write("HEAD-START-12345\\n" + "x".repeat(120 * 1024) + "\\nTAIL-END-67890");',
+                    ],
+                    cwd: tempDir,
+                },
+                requiredResources: [],
+                maxOutputBytes: 10 * 1024,
+            });
+            expect(result.status).toBe('succeeded');
+            expect(result.isTruncated).toBe(true);
+            expect(result.stdout).toContain('HEAD-START-12345');
+            expect(result.stdout).toContain('TAIL-END-67890');
+            expect(result.stdout).toContain('[... truncated');
+        });
+        it('契约 26: 转储失败可见：spillError 出现时不返回引用', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c26', 'run-c26');
+            const nonWritablePath = path.join(tempDir, 'non-writable-file');
+            fs.writeFileSync(nonWritablePath, 'block');
+            const result = await supervisor.executeProcess({
+                runId: 'run-c26',
+                opId: 'op-c26-spill-err',
+                name: 'spill-err-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'process.stdout.write("hello-spill-fail");'],
+                    cwd: tempDir,
+                },
+                requiredResources: [],
+                artifactsDir: nonWritablePath,
+            });
+            expect(result.status).toBe('succeeded');
+            expect(result.spillError).toBeDefined();
+            expect(result.outputRef).toBeUndefined();
+            expect(result.stdout).toBe('hello-spill-fail');
+        });
+        it('契约 27: 未截断转储在结清时删除；pruneArtifacts 拒绝回收未终结 / 未裁决 op 的产物', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c27', 'run-c27');
+            const artifactsDir = path.join(tempDir, 'artifacts');
+            // 1. 未截断转储在结清时自动删除
+            const untruncated = await supervisor.executeProcess({
+                runId: 'run-c27',
+                opId: 'op-c27-untruncated',
+                name: 'untruncated-op',
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'process.stdout.write("short text");'],
+                    cwd: tempDir,
+                },
+                requiredResources: [],
+                artifactsDir,
+            });
+            expect(untruncated.status).toBe('succeeded');
+            expect(untruncated.isTruncated).toBe(false);
+            expect(untruncated.outputRef).toBeUndefined();
+            const files = fs.existsSync(artifactsDir) ? fs.readdirSync(artifactsDir) : [];
+            expect(files.filter((f) => f.includes('op-c27-untruncated'))).toHaveLength(0);
+            // 2. pruneArtifacts 拒绝回收未终结 / 未裁决 op 的产物
+            domain.registerOperationIntent({
+                id: 'op-c27-active',
+                runId: 'run-c27',
+                kind: 'process',
+                name: 'active-op',
+                inputFingerprint: 'f'.repeat(64),
+                requiredResources: [],
+                status: 'intent_registered',
+            });
+            fs.mkdirSync(artifactsDir, { recursive: true });
+            const activeFile = path.join(artifactsDir, 'op-c27-active-stdout.log');
+            fs.writeFileSync(activeFile, 'active artifact');
+            const pruneResult = domain.pruneArtifacts();
+            expect(pruneResult.retained).toContain(activeFile);
+            expect(fs.existsSync(activeFile)).toBe(true);
+        });
+        it('契约 45: 同 opId 同指纹重放返回已记录结果，不产生新进程，写 OPERATION_REPLAYED', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c45', 'run-c45');
+            const counterFile = path.join(tempDir, 'counter-c45.log');
+            const options = {
+                runId: 'run-c45',
+                opId: 'op-c45-recorded',
+                name: 'op-c45',
+                requiredResources: [],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', `require('fs').appendFileSync(process.argv[1], '1\\n'); console.log('c45-out');`, counterFile],
+                    cwd: tempDir,
+                },
+            };
+            const res1 = await supervisor.executeProcess(options);
+            expect(res1.status).toBe('succeeded');
+            expect(res1.replayed).toBeUndefined();
+            expect(res1.stdout).toContain('c45-out');
+            const res2 = await supervisor.executeProcess(options);
+            expect(res2.status).toBe('succeeded');
+            expect(res2.replayed).toBe(true);
+            expect(res2.stdout).toContain('c45-out');
+            // 验证副作用仅发生 1 次
+            const lines = fs.readFileSync(counterFile, 'utf8').trim().split('\n');
+            expect(lines.length).toBe(1);
+            // journal 记录 OPERATION_REPLAYED
+            const events = domain.getStore().getJournalEvents(domain.domainId);
+            const replayEvt = events.find((e) => e.type === 'OPERATION_REPLAYED' && e.operationId === 'op-c45-recorded');
+            expect(replayEvt).toBeDefined();
+            expect(replayEvt?.payload.mode).toBe('recorded');
+        });
+        it('契约 46: 同 opId 不同指纹 => OperationIdConflictError，不改动已有 op 的任何事实', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c46', 'run-c46');
+            const options1 = {
+                runId: 'run-c46',
+                opId: 'op-c46-conflict',
+                name: 'op-c46-orig',
+                requiredResources: [],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'console.log("c46-orig");'],
+                    cwd: tempDir,
+                },
+            };
+            const res1 = await supervisor.executeProcess(options1);
+            expect(res1.status).toBe('succeeded');
+            const options2 = {
+                runId: 'run-c46',
+                opId: 'op-c46-conflict',
+                name: 'op-c46-conflict',
+                requiredResources: [],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'console.log("c46-diff");'], // 不同 args
+                    cwd: tempDir,
+                },
+            };
+            await expect(supervisor.executeProcess(options2)).rejects.toThrow(OperationIdConflictError);
+            const op = domain.getStore().getOperation('op-c46-conflict');
+            expect(op?.status).toBe('done');
+            expect(op?.result?.status).toBe('succeeded');
+        });
+        it('契约 47: 重放命中在飞 op => 两个调用拿到同一结果，进程只启动一次', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c47', 'run-c47');
+            const counterFile = path.join(tempDir, 'counter-c47.log');
+            const options = {
+                runId: 'run-c47',
+                opId: 'op-c47-inflight',
+                name: 'op-c47',
+                requiredResources: [],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', `require('fs').appendFileSync(process.argv[1], '1\\n'); setTimeout(() => console.log('c47-out'), 300);`, counterFile],
+                    cwd: tempDir,
+                },
+            };
+            const [res1, res2] = await Promise.all([
+                supervisor.executeProcess(options),
+                supervisor.executeProcess(options),
+            ]);
+            expect(res1.status).toBe('succeeded');
+            expect(res2.status).toBe('succeeded');
+            expect(res2.replayed).toBe(true);
+            const lines = fs.readFileSync(counterFile, 'utf8').trim().split('\n');
+            expect(lines.length).toBe(1);
+            const events = domain.getStore().getJournalEvents(domain.domainId);
+            const replayEvt = events.find((e) => e.type === 'OPERATION_REPLAYED' && e.operationId === 'op-c47-inflight');
+            expect(replayEvt?.payload.mode).toBe('joined');
+        });
+        it('契约 48: 重放命中 indeterminate => 原样返回，不重跑，租约保持', async () => {
+            const { supervisor, domain, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c48', 'run-c48');
+            const opId = 'op-c48-indet';
+            const store = domain.getStore();
+            const options = {
+                runId: 'run-c48',
+                opId,
+                name: 'test-indet',
+                requiredResources: ['res:c48'],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'process.exit(0)'],
+                    cwd: tempDir,
+                },
+            };
+            store.registerOperationIntent({
+                id: opId,
+                runId: 'run-c48',
+                kind: 'process',
+                name: 'test-indet',
+                inputFingerprint: computeInputFingerprint(options),
+                requiredResources: ['res:c48'],
+                status: 'pending',
+            }, domain.domainId);
+            const indetResult = {
+                kind: 'process',
+                status: 'indeterminate',
+                exitCode: null,
+                signal: null,
+                stdout: '',
+                stderr: 'indeterminate residual',
+                isTruncated: false,
+                identityVerification: 'cannot_determine',
+                durationMs: 50,
+                completedAt: new Date().toISOString(),
+            };
+            store.recordOperationResult(opId, indetResult, false);
+            const res = await supervisor.executeProcess(options);
+            expect(res.status).toBe('indeterminate');
+            expect(res.replayed).toBe(true);
+            const leases = store.getPersistedResourceLeases(domain.domainId);
+            expect(leases.some((l) => l.operationId === opId && l.resourceId === 'res:c48')).toBe(true);
+        });
+        it('契约 49: 有意图无身份的崩溃现场：未恢复时提交抛 RecoveryRequiredError；恢复后结清重放命中已记录事实', async () => {
+            const { supervisor, domain, driver, tempDir } = ctx;
+            ensureTaskAndRun(domain, 'task-c49', 'run-c49');
+            const opId = 'op-c49-unrecovered';
+            const store = domain.getStore();
+            const options = {
+                runId: 'run-c49',
+                opId,
+                name: 'test-unrecovered',
+                requiredResources: [],
+                command: {
+                    execPath: process.execPath,
+                    args: ['-e', 'console.log(1)'],
+                    cwd: tempDir,
+                },
+            };
+            // 构造崩溃残留：intent_registered 且不在内存活跃表中
+            store.registerOperationIntent({
+                id: opId,
+                runId: 'run-c49',
+                kind: 'process',
+                name: 'test-unrecovered',
+                inputFingerprint: computeInputFingerprint(options),
+                requiredResources: [],
+                status: 'intent_registered',
+            }, domain.domainId);
+            // 未调用 recover() 前调用，抛 RecoveryRequiredError
+            await expect(supervisor.executeProcess(options)).rejects.toThrow(RecoveryRequiredError);
+            // 执行崩溃恢复
+            const recoveryEngine = new RecoveryEngine(domain, driver);
+            await recoveryEngine.recover();
+            // 恢复后该意图被收敛为 failed(never spawned)，新 Run 再次发起重放应命中已记录结果
+            ensureTaskAndRun(domain, 'task-c49', 'run-c49-new');
+            const replayOptions = {
+                ...options,
+                runId: 'run-c49-new',
+            };
+            const res = await supervisor.executeProcess(replayOptions);
+            expect(res.status).toBe('failed');
+            expect(res.replayed).toBe(true);
+            expect(res.runId).toBe('run-c49');
+        });
     });
 }
 //# sourceMappingURL=contract-suite.js.map