@deksden-com/dd-flow-cli 0.9.0-beta.19 → 0.9.0-beta.22

package/dist/services/hooks.js

@@ -8,6 +8,7 @@ import { parseJsonObject } from "../shared/json.js";
 import { ensureDir, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
+import { assertRecoveryHookCurrent } from "./run-recovery.js";
 import { commandHasOption, commandOption, commandPosition, parseLifecycleCommand, unwrapShellCommand } from "./lifecycle-command.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { activeFlowSessionsForProject, bindObservedFlowSession, flowSessionPayloadFromRegisterCommand, recordFlowSessionObservation } from "./sessions.js";
@@ -323,10 +324,12 @@ export function handleCodexHook(context, input) {
     // Codex retains the root session_id for a thread-spawned child, while the
     // payload transcript belongs to the current agent_id. Keep lineage separate
     // from ownership: otherwise a child overwrites the root transcript binding.
-    const bindingOwnerId = providerSessionId ?? rootProviderSessionId;
-    const binding = bindingOwnerId ? upsertSessionBindingFromPayload(context, project, bindingOwnerId, payload) : undefined;
+    const eventKey = hookEventKey(payload, eventName, toolName, command);
     const storageId = providerSessionId ? storageSessionId(nativeSessionIdentity("codex-desktop", providerSessionId)) : null;
     const parentSessionId = parentProviderSessionId ? storageSessionId(nativeSessionIdentity("codex-desktop", parentProviderSessionId)) : null;
+    assertHookEventReplay(context, { projectId: project.id, eventKey, harness: "codex-desktop", providerSessionId: providerSessionId ?? null, parentSessionId, daemonId: stringValue(context.env.DD_FLOW_DAEMON_ID) ?? null, sessionId: storageId, turnId: turnId ?? null, eventName, toolName: toolName ?? null, matchKey, cwd: stringValue(payload.cwd) ?? null });
+    const bindingOwnerId = providerSessionId ?? rootProviderSessionId;
+    const binding = bindingOwnerId ? upsertSessionBindingFromPayload(context, project, bindingOwnerId, payload) : undefined;
     const observedSession = flowPayload
         ? bindObservedFlowSession(context, project, {
             ...flowPayload,
@@ -337,13 +340,15 @@ export function handleCodexHook(context, input) {
         : undefined;
     const effectiveSessionId = observedSession?.session_id ?? storageId;
     const protocolId = observedSession?.protocol_id ?? binding?.protocol_id ?? null;
-    const eventKey = hookEventKey(payload, eventName, toolName, command);
     const inserted = recordHookEvent(context, {
         projectId: project.id,
         protocolId,
         harness: "codex-desktop",
         providerSessionId: providerSessionId ?? null,
         parentSessionId,
+        // Pinned by the owning app-server process, never derived from current RUN
+        // state or an agent-supplied shell command/payload.
+        daemonId: stringValue(context.env.DD_FLOW_DAEMON_ID) ?? null,
         sessionId: effectiveSessionId,
         agentId: rawChildProviderSessionId ?? null,
         turnId: turnId ?? null,
@@ -375,7 +380,7 @@ export function handleCodexHook(context, input) {
         session: providerSessionId ? nativeSessionIdentity("codex-desktop", providerSessionId) : null,
         ...(parentProviderSessionId ? { parent_session: nativeSessionIdentity("codex-desktop", parentProviderSessionId) } : {}),
         protocol_id: protocolId,
-        ...(providerSessionId && (flowPayload || stageStart || stageFinish || stagePause || stageResume || workStart || workFinish || workFail)
+        ...(providerSessionId && (flowPayload || stageStart || stageFinish || stagePause || stageResume || workStart || workFinish || workFail || lifecycle.invocation.operation === "recovery_accept")
             ? {
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",
@@ -454,6 +459,10 @@ export function handleZcodeEvent(context, input) {
     const sessionId = storageSessionId(nativeSessionIdentity("zcode-acp", providerSessionId));
     const parentSessionId = childProviderSessionId ? storageSessionId(nativeSessionIdentity("zcode-acp", rootProviderSessionId)) : null;
     const agentId = stringValue(runtime.agentId);
+    const eventKey = stringValue(update.toolCallId) ?? crypto.createHash("sha256").update(JSON.stringify({
+        harness: "zcode-acp", providerSessionId, command
+    })).digest("hex");
+    assertHookEventReplay(context, { projectId: project.id, eventKey, harness: "zcode-acp", providerSessionId, parentSessionId, daemonId: daemonId ?? null, sessionId, turnId: null, eventName: "PreToolUse", toolName: toolName ?? "Bash", matchKey, cwd: expectedRoot });
     const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
         ...flowPayload,
         harness: "zcode-acp",
@@ -461,9 +470,6 @@ export function handleZcodeEvent(context, input) {
         agent_id: agentId ?? null,
         parent_session_id: parentSessionId
     }, sessionId) : undefined;
-    const eventKey = stringValue(update.toolCallId) ?? crypto.createHash("sha256").update(JSON.stringify({
-        harness: "zcode-acp", providerSessionId, command
-    })).digest("hex");
     const payload = {
         session_id: providerSessionId,
         agent_id: agentId,
@@ -560,12 +566,13 @@ export function handleGrokEvent(context, input) {
     const parentSessionId = isChild ? storageSessionId(nativeSessionIdentity("grok-acp", stringValue(ddGrok.parentProviderSessionId) ?? rootProviderSessionId)) : null;
     const daemonId = stringValue(ddGrok.daemonId);
     const agentId = stringValue(hook.agent_id) ?? stringValue(hook.agentId);
-    const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
-        ...flowPayload, harness: "grok-acp", provider_session_id: providerSessionId, agent_id: agentId ?? null, parent_session_id: parentSessionId
-    }, sessionId) : undefined;
     const eventKey = stringValue(hook.event_id) ?? stringValue(hook.eventId) ?? crypto.createHash("sha256").update(JSON.stringify({
         harness: "grok-acp", providerSessionId, command, turn: hook.turn_id ?? hook.turnId ?? null
     })).digest("hex");
+    assertHookEventReplay(context, { projectId: project.id, eventKey, harness: "grok-acp", providerSessionId, parentSessionId, daemonId: daemonId ?? null, sessionId, turnId: stringValue(hook.turn_id) ?? stringValue(hook.turnId) ?? null, eventName: "PreToolUse", toolName: toolName ?? "Bash", matchKey, cwd: expectedRoot });
+    const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
+        ...flowPayload, harness: "grok-acp", provider_session_id: providerSessionId, agent_id: agentId ?? null, parent_session_id: parentSessionId
+    }, sessionId) : undefined;
     const payload = {
         ...hook, session_id: providerSessionId, agent_id: agentId, cwd: expectedRoot, tool_name: toolName ?? "Bash", tool_input: rawInput,
         command, provider: stringValue(observedProfile.provider), model: stringValue(observedProfile.model), reasoning: stringValue(observedProfile.reasoning), mode: stringValue(observedProfile.mode), agent_type: stringValue(hook.subagent_type) ?? stringValue(hook.subagentType)
@@ -581,7 +588,7 @@ export function handleGrokEvent(context, input) {
     });
     const result = { ok: true, observed: inserted, duplicate: !inserted, event_key: eventKey, session: nativeSessionIdentity("grok-acp", providerSessionId),
         ...(isChild ? { parent_session: nativeSessionIdentity("grok-acp", stringValue(ddGrok.parentProviderSessionId) ?? rootProviderSessionId) } : {}), daemon_id: daemonId ?? null };
-    return (flowPayload || stageStart || stageFinish || stagePause || stageResume || workStart || workFinish || workFail)
+    return (flowPayload || stageStart || stageFinish || stagePause || stageResume || workStart || workFinish || workFail || lifecycle.invocation.operation === "recovery_accept")
         ? { ...result, hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...(rawInput ?? {}), command: commandWithHookEvent(command, eventKey) } } }
         : result;
 }
@@ -664,6 +671,7 @@ function handleControlledToolEvent(context, input, event, harness) {
         }
     }
     const agentId = stringValue(session.agent_id);
+    assertHookEventReplay(context, { projectId: project.id, eventKey: baseKey, harness, providerSessionId, parentSessionId, daemonId, sessionId, turnId: stringValue(event.message_id) ?? null, eventName: "PreToolUse", toolName, matchKey, cwd: expectedRoot });
     const observedSession = flowPayload ? bindObservedFlowSession(context, project, {
         ...flowPayload, harness, provider_session_id: providerSessionId, agent_id: agentId ?? null,
         parent_session_id: parentSessionId, provider: stringValue(profile.provider) ?? null, model: stringValue(profile.model) ?? null,
@@ -791,6 +799,10 @@ function allowsStdinLifecycleCompound(facts) {
 }
 function lifecycleMatchKey(facts, projectRoot) {
     const { invocation, bootstrapStageStart, stageStart, stageFinish, stagePause, stageResume, workStart, workFinish, workFail, stageName, runId, workId, contextSha256 } = facts;
+    if (invocation.operation === "recovery_accept") {
+        const run = commandPosition(invocation, 0), recovery = commandOption(invocation, "recovery-id");
+        return run && recovery ? recoveryAcceptMatchKey(run, recovery, projectRoot) : null;
+    }
     if (bootstrapStageStart)
         return bootstrapMatchKey({
             projectRoot,
@@ -807,7 +819,7 @@ function lifecycleMatchKey(facts, projectRoot) {
     if (stageResume && runId && stageName && workId)
         return stageResumeMatchKey(runId, stageName, workId, projectRoot);
     if (workStart && workId)
-        return workStartMatchKey(workId, projectRoot);
+        return workStartMatchKey(workId, projectRoot, commandOption(invocation, "recovery-id"));
     if (workFinish && workId)
         return workLifecycleMatchKey("work_finish", workId, projectRoot);
     if (workFail && workId)
@@ -817,6 +829,9 @@ function lifecycleMatchKey(facts, projectRoot) {
 export function stageLifecycleMatchKey(operation, runId, stage, projectRoot, workId) {
     return crypto.createHash("sha256").update(JSON.stringify({ operation, run_id: runId, stage, project_root: resolveProjectRoot(projectRoot), ...(workId ? { work_id: workId } : {}) })).digest("hex");
 }
+export function recoveryAcceptMatchKey(runId, recoveryId, projectRoot) {
+    return crypto.createHash("sha256").update(JSON.stringify({ operation: "recovery_accept", run_id: runId, recovery_id: recoveryId, project_root: resolveProjectRoot(projectRoot) })).digest("hex");
+}
 export function workLifecycleMatchKey(operation, workId, projectRoot) {
     return crypto.createHash("sha256").update(JSON.stringify({ operation, work_id: workId, project_root: resolveProjectRoot(projectRoot) })).digest("hex");
 }
@@ -903,21 +918,24 @@ export function claimRecentMatchingHookEvent(context, input) {
 /** Finds the trusted event that a stage- or Work-specific claimant will atomically claim. */
 export function findRecentMatchingHookEvent(context, input) {
     const freshAfter = new Date(Date.parse(context.now()) - 60_000).toISOString();
-    const find = () => context.db.get(`SELECT id, event_key FROM hook_events
+    const find = () => context.db.all(`SELECT id, event_key FROM hook_events
      WHERE project_id = ? AND match_key = ? AND status = 'observed' AND created_at >= ?
-     ORDER BY id DESC LIMIT 1`, [input.projectId, input.matchKey, freshAfter]);
-    let event = find();
+     ORDER BY id DESC LIMIT 2`, [input.projectId, input.matchKey, freshAfter]);
+    let events = find();
     // Some harnesses publish nested-agent tool events concurrently with command
     // execution. Give the trusted event a short bounded window to reach SQLite.
     const deadline = Date.now() + 250;
-    while (!event?.event_key && Date.now() < deadline) {
+    while (events.length === 0 && Date.now() < deadline) {
         Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
-        event = find();
+        events = find();
     }
-    if (!event?.event_key) {
+    if (events.length === 0 || !events[0]?.event_key) {
         throw new AppError(input.errorCode, `${input.operation} requires one matching harness lifecycle event. Stay in this Session and retry the exact standalone lifecycle command; do not create a new Session.`, 1);
     }
-    return { id: event.id, eventKey: event.event_key };
+    if (events.length > 1) {
+        throw new AppError("ambiguous_lifecycle_receipt", `${input.operation} has more than one fresh matching lifecycle event; provide its exact hook event ID`, 1, { match_key: input.matchKey, event_keys: events.map((event) => event.event_key) });
+    }
+    return { id: events[0].id, eventKey: events[0].event_key };
 }
 /** Fallback for Desktop paths that execute the original command after a hook rewrite. */
 export function claimBootstrapHookEvent(context, input) {
@@ -940,7 +958,7 @@ export function bootstrapMatchKey(input) {
     })).digest("hex");
 }
 export function claimWorkStartHookEvent(context, input) {
-    const expected = new Set([workStartMatchKey(input.workId, input.projectRoot), workStartMatchKey(shortWorkReference(input.workId), input.projectRoot)]);
+    const expected = new Set([workStartMatchKey(input.workId, input.projectRoot, input.recoveryId), workStartMatchKey(shortWorkReference(input.workId), input.projectRoot, input.recoveryId)]);
     const event = context.db.get("SELECT id, session_id, agent_id, turn_id, transcript_path, model, agent_type, match_key, status FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
     if (!event?.session_id || event.status !== "observed" || !event.match_key || !expected.has(event.match_key)) {
         throw new AppError("trusted_work_launch_required", "work start requires one fresh matching PreToolUse event", 1, { work_id: input.workId, event_key: input.eventKey });
@@ -958,7 +976,9 @@ export function assertStageStartHookEvent(context, input) {
     if (!event?.session_id || event.status !== "observed" || event.match_key !== expected) {
         throw new AppError("trusted_stage_launch_required", "stage start requires one fresh matching PreToolUse event", 1, { run_id: input.runId, stage: input.stage, event_key: input.eventKey, expected_match_key: expected, observed_match_key: event?.match_key ?? null, observed_status: event?.status ?? null });
     }
-    return hookSessionIdentity(context, input.projectId, input.eventKey);
+    const identity = hookSessionIdentity(context, input.projectId, input.eventKey);
+    assertRecoveryHookCurrent(context, input.projectId, input.runId, identity);
+    return identity;
 }
 export function claimStageStartHookEvent(context, input) {
     assertStageStartHookEvent(context, input);
@@ -996,16 +1016,19 @@ export function claimStageResumeHookEvent(context, input) {
     if (!event?.event_key || !event.session_id || event.match_key !== matchKey || event.status !== "observed") {
         throw new AppError("trusted_stage_resume_required", "stage resume requires one fresh matching PreToolUse event", 1, { run_id: input.runId, stage: input.stage, work_id: input.workId });
     }
+    const identity = hookSessionIdentity(context, input.projectId, event.event_key);
+    assertRecoveryHookCurrent(context, input.projectId, input.runId, identity);
     const claimed = context.db.run("UPDATE hook_events SET status = 'claimed', claimed_at = ? WHERE id = ? AND status = 'observed'", [context.now(), event.id]);
     if (claimed.changes !== 1)
         throw new AppError("trusted_stage_resume_required", "matching stage-resume hook event was already claimed", 1, { run_id: input.runId, stage: input.stage });
-    return hookSessionIdentity(context, input.projectId, event.event_key);
+    return identity;
 }
-export function workStartMatchKey(workId, projectRoot) {
+export function workStartMatchKey(workId, projectRoot, recoveryId) {
     return crypto.createHash("sha256").update(JSON.stringify({
         operation: "work_start",
         work_id: workId,
-        project_root: resolveProjectRoot(projectRoot)
+        project_root: resolveProjectRoot(projectRoot),
+        ...(recoveryId ? { recovery_id: recoveryId } : {})
     })).digest("hex");
 }
 export function hookStatusForProject(context, projectId) {
@@ -1389,12 +1412,11 @@ function sessionBinding(context, projectId, sessionId) {
     return context.db.get("SELECT * FROM codex_session_bindings WHERE project_id = ? AND session_id = ?", [projectId, sessionId]);
 }
 function recordHookEvent(context, input) {
-    const existing = context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
-    if (existing)
+    if (assertHookEventReplay(context, input))
         return false;
     context.db.run(`INSERT INTO hook_events
-      (project_id, protocol_id, harness, provider_session_id, parent_session_id, daemon_id, session_id, agent_id, turn_id, transcript_path, provider, model, reasoning, mode, agent_type, cwd, event_key, match_key, event_name, tool_name, status, sanitized_summary, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        (project_id, protocol_id, harness, provider_session_id, parent_session_id, daemon_id, session_id, agent_id, turn_id, transcript_path, provider, model, reasoning, mode, agent_type, cwd, event_key, match_key, event_name, tool_name, status, sanitized_summary, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         input.projectId,
         input.protocolId,
         input.harness,
@@ -1421,6 +1443,23 @@ function recordHookEvent(context, input) {
     ]);
     return true;
 }
+/** A duplicate delivery is harmless only when all durable identity facts match. */
+function assertHookEventReplay(context, input) {
+    const existing = context.db.get(`SELECT harness, provider_session_id, parent_session_id, daemon_id, session_id, turn_id, event_name, tool_name, match_key, cwd
+       FROM hook_events WHERE project_id = ? AND event_key = ?`, [input.projectId, input.eventKey]);
+    if (existing) {
+        const observed = {
+            harness: input.harness, provider_session_id: input.providerSessionId, parent_session_id: input.parentSessionId,
+            daemon_id: input.daemonId ?? null, session_id: input.sessionId, turn_id: input.turnId,
+            event_name: input.eventName, tool_name: input.toolName, match_key: input.matchKey, cwd: input.cwd
+        };
+        if (Object.entries(observed).some(([key, value]) => existing[key] !== value)) {
+            throw new AppError("hook_event_replay_mismatch", "Lifecycle event ID was already observed with different immutable identity", 1, { event_key: input.eventKey });
+        }
+        return true;
+    }
+    return false;
+}
 function projectForHook(context, explicitRoot, cwd) {
     if (explicitRoot)
         return requireProjectByRoot(context, resolveProjectRoot(explicitRoot));

package/dist/services/lifecycle-command.js

@@ -138,7 +138,7 @@ function invocationFromSegment(segment, heredoc, wrapped, inheritedEnv) {
         executable,
         argv,
         env,
-        args: parseCommandArgs(argv.slice(2)),
+        args: parseCommandArgs(argv.slice(operation === "recovery_accept" ? 3 : 2)),
         command: quote(segment.words),
         rewriteSafe: !heredoc && !wrapped && !segment.dynamic,
         wrapped,
@@ -170,6 +170,8 @@ function wrappedInvocationFromSegment(segment) {
     return parseLifecycleCommandInner(payload, true);
 }
 function lifecycleOperation(argv) {
+    if (argv[0] === "run" && argv[1] === "recovery" && argv[2] === "accept")
+        return "recovery_accept";
     const key = `${argv[0] ?? ""} ${argv[1] ?? ""}`;
     if (key === "session register")
         return "session_register";

package/dist/services/merge-server.js

@@ -6,6 +6,7 @@ import { flowCommand } from "./stage-pause.js";
 import { validateSchema } from "./schema-validation.js";
 import { adapterSessionId, runHarnessAdapter } from "./harness-adapter.js";
 import { harnessRuntimeArguments, resolveHarnessCommand } from "./harness-config.js";
+import { assertRunMutationAllowed, recoveryGuard } from "./run-recovery.js";
 /** A deterministic dispatcher; only the launched harness Session performs agent work. */
 export async function serveMergeRequests(context, input) {
     const running = context.db.get("SELECT server_id, pid FROM merge_servers WHERE status IN ('running','stopping') ORDER BY started_at LIMIT 1");
@@ -59,12 +60,23 @@ export function mergeServerStatus(context) { return { ok: true, servers: context
 export function stopMergeServer(context, input) { const changed = context.db.run("UPDATE merge_servers SET status = 'stopping', heartbeat_at = ? WHERE server_id = ? AND status = 'running'", [context.now(), input.serverId]); if (changed.changes !== 1)
     throw new AppError("not_found", "Running merge-server was not found", 1, { server_id: input.serverId }); return { ok: true, server_id: input.serverId, status: "stopping" }; }
 async function dispatch(context, input) {
+    let generation;
+    context.db.exec("BEGIN IMMEDIATE");
     const token = crypto.randomUUID();
     const leaseUntil = new Date(Date.now() + 120_000).toISOString();
-    const claimed = context.db.run("UPDATE merge_requests SET status = 'dispatching', dispatch_owner = ?, dispatch_lease_token = ?, dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status = 'queued' AND execution_route = 'server'", [input.serverId, token, leaseUntil, context.now(), input.request.merge_request_id]);
-    if (claimed.changes !== 1)
-        return;
-    const leaseHeartbeat = setInterval(() => { const now = context.now(); context.db.run("UPDATE merge_requests SET dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status = 'dispatching' AND dispatch_owner = ? AND dispatch_lease_token = ?", [new Date(Date.now() + 120_000).toISOString(), now, input.request.merge_request_id, input.serverId, token]); }, 30_000);
+    try {
+        generation = assertRunMutationAllowed(context, input.request.project_id, input.request.run_id);
+        const claimed = context.db.run("UPDATE merge_requests SET status = 'dispatching', dispatch_owner = ?, dispatch_lease_token = ?, dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status = 'queued' AND execution_route = 'server'", [input.serverId, token, leaseUntil, context.now(), input.request.merge_request_id]);
+        context.db.exec("COMMIT");
+        if (claimed.changes !== 1)
+            return;
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+    const leaseHeartbeat = setInterval(() => { if (guarded(context, input.request) || (recoveryGuard(context, input.request.project_id, input.request.run_id)?.generation ?? 0) !== generation)
+        return; const now = context.now(); context.db.run("UPDATE merge_requests SET dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status = 'dispatching' AND dispatch_owner = ? AND dispatch_lease_token = ?", [new Date(Date.now() + 120_000).toISOString(), now, input.request.merge_request_id, input.serverId, token]); }, 30_000);
     leaseHeartbeat.unref();
     const stateDir = path.join(input.root, input.request.merge_request_id);
     fs.mkdirSync(stateDir, { recursive: true });
@@ -77,13 +89,14 @@ async function dispatch(context, input) {
     const executable = resolveHarnessCommand(context.ddFlowHome, input.profile.harness, "adapter");
     const common = ["--state-dir", stateDir, "--journal", adapterJournal, "--cwd", input.request.target_workspace, "--provider", input.profile.provider, "--model", input.profile.model, "--reasoning", input.profile.reasoning, "--mode", input.profile.mode, "--permission", input.profile.permission, "--project-root", input.request.target_workspace, "--dd-flow-home", context.ddFlowHome, ...harnessRuntimeArguments(context.ddFlowHome, input.profile.harness), "--json"];
     try {
-        const adapterCall = (args, timeoutMs, progressMessage) => runHarnessAdapter({ executable, args, env: context.env, ...(timeoutMs ? { timeoutMs } : {}), ...(input.progress ? { progress: input.progress } : {}), ...(progressMessage ? { progressMessage } : {}), onEvidence: (value) => event(input.journal, { type: "adapter_call", ...value }) });
+        const adapterCall = (args, timeoutMs, progressMessage) => { assertRunMutationAllowed(context, input.request.project_id, input.request.run_id, generation); return runHarnessAdapter({ executable, args, env: context.env, ...(timeoutMs ? { timeoutMs } : {}), ...(input.progress ? { progress: input.progress } : {}), ...(progressMessage ? { progressMessage } : {}), onEvidence: (value) => event(input.journal, { type: "adapter_call", ...value }) }); };
         await adapterCall(["daemon", "start", ...common]);
         const created = await adapterCall(["session", "create", ...common]);
         const sessionId = adapterSessionId(created);
         if (!sessionId)
             throw new AppError("merge_adapter_invalid", "Harness adapter did not return a Session id", 1, { harness: input.profile.harness, response: created });
         const prompted = await adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60 * 1000, `MERGE ${input.request.merge_request_id} Session ${sessionId} is still running`);
+        assertRunMutationAllowed(context, input.request.project_id, input.request.run_id, generation);
         const request = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id]);
         context.db.run("UPDATE merge_requests SET adapter_receipt_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ profile: input.profile, executable, session_id: sessionId, response: prompted }), context.now(), input.request.merge_request_id]);
         event(input.journal, { type: "adapter_settled", request_id: input.request.merge_request_id, session_id: sessionId, request_status: request?.status ?? null, at: context.now() });
@@ -91,6 +104,10 @@ async function dispatch(context, input) {
             context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "adapter_did_not_start_stage", response: prompted }), context.now(), input.request.merge_request_id]);
     }
     catch (error) {
+        if (error instanceof AppError && ["run_recovery_guarded", "run_recovery_generation_stale"].includes(error.code)) {
+            event(input.journal, { type: "recovery_dispatch_blocked", request_id: input.request.merge_request_id, code: error.code, at: context.now() });
+            throw error;
+        }
         const request = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id]);
         if (request?.status === "dispatching")
             context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "adapter_launch_failed", error: String(error) }), context.now(), input.request.merge_request_id]);
@@ -102,9 +119,11 @@ async function dispatch(context, input) {
         clearInterval(leaseHeartbeat);
     }
 }
-function nextServerRequests(context, limit) { const selected = new Set(); return context.db.all("SELECT merge_request_id, project_id, run_id, executor_work_id, target_workspace, execution_route, status, created_at FROM merge_requests WHERE status = 'queued' AND execution_route = 'server' ORDER BY created_at, merge_request_id").filter((request) => { if (selected.has(request.project_id) || context.db.get("SELECT 1 FROM merge_requests WHERE project_id = ? AND status NOT IN ('completed','failed','cancelled','superseded') AND (created_at < ? OR (created_at = ? AND merge_request_id < ?)) LIMIT 1", [request.project_id, request.created_at, request.created_at, request.merge_request_id]))
+function nextServerRequests(context, limit) { const selected = new Set(); return context.db.all("SELECT merge_request_id, project_id, run_id, executor_work_id, target_workspace, execution_route, status, created_at FROM merge_requests WHERE status = 'queued' AND execution_route = 'server' ORDER BY created_at, merge_request_id").filter((request) => { if (guarded(context, request) || selected.has(request.project_id) || context.db.get("SELECT 1 FROM merge_requests WHERE project_id = ? AND status NOT IN ('completed','failed','cancelled','superseded') AND (created_at < ? OR (created_at = ? AND merge_request_id < ?)) LIMIT 1", [request.project_id, request.created_at, request.created_at, request.merge_request_id]))
     return false; selected.add(request.project_id); return true; }).slice(0, limit); }
-function reconcileExpiredDispatches(context) { const expired = context.db.all("SELECT merge_request_id, executor_work_id FROM merge_requests WHERE status = 'dispatching' AND dispatch_lease_expires_at < ?", [context.now()]); for (const request of expired) {
+function reconcileExpiredDispatches(context) { const expired = context.db.all("SELECT merge_request_id, executor_work_id, project_id, run_id FROM merge_requests WHERE status = 'dispatching' AND dispatch_lease_expires_at < ?", [context.now()]); for (const request of expired) {
+    if (guarded(context, request))
+        continue;
     const work = context.db.get("SELECT status FROM works WHERE work_id = ?", [request.executor_work_id]);
     if (work?.status === "created")
         context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "expired_dispatch_requeued" }), context.now(), request.merge_request_id]);
@@ -119,6 +138,7 @@ catch (error) {
 } validateSchema({ schemaName: "agent-profile", file }); if (value.id !== id)
     throw new AppError("agent_profile_invalid", "Agent profile id does not match its requested filename", 2, { file, expected: id, actual: value.id ?? null }); return value; }
 function event(file, value) { fs.appendFileSync(file, `${JSON.stringify(value)}\n`); }
+function guarded(context, request) { const guard = recoveryGuard(context, request.project_id, request.run_id); return Boolean(guard && ["draining", "sealed", "resuming"].includes(guard.status)); }
 function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
 function processAlive(pid) { if (!pid)
     return false; try {