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

package/dist/harness-runtime/lib/native-hook-command.mjs

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
 import { reportedFailure } from "./process-json.mjs";
 
-/** Native command hooks have a 30s outer limit; leave room for transport and cleanup. */
-export function hookBudget(timeoutMs = 25_000, deadlineAt = null) {
+/** The caller supplies its qualified native limit; phases share that deadline. */
+export function hookBudget(timeoutMs = 25_000, deadlineAt = process.env.DD_FLOW_HOOK_DEADLINE_AT === undefined ? null : Number(process.env.DD_FLOW_HOOK_DEADLINE_AT)) {
+  if (deadlineAt !== null && (!Number.isSafeInteger(deadlineAt) || deadlineAt < 0)) throw Object.assign(new Error("Invalid native hook deadline"), { code: "hook_deadline_invalid", details: { effect: "unknown" } });
   const started = performance.now();
   const duration = Math.max(0, Math.min(timeoutMs, Number.isFinite(deadlineAt) ? deadlineAt - Date.now() : timeoutMs));
   const remaining = (phase, maximum = duration) => {
@@ -10,7 +11,7 @@ export function hookBudget(timeoutMs = 25_000, deadlineAt = null) {
     if (value <= 0) throw Object.assign(new Error(`Native hook deadline exceeded during ${phase}`), { code: "native_hook_timeout", details: { phase, elapsed_ms: Math.round(performance.now() - started), effect: "unknown" } });
     return Math.max(1, Math.min(maximum, value));
   };
-  return { deadlineAt: Date.now() + duration, remaining, async run(action, phase) {
+  return { deadlineAt: Math.floor(Date.now() + duration), remaining, async run(action, phase) {
     const timeoutMs = remaining(phase);
     let timer;
     try { return await Promise.race([Promise.resolve().then(action), new Promise((_, reject) => { timer = setTimeout(() => reject(Object.assign(new Error(`Native hook deadline exceeded during ${phase}`), { code: "native_hook_timeout", details: { phase, effect: "unknown" } })), timeoutMs); })]); }
@@ -57,14 +58,31 @@ export async function terminateCommandTree(child, { platform = process.platform,
 
 /** Preserve the native hook protocol across the CLI process boundary. */
 export async function runBoundedCommand({ bin, args, input = null, cwd, env = {}, timeoutMs = 15_000, timeoutCode = "native_hook_timeout" }) {
+  const inherited = env.DD_FLOW_HOOK_DEADLINE_AT ?? process.env.DD_FLOW_HOOK_DEADLINE_AT;
+  if (inherited !== undefined) {
+    const deadline = Number(inherited);
+    if (!Number.isSafeInteger(deadline) || deadline < 0) throw Object.assign(new Error("Invalid native hook deadline"), { code: "hook_deadline_invalid", details: { effect: "no_effect" } });
+    timeoutMs = Math.min(timeoutMs, deadline - Date.now());
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw Object.assign(new Error("Native hook budget exhausted before subprocess launch"), { code: timeoutCode, details: { phase: "subprocess", effect: "no_effect" } });
   const started = performance.now();
+  // Transport/physical cleanup has its own small tail inside the outer limit.
+  const deadlineAt = Math.floor(Date.now() + Math.max(0, timeoutMs - Math.min(250, timeoutMs / 10)));
   const script = /\.[cm]?js$/.test(bin);
   const output = await new Promise((resolve, reject) => {
     const child = spawn(script ? process.execPath : bin, [...(script ? [bin] : []), ...args], {
-      cwd, env: { ...process.env, ...env }, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"]
+      cwd, env: { ...process.env, ...env, DD_FLOW_HOOK_DEADLINE_AT: String(deadlineAt) }, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "", stderr = "", failure, cleanupTimer, settled = false, termination;
-    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); clearTimeout(cleanupTimer); error ? reject(error) : resolve(value); };
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true; clearTimeout(timer); clearTimeout(cleanupTimer);
+      if (error) {
+        const diagnostics = hookDiagnostics(stderr);
+        if (diagnostics.length) error.details = { ...error.details, hook_diagnostics: diagnostics };
+        reject(error);
+      } else resolve(value);
+    };
     const stop = error => {
       if (termination || settled) return;
       failure ??= error;
@@ -98,6 +116,19 @@ export async function runBoundedCommand({ bin, args, input = null, cwd, env = {}
   return output;
 }
 
+/** Only our structured phase allowlist crosses a timeout, never raw stderr/env. */
+function hookDiagnostics(stderr) {
+  return stderr.split("\n").flatMap(line => {
+    try {
+      const value = JSON.parse(line);
+      if (value?.kind !== "native_hook_phase") return [];
+      const phase = typeof value.phase === "string" && /^[a-z_]{1,48}$/.test(value.phase) ? value.phase : null;
+      if (!phase) return [];
+      return [{ phase, ...Object.fromEntries(["elapsed_ms", "remaining_ms", "sqlite_extended_code"].filter(key => Number.isFinite(value[key])).map(key => [key, value[key]])) }];
+    } catch { return []; }
+  }).slice(-16);
+}
+
 export async function invokeNativeHook({ bin, args, payload, home, cwd, env, timeoutMs = 15_000 }) {
   const output = await runBoundedCommand({ bin, args, input: `${JSON.stringify(payload)}\n`, cwd, env: { ...env, DD_FLOW_HOME: home }, timeoutMs });
   let result;

package/dist/harness-runtime/lib/tool-observations.d.mts

@@ -10,6 +10,7 @@ export class ToolObservations {
   calls: Map<string, ToolEvent>;
   turns: Map<string, { session: { harness_id: string; session_id: string }; turn_id: string; started: boolean; completed: boolean }>;
   gaps: Set<string>;
+  sources: Map<string, ToolEvent>;
   add(event: ToolEvent | null): void;
   observeTurn(event: { session: { harness_id: string; session_id: string }; turn_id: string; started?: boolean; completed?: boolean }): void;
   summary(sessionId?: string, cursor?: Set<string>): { total: number; failures: number; pending: number; by_tool: Record<string, number>; completeness: string; outcome_completeness: string; sessions: Array<{ session: { harness_id: string; session_id: string }; total: number; failures: number; pending: number; by_tool: Record<string, number> }>; reasons: string[] };

package/dist/harness-runtime/lib/tool-observations.mjs

@@ -3,7 +3,7 @@ import fs from "node:fs";
 /** Canonical physical-session tool accounting. Native decoding lives below;
  * consumers never have to inspect provider envelopes or aggregate tokens. */
 export class ToolObservations {
-  constructor() { this.calls = new Map(); this.turns = new Map(); this.gaps = new Set(); }
+  constructor() { this.calls = new Map(); this.turns = new Map(); this.gaps = new Set(); this.transcriptSessions = new Set(); this.sources = new Map(); }
   observeTurn(event) {
     if (!event?.session?.harness_id || !event.session.session_id || !event.turn_id) { this.gaps.add("turn_identity_missing"); return; }
     const key = JSON.stringify([event.session, event.turn_id]);
@@ -13,10 +13,19 @@ export class ToolObservations {
   }
   add(event) {
     if (!event) return;
-    if (event.reason) { this.gaps.add(event.reason); return; }
+    if (event.reason) this.gaps.add(event.reason);
+    if (event.source_observed && event.session?.harness_id && event.session?.session_id) { this.sources.set(JSON.stringify(event.session), event); return; }
+    if (event.reason && !event.call_id) return;
     const { harness_id, session_id } = event.session ?? {};
     if (!harness_id || !session_id || !event.call_id) { this.gaps.add("tool_identity_missing"); return; }
     const key = JSON.stringify([harness_id, session_id, event.epoch ?? "", event.call_id]);
+    const physical = JSON.stringify([harness_id, session_id]);
+    if (event.source?.channel === "agy.native_transcript") {
+      this.transcriptSessions.add(physical);
+      for (const [oldKey, call] of this.calls) if (JSON.stringify([call.session.harness_id, call.session.session_id]) === physical && call.source?.channel !== "agy.native_transcript") {
+        this.calls.delete(oldKey); this.gaps.add("agy_live_transcript_correlation_unproven");
+      }
+    } else if (this.transcriptSessions.has(physical)) { this.gaps.add("agy_live_transcript_correlation_unproven"); return; }
     const old = this.calls.get(key);
     // Replay and late starts cannot undo a terminal outcome. Conflicting
     // terminal facts remain visible rather than silently choosing success.
@@ -28,12 +37,12 @@ export class ToolObservations {
         : old?.status === "unknown" || event.status === "unknown" ? "unknown" : "running" });
   }
   summary(sessionId, cursor) {
-    const by_tool = {}, sessions = new Map(), reasons = new Set(this.gaps); let total = 0, failures = 0, pending = 0;
+    const by_tool = Object.create(null), sessions = new Map(), reasons = new Set(this.gaps); let total = 0, failures = 0, pending = 0;
     for (const [key, value] of this.calls) {
       if (sessionId !== undefined && value.session.session_id !== sessionId || cursor?.has(key)) continue;
       const id = JSON.stringify(value.session);
       if (value.name === "unknown") reasons.add("tool_start_missing");
-      const session = sessions.get(id) ?? { session: value.session, parent_session: value.parent_session ?? null, total: 0, failures: 0, pending: 0, by_tool: {} };
+      const session = sessions.get(id) ?? { session: value.session, parent_session: value.parent_session ?? null, total: 0, failures: 0, pending: 0, by_tool: Object.create(null) };
       total++; session.total++; by_tool[value.name] = (by_tool[value.name] ?? 0) + 1; session.by_tool[value.name] = (session.by_tool[value.name] ?? 0) + 1;
       if (value.status === "failed") { failures++; session.failures++; }
       if (!["completed", "failed"].includes(value.status)) { pending++; session.pending++; }
@@ -45,6 +54,10 @@ export class ToolObservations {
       sessions.set(id, sessions.get(id) ?? { session: turn.session, parent_session: null, total: 0, failures: 0, pending: 0, by_tool: {} });
       if (!turn.started || !turn.completed) reasons.add("turn_lifecycle_incomplete");
     }
+    if (!cursor) for (const [id, event] of this.sources) {
+      if (sessionId !== undefined && event.session.session_id !== sessionId) continue;
+      sessions.set(id, sessions.get(id) ?? { session: event.session, parent_session: event.parent_session ?? null, total: 0, failures: 0, pending: 0, by_tool: {} });
+    }
     return { schema_id: "dd-flow/tool-summary@1", scope: "physical_sessions", measurement: "observed_invocations", origin: "native_tool_events", aggregation: cursor ? "delta" : "cumulative", total, failures, pending, by_tool,
       sessions: [...sessions.values()], completeness: reasons.size ? "partial" : "complete", outcome_completeness: pending ? "partial" : "complete", reasons: [...reasons] };
   }
@@ -56,7 +69,7 @@ export class ToolObservations {
 export function journalToolObservations(file, events, previous) {
   const batch = new ToolObservations();
   for (const event of events) batch.add(event);
-  const records = [...batch.calls.values(), ...[...batch.gaps].map(reason => ({ reason }))];
+  const records = [...batch.calls.values(), ...batch.sources.values(), ...[...batch.gaps].map(reason => ({ reason }))];
   for (const event of records) {
     const key = JSON.stringify([event.session, event.epoch, event.call_id, event.reason]);
     const encoded = JSON.stringify(event);
@@ -67,7 +80,9 @@ export function journalToolObservations(file, events, previous) {
 }
 
 const identity = (harness_id, session_id) => ({ harness_id, session_id });
-const status = value => ["error", "failed", "ERROR"].includes(value) ? "failed" : ["completed", "success", "DONE"].includes(value) ? "completed" : "running";
+const status = value => ["error", "failed", "ERROR"].includes(value) ? "failed" : ["completed", "success", "DONE"].includes(value) ? "completed"
+  : value === undefined || value === null || ["running", "pending", "in_progress", "inProgress", "RUNNING", "PENDING", "IN_PROGRESS"].includes(value) ? "running" : "unknown";
+const nativeStatus = value => ({ status: status(value), ...(status(value) === "unknown" ? { reason: "tool_status_unsupported" } : {}) });
 export function zcodePhysicalSession(update, rootSessionId) {
   const native = update?._meta?.zcodeRuntime ?? {};
   if (native.source === "subagent" && !native.childSessionId) return null;
@@ -84,7 +99,7 @@ export function acpToolObservation(message, { harness = "zcode-acp", rootSession
   const session = harness === "zcode-acp" ? zcodePhysicalSession(update, root) : harness === "grok-acp" ? transport : root;
   if (!session || !update.toolCallId) return { reason: "tool_identity_missing" };
   return { session: identity(harness, session), parent_session: session !== root ? identity(harness, root) : null,
-    transport_session_id: transport, call_id: update.toolCallId, name: update._meta?.["x.ai/tool"]?.name ?? update._meta?.claudeCode?.toolName ?? update.title?.split(":", 1)[0], status: status(update.status) };
+    transport_session_id: transport, call_id: update.toolCallId, name: update._meta?.["x.ai/tool"]?.name ?? update._meta?.claudeCode?.toolName ?? update.title?.split(":", 1)[0], ...nativeStatus(update.status) };
 }
 
 export function droidToolObservations(record, sessionId) {
@@ -130,15 +145,41 @@ export function codexAppServerObservation(message) {
 export function openCodeToolObservation(part, sessionId, messageId) {
   if (part.type !== "tool") return null;
   return { session: identity("opencode-server", part.sessionID ?? sessionId), call_id: part.callID ?? part.id,
-    epoch: messageId, name: part.tool, status: status(part.state?.status) };
+    epoch: messageId, name: part.tool, ...nativeStatus(part.state?.status) };
 }
 
 export function agyToolObservation(step, rootSessionId) {
-  if (step.step_type !== "tool") return null;
+  if (step.step_type !== "tool" && !(step.step_type === "subagent" && step.tool_name === "invoke_subagent")) return null;
   const sessionId = step.conversation_id ?? rootSessionId;
   return { session: identity("antigravity-cli", sessionId), parent_session: sessionId !== rootSessionId ? identity("antigravity-cli", rootSessionId) : null,
     call_id: step.step_id ?? step.stepId ?? step.id ?? step.tool_call_id ?? step.toolCallId ?? (Number.isInteger(step.step_index) ? String(step.step_index) : null),
-    name: step.tool_name ?? step.tool_info?.name, status: step.tool_info?.error ? "failed" : status(step.state) };
+    name: step.tool_name ?? step.tool_info?.name, ...(step.tool_info?.error ? { status: "failed" } : nativeStatus(step.state)) };
+}
+
+/** Native AGY JSONL records have planner tool invocations, not matching live
+ * step IDs. GENERIC result text is deliberately not guessed into success. */
+export function agyTranscriptObservations(text, sessionId, parentSessionId, source = {}) {
+  const events = [], lines = text.split("\n"); let recognized = false;
+  const session = identity("antigravity-cli", sessionId);
+  for (const [line, bytes] of lines.entries()) {
+    if (!bytes.trim()) continue;
+    let record; try { record = JSON.parse(bytes); } catch { events.push({ session, reason: line === lines.length - 1 ? "agy_transcript_partial_tail" : "agy_transcript_invalid_record" }); continue; }
+    if (!record || typeof record !== "object" || Array.isArray(record)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); continue; }
+    if (record.conversation_id && record.conversation_id !== sessionId) { events.push({ session, reason: "agy_transcript_session_mismatch" }); continue; }
+    if (!["SYSTEM_MESSAGE", "USER_INPUT", "PLANNER_RESPONSE", "GENERIC", "TOOL_RESPONSE", "CHECKPOINT"].includes(record.type)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); continue; }
+    recognized = true;
+    if (record.tool_calls !== undefined && !Array.isArray(record.tool_calls)) events.push({ session, reason: "agy_transcript_shape_unsupported" });
+    if (record.truncated || record.truncation || typeof record.content === "string" && /\[.*truncat|<.*truncat/i.test(record.content)) events.push({ session, reason: "agy_transcript_truncated" });
+    for (const [index, call] of (Array.isArray(record.tool_calls) ? record.tool_calls : []).entries()) {
+      if (!Number.isInteger(record.step_index) || !call || typeof call.name !== "string" || !call.name) { events.push({ session, reason: "agy_transcript_tool_identity_missing" }); continue; }
+      const id = call.id ?? call.tool_call_id;
+      events.push({ session, parent_session: identity("antigravity-cli", parentSessionId), epoch: "native_transcript", call_id: id ?? `${record.step_index}:${index}`, name: call.name,
+        status: "unknown", reason: "agy_transcript_tool_outcome_unproven", source: { ...source, channel: "agy.native_transcript", line: line + 1, step_index: record.step_index } });
+    }
+  }
+  if (!recognized) events.push({ session, reason: "agy_transcript_shape_unsupported" });
+  else events.push({ session, parent_session: identity("antigravity-cli", parentSessionId), source_observed: true, source: { ...source, channel: "agy.native_transcript" } });
+  return events;
 }
 
 /** Read-only replay, shared by accounting and offline diagnosis. A journal
@@ -150,7 +191,7 @@ export function replayToolJournal(file, options, reducer = new ToolObservations(
   for (const [index, line] of lines.entries()) {
     if (!line.trim()) continue;
     let e; try { e = JSON.parse(line); } catch { reducer.gaps.add(index === lines.length - 1 ? "journal_partial_tail" : "journal_invalid_record"); continue; }
-    const add = event => { if (event) reducer.add({ ...event, source: { journal: file, line: index + 1 }, observed_at: e.observed_at ?? e.timestamp ?? e.at ?? e.ts ?? null }); };
+    const add = event => { if (event) reducer.add({ ...event, source: { ...event.source, journal: file, journal_line: index + 1 }, observed_at: e.observed_at ?? e.timestamp ?? e.at ?? e.ts ?? null }); };
     if (e.kind === "tool_observation" && e.schema_id === "dd-flow/tool-observation@1") { add(e.event); continue; }
     if (e.kind === "notification_failure") reducer.gaps.add("notification_failure");
     const m = e.payload ?? e;

package/dist/runtime/context.js

@@ -12,7 +12,7 @@ export function createContext(env, mode = "initialize", importPermitId) {
     const ddFlowHome = resolveDdFlowHome(env);
     return {
         ddFlowHome,
-        db: getDatabase(ddFlowHome, mode, importPermitId),
+        db: getDatabase(ddFlowHome, mode, importPermitId, mode === "hook" && env.DD_FLOW_HOOK_DEADLINE_AT ? Number(env.DD_FLOW_HOOK_DEADLINE_AT) : undefined),
         env,
         now: () => new Date().toISOString()
     };

package/dist/schemas/flow-run.schema.json

@@ -12,6 +12,7 @@
     "project": {"$ref": "#/definitions/identity"},
     "subject": {"$ref": "#/definitions/identity"},
     "flow_kind": {"type": "string", "minLength": 1},
+    "verification_matrix_contract": {"const": "dd-flow/verification-matrix@1"},
     "status": {"enum": ["created", "running", "paused", "waiting_for_user", "done", "failed", "blocked", "cancelled", "discarded"]},
     "verdict": {"type": ["string", "null"]},
     "started_at": {"type": "string", "format": "date-time"},

package/dist/services/codex-capacity.js

@@ -1,14 +1,114 @@
 import { setTimeout as delay } from "node:timers/promises";
+import crypto from "node:crypto";
 import { terminalCodexOverload } from "../harness-runtime/lib/dd-codex.mjs";
-/** Only a terminal, effect-free native Turn may get another productive Turn. */
+import { AppError } from "../shared/errors.js";
+/** Permit acquisition must still belong to the original task, not merely an
+ * open RUN. Controls/inspection and ordinary successor prompts are unaffected. */
+export function assertCapacityOwnerAdmission(context, record, operationId) {
+    if (!operationId || !record.project_id || !record.run_id)
+        return;
+    const root = operationId.replace(/:capacity:[12]:session\.prompt$/, "");
+    if (root === operationId && !/:child:[a-f0-9]+:followup:[12]$/.test(root))
+        return;
+    const reject = () => { throw new AppError("capacity_owner_boundary_changed", "Queued continuation no longer belongs to an unfinished task; reconcile its durable state", 1, { operation_id: operationId, work_id: record.work_id, run_id: record.run_id }); };
+    if (context.db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'run_recovery_bindings'")) {
+        if (context.db.get("SELECT 1 FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND g.status = 'recovered' AND b.status = 'accepted' AND json_extract(b.runtime_dispatch_json, '$.operation_id') = ?", [record.project_id, record.run_id, root]))
+            reject();
+    }
+    if (record.work_id) {
+        const work = context.db.get("SELECT status FROM works WHERE work_id = ? AND project_id = ? AND run_id = ?", [record.work_id, record.project_id, record.run_id]);
+        const merge = context.db.get("SELECT status FROM merge_requests WHERE executor_work_id = ? AND project_id = ? AND run_id = ?", [record.work_id, record.project_id, record.run_id]);
+        if (merge && !["dispatching", "active"].includes(merge.status))
+            reject();
+        // MERGE owns the Stage/request boundary: finishing its Work does not
+        // necessarily commit stage finish yet. External workers own only Work.
+        const mergeOwner = JSON.parse(record.metadata_json).role === "merge";
+        if (!work || !(merge && mergeOwner ? ["created", "running", "completed"] : ["created", "running"]).includes(work.status))
+            reject();
+    }
+    if (!context.db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'run_controllers'"))
+        return;
+    const controller = context.db.get("SELECT state_json FROM run_controllers WHERE controller_id = ? AND project_id = ? AND run_id = ?", [record.owner_id, record.project_id, record.run_id]);
+    if (!controller)
+        return;
+    const state = JSON.parse(controller.state_json);
+    const run = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [record.project_id, record.run_id]);
+    const index = JSON.parse(run?.index_json ?? "{}");
+    if (state.stage && (index.current_stage && index.current_stage !== state.stage || index.stage_runs?.some(stage => stage.stage === state.stage && ["done", "skipped"].includes(stage.status))))
+        reject();
+    const child = Object.entries(state.child_capacity ?? {}).find(([, intent]) => intent.operation_id === root)?.[0];
+    if (child && context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id JOIN sessions s ON s.session_id = ws.session_id WHERE w.project_id = ? AND w.run_id = ? AND s.provider_session_id = ? AND w.status <> 'running'", [record.project_id, record.run_id, child]))
+        reject();
+}
+export function capacityDelay(error, ordinal, now = Date.now()) {
+    const native = error?.details?.provider_error;
+    const headers = native?.headers;
+    const header = headers && Object.entries(headers).find(([key]) => key.toLowerCase() === "retry-after")?.[1];
+    const value = header ?? native?.retryAfter ?? native?.retry_after;
+    const seconds = typeof value === "number" || typeof value === "string" && /^\d+(\.\d+)?$/.test(value.trim()) ? Number(value) * 1000 : typeof value === "string" ? Date.parse(value) - now : NaN;
+    return Math.max(ordinal === 1 ? 5_000 : 15_000, Number.isFinite(seconds) ? Math.max(0, seconds) : 0);
+}
+/** Continue a confirmed terminal Turn, never replay its completed effects. */
 export async function continueCodexCapacity(input) {
     let { error, operationId } = input;
-    for (let ordinal = 1; ordinal <= 2; ordinal += 1) {
+    const history = input.retainedIntents?.() ?? [];
+    const rootId = input.operationId.replace(/:capacity:[12]:session\.prompt$/, "");
+    const text = input.continuationText ?? "Continue the same assigned task in this Session. Check current durable RUN, Work and Stage state first. Never repeat an observed lifecycle command, accepted HITL answer, check or merge apply; use only an exact issued successor. Stop at the assigned boundary.";
+    const promptSha = crypto.createHash("sha256").update(text).digest("hex");
+    let ordinal = Number(/:capacity:([12]):session\.prompt$/.exec(operationId)?.[1] ?? 0) + 1;
+    // Reconcile a retained dispatch before preparing another. Native absence is
+    // the only safe way to reuse a prepared intent; a lost reply is not absence.
+    for (const intent of history) {
+        if (intent.predecessor !== operationId || intent.ordinal !== ordinal || intent.operation_id !== `${rootId}:capacity:${ordinal}:session.prompt`)
+            continue;
+        if (intent.prompt_sha256 !== promptSha || !intent.turn_id || !Number.isFinite(Date.parse(intent.not_before)))
+            throw error;
+        let observed;
+        try {
+            observed = await input.inspectOperation(intent.operation_id);
+        }
+        catch (cause) {
+            let code = cause;
+            for (let depth = 0; depth < 4 && code?.code === "harness_adapter_failed"; depth++)
+                code = code.details?.cause;
+            if (code?.code !== "operation_not_found")
+                throw error;
+            break;
+        }
+        if (observed.operation_id !== intent.operation_id || observed.session_id !== input.sessionId || observed.operation !== "session.prompt" || observed.primary_error)
+            throw error;
+        if (observed.state === "completed" && observed.result && typeof observed.result === "object") {
+            input.signal?.throwIfAborted();
+            input.assertCurrent();
+            return observed.result;
+        }
+        if (observed.state !== "failed" || !terminalCodexOverload(observed.error, input.sessionId))
+            throw error;
+        operationId = intent.operation_id;
+        error = observed.error;
+        ordinal += 1;
+    }
+    const decide = async () => {
+        input.signal?.throwIfAborted();
+        input.assertCurrent();
+        const decision = await input.decision?.() ?? "continue";
+        input.signal?.throwIfAborted();
+        input.assertCurrent();
+        if (decision === "reconciliation_blocked")
+            throw error;
+        if (decision === "continue" && input.deadline !== undefined && Date.now() >= input.deadline)
+            throw error;
+        return decision === "continue" ? null : { provider_session_id: input.sessionId, capacity_decision: decision };
+    };
+    for (; ordinal <= 2; ordinal += 1) {
         if (!terminalCodexOverload(error, input.sessionId)) {
             if (ordinal === 1)
                 return null;
             throw error;
         }
+        const completed = await decide();
+        if (completed)
+            return completed;
         let prior;
         try {
             prior = await input.inspectOperation(operationId);
@@ -21,14 +121,16 @@ export async function continueCodexCapacity(input) {
         const failure = prior.error;
         const turnId = failure?.details?.turn_id;
         if (prior.operation_id !== operationId || prior.operation !== "session.prompt" || prior.session_id !== input.sessionId
-            || prior.state !== "failed" || prior.primary_error || !turnId || !terminalCodexOverload(failure, input.sessionId, turnId)
-            || failure.details?.native_turn_items?.observed !== true || failure.details.native_turn_items.possible_effects !== false) {
+            || prior.state !== "failed" || prior.primary_error || !turnId || !terminalCodexOverload(failure, input.sessionId, turnId)) {
             if (ordinal === 1)
                 return null;
             throw error;
         }
         const settled = async () => {
-            const seen = await input.inspectSession();
+            const seen = await input.inspectSession(turnId);
+            const items = seen.terminal_turn_id === turnId && seen.terminal_status === "failed" ? seen.native_turn_items : failure.details?.native_turn_items;
+            if (items?.observed !== true || typeof items.possible_effects !== "boolean" || items.pending === true || items.possible_effects === true && items.pending !== false)
+                return false;
             const settlement = seen.settlement;
             const ids = Array.isArray(seen.tree_session_ids) ? seen.tree_session_ids : [];
             const observations = Array.isArray(seen.tree_observations) ? seen.tree_observations : [];
@@ -38,9 +140,8 @@ export async function continueCodexCapacity(input) {
                     && Array.isArray(seen.unsettled_sessions) && seen.unsettled_sessions.length === 0
                 : ids.length === 1 && ids[0] === input.sessionId;
             return seen.provider_session_id === input.sessionId && seen.settled === true && treeProven
-                && (!settlement || ["settled", "not_required"].includes(settlement.state ?? ""));
+                && (!settlement || settlement.state === "not_required" || settlement.state === "settled" && settlement.operation_ids?.includes(operationId) === true);
         };
-        input.assertCurrent();
         try {
             if (!await settled()) {
                 if (ordinal === 1)
@@ -53,16 +154,34 @@ export async function continueCodexCapacity(input) {
                 return null;
             throw error;
         }
-        const nextId = `${input.operationId}:capacity:${ordinal}:session.prompt`;
-        input.retainIntent({ predecessor: operationId, operation_id: nextId, turn_id: turnId, ordinal, not_before: new Date(Date.now() + (ordinal === 1 ? 5_000 : 15_000)).toISOString() });
-        await delay(ordinal === 1 ? 5_000 : 15_000);
-        input.assertCurrent();
+        const nextId = `${rootId}:capacity:${ordinal}:session.prompt`;
+        const existing = history.find(item => item.operation_id === nextId);
+        if (existing && (existing.predecessor !== operationId || existing.turn_id !== turnId || existing.prompt_sha256 !== promptSha || existing.ordinal !== ordinal))
+            throw error;
+        const wait = existing ? Math.max(0, Date.parse(existing.not_before) - Date.now()) : capacityDelay(failure, ordinal);
+        if (!Number.isFinite(wait) || wait > 30_000 || input.deadline !== undefined && Date.now() + wait >= input.deadline)
+            throw error;
+        if (!existing)
+            input.retainIntent({ predecessor: operationId, operation_id: nextId, turn_id: turnId, ordinal, prompt_sha256: promptSha, not_before: new Date(Date.now() + wait).toISOString() });
+        await delay(wait, undefined, { signal: input.signal });
+        const afterWait = await decide();
+        if (afterWait)
+            return afterWait;
         if (!await settled().catch(() => false))
             throw error;
+        const beforeDispatch = await decide();
+        if (beforeDispatch)
+            return beforeDispatch;
         try {
-            return await input.prompt(nextId, input.continuationText ?? "Continue the same assigned task in this Session. Check current durable RUN, Work and Stage state first. Never repeat an observed lifecycle command, accepted HITL answer, check or merge apply; use only an exact issued successor. Stop at the assigned boundary.", ordinal);
+            return await input.prompt(nextId, text, ordinal);
         }
         catch (nextError) {
+            // A task can complete/pause while the daemon queues for its permit.
+            // Admission then refuses the stale prompt; accept that owner decision
+            // before treating the transport's rejection as another provider failure.
+            const finished = await decide();
+            if (finished)
+                return finished;
             error = nextError;
             operationId = nextId;
         }

package/dist/services/codex-hook-delivery.js

@@ -6,17 +6,21 @@ import { commandOption, lifecycleCommandFromPayload, parseLifecycleCommand, cont
 export async function verifyCodexHookDelivery(env, payload) {
     const command = lifecycleCommandFromPayload(payload);
     const parsed = command ? parseLifecycleCommand(command) : { kind: "none" };
-    if (parsed.kind === "none" && !(command && continuationCommand(command)))
+    if (parsed.kind === "none" && !parsed.unresolved && !(command && continuationCommand(command)))
         return undefined;
     const managed = (parsed.kind !== "none" && commandOption(parsed.invocation, "invocation-id")) || env.DD_FLOW_DAEMON_ID;
     if (!managed)
         return undefined; // Explicit legacy/unmanaged transport.
     if (!env.DD_FLOW_CODEX_STATE_DIR || !env.DD_FLOW_DAEMON_ID)
         throw new AppError("native_hook_unproven", "Managed hook has no owning native daemon", 1, { effect: "no_effect" });
+    const deadline = Number(env.DD_FLOW_HOOK_DEADLINE_AT);
+    const remaining = Number.isFinite(deadline) && deadline > 0 ? deadline - Date.now() : 5000;
+    if (remaining <= 0)
+        throw new AppError("native_hook_timeout", "Native hook deadline expired before delivery verification", 1, { phase: "verification", effect: "no_effect", recoverable: false });
     const proof = await callDaemon(env.DD_FLOW_CODEX_STATE_DIR, "hook.verify", {
         daemonId: env.DD_FLOW_DAEMON_ID, rootSessionId: payload.session_id,
         sessionId: payload.agent_id ?? payload.session_id, toolCallId: payload.tool_use_id, turnId: payload.turn_id
-    }, 5000);
+    }, Math.min(5000, remaining));
     if (typeof proof.projectRoot !== "string"
         || typeof proof.ddFlowHome !== "string" || !env.DD_FLOW_HOME || path.resolve(env.DD_FLOW_HOME) !== path.resolve(proof.ddFlowHome)
         || proof.daemonId !== env.DD_FLOW_DAEMON_ID || typeof proof.rootSessionId !== "string" || typeof proof.sessionId !== "string"

package/dist/services/eval-snapshots.js

@@ -409,7 +409,12 @@ export function restoreEvalRunSnapshot(context, input, prepared = prepareEvalRun
     let result, primary, failed = false;
     try {
         const runtimeLineage = recovery ? null : detachSnapshotRuntimeOwners(restored, snapshot, manifest);
+        const originalRunRoot = restored.db.get("SELECT run_root FROM runs WHERE id = ?", [manifest.run_id])?.run_root;
         rebaseRuntime(restored, manifest.project_root, projectRoot, sourceWorkspaceRoot(manifest), workspaceRoot, manifest.dd_flow_home, context.ddFlowHome, recovery);
+        const publicationRun = restored.db.get("SELECT project_id, run_root FROM runs WHERE id = ?", [manifest.run_id]);
+        if (!originalRunRoot || !publicationRun?.run_root || !isInside(manifest.dd_flow_home, originalRunRoot) || !isInside(context.ddFlowHome, publicationRun.run_root))
+            throw new AppError("snapshot_invalid", "Restored publication roots are not bound to their runtime", 1);
+        restored.db.run("INSERT INTO audit_events (project_id, event_type, forced, payload_json, created_at) VALUES (?, 'flow_run.publication_relocation', 0, ?, ?)", [publicationRun.project_id, JSON.stringify({ run_id: manifest.run_id, from: originalRunRoot, to: publicationRun.run_root, source_manifest_sha256: sourceManifestSha256, import_id: importId }), restored.now()]);
         registerProject(restored, { root: projectRoot });
         requireProjectByRoot(restored, projectRoot);
         if (selectedProfile && routingInput && runtimeLineage) {
@@ -423,14 +428,6 @@ export function restoreEvalRunSnapshot(context, input, prepared = prepareEvalRun
                 fs.writeFileSync(artifact, routingInput.bytes, { flag: "wx", mode: 0o600 });
             importFlowRunExecutionProfile(restored, { projectRoot, runId: manifest.run_id, stage: manifest.stage_entry, lineageFile: runtimeLineage, profile: selectedProfile });
         }
-        const status = getFlowRunStatus(restored, { projectRoot, runId: manifest.run_id });
-        if (!recovery)
-            assertStageEntry(status.index.stage_runs ?? [], manifest.stage_entry);
-        else
-            restored.db.run("UPDATE run_recovery_guards SET capture_path = ? WHERE recovery_id = ? AND status = 'sealed'", [snapshot, input.recoveryId]);
-        if (!status.run.run_root)
-            throw new AppError("runtime_missing", "Restored RUN has no artifact root", 1, { run_id: manifest.run_id });
-        const runHome = status.run.run_root;
         const relocation = recovery ? {
             schema_id: "dd-flow/recovery-relocation@1", physical_runtime_id: crypto.randomUUID(), recovery_id: input.recoveryId, run_id: manifest.run_id,
             path_mapping: [{ from: manifest.dd_flow_home, to: context.ddFlowHome }, { from: sourceWorkspaceRoot(manifest), to: workspaceRoot }, { from: manifest.project_root, to: projectRoot }]
@@ -440,6 +437,14 @@ export function restoreEvalRunSnapshot(context, input, prepared = prepareEvalRun
             fs.mkdirSync(path.dirname(relocationFile), { recursive: true });
             writeJson(relocationFile, relocation);
         }
+        const status = getFlowRunStatus(restored, { projectRoot, runId: manifest.run_id });
+        if (!recovery)
+            assertStageEntry(status.index.stage_runs ?? [], manifest.stage_entry);
+        else
+            restored.db.run("UPDATE run_recovery_guards SET capture_path = ? WHERE recovery_id = ? AND status = 'sealed'", [snapshot, input.recoveryId]);
+        if (!status.run.run_root)
+            throw new AppError("runtime_missing", "Restored RUN has no artifact root", 1, { run_id: manifest.run_id });
+        const runHome = status.run.run_root;
         const expectedWorkspaceRoot = restoredWorkspaceRoot(manifest, projectRoot, context.ddFlowHome);
         if (physicalPath(workspaceRoot) !== physicalPath(expectedWorkspaceRoot))
             throw new AppError("snapshot_workspace_restore_failed", "Restored workspace differs from the import target", 1, { workspace_root: workspaceRoot, expected_workspace_root: expectedWorkspaceRoot });

package/dist/services/external-work-launch.js

@@ -93,7 +93,7 @@ export async function launchExternalWork(context, input) {
     const common = ["--dd-flow-bin", flowExecutable, "--state-dir", root, "--journal", journal, "--cwd", isolatedWorkspace ?? run.workspace_root, "--provider", resolved.worker.provider, "--model", resolved.worker.model, "--reasoning", resolved.worker.reasoning, "--mode", resolved.worker.mode, "--permission", resolved.worker.permission, "--project-root", run.project_root, "--dd-flow-home", context.ddFlowHome, ...harnessRuntimeArguments(context.ddFlowHome, runtimeHarness(resolved.worker)), "--json"];
     const evidence = (value) => fs.appendFileSync(journal, `${JSON.stringify({ type: "adapter_call", at: context.now(), ...value })}\n`);
     try {
-        const call = (args, timeoutMs, id = `${operationId}:${args[0]}.${args[1]}`) => runHarnessAdapter({ executable, args, env: runtimeContext.env, operationId: id, runtimeOwner, ...(timeoutMs ? { timeoutMs } : {}), ...(input.progress ? { progress: input.progress } : {}), onEvidence: evidence });
+        const call = (args, timeoutMs, id = `${operationId}:${args[0]}.${args[1]}`) => runHarnessAdapter({ executable, args, env: runtimeContext.env, operationId: id, runtimeOwner, ...(timeoutMs ? { timeoutMs } : {}), ...(input.signal ? { signal: input.signal } : {}), ...(input.progress ? { progress: input.progress } : {}), onEvidence: evidence });
         await call(["daemon", "start", ...common]);
         assertRunMutationAllowed(context, work.project_id, work.run_id, generation);
         const created = await call(["session", "create", ...common], runtimeHarness(resolved.worker) === "zcode-acp" ? 180_000 : undefined);
@@ -111,6 +111,7 @@ export async function launchExternalWork(context, input) {
         const promptFile = path.join(root, "launch.md");
         fs.writeFileSync(promptFile, `Start the assigned Work now. Your first tool call must be this exact standalone command:\n\n${workStartCommand(runtimeContext, work)}\n\nUse the packet returned by that command. Do not claim another Work or run this command more than once.\n\n${lifecycleRetryInstruction}${isolatedWorkspace ? `\n\nThe review copy has no .git. Read the captured status/diff or gitless note in ${path.join(isolatedWorkspace, ".dd-flow", "review-evidence")}; do not run Git inside the copy.\n` : "\n"}`);
         const promptOperationId = `${operationId}:session.prompt`;
+        const promptDeadline = Date.now() + 45 * 60_000;
         let prompted;
         try {
             prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60_000);
@@ -118,37 +119,54 @@ export async function launchExternalWork(context, input) {
         catch (error) {
             if (runtimeHarness(resolved.worker) !== "codex-desktop")
                 throw error;
-            const resumed = await continueCodexCapacity({ error, sessionId, operationId: promptOperationId,
+            const retained = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
+            const capacityIntents = retained?.adapter_receipt_json ? JSON.parse(retained.adapter_receipt_json).capacity_intents ?? [] : [];
+            const resumed = await continueCodexCapacity({ error, sessionId, operationId: promptOperationId, allowSettledDescendants: true,
+                ...(input.signal ? { signal: input.signal } : {}), deadline: promptDeadline,
+                continuationText: `Continue only Work ${work.work_id} in RUN ${work.run_id}, Stage ${stage ?? "current"}, in the same Session. Inspect its current durable state and the retained Work packet. Never repeat Work start or a completed tool, accepted answer, check or lifecycle command. Use only the current exact issued successor and finish at the original Work boundary.`,
+                retainedIntents: () => capacityIntents,
                 inspectOperation: id => call(["daemon", "operation", "--state-dir", root, "--operation-id", id, "--json"], 30_000, `${id}:capacity-observe`),
-                inspectSession: () => call(["session", "inspect", "--session-id", sessionId, ...common], 30_000, `${operationId}:capacity-inspect`),
+                inspectSession: turnId => call(["session", "inspect", "--session-id", sessionId, ...(turnId ? ["--turn-id", turnId] : []), ...common], 30_000, `${operationId}:capacity-inspect`),
                 assertCurrent: () => {
                     assertRunMutationAllowed(context, work.project_id, work.run_id, generation);
                     const current = context.db.get("SELECT w.status, l.status AS launch_status FROM works w JOIN work_launches l ON l.work_id = w.work_id WHERE w.work_id = ? AND l.operation_id = ?", [work.work_id, operationId]);
-                    if (current?.status !== "created" || current.launch_status !== "launching")
+                    if (!current || !["created", "running", "paused", "completed"].includes(current.status) || current.launch_status !== "launching")
                         throw new AppError("capacity_continuation_blocked", "External Work changed before its native continuation", 1, { work_id: work.work_id, state: current });
                     if (reviewCopy && reviewSourceHash(run.workspace_root, reviewInputs, reviewBase) !== reviewCopy.source_sha256)
                         throw new AppError("read_only_input_changed", "Authoritative review workspace changed during capacity wait", 2);
                 },
+                decision: () => {
+                    const status = context.db.get("SELECT status FROM works WHERE work_id = ?", [work.work_id])?.status;
+                    return status === "completed" ? "completed" : status === "paused" ? "paused" : "continue";
+                },
                 retainIntent: intent => {
-                    const changed = context.db.run("UPDATE work_launches SET adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ? AND status = 'launching'", [JSON.stringify({ create: created, capacity_intent: intent }), context.now(), operationId]);
+                    capacityIntents.push(intent);
+                    const changed = context.db.run("UPDATE work_launches SET adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ? AND status = 'launching'", [JSON.stringify({ create: created, capacity_intent: intent, capacity_intents: capacityIntents }), context.now(), operationId]);
                     if (changed.changes !== 1)
                         throw new AppError("capacity_continuation_blocked", "External Work launch owner changed", 1);
                 },
                 prompt: (id, text, ordinal) => {
                     const file = path.join(root, `capacity-${ordinal}.md`);
-                    fs.writeFileSync(file, `${text}\n`, { flag: "wx", mode: 0o600 });
-                    return call(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], 45 * 60_000, id);
+                    if (fs.existsSync(file)) {
+                        if (fs.readFileSync(file, "utf8") !== text)
+                            throw new AppError("capacity_continuation_conflict", "Retained Work continuation prompt differs", 1);
+                    }
+                    else
+                        fs.writeFileSync(file, text, { flag: "wx", mode: 0o600 });
+                    return call(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], Math.max(1, promptDeadline - Date.now()), id);
                 } });
             if (!resumed)
                 throw error;
             prompted = resumed;
         }
         assertRunMutationAllowed(context, work.project_id, work.run_id, generation);
-        context.db.run("UPDATE work_launches SET status = 'start_requested', provider_session_id = ?, adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [sessionId, JSON.stringify({ create: created, prompt: prompted }), context.now(), operationId]);
+        const saved = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
+        context.db.run("UPDATE work_launches SET status = 'start_requested', provider_session_id = ?, adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [sessionId, JSON.stringify({ ...(saved?.adapter_receipt_json ? JSON.parse(saved.adapter_receipt_json) : {}), create: created, prompt: prompted }), context.now(), operationId]);
         return { ok: true, work_id: work.work_id, operation_id: operationId, status: "start_requested", session: { harness_id: runtimeHarness(resolved.worker), session_id: sessionId }, profile_hash: resolved.profile_hash, journal_path: journal };
     }
     catch (error) {
-        context.db.run("UPDATE work_launches SET status = 'failed', adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify({ error: errorRecord(error) }), context.now(), operationId]);
+        const saved = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
+        context.db.run("UPDATE work_launches SET status = 'failed', adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify({ ...(saved?.adapter_receipt_json ? JSON.parse(saved.adapter_receipt_json) : {}), error: errorRecord(error) }), context.now(), operationId]);
         throw error;
     }
 }