@deksden-com/dd-flow-cli 0.9.0-beta.121 → 0.9.0-beta.123

package/dist/services/lifecycle-invocations.js

@@ -777,7 +777,8 @@ export function issueLifecycleInvocation(context, command, scope) {
 }
 function commandWithInvocationId(command, id) {
     const at = shellSuffixOffset(command);
-    return `${command.slice(0, at).trimEnd()} --invocation-id ${id} ${command.slice(at)}`.trimEnd();
+    const suffix = command.slice(at);
+    return `${command.slice(0, at)} --invocation-id ${id}${suffix ? /^\s/.test(suffix) ? suffix : ` ${suffix}` : ""}`;
 }
 /** The attempt owns authority; the caller owns presentation-only shell input.
  * Preserve current stdin/heredoc/response-file text while validating that it
@@ -909,11 +910,7 @@ export function observeLifecycleInvocation(context, input) {
     storage(context);
     const supplied = input.id ? context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [input.id]) : undefined;
     const analysis = parseLifecycleCommand(input.command);
-    if (analysis.kind !== "standalone" || analysis.invocation.wrapped) {
-        if (analysis.kind !== "none" && ["grok-acp", "antigravity-cli"].includes(input.harness ?? "") && input.projectId
-            && managedNativeOwner(context, input.identity, input.harness, input.projectId)) {
-            throw new AppError("invocation_command_invalid", "Managed native lifecycle call must be one direct standalone command", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
-        }
+    if (analysis.kind === "none" || analysis.supported === false) {
         const eventKey = input.recordReceipt();
         if (analysis.kind !== "none") {
             const retained = context.db.get("SELECT outcome_json FROM hook_events WHERE event_key = ?", [eventKey]);
@@ -928,22 +925,32 @@ export function observeLifecycleInvocation(context, input) {
                     ...outcome,
                     lifecycle_observation: {
                         code: "lifecycle_shell_syntax_invalid",
-                        reason: analysis.kind === "compound" ? analysis.reason : "wrapped_lifecycle_command",
+                        reason: analysis.kind === "compound" ? analysis.reason : "unsupported_lifecycle_command",
                         command_fingerprint: fingerprint(analysis.invocation),
                         effect: "no_effect",
                         recoverable: true
                     }
                 }), eventKey]);
         }
+        if (analysis.kind !== "none")
+            throw new AppError("lifecycle_shell_syntax_invalid", "This shell form cannot bind exactly one lifecycle execution; use the exact issued lifecycle command without the unsupported shell context", 1, { phase: "prepare", effect: "no_effect", recoverable: true, disposition: "pre_cli_shell_refusal", reason: analysis.kind === "compound" ? analysis.reason : "unsupported_lifecycle_command", event_key: eventKey });
         return { eventKey, duplicate: false, invocationId: null };
     }
-    const candidates = context.db.all("SELECT * FROM lifecycle_invocations WHERE status IN ('issued','observed') ORDER BY rowid DESC")
+    // Admit the one parsed leaf, never execute or fingerprint the prefix/suffix.
+    const leafCommand = analysis.invocation.command;
+    if (input.executionCwd !== undefined && !path.isAbsolute(input.executionCwd))
+        throw new AppError("invocation_directory_mismatch", "Bound lifecycle execution cwd must be absolute", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+    const deliveredIdentity = JSON.stringify([input.identity.daemonId, input.identity.rootSessionId, input.identity.sessionId, input.identity.parentSessionId, input.identity.toolCallId,
+        ...(input.executionCwd === undefined ? [] : [{ executionCwd: canonicalPath(input.executionCwd) }])]);
+    const candidates = context.db.all("SELECT * FROM lifecycle_invocations WHERE status IN ('issued','observed','executing','settled') ORDER BY rowid DESC")
         .filter(row => {
+        if (["executing", "settled"].includes(row.status) && row.identity_json !== deliveredIdentity)
+            return false;
         const scope = JSON.parse(row.scope_json);
         if (scope.daemonId !== input.identity.daemonId || scope.rootSessionId !== input.identity.rootSessionId)
             return false;
         try {
-            return fingerprint(invocation(canonicalManagedCommand(context, input.command, scope))) === row.fingerprint;
+            return fingerprint(invocation(canonicalManagedCommand(context, leafCommand, scope))) === row.fingerprint;
         }
         catch {
             return false;
@@ -979,7 +986,7 @@ export function observeLifecycleInvocation(context, input) {
     const project = requireProjectByRoot(context, scope.projectRoot);
     const identity = input.identity;
     checkNativeIdentity(scope, identity, initial.id);
-    const identityJson = JSON.stringify([identity.daemonId, identity.rootSessionId, identity.sessionId, identity.parentSessionId, identity.toolCallId]);
+    const identityJson = deliveredIdentity;
     return context.db.writeTransaction(() => {
         const row = context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [initial.id]);
         if (row.status === "settled")
@@ -992,6 +999,9 @@ export function observeLifecycleInvocation(context, input) {
         if (row.identity_json === identityJson) {
             return { eventKey: row.event_key, duplicate: true, ...resolved };
         }
+        if (row.identity_json && JSON.stringify(JSON.parse(row.identity_json).slice(0, 5)) === JSON.stringify(JSON.parse(identityJson).slice(0, 5))) {
+            throw new AppError("invocation_identity_mismatch", "The same native tool call changed its bound execution route", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+        }
         const eventKey = input.recordReceipt({ projectRoot: scope.projectRoot, runId: scope.runId, command: initial.command });
         // A native hook may execute from a provider worktree while the issued
         // lifecycle scope is anchored to the stable project root. Project
@@ -1019,7 +1029,7 @@ export function observedLifecycleNativeEvent(context, command, daemonId) {
         return null;
     const signature = (value) => {
         const parsed = parseLifecycleCommand(value);
-        const candidate = parsed.kind === "standalone" && !parsed.invocation.wrapped ? parsed.invocation : continuationCommand(value);
+        const candidate = parsed.kind !== "none" && parsed.supported ? parsed.invocation : continuationCommand(value);
         if (!candidate)
             return null;
         return JSON.stringify([candidate.operation, candidate.args.positional,
@@ -1080,8 +1090,9 @@ export function observedLifecycleInvocation(context, command, daemonId) {
     if (!context.db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'lifecycle_invocations'"))
         return null;
     const analysis = parseLifecycleCommand(command);
-    if (analysis.kind !== "standalone" || analysis.invocation.wrapped)
+    if (analysis.kind === "none" || analysis.supported === false)
         return null;
+    const leafCommand = analysis.invocation.command;
     // `issued` is a rendezvous, not authority: the CLI still blocks in
     // awaitLifecycleInvocation until the native observer commits the receipt.
     const matches = context.db.all("SELECT * FROM lifecycle_invocations WHERE status IN ('issued','observed','executing') ORDER BY rowid DESC")
@@ -1090,7 +1101,7 @@ export function observedLifecycleInvocation(context, command, daemonId) {
             const scope = JSON.parse(row.scope_json);
             if (daemonId && scope.daemonId !== daemonId)
                 return false;
-            return fingerprint(invocation(canonicalManagedCommand(context, command, scope))) === row.fingerprint;
+            return fingerprint(invocation(canonicalManagedCommand(context, leafCommand, scope))) === row.fingerprint;
         }
         catch {
             return false;
@@ -1348,6 +1359,16 @@ export async function awaitLifecycleInvocation(context, input) {
         }
         input.assertCurrent(JSON.parse(row.scope_json));
         if (row.status === "observed") {
+            if (row.identity_json) {
+                // Receipt display text is bounded/redacted and may not be valid JSON.
+                // Only the native admission's typed identity binds an execution route.
+                const identity = JSON.parse(row.identity_json);
+                const route = identity[5]?.executionCwd;
+                if (identity.length > 5 && (typeof route !== "string" || !path.isAbsolute(route)))
+                    throw new AppError("invocation_directory_mismatch", "Bound lifecycle execution cwd is invalid", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+                if (typeof route === "string" && canonicalPath(process.cwd()) !== canonicalPath(route))
+                    throw new AppError("invocation_directory_mismatch", "Reached CLI cwd differs from the bound shell execution route", 1, { phase: "prepare", effect: "no_effect", recoverable: false, expected: route, actual: process.cwd(), actual_provenance: "cli_process_cwd" });
+            }
             const claimed = context.db.run("UPDATE lifecycle_invocations SET status = 'executing', updated_at = ? WHERE id = ? AND status = 'observed'", [context.now(), input.id]);
             if (claimed.changes === 1)
                 return { eventKey: row.event_key, replay: false };

package/dist/services/merge-server.js

@@ -109,7 +109,7 @@ async function dispatch(context, input) {
     const retain = () => { context.db.run("UPDATE merge_requests SET adapter_receipt_json = ?, updated_at = ? WHERE merge_request_id = ? AND dispatch_owner = ? AND dispatch_lease_token = ?", [JSON.stringify(retained), context.now(), input.request.merge_request_id, input.serverId, token]); };
     retain();
     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);
+        return; const now = context.now(); context.db.run("UPDATE merge_requests SET dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status IN ('dispatching','active') 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();
     try {
         const adapterCall = (args, timeoutMs, progressMessage, id = `${input.request.merge_request_id}:${token}:${args[0]}.${args[1]}`) => { assertRunMutationAllowed(context, input.request.project_id, input.request.run_id, generation); return runHarnessAdapter({ executable, args, env: runtimeContext.env, runtimeOwner, operationId: id, ...(timeoutMs ? { timeoutMs } : {}), ...(input.progress ? { progress: input.progress } : {}), ...(progressMessage ? { progressMessage } : {}), onEvidence: (value) => event(input.journal, { type: "adapter_call", ...value }) }); };
@@ -124,29 +124,46 @@ async function dispatch(context, input) {
         const stageCommand = managedLifecycleCommand(runtimeContext, `${flowCommand(runtimeContext)} stage start ${input.request.run_id} --stage merge --project-root ${JSON.stringify(run.project_root)} --json --progress-jsonl`);
         fs.writeFileSync(promptFile, `Start the assigned MERGE stage now. Your first tool call must be this exact standalone command:\n\n${stageCommand}\n\nTrust and follow the complete stage packet it returns. Continue through merge apply and stage finish. Stop only when the stage reaches a terminal result or explicitly requests user/operator action.\n\n${stageLifecycleInstruction}\n`);
         let prompted;
+        const promptDeadline = Date.now() + 45 * 60_000;
         try {
             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`);
         }
         catch (error) {
             if (runtimeHarness(input.profile) !== "codex-desktop")
                 throw error;
-            const resumed = await continueCodexCapacity({ error, sessionId, operationId: String(retained.prompt_operation_id),
+            const capacityIntents = (retained.capacity_intents ?? []);
+            const resumed = await continueCodexCapacity({ error, sessionId, operationId: String(retained.prompt_operation_id), allowSettledDescendants: true,
+                deadline: promptDeadline,
+                continuationText: `Continue only MERGE ${input.request.merge_request_id}, Work ${input.request.executor_work_id}, RUN ${input.request.run_id} in this same Session and target ${input.request.target_workspace}. First inspect current durable Stage/Work/MERGE receipts. Never repeat Stage start, accepted answer, completed apply or checks. Follow only the current exact issued successor and stop at the original boundary.`,
+                retainedIntents: () => capacityIntents,
                 inspectOperation: id => adapterCall(["daemon", "operation", "--state-dir", stateDir, "--operation-id", id, "--json"], 30_000, undefined, `${id}:capacity-observe`),
-                inspectSession: () => adapterCall(["session", "inspect", "--session-id", sessionId, ...common], 30_000, undefined, `${input.request.merge_request_id}:${token}:capacity-inspect`),
+                inspectSession: turnId => adapterCall(["session", "inspect", "--session-id", sessionId, ...(turnId ? ["--turn-id", turnId] : []), ...common], 30_000, undefined, `${input.request.merge_request_id}:${token}:capacity-inspect`),
                 assertCurrent: () => {
                     assertRunMutationAllowed(context, input.request.project_id, input.request.run_id, generation);
                     const current = context.db.get("SELECT status, dispatch_owner, dispatch_lease_token, dispatch_lease_expires_at, target_workspace FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id]);
-                    if (current?.status !== "dispatching" || current.dispatch_owner !== input.serverId || current.dispatch_lease_token !== token
+                    if (current?.status === "completed" || current?.status === "action_required")
+                        return;
+                    if (!current || !["dispatching", "active"].includes(current.status) || current.dispatch_owner !== input.serverId || current.dispatch_lease_token !== token
                         || current.dispatch_lease_expires_at <= context.now() || current.target_workspace !== input.request.target_workspace)
                         throw new AppError("capacity_continuation_blocked", "MERGE dispatch owner or target changed during capacity wait", 1, { request_id: input.request.merge_request_id });
-                    if (context.db.get("SELECT status FROM works WHERE work_id = ?", [input.request.executor_work_id])?.status !== "created")
-                        throw new AppError("capacity_continuation_blocked", "MERGE Work already changed state", 1);
+                    if (!["created", "running", "paused", "completed"].includes(context.db.get("SELECT status FROM works WHERE work_id = ?", [input.request.executor_work_id])?.status ?? ""))
+                        throw new AppError("capacity_continuation_blocked", "MERGE Work has failed or lost its binding", 1);
                 },
-                retainIntent: intent => { retained.capacity_intent = intent; retain(); },
+                decision: () => {
+                    const status = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id])?.status;
+                    const workStatus = context.db.get("SELECT status FROM works WHERE work_id = ?", [input.request.executor_work_id])?.status;
+                    return status === "completed" ? "completed" : status === "action_required" || workStatus === "paused" ? "paused" : "continue";
+                },
+                retainIntent: intent => { capacityIntents.push(intent); retained.capacity_intents = capacityIntents; retained.capacity_intent = intent; retain(); },
                 prompt: (id, text, ordinal) => {
                     const file = path.join(stateDir, `capacity-${ordinal}.md`);
-                    fs.writeFileSync(file, `${text}\n`, { flag: "wx", mode: 0o600 });
-                    return adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], 45 * 60 * 1000, `MERGE ${input.request.merge_request_id} Session ${sessionId} capacity continuation ${ordinal}/2`, id);
+                    if (fs.existsSync(file)) {
+                        if (fs.readFileSync(file, "utf8") !== text)
+                            throw new AppError("capacity_continuation_conflict", "Retained MERGE continuation prompt differs", 1);
+                    }
+                    else
+                        fs.writeFileSync(file, text, { flag: "wx", mode: 0o600 });
+                    return adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], Math.max(1, promptDeadline - Date.now()), `MERGE ${input.request.merge_request_id} Session ${sessionId} capacity continuation ${ordinal}/2`, id);
                 } });
             if (!resumed)
                 throw error;

package/dist/services/review-copy.js

@@ -5,6 +5,27 @@ import { spawnSync } from "node:child_process";
 import { AppError } from "../shared/errors.js";
 import { ignoredWorkspacePaths } from "./code-checks.js";
 import { localEnvironmentAllowed, ownedWorkspaceHookPath, projectServicePathFilter, workspaceGitFiles } from "./workspace-files.js";
+export function reviewerSourceInputs(root, aspectIds) {
+    const criteria = [...new Set(aspectIds)].sort().map(id => {
+        if (!/^[a-z][a-z0-9_-]*$/.test(id))
+            throw new AppError("review_criterion_invalid", "Assigned aspect has an invalid identity", 1, { aspect_id: id });
+        return `.memory-bank/dd-flow/mb-sdlc/plan-aspects/aspects/${id}.md`;
+    });
+    const orientation = [".memory-bank/index.md", ".memory-bank/spec/engineering/index.md", ".memory-bank/spec/engineering/coding-standards.md"].filter(relative => fs.existsSync(path.join(root, relative)));
+    return [...criteria, ...orientation].map(relative => {
+        const file = path.join(root, relative);
+        if (!fs.existsSync(file))
+            throw new AppError("review_criterion_missing", "Assigned reviewer criterion is missing", 1, { path: relative });
+        const inside = path.relative(fs.realpathSync(root), fs.realpathSync(file));
+        if (inside === ".." || inside.startsWith(`..${path.sep}`) || !fs.statSync(file).isFile())
+            throw new AppError("review_criterion_invalid", "Reviewer source must be a file in its workspace", 1, { path: relative });
+        return { path: relative, sha256: crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") };
+    });
+}
+export function reviewerSourceInstruction(root, aspectIds) {
+    const inputs = reviewerSourceInputs(root, aspectIds);
+    return ["Read the assigned canonical criterion files and the available project orientation below before independent review. Apply each criterion's scope; a small behavior change is not by itself a reason to omit testing or evidence. These starting inputs do not limit relevant project investigation. Do not edit them.", ...inputs.map(input => `- ${path.join(root, input.path)} (SHA256 ${input.sha256})`)].join("\n");
+}
 export function reviewEnvironmentAllowed(file) {
     return localEnvironmentAllowed(file);
 }

package/dist/services/run-controller-adapter.js

@@ -34,6 +34,8 @@ export function controllerHitlAdmission(context, record, input) {
         }
         if (retained.capacity_intent?.predecessor !== predecessorId || retained.capacity_intent.operation_id !== input.operationId || retained.capacity_intent.ordinal !== ordinal)
             return false;
+        if (!retained.capacity_intent.not_before || !Number.isFinite(Date.parse(retained.capacity_intent.not_before)) || Date.parse(retained.capacity_intent.not_before) > Date.parse(context.now()) || retained.capacity_intent.prompt_sha256 !== input.promptSha256)
+            return false;
     }
     const state = JSON.parse(row.state_json);
     const session = state.current_session === null ? undefined : state.sessions[state.current_session];
@@ -208,8 +210,18 @@ export async function controllerAdapter(context, row, manifest, session, args, a
     const promptSha256 = promptFile >= 0 ? digestBytes(fs.readFileSync(args[promptFile + 1])) : inlinePrompt >= 0 ? digestBytes(args[inlinePrompt + 1] ?? "") : undefined;
     const input = { executable, args, owner: session.owner.owner_id, state_dir: session.state_dir, ...(args[0] === "session" && args[1] === "prompt" && promptSha256 ? { prompt_sha256: promptSha256 } : {}) };
     const now = context.now();
-    context.db.run("INSERT INTO run_controller_operations (operation_id, controller_id, generation, input_hash, input_json, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'dispatching', ?, ?)", [operationId, row.controller_id, row.generation, digest(input), JSON.stringify(input), now, now]);
-    appendEvent(context, row.controller_id, "operation_requested", { operation_id: operationId, operation: args.slice(0, 2), session_id: session.id || null });
+    const existing = context.db.get("SELECT input_hash,status,receipt_json,error_json FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND generation = ?", [operationId, row.controller_id, row.generation]);
+    if (existing?.input_hash && existing.input_hash !== digest(input))
+        throw new AppError("controller_operation_conflict", "Retained operation has different dispatch parameters", 1, { operation_id: operationId });
+    if (existing?.status === "completed" && existing.receipt_json) {
+        const receipt = JSON.parse(existing.receipt_json);
+        validateReceipt(receipt, session, args);
+        return receipt;
+    }
+    if (!existing) {
+        context.db.run("INSERT INTO run_controller_operations (operation_id, controller_id, generation, input_hash, input_json, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'dispatching', ?, ?)", [operationId, row.controller_id, row.generation, digest(input), JSON.stringify(input), now, now]);
+        appendEvent(context, row.controller_id, "operation_requested", { operation_id: operationId, operation: args.slice(0, 2), session_id: session.id || null });
+    }
     try {
         assertOwner?.();
         let receipt;
@@ -217,7 +229,17 @@ export async function controllerAdapter(context, row, manifest, session, args, a
         try {
             const timeoutMs = args[0] === "session" && args[1] === "prompt" ? null
                 : args[0] === "session" && args[1] === "create" && runtimeHarness(session.profile) === "zcode-acp" ? 180_000 : 120_000;
-            receipt = await runHarnessAdapter({ executable, args, env: controllerEnvironment(context, manifest, session), operationId, runtimeOwner: session.owner, timeoutMs, ...(signal ? { signal } : {}) });
+            if (existing) {
+                const observed = await recoverCompletedOperation(context, manifest, session, executable, args, operationId, signal);
+                if (!observed) {
+                    const cause = existing.error_json ? JSON.parse(existing.error_json) : { code: "controller_operation_outcome_unknown", message: "Retained dispatch has no observed terminal result", details: { operation_id: operationId } };
+                    throw new AppError(cause.code, cause.message, 1, cause.details);
+                }
+                receipt = observed;
+                recoveredOperation = true;
+            }
+            else
+                receipt = await runHarnessAdapter({ executable, args, env: controllerEnvironment(context, manifest, session), operationId, runtimeOwner: session.owner, timeoutMs, ...(signal ? { signal } : {}) });
         }
         catch (error) {
             const retained = await recoverCompletedOperation(context, manifest, session, executable, args, operationId, signal);

package/dist/services/run-controller-recovery.js

@@ -213,15 +213,21 @@ export async function resumeControllerSession(context, row, manifest, state, ass
     catch (error) {
         if (runtimeHarness(session.profile) !== "codex-desktop")
             throw error;
-        const continuationText = `The preceding native recovery ACK Turn failed before any observed tool or file effect. This is the same retained Session and recovery generation. First inspect the current RUN recovery state; only if the exact ACK still awaits acceptance, execute the exact standalone acceptance command below once. Never deliver it again after acceptance. Then stop at the original Stage or Work-graph boundary.\n\n${dispatch.prompt}`;
+        const continuationText = `Continue the same retained Session and recovery generation. First inspect the current RUN recovery state; only if the exact ACK still awaits acceptance, execute the exact standalone acceptance command below once. Never deliver it again after acceptance. Then stop at the original Stage or Work-graph boundary.\n\n${dispatch.prompt}`;
         const inspect = (args, operationId) => runHarnessAdapter({ executable: manifest.adapters["codex-desktop"].executable,
             args, env: controllerEnvironment(executionContext, manifest, session), runtimeOwner: session.owner, operationId, timeoutMs: 30_000 });
         const resumed = await continueCodexCapacity({ error, sessionId: session.id, operationId: dispatch.operation_id, allowSettledDescendants: true, continuationText,
+            retainedIntents: () => {
+                const binding = context.db.get("SELECT runtime_dispatch_json FROM run_recovery_bindings WHERE recovery_id = ?", [recovery.recovery_id]);
+                return binding?.runtime_dispatch_json ? JSON.parse(binding.runtime_dispatch_json).capacity_intents ?? [] : [];
+            },
             inspectOperation: id => inspect(["daemon", "operation", "--state-dir", session.state_dir, "--operation-id", id, "--json"], `${id}:capacity-observe`),
-            inspectSession: () => inspect(["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], `${dispatch.operation_id}:capacity-inspect`),
+            inspectSession: turnId => inspect(["session", "inspect", "--session-id", session.id, ...(turnId ? ["--turn-id", turnId] : []), ...sessionArguments(context, manifest, session)], `${dispatch.operation_id}:capacity-inspect`),
             assertCurrent: () => {
                 assertRecoveryOwner();
                 const guard = recoveryGuard(context, row.project_id, row.run_id);
+                if (guard?.status === "recovered")
+                    return;
                 const binding = context.db.get("SELECT status, daemon_id FROM run_recovery_bindings WHERE recovery_id = ?", [recovery.recovery_id]);
                 const ack = context.db.get("SELECT status FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND generation = ?", [recovery.operation_id, row.controller_id, row.generation]);
                 if (guard?.status !== "resuming" || binding?.status !== "prepared" || binding.daemon_id !== daemonId || ack?.status !== "accepted")
@@ -232,6 +238,7 @@ export async function resumeControllerSession(context, row, manifest, state, ass
                     || current.process.lease_expires_at <= context.now() || metadata.run_generation !== row.generation || !processIsAlive(current.process))
                     throw new AppError("recovery_capacity_owner_changed", "Replacement native owner changed during capacity wait", 1);
             },
+            decision: () => recoveryGuard(context, row.project_id, row.run_id)?.status === "recovered" ? "completed" : "continue",
             retainIntent: intent => retainRecoveryCapacityIntent(executionContext, { projectId: row.project_id, runId: row.run_id, recoveryId: recovery.recovery_id,
                 controllerId: row.controller_id, generation: row.generation, daemonId, intent, prompt: continuationText }),
             prompt: (operationId, prompt) => sendAck(operationId, prompt) });

package/dist/services/run-controller.js

@@ -30,7 +30,7 @@ import { requireRun, requireController, controllerReceipt, appendEvent, saveStat
 import { assertNoCorrelatedRejection } from "./continuation-outcome.js";
 import { spawnController, recordControllerLauncher, claimControllerProcess, markControllerDispatchReady } from "./run-controller-process.js";
 import { controllerAdapter, controllerEnvironment, sessionArguments } from "./run-controller-adapter.js";
-import { continueCodexCapacity } from "./codex-capacity.js";
+import { capacityDelay, continueCodexCapacity } from "./codex-capacity.js";
 import { resumeControllerSession, failControllerRecovery } from "./run-controller-recovery.js";
 import { captureControllerBoundary } from "./run-controller-capture.js";
 import { requestRunControl } from "./run-control-worker.js";
@@ -534,8 +534,15 @@ async function executeController(context, row, manifest, state, assertOwnership,
         await reconcilePromptPredecessor(session);
         const firstOperationId = operationId ?? `${row.controller_id}:prompt:${crypto.randomUUID()}`;
         const send = (value, id) => {
+            const retained = context.db.get("SELECT input_json FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND generation = ?", [id, row.controller_id, row.generation]);
+            if (retained) {
+                const dispatch = JSON.parse(retained.input_json);
+                if (![value, `${value}\n`].some(text => dispatch.prompt_sha256 === crypto.createHash("sha256").update(text).digest("hex")))
+                    throw new AppError("capacity_continuation_conflict", "Retained prompt differs from continuation", 1);
+                return controllerAdapter(executionContext, row, manifest, session, dispatch.args, assertOwner, id, cancellation.signal);
+            }
             const file = path.join(row.state_dir, `turn-${String(state.turns + 1).padStart(5, "0")}.md`);
-            fs.writeFileSync(file, `${value}\n`, { flag: "wx", mode: 0o600 });
+            fs.writeFileSync(file, value, { flag: "wx", mode: 0o600 });
             state.turns += 1;
             saveState(context, row, state);
             return controllerAdapter(executionContext, row, manifest, session, ["session", "prompt", "--session-id", session.id, "--prompt-file", file, ...sessionArguments(context, manifest, session)], assertOwner, id, cancellation.signal);
@@ -553,24 +560,45 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     throw error;
                 const inspect = (args, id) => runHarnessAdapter({ executable: manifest.adapters["codex-desktop"].executable,
                     args, env: controllerEnvironment(context, manifest, session), runtimeOwner: session.owner, operationId: id, timeoutMs: 30_000, signal: cancellation.signal });
-                const resumed = await continueCodexCapacity({ error, sessionId: session.id, operationId: firstOperationId,
+                const resumed = await continueCodexCapacity({ error, sessionId: session.id, operationId: firstOperationId, signal: cancellation.signal, allowSettledDescendants: true,
+                    retainedIntents: () => context.db.all("SELECT receipt_json FROM run_controller_operations WHERE controller_id = ? AND generation = ? AND operation_id IN (?, ?)", [row.controller_id, row.generation, firstOperationId, `${firstOperationId}:capacity:1:session.prompt`])
+                        .flatMap(item => { const retained = JSON.parse(item.receipt_json || "null"); return retained?.capacity_intent ? [retained.capacity_intent] : []; }).sort((a, b) => a.ordinal - b.ordinal),
                     inspectOperation: id => inspect(["daemon", "operation", "--state-dir", session.state_dir, "--operation-id", id, "--json"], `${id}:capacity-observe`),
-                    inspectSession: () => inspect(["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], `${firstOperationId}:capacity-inspect`),
+                    inspectSession: turnId => inspect(["session", "inspect", "--session-id", session.id, ...(turnId ? ["--turn-id", turnId] : []), ...sessionArguments(context, manifest, session)], `${firstOperationId}:capacity-inspect`),
                     assertCurrent: () => {
                         assertOwner();
+                    },
+                    decision: async () => {
+                        if (kind === "child") {
+                            const target = Object.entries(state.child_capacity ?? {}).find(([, retained]) => retained.operation_id === firstOperationId);
+                            if (!target)
+                                return "reconciliation_blocked";
+                            const seen = await inspect(["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], `${firstOperationId}:child-followup-observe`);
+                            const child = controllerNativeChildren(seen, session.id).find(item => item.session_id === target[0]);
+                            if (child?.parent_session_id === session.id && (child.status === "running" || child.terminal_turn_id && child.terminal_turn_id !== target[1].turn_id))
+                                return "completed";
+                        }
                         const view = getFlowRunStatus(executionContext, { projectRoot: manifest.request.project_root, runId: row.run_id });
                         const next = view.continuation;
+                        if (next.kind === "blocked")
+                            return "reconciliation_blocked";
+                        if (next.kind === "paused" && next.stage !== state.stage)
+                            return "paused";
+                        if (next.kind === "terminal" || next.stage !== state.stage)
+                            return "completed";
                         if (hitl) {
                             const answerId = firstOperationId.slice(0, -`:prompt:${row.generation}`.length);
                             const answer = context.db.get("SELECT input_json FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND status = 'accepted'", [answerId, row.controller_id]);
                             const accepted = answer && JSON.parse(answer.input_json);
                             const pause = view.index.stage_runs.find(item => item.stage === accepted?.stage)?.pause;
-                            if (next.kind !== "paused" || next.stage !== state.stage || !accepted || pause?.id !== accepted.pause_id || pause.work_id !== accepted.work_id || pause.answer_path)
-                                throw new AppError("capacity_continuation_blocked", "Accepted HITL pause changed during capacity wait", 1, { continuation: next });
-                        }
-                        else if (next.stage !== state.stage || ["terminal", "paused", "blocked", "wait"].includes(next.kind)) {
-                            throw new AppError("capacity_continuation_blocked", "RUN changed while native capacity was unavailable", 1, { continuation: next });
+                            if (next.kind !== "paused")
+                                return "continue";
+                            if (!accepted || pause?.id !== accepted.pause_id || pause.work_id !== accepted.work_id || pause.answer_path)
+                                return "paused";
                         }
+                        else if (next.kind === "paused")
+                            return "paused";
+                        return next.kind === "wait" ? "reconciliation_blocked" : "continue";
                     },
                     retainIntent: intent => context.db.writeTransaction(() => {
                         const changed = context.db.run("UPDATE run_controller_operations SET status = 'failed', receipt_json = ?, updated_at = ? WHERE operation_id = ? AND controller_id = ? AND generation = ? AND status = 'outcome_unknown'", [JSON.stringify({ capacity_intent: intent }), context.now(), intent.predecessor, row.controller_id, row.generation]);
@@ -579,7 +607,7 @@ async function executeController(context, row, manifest, state, assertOwnership,
                         appendEvent(context, row.controller_id, "capacity_continuation", intent);
                     }),
                     prompt: (id, value) => send(value, id),
-                    ...(resumeCommand ? { continuationText: `The preceding Turn failed before any tool call. Continue the same accepted HITL answer in this Session. If the pause is still current, run this exact previously issued standalone command once without changing the answer:\n\n${resumeCommand}\n\nDo not accept or deliver the answer again if the pause has changed.` } : {}) });
+                    ...(resumeCommand ? { continuationText: `Continue the same accepted HITL task in this Session. First inspect current durable RUN and pause state. Only if the exact pause still awaits the accepted answer, run this previously issued command once:\n\n${resumeCommand}\n\nNever replay an already committed answer. Otherwise use only the current issued successor.` } : {}) });
                 if (!resumed)
                     throw error;
                 receipt = resumed;
@@ -773,18 +801,22 @@ async function executeController(context, row, manifest, state, assertOwnership,
                 const prior = child && state.child_capacity?.[child.session_id];
                 const links = child ? context.db.all("SELECT w.status FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ?", [row.project_id, row.run_id, storageSessionId({ harness_id: "codex-desktop", session_id: child.session_id })]) : [];
                 if (child && turnId && native && terminalCodexOverload(native, child.session_id, turnId)
-                    && child.native_turn_items?.observed === true && child.native_turn_items.possible_effects === false
+                    && child.native_turn_items?.observed === true && (child.native_turn_items.possible_effects === false || child.native_turn_items.pending === false)
                     && inspected.settled === true && child.parent_session_id === session.id && links.length <= 1
-                    && (!links.length || links[0].status === "running") && (prior?.attempts ?? 0) < 2) {
-                    if (prior?.turn_id === turnId)
+                    && (!links.length || links[0].status === "running") && ((prior?.attempts ?? 0) < 2 || prior?.turn_id === turnId && prior.dispatched === false)) {
+                    const prepared = prior?.turn_id === turnId && prior.dispatched === false && prior.operation_id && prior.not_before ? prior : null;
+                    if (prior?.turn_id === turnId && !prepared)
                         throw new AppError("capacity_child_followup_unconfirmed", "Parent continuation did not start a new native child Turn", 1, { child_session_id: child.session_id, turn_id: turnId });
-                    const attempt = (prior?.attempts ?? 0) + 1;
+                    const attempt = prepared ? prepared.attempts : (prior?.attempts ?? 0) + 1;
+                    const wait = prepared ? Math.max(0, Date.parse(prepared.not_before) - Date.now()) : capacityDelay(native, attempt);
+                    if (!Number.isFinite(wait) || wait > 30_000)
+                        throw new AppError("capacity_child_retry_delay_exceeded", "Native child retry delay exceeds the bounded continuation window", 1, { child_session_id: child.session_id, delay_ms: wait });
+                    const operationId = prepared?.operation_id ?? `${row.controller_id}:child:${digest([child.session_id, turnId]).slice(0, 16)}:followup:${attempt}`;
                     state.child_capacity ??= {};
-                    state.child_capacity[child.session_id] = { turn_id: turnId, attempts: attempt };
+                    state.child_capacity[child.session_id] = { turn_id: turnId, attempts: attempt, operation_id: operationId, not_before: prepared?.not_before ?? new Date(Date.now() + wait).toISOString(), dispatched: false };
                     saveState(context, row, state);
-                    const operationId = `${row.controller_id}:child:${digest([child.session_id, turnId]).slice(0, 16)}:followup:${attempt}`;
                     appendEvent(context, row.controller_id, "capacity_child_followup", { child_session_id: child.session_id, turn_id: turnId, attempt, operation_id: operationId });
-                    await delay(attempt === 1 ? 5_000 : 15_000);
+                    await delay(wait, undefined, { signal: cancellation.signal });
                     assertOwner();
                     const current = getFlowRunStatus(executionContext, { projectRoot: manifest.request.project_root, runId: row.run_id });
                     if (current.continuation.stage !== state.stage || ["terminal", "paused", "blocked", "wait"].includes(current.continuation.kind))
@@ -792,13 +824,20 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     const fresh = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
                     const still = controllerNativeChildren(fresh, session.id).find(item => item.session_id === child.session_id);
                     const currentLinks = context.db.all("SELECT w.status FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ?", [row.project_id, row.run_id, storageSessionId({ harness_id: "codex-desktop", session_id: child.session_id })]);
+                    if (still?.status === "completed" && currentLinks.length <= 1 && currentLinks.every(link => link.status === "completed")) {
+                        state.last_receipt = fresh;
+                        saveState(context, row, state);
+                        continue;
+                    }
                     if (fresh.settled !== true || !still || still.parent_session_id !== session.id || still.status !== "failed" || still.terminal_turn_id !== turnId
-                        || still.native_turn_items?.observed !== true || still.native_turn_items.possible_effects !== false || currentLinks.length > 1
+                        || still.native_turn_items?.observed !== true || still.native_turn_items.possible_effects !== false && still.native_turn_items.pending !== false || currentLinks.length > 1
                         || currentLinks.some(link => link.status !== "running"))
                         throw new AppError("capacity_child_followup_blocked", "Native child or Work changed during capacity wait", 1, { child_session_id: child.session_id, turn_id: turnId });
                     assertOwner();
-                    const text = `The existing native child ${child.session_id} has a confirmed effect-free failed Turn. Use the native followup_task tool exactly once for that same child ID with this short message: "Continue your assigned Work from its current durable state. Do not repeat an observed lifecycle command. Finish only the original Work." Do not spawn another child, claim another Work, or perform the child's Work in this parent Turn. End this Turn after the followup_task response.`;
+                    const text = `The existing native child ${child.session_id} has a confirmed terminal overloaded Turn. Use the native followup_task tool exactly once for that same child ID with this short message: "Continue your assigned Work from its current durable state. Do not repeat an observed lifecycle command. Finish only the original Work." Do not spawn another child, claim another Work, or perform the child's Work in this parent Turn. End this Turn after the followup_task response.`;
                     await prompt(session, text, operationId, "child");
+                    state.child_capacity[child.session_id].dispatched = true;
+                    saveState(context, row, state);
                     const after = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
                     state.last_receipt = after;
                     saveState(context, row, state);
@@ -829,7 +868,7 @@ async function executeController(context, row, manifest, state, assertOwnership,
                 const results = await Promise.allSettled(fanout.works.map(async (work) => {
                     try {
                         assertOwner();
-                        const receipt = await launchExternalWork(executionContext, { workId: work.work_id, stage: next.stage });
+                        const receipt = await launchExternalWork(executionContext, { workId: work.work_id, stage: next.stage, signal: cancellation.signal });
                         if (fatal)
                             throw fatal;
                         appendEvent(context, row.controller_id, "external_work_observed", { work_id: work.work_id, receipt });

package/dist/services/run-observations.js

@@ -90,7 +90,7 @@ export function runObservations(context, projectId, runId) {
             const actual = fs.realpathSync(file);
             if (!inside(home, actual))
                 throw new Error("journal escaped owned home");
-            fd = fs.openSync(actual, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            fd = fs.openSync(actual, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
             if (!fs.fstatSync(fd).isFile())
                 throw new Error("journal is not a regular file");
             replayToolJournal(file, { harness: source.session.harness_id, rootSessionId: sessionId, text: fs.readFileSync(fd, "utf8"), ...(source.session.harness_id === "codex-desktop" ? { expectedSessionIds: expectedCodexIds } : {}) }, reducer);
@@ -114,7 +114,9 @@ export function runObservations(context, projectId, runId) {
     // Select transcript fallback only after replay reveals an actual gap.
     for (const session of sessions) {
         const nativeId = session.provider_session_id ?? session.session_id;
-        if (!session.transcript_path || covered().has(JSON.stringify({ harness_id: session.harness, session_id: nativeId })))
+        const sessionSummary = reducer.summary(nativeId);
+        if (!session.transcript_path || covered().has(JSON.stringify({ harness_id: session.harness, session_id: nativeId }))
+            && sessionSummary.completeness === "complete" && sessionSummary.outcome_completeness === "complete")
             continue;
         const id = `transcript:${session.harness}:${nativeId}`;
         add(id, nativeId, session.transcript_path, home, "current", session.harness);
@@ -136,6 +138,9 @@ export function runObservations(context, projectId, runId) {
         if (!expectedIds.has(JSON.stringify(event.session))) {
             reducer.turns.delete(key);
         }
+    for (const [key, event] of reducer.sources)
+        if (!expectedIds.has(JSON.stringify(event.session)))
+            reducer.sources.delete(key);
     const summary = reducer.summary();
     const observed = new Set(summary.sessions.map(s => JSON.stringify(s.session)));
     const missing = expected.filter(s => !observed.has(JSON.stringify(s)));