@deksden-com/dd-flow-cli 0.9.0-beta.124 → 0.9.0-beta.127

package/dist/harness-runtime/lib/dd-agy-daemon.mjs

@@ -1,4 +1,7 @@
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { operationProgressReporter } from './operation-progress.mjs';
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { errorRecord } from "./operation-errors.mjs";
 import { ToolObservations, agyToolObservation, agyTranscriptObservations } from "./tool-observations.mjs";
 import { constants } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -7,14 +10,15 @@ import { appendFile, chmod, lstat, mkdir, open, readFile, realpath, rename, unli
 import { spawn } from "node:child_process";
 import net from "node:net";
 import { isDeepStrictEqual } from "node:util";
-import { ObservationClock } from "./observation-clock.mjs";
+import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
 import { hookBudget } from "./native-hook-command.mjs";
 import { agyWorkspaceHooks } from "./agy-hooks.mjs";
 import { durableDaemonDispatch, completeDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
-import { AGY_VERSION_TIMEOUT_MS, AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
+import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
 import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { readNativeLines, streamNativeDiagnostics, nativeObservationError, admitNativeRequestBuffer } from "./native-streams.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
 class DaemonError extends AgyError {}
@@ -53,15 +57,15 @@ async function writeJson(file, value) { const temporary = `${file}.${process.pid
 async function readState(dir) { try { return JSON.parse(await readFile(locations(dir).state, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
 async function removeSocket(paths) { try { if (!(await lstat(paths.socket)).isSocket()) throw new DaemonError("unsafe_socket", "refusing to replace a non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 const shell = value => `'${String(value).replaceAll("'", `'"'"'`)}'`;
-export function sanitizedEnv(config) { const env = { ...process.env, TMPDIR: config.temporary, DD_AGY_HOOK_NODE: process.execPath, DD_AGY_HOOK_ENTRY: config.entryPath, DD_AGY_STATE_DIR: config.stateDir, DD_AGY_DAEMON_ID: config.daemonId }; for (const key of ["GEMINI_API_KEY","GOOGLE_API_KEY","ANTHROPIC_API_KEY","OPENAI_API_KEY","DD_FLOW_DAEMON_ID"]) delete env[key]; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
-function errorPayload(error) { return { code: error.code ?? "operation_failed", message: error.message ?? String(error), retryable: error.retryable === true, ...(error.details === undefined ? {} : { details: error.details }) }; }
+export function sanitizedEnv(config) { const env = { ...process.env, TMPDIR: config.temporary, DD_AGY_HOOK_NODE: process.execPath, DD_AGY_HOOK_ENTRY: config.entryPath, DD_AGY_STATE_DIR: config.stateDir, DD_AGY_DAEMON_ID: config.daemonId }; for (const key of ["GEMINI_API_KEY","GOOGLE_API_KEY","ANTHROPIC_API_KEY","OPENAI_API_KEY","DD_FLOW_DAEMON_ID"]) env[key] = undefined; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
+const errorPayload = errorRecord;
 async function forwardUsage(config, sessionId, result, tools, descendants) {
   if (!config.ddFlowBin || !config.projectRoot) return;
   const snapshot = usageSnapshot(result, tools), hasChildren = descendants.length > 0;
   if (snapshot.total_tokens === null) return { status: "unavailable", reason: "provider_did_not_report_total_tokens" };
   const payload = { provider_session_id: sessionId, daemon_id: config.daemonId, observed_at: new Date().toISOString(), usage_scope: hasChildren ? "unknown" : "physical_session", completeness: hasChildren ? "partial" : "complete", usage: { inputTokens: snapshot.input_tokens, outputTokens: snapshot.output_tokens, reasoningTokens: snapshot.reasoning_tokens, cacheReadInputTokens: snapshot.cache_read_tokens, totalTokens: snapshot.total_tokens }, tool_calls: snapshot.tool_calls };
   const target = executable(config.ddFlowBin, ["agy", "usage", "ingest", "--project-root", config.projectRoot, "--json"]);
-  await new Promise((resolve, reject) => { const child = spawn(target.command, target.args, { env: { ...process.env, DD_FLOW_HOME: config.ddFlowHome }, stdio: ["pipe", "ignore", "pipe"] }); let stderr = ""; child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk); child.on("error", reject); child.on("close", code => code === 0 ? resolve() : reject(new DaemonError("agy_usage_ingest_failed", stderr.trim() || "dd-flow rejected Antigravity usage"))); child.stdin.end(`${JSON.stringify(payload)}\n`); });
+  await commandText(target.command, target.args, { input: `${JSON.stringify(payload)}\n`, env: { DD_FLOW_HOME: config.ddFlowHome }, phase: "usage-ingest" });
   return { status: "ingested" };
 }
 
@@ -159,39 +163,11 @@ export async function qualifyAgyHooks(projectRoot, { stateDir = null, install =
 }
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000, requestId = null) {
-  const paths = locations(stateDir), request = { schema_id: REQUEST_SCHEMA, id: requestId ?? process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
-  return await new Promise((resolve, reject) => {
-    const client = net.createConnection(paths.socket); let buffer = "", settled = false, timer, checking = false, lastActivity = Date.now();
-    const clock = new ObservationClock({ timeoutMs, onGap: gap => { void appendFile(paths.journal, `${JSON.stringify({ kind: "observation_gap", payload: { ...gap, operation_id: request.id } })}\n`, { mode: 0o600 }).catch(() => {}); } });
-    const finish = (error, result) => { if (settled) return; settled = true; if (timer) clearInterval(timer); client.destroy(); error ? reject(error) : resolve(result); };
-    const poll = Math.min(5_000, Math.max(25, Math.floor(timeoutMs / 20)));
-    timer = setInterval(async () => {
-      if (settled || checking) return;
-      checking = true;
-      try {
-        if (operation !== "session.prompt") {
-          if (clock.sample()) finish(new DaemonError("daemon_timeout", `${operation} timed out`, true));
-          return;
-        }
-        let status = null;
-        try { status = await callDaemon(stateDir, "daemon.status", {}, Math.min(timeoutMs, 5_000)); }
-        catch { /* The original RPC retains the authoritative failure. */ }
-        const observed = Date.parse(status?.last_activity_at ?? "");
-        const progressed = status?.active_tree === true && Number.isFinite(observed) && observed > lastActivity;
-        if (progressed) lastActivity = observed;
-        if (!clock.sample(progressed ? lastActivity : undefined, progressed ? lastActivity : undefined)) return;
-        finish(new DaemonError(status?.active_tree ? "subject_liveness_timeout" : "operation_observation_lost", `${operation} has no recent productive provider activity`, true, {
-          operation_id: request.id,
-          last_activity_at: status?.last_activity_at ?? null,
-          active_tree: status?.active_tree === true
-        }));
-      } finally { checking = false; }
-    }, poll);
-    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`)); client.on("data", chunk => { buffer += chunk; const index = buffer.indexOf("\n"); if (index < 0) return; try { const response = JSON.parse(buffer.slice(0, index)); response.ok ? finish(null, response.result) : finish(new DaemonError(response.error.code, response.error.message, response.error.retryable, response.error.details)); } catch (error) { finish(new DaemonError("daemon_protocol_mismatch", error.message)); } }); client.on("error", error => finish(new DaemonError("daemon_not_running", error.message, true))); client.on("end", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true))); client.on("close", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true)));
-  });
+  const request = { schema_id: REQUEST_SCHEMA, id: requestId ?? process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: RESPONSE_SCHEMA, harness: 'agy', timeoutMs });
 }
 
-function sameConfig(state, config) { return ["cwd","journal","bin","provider","model","reasoning","mode","projectRoot","ddFlowBin","ddFlowHome","resourceHome","noFlow"].every(key => (state.config?.[key] ?? null) === (config[key] ?? null)); }
+function sameConfig(state, config) { return ["cwd","journal","bin","provider","model","reasoning","mode","projectRoot","ddFlowBin","ddFlowHome","resourceHome","noFlow","livenessTimeoutMs"].every(key => (state.config?.[key] ?? null) === (config[key] ?? null)); }
 // Called only after authorizeRetainedDaemonResume verifies the old daemon,
 // provider processes and operation ledger. Native outcomes remain historical;
 // their old liveness flags cannot describe the replacement process tree.
@@ -209,6 +185,8 @@ export function retainedAgyState(previous, sessionId) {
 export async function startDaemon(options) {
   const paths = locations(options.stateDir); await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
   const previous = await readState(paths.dir), noFlow = options.noFlow === true, cwd = await realpath(absolute(options.cwd, "--cwd")), config = { cwd, journal: options.journal ? absolute(options.journal, "--journal") : paths.journal, bin: options.bin ?? process.env.DD_AGY_BIN ?? "agy", provider: String(options.provider ?? "google"), model: String(options.model ?? "gemini-3.1-pro-high"), reasoning: String(options.reasoning ?? "high"), mode: String(options.mode ?? "accept-edits"), projectRoot: noFlow ? cwd : await realpath(absolute(options.projectRoot, "--project-root")), ddFlowBin: noFlow ? null : absolute(options.ddFlowBin, "--dd-flow-bin"), ddFlowHome: noFlow ? null : absolute(options.ddFlowHome, "--dd-flow-home"), resourceHome: noFlow ? null : (process.env.DD_FLOW_RESOURCE_HOME ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null), env: noFlow ? {} : { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home") }, entryPath: absolute(options.entryPath, "dd-agy entry"), daemonId: randomUUID(), resumeSessionId: options.sessionId ?? null, geminiDir: paths.gemini, appDataDir: "runtime", temporary: paths.temporary, noFlow };
+  config.livenessTimeoutMs = options.livenessTimeoutMs ?? 1_800_000;
+  validateObservationDuration(config.livenessTimeoutMs);
   await prepareRuntimeOwner(config, paths.dir);
   assertDaemonRestartable(previous);
   try { const status = await callDaemon(paths.dir, "daemon.status", {}, 1000); if (!sameConfig(status, config)) throw new DaemonError("daemon_config_mismatch", "a daemon is already running with different configuration"); return { ...status, already_running: true }; } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
@@ -223,7 +201,7 @@ export async function startDaemon(options) {
   const log = await open(paths.log, "a", 0o600), child = spawn(process.execPath, [config.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: sanitizedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 100));
+    const startupClock = new ObservationClock({ timeoutMs: 30_000 }); while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100));
       const persisted = await readState(paths.dir);
       if (persisted?.shutdown_state === "failed") {
         const failure = persisted.startup_error ?? {};
@@ -243,7 +221,7 @@ export class Runtime {
   constructor(paths, state) { this.paths = paths; this.state = state; this.config = state.config; this.child = null; this.providerProcess = state.provider_process ?? null; this.providerFinalization = Promise.resolve(); this.buffer = ""; this.init = null; this.readyPromise = null; this.active = null; this.exited = false; this.toolObservations = new ToolObservations(); for (const reason of state.tool_observation_gaps ?? []) this.toolObservations.gaps.add(reason); for (const event of state.tool_observations ?? []) this.toolObservations.add(event); if (state.tool_calls?.length && !state.tool_observations) this.toolObservations.gaps.add("legacy_tools_not_attributed"); this.turnGeneration = state.turn_generation ?? 0; this.descendants = new Map((state.descendants ?? []).map(child => [child.provider_session_id, child])); this.lastResult = state.last_result ?? null; this.sessionObservations = new Map(state.session_observations ?? []); this.startupError = null; this.persisting = Promise.resolve(); this.draining = Promise.resolve(); this.lastActivityAt = state.last_activity_at ?? null; this.usageIngest = null; this.lastProviderEvent = null; }
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, updated_at: new Date().toISOString(), last_activity_at: this.lastActivityAt, session_observations: [...this.sessionObservations], tool_observations: [...this.toolObservations.calls.values(), ...this.toolObservations.sources.values()], tool_observation_gaps: [...this.toolObservations.gaps], turn_generation: this.turnGeneration, descendants: [...this.descendants.values()], sessions: this.init ? [{ provider_session_id: this.init.conversation_id, root_provider_session_id: this.init.conversation_id, cwd: this.config.cwd }] : [] }); const snapshot = structuredClone(this.state); const queued = performance.now(); this.persisting = this.persisting.catch(() => {}).then(async () => { const started = performance.now(); await writeJson(this.paths.state, snapshot); this.persistTiming = { queue_ms: Math.round(started - queued), write_ms: Math.round(performance.now() - started) }; }); return this.persisting; }
   async journal(kind, payload = {}) { const line = `${JSON.stringify({ schema_id: "dd-agy/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), kind, ...payload })}\n`; for (const journal of new Set([this.paths.journal, this.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
-  args(sessionId) { return ["--input-format", "stream-json", "--output-format", "stream-json", "--model", this.config.model, "--effort", this.config.reasoning, "--mode", this.config.mode, "--dangerously-skip-permissions", "--print-timeout", "6h", `--gemini_dir=${this.paths.gemini}`, "--app_data_dir=runtime", ...(sessionId ? ["--conversation", sessionId] : ["--new-project"])]; }
+  args(sessionId) { return ["--input-format", "stream-json", "--output-format", "stream-json", "--model", this.config.model, "--effort", this.config.reasoning, "--mode", this.config.mode, "--dangerously-skip-permissions", "--print-timeout", "0", `--gemini_dir=${this.paths.gemini}`, "--app_data_dir=runtime", ...(sessionId ? ["--conversation", sessionId] : ["--new-project"])]; }
   requireSessionIdentity(requestedId) {
     const observedId = this.init?.conversation_id ?? null;
     if (!requestedId || requestedId === observedId) return observedId;
@@ -251,12 +229,39 @@ export class Runtime {
       harness: "antigravity-cli", expected_session_id: requestedId, observed_session_id: observedId
     });
   }
-  markActivity() { this.lastActivityAt = new Date().toISOString(); }
+  markActivity() { const current = this.active; this.lastActivityAt = new Date().toISOString(); this.progress = { cursor: (this.progress?.cursor ?? 0) + 1, observed_at: Date.now() }; void current?.publishProgress?.('native_progress', { session_id: this.init?.conversation_id, observed_at: this.lastActivityAt }).catch(error => { if(this.active === current) current.reject(error); }); }
+  markTerminalActivity(result) {
+    const current = this.active;
+    if (!current) return;
+    const key = createHash("sha256").update(JSON.stringify({ conversation_id: result.conversation_id ?? this.init?.conversation_id, status: result.status, num_turns: result.num_turns, error: result.error, response: result.response ?? result.text })).digest("hex");
+    current.terminalProgress ??= new Set();
+    if (current.terminalProgress.has(key) || current.terminalProgress.size >= 1_024) return;
+    current.terminalProgress.add(key); this.markActivity();
+  }
   observeProviderActivity(event) {
-    const fingerprint = createHash("sha256").update(JSON.stringify(event)).digest("hex");
-    if (this.lastProviderEvent === fingerprint) return;
-    this.lastProviderEvent = fingerprint;
-    if (["init", "step_update", "result"].includes(event.event)) this.markActivity();
+    if (!this.active) return;
+    const root = this.init?.conversation_id, step = event.step_update;
+    const id = step?.conversation_id ?? event.result?.conversation_id ?? root;
+    let parent = id; const seen = new Set();
+    while (parent && parent !== root && !seen.has(parent)) { seen.add(parent); const child = this.descendants.get(parent); if (child?.activity_generation !== this.active.generation) return; parent = child.parent_provider_session_id; }
+    if (!root || parent !== root) return;
+    if (event.event === "result") { if (["SUCCESS", "ERROR", "CANCELLED"].includes(event.result?.status)) this.markTerminalActivity(event.result); return; }
+    if (event.event !== "step_update") return;
+    const index = step?.step_index ?? (/^\d+$/.test(step?.step_id ?? "") ? Number(step.step_id) : null);
+    if (!Number.isInteger(index)) return;
+    const floor = this.sessionObservations.get(id)?.step_floor;
+    if (floor != null && index <= floor) return;
+    const tool = step.tool_call ?? step.tool_info ?? (step.step_type === "tool" ? step.tool_name : null);
+    if (!step.content && !step.text && !step.thought && !tool && !step.error && !(step.subagent_info?.subagents?.length)) return;
+    const fingerprint = createHash("sha256").update(JSON.stringify({ content: step.content, text: step.text, thought: step.thought, tool_call: step.tool_call, tool_info: step.tool_info, tool_name: step.tool_name, ...(tool ? { state: step.state, status: step.status } : {}), error: step.error, subagent_info: step.subagent_info })).digest("hex");
+    this.progressSteps ??= new Map(); const prior = this.progressSteps.get(id);
+    if (prior && index < prior.index) return;
+    const snapshots = prior?.index === index ? prior.seen : new Set();
+    if (snapshots.has(fingerprint)) return;
+    // Native step snapshots can alternate/replay; scope retained dedup to the
+    // current step. Too many unique snapshots becomes uncertain, never a grant.
+    if (snapshots.size >= 1_024) return;
+    snapshots.add(fingerprint); this.progressSteps.set(id, { index, seen: snapshots }); this.markActivity();
   }
   async start(sessionId = null) {
     if (this.drainingError) throw this.drainingError;
@@ -284,14 +289,15 @@ export class Runtime {
     const providerChild = this.child;
     let allowProviderFinalization;
     const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
-    this.child.stdout.setEncoding("utf8").on("data", chunk => { this.buffer += chunk; this.draining = this.draining.then(() => this.drain(readyResolve)).catch(error => { this.drainingError ??= error; readyReject(error); if (this.active) { this.active.reject(error); this.active = null; } }); });
-    this.child.stderr.setEncoding("utf8").on("data", chunk => void this.journal("stderr", { text: String(chunk).slice(0, 4000) }));
+    const observationFailure = error => { this.drainingError ??= error; readyReject(error); this.active?.reject(error); };
+    this.nativeDrain = readNativeLines(this.child.stdout, line => { this.buffer = `${line}\n`; return this.draining = this.drain(readyResolve); }, observationFailure);
+    this.diagnostics = streamNativeDiagnostics(this.child.stderr, chunk => this.journal("stderr", { text: chunk }), observationFailure);
     this.child.on("error", error => { readyReject(error); if (this.active) { this.active.reject(error); this.active = null; } });
     // A dead leader is not yet a finalized tree: stop must also join the
     // pending drain, process-group check and final persistence/lease writes.
     this.providerFinalization = new Promise((resolve, reject) => {
       this.child.on("close", (code, signal) => {
-        void this.draining.then(async () => {
+        void Promise.all([this.nativeDrain, this.diagnostics]).then(async () => {
           const interrupted = Boolean(this.active); this.exited = true; const beforeInit = !this.init;
           const error = this.startupError ?? new DaemonError(beforeInit ? "agy_init_missing" : "agy_terminal_result_missing", `Antigravity exited ${beforeInit ? "before init" : "before result"} (${code ?? signal})`);
           if (beforeInit) readyReject(error);
@@ -316,15 +322,38 @@ export class Runtime {
     catch (error) { await cleanupFailedStart(this.config, providerProcess, this.child, error); throw error; }
     finally { allowProviderFinalization(); }
     let readyTimer;
-    try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = setTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), 30_000); })]); }
+    try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = observedTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), 30_000); })]); }
     finally { clearTimeout(readyTimer); }
   }
   async drain(readyResolve) { let index; while ((index = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, index).trim(); this.buffer = this.buffer.slice(index + 1); if (!line) continue; let event; try { event = JSON.parse(line); } catch { await this.journal("invalid_json", { line: line.slice(0, 1000) }); continue; }
     // Record an early provider rejection before journalling: a short-lived
     // child can close while the asynchronous write is still pending.
-    if (!this.init && event.event === "result" && event.result?.status === "ERROR") this.startupError = new DaemonError("agy_provider_rejected", String(event.result.error ?? "Antigravity rejected the Session before initialization"), false, { provider_result: event.result });
+    if (event.event === "result" && ["ERROR", "CANCELLED"].includes(event.result?.status)) {
+      this.lastTerminalFailure ??= this.state.last_terminal_failure;
+      const repeated = Boolean(this.lastTerminalFailure && this.lastTerminalFailure.details?.provider_result?.error === event.result.error
+        && this.lastTerminalFailure.details.provider_session_id === (event.result.conversation_id || this.init?.conversation_id || null)
+        && (this.active?.previousError === event.result.error || this.lastResult?.status === "ERROR" && this.lastResult.error === event.result.error));
+      event.terminal_metadata = repeated ? this.lastTerminalFailure.details : { observed_at: new Date().toISOString(), provider_session_id: event.result.conversation_id || this.init?.conversation_id || null,
+        operation_id: this.active?.operationId ?? null, turn_generation: this.active?.generation ?? null, journal_locator: this.paths.journal, native_source: "agy.result" };
+      if (!this.init) this.startupError ??= agyTerminalFailure(event.result, event.terminal_metadata);
+      this.receivedTerminalMetadata = event.terminal_metadata;
+    }
     this.observeProviderActivity(event); await this.journal("provider_event", { event }); if (event.event === "init") { this.init = { conversation_id: event.conversation_id, ...(event.init ?? {}) }; if (!this.init.conversation_id) throw new DaemonError("agy_init_missing", "Antigravity init has no conversation ID"); const requested = { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode, permission_mode: "always-proceed" }; this.profile = assertProfile(requested, observedProfile(this.init, requested)); await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: this.init.conversation_id, requested, observed: this.profile.observed, source: "native.init" }); await this.persist({ shutdown_state: "running", active_tree: false }); readyResolve(this.init); } else if (event.event === "step_update") this.observeStep(event.step_update ?? {}); else if (event.event === "result") { if (this.startupError) throw this.startupError; await this.finishTurn(event.result ?? {}); } } }
-  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1)) this.childActivity(sessionId); if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); this.toolObservations.add(agyToolObservation(step, this.init?.conversation_id)); for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: sessionId ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
+  observeStep(step) {
+    const sessionId = step.conversation_id ?? this.init?.conversation_id, observation = this.sessionObservations.get(sessionId) ?? {};
+    const fresh = Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1) && step.step_index > (observation.step_floor ?? -1);
+    const bound = sessionId === this.init?.conversation_id || this.descendants.get(sessionId)?.activity_generation === this.active?.generation;
+    // Tree liveness is broader than current-Turn model progress: fresh work
+    // from a retained child invalidates settlement without adopting this Turn.
+    if (fresh && (sessionId === this.init?.conversation_id || this.descendants.has(sessionId))) this.childActivity(sessionId);
+    if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) });
+    this.toolObservations.add(agyToolObservation(step, this.init?.conversation_id));
+    for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) {
+      const prior = this.descendants.get(child.conversation_id);
+      this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: sessionId ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown",
+        ...(fresh && bound && this.active ? { activity_generation: this.active.generation } : {}) });
+    }
+  }
   toolSnapshot() { const summary = this.toolObservations.summary(); const failures_by_name = {}; for (const event of this.toolObservations.calls.values()) if (event.status === "failed") failures_by_name[event.name] = (failures_by_name[event.name] ?? 0) + 1; return { ...summary, by_name: summary.by_tool, failures_by_name }; }
   async captureChildTools() {
     this.capturedToolFacts ??= new Map();
@@ -346,7 +375,7 @@ export class Runtime {
       }
     }
   }
-  async finishTurn(result) {
+  async finishTurn(result, retainedMetadata = null) {
     if (result.status === "RUNNING") { await this.persist({ active_tree: true }); return; }
     if (!["SUCCESS", "ERROR", "CANCELLED"].includes(result.status)) throw new DaemonError("agy_terminal_result_invalid", "Antigravity result has no recognized terminal status", false, { provider_result: result });
     if (result.conversation_id && result.conversation_id !== this.init?.conversation_id) {
@@ -359,12 +388,18 @@ export class Runtime {
       return;
     }
     const current = this.active;
+    const terminalMetadata = retainedMetadata ?? this.receivedTerminalMetadata ?? (this.lastTerminalFailure && this.lastTerminalFailure.details?.provider_result?.error === result.error
+      && this.lastTerminalFailure.details.provider_session_id === (result.conversation_id || this.init?.conversation_id || null)
+      && (current?.previousError === result.error || this.lastResult?.status === "ERROR" && this.lastResult.error === result.error) ? this.lastTerminalFailure.details
+      : { observed_at: new Date().toISOString(), provider_session_id: result.conversation_id || this.init?.conversation_id || null, operation_id: current?.operationId ?? null,
+        turn_generation: current?.generation ?? null, journal_locator: this.paths.journal, native_source: "agy.result" });
+    this.receivedTerminalMetadata = null;
     // The ordered stream returns one result per input. Model usage counters
     // are not request IDs: native command rejections can report zero turns.
     // prompt() drains earlier events before accepting another input.
     if (!current && this.lastResult) { await this.journal("stale_terminal_observed", { result }); return; }
     await this.captureChildTools();
-    this.lastResult = result; this.markActivity();
+    this.lastResult = result; this.markTerminalActivity(result);
     const rootStop = this.sessionObservations.get(this.init?.conversation_id)?.stop;
     const pendingTerminal = current && result.status === "SUCCESS";
     if (pendingTerminal) current.terminalResult = result;
@@ -377,13 +412,9 @@ export class Runtime {
     if (this.active !== current) return;
     if (result.status === "ERROR" || result.status === "CANCELLED") {
       this.active = null;
-      const message = String(result.error ?? "Antigravity returned ERROR"); const normalized = message.toLowerCase();
-      const code = result.status === "CANCELLED" ? "agy_turn_cancelled" : /quota|insufficient.?credit|billing|usage limit/.test(normalized) ? "agy_provider_quota_exhausted"
-        : /rate.?limit|too many requests/.test(normalized) ? "agy_provider_rate_limited"
-          : /\b429\b/.test(normalized) ? "agy_provider_limit_unknown"
-          : /auth|unauthori[sz]ed|forbidden|account/.test(normalized) ? "agy_provider_account"
-            : "agy_provider_failed";
-      return current.reject(new DaemonError(code, message, code === "agy_provider_rate_limited", { provider_result: result, provider_error_scope: current.previousError && current.previousError === result.error ? "repeated_conversation_error" : "terminal_result", usage_ingest: this.usageIngest }));
+      this.lastTerminalFailure = agyTerminalFailure(result, { ...terminalMetadata, provider_error_scope: current.previousError && current.previousError === result.error ? "repeated_conversation_error" : "terminal_result", usage_ingest: this.usageIngest });
+      await this.persist({ last_terminal_failure: errorRecord(this.lastTerminalFailure) });
+      return current.reject(this.lastTerminalFailure);
     }
     await this.completePendingTurn();
   }
@@ -401,6 +432,9 @@ export class Runtime {
     current.resolve(receipt);
   }
   receipt(result = this.lastResult) {
+    if (this.state.last_terminal_failure && !this.lastTerminalFailure) this.lastTerminalFailure = this.state.last_terminal_failure;
+    const terminalMetadata = this.lastTerminalFailure && this.lastTerminalFailure.details?.provider_result?.error === result?.error
+      && this.lastTerminalFailure.details.provider_session_id === (result?.conversation_id || this.init?.conversation_id || null) ? this.lastTerminalFailure.details : null;
     const assistantText = typeof result?.response === "string" ? result.response : typeof result?.text === "string" ? result.text : null;
     const root = this.init?.conversation_id; const observation = this.sessionObservations.get(root);
     const treeSettled = [...this.descendants.values()].every(child => child.tree_settled === true || ["completed", "failed", "cancelled", "settled_by_root"].includes(child.status));
@@ -409,13 +443,14 @@ export class Runtime {
     // non-idle Stop still wins, and every discovered child must be terminal.
     const rootSettled = observation?.stop?.fullyIdle !== false;
     const terminalPending = this.active?.terminalResult === result;
-    return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean(!this.state.unclaimed_activity && (!this.active || terminalPending) && result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status) && treeSettled && rootSettled) };
+    return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(terminalMetadata ? { terminal_metadata: terminalMetadata } : {}), ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean(!this.state.unclaimed_activity && (!this.active || terminalPending) && result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status) && treeSettled && rootSettled) };
   }
   async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
-  async prompt(text, assertDispatch = captureDispatchGuard(this), operationId = null) {
+  async prompt(text, assertDispatch = captureDispatchGuard(this), operationId = null, livenessTimeoutMs = 1_800_000) {
+    validateObservationDuration(livenessTimeoutMs);
     if (!text) throw new DaemonError("prompt_required", "prompt is required");
     await this.start(); await this.draining;
-    if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running");
+    if (this.active || this.promptObservation) throw new DaemonError("operation_in_progress", "an Antigravity turn or its mandatory dispatch observation is already running");
     if (this.state.last_hook_rejection && !this.receipt().settled) throw new DaemonError("tree_not_settled", "Rejected hook does not prove that the prior Antigravity tree stopped", false, { primary_error: this.state.last_hook_rejection });
     if (this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled)) throw new DaemonError("tree_not_settled", "the prior Antigravity agent tree is not fully settled");
     let resolveTurn, rejectTurn;
@@ -423,28 +458,71 @@ export class Runtime {
     // Cancellation can reject while admission persistence is still pending.
     void reply.catch(() => {});
     const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, operationId, previousError: this.lastResult?.error ?? null };
+    let resolveDispatchJournal;
+    const dispatchJournal = current.dispatchJournal = new Promise(resolve => { resolveDispatchJournal = resolve; });
+    this.promptObservation = current;
+    const finishDispatchJournal = () => {
+      current.dispatchJournalSettled = true; resolveDispatchJournal();
+      if (current.observerReturned && this.promptObservation === current) this.promptObservation = null;
+    };
     // Reserve before persistence so different operation IDs cannot overlap.
+    current.publishProgress = operationProgressReporter();
     this.active = current;
     this.hookRequests = new Map();
     const root = this.init?.conversation_id, prior = this.sessionObservations.get(root) ?? {};
     this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null });
-    this.lastProviderEvent = null;
+    this.lastProviderEvent = null; this.progressSteps = new Map(); this.progressHooks = new Set(); this.progress = undefined;
     try {
       await this.persist({ active_tree: true, last_hook_rejection: null });
       assertDispatch();
       assertDaemonDispatch(this.paths?.dir);
       if (this.active !== current) throw new DaemonError("operation_cancelled", "prompt reservation was superseded");
+      current.dispatched = true;
       this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => {
-        if (error) { if (this.active === current) this.active = null; current.reject(error); }
+        if (error) { this.drainingError ??= nativeObservationError(error); current.dispatchObservationError = this.drainingError; current.reject(this.drainingError); finishDispatchJournal(); }
+        else void Promise.resolve().then(() => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: this.init?.conversation_id, native_request_id: current.generation })).then(finishDispatchJournal, cause => {
+          this.drainingError ??= nativeObservationError(cause); current.dispatchObservationError = this.drainingError;
+          current.reject(this.drainingError); finishDispatchJournal();
+        });
       });
-    } catch (error) { if (this.active === current) this.active = null; current.reject(error); }
-    return await reply;
+    } catch (error) {
+      if (current.dispatched) { this.drainingError ??= nativeObservationError(error); error = this.drainingError; }
+      else if (this.active === current) this.active = null;
+      current.reject(error); finishDispatchJournal();
+    }
+    const clock = new ObservationClock({ timeoutMs: livenessTimeoutMs, onGap: gap => { void this.journal("observation_gap", { gap, operation_id: operationId }).catch(() => {}); } });
+    let checking = false;
+    const timer = setInterval(() => {
+      if (this.active !== current || checking || !clock.sample(this.progress)) return;
+      checking = true; const cursor = this.progress?.cursor;
+      void this.completePendingTurn().then(() => {
+        if (this.active !== current || this.progress?.cursor !== cursor || !clock.sample(this.progress)) return;
+        current.reject(new DaemonError("operation_observation_lost", "Antigravity native outcome is unknown after the productive silence window", true, { operation_id: operationId, turn_generation: current.generation, native_outcome: "unknown", last_activity_at: this.lastActivityAt ?? null }));
+      }).catch(error => {
+        if (this.active === current && this.progress?.cursor === cursor) current.reject(new DaemonError("operation_observation_lost", "Antigravity quiet reconciliation could not confirm the native outcome", true, { operation_id: operationId, turn_generation: current.generation, native_outcome: "unknown", observation_error: errorRecord(error) }));
+      }).finally(() => { checking = false; });
+    }, Math.max(10, Math.min(1_000, livenessTimeoutMs / 4)));
+    try {
+      const result = await reply;
+      await dispatchJournal;
+      if (current.dispatchObservationError) {
+        const error = current.dispatchObservationError;
+        if (error.code !== "operation_observation_lost") throw error;
+        throw Object.assign(new Error("Antigravity completed natively but its dispatch journal could not be saved", { cause: error.cause ?? error }), {
+          code: "native_outcome_observation_failed", details: { native_outcome: result, settled: false, observation_error: errorRecord(error) }
+        });
+      }
+      return result;
+    } finally {
+      clearInterval(timer); current.observerReturned = true;
+      if (current.dispatchJournalSettled && this.promptObservation === current) this.promptObservation = null;
+    }
   }
   childActivity(sessionId) {
     if (sessionId === this.init?.conversation_id && !this.active) this.state.unclaimed_activity = true;
     const child = this.descendants.get(sessionId);
     if (!child) return;
-    this.descendants.set(sessionId, { ...child, previous_terminal_status: child.status === "unknown" ? child.previous_terminal_status : child.status, status: "unknown", tree_settled: false, settlement_evidence: null, settlement_daemon_id: null, activity_generation: this.turnGeneration });
+    this.descendants.set(sessionId, { ...child, previous_terminal_status: child.status === "unknown" ? child.previous_terminal_status : child.status, status: "unknown", tree_settled: false, settlement_evidence: null, settlement_daemon_id: null });
   }
   async childForHook(conversationId) {
     if (conversationId === this.init?.conversation_id) return null;
@@ -466,8 +544,7 @@ export class Runtime {
       const correction = { code: error.code, message: error.message, details: error.details, event, conversation_id: payload.conversationId ?? null,
         daemon_id: this.config.daemonId, operation_id: current.operationId, turn_generation: current.generation };
       try {
-        await this.journal("hook_correction", { correction });
-        await this.persist({ last_hook_correction: correction });
+        await hookBudget(1_000, null).run(async () => { await this.journal("hook_correction", { correction }); await this.persist({ last_hook_correction: correction }); }, "correction_persistence");
         current.hookCorrectionGeneration = current.generation;
         return;
       } catch (storage) { error = Object.assign(new Error("Could not persist native hook correction"), { code: "native_hook_receipt_invalid", details: { effect: "unknown", primary_error: correction, receipt_error: storage.message } }); }
@@ -475,7 +552,7 @@ export class Runtime {
     const rejection = this.state.last_hook_rejection && this.state.last_hook_rejection.turn_generation === current?.generation ? this.state.last_hook_rejection : { code: error.code ?? "agy_hook_rejected", message: error.message ?? String(error), details: error.details, event, conversation_id: payload.conversationId ?? null, tool: payload.toolCall?.name ?? null, daemon_id: this.config.daemonId, operation_id: current?.operationId ?? null, turn_generation: current?.generation ?? null };
     this.state.last_hook_rejection = rejection;
     if (current && this.active === current) { this.active = null; current.reject(new DaemonError(rejection.code, rejection.message, false, rejection)); }
-    try { await this.journal("hook_rejected", { rejection }); await this.persist({ last_hook_rejection: rejection }); }
+    try { await hookBudget(1_000, null).run(async () => { await this.journal("hook_rejected", { rejection }); await this.persist({ last_hook_rejection: rejection }); }, "failure_persistence"); }
     catch (storageError) { rejection.receipt_error = { code: storageError.code, message: storageError.message }; }
   }
   async observeHookFailures() {
@@ -489,7 +566,7 @@ export class Runtime {
       await this.rejectHook(Object.assign(new Error(failure.message ?? "Native hook failed"), { code: failure.code, details: failure.details }), binding.event, binding.payload, binding.current);
     }
   }
-  async observeHook(event, payload, budget = null) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); budget?.remaining("identity"); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const parent = child?.parent_provider_session_id ?? null;
+  async observeHook(event, payload, budget = null) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); budget?.remaining("identity"); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); this.progressHooks ??= new Set(); const scoped = this.active && (!child || child.activity_generation === this.active.generation); const progressKey = JSON.stringify([conversationId, step, execution, event, payload.toolCall ?? null, payload.fullyIdle ?? null]); if (scoped && step !== null && (["PreToolUse", "PostToolUse"].includes(event) || event === "Stop" && payload.fullyIdle === true) && !this.progressHooks.has(progressKey) && this.progressHooks.size < 1_024) { this.progressHooks.add(progressKey); this.markActivity(); } if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const parent = child?.parent_provider_session_id ?? null;
     const observed = payload.model ? observedProfile(payload) : {};
     await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: conversationId, parentSessionId: parent, requested: this.config, observed, source: { channel: "native.hook", scope: "configured", ...(!payload.model ? { non_asserting: true } : {}) }, evidence: payload.model ? "configured" : "unavailable", reason: payload.model ? null : "hook_omits_current_model" });
     const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, fully_idle: payload.fullyIdle ?? null, termination_reason: payload.terminationReason ?? null, execution: payload.executionNum ?? null, step: payload.stepIdx ?? null, tool: payload.toolCall?.name ?? null, args: payload.toolCall?.args ?? null })).digest("hex"); await this.persist(); await this.journal("hook", { stale, hook_event: event, event_id: eventId, conversation_id: conversationId, turn_generation: this.turnGeneration, execution_num: execution, step_index: step, termination_reason: payload.terminationReason ?? null, fully_idle: payload.fullyIdle ?? null, persistence_timing: this.persistTiming ?? null }); await this.completePendingTurn(); return { event_id: eventId, daemon_id: this.config.daemonId, launch_cwd: this.config.cwd, parent_conversation_id: parent, profile: observed, requested_profile: { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode }, project_root: this.config.projectRoot, dd_flow_bin: this.config.ddFlowBin, dd_flow_home: this.config.ddFlowHome };
@@ -508,6 +585,7 @@ export class Runtime {
           await this.providerFinalization;
         }
       }
+      await this.promptObservation?.dispatchJournal;
     } catch (error) {
       if (!this.drainingError) throw error;
       this.drainingError.cleanup_error = errorRecord(error);
@@ -548,7 +626,7 @@ export async function serveDaemon(stateDir) {
     let buffer = "", consumed = false; socket.setEncoding("utf8");
     socket.on("data", chunk => {
       if (consumed) return;
-      buffer += chunk; const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, socket, RESPONSE_SCHEMA)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
       void (async () => {
         let request;
         try {
@@ -580,7 +658,7 @@ async function dispatch(runtime, request) {
   if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume"].includes(request.operation)) assertDaemonDispatch(runtime.paths.dir);
   if (request.operation === "daemon.status") { await runtime.observeHookFailures(); return { daemon_id: runtime.config.daemonId, shutdown_state: runtime.state.shutdown_state, active_tree: runtime.state.active_tree, active_operation: runtime.active?.operationId ?? null, last_hook_rejection: runtime.state.last_hook_rejection ?? null, last_activity_at: runtime.lastActivityAt, provider_ready: Boolean(runtime.init && !runtime.exited), pid: process.pid, provider_pid: runtime.child?.pid ?? null, versions: runtime.state.versions, config: runtime.config, sessions: runtime.state.sessions ?? [], receipt: runtime.receipt() }; }
   if (request.operation === "session.create") { if (params.sessionId) throw new DaemonError("invalid_create", "create does not accept a Session ID"); if (params.prompt) throw new DaemonError("invalid_create", "create does not execute a prompt; use session.prompt"); await runtime.start(); await runtime.zeroUsage(); return runtime.receipt(); }
-  if (request.operation === "session.prompt") { const assertDispatch = captureDispatchGuard(runtime); await runtime.start(params.sessionId ?? null); runtime.requireSessionIdentity(params.sessionId); return await runtime.prompt(params.prompt, assertDispatch, request.id); }
+  if (request.operation === "session.prompt") { const assertDispatch = captureDispatchGuard(runtime); await runtime.start(params.sessionId ?? null); runtime.requireSessionIdentity(params.sessionId); return await runtime.prompt(params.prompt, assertDispatch, request.id, params.livenessTimeoutMs ?? runtime.config.livenessTimeoutMs ?? 1_800_000); }
   if (request.operation === "session.inspect") { runtime.requireSessionIdentity(params.sessionId); await runtime.captureChildTools(); return runtime.receipt(); }
   if (request.operation === "session.resume") { await runtime.start(params.sessionId ?? runtime.init?.conversation_id ?? null); runtime.requireSessionIdentity(params.sessionId); return runtime.receipt(); }
   if (request.operation === "session.cancel") { runtime.requireSessionIdentity(params.sessionId); return await runtime.cancel(); }
@@ -611,3 +689,4 @@ async function dispatch(runtime, request) {
   throw new DaemonError("unknown_operation", `unknown dd-agy daemon operation: ${request.operation}`);
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";
+import { commandText } from "./process-json.mjs";

package/dist/harness-runtime/lib/dd-agy.mjs

@@ -1,11 +1,8 @@
-import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
 import { checkObservedProfile } from "./model-observations.mjs";
-import { stopProcessGroup } from "./managed-daemon.mjs";
-import { errorRecord } from "./operation-errors.mjs";
 
 const DEFAULT_MODEL = "gemini-3.1-pro-high";
 export const AGY_VERSION_TIMEOUT_MS = 30_000;
@@ -14,31 +11,21 @@ export class AgyError extends Error {
   constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
 }
 
+export function agyTerminalFailure(result, metadata = {}) {
+  const message = String(result.error ?? "Antigravity returned ERROR"), normalized = message.toLowerCase();
+  const code = result.status === "CANCELLED" ? "agy_turn_cancelled" : /quota|insufficient.?credit|billing|usage limit/.test(normalized) ? "agy_provider_quota_exhausted"
+    : /rate.?limit|too many requests/.test(normalized) ? "agy_provider_rate_limited" : /\b429\b/.test(normalized) ? "agy_provider_limit_unknown"
+      : /auth|unauthori[sz]ed|forbidden|account|eligib/.test(normalized) ? "agy_provider_account" : "agy_provider_failed";
+  return new AgyError(code, message, code === "agy_provider_rate_limited", { provider_result: result, ...metadata });
+}
+
 export function executable(bin, args = []) {
   return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args };
 }
 
 export async function runAgy(bin, args, options = {}) {
-  const target = executable(bin, args);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { cwd: options.cwd, env: options.env ?? process.env, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "", stderr = "", settled = false;
-    let timeoutError, inputError, cleanup;
-    const timer = setTimeout(() => {
-      timeoutError = new AgyError("agy_timeout", `${args[0] ?? "agy"} timed out`, true);
-      cleanup = stopProcessGroup(child, 1_000).catch(error => { timeoutError.cleanup_error = errorRecord(error); timeoutError.details = { cleanup_error: timeoutError.cleanup_error }; finish(timeoutError); });
-    }, options.timeoutMs ?? 30_000);
-    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); error ? reject(error) : resolve(value); };
-    child.stdout.setEncoding("utf8").on("data", chunk => stdout += chunk);
-    child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk);
-    child.on("error", error => finish(error));
-    child.on("close", async code => { await cleanup; if (timeoutError) finish(timeoutError); else if (inputError) finish(inputError); else if (code === 0) finish(null, { stdout, stderr, code }); else finish(new AgyError("agy_cli_failed", stderr.trim() || stdout.trim() || `agy exited ${code}`, false, { exit_code: code })); });
-    child.stdin.on("error", error => {
-      inputError ??= error;
-      cleanup ??= stopProcessGroup(child, 1_000).catch(cause => { inputError.details = { ...inputError.details, cleanup_error: errorRecord(cause) }; finish(timeoutError ?? inputError); });
-    });
-    child.stdin.end(options.stdin ?? "");
-  });
+  const stdout = await commandText(bin, args, { cwd: options.cwd, env: options.env, input: options.stdin ?? "", timeoutMs: options.timeoutMs, phase: "native-doctor" });
+  return { stdout, stderr: "", code: 0 };
 }
 
 export function usageSnapshot(result = {}, toolCalls = {}) {
@@ -68,3 +55,4 @@ export async function doctor(options = {}) {
     return { compatible: true, observed_runtime: { agy: version, dd_harness_contract: "dd-agy-harness@1" }, isolation: { gemini_dir: "verified", app_data_dir: "verified" }, auth: "available", models: modelIds };
   } finally { await rm(temporary, { recursive: true, force: true }); }
 }
+import { commandText } from "./process-json.mjs";

package/dist/harness-runtime/lib/dd-codex-daemon.mjs

@@ -1,9 +1,11 @@
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import net from "node:net";
 import { durableDaemonDispatch, completeDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
-import { observedTimeout } from "./observation-clock.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
 import { parseCapacityOperation } from "./codex-capacity-policy.mjs";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -70,15 +72,8 @@ export async function cancelCodexTree(bridge, options, { remember = () => {}, ac
 }
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
-  const target = locations(stateDir); const request = { schema_id: requestSchema, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
-  return await new Promise((resolve, reject) => {
-    const client = net.createConnection(target.socket); let buffer = ""; let settled = false; const timer = operation === "session.prompt" ? null : observedTimeout(() => finish(Object.assign(new Error(`${operation} timed out`), { code: "daemon_timeout", retryable: true })), timeoutMs);
-    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); client.destroy(); error ? reject(error) : resolve(value); };
-    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`)); client.on("error", (error) => finish(Object.assign(error, { code: "daemon_not_running", retryable: true })));
-    client.on("end", () => finish(Object.assign(new Error("daemon closed the request without a response"), { code: "daemon_connection_closed", retryable: true })));
-    client.on("close", () => finish(Object.assign(new Error("daemon connection closed without a response"), { code: "daemon_connection_closed", retryable: true })));
-    client.on("data", (chunk) => { buffer += chunk; const at = buffer.indexOf("\n"); if (at < 0) return; try { const response = JSON.parse(buffer.slice(0, at)); if (response.schema_id !== responseSchema || response.id !== request.id) throw new Error("invalid daemon response"); response.ok ? finish(null, response.result) : finish(Object.assign(new Error(response.error?.message ?? "daemon error"), response.error)); } catch (error) { finish(Object.assign(error, { code: "daemon_protocol" })); } });
-  });
+  const request = { schema_id: requestSchema, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: responseSchema, harness: 'codex', timeoutMs });
 }
 
 export async function startDaemon(options) {
@@ -92,7 +87,7 @@ export async function startDaemon(options) {
   if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
   await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 60_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed" }); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: 60_000 }); while (!startupClock.sample()) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed" }); }
   catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(locations(options.stateDir).state) }); }
@@ -146,11 +141,11 @@ export async function serveDaemon(stateDir) {
         if (/:capacity:[1-9]\d*:session\.prompt$|:child:[a-f0-9]+:followup:[1-9]\d*$/.test(operationId ?? ""))
           await assertDaemonOwnership(paths.dir, { "operation-id": operationId, operation, "native-session-id": params.sessionId, "prompt-sha256": createHash("sha256").update(params.prompt ?? "").digest("hex") }, assertDispatch);
         sessions.add(params.sessionId);
-        await save({ active_operation: active }); return await promptSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch });
+        await save({ active_operation: active }); return await promptSessionWithBridge(bridge, { ...state.config, ...params, operationId, assertDispatch });
       }
       finally { active = null; await save({ active_operation: null }); }
     }
-    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch }); } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch, operationId }); } finally { active = null; await save({ active_operation: null }); } }
     if (operation === "session.inspect" || operation === "session.resume") {
       const owned = new Set(sessions);
       for (const id of owned) for (const child of bridge.directChildren?.(id) ?? []) owned.add(child.provider_session_id);
@@ -172,7 +167,7 @@ export async function serveDaemon(stateDir) {
     connection.setEncoding("utf8"); let buffer = "", consumed = false;
     connection.on("data", chunk => {
       if (consumed) return;
-      buffer += chunk; const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, responseSchema)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
       void (async () => {
         let request;
         try {