@deksden-com/dd-flow-cli 0.9.0-beta.144 → 0.9.0-beta.145

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

@@ -19,14 +19,15 @@ 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, agyTerminalFailure, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
+import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, agyModelArgs, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
+import { recoveredAgyErrorBoundary } from "./agy-error-boundary.mjs";
 import { settledNativeTree } from "./native-children.mjs";
 import { retainStartupFailure, 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 {}
-export async function captureAgyTranscript(runtimeRoot, child, rootSessionId, ownedSessionIds = [rootSessionId]) {
+export async function captureAgyTranscript(runtimeRoot, child, rootSessionId, ownedSessionIds = [rootSessionId], inspect = null) {
   const session = { harness_id: "antigravity-cli", session_id: child.provider_session_id };
   let handle;
   try {
@@ -43,6 +44,7 @@ export async function captureAgyTranscript(runtimeRoot, child, rootSessionId, ow
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
     const bytes = buffer.subarray(0, bytesRead), prefix = bytes.subarray(0, bytes.lastIndexOf(10) + 1);
     const source = { locator: child.log_uri, byte_start: 0, byte_end: prefix.length, sha256: createHash("sha256").update(prefix).digest("hex") };
+    if (prefix.length === bytesRead && stat.size <= maximum) inspect?.(prefix.toString("utf8"), source);
     const events = agyTranscriptObservations(prefix.toString("utf8"), child.provider_session_id, child.parent_provider_session_id ?? rootSessionId, source);
     if (prefix.length !== bytesRead || stat.size > maximum) events.push({ session, reason: stat.size > maximum ? "agy_transcript_size_limit" : "agy_transcript_partial_tail" });
     return events;
@@ -224,8 +226,8 @@ export const stopDaemon = async options => { const timeoutMs = options.timeoutMs
 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", "0", `--gemini_dir=${this.paths.gemini}`, "--app_data_dir=runtime", ...(sessionId ? ["--conversation", sessionId] : ["--new-project"])]; }
+  async journal(kind, payload = {}, reservedPosition = null) { const position = reservedPosition ?? (this.journalPosition = (this.journalPosition ?? 0) + 1); const line = `${JSON.stringify({ schema_id: "dd-agy/daemon-event@1", event_id: randomUUID(), position, 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 }); } return position; }
+  args(sessionId) { return ["--input-format", "stream-json", "--output-format", "stream-json", ...agyModelArgs(this.config.model, 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;
@@ -288,7 +290,7 @@ export class Runtime {
     const providerProcess = this.providerProcess;
     try { await this.persist({ provider_process: providerProcess }); }
     catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
-    try { assertDaemonDispatch(this.paths?.dir); this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] }); }
+    try { assertDaemonDispatch(this.paths?.dir); this.connectionId = randomUUID(); this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] }); }
     catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
     const providerChild = this.child;
     let allowProviderFinalization;
@@ -334,10 +336,7 @@ export class Runtime {
     // child can close while the asynchronous write is still pending.
     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,
+      event.terminal_metadata = { 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;
@@ -399,16 +398,24 @@ export class Runtime {
       return;
     }
     const current = this.active;
-    const terminalMetadata = { received_at: new Date().toISOString(), ...(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" })) };
+    if (current?.dispatched === false) {
+      const error = new DaemonError("operation_observation_lost", "Unexpected native terminal before this stream request was dispatched", false, { operation_id: current.operationId, turn_generation: current.generation, native_outcome: "unknown" });
+      this.active = null; current.reject(error);
+      await this.journal("unexpected_terminal_before_dispatch", { result, operation_id: current.operationId });
+      await this.persist({ unclaimed_activity: true, active_tree: true });
+      return;
+    }
+    const terminalMetadata = { received_at: new Date().toISOString(), ...(retainedMetadata ?? this.receivedTerminalMetadata ?? { 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; }
+    if (!current && this.lastResult) {
+      await this.journal("stale_terminal_observed", { result });
+      if (!isDeepStrictEqual(result, this.lastResult)) await this.persist({ unclaimed_activity: true, active_tree: true });
+      return;
+    }
     this.lastResult = result; this.markTerminalActivity(result);
     const rootStop = this.sessionObservations.get(this.init?.conversation_id)?.stop;
     const pendingTerminal = current && result.status === "SUCCESS";
@@ -418,7 +425,12 @@ export class Runtime {
     try {
       await this.persist({ active_tree: true, last_result: result, last_terminal_metadata: terminalMetadata });
       if (current) current.terminalPersisted = true;
-      if (providerEvent) await this.journal("provider_event", { event: providerEvent });
+      const terminalPosition = await this.journal("provider_event", { event: providerEvent ?? { event: "result", result } });
+      terminalMetadata.stream_terminal_position = terminalPosition;
+      if (current?.outboundPosition && current.dispatchJournalSettled && !current.dispatchObservationError && this.config.daemonId && current.connectionId && current.operationId) terminalMetadata.request_proof = {
+        kind: "stream_request", daemon_instance: this.config.daemonId, connection_id: current.connectionId, operation_id: current.operationId,
+        turn_generation: current.generation, session_id: this.init.conversation_id, outbound_position: current.outboundPosition, terminal_position: terminalPosition
+      };
       await this.captureChildTools();
     } catch (error) { return this.failTerminalObservation(current, result, terminalMetadata, error); }
     try { this.usageIngest = await forwardUsage(this.config, result.conversation_id ?? this.init.conversation_id, result, this.toolSnapshot(), [...this.descendants.values()]); }
@@ -429,9 +441,19 @@ export class Runtime {
     if (!current) return;
     if (this.active !== current) return;
     if (result.status === "ERROR" || result.status === "CANCELLED") {
+      await this.observeHookFailures();
+      if (this.active !== current) return;
       this.active = null;
       const settled = this.receipt().settled;
-      this.lastTerminalFailure = agyTerminalFailure(result, { ...terminalMetadata, native_turn_items: { observed: settled, possible_effects: true, pending: !settled }, provider_error_scope: current.previousError && current.previousError === result.error ? "repeated_conversation_error" : "terminal_result", usage_ingest: this.usageIngest });
+      if (result.status === "ERROR" && settled && rootStop?.fullyIdle === true && !this.state.last_hook_rejection && current.operationId && this.paths.runtime) {
+        const root = this.init.conversation_id, transcript = path.join(this.paths.runtime, "brain", root, ".system_generated", "logs", "transcript.jsonl");
+        await captureAgyTranscript(this.paths.runtime, { provider_session_id: root, parent_provider_session_id: root, log_uri: new URL(`file://${transcript}`).href }, root, [root], (text, source) => {
+          const boundary = recoveredAgyErrorBoundary(text, result.error, current.stepFloor);
+          const hook = current.nativeHookEvents?.get(boundary?.boundary_step);
+          if (boundary && hook) terminalMetadata.recovered_error_boundary = { ...boundary, receipt: { ...boundary.receipt, native_hook_event_key: hook, daemon_instance: this.config.daemonId }, source };
+        });
+      }
+      this.lastTerminalFailure = agyTerminalFailure(result, { ...terminalMetadata, native_turn_items: { observed: settled, possible_effects: true, pending: !settled }, provider_error_scope: "terminal_result", usage_ingest: this.usageIngest });
       try { await this.persist({ active_tree: !settled, last_terminal_failure: errorRecord(this.lastTerminalFailure) }); }
       catch (error) { return this.failTerminalObservation(current, result, terminalMetadata, error); }
       return current.reject(this.lastTerminalFailure);
@@ -491,7 +513,8 @@ export class Runtime {
     const reply = new Promise((resolve, reject) => { resolveTurn = resolve; rejectTurn = reject; });
     // 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 };
+    this.connectionId ??= randomUUID();
+    const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, operationId, connectionId: this.connectionId, dispatched: false };
     let resolveDispatchJournal;
     const dispatchJournal = current.dispatchJournal = new Promise(resolve => { resolveDispatchJournal = resolve; });
     this.promptObservation = current;
@@ -504,6 +527,7 @@ export class Runtime {
     this.active = current;
     this.hookRequests = new Map();
     const root = this.init?.conversation_id, prior = this.sessionObservations.get(root) ?? {};
+    current.stepFloor = prior.last_step_index ?? -1;
     this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null });
     this.lastProviderEvent = null; this.progressSteps = new Map(); this.progressHooks = new Set(); this.progress = undefined;
     try {
@@ -511,10 +535,11 @@ export class Runtime {
       assertDispatch();
       assertDaemonDispatch(this.paths?.dir);
       if (this.active !== current) throw new DaemonError("operation_cancelled", "prompt reservation was superseded");
+      current.outboundPosition = this.journalPosition = (this.journalPosition ?? 0) + 1;
       current.dispatched = true;
       this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, 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 => {
+        else void Promise.resolve().then(() => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: this.init?.conversation_id, turn_generation: current.generation, connection_id: current.connectionId }, current.outboundPosition)).then(finishDispatchJournal, cause => {
           this.drainingError ??= nativeObservationError(cause); current.dispatchObservationError = this.drainingError;
           current.reject(this.drainingError); finishDispatchJournal();
         });
@@ -552,6 +577,20 @@ export class Runtime {
         });
       }
       return result;
+    } catch (error) {
+      await dispatchJournal;
+      if (error.code === "native_outcome_observation_failed") throw error;
+      if (current.dispatchObservationError) throw current.dispatchObservationError;
+      const metadata = current.terminalMetadata;
+      if (error === this.lastTerminalFailure && metadata && !metadata.request_proof && current.outboundPosition && metadata.stream_terminal_position && this.config.daemonId && current.operationId) {
+        metadata.request_proof = { kind: "stream_request", daemon_instance: this.config.daemonId, connection_id: current.connectionId, operation_id: current.operationId,
+          turn_generation: current.generation, session_id: this.init.conversation_id, outbound_position: current.outboundPosition, terminal_position: metadata.stream_terminal_position };
+        const proven = agyTerminalFailure(current.terminalResult, { ...error.details, ...metadata });
+        this.lastTerminalFailure = proven;
+        await this.persist({ last_terminal_metadata: metadata, last_terminal_failure: errorRecord(proven) });
+        throw proven;
+      }
+      throw error;
     } finally {
       clearInterval(timer); current.observerReturned = true;
       if (current.dispatchJournalSettled && this.promptObservation === current) this.promptObservation = null;
@@ -606,7 +645,10 @@ export class Runtime {
   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 };
+    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 });
+    if (!stale && !child && event === "PreToolUse" && Number.isInteger(step) && this.active) { this.active.nativeHookEvents ??= new Map(); this.active.nativeHookEvents.set(step, `${eventId}:before`); }
+    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 };
   }
   async finalizeProviderForControl() {
     const pending = this.providerFinalization;

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import { SETUP_STARTUP_MS } from './setup-progress.mjs';
 
 import { checkObservedProfile } from "./model-observations.mjs";
-import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
+import { classifyProviderError, safeProviderError, streamRequestKey } from "./provider-overload-policy.mjs";
 
 const DEFAULT_MODEL = "gemini-3.1-pro-high";
 export const AGY_VERSION_TIMEOUT_MS = 30_000;
@@ -14,14 +14,22 @@ export class AgyError extends Error {
 }
 
 export function agyTerminalFailure(result, metadata = {}) {
-  const native = typeof result.error === "object" && result.error ? result.error : { message: result.error ?? "Antigravity returned ERROR" };
+  let native = typeof result.error === "object" && result.error ? result.error : { message: result.error ?? "Antigravity returned ERROR" };
+  if (typeof result.error === "string" && /^AGY_ERROR\s*[: ]/.test(result.error)) {
+    try {
+      const envelope = JSON.parse(result.error.replace(/^AGY_ERROR\s*:?\s*/, ""));
+      const error = envelope.error ?? envelope;
+      if (error && typeof error === "object" && !Array.isArray(error)) native = error;
+    } catch { /* A malformed envelope remains a native failure, never evidence. */ }
+  }
   const category = classifyProviderError(native);
   const legacy = { provider_quota_exhausted: "agy_provider_quota_exhausted", provider_limit_unknown: "agy_provider_limit_unknown", provider_auth_failed: "agy_provider_account", provider_failed: "agy_provider_failed" };
   let code = result.status === "CANCELLED" ? "agy_turn_cancelled" : legacy[category] ?? category;
   // A local generation/usage count is not a native request identity.
   const identity = result.turn_id ?? result.request_id;
   const turn = typeof identity === "string" && identity ? identity : null;
-  const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited"].includes(category) && !turn;
+  const stream = streamRequestKey(metadata.request_proof);
+  const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited"].includes(category) && !turn && !stream;
   if (proofMissing) code = "provider_overload_evidence_unavailable";
   return new AgyError(code, String(native.message ?? "Antigravity returned ERROR"), code === "provider_capacity_transient" || code === "provider_rate_limited", {
     provider_result: result, ...metadata, provider_error: safeProviderError(native), native_source: "agy.result", terminal_status: result.status === "ERROR" ? "failed" : "cancelled",
@@ -57,6 +65,12 @@ export function observedProfile(init = {}, requested = {}) {
 
 export function assertProfile(requested, observed) { return checkObservedProfile(requested, observed, { required: requested.permission_mode ? ["permission_mode"] : [] }); }
 
+export function agyModelArgs(model, reasoning) {
+  const encoded = /^gemini-.+-(low|medium|high)$/.exec(model)?.[1];
+  if (encoded && encoded !== reasoning) throw new AgyError("agy_profile_invalid", "Requested reasoning conflicts with the selected Gemini model");
+  return ["--model", model, ...(encoded ? [] : ["--effort", reasoning])];
+}
+
 export async function doctor(options = {}) {
   const bin = options.bin ?? process.env.DD_AGY_BIN ?? "agy", temporary = await mkdtemp(path.join(os.tmpdir(), "dd-agy-doctor-"));
   try {

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

@@ -521,7 +521,7 @@ export class DroidRuntime {
     if (!this.config.ddFlowBin || payload.tool_name !== "Execute") return {};
     // Usage is ingested by inspect/turn completion, never ahead of admission.
     try {
-      return await this.flow("event", "handle", { schema_id: "dd-flow/droid-tool-event@1", phase: event === "PreToolUse" ? "before" : "after", event_id: eventId, daemon_id: this.config.daemonId, session: { provider_session_id: id, parent_provider_session_id: parent, directory: this.config.cwd }, tool: payload.tool_name, input: payload.tool_input, profile, transcript_path: native.transcript_path, outcome: { status: payload.tool_response?.is_error ? "error" : "completed" } }, budget.remaining("admission", 15_000));
+      return await this.flow("event", "handle", { schema_id: "dd-flow/droid-tool-event@1", phase: event === "PreToolUse" ? "before" : "after", event_id: eventId, daemon_id: this.config.daemonId, session: { provider_session_id: id, parent_provider_session_id: parent, directory: this.config.cwd }, tool: payload.tool_name, input: payload.tool_input, profile, transcript_path: native.transcript_path, outcome: { status: payload.tool_response?.is_error ? "error" : "completed" } }, budget.remaining("admission"));
     } catch (error) {
       if (event === "PreToolUse" && isProvenShellCorrection(error)) {
         const refusal = errorRecord(error);

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

@@ -187,8 +187,53 @@ export async function stopDaemon(options) { const timeoutMs = options.timeoutMs
 export class Runtime {
   constructor(paths, state, bridge, initialized) { this.paths = paths; this.state = state; this.bridge = bridge; this.initialized = initialized; this.sessions = new Map((state.sessions ?? []).map((item) => [item.provider_session_id, item])); this.descendants = new Map((state.descendants ?? []).map(child => [child.provider_session_id, child])); for (const session of this.sessions.values()) if (session.parent_provider_session_id && !this.descendants.has(session.provider_session_id)) this.descendants.set(session.provider_session_id, { provider_session_id: session.provider_session_id, parent_provider_session_id: session.parent_provider_session_id, status: "unknown", source: "legacy.daemon_state", outcome_error: { code: "native_child_outcome_unavailable", message: "Retained Grok child has no durable outcome receipt" } }); this.toolUsage = new Map(); this.loadedSessionId = null; this.active = null; this.server = null; this.ready = false; this.persisting = Promise.resolve(); }
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...this.sessions.values()], descendants: [...this.descendants.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.catch(() => {}).then(() => writeState(this.paths.state, snapshot)); return this.persisting; }
-  options(params) { const sessionId = params.sessionId; const session = sessionId ? this.sessions.get(sessionId) : null; const root = session?.root_provider_session_id ?? sessionId; return { ...this.state.config, ...params, cwd: params.cwd ?? session?.cwd ?? this.state.config.cwd, initialized: this.initialized, daemonId: this.state.daemon_id, rootProviderSessionId: root, toolUsage: this.toolUsage, allowBackground: true, liveSession: params.liveSession ?? Boolean(sessionId && sessionId === this.loadedSessionId) }; }
-  track(result, before = null) { if (!result?.provider_session_id) return; const session = this.sessions.get(result.provider_session_id); const root = result.parent_provider_session_id ? (this.sessions.get(result.parent_provider_session_id)?.root_provider_session_id ?? result.parent_provider_session_id) : (session?.root_provider_session_id ?? result.provider_session_id); this.sessions.set(result.provider_session_id, { native_root_receipt: session?.native_root_receipt ?? null, provider_session_id: result.provider_session_id, adapter_session_id: result.adapter_session_id ?? result.provider_session_id, parent_provider_session_id: result.parent_provider_session_id ?? session?.parent_provider_session_id ?? null, root_provider_session_id: root, cwd: result.cwd ?? result.target?.newCwd ?? result.info?.cwd ?? session?.cwd ?? null }); for (const child of this.running(result)) this.recordDescendant({ ...child, stale_activity: Boolean(before && before.get(child.sessionId ?? child.subagentId ?? child.provider_session_id) !== this.descendants.get(child.sessionId ?? child.subagentId ?? child.provider_session_id)) }, root, "x.ai/subagent/list_running", "running"); for (const child of result.descendants ?? []) this.recordDescendant(child, root, child.source ?? "x.ai/subagent/event", child.status ?? "unknown"); }
+  async reduceTerminal(outcome) {
+    const session = this.sessions.get(outcome.session_id), turn = session?.native_prompt_operation;
+    if (outcome.method !== "session/prompt" || !turn || typeof outcome.connection_id !== "string" || !outcome.connection_id
+      || !Number.isSafeInteger(outcome.request_id) || outcome.request_id < 1 || !Number.isSafeInteger(outcome.native_sequence) || outcome.native_sequence < 1 || turn.daemon_id !== this.state.daemon_id
+      || turn.connection_id !== outcome.connection_id || turn.operation_id !== outcome.operation_id || turn.generation !== outcome.generation
+      || turn.native_request_id !== outcome.request_id) return;
+    const message = outcome.terminal_response;
+    const kind = message?.error ? "failed" : message?.result?.stopReason;
+    if (!["failed", "end_turn", "cancelled"].includes(kind)) return;
+    const receipt = { kind, ...turn, request_id: outcome.request_id, native_sequence: outcome.native_sequence };
+    if (session.native_root_receipt && (session.native_root_receipt.kind !== kind || session.native_root_receipt.request_id !== outcome.request_id)) {
+      this.state.observation_error = { code: "native_terminal_outcome_conflict", message: "Conflicting native terminal outcomes for the same prompt" };
+      await this.persist();
+      throw new DaemonError(this.state.observation_error.code, this.state.observation_error.message);
+    }
+    if (session.native_root_receipt) return;
+    if (session.native_activity && session.native_activity.connection_id === outcome.connection_id && session.native_activity.sequence > outcome.native_sequence) {
+      return await this.invalidateTerminal(session);
+    }
+    session.native_root_receipt = receipt;
+    await this.persist();
+  }
+  async invalidateTerminal(session) {
+    session.native_root_receipt = null;
+    this.state.observation_error = { code: "native_activity_after_terminal", message: "Productive root activity followed its native terminal outcome" };
+    await this.persist();
+  }
+  async observeRootActivity(message, observation) {
+    const session = this.sessions.get(message?.params?.sessionId), turn = session?.native_prompt_operation;
+    if (!observation?.productive || !turn || session.parent_provider_session_id || turn.connection_id !== observation.connection_id) return;
+    if (session.native_activity?.connection_id !== observation.connection_id || session.native_activity.sequence < observation.sequence) session.native_activity = { connection_id: observation.connection_id, sequence: observation.sequence };
+    const receipt = session.native_root_receipt;
+    if (receipt?.connection_id === observation.connection_id && observation.sequence > receipt.native_sequence) await this.invalidateTerminal(session);
+  }
+  async drainTerminal() { await this.bridge.terminalOutcomes; await this.persisting; if (this.bridge.terminalProjectionError) throw this.bridge.terminalProjectionError; }
+  settledRoot(id) { return !this.active && !this.rootRunning({ provider_session_id: id }) && this.topology(id).every(child => !this.rootRunning({ provider_session_id: child.provider_session_id }) && !child.outcome_error && !child.activity_status); }
+  async restoreTerminals() {
+    if (!this.state.config?.journal) return;
+    let contents;
+    try { contents = await readFile(this.state.config.journal, "utf8"); } catch (error) { if (error.code === "ENOENT") return; throw error; }
+    for (const line of contents.split("\n").filter(Boolean)) {
+      const event = JSON.parse(line);
+      if (["native_terminal_outcome", "native_terminal_after_hook_failure"].includes(event.kind)) await this.reduceTerminal(event.payload);
+    }
+  }
+  options(params) { const sessionId = params.sessionId; const session = sessionId ? this.sessions.get(sessionId) : null; const root = session?.root_provider_session_id ?? sessionId; return { ...this.state.config, ...params, cwd: params.cwd ?? session?.cwd ?? this.state.config.cwd, initialized: this.initialized, daemonId: this.state.daemon_id, rootProviderSessionId: root, toolUsage: this.toolUsage, allowBackground: true, rootSettled: id => this.settledRoot(id), liveSession: params.liveSession ?? Boolean(sessionId && sessionId === this.loadedSessionId) }; }
+  track(result, before = null) { if (!result?.provider_session_id) return; const session = this.sessions.get(result.provider_session_id); const root = result.parent_provider_session_id ? (this.sessions.get(result.parent_provider_session_id)?.root_provider_session_id ?? result.parent_provider_session_id) : (session?.root_provider_session_id ?? result.provider_session_id); this.sessions.set(result.provider_session_id, { ...session, native_root_receipt: session?.native_root_receipt ?? null, provider_session_id: result.provider_session_id, adapter_session_id: result.adapter_session_id ?? result.provider_session_id, parent_provider_session_id: result.parent_provider_session_id ?? session?.parent_provider_session_id ?? null, root_provider_session_id: root, cwd: result.cwd ?? result.target?.newCwd ?? result.info?.cwd ?? session?.cwd ?? null }); for (const child of this.running(result)) this.recordDescendant({ ...child, stale_activity: Boolean(before && before.get(child.sessionId ?? child.subagentId ?? child.provider_session_id) !== this.descendants.get(child.sessionId ?? child.subagentId ?? child.provider_session_id)) }, root, "x.ai/subagent/list_running", "running"); for (const child of result.descendants ?? []) this.recordDescendant(child, root, child.source ?? "x.ai/subagent/event", child.status ?? "unknown"); }
   recordDescendant(value, root, source, fallback) {
     const id = value?.provider_session_id ?? value?.session_id ?? value?.sessionId ?? value?.childSessionId ?? value?.subagentId ?? value?.child_session_id ?? value?.subagent_id;
     const parent = value?.parent_provider_session_id ?? value?.parentSessionId ?? value?.parent_session_id ?? root;
@@ -302,13 +347,14 @@ export class Runtime {
     }
     return modelFacts;
   }
-  topology(root) { if (this.state.observation_error) { const error = this.state.observation_error; throw new DaemonError(error.code, error.message, false, error.details); } return [...this.descendants.values()].filter((child) => child.parent_provider_session_id === root); }
+  topology(root) { if (this.state.observation_error) { const error = this.state.observation_error; throw new DaemonError(error.code, error.message, false, error.details); } return [...this.descendants.values()].filter((child) => child.parent_provider_session_id === root || this.sessions.get(child.provider_session_id)?.root_provider_session_id === root); }
   observeToolCall(message) { this.toolObservations ??= new ToolObservations(); this.toolObservations.add(acpToolObservation(message, { harness: "grok-acp" })); const sessionId = message?.params?.sessionId; if (sessionId) this.toolUsage.set(sessionId, this.toolObservations.summary(sessionId)); }
   running(result) { return result?.evidence?.subagents?.subagents ?? result?.subagents?.subagents ?? []; }
   treeRunning(result) {
     const evidence = result?.evidence ?? result;
     const children = evidence?.subagents?.subagents;
-    return this.rootRunning({ ...result, ...evidence }) || !Array.isArray(children) || children.length > 0 || Boolean(evidence?.subagents?.observation_error);
+    return this.rootRunning({ ...result, ...evidence }) || !Array.isArray(children) || children.length > 0 || Boolean(evidence?.subagents?.observation_error)
+      || this.topology(result?.provider_session_id).some(child => this.rootRunning({ provider_session_id: child.provider_session_id }) || child.outcome_error || child.activity_status);
   }
   rootRunning(result) {
     const status = String(result?.info?.status ?? result?.info?.state ?? result?.info?.data?.status ?? "unknown").toLowerCase();
@@ -316,7 +362,7 @@ export class Runtime {
     // Grok may retire a completed child Session before session/info can be
     // inspected. A retained TaskOutput for that exact attempt is native
     // terminal proof; missing session/info alone is not.
-    if (status === "unknown" && child?.source === "x.ai/tool/TaskOutput" && !child.outcome_error && !child.activity_status
+    if (status === "unknown" && ["x.ai/tool/TaskOutput", "x.ai/subagent/event"].includes(child?.source) && child.attempt_id && !child.outcome_error && !child.activity_status
       && ["completed", "failed", "cancelled"].includes(child.status)) return false;
     // Grok 1.0.17 omits status from session/info. Only a durable native
     // creation/end_turn receipt can then establish an idle root. Dispatch
@@ -326,6 +372,7 @@ export class Runtime {
     return !["completed", "failed", "cancelled", "stopped", "idle"].includes(status);
   }
   async refreshTree(cancel = false) {
+    await this.drainTerminal();
     const running = [];
     for (const session of [...this.sessions.values()].filter(item => !item.parent_provider_session_id)) {
       const id = session.provider_session_id;
@@ -357,15 +404,21 @@ export class Runtime {
     const timer = setInterval(() => { void this.observeHookFailures(current).catch(error => current.reject(error)); }, 100);
     // Only a new native turn invalidates its own root proof. Creation, fork
     // and local archive export must not erase an unrelated Session's receipt.
-    if (name === "session.prompt" && this.sessions.has(sessionId)) this.sessions.get(sessionId).native_root_receipt = null;
+    if (name === "session.prompt" && this.sessions.has(sessionId)) {
+      const session = this.sessions.get(sessionId);
+      session.native_root_receipt = null;
+      this.bridge.dispatchGeneration = current.generation;
+      session.native_prompt_operation = { daemon_id: this.state.daemon_id, connection_id: this.bridge.connectionId, operation_id: operationId, generation: current.generation };
+    }
     try {
       await this.persist({ active_tree: true, active_operation: name });
       assertDaemonDispatch(this.paths?.dir);
       const before = new Map(this.descendants);
       const result = await Promise.race([task(), hookFailed]);
+      await this.drainTerminal();
       this.track(result, before);
       const session = this.sessions.get(result.provider_session_id);
-      if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id };
+      if (session && ["session.create", "session.fork"].includes(name)) session.native_root_receipt = { kind: "created", daemon_id: this.state.daemon_id };
       // Archive requires an idle tree before entering this exclusive section
       // and performs no native work. Its file receipt is not tree evidence.
       const running = name === "session.archive" ? false : this.treeRunning(result);
@@ -375,11 +428,7 @@ export class Runtime {
       // A matched JSON-RPC error completes this native prompt request. It is
       // root-turn proof, not proof that any descendants have stopped. A lost
       // response, bridge error, or failure before dispatch earns no receipt.
-      const response = error?.details?.terminal_response;
-      if (name === "session.prompt" && response?.method === "session/prompt" && response.session_id === sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) session.native_root_receipt = { kind: "failed", daemon_id: this.state.daemon_id, request_id: response.request_id };
-      }
+      try { await this.drainTerminal(); } catch (storage) { error.cleanup_error ??= errorRecord(storage); }
       try { await hookBudget(1_000, null).run(() => this.persist({ active_tree: true, active_operation: null }), "failure_persistence"); }
       catch (storage) { error.cleanup_error = errorRecord(storage); }
       throw error;
@@ -441,10 +490,11 @@ export class Runtime {
 
 export async function serveDaemon(stateDir) {
   const paths = locations(stateDir); const state = await readState(paths.dir); if (!state || state.schema_id !== STATE_SCHEMA) throw new DaemonError("daemon_state_missing", "daemon state is missing or incompatible"); let runtime;
-  const bridge = new AcpBridge({ ...state.config, initializeTimeoutMs: 60_000, commandArgs: ["agent", "--no-leader", "--always-approve", "--model", state.config.model, "--reasoning-effort", state.config.reasoning, "stdio"], env: isolatedEnv(state.config), clientInfo: { name: "dd-grok", version: "0.1.0" }, permission: "allow", onNotification: async (message) => {
+  const bridge = new AcpBridge({ ...state.config, initializeTimeoutMs: 60_000, commandArgs: ["agent", "--no-leader", "--always-approve", "--model", state.config.model, "--reasoning-effort", state.config.reasoning, "stdio"], env: isolatedEnv(state.config), clientInfo: { name: "dd-grok", version: "0.1.0" }, permission: "allow", onNotification: async (message, observation) => {
     const sessionId = message?.params?.sessionId;
     if (!runtime || !sessionId) return;
     try {
+      await runtime.observeRootActivity(message, observation);
       runtime.observeToolCall(message);
       for (const fact of runtime.observeSubagentEvent(message)) {
         const source = { channel: "x.ai/subagent_spawned", scope: "configured", attempt_id: fact.attemptId, parent_prompt_id: fact.parentPromptId,
@@ -463,6 +513,13 @@ export async function serveDaemon(stateDir) {
     const rootProviderSessionId = session?.root_provider_session_id ?? sessionId;
     await observeAcpToolCall(state.config, { daemonId: state.daemon_id, rootProviderSessionId, parentProviderSessionId: session?.parent_provider_session_id ?? null, observedProfile: bridge.modelProfiles?.get(sessionId) ?? {} }, message);
   } }); const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "grok-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log }); runtime = new Runtime(paths, state, bridge, initialized);
+  bridge.configure({ onTerminalOutcome: outcome => runtime.reduceTerminal(outcome), onPromptDispatch: async dispatch => {
+    const turn = runtime.sessions.get(dispatch.session_id)?.native_prompt_operation;
+    if (!turn || turn.operation_id !== dispatch.operation_id || turn.connection_id !== dispatch.connection_id || turn.generation !== dispatch.generation) throw new DaemonError("native_dispatch_binding_mismatch", "Native prompt dispatch differs from retained operation");
+    turn.native_request_id = dispatch.native_request_id;
+    await runtime.persist();
+  } });
+  await runtime.restoreTerminals();
   for (const fact of await readModelObservations(state.config.journal)) {
     if (fact.harness === "grok-acp" && fact.source?.channel === "x.ai/subagent_spawned" && runtime.sessions.has(fact.session_id)
       && (runtime.descendants.get(fact.session_id)?.attempt_id ?? null) === (fact.source.attempt_id ?? null) && fact.observed?.model) {

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

@@ -102,7 +102,7 @@ async function identity(bridge, options) {
   return sessionId;
 }
 
-async function cancelTree(bridge, sessionId) {
+async function cancelTree(bridge, sessionId, options = {}) {
   const before = await subagents(bridge, sessionId).catch(error => ({ observation_error: { code: error.code, message: error.message } })); const cancellations = [];
   for (const child of before.subagents ?? []) {
     const childId = child.sessionId ?? child.subagentId;
@@ -119,7 +119,10 @@ async function cancelTree(bridge, sessionId) {
     if (!(after.subagents ?? []).length) {
       const root = await sessionInfo(bridge, sessionId).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
       const status = root?.status ?? root?.state ?? root?.data?.status ?? null;
-      return { before, after, cancellations, root_status: status, settled: ["completed", "failed", "cancelled", "stopped", "idle"].includes(String(status).toLowerCase()) };
+      await bridge.terminalOutcomes;
+      const retained = options.rootSettled?.(sessionId) === true;
+      if (status === null && !retained) continue;
+      return { before, after, cancellations, root_status: status, settled: options.rootSettled ? retained : ["completed", "failed", "cancelled", "stopped", "idle"].includes(String(status).toLowerCase()) };
     }
   }
   const root = await sessionInfo(bridge, sessionId).catch(() => null);
@@ -163,7 +166,7 @@ export async function promptSessionWithBridge(bridge, options) {
 export async function inspectSession(options) { requireJournal(options); return await withBridge(options, async (bridge, initialized) => await inspectSessionWithBridge(bridge, { ...options, initialized })); }
 export async function inspectSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); const evidence = await inspect(bridge, sessionId, options); evidence.tool_calls = sessionToolCalls(options, bridge, sessionId); const usage_ingest_error = await forwardUsageBestEffort(options, sessionId, evidence.usage, evidence.tool_calls); if (usage_ingest_error) evidence.usage_ingest_error = usage_ingest_error; return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...evidence }); }
 export async function cancelSession(options) { requireJournal(options); return await withBridge(options, async (bridge) => await cancelSessionWithBridge(bridge, options)); }
-export async function cancelSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...await cancelTree(bridge, sessionId) }); }
+export async function cancelSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...await cancelTree(bridge, sessionId, options) }); }
 export async function forkSession(options) { requireJournal(options); return await withBridge(options, async (bridge) => await forkSessionWithBridge(bridge, options)); }
 export async function forkSessionWithBridge(bridge, options) {
   requireJournal(options); const sessionId = await identity(bridge, options); const target = options.target;

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

@@ -3,7 +3,7 @@ import { ToolObservations, acpToolObservation, zcodePhysicalSession } from "./to
 import { hookBudget, invokeNativeHook } from "./native-hook-command.mjs";
 import { parseLifecycleCommand, continuationCommand, commandOption } from "./lifecycle-command.mjs";
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from 'node:fs';
 import { publishSetup, SETUP_STARTUP_MS } from './setup-progress.mjs';
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
@@ -141,6 +141,10 @@ export class AcpBridge {
     this.expiredRequests = new Map();
     this.sessionActivity = new Map();
     this.notifications = Promise.resolve();
+    this.terminalOutcomes = Promise.resolve();
+    this.terminalRequests = new Map();
+    this.connectionId = randomUUID();
+    this.receivedSequence = 0;
     this.lifecycleNotifications = new Set();
     this.notificationError = null;
     this.bridgeStderr = "";
@@ -202,16 +206,27 @@ export class AcpBridge {
   receive(line) {
     let message;
     try { message = JSON.parse(line); } catch { this.journal.write("malformed", { line }); return; }
+    const observation = { connection_id: this.connectionId, sequence: ++this.receivedSequence, productive: isProductiveSessionNotification(message) };
     const request = message.id !== undefined ? this.pending.get(message.id) : null;
     const expired = message.id !== undefined ? this.expiredRequests.get(message.id) : null;
     const isResponse = message.id !== undefined && !message.method;
     const rejected = isResponse && this.rejectedHookRequests?.get(message.id);
-    if (rejected) {
-      this.rejectedHookRequests.delete(message.id);
-      const terminal = { request_id: message.id, method: rejected.method, session_id: rejected.sessionId, terminal_response: message };
+    if (rejected || isResponse && (request?.method === "session/prompt" || this.terminalRequests.has(message.id))) {
+      const owner = rejected ?? request ?? this.terminalRequests.get(message.id);
+      const terminal = { request_id: message.id, method: owner.method, session_id: owner.sessionId, terminal_response: message,
+        connection_id: this.connectionId, operation_id: owner.operationId ?? null, generation: owner.generation ?? null, native_sequence: observation.sequence };
+      this.terminalOutcomes = this.terminalOutcomes.then(async () => {
+        await this.journal.write(rejected ? "native_terminal_after_hook_failure" : "native_terminal_outcome", terminal);
+        await this.journal.flush();
+        await this.options.onTerminalOutcome?.(terminal);
+        this.terminalRequests.set(message.id, owner);
+        while (this.terminalRequests.size > 128) this.terminalRequests.delete(this.terminalRequests.keys().next().value);
+        if (rejected) this.rejectedHookRequests.delete(message.id);
+      });
+      void this.terminalOutcomes.catch(storage => { this.terminalProjectionError ??= storage; if (rejected) rejected.error.cleanup_error ??= errorRecord(storage); });
+      if (rejected) {
       rejected.error.details = { ...rejected.error.details, native_terminal_after_hook_failure: terminal };
-      try { void Promise.resolve(this.journal.write("native_terminal_after_hook_failure", terminal)).catch(storage => { rejected.error.cleanup_error ??= errorRecord(storage); }); }
-      catch (storage) { rejected.error.cleanup_error ??= errorRecord(storage); }
+      }
     }
     if (!isResponse || request) this.journal.writeInbound(message, request?.method);
     if (typeof message.params?.sessionId === "string" && isProductiveSessionNotification(message)) this.observeActivity(message.params.sessionId, message.params.update);
@@ -305,7 +320,7 @@ export class AcpBridge {
       return;
     }
     if (message.method) this.notifications = this.notifications
-      .then(async () => { await this.observeModelUpdate(message); await this.options.onNotification?.(message); })
+      .then(async () => { await this.observeModelUpdate(message); await this.options.onNotification?.(message, observation); })
       .catch(async (error) => {
         const failure = { code: error.code ?? "notification_observation_failed", message: error.message, ...(error.details ? { details: error.details } : {}), session_id: message.params?.sessionId ?? null, tool_call_id: message.params?.update?.toolCallId ?? null, event_time: now(), delivery_stage: "acp_evidence", completeness: "incomplete" };
         try { await this.journal.write("notification_failure", failure); }
@@ -405,6 +420,7 @@ export class AcpBridge {
   }
 
   request(method, params = {}, timeoutMs = 30_000, { idleSessionId = null, idleTimeoutMs = null, inactivityMode = "reject" } = {}) {
+    if (method === "session/prompt" && (this.rejectedHookRequests?.size ?? 0) + [...this.pending.values()].filter(request => request.method === "session/prompt").length >= 32) return Promise.reject(Object.assign(new Error("Unreconciled native terminal evidence limit reached"), { code: "native_terminal_evidence_pending" }));
     if (timeoutMs !== null) validateObservationDuration(timeoutMs);
     if (idleTimeoutMs !== null) validateObservationDuration(idleTimeoutMs);
     if ((this.lifecycleFailure || this.notificationError?.code === "profile_integrity_violation") && ["session/new", "session/prompt", "session/fork"].includes(method)) return Promise.reject(this.lifecycleFailure ?? this.notificationError);
@@ -467,9 +483,19 @@ export class AcpBridge {
           void this.journal.write("inactivity_observation_failure", { method, request_id: id, session_id: idleSessionId, error: { code: error?.code ?? "inactivity_observation_failed", message: error?.message ?? String(error) } }).catch(() => {});
         });
       }, Math.max(10, Math.min(1_000, Math.floor(validIdleTimeout / 4)))) : null;
-      this.pending.set(id, { id, resolve, reject, timer, idleTimer, method, sessionId: params.sessionId ?? null, dispatchedAt: Date.now(), publish: operationProgressReporter() });
-      this.send({ jsonrpc: "2.0", id, method, params });
-      if (method === "session/prompt") this.journal.write("native_dispatch", { operation_id: this.dispatchOperationId ?? process.env.DD_EVAL_OPERATION_ID ?? null, session_id: params.sessionId, native_request_id: id });
+      this.pending.set(id, { id, resolve, reject, timer, idleTimer, method, sessionId: params.sessionId ?? null, operationId: this.dispatchOperationId ?? process.env.DD_EVAL_OPERATION_ID ?? null, generation: this.dispatchGeneration ?? null, dispatchedAt: Date.now(), publish: operationProgressReporter() });
+      if (method === "session/prompt") {
+        void (async () => {
+          const dispatch = { operation_id: this.pending.get(id)?.operationId, session_id: params.sessionId, native_request_id: id,
+            connection_id: this.connectionId, generation: this.pending.get(id)?.generation };
+          await this.journal.write("native_dispatch_prepared", dispatch);
+          await this.journal.flush();
+          await this.options.onPromptDispatch?.(dispatch);
+          if (!this.pending.has(id) || this.pending.get(id).timedOut || this.lifecycleFailure) return;
+          this.send({ jsonrpc: "2.0", id, method, params });
+          await this.journal.write("native_dispatch", dispatch);
+        })().catch(finish);
+      } else this.send({ jsonrpc: "2.0", id, method, params });
     });
   }
 
@@ -488,14 +514,14 @@ export class AcpBridge {
   rejectAll(error) {
     for (const [id, pending] of this.pending) {
       if (this.notificationError === error && pending.method === "session/prompt") {
-        this.rejectedHookRequests ??= new Map(); this.rejectedHookRequests.set(id, { method: pending.method, sessionId: pending.sessionId, error });
-        if (this.rejectedHookRequests.size > 32) this.rejectedHookRequests.delete(this.rejectedHookRequests.keys().next().value);
+        this.rejectedHookRequests ??= new Map(); this.rejectedHookRequests.set(id, { method: pending.method, sessionId: pending.sessionId, operationId: pending.operationId, generation: pending.generation, error });
       }
       clearTimeout(pending.timer); if (pending.idleTimer) clearInterval(pending.idleTimer); pending.reject(error);
     }
     this.pending.clear();
   }
   async flush() {
+    await this.terminalOutcomes;
     if (this.notificationError) throw this.notificationError;
     try { await Promise.all([...this.lifecycleNotifications]); await this.notifications; await this.journal.flush(); }
     catch (error) { throw this.notificationError ?? error; }
@@ -507,6 +533,7 @@ export class AcpBridge {
     // Draining them must not relabel a successful physical shutdown as failed.
     return await closeBridgeProcess(this, async () => {
       await Promise.all([this.nativeDrain, this.diagnostics]);
+      await this.terminalOutcomes;
       await Promise.allSettled([...this.lifecycleNotifications, this.notifications]);
       if (this.notificationError) await hookBudget(1_000, null).run(() => this.journal.flush(), "failure_drain");
       else await this.journal.flush();
@@ -964,6 +991,7 @@ export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContrac
     native_nested_children: false, reason: qualified ? null : "native_event_contract_unqualified" };
 }
 
+let doctorDigestScanOrdinal = 0;
 export async function doctor(options = {}) {
   const zcodeAcp = await commandOutput(options.bin, ["--version"]);
   const zcodeAcpCommit = await commandOutput(options.bin, ["--dd-harness-commit"]);
@@ -971,11 +999,13 @@ export async function doctor(options = {}) {
   const zcodePath = options.zcodePath ?? process.env.ZCODE_BIN ?? process.env.ZCODE_PATH ?? "/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs";
   const zcode = await commandOutput(zcodePath, ["--version"]);
   const hash = createHash('sha256'); let bytes = 0;
+  const scan = `zcode-digest:${zcodePath}:scan-${++doctorDigestScanOrdinal}`;
+  publishSetup('probe_started', scan);
   for await (const chunk of createReadStream(zcodePath)) {
     hash.update(chunk); bytes += chunk.length;
-    if (bytes % (4 * 1024 * 1024) < chunk.length) publishSetup('identity_digest_progress', bytes);
+    if (bytes % (4 * 1024 * 1024) < chunk.length) publishSetup('identity_digest_progress', `${scan}:${bytes}`);
   }
-  const sha256 = hash.digest('hex'); publishSetup('identity_digest_completed');
+  const sha256 = hash.digest('hex'); publishSetup('identity_digest_completed', scan);
   const qualification = zcodeLifecycleQualification(sha256, zcodeAcpCommit, ddHarness);
   return { compatible: qualification.status === "qualified", contract_supported: supportedZcodeHarnessContract(ddHarness), lifecycle_qualification: qualification, observed_runtime: { zcode, zcode_acp: zcodeAcp, zcode_acp_commit: zcodeAcpCommit, dd_harness_contract: ddHarness } };
 }