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

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

@@ -3,11 +3,14 @@ import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-p
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { operationProgressReporter } from './operation-progress.mjs';
 import { prepareDaemonRequest } from "./native-request-proof.mjs";
+import { inspectAgyNative, stopAgyNativeTree, ownedAgyEndpoint, readAgyNativeQualification, AGY_NATIVE_INSPECTION_CONTRACT } from './agy-native-inspection.mjs';
+import { processSnapshot } from './process-snapshot.mjs';
+import { streamRequestKey } from './provider-overload-policy.mjs';
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
 import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
 import { ToolObservations, agyToolObservation, agyTranscriptObservations } from "./tool-observations.mjs";
 import { constants } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { createHash, randomUUID } from "node:crypto";
 import { appendFile, chmod, lstat, mkdir, open, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
@@ -19,14 +22,48 @@ 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 { settledNativeTree } from "./native-children.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, nativeExecutionReceipt } 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]) {
+// Only unambiguously correlated native tool results can introduce children or
+// classify services. This transcript format has no tool-call IDs: parallel
+// calls therefore retain unknown resources, never FIFO-derived authority.
+export function agyTranscriptFacts(text, source, sessionId) {
+  const children = [], resources = [], calls = [];
+  if (!source?.locator || !source?.sha256 || !sessionId) return { children, resources };
+  for (const line of text.trim().split('\n')) {
+    let event;
+    try { event = JSON.parse(line); } catch { return { children: [], resources: [] }; }
+    if (event.source !== 'MODEL') continue;
+    if (event.type === 'PLANNER_RESPONSE') { calls.length = 0; if (Array.isArray(event.tool_calls) && event.tool_calls.length === 1) calls.push(event.tool_calls[0]); continue; }
+    if (event.type !== 'GENERIC') continue;
+    const call = calls.shift(), content = typeof event.content === 'string' ? event.content : '';
+    const native_source = { ...source, step_index: event.step_index };
+    if (call?.name === 'invoke_subagent' && event.status === 'DONE') {
+      const match = content.match(/^Created At: [^\n]+\nCompleted At: [^\n]+\nCreated the following subagent:\n(\{[\s\S]*?\})\nThe subagent will send you a message/);
+      if (!match) continue;
+      try {
+        const child = JSON.parse(match[1]);
+        if (/^[\w-]+$/.test(child.conversationId) && typeof child.logAbsoluteUri === 'string') children.push({ provider_session_id: child.conversationId, parent_provider_session_id: sessionId, log_uri: child.logAbsoluteUri, workspace_uris: child.workspaceUris ?? [], status: 'unknown', native_source });
+      } catch { /* No partial/guessed native edge. */ }
+    }
+    if (event.status !== 'RUNNING') continue;
+    const task = content.match(/^Created At: [^\n]+\nTool is running as a background task with task id: ([\w-]+\/task-\d+)\n/);
+    if (!task || !task[1].startsWith(`${sessionId}/`)) continue;
+    let daemon = call?.name === 'run_command' ? call.args?.IsDaemon : null;
+    if (typeof daemon === 'string') { try { daemon = JSON.parse(daemon); } catch { daemon = null; } }
+    resources.push({ resource_id: task[1], provider_session_id: sessionId, classification: daemon === true ? 'support_service' : daemon === false ? 'required_work' : 'unknown', state: 'unknown', native_source,
+      ...(typeof daemon === 'boolean' ? { native_classification: { tool: 'run_command', IsDaemon: daemon } } : {}) });
+  }
+  return { children, resources };
+}
+export const agyTranscriptResources = (text, source, sessionId) => agyTranscriptFacts(text, source, sessionId).resources;
+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 +80,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;
@@ -171,7 +209,7 @@ export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 3
   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","livenessTimeoutMs"].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","nativeQualificationPath"].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.
@@ -181,6 +219,8 @@ export function retainedAgyState(previous, sessionId) {
   return {
     ...previous,
     unclaimed_activity: false,
+    native_resources_entries: [],
+    native_topology_error: null,
     retained_tree_settlement: { daemon_id: previous.daemon_id, session_id: sessionId, turn_generation: previous.turn_generation ?? 0, evidence: "verified_clean_daemon_shutdown" },
     session_observations: (previous.session_observations ?? []).map(([id, observation]) => [id, id === sessionId ? { ...observation, retained_stop: observation.stop ?? null, stop: null } : observation]),
     descendants: (previous.descendants ?? []).map(child => child.tree_settled === true ? child : { ...child, tree_settled: true, settlement_evidence: "prior_clean_daemon_shutdown", settlement_daemon_id: previous.daemon_id })
@@ -190,6 +230,7 @@ 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;
+  config.nativeQualificationPath = process.env.DD_AGY_NATIVE_QUALIFICATION ? absolute(process.env.DD_AGY_NATIVE_QUALIFICATION, 'DD_AGY_NATIVE_QUALIFICATION') : null;
   validateObservationDuration(config.livenessTimeoutMs);
   await prepareRuntimeOwner(config, paths.dir);
   assertDaemonRestartable(previous);
@@ -201,7 +242,7 @@ export async function startDaemon(options) {
   const version = (await runAgy(config.bin, ["--version"], { cwd: config.cwd, env: sanitizedEnv(config), timeoutMs: AGY_VERSION_TIMEOUT_MS })).stdout.trim();
   const resourceProcess = await registerDaemonProcess(config, { kind: "agy-daemon", owner: `agy:${path.basename(paths.dir)}`, operation: `agy-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
   const retained = retainedAgyState(previous, config.resumeSessionId);
-  await writeJson(paths.state, { schema_id: STATE_SCHEMA, daemon_id: config.daemonId, shutdown_state: "starting", active_tree: false, unclaimed_activity: retained.unclaimed_activity ?? false, retained_tree_settlement: retained.retained_tree_settlement ?? null, versions: { agy: version }, config, sessions: [], session_observations: retained.session_observations ?? [], descendants: retained.descendants ?? [], ...(Array.isArray(retained.tool_observations) ? { tool_observations: retained.tool_observations } : {}), tool_observation_gaps: retained.tool_observation_gaps ?? [], tool_calls: retained.tool_calls ?? [], completed_tool_steps: retained.completed_tool_steps ?? [], tool_identity_complete: retained.tool_identity_complete !== false, turn_generation: retained.turn_generation ?? 0, last_result: retained.last_result ?? null, resource_process: resourceProcess });
+  await writeJson(paths.state, { schema_id: STATE_SCHEMA, daemon_id: config.daemonId, shutdown_state: "starting", active_tree: false, unclaimed_activity: retained.unclaimed_activity ?? false, retained_tree_settlement: retained.retained_tree_settlement ?? null, versions: { agy: version }, config, sessions: [], session_observations: retained.session_observations ?? [], descendants: retained.descendants ?? [], native_resources_entries: retained.native_resources_entries ?? [], native_topology_error: retained.native_topology_error ?? null, ...(Array.isArray(retained.tool_observations) ? { tool_observations: retained.tool_observations } : {}), tool_observation_gaps: retained.tool_observation_gaps ?? [], tool_calls: retained.tool_calls ?? [], completed_tool_steps: retained.completed_tool_steps ?? [], tool_identity_complete: retained.tool_identity_complete !== false, turn_generation: retained.turn_generation ?? 0, last_result: retained.last_result ?? null, resource_process: resourceProcess });
   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);
@@ -222,10 +263,17 @@ export async function startDaemon(options) {
 export const stopDaemon = async 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(options.stateDir) }); };
 
 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"])]; }
+  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;
+    const saved = state.native_observation_episode;
+    if (saved?.clock) {
+      this.observationEpisode = { operationId: saved.operation_id, generation: saved.turn_generation, connectionId: saved.connection_id, terminalMetadata: state.last_terminal_metadata,
+        clock: new ObservationClock({ timeoutMs: saved.clock.timeout_ms, saved: saved.clock }) };
+      this.connectionId = saved.connection_id;
+    }
+  }
+  persist(patch = {}) { Object.assign(this.state, patch, { native_observation_episode: this.episodeSnapshot(), 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 = {}, 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", ...(this.nativeLogFile ? ['--log-file', this.nativeLogFile] : []), ...(this.nativeCsrfToken ? [`--csrf_token=${this.nativeCsrfToken}`] : []), `--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;
@@ -233,7 +281,7 @@ export class Runtime {
       harness: "antigravity-cli", expected_session_id: requestedId, observed_session_id: observedId
     });
   }
-  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); }); }
+  markActivity() { const current = this.active ?? this.observationEpisode; this.nativeRevision = (this.nativeRevision ?? 0) + 1; this.state.native_execution_revision = this.nativeRevision; this.nativeProof = null; this.nativeAbort?.abort(); this.lastActivityAt = new Date().toISOString(); this.progress = { cursor: (this.progress?.cursor ?? 0) + 1, observed_at: Date.now() }; current?.clock?.sample(this.progress); 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;
@@ -243,11 +291,12 @@ export class Runtime {
     current.terminalProgress.add(key); this.markActivity();
   }
   observeProviderActivity(event) {
-    if (!this.active) return;
+    const owner = this.active ?? this.observationEpisode;
+    if (!owner || owner.connectionId !== this.connectionId || owner.generation !== this.turnGeneration) 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; }
+    while (parent && parent !== root && !seen.has(parent)) { seen.add(parent); const child = this.descendants.get(parent); if (child?.activity_generation !== owner.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;
@@ -265,7 +314,7 @@ export class Runtime {
     // 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();
+    snapshots.add(fingerprint); this.progressSteps.set(id, { index, seen: snapshots }); this.invalidateSettlement(id); this.markActivity();
   }
   async start(sessionId = null) {
     if (this.drainingError) throw this.drainingError;
@@ -278,6 +327,11 @@ export class Runtime {
     await this.providerFinalization;
     if (this.drainingError) throw this.drainingError;
     assertDaemonDispatch(this.paths?.dir);
+    this.nativeAbort?.abort(); this.nativeProof = null;
+    this.nativeLogFile = path.join(this.paths.dir, `native-${randomUUID()}.log`);
+    this.nativeCsrfToken = randomUUID();
+    this.admissionClock = null;
+    this.nativeQualification = await readAgyNativeQualification(this.paths.dir, this.config.bin, this.config.nativeQualificationPath);
     const target = executable(this.config.bin, this.args(sessionId)); this.exited = false; this.buffer = ""; this.init = null;
     let readyResolve, readyReject; this.readyPromise = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject; });
     // The provider can reject before durable registration finishes.  Keep a
@@ -288,9 +342,10 @@ 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;
+    this.nativeLaunch = { logFile: this.nativeLogFile, providerPid: providerChild.pid, providerBirth: (await processSnapshot()).find(item => item.pid === providerChild.pid)?.started, connectionId: this.connectionId };
     let allowProviderFinalization;
     const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
     const observationFailure = error => { this.drainingError ??= error; readyReject(error); this.active?.reject(error); };
@@ -334,10 +389,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;
@@ -357,25 +409,53 @@ export class Runtime {
     // 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) });
+    if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...this.sessionObservations.get(sessionId), ...(step.step_index > (observation.last_step_index ?? -1) ? { last_execution_num: null } : {}), 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);
+      if (child.conversation_id === this.init?.conversation_id || prior && prior.parent_provider_session_id !== sessionId) {
+        this.state.native_topology_error = 'agy_native_ancestry_contradiction'; this.invalidateSettlement(sessionId); continue;
+      }
       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",
+        ...(bound && Number.isInteger(step.step_index) ? { native_source: { kind: 'agy.step_update.subagent_info', parent_provider_session_id: sessionId, step_index: step.step_index } } : {}),
         ...(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();
+    this.nativeResources ??= new Map(this.state.native_resources_entries?.map(item => [item.resource_id, item]) ?? []);
     const root = this.init?.conversation_id ?? this.state.sessions?.[0]?.provider_session_id ?? this.lastResult?.conversation_id;
-    for (const child of this.descendants.values()) {
+    const queue = root && this.paths.runtime ? [{ provider_session_id: root, parent_provider_session_id: root, log_uri: pathToFileURL(path.join(this.paths.runtime, 'brain', root, '.system_generated', 'logs', 'transcript.jsonl')).href }, ...this.descendants.values()] : [...this.descendants.values()];
+    const visited = new Set();
+    for (let index = 0; index < queue.length && index < 256; index++) {
+      const child = queue[index];
+      if (visited.has(child.provider_session_id)) continue;
+      visited.add(child.provider_session_id);
       const ancestors = new Set(); let parent = child.parent_provider_session_id;
       while (parent && parent !== root && this.descendants.has(parent) && !ancestors.has(parent)) {
         ancestors.add(parent); parent = this.descendants.get(parent).parent_provider_session_id;
       }
       const events = parent === root && root
-        ? await captureAgyTranscript(this.paths.runtime, child, root, [root, ...ancestors])
+        ? await captureAgyTranscript(this.paths.runtime, child, root, [root, ...ancestors], (text, source) => {
+          const facts = agyTranscriptFacts(text, source, child.provider_session_id);
+          for (const resource of facts.resources) this.nativeResources.set(resource.resource_id, resource);
+          for (const discovered of facts.children) {
+            const expected = path.join(this.paths.runtime, 'brain', discovered.provider_session_id, '.system_generated', 'logs', 'transcript.jsonl');
+            const sourceBrain = path.resolve(path.dirname(fileURLToPath(source.locator)), '../../..');
+            const sibling = path.join(sourceBrain, discovered.provider_session_id, '.system_generated', 'logs', 'transcript.jsonl');
+            let locator;
+            try { locator = fileURLToPath(discovered.log_uri); } catch { locator = null; }
+            if (locator !== expected && locator !== sibling) { this.state.native_topology_error = 'agy_native_locator_unbound'; this.invalidateSettlement(root); continue; }
+            const prior = this.descendants.get(discovered.provider_session_id);
+            if (discovered.provider_session_id === root || prior && (prior.parent_provider_session_id !== discovered.parent_provider_session_id || prior.log_uri && prior.log_uri !== discovered.log_uri)) {
+              this.state.native_topology_error = 'agy_native_ancestry_contradiction'; this.invalidateSettlement(root); continue;
+            }
+            const value = { ...discovered, ...prior, native_source: discovered.native_source };
+            this.descendants.set(value.provider_session_id, value);
+            queue.push(value);
+          }
+        })
         : [{ session: { harness_id: "antigravity-cli", session_id: child.provider_session_id }, reason: "agy_transcript_ancestry_unproven" }];
       for (const event of events) {
         this.toolObservations.add(event);
@@ -385,6 +465,8 @@ export class Runtime {
         this.capturedToolFacts.set(key, encoded);
       }
     }
+    if (queue.length > 256 && visited.size < new Set(queue.map(item => item.provider_session_id)).size) { this.state.native_topology_error = 'agy_native_inventory_limit'; this.invalidateSettlement(root); }
+    this.state.native_resources_entries = [...this.nativeResources.values()];
   }
   async finishTurn(result, retainedMetadata = null, providerEvent = null) {
     if (result.status === "RUNNING") { await this.persist({ active_tree: true }); return; }
@@ -399,26 +481,39 @@ 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";
     if (current) { current.terminalResult = result; current.terminalMetadata = terminalMetadata; current.terminalPersisted = false; }
-    if (pendingTerminal && rootStop?.fullyIdle === true) 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" });
+    if (pendingTerminal && rootStop?.source_bound === true && rootStop.fullyIdle === true) 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" });
     this.state.terminal_observation_pending = true;
     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()]); }
@@ -426,12 +521,23 @@ export class Runtime {
     try { await this.persist({ terminal_observation_pending: false }); }
     catch (error) { this.state.terminal_observation_pending = true; return this.failTerminalObservation(current, result, terminalMetadata, error); }
     this.state.terminal_observation_pending = false;
+    this.queueNativeInspection();
     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);
@@ -444,6 +550,7 @@ export class Runtime {
     const current = this.active;
     if (current?.observationError) throw current.observationError;
     if (current?.terminalResult?.status !== "SUCCESS" || current.terminalResult !== this.lastResult) return;
+    this.queueNativeInspection();
     await this.persist({ active_tree: !this.receipt().settled });
     // Hooks can invalidate the tree while persistence is pending. Never
     // publish a proof captured before that asynchronous boundary.
@@ -464,26 +571,127 @@ export class Runtime {
     if (current) { current.observationError = error; current.reject(error); }
     throw error;
   }
+  queueNativeInspection() {
+    const owner = this.active ?? this.observationEpisode, proof = owner?.terminalMetadata?.request_proof;
+    if (!owner?.clock || !proof || this.state.terminal_observation_pending || this.nativeFlight || this.nativeProof || this.exited) return;
+    if (proof.connection_id !== this.connectionId || proof.daemon_instance !== this.config.daemonId || proof.turn_generation !== this.turnGeneration || proof.operation_id !== owner.operationId || proof.session_id !== this.init?.conversation_id) { this.nativeInspection = { state: 'unproven', reason: 'native_owner_binding_changed' }; return; }
+    if (owner.clock.sample(this.progress)) { this.nativeInspection = { state: 'unproven', reason: 'observation_budget_exhausted' }; return; }
+    // The observer's raw wire result is never authority before P3 qualification.
+    if (!this.nativeObserver && !this.nativeQualification?.qualified) { this.nativeInspection = { state: 'unproven', reason: 'native_inspection_not_qualified' }; return; }
+    const revision = this.nativeRevision ?? 0, connection = this.connectionId;
+    const controller = this.nativeAbort = new AbortController();
+    let recording = false;
+    this.nativeInspection = { state: 'inspection_pending', reason: 'native_idle_barrier_pending' };
+    this.nativeFlight = Promise.resolve().then(async () => {
+      await owner.dispatchJournal;
+      const clock = owner.clock.state(), remainingMs = Math.max(0, clock.timeout_ms - clock.elapsed_ms);
+      if (!remainingMs || owner.clock.sample(this.progress)) throw new Error('observation_budget_exhausted');
+      const endpoint = this.nativeObserver ? null : await ownedAgyEndpoint(this.nativeLaunch);
+      const observed = await (this.nativeObserver ?? inspectAgyNative)({ endpoint, sessionId: proof.session_id, cwd: this.config.cwd, remainingMs, signal: controller.signal, rootRelation: this.nativeQualification?.rootRelation, csrfToken: this.nativeCsrfToken });
+      if (!this.nativeObserver && JSON.stringify(await ownedAgyEndpoint(this.nativeLaunch)) !== JSON.stringify(endpoint)) throw new Error('native_endpoint_changed');
+      const current = () => !controller.signal.aborted && this.connectionId === connection && (this.nativeRevision ?? 0) === revision && this.turnGeneration === owner.generation && this.observationEpisode === owner && !this.exited && !owner.clock.sample(this.progress);
+      if (!current()) return;
+      if (!observed.idle) { this.nativeInspection = { state: 'inspection_pending', reason: observed.reason ?? 'native_wait_pending' }; return; }
+      const candidate = { daemon_instance: this.config.daemonId, connection_id: connection, operation_id: owner.operationId, turn_generation: owner.generation, request_proof: proof, revision, method: observed.method, source: 'native_idle_barrier' };
+      recording = true;
+      await this.journal('native_tree_settlement', { proof: candidate });
+      if (!current()) return;
+      // Persist conservatively before publishing. A crash may require another
+      // read-only observation; no concurrent reader gets an uncommitted grant.
+      await this.persist({ active_tree: true });
+      if (!current()) return;
+      this.nativeProof = candidate;
+      this.state.native_execution_revision = revision;
+      this.state.unclaimed_activity = false;
+      this.projectNativeIdleChildren();
+      this.nativeInspection = { state: 'ready', reason: 'native_wait_fully_idle' };
+      this.state.active_tree = !this.receipt().settled;
+      await this.completePendingTurn();
+    }).catch(error => {
+      if (!controller.signal.aborted) {
+        this.nativeProof = null;
+        const transient = !recording && ['grpc_4', 'grpc_14'].includes(error.details?.reason) && !owner.clock.sample(this.progress);
+        this.nativeInspection = { state: transient ? 'inspection_pending' : 'unproven', reason: error.details?.reason ?? error.message ?? 'native_inspection_failed' };
+        if (recording && this.active === owner && owner.terminalResult) {
+          try { this.failTerminalObservation(owner, owner.terminalResult, owner.terminalMetadata, error); } catch { /* original prompt owns the typed failure */ }
+        }
+        if (recording) this.state.terminal_observation_pending = true;
+      }
+    })
+      .finally(() => { this.nativeFlight = null; });
+  }
+  projectNativeIdleChildren() {
+    for (const [id, child] of this.descendants) this.descendants.set(id, { ...child, ...(!['completed', 'failed', 'cancelled'].includes(child.status) ? { previous_native_status: child.status, status: 'settled_by_root' } : {}), ...(child.native_turn_items ? { native_turn_items: { ...child.native_turn_items, observed: true, pending: false } } : {}), tree_settled: true, settlement_evidence: 'native_idle_barrier' });
+  }
+  async reconcileRetainedAdmission() {
+    const retained = this.state.retained_tree_settlement;
+    const fresh = !this.lastResult;
+    if (this.active || this.receipt().settled || !fresh && (retained?.evidence !== 'verified_clean_daemon_shutdown' || retained.session_id !== this.init?.conversation_id)) return;
+    if (!this.nativeObserver && !this.nativeQualification?.qualified) return;
+    if (this.admissionFlight) return await this.admissionFlight;
+    const clock = this.admissionClock ??= new ObservationClock({ timeoutMs: SETUP_STARTUP_MS });
+    if (!clock || clock.sample()) throw new DaemonError('agy_native_inspection_unavailable', 'Retained AGY native admission budget exhausted');
+    const connection = this.connectionId, revision = this.nativeRevision ?? 0, generation = this.turnGeneration;
+    const controller = this.nativeAbort = new AbortController();
+    this.admissionFlight = (async () => {
+      const endpoint = this.nativeObserver ? null : await ownedAgyEndpoint(this.nativeLaunch);
+      const observed = await (this.nativeObserver ?? inspectAgyNative)({ endpoint, sessionId: this.init.conversation_id, cwd: this.config.cwd, remainingMs: Math.max(1, clock.timeoutMs - clock.elapsed), signal: controller.signal, rootRelation: this.nativeQualification?.rootRelation, csrfToken: this.nativeCsrfToken });
+      if (!this.nativeObserver && JSON.stringify(await ownedAgyEndpoint(this.nativeLaunch)) !== JSON.stringify(endpoint)) throw new DaemonError('agy_native_inspection_unavailable', 'AGY admission endpoint changed');
+      const current = () => !controller.signal.aborted && !this.exited && !this.active && !clock.sample() && this.connectionId === connection && this.turnGeneration === generation && (this.nativeRevision ?? 0) === revision;
+      if (!observed.idle || !current()) throw new DaemonError('agy_native_inspection_unavailable', 'AGY fresh native admission is unproven');
+      // Admission is not the old stream request: no invented operation/Turn or
+      // request proof. The old failed result remains historical diagnostics.
+      const candidate = { daemon_instance: this.config.daemonId, connection_id: connection, turn_generation: generation, revision, method: observed.method, source: 'native_idle_admission' };
+      await this.journal('native_idle_admission', { proof: candidate });
+      if (!current()) throw new DaemonError('agy_native_inspection_unavailable', 'AGY native admission changed during observation persistence');
+      await this.persist({ active_tree: true });
+      if (!current()) throw new DaemonError('agy_native_inspection_unavailable', 'AGY native admission changed during observation persistence');
+      this.nativeProof = candidate;
+      this.state.native_execution_revision = revision;
+      this.state.unclaimed_activity = false; this.projectNativeIdleChildren();
+      this.state.active_tree = !this.receipt().settled;
+    })().catch(error => { this.nativeProof = null; this.nativeInspection = { state: 'unproven', reason: error.details?.reason ?? error.code ?? 'native_admission_unproven' }; throw error; }).finally(() => { this.admissionFlight = null; });
+    return await this.admissionFlight;
+  }
+  episodeSnapshot() {
+    const owner = this.observationEpisode;
+    return owner?.clock ? { operation_id: owner.operationId, turn_generation: owner.generation, connection_id: owner.connectionId, clock: owner.clock.state() } : null;
+  }
   receipt(result = this.lastResult) {
     if (this.state.last_terminal_failure && !this.lastTerminalFailure) this.lastTerminalFailure = this.state.last_terminal_failure;
-    const terminalMetadata = this.active?.terminalResult === result ? this.active.terminalMetadata : this.state.last_result === result ? this.state.last_terminal_metadata : this.lastTerminalFailure && this.lastTerminalFailure.details?.provider_result?.error === result?.error
+    const metadata = this.active?.terminalResult === result ? this.active.terminalMetadata : this.state.last_result === result ? this.state.last_terminal_metadata : 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 terminalMetadata = metadata?.request_proof && (metadata.request_proof.connection_id !== this.connectionId || metadata.request_proof.daemon_instance !== this.config.daemonId)
+      ? { ...metadata, request_proof: undefined } : metadata;
     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));
-    // A terminal root result is the provider's authoritative end-of-turn
-    // observation when AGY does not emit a root Stop hook.  A received
-    // non-idle Stop still wins, and every discovered child must be terminal.
-    const rootSettled = observation?.stop?.fullyIdle !== false;
+    // SUCCESS can coexist with background tasks. Only a current native idle
+    // proof (or verified prior clean retirement before new activity) closes it.
+    const retained = this.state.retained_tree_settlement;
+    const rootSettled = this.nativeProof?.turn_generation === this.turnGeneration && this.nativeProof.connection_id === this.connectionId && this.nativeProof.revision === (this.nativeRevision ?? 0)
+      || observation?.stop?.source_bound === true && observation.stop?.fullyIdle === true && observation.stop.generation === this.turnGeneration
+      || retained?.evidence === "verified_clean_daemon_shutdown" && retained.session_id === root && retained.turn_generation === this.turnGeneration && !this.child;
     const terminalPending = this.active?.terminalResult === result;
-    const settled = Boolean(!this.state.terminal_observation_pending && !this.active?.observationError && !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, ...(terminalMetadata.turn_id ? { terminal_turn_id: terminalMetadata.turn_id } : {}) } : {}), ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], ...settledNativeTree(root, [...this.descendants.values()], settled, !this.state.unclaimed_activity && (!this.active || terminalPending) && rootSettled && ["SUCCESS", "ERROR", "CANCELLED"].includes(result?.status)), transcript_path: observation?.transcript_path ?? null, settled };
+    // A positively inspected owned scope before its first Turn has no model
+    // result to manufacture. Native admission alone proves this empty execution.
+    const emptyExecution = !result && this.turnGeneration === 0 && !this.active && !this.descendants.size && this.nativeProof?.source === 'native_idle_admission';
+    const executionTerminal = emptyExecution || result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status);
+    const settled = Boolean(!this.state.native_topology_error && !this.state.terminal_observation_pending && !this.active?.observationError && !this.state.unclaimed_activity && (!this.active || terminalPending) && executionTerminal && treeSettled && rootSettled);
+    const clock = this.observationEpisode?.clock;
+    if (clock) clock.sample(this.progress);
+    const exhausted = clock && (clock.observationLost || clock.elapsed >= clock.timeoutMs);
+    const nativeSettlement = { confirmed: Boolean(settled), state: settled ? 'ready' : exhausted ? 'unproven' : this.nativeInspection?.state ?? 'unproven', reason: settled ? 'current_root_idle_proven' : exhausted ? 'observation_budget_exhausted' : this.nativeInspection?.reason ?? 'current_root_idle_proof_missing', capability: AGY_NATIVE_INSPECTION_CONTRACT, operation_id: terminalMetadata?.request_proof?.operation_id, request_key: streamRequestKey(terminalMetadata?.request_proof), provider_session_id: root, daemon_instance: this.config.daemonId, connection_epoch: this.connectionId, generation: this.turnGeneration, ...(this.nativeProof ? { source: this.nativeProof.source, method: this.nativeProof.method, proof_sha256: createHash('sha256').update(JSON.stringify(this.nativeProof)).digest('hex') } : {}), ...(clock ? { observation_clock: clock.state() } : {}) };
+    return nativeExecutionReceipt({ 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, ...(terminalMetadata.turn_id ? { terminal_turn_id: terminalMetadata.turn_id } : {}) } : {}), ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], ...settledNativeTree(root, [...this.descendants.values()], settled, !this.state.unclaimed_activity && (!this.active || terminalPending) && rootSettled && ["SUCCESS", "ERROR", "CANCELLED"].includes(result?.status)), native_turn_items: { observed: Boolean(terminalMetadata?.request_proof), possible_effects: true, pending: !settled, settled, ...(terminalMetadata?.request_proof ? { request_proof: terminalMetadata.request_proof } : {}) }, transcript_path: observation?.transcript_path ?? null, settled, native_settled: settled, physical_stopped: this.exited === true, native_settlement: nativeSettlement, }, { daemonId: this.config.daemonId, generation: this.turnGeneration, revision: this.nativeRevision ?? 0, resources: { coverage: "partial", entries: [...(this.nativeResources?.values() ?? this.state.native_resources_entries ?? [])] } });
   }
   async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
   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.nativeObserver && !this.nativeQualification?.qualified && this.config.bin && this.paths.dir) this.nativeQualification = await readAgyNativeQualification(this.paths.dir, this.config.bin, this.config.nativeQualificationPath);
+    if (!this.nativeObserver && !this.nativeQualification?.qualified) throw new DaemonError('agy_native_inspection_unqualified', 'AGY whole-tree inspection requires a matching native qualification receipt before productive dispatch', false, { capability: AGY_NATIVE_INSPECTION_CONTRACT });
+    await this.reconcileRetainedAdmission();
     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");
@@ -491,7 +699,11 @@ 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 };
+    this.nativeAbort?.abort(); this.nativeProof = null; this.nativeInspection = null;
+    current.clock = new ObservationClock({ timeoutMs: livenessTimeoutMs, onGap: gap => { void this.journal('observation_gap', { gap, operation_id: operationId }).catch(() => {}); } });
+    this.observationEpisode = current;
     let resolveDispatchJournal;
     const dispatchJournal = current.dispatchJournal = new Promise(resolve => { resolveDispatchJournal = resolve; });
     this.promptObservation = current;
@@ -504,6 +716,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 +724,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();
         });
@@ -524,9 +738,10 @@ export class Runtime {
       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(() => {}); } });
+    const clock = current.clock;
     let checking = false;
     const timer = setInterval(() => {
+      if (this.active === current && current.terminalResult && this.nativeInspection?.state === 'inspection_pending' && !this.nativeFlight) this.queueNativeInspection();
       if (this.active !== current || checking || !clock.sample(this.progress)) return;
       checking = true; const cursor = this.progress?.cursor;
       void this.completePendingTurn().then(() => {
@@ -552,24 +767,67 @@ export class Runtime {
         });
       }
       return result;
+    } catch (error) {
+      await dispatchJournal;
+      if (error.code === "native_outcome_observation_failed") throw error;
+      if (current.dispatchObservationError) {
+        if (!current.terminalResult) throw current.dispatchObservationError;
+        const cause = current.dispatchObservationError;
+        const failed = current.terminalResult.status === 'SUCCESS'
+          ? new DaemonError('native_outcome_observation_failed', 'Antigravity completed natively but its dispatch journal could not be saved', false, { native_outcome: this.receipt(current.terminalResult), settled: false, observation_error: errorRecord(cause) })
+          : agyTerminalFailure(current.terminalResult, { ...current.terminalMetadata, native_outcome: current.terminalResult, settled: false, native_turn_items: { observed: false, possible_effects: true, pending: true }, observation_error: errorRecord(cause) });
+        failed.cause = cause.cause ?? cause;
+        current.observationError = failed; current.dispatchObservationError = failed;
+        this.drainingError = failed; this.state.terminal_observation_pending = true;
+        if (current.terminalResult.status !== 'SUCCESS') this.lastTerminalFailure = failed;
+        throw failed;
+      }
+      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;
     }
   }
   childActivity(sessionId) {
+    this.invalidateSettlement(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 });
   }
+  invalidateSettlement(sessionId) {
+    this.nativeProof = null; this.nativeRevision = (this.nativeRevision ?? 0) + 1; this.nativeAbort?.abort();
+    this.state.native_execution_revision = this.nativeRevision;
+    if (this.init) this.state.active_tree = true;
+    this.state.retained_tree_settlement = null;
+    for (const id of new Set([this.init?.conversation_id, sessionId])) {
+      const observation = this.sessionObservations.get(id);
+      if (observation?.stop) this.sessionObservations.set(id, { ...observation, stop: null });
+    }
+  }
   async childForHook(conversationId) {
     if (conversationId === this.init?.conversation_id) return null;
+    await this.captureChildTools();
     const deadline = Date.now() + 1_000;
-    while (!this.descendants.has(conversationId) && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 10));
+    while (!this.descendants.has(conversationId) && Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 25)); await this.captureChildTools(); }
     const child = this.descendants.get(conversationId);
     if (!child) throw new DaemonError("agy_child_identity_unconfirmed", "Antigravity hook has no confirmed native parent", true, { conversation_id: conversationId });
-    if (child.parent_provider_session_id !== this.init?.conversation_id) throw new DaemonError("agy_child_parent_unqualified", "Nested Antigravity worker is not a direct child of the controlled Session", false, { conversation_id: conversationId, parent_conversation_id: child.parent_provider_session_id });
+    const seen = new Set([conversationId]); let current = child;
+    while (current.parent_provider_session_id !== this.init?.conversation_id) {
+      const parent = this.descendants.get(current.parent_provider_session_id);
+      if (this.state.native_topology_error || !current.native_source || !parent || seen.has(parent.provider_session_id)) throw new DaemonError("agy_child_parent_unqualified", "Antigravity worker has no source-bound ancestry to the controlled Session", false, { conversation_id: conversationId, parent_conversation_id: current.parent_provider_session_id });
+      seen.add(parent.provider_session_id); current = parent;
+    }
+    if (this.state.native_topology_error) throw new DaemonError("agy_child_parent_unqualified", "Antigravity native ancestry is contradictory");
     return child;
   }
   async rejectHook(error, event, payload, current = this.active) {
@@ -603,10 +861,45 @@ 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"); 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;
+  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 stale = step !== null && (Number.isInteger(prior.step_floor) && step <= prior.step_floor
+      || Number.isInteger(prior.last_step_index) && step < prior.last_step_index
+      || step === prior.last_step_index && execution !== null && Number.isInteger(prior.last_execution_num) && execution < prior.last_execution_num);
+    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 (event === "Stop" && prior.last_stop_hook === fingerprint && prior.last_stop_generation === this.turnGeneration) return { stale: true };
+    this.progressHooks ??= new Set();
+    const scoped = this.active && (!child || child.activity_generation === this.active.generation);
+    const sourceBound = Boolean(scoped && step !== null && step > (this.active.stepFloor ?? -1)
+      && this.progressSteps?.get(conversationId)?.index === step);
+    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) this.sessionObservations.set(conversationId, { ...prior,
+      ...(step !== null ? { last_step_index: step, last_execution_num: execution ?? (step === prior.last_step_index ? prior.last_execution_num : null) } : {}),
+      last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}),
+      ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}),
+      ...(event === "Stop" ? { last_stop_hook: fingerprint, last_stop_generation: this.turnGeneration, stop: { fullyIdle: payload.fullyIdle === true, source_bound: sourceBound, terminationReason: payload.terminationReason ?? null, executionNum: execution } } : {}) });
+    if (event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId);
+    if (child && event === "Stop" && sourceBound && 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 && event === "Stop" && sourceBound && 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;
+    if (event === "Stop" && !stale) {
+      const observation = this.sessionObservations.get(conversationId);
+      this.sessionObservations.set(conversationId, { ...observation, stop: { ...observation.stop, generation: this.turnGeneration } });
+    }
     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`); }
+    this.queueNativeInspection();
+    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;
@@ -633,19 +926,40 @@ export class Runtime {
   }
   async prepareStop(cancelTree) {
     const current = this.active, priorResult = this.lastResult;
-    const emptyTree = !current && !this.state.active_tree && !this.state.unclaimed_activity && !priorResult && !this.descendants.size;
-    if (cancelTree) await this.cancel();
+    if (!cancelTree && !current && !priorResult) await this.reconcileRetainedAdmission();
+    if (cancelTree && (this.active || !this.receipt().settled)) await this.cancel();
     else if (this.active || this.state.active_tree || this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled)) throw new DaemonError("tree_not_settled", "Antigravity root or child tree is still running");
     // A physical kill is settlement, not a native clean terminal receipt.
     // In particular, the previous Turn's SUCCESS cannot certify a cancelled
     // in-flight Turn that exited without its own result.
     const currentResult = !current || current.terminalResult === this.lastResult || this.lastResult !== priorResult;
-    const clean = emptyTree || (currentResult && this.receipt().settled);
-    return { clean, ...(clean ? {} : { native_settlement: { confirmed: false, reason: "native_terminal_unconfirmed" } }) };
+    if (currentResult && this.receipt().settled) await this.retireNativeServices();
+    const clean = currentResult && this.receipt().settled;
+    return { ...this.receipt(), clean, settled: Boolean(clean), native_settled: Boolean(clean), ...(clean ? {} : { native_settlement: { confirmed: false, reason: "native_terminal_unconfirmed" } }) };
+  }
+  async retireNativeServices() {
+    const services = [...(this.nativeResources?.values() ?? [])].filter(item => item.classification === 'support_service' && item.state !== 'stopped');
+    // Unknown classification/unsupported binaries keep the existing cleanup
+    // blocker. A fixture PID printed to stdout is never a production mapping.
+    if (!services.length || !this.nativeQualification?.qualified) return;
+    const revision = this.nativeRevision ?? 0;
+    const endpoint = this.nativeStopper ? null : await ownedAgyEndpoint(this.nativeLaunch);
+    const input = { endpoint, sessionId: this.init.conversation_id, cwd: this.config.cwd,
+      csrfToken: this.nativeCsrfToken, remainingMs: 10_000, rootRelation: this.nativeQualification.rootRelation };
+    const stopped = await (this.nativeStopper ?? stopAgyNativeTree)(input, [...this.descendants.keys()]);
+    const observed = await (this.nativeObserver ?? inspectAgyNative)(input);
+    if (!this.nativeStopper && !isDeepStrictEqual(await ownedAgyEndpoint(this.nativeLaunch), endpoint)
+      || !observed.idle || revision !== (this.nativeRevision ?? 0) || !this.receipt().settled)
+      throw new DaemonError('native_resources_unproven', 'AGY native service retirement lost its owner/execution fence');
+    // This is native handle retirement, not physical cleanup. Shared shutdown
+    // still re-observes the retained local PID/birth inventory after close.
+    for (const service of services) this.nativeResources.set(service.resource_id, { ...service, state: 'stopped',
+      native_retirement: { method: stopped.method, stopped_session_ids: stopped.stopped_session_ids, revision } });
+    await this.persist({ native_resources_entries: [...this.nativeResources.values()] });
   }
-  async cancel() { cancelPendingDispatch(this); if (!this.child) return { ...this.receipt(), settled: Boolean(this.exited) }; if (!this.exited) { try { process.kill(-this.child.pid, "SIGINT"); } catch (error) { if (error.code !== "ESRCH") throw error; } const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) await stopProcessGroup(this.child, 5_000); } await this.finalizeProviderForControl(); await this.persist({ active_tree: false }); return { ...this.receipt(), cancelled: true, settled: Boolean(this.exited) };
+  async cancel() { if (!this.active && this.receipt().settled) return { ...this.receipt(), cancelled: true }; this.nativeAbort?.abort(); this.nativeProof = null; this.nativeRevision = (this.nativeRevision ?? 0) + 1; this.state.native_execution_revision = this.nativeRevision; cancelPendingDispatch(this); if (!this.child) return this.receipt(); if (!this.exited) { try { process.kill(-this.child.pid, "SIGINT"); } catch (error) { if (error.code !== "ESRCH") throw error; } const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) await stopProcessGroup(this.child, 5_000); } await this.finalizeProviderForControl(); await this.persist({ active_tree: false }); return { ...this.receipt(), cancelled: true };
   }
-  async close(cancelTree) { if (cancelTree) cancelPendingDispatch(this); if (!cancelTree && !this.exited && (this.active || this.state.active_tree || this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled))) throw new DaemonError("tree_not_settled", "Antigravity root or child tree is still running"); if (cancelTree) await this.cancel(); else if (this.child && !this.exited) this.child.stdin.end(); const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) await this.cancel(); await this.finalizeProviderForControl(); }
+  async close(cancelTree) { if (cancelTree) cancelPendingDispatch(this); if (!cancelTree && !this.exited && (this.active || this.state.active_tree || this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled))) throw new DaemonError("tree_not_settled", "Antigravity root or child tree is still running"); if (cancelTree) await this.cancel(); else if (this.child && !this.exited) this.child.stdin.end(); const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) { if (!this.active && this.receipt().settled) await stopProcessGroup(this.child, 5_000); else await this.cancel(); } await this.finalizeProviderForControl(); }
   async abortProvider(reason) {
     const child = this.child, providerProcess = this.providerProcess;
     await stopProcessGroup(child);
@@ -700,7 +1014,7 @@ async function dispatch(runtime, request) {
   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, 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.inspect") { runtime.requireSessionIdentity(params.sessionId); await runtime.captureChildTools(); void runtime.reconcileRetainedAdmission().catch(error => { runtime.nativeInspection = { state: 'unproven', reason: error.details?.reason ?? error.code ?? 'native_admission_unproven' }; }); runtime.queueNativeInspection(); await runtime.persist({ native_observation_episode: runtime.episodeSnapshot() }); 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(); }
   if (request.operation === "hook.observe") {