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

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-codex-daemon.mjs

@@ -7,12 +7,13 @@ import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mj
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import net from "node:net";
-import { durableDaemonDispatch, completeDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
+import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import { ObservationClock } from "./observation-clock.mjs";
 import { parseCapacityOperation } from "./provider-overload-policy.mjs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { waitForSettlement } from "./session-settlement.mjs";
+import { nativeExecutionReceipt } from "./native-children.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { CODEX_REQUEST_TIMEOUT_MS, LATE_RESPONSE_GRACE_MS, CodexBridge, codexReadPhase, readCodexHistory, retainedCodexTurn, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
 import { assertDaemonOwnership, assertStartupChild, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
@@ -77,7 +78,7 @@ export async function inspectCodexTree(bridge, options, { remember = () => {}, a
   options = { ...options, readPhase: options.readPhase ?? codexReadPhase(bridge, options) };
   const sessions = new Set([options.sessionId]);
   const observed = await observeCodexSessions(bridge, options, sessions, active, remember);
-  return { ...observed.observations[0], settled: !observed.active && !observed.sessions.length, unsettled_sessions: observed.sessions, tree_session_ids: [...sessions], tree_observations: observed.observations.map(item => ({ provider_session_id: item.provider_session_id, status: item.status, settled: item.settled })) };
+  return nativeExecutionReceipt({ ...observed.observations[0], settled: !observed.active && !observed.sessions.length, unsettled_sessions: observed.sessions, tree_session_ids: [...sessions], tree_observations: observed.observations.map(item => ({ provider_session_id: item.provider_session_id, status: item.status, settled: item.settled })) }, { daemonId: options.daemonId });
 }
 
 export async function cancelCodexTree(bridge, options, { remember = () => {}, active = () => null, timeoutMs = 5_000 } = {}) {
@@ -120,32 +121,44 @@ export async function startDaemon(options) {
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(locations(options.stateDir).state) }); }
 
+export async function prepareCodexStop({ bridge, state, sessions, active, save, stateDir, cancelTree }) {
+  if (cancelTree) cancelPendingDispatch(bridge);
+  if (active() && !cancelTree) throw Object.assign(new Error("productive operation is running"), { code: "tree_not_settled" });
+  let revision;
+  await waitForSettlement({
+    knownSessions: () => [...sessions],
+    observe: () => { revision = state.native_execution_revision; return observeCodexSessions(bridge, state.config, sessions, active); },
+    ...(cancelTree ? { cancel: async sessionId => { try { await cancelSessionWithBridge(bridge, { ...state.config, sessionId }); } catch (error) { if (error.code !== "turn_not_active") throw error; } } } : {})
+  });
+  if (active() || state.native_execution_revision !== revision) throw Object.assign(new Error("native activity changed during settlement observation"), { code: "tree_not_settled" });
+  commitDaemonShutdown(stateDir);
+  await save({ active_tree: false });
+  return { clean: true, settled: true, native_settled: true, native_settlement: { confirmed: true, revision } };
+}
+
 export async function serveDaemon(stateDir) {
   const paths = locations(stateDir); const state = await readState(paths.state); if (!state || state.schema_id !== stateSchema) throw Object.assign(new Error("daemon state missing"), { code: "daemon_state_missing" });
   const bridge = new CodexBridge({ ...state.config, env: { ...codexBridgeEnv(state.config, state.daemon_id), CODEX_HOME: process.env.CODEX_HOME, DD_FLOW_CODEX_STATE_DIR: paths.dir } }); await startManagedBridge({ config: state.config, state, bridge, kind: "codex-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log }); const sessions = new Set(state.sessions ?? []); let active = null; let server; let persist = Promise.resolve();
   scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
   const save = (patch = {}) => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...sessions] }); const snapshot = structuredClone(state); persist = persist.catch(() => {}).then(() => writeState(paths.state, snapshot)); return persist; };
+  bridge.options.onNativeActivity = () => {
+    state.native_execution_revision = (state.native_execution_revision ?? 0) + 1;
+    if (state.active_tree !== true) void save({ active_tree: true }).catch(error => { bridge.rejectAll(error); });
+  };
   const dispatch = async (operation, params, operationId) => {
     const assertDispatch = captureDispatchGuard(bridge);
     if (operation === "hook.verify") {
       if (params.daemonId !== state.daemon_id) throw Object.assign(new Error("Hook daemon identity differs"), { code: "native_hook_unproven" });
       return { ...bridge.verifyNativeHook(params), daemonId: state.daemon_id, ddFlowHome: state.config.ddFlowHome, projectRoot: state.config.projectRoot };
     }
-    if (operation === "daemon.status") return { daemon_id: state.daemon_id, pid: process.pid, cwd: state.cwd, journal: state.journal, config: state.config, sessions: [...sessions], active_operation: active, shutdown_state: state.shutdown_state };
+    if (operation === "daemon.status") return { daemon_id: state.daemon_id, pid: process.pid, cwd: state.cwd, journal: state.journal, config: state.config, sessions: [...sessions], active_operation: active, active_tree: state.active_tree ?? null, shutdown_state: state.shutdown_state };
     // The runner may need to retire an orphaned daemon after its caller was
     // interrupted. `daemon.stop` is the one control operation that remains
     // available while a request is marked active; callers must first prove the
     // provider Session itself is idle.
     if (operation === "daemon.stop") {
       return await completeDaemonShutdown(paths.dir, state, save, async () => {
-      if (params.cancelTree) cancelPendingDispatch(bridge);
-      if (active && !params.cancelTree) throw Object.assign(new Error("productive operation is running"), { code: "tree_not_settled" });
-      await waitForSettlement({
-        knownSessions: () => [...sessions],
-        observe: () => observeCodexSessions(bridge, state.config, sessions, () => active),
-        ...(params.cancelTree ? { cancel: async sessionId => { try { await cancelSessionWithBridge(bridge, { ...state.config, sessionId }); } catch (error) { if (error.code !== "turn_not_active") throw error; } } } : {})
-      });
-      return { clean: true };
+      return await prepareCodexStop({ bridge, state, sessions, active: () => active, save, stateDir: paths.dir, cancelTree: params.cancelTree });
       }, [
         ["provider", () => bridge.close()],
         ["provider_resource", () => finishDaemonProcess(state.config, state.provider_process)],
@@ -154,7 +167,7 @@ export async function serveDaemon(stateDir) {
     }
     if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume"].includes(operation)) assertDaemonDispatch(paths.dir);
     if (active && !["session.inspect", "session.cancel"].includes(operation)) throw Object.assign(new Error(`${active} is in progress`), { code: "operation_busy", retryable: true });
-    if (operation === "session.create") { active = operation; try { await save({ active_operation: active }); const result = await createSessionWithBridge(bridge, { ...state.config, ...params }); sessions.add(result.provider_session_id); return result; } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.create") { active = operation; try { await save({ active_operation: active, active_tree: true }); const result = await createSessionWithBridge(bridge, { ...state.config, ...params }); sessions.add(result.provider_session_id); return result; } finally { active = null; await save({ active_operation: null }); } }
     if (operation === "session.prompt") {
       parseCapacityOperation(operationId);
       // Admission can wait for a permit. Observe again after it returns, not
@@ -163,6 +176,7 @@ export async function serveDaemon(stateDir) {
       // journal entries and must not both pass the idle check while inspecting.
       active = operation;
       try {
+        await save({ active_operation: active, active_tree: true });
         const tree = await inspectCodexTree(bridge, { ...state.config, ...params });
         assertDispatch();
         if (tree.settled !== true) throw Object.assign(new Error("native Session tree changed while waiting for admission"), { code: "tree_not_settled", details: { provider_session_id: params.sessionId, unsettled_sessions: tree.unsettled_sessions } });
@@ -173,7 +187,7 @@ export async function serveDaemon(stateDir) {
       }
       finally { active = null; await save({ active_operation: null }); }
     }
-    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch, operationId }); } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active, active_tree: true }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch, operationId }); } finally { active = null; await save({ active_operation: null }); } }
     if (operation === "session.inspect" || operation === "session.resume") {
       const owned = new Set(sessions);
       for (const id of owned) for (const child of bridge.directChildren?.(id) ?? []) owned.add(child.provider_session_id);

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

@@ -180,6 +180,10 @@ export class CodexBridge {
 
   receive(line) {
     let message; try { message = JSON.parse(line); } catch { this.journal.write("malformed", { line }); return; }
+    // Read-induced idle/status notifications are not new execution. Native
+    // turn/item events and newly active threads invalidate an idle proof.
+    if (/^(turn|item)\//.test(message.method ?? "")
+      || message.method === "thread/status/changed" && message.params?.status?.type === "active") this.options.onNativeActivity?.();
     this.observeItemPhase(message);
     try { this.observeTopology(message); }
     catch (error) { this.topologyError = error; this.rejectAll(error); return; }

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

@@ -66,7 +66,7 @@ export async function serveDaemon(stateDir) {
       runtime.requireIdentity(params.sessionId); const cleanup = await runtime.closeTree(true); let inspected;
       try { inspected = await runtime.inspect(params.sessionId, { ignoreActive: true }); }
       catch (error) { inspected = { harness: "droid-cli", provider_session_id: params.sessionId, descendants: [...runtime.topology.values()], inspection_error: errorRecord(error) }; }
-      return { ...inspected, cancelled: true, settled: cleanup.settled, cleanup };
+      return { ...inspected, cancelled: true, settled: inspected.settled === true && cleanup.native_settled === true, native_settled: inspected.settled === true && cleanup.native_settled === true, physical_stopped: cleanup.physical_stopped, cleanup };
     }
     if (operation === "daemon.stop") {
       stopping = true;
@@ -78,9 +78,10 @@ export async function serveDaemon(stateDir) {
         if (runtime.rootId) try { await runtime.inspect(runtime.rootId, { ignoreActive: true }); } catch (error) { cleanup.inspection_error = errorRecord(error); }
         // Native evidence failures remain visible, but cannot strand copied
         // credentials or the daemon after the owned process tree is gone.
-        const clean = !cleanup.forced && !cleanup.topology_error && !cleanup.inspection_error;
-        return { clean, cleanup };
+        const clean = cleanup.native_settled === true && !cleanup.inspection_error;
+        return { clean, settled: cleanup.native_settled === true, native_settled: cleanup.native_settled === true, physical_stopped: cleanup.physical_stopped, cleanup };
         }, [
+          ["provider", async () => { if (!runtime.closed) throw new DroidError("provider_process_stop_incomplete", "Droid provider has not closed"); }],
           ["auth", () => removeDroidAuth(state.config)],
           ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
         ]);

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

@@ -22,7 +22,7 @@ function metadataReader(factory) { if (!metadataReaders.has(factory)) metadataRe
 import { confirmDaemonProcess, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 import { renderAdapterPolicy, lifecycleRetryInstruction } from "./delegation-instructions.mjs";
 import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
-import { settledNativeTree } from "./native-children.mjs";
+import { settledNativeTree, nativeExecutionReceipt } from "./native-children.mjs";
 
 export const DROID_CONTRACT = "dd-droid-harness@1";
 export const DROID_PROTOCOL = "1.201.0";
@@ -256,7 +256,7 @@ export class DroidRuntime {
   }
   async observeSettings(id, settings, source, extra = {}) {
     const observed = this.profile(settings);
-    const event = await observeModel({ journal: this.config.journal, harness: "droid-cli", sessionId: id, parentSessionId: id === this.rootId ? null : this.rootId,
+    const event = await observeModel({ journal: this.config.journal, harness: "droid-cli", sessionId: id, parentSessionId: id === this.rootId ? null : this.topology.get(id)?.parent_provider_session_id ?? this.rootId,
       requested: this.config, observed, source, ...extra });
     if (id === this.rootId) this.observedProfile = observed;
     this.modelEventIds ??= new Map();
@@ -267,8 +267,9 @@ export class DroidRuntime {
     return observed;
   }
   validateMetadata(id, native) {
-    if (!native || path.resolve(native.header.cwd) !== this.config.cwd || native.header.id !== id || (id !== this.rootId && native.header.callingSessionId !== this.rootId)) throw new DroidError("session_identity_mismatch", "Native model observation is outside the owned Session tree");
-    if (id !== this.rootId && !this.topology.has(id)) this.topology.set(id, { provider_session_id: id, parent_provider_session_id: this.rootId, tool_use_id: native.header.callingToolUseId, status: "unknown", source: "native.metadata" });
+    const parent = native?.header.callingSessionId;
+    if (!native || path.resolve(native.header.cwd) !== this.config.cwd || native.header.id !== id || (id !== this.rootId && (id === parent || parent !== this.rootId && !this.topology.has(parent) || this.topology.has(id) && this.topology.get(id).parent_provider_session_id !== parent))) throw new DroidError("session_identity_mismatch", "Native model observation is outside the owned Session tree");
+    if (id !== this.rootId && !this.topology.has(id)) this.topology.set(id, { provider_session_id: id, parent_provider_session_id: parent, tool_use_id: native.header.callingToolUseId, status: "unknown", source: "native.metadata" });
   }
   async observeModels() {
     if (!this.rootId || !this.loaded) return;
@@ -276,9 +277,12 @@ export class DroidRuntime {
     const info = await stat(catalog).catch(error => { if (error.code === "ENOENT") return null; throw error; });
     if (info && info.mtimeMs !== this.modelCatalogMtime) {
       const value = await readJson(catalog);
-      for (const task of value?.invocations ?? []) if (task.parentSessionId === this.rootId && task.childSessionId) {
-        const native = await this.metadata.read(task.childSessionId);
-        if (native) this.validateMetadata(task.childSessionId, native);
+      const tasks = Array.isArray(value?.invocations) ? value.invocations : [];
+      for (let size = -1; size !== this.topology.size;) { size = this.topology.size;
+        for (const task of tasks) if (task?.childSessionId && (task.parentSessionId === this.rootId || this.topology.has(task.parentSessionId))) {
+          const native = await this.metadata.read(task.childSessionId);
+          if (native) this.validateMetadata(task.childSessionId, native);
+        }
       }
       this.modelCatalogMtime = info.mtimeMs;
     }
@@ -286,7 +290,7 @@ export class DroidRuntime {
     const routing = await readDroidRoutingLog(log, this.state.model_log_cursor);
     for (const transition of routing.events) {
       const native = await this.metadata.read(transition.session_id);
-      if (!native || (transition.session_id !== this.rootId && native.header.callingSessionId !== this.rootId)) continue;
+      if (!native || (transition.session_id !== this.rootId && native.header.callingSessionId !== this.rootId && !this.topology.has(native.header.callingSessionId))) continue;
       this.validateMetadata(transition.session_id, native);
       await this.observeSettings(transition.session_id, { ...native.settings, modelId: transition.model, model: transition.model },
         { path: log, channel: "native_router", event_sha256: transition.event_sha256 }, { reason: transition.reason, nativeTimestamp: transition.native_timestamp, previousModel: transition.previous_model });
@@ -439,39 +443,72 @@ export class DroidRuntime {
     return { ...receipt, result: { ...outcome, status: status(outcome.reason) }, assistant_text: binding.assistant_text ?? "", turn_id: binding.turn_id, recovered_from: "native.agent_turn_outcome" };
   }
   async refreshTopology() {
-    let catalog;
-    try { catalog = await readJson(path.join(this.paths.factory, "task-invocations.json")); }
-    catch (error) { if (!(error instanceof SyntaxError)) throw error; this.topologyIncomplete = true; return [...this.topology.values()]; }
+    let catalog, missing = false;
+    try { catalog = JSON.parse(await readFile(path.join(this.paths.factory, "task-invocations.json"), "utf8")); }
+    catch (error) { if (error.code === "ENOENT") missing = true; else { if (!(error instanceof SyntaxError)) throw error; this.topologyIncomplete = true; return [...this.topology.values()]; } }
     this.topologyIncomplete = false;
-    const invocations = catalog?.invocations ?? [];
     const root = this.rootId ? await readDroidSession(this.paths.factory, this.rootId) : null;
-    const rootTools = new Map((root?.records ?? []).flatMap(record => record.message?.content ?? []).filter(block => block.type === "tool_use").map(block => [block.id, block]));
+    const taskTools = native => new Map((native?.records ?? []).flatMap(record => record.message?.content ?? []).filter(block => block.type === "tool_use" && block.name === "Task").map(block => [block.id, block]));
+    const validCatalog = catalog && !Array.isArray(catalog) && Array.isArray(catalog.invocations);
+    if (!validCatalog) {
+      const noChildren = !this.topology.size && !taskTools(root).size;
+      const noDispatch = !this.active && !this.lastResult && !this.state.active_tree && (!root || root.complete && root.records.every(record => record.type === "session_start"));
+      const completeNoTask = root?.complete && terminal(root.outcomes.at(-1)?.reason) && root.tool_calls.completeness === "complete";
+      this.topologyIncomplete = !(missing && noChildren && (noDispatch || completeNoTask));
+      return [...this.topology.values()];
+    }
+    const invocations = catalog.invocations, owned = new Set([this.rootId, ...this.topology.keys()]);
+    // Resolve ancestry before validating records so malformed foreign entries
+    // do not block this tree, while malformed reachable children do.
+    for (let size = -1; size !== owned.size;) { size = owned.size; for (const task of invocations) if (owned.has(task?.parentSessionId) && task?.childSessionId) owned.add(task.childSessionId); }
+    const parents = new Map([[this.rootId, root]]);
+    for (const id of owned) if (id !== this.rootId) parents.set(id, await readDroidSession(this.paths.factory, id));
+    for (const [parentId, native] of parents) {
+      if (!native?.complete) this.topologyIncomplete = true;
+      for (const toolId of taskTools(native).keys()) if (!invocations.some(task => task?.parentSessionId === parentId && task?.parentToolUseId === toolId)) this.topologyIncomplete = true;
+    }
     const groups = new Map();
     for (const task of invocations) {
-      if (task.parentSessionId !== this.rootId || !task.childSessionId || !task.parentToolUseId) continue;
+      if (!task || typeof task !== "object") { this.topologyIncomplete = true; continue; }
+      if (!owned.has(task.parentSessionId) && !owned.has(task.childSessionId) && ![...parents.values()].some(native => taskTools(native).has(task.parentToolUseId))) continue;
+      if (![task.parentSessionId, task.childSessionId, task.parentToolUseId, task.taskInvocationId, task.status].every(value => typeof value === "string" && value.length)) { this.topologyIncomplete = true; continue; }
       const tasks = groups.get(task.childSessionId) ?? []; tasks.push(task); groups.set(task.childSessionId, tasks);
     }
+    for (const id of this.topology.keys()) if (!groups.has(id)) this.topologyIncomplete = true;
     for (const [id, tasks] of groups) {
-      const native = await readDroidSession(this.paths.factory, id);
+      const native = parents.get(id), parentId = tasks[0].parentSessionId, rootTools = taskTools(parents.get(parentId));
       if (!native || !native.settings) { this.topologyIncomplete = true; continue; }
-      if (native.header.callingSessionId !== this.rootId) throw new DroidError("droid_child_identity_invalid", "Task invocation disagrees with physical child parent");
+      if (id === this.rootId || id === parentId || tasks.some(task => task.parentSessionId !== parentId) || native.header.callingSessionId !== parentId || path.resolve(native.header.cwd) !== this.config.cwd) throw new DroidError("droid_child_identity_invalid", "Task invocation disagrees with physical child parent/workspace");
+      if (new Set(tasks.map(task => task.taskInvocationId)).size !== tasks.length) this.topologyIncomplete = true;
       const creationTool = native.header.callingToolUseId;
       for (const task of tasks) {
+        if (!rootTools.has(task.parentToolUseId)) {
+          const block = (parents.get(parentId)?.records ?? []).flatMap(record => record.message?.content ?? []).find(block => block.type === "tool_use" && block.id === task.parentToolUseId);
+          if (block) throw new DroidError("droid_child_identity_invalid", "Task invocation is bound to a non-Task tool");
+          this.topologyIncomplete = true; continue;
+        }
         if (task.parentToolUseId === creationTool) continue;
         const tool = rootTools.get(task.parentToolUseId);
         if (tool?.name !== "Task" || tool.input?.resume !== id) throw new DroidError("droid_child_identity_invalid", "Repeated child invocation has no matching native Task resume evidence");
       }
       await this.observeSettings(id, native.settings, { path: native.transcript_path, sha256: native.source_sha256 });
-      const prior = this.topology.get(id);
       // Task resume adds a Turn to the same physical child, not another
       // Session. Its transcript retains the original creation edge. Work
       // reassignment is checked by dd-flow's physical Session binding.
-      const ordered = tasks.toSorted((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0));
-      const latest = ordered.at(-1); const running = tasks.some(task => !terminal(task.status));
-      const closed = running && prior?.source === "adapter.tree_closed";
+      const order = [...rootTools.keys()];
+      const ordered = tasks.toSorted((a, b) => order.indexOf(a.parentToolUseId) - order.indexOf(b.parentToolUseId));
+      const latest = ordered.at(-1); const running = !terminal(latest.status);
       const outcome = native.outcomes.at(-1), nativeTurn = outcome && terminal(outcome.reason) && typeof outcome.turnId === "string" ? outcome.turnId : null;
-      const evidence = !running && nativeTurn ? { terminal_turn_id: nativeTurn, native_source: "droid.agent_turn_outcome", native_turn_items: { observed: native.complete && native.tool_calls.completeness === "complete", possible_effects: native.tool_calls.total > 0, pending: native.tool_calls.pending > 0 }, ...(outcome.error && typeof outcome.error === "object" ? { provider_error: safeProviderError(outcome.error) } : {}) } : {};
-      this.topology.set(id, { provider_session_id: id, parent_provider_session_id: this.rootId, tool_use_id: creationTool, latest_tool_use_id: latest.parentToolUseId, task_id: latest.taskInvocationId, task_invocation_ids: ordered.map(task => task.taskInvocationId), status: closed ? prior.status : running ? "running" : status(latest.status), source: closed ? prior.source : "droid.task_invocations", transcript_path: native.transcript_path, ...evidence });
+      const parentResult = (parents.get(parentId)?.records ?? []).flatMap(record => record.message?.content ?? []).some(block => block.type === "tool_result" && block.tool_use_id === latest.parentToolUseId);
+      const exactTurn = nativeTurn && (tasks.length === 1 || latest.turnId === nativeTurn);
+      // A resumed Task's previous terminal Turn is not its current outcome.
+      // The matching native Task result proves completion without attributing
+      // a previous error/Turn ID to this invocation.
+      const evidence = !running && nativeTurn && (tasks.length === 1 || parentResult || exactTurn) ? {
+        ...(exactTurn ? { terminal_turn_id: nativeTurn } : {}), native_source: "droid.agent_turn_outcome",
+        native_turn_items: { observed: native.complete && native.tool_calls.completeness === "complete", possible_effects: native.tool_calls.total > 0, pending: native.tool_calls.pending > 0 },
+        ...(exactTurn && outcome.error && typeof outcome.error === "object" ? { provider_error: safeProviderError(outcome.error) } : {}) } : {};
+      this.topology.set(id, { provider_session_id: id, parent_provider_session_id: parentId, tool_use_id: creationTool, latest_tool_use_id: latest.parentToolUseId, task_id: latest.taskInvocationId, task_invocation_ids: ordered.map(task => task.taskInvocationId), status: running ? "running" : status(latest.status), source: "droid.task_invocations", transcript_path: native.transcript_path, ...evidence });
     }
     return [...this.topology.values()];
   }
@@ -491,9 +528,10 @@ export class DroidRuntime {
   async inspect(id, { ignoreActive = false, ingestUsage = true } = {}) {
     this.requireIdentity(id); await this.captureProcesses(); const children = await this.refreshTopology(); const source = await readDroidSession(this.paths.factory, id);
     const usage = []; for (const sessionId of [id, ...children.map(child => child.provider_session_id)]) usage.push(await this.snapshotUsage(sessionId, { ingest: ingestUsage }));
-    const settled = !this.topologyIncomplete && (!this.active || ignoreActive) && (this.closed || this.workingState === "idle") && children.every(child => terminal(child.status));
-    const rootSettled = (!this.active || ignoreActive) && (this.closed || this.workingState === "idle") && terminal((source?.outcomes?.at(-1) ?? this.lastResult)?.reason);
-    return { harness: "droid-cli", runtime_family: "droid", session: { harness_id: "droid-cli", session_id: id }, provider_session_id: id, adapter_session_id: id, cwd: this.config.cwd, observed_profile: source?.settings ? await this.observeSettings(id, source.settings, { path: source.transcript_path, sha256: source.source_sha256 }) : this.observedProfile, observed_runtime: { droid: this.config.version, factory_protocol: this.protocol ?? DROID_PROTOCOL, dd_harness_contract: DROID_CONTRACT }, status: settled ? "idle" : "running", settled, ...settledNativeTree(id, children, settled, rootSettled && !this.topologyIncomplete), terminal_turn_id: source?.outcomes?.at(-1)?.turnId ?? this.lastResult?.turnId, descendants: children, transcript_path: source?.transcript_path ?? null, usage, result: this.lastResult, provider_pid: this.closed ? null : this.child?.pid ?? null };
+    const settled = !this.topologyIncomplete && (!this.active || ignoreActive) && (this.closed || this.workingState === "idle") && source?.tool_calls.pending === 0 && children.every(child => terminal(child.status) && child.native_turn_items?.observed === true && child.native_turn_items.pending === false);
+    const rootSettled = source?.complete && source.tool_calls.completeness === "complete" && source.tool_calls.pending === 0 && (!this.active || ignoreActive) && (this.closed || this.workingState === "idle") && terminal((source?.outcomes?.at(-1) ?? this.lastResult)?.reason);
+    return nativeExecutionReceipt({ harness: "droid-cli", runtime_family: "droid", session: { harness_id: "droid-cli", session_id: id }, provider_session_id: id, adapter_session_id: id, cwd: this.config.cwd, observed_profile: source?.settings ? await this.observeSettings(id, source.settings, { path: source.transcript_path, sha256: source.source_sha256 }) : this.observedProfile, observed_runtime: { droid: this.config.version, factory_protocol: this.protocol ?? DROID_PROTOCOL, dd_harness_contract: DROID_CONTRACT }, status: settled ? "idle" : "running", settled, ...settledNativeTree(id, children, settled, rootSettled && !this.topologyIncomplete), terminal_turn_id: source?.outcomes?.at(-1)?.turnId ?? this.lastResult?.turnId, descendants: children, transcript_path: source?.transcript_path ?? null, usage, result: this.lastResult, provider_pid: this.closed ? null : this.child?.pid ?? null,
+      ...(this.topologyIncomplete ? { native_settlement: { confirmed: false, state: "unproven", reason: "native_task_inventory_incomplete" } } : {}) }, { daemonId: this.config.daemonId });
   }
   async observeHook(payload, eventId, deadlineAt = null) {
     try { return await this.observeHookChecked(payload, eventId, hookBudget(23_000, deadlineAt)); }
@@ -508,7 +546,8 @@ export class DroidRuntime {
     const foreign = message => new DroidError("droid_hook_identity_invalid", message, { scope: "foreign_hook", provider_session_id: id });
     if (!native || path.resolve(payload.cwd) !== this.config.cwd || await realpath(payload.transcript_path) !== await realpath(native.transcript_path)) throw foreign("Hook is outside its controlled native Session/workspace");
     const parent = native.header.callingSessionId ?? null;
-    if (parent && parent !== this.rootId) throw foreign("Hook child belongs to another root");
+    if (parent && parent !== this.rootId && !this.topology.has(parent)) throw foreign("Hook child belongs to another root");
+    if (parent && (id === parent || this.topology.has(id) && this.topology.get(id).parent_provider_session_id !== parent)) throw foreign("Hook child ancestry changed");
     if (!parent && this.rootId && id !== this.rootId) throw foreign("Hook came from an unrelated root");
     if (path.resolve(native.header.cwd) !== this.config.cwd) throw new DroidError("droid_hook_identity_invalid", "Owned native Session workspace changed");
     if (parent && !terminal(this.topology.get(id)?.status)) this.topology.set(id, { ...(this.topology.get(id) ?? {}), provider_session_id: id, parent_provider_session_id: parent, tool_use_id: native.header.callingToolUseId, status: "running", source: "droid.session_start" });
@@ -521,7 +560,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);
@@ -576,8 +615,11 @@ export class DroidRuntime {
     let topologyError = null;
     try { await this.refreshTopology(); }
     catch (error) { topologyError = errorRecord(error); await this.journal("closed_tree_topology_error", { error: topologyError }); }
-    for (const [id, child] of this.topology) if (!terminal(child.status)) this.topology.set(id, { ...child, status: "cancelled", source: "adapter.tree_closed", native_status: child.status });
-    const cleanup = { settled: true, forced, observed_processes: this.ownedProcesses.length, ...(topologyError ? { topology_error: topologyError } : {}) };
+    const root = this.rootId ? await readDroidSession(this.paths.factory, this.rootId) : null;
+    const nativeSettled = !forced && !topologyError && !this.topologyIncomplete
+      && (!this.rootId || root?.complete && (terminal(root.outcomes.at(-1)?.reason) || !this.active && !this.lastResult && root.records.every(record => record.type === "session_start")) && root.tool_calls.pending === 0)
+      && [...this.topology.values()].every(child => terminal(child.status) && child.native_turn_items?.observed === true && child.native_turn_items.pending === false);
+    const cleanup = { settled: true, physical_stopped: true, native_settled: nativeSettled, forced, observed_processes: this.ownedProcesses.length, ...(topologyError ? { topology_error: topologyError } : {}) };
     await this.save({ active_tree: false, cleanup });
     return cleanup;
   }

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

@@ -21,7 +21,7 @@ import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
 import { safeProviderError } from "./provider-overload-policy.mjs";
-import { settledNativeTree } from "./native-children.mjs";
+import { settledNativeTree, nativeExecutionReceipt } from "./native-children.mjs";
 import { observeModel, readModelObservations } from "./model-observations.mjs";
 import { cancelSessionWithBridge, createSessionWithBridge, doctor, forkSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge } from "./dd-grok.mjs";
 import { prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-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;
@@ -416,7 +465,7 @@ export class Runtime {
     if (operation === "session.create") return await this.productive(operation, async () => { const result = await createSessionWithBridge(this.bridge, { ...this.options(params), onSessionCreated: async (session) => { this.track(session); this.loadedSessionId = session.provider_session_id; await this.persist(); } }, this.initialized); this.loadedSessionId = result.provider_session_id; return result; }, null, operationId);
     if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch, operationId }); this.loadedSessionId = params.sessionId; return result; }, params.sessionId, operationId); }
     if (operation === "session.fork") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await forkSessionWithBridge(this.bridge, this.options(params)); this.loadedSessionId = params.sessionId; return result; }); }
-    if (operation === "session.inspect" || operation === "session.resume") { const before = new Map(this.descendants); const result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result, before); await this.persist(); const settled = !this.active && !this.treeRunning(result); const descendants = this.topology(result.provider_session_id); const terminal = this.sessions.get(result.provider_session_id)?.native_root_receipt; return { ...result, settled, descendants, ...settledNativeTree(result.provider_session_id, descendants, settled, !this.active && !this.rootRunning(result)), ...(terminal?.kind === "failed" && terminal.request_id !== undefined ? { terminal_turn_id: String(terminal.request_id) } : {}) }; }
+    if (operation === "session.inspect" || operation === "session.resume") { const before = new Map(this.descendants); const result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result, before); await this.persist(); const settled = !this.active && !this.treeRunning(result); const descendants = this.topology(result.provider_session_id); const terminal = this.sessions.get(result.provider_session_id)?.native_root_receipt; return nativeExecutionReceipt({ ...result, settled, descendants, ...settledNativeTree(result.provider_session_id, descendants, settled, !this.active && !this.rootRunning(result)), ...(terminal?.kind === "failed" && terminal.request_id !== undefined ? { terminal_turn_id: String(terminal.request_id) } : {}) }, { daemonId: this.state.daemon_id, generation: this.controlGeneration ?? 0 }); }
     if (operation === "session.cancel") { if (!this.sessions.has(params.sessionId)) throw new DaemonError("session_identity_mismatch", "cancellation Session is not owned by this daemon"); cancelPendingDispatch(this); const result = await cancelSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); await this.persist({ active_tree: Boolean(this.active) || !result.settled }); return result; }
     if (operation === "session.archive") { await this.requireSettled(); return await this.productive(operation, async () => { let session = this.sessions.get(params.sessionId); if (!session?.cwd) { const result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result); session = this.sessions.get(result.provider_session_id); } return await exportSessionArchive(this.paths, session.provider_session_id, absolute(session.cwd, "Grok Build session cwd"), params.archiveDir, this.state.versions); }); }
     if (operation === "daemon.stop") {
@@ -427,7 +476,7 @@ export class Runtime {
         observe: async () => ({ sessions: await this.refreshTree(), active: Boolean(this.active), active_operation: this.active }),
         ...(params.cancelTree ? { cancel: id => cancelSessionWithBridge(this.bridge, this.options({ sessionId: id, liveSession: true })) } : {})
       });
-      return { clean: true };
+      return { clean: true, settled: true, native_settled: true };
       }, [
         ["provider", () => this.bridge.close()],
         ["provider_resource", () => finishDaemonProcess(this.state.config, this.state.provider_process)],
@@ -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) {