@lsctech/polaris 0.1.0

package/dist/runtime/continuation/confirmed.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchConfirmedContinuation = dispatchConfirmedContinuation;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+const state_js_1 = require("../state.js");
+const envelope_js_1 = require("../verification/envelope.js");
+const checkpoint_js_1 = require("../checkpoint.js");
+const logger_js_1 = require("../audit/logger.js");
+const reader_js_1 = require("../audit/reader.js");
+const execution_adapter_js_1 = require("../../loop/execution-adapter.js");
+const agent_subtask_js_1 = require("../../loop/adapters/agent-subtask.js");
+const execution_window_js_1 = require("../execution-window.js");
+const fingerprint_js_1 = require("../verification/fingerprint.js");
+/**
+ * Dispatch a confirmed continuation: validate, checkpoint, acquire active_child lease,
+ * and stub the adapter call. Full adapter dispatch wired in Issue C (POL-93).
+ */
+async function dispatchConfirmedContinuation(request) {
+    const { artifact_dir, envelope } = request;
+    // Step 1: fresh state read — never use a caller-supplied cached copy
+    const rawState = await (0, state_js_1.loadState)(artifact_dir);
+    if (rawState === null) {
+        return { ok: false, rejection: { check: "state", reason: "state_not_found" } };
+    }
+    // Step 4: recovery state detection (before envelope validation — active_child may need clearing first)
+    const auditLog = await (0, reader_js_1.readAuditLog)(artifact_dir);
+    const lastDispatch = (0, reader_js_1.findLastEvent)(auditLog, "worker_dispatched", rawState.run_id, rawState.step_cursor ?? "");
+    const lastResult = (0, reader_js_1.findLastEvent)(auditLog, "worker_result_received", rawState.run_id, rawState.step_cursor ?? "");
+    if (lastDispatch && (!lastResult || lastDispatch.timestamp > lastResult.timestamp)) {
+        // dispatched-awaiting-result: a worker was dispatched but result not yet received — do NOT re-dispatch
+        return { ok: false, rejection: { check: "recovery", reason: "dispatched-awaiting-result" } };
+    }
+    let state = rawState;
+    if (rawState.active_child && !lastDispatch) {
+        // interrupted-before-dispatch: active_child set but no dispatch event — clear and proceed
+        const cleared = { ...rawState, active_child: null };
+        await (0, state_js_1.writeState)(artifact_dir, cleared);
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "recovery_attempted",
+            run_id: rawState.run_id,
+            step_cursor: rawState.step_cursor ?? "",
+            operator: "mcp",
+            operation: "interrupted_before_dispatch_recovery",
+            result: "ok",
+            metadata: { cleared_active_child: rawState.active_child },
+        });
+        state = cleared;
+    }
+    // Step 2: paranoid re-validation after the pendingConfirmations gate
+    const validation = (0, envelope_js_1.validateEnvelope)(state, envelope);
+    if (!validation.ok) {
+        return { ok: false, rejection: validation.failure };
+    }
+    // Step 3: execution window validation
+    if (request.executionWindow) {
+        const fingerprint = (0, fingerprint_js_1.computeStateFingerprint)({ state, approvalNonce: request.executionWindow.run_id });
+        const windowResult = (0, execution_window_js_1.validateWindow)(state, request.executionWindow, fingerprint);
+        if (!windowResult.ok) {
+            return { ok: false, rejection: { check: "execution_window", reason: windowResult.reason } };
+        }
+    }
+    // Step 5: pre-dispatch checkpoint
+    await (0, checkpoint_js_1.writeCheckpoint)(artifact_dir, state.step_cursor);
+    const nextChild = validation.next_child;
+    // Step 6: acquire active_child lease — single writeState call sets both fields atomically
+    await (0, state_js_1.writeState)(artifact_dir, {
+        ...state,
+        active_child: nextChild,
+        continuation_epoch: (state.continuation_epoch ?? 0) + 1,
+    });
+    // Decrement window after lease acquired — persist as side-file
+    if (request.executionWindow) {
+        const decremented = (0, execution_window_js_1.decrementWindow)(request.executionWindow);
+        // Persist decremented window to side-file (not in CurrentState)
+        const windowFile = node_path_1.default.join((0, state_js_1.getArtifactDir)(artifact_dir), "execution-window.json");
+        await (0, promises_1.writeFile)(windowFile, JSON.stringify(decremented, null, 2) + "\n", "utf-8");
+    }
+    // Step 7: record mutation_approved after state is durably written
+    await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+        event_type: "mutation_approved",
+        run_id: state.run_id,
+        step_cursor: state.step_cursor,
+        operator: "mcp",
+        operation: "loop_continue_confirmed",
+        approval_fingerprint: envelope.fingerprint,
+        result: "ok",
+        metadata: { next_child: nextChild },
+    });
+    // Step 8: adapter selection + autoDispatch gating
+    const selection = (0, execution_adapter_js_1.selectExecutionAdapter)({
+        explicitAdapter: request.adapterOverride,
+        insideAgentSession: true,
+        nativeSubtaskAvailable: true,
+        crossAgentConfigured: false,
+        tokenBudgetLow: false,
+    });
+    if (!selection.autoDispatch) {
+        return {
+            ok: false,
+            rejection: {
+                check: "adapter_mode",
+                reason: "manual_dispatch_required",
+                detail: `Adapter "${selection.mode}" requires manual operator dispatch`,
+            },
+        };
+    }
+    // Step 9: dispatch boundary assertion
+    if (!nextChild)
+        throw new Error("dispatch_invariant_violated: nextChild must be non-empty at dispatch boundary");
+    // Step 10: emit worker_dispatched audit event before adapter call
+    await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+        event_type: "worker_dispatched",
+        run_id: state.run_id,
+        step_cursor: state.step_cursor,
+        child_id: nextChild,
+        operator: "mcp",
+        operation: "confirmed_dispatch",
+        result: "ok",
+        metadata: { adapter_mode: selection.mode },
+    });
+    // Step 11: build bootstrap packet and call adapter.dispatch()
+    const packet = {
+        schema_version: "1.0",
+        run_id: state.run_id,
+        cluster_id: state.cluster_id,
+        active_child: nextChild,
+        state_file: node_path_1.default.resolve(artifact_dir, "current-state.json"),
+        telemetry_file: node_path_1.default.resolve(artifact_dir, "telemetry.jsonl"),
+    };
+    const adapter = request._adapterFactory ? request._adapterFactory() : new agent_subtask_js_1.AgentSubtaskAdapter();
+    let compactReturn;
+    let dispatchResultCode = 0;
+    try {
+        const dispatchResult = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        dispatchResultCode = dispatchResult.exit_code;
+        // Parse summary if available; fall back to inferring done state from exit_code
+        if (dispatchResult.summary) {
+            try {
+                const parsed = JSON.parse(dispatchResult.summary);
+                compactReturn = {
+                    status: typeof parsed["status"] === "string" ? parsed["status"] : "done",
+                    state_updated: typeof parsed["state_updated"] === "boolean" ? parsed["state_updated"] : dispatchResult.exit_code === 0,
+                    exit_code: dispatchResult.exit_code,
+                };
+            }
+            catch {
+                compactReturn = { status: "done", state_updated: dispatchResult.exit_code === 0, exit_code: dispatchResult.exit_code };
+            }
+        }
+        else {
+            compactReturn = { status: "done", state_updated: dispatchResult.exit_code === 0, exit_code: dispatchResult.exit_code };
+        }
+    }
+    catch {
+        // Adapter dispatch failed — clear active_child, write recovery audit events, and
+        // return ok: false so MCP callers are not misled into treating a failed dispatch
+        // as successful execution.
+        // Read the latest persisted state to avoid clobbering newer fields like continuation_epoch
+        const latestState = await (0, state_js_1.loadState)(artifact_dir);
+        if (latestState !== null) {
+            await (0, state_js_1.writeState)(artifact_dir, { ...latestState, active_child: "" });
+        }
+        else {
+            // Fallback: use the stale state if persisted state is missing (should not happen)
+            await (0, state_js_1.writeState)(artifact_dir, { ...state, active_child: "" });
+        }
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "worker_result_received",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            child_id: nextChild,
+            operator: "mcp",
+            operation: "confirmed_dispatch",
+            result: "error",
+            metadata: { reason: "adapter_throw" },
+        });
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "recovery_attempted",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "confirmed_dispatch_recovery",
+            result: "ok",
+            metadata: { reason: "adapter_dispatch_failed" },
+        });
+        return { ok: false, rejection: { check: "adapter_dispatch", reason: "dispatch_failed" } };
+    }
+    // Step 12: emit worker_result_received audit event
+    await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+        event_type: "worker_result_received",
+        run_id: state.run_id,
+        step_cursor: state.step_cursor,
+        child_id: nextChild,
+        operator: "mcp",
+        operation: "confirmed_dispatch",
+        result: "ok",
+        metadata: { exit_code: dispatchResultCode, status: compactReturn.status },
+    });
+    // Step 13: handle state_updated: false — defensively clear active_child
+    if (compactReturn.state_updated === false) {
+        // Read the latest persisted state to avoid clobbering newer fields like continuation_epoch
+        const currentPersistedState = await (0, state_js_1.loadState)(artifact_dir);
+        if (currentPersistedState !== null) {
+            await (0, state_js_1.writeState)(artifact_dir, { ...currentPersistedState, active_child: "" });
+        }
+        else {
+            // Fallback: use the stale state if persisted state is missing (should not happen)
+            await (0, state_js_1.writeState)(artifact_dir, { ...state, active_child: "" });
+        }
+        await (0, logger_js_1.appendAuditEvent)(artifact_dir, {
+            event_type: "recovery_attempted",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "confirmed_dispatch_recovery",
+            result: "ok",
+            metadata: { reason: "state_updated_false" },
+        });
+    }
+    return { ok: true, child_id: nextChild, compact_return: compactReturn };
+}

package/dist/runtime/continuation/confirmed.test.js

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * POL-92: Unit tests for adapter selection + autoDispatch gating in confirmed.ts
+ *
+ * Tests the selectExecutionAdapter integration and autoDispatch gate.
+ * Each test gets an isolated artifact directory in .taskchain_artifacts.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const fingerprint_js_1 = require("../verification/fingerprint.js");
+const confirmed_js_1 = require("./confirmed.js");
+const logger_js_1 = require("../audit/logger.js");
+async function readAuditLog(artifactDir) {
+    const filePath = node_path_1.default.join(ARTIFACTS_ROOT, artifactDir, "audit.jsonl");
+    try {
+        const raw = await (0, promises_1.readFile)(filePath, "utf-8");
+        return raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+function makeMockAdapter(result) {
+    return () => ({
+        name: "mock-adapter",
+        // eslint-disable-next-line no-unused-vars
+        async dispatch(_packet, _options) {
+            return {
+                exit_code: 0,
+                provider_used: "mock",
+                command_run: "mock",
+                summary: JSON.stringify(result),
+            };
+        },
+    });
+}
+const ARTIFACTS_ROOT = node_path_1.default.join(process.cwd(), ".taskchain_artifacts");
+function makeRunningState(overrides = {}) {
+    return {
+        schema_version: "1.0",
+        run_id: "polaris-run-test-pol92",
+        cluster_id: "POL-88",
+        active_child: null,
+        completed_children: ["POL-89", "POL-90", "POL-91"],
+        open_children: ["POL-92"],
+        step_cursor: "06-decide-continuation",
+        context_budget: { children_completed: 3, max_children_per_session: 4 },
+        status: "running",
+        runtime_generation: 1,
+        orchestration_mode: "bootstrap",
+        continuation_epoch: 0,
+        ...overrides,
+    };
+}
+async function writeStateToDir(artifactDir, state) {
+    const dir = node_path_1.default.join(ARTIFACTS_ROOT, artifactDir);
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(dir, "current-state.json"), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function buildEnvelope(state) {
+    const nonce = (0, node_crypto_1.randomUUID)();
+    const fingerprint = (0, fingerprint_js_1.computeStateFingerprint)({ state, approvalNonce: nonce });
+    const now = new Date();
+    return {
+        run_id: state.run_id,
+        expected_step_cursor: state.step_cursor,
+        fingerprint,
+        runtime_generation: state.runtime_generation ?? 1,
+        nonce,
+        issued_at: now.toISOString(),
+        expires_at: new Date(now.getTime() + 5 * 60 * 1000).toISOString(),
+        requested_action: "loop_continue",
+    };
+}
+let testArtifactDir;
+(0, vitest_1.beforeEach)(() => {
+    testArtifactDir = `test-pol92-${(0, node_crypto_1.randomUUID)().slice(0, 8)}`;
+});
+(0, vitest_1.afterEach)(async () => {
+    const dir = node_path_1.default.join(ARTIFACTS_ROOT, testArtifactDir);
+    await (0, promises_1.rm)(dir, { recursive: true, force: true });
+});
+(0, vitest_1.describe)("confirmed.ts: adapter selection + autoDispatch gating", () => {
+    (0, vitest_1.it)("agent-subtask mode → autoDispatch true → proceeds past gating (ok: true)", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+            (0, vitest_1.expect)(result.compact_return.status).toBe("done");
+        }
+    });
+    (0, vitest_1.it)("terminal-cli mode → autoDispatch false → returns manual_dispatch_required rejection", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "terminal-cli",
+        });
+        (0, vitest_1.expect)(result.ok).toBe(false);
+        if (!result.ok) {
+            (0, vitest_1.expect)(result.rejection.check).toBe("adapter_mode");
+            (0, vitest_1.expect)(result.rejection.reason).toBe("manual_dispatch_required");
+            (0, vitest_1.expect)(result.rejection.detail).toContain("terminal-cli");
+        }
+    });
+    (0, vitest_1.it)("ci mode → autoDispatch false → returns manual_dispatch_required rejection", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "ci",
+        });
+        (0, vitest_1.expect)(result.ok).toBe(false);
+        if (!result.ok) {
+            (0, vitest_1.expect)(result.rejection.check).toBe("adapter_mode");
+            (0, vitest_1.expect)(result.rejection.reason).toBe("manual_dispatch_required");
+            (0, vitest_1.expect)(result.rejection.detail).toContain("ci");
+        }
+    });
+    (0, vitest_1.it)("no adapterOverride → auto-detects agent-subtask (insideAgentSession + nativeSubtaskAvailable) → autoDispatch true → ok", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        // No adapterOverride: selectExecutionAdapter called with insideAgentSession: true, nativeSubtaskAvailable: true
+        // → resolves to agent-subtask → autoDispatch: true
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+        }
+    });
+});
+function makeWindow(state, overrides = {}) {
+    return {
+        run_id: state.run_id,
+        max_continuations: 3,
+        valid_from: new Date(Date.now() - 60000).toISOString(),
+        valid_until: new Date(Date.now() + 3600000).toISOString(),
+        allowed_child_types: [],
+        state_fingerprint_at_issue: (0, fingerprint_js_1.computeStateFingerprint)({ state, approvalNonce: state.run_id }),
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("execution window validation", () => {
+    (0, vitest_1.it)("window present and valid → proceeds to dispatch (ok: true)", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const executionWindow = makeWindow(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            executionWindow,
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+        }
+    });
+    (0, vitest_1.it)("window present and exhausted (max_continuations: 0) → returns execution_window/window_exhausted rejection", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const executionWindow = makeWindow(state, { max_continuations: 0 });
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            executionWindow,
+        });
+        (0, vitest_1.expect)(result.ok).toBe(false);
+        if (!result.ok) {
+            (0, vitest_1.expect)(result.rejection.check).toBe("execution_window");
+            (0, vitest_1.expect)(result.rejection.reason).toBe("window_exhausted");
+        }
+    });
+    (0, vitest_1.it)("window absent → skipped entirely (proceeds normally, ok: true)", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+    });
+    (0, vitest_1.it)("valid window with non-empty allowed_child_types → proceeds (check deferred)", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const executionWindow = makeWindow(state, { allowed_child_types: ["implement"] });
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            executionWindow,
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+    });
+    (0, vitest_1.it)("decremented window is written to side-file after lease acquired", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const executionWindow = makeWindow(state, { max_continuations: 3 });
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            executionWindow,
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        const windowFilePath = node_path_1.default.join(ARTIFACTS_ROOT, testArtifactDir, "execution-window.json");
+        const raw = await (0, promises_1.readFile)(windowFilePath, "utf-8");
+        const persisted = JSON.parse(raw);
+        (0, vitest_1.expect)(persisted.max_continuations).toBe(2); // decremented from 3
+        (0, vitest_1.expect)(persisted.run_id).toBe(state.run_id);
+    });
+});
+(0, vitest_1.describe)("confirmed.ts: POL-93 dispatch + CompactReturn handling", () => {
+    (0, vitest_1.it)("mock adapter state_updated: true → active_child NOT cleared, worker_dispatched and worker_result_received in audit log", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+            (0, vitest_1.expect)(result.compact_return.status).toBe("done");
+            (0, vitest_1.expect)(result.compact_return.state_updated).toBe(true);
+        }
+        const events = await readAuditLog(testArtifactDir);
+        const dispatchedIdx = events.findIndex((e) => e["event_type"] === "worker_dispatched");
+        const receivedIdx = events.findIndex((e) => e["event_type"] === "worker_result_received");
+        (0, vitest_1.expect)(dispatchedIdx).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(receivedIdx).toBeGreaterThanOrEqual(0);
+        // worker_dispatched must appear before worker_result_received
+        (0, vitest_1.expect)(dispatchedIdx).toBeLessThan(receivedIdx);
+        const dispatched = events[dispatchedIdx];
+        (0, vitest_1.expect)(dispatched["child_id"]).toBe("POL-92");
+        (0, vitest_1.expect)(dispatched["operator"]).toBe("mcp");
+        (0, vitest_1.expect)(dispatched["operation"]).toBe("confirmed_dispatch");
+        (0, vitest_1.expect)(dispatched["result"]).toBe("ok");
+        const received = events[receivedIdx];
+        (0, vitest_1.expect)(received["child_id"]).toBe("POL-92");
+        (0, vitest_1.expect)(received["metadata"]["status"]).toBe("done");
+        // active_child should NOT be cleared by confirmed.ts (state_updated: true means adapter handled it)
+        // We can verify no recovery_attempted event was emitted
+        const recovery = events.find((e) => e["event_type"] === "recovery_attempted");
+        (0, vitest_1.expect)(recovery).toBeUndefined();
+    });
+    (0, vitest_1.it)("mock adapter state_updated: false → active_child defensively cleared + recovery_attempted emitted", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "dispatched-stub", state_updated: false }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.compact_return.state_updated).toBe(false);
+        }
+        const events = await readAuditLog(testArtifactDir);
+        const recovery = events.find((e) => e["event_type"] === "recovery_attempted");
+        (0, vitest_1.expect)(recovery).toBeDefined();
+        (0, vitest_1.expect)(recovery["result"]).toBe("ok");
+        (0, vitest_1.expect)(recovery["metadata"]["reason"]).toBe("state_updated_false");
+    });
+    (0, vitest_1.it)("worker_dispatched event appears before worker_result_received in audit log", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        const events = await readAuditLog(testArtifactDir);
+        const types = events.map((e) => e["event_type"]);
+        const dispatchedIdx = types.indexOf("worker_dispatched");
+        const receivedIdx = types.indexOf("worker_result_received");
+        (0, vitest_1.expect)(dispatchedIdx).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(receivedIdx).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(dispatchedIdx).toBeLessThan(receivedIdx);
+    });
+});
+(0, vitest_1.describe)("recovery state detection", () => {
+    (0, vitest_1.it)("clean state (no prior dispatch events) → proceeds normally (ok: true)", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+        }
+    });
+    (0, vitest_1.it)("dispatched-awaiting-result: worker_dispatched with no worker_result_received → returns dispatched-awaiting-result rejection", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        // Pre-seed worker_dispatched but no worker_result_received
+        await (0, logger_js_1.appendAuditEvent)(testArtifactDir, {
+            event_type: "worker_dispatched",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "confirmed_dispatch",
+            result: "ok",
+            metadata: { adapter_mode: "agent-subtask" },
+        });
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(false);
+        if (!result.ok) {
+            (0, vitest_1.expect)(result.rejection.check).toBe("recovery");
+            (0, vitest_1.expect)(result.rejection.reason).toBe("dispatched-awaiting-result");
+        }
+    });
+    (0, vitest_1.it)("interrupted-before-dispatch: active_child set but no worker_dispatched → clears active_child, emits recovery_attempted, then proceeds", async () => {
+        // Envelope issued against clean state (active_child null), then active_child got set without dispatch
+        const cleanState = makeRunningState({ active_child: null });
+        const envelope = buildEnvelope(cleanState);
+        // Now simulate an interrupted state: active_child got set but no worker_dispatched was emitted
+        const state = makeRunningState({ active_child: "POL-92" });
+        await writeStateToDir(testArtifactDir, state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        const events = await readAuditLog(testArtifactDir);
+        const recovery = events.find((e) => e["event_type"] === "recovery_attempted");
+        (0, vitest_1.expect)(recovery).toBeDefined();
+        (0, vitest_1.expect)(recovery["result"]).toBe("ok");
+        (0, vitest_1.expect)(recovery["metadata"]["cleared_active_child"]).toBe("POL-92");
+        (0, vitest_1.expect)(recovery["metadata"]["operation"]).toBeUndefined();
+        // Verify operation field on the recovery event
+        (0, vitest_1.expect)(recovery["operation"]).toBe("interrupted_before_dispatch_recovery");
+    });
+    (0, vitest_1.it)("idempotency: both worker_dispatched and worker_result_received present → proceeds normally", async () => {
+        const state = makeRunningState();
+        await writeStateToDir(testArtifactDir, state);
+        // Pre-seed both events (previous successful dispatch)
+        await (0, logger_js_1.appendAuditEvent)(testArtifactDir, {
+            event_type: "worker_dispatched",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "confirmed_dispatch",
+            result: "ok",
+            metadata: {},
+        });
+        await (0, logger_js_1.appendAuditEvent)(testArtifactDir, {
+            event_type: "worker_result_received",
+            run_id: state.run_id,
+            step_cursor: state.step_cursor,
+            operator: "mcp",
+            operation: "confirmed_dispatch",
+            result: "ok",
+            metadata: {},
+        });
+        const envelope = buildEnvelope(state);
+        const result = await (0, confirmed_js_1.dispatchConfirmedContinuation)({
+            artifact_dir: testArtifactDir,
+            envelope,
+            adapterOverride: "agent-subtask",
+            _adapterFactory: makeMockAdapter({ status: "done", state_updated: true }),
+        });
+        (0, vitest_1.expect)(result.ok).toBe(true);
+        if (result.ok) {
+            (0, vitest_1.expect)(result.child_id).toBe("POL-92");
+        }
+    });
+});