@deksden-com/dd-flow-cli 0.9.0-beta.100 → 0.9.0-beta.103

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

@@ -11,6 +11,7 @@ import path from "node:path";
 import { ObservationClock, observedTimeout } from "./observation-clock.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { errorRecord, reportedError } from "./operation-errors.mjs";
+import { hookBudget, invokeNativeHook } from "./native-hook-command.mjs";
 import { checkObservedProfile, observeModel } from "./model-observations.mjs";
 import { DroidMetadataReader, readDroidRoutingLog } from "./droid-observation.mjs";
 const metadataReaders = new Map();
@@ -381,14 +382,9 @@ export class DroidRuntime {
     if (ingest && measured && this.config.ddFlowBin) await this.flow("usage", "ingest", payload);
     return { status: measured ? "measured" : "unavailable", ...payload };
   }
-  async flow(family, command, payload) {
-    const target = executable(this.config.ddFlowBin, ["droid", family, command, "--project-root", this.config.projectRoot, "--json"]);
-    return await new Promise((resolve, reject) => {
-      const child = spawn(target.command, target.args, { cwd: this.config.cwd, env: droidEnvironment(this.config), stdio: ["pipe", "pipe", "pipe"] }); let stdout = "", stderr = "";
-      const timer = observedTimeout(() => { child.kill("SIGTERM"); reject(new DroidError("droid_flow_timeout", "dd-flow did not acknowledge Droid evidence")); }, 25_000);
-      child.stdout.setEncoding("utf8").on("data", chunk => stdout += chunk); child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk);
-      child.on("error", error => { clearTimeout(timer); reject(error); }); child.on("close", code => { clearTimeout(timer); if (code !== 0) return reject(new DroidError("droid_flow_rejected", stderr || "dd-flow rejected Droid evidence")); try { resolve(JSON.parse(stdout)); } catch (error) { reject(error); } }); child.stdin.end(`${JSON.stringify(payload)}\n`);
-    });
+  async flow(family, command, payload, timeoutMs = 25_000) {
+    return await invokeNativeHook({ bin: this.config.ddFlowBin, args: ["droid", family, command, "--project-root", this.config.projectRoot, "--json"], payload,
+      cwd: this.config.cwd, env: droidEnvironment(this.config), home: this.config.ddFlowHome, timeoutMs });
   }
   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);
@@ -396,20 +392,22 @@ export class DroidRuntime {
     const settled = !this.topologyIncomplete && (!this.active || ignoreActive) && (this.closed || this.workingState === "idle") && children.every(child => terminal(child.status));
     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, descendants: children, transcript_path: source?.transcript_path ?? null, usage, result: this.lastResult, provider_pid: this.closed ? null : this.child?.pid ?? null };
   }
-  async observeHook(payload, eventId) {
-    try { return await this.observeHookChecked(payload, eventId); }
-    catch (error) { await this.handleObservationError(error); throw error; }
+  async observeHook(payload, eventId, deadlineAt = null) {
+    try { return await this.observeHookChecked(payload, eventId, hookBudget(23_000, deadlineAt)); }
+    catch (error) { if (error.details?.scope !== "foreign_hook") await this.handleObservationError(error); throw error; }
   }
-  async observeHookChecked(payload, eventId) {
+  async observeHookChecked(payload, eventId, budget = hookBudget(23_000)) {
     const id = payload.session_id, event = payload.hook_event_name;
     if (!id || !event || !eventId) throw new DroidError("droid_hook_invalid", "Hook lacks native identity or event ID");
     // Hooks can precede the root initialize response or the child notification.
     const deadline = Date.now() + 3_000; let native;
     do { native = ["PreToolUse", "PostToolUse"].includes(event) ? await this.metadata.read(id) : await readDroidSession(this.paths.factory, id); if (native) break; await sleep(25); } while (Date.now() < deadline);
-    if (!native || path.resolve(native.header.cwd) !== this.config.cwd || path.resolve(payload.cwd) !== this.config.cwd || await realpath(payload.transcript_path) !== await realpath(native.transcript_path)) throw new DroidError("droid_hook_identity_invalid", "Hook is outside its controlled native Session/workspace");
+    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 new DroidError("droid_hook_identity_invalid", "Hook child belongs to another root");
-    if (!parent && this.rootId && id !== this.rootId) throw new DroidError("droid_hook_identity_invalid", "Hook came from an unrelated root");
+    if (parent && parent !== this.rootId) throw foreign("Hook child belongs to another root");
+    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" });
     this.activity += 1; await this.journal("hook", { event_id: eventId, event, session_id: id, parent_session_id: parent }); await this.save();
     if (!["PreToolUse", "PostToolUse"].includes(event)) return {};
@@ -418,8 +416,17 @@ export class DroidRuntime {
     try { profile = await this.observeSettings(id, native.settings, { path: native.transcript_path, sha256: native.source_sha256 }); }
     catch (error) { await this.handleObservationError(error); return { continue: false, stopReason: error.message }; }
     if (!this.config.ddFlowBin || payload.tool_name !== "Execute") return {};
-    await this.snapshotUsage(id);
-    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" } });
+    // 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));
+    } catch (error) {
+      // Identity is proven above; only this owned admission can fail its turn.
+      this.fatalError ??= Object.assign(error, { details: { ...error.details, provider_session_id: id, event_id: eventId, effect: "unknown" } });
+      this.rejectPending(this.fatalError);
+      try { await this.save({ fatal_error: errorRecord(this.fatalError) }); await this.journal("hook_rejected", { error: errorRecord(this.fatalError) }); }
+      catch (storage) { this.fatalError.details.receipt_error = errorRecord(storage); }
+      throw this.fatalError;
+    }
   }
   async captureProcesses() {
     const rows = await processSnapshot();

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

@@ -12,7 +12,7 @@ import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
 import { cancelSessionWithBridge, createSessionWithBridge, doctor, forkSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge } from "./dd-grok.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-grok/daemon-request@1";
 const RESPONSE_SCHEMA = "dd-grok/daemon-response@1";
@@ -167,7 +167,7 @@ export async function startDaemon(options) {
   const previous = await readState(paths.dir); if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config); if (previous?.shutdown_state === "running" && previous.active_tree) throw new DaemonError("invalid_harness_crash", "previous daemon died with an active or unproven Session tree", false, { daemon_id: previous.daemon_id });
   await removeSocket(paths.socket, paths.dir); await mkdir(paths.home, { recursive: true, mode: 0o700 }); const importedSession = await materializeSessionArchive(paths, config.sessionArchive); const copiedAuth = await copyAuth(paths, authSource); await writeIsolatedConfig(paths); if (!noFlow) await writeHook(paths, config, absolute(options.entryPath, "dd-grok entry")); const versions = await doctor({ bin: config.bin }); if (importedSession && importedSession.grok_version !== versions.versions.grok) throw new DaemonError("session_archive_version_mismatch", "Grok Build session archive was created by a different CLI version", false, { archive_version: importedSession.grok_version, current_version: versions.versions.grok }); const configIsolation = await inspectIsolatedConfig(config);
   const resourceProcess = await registerDaemonProcess(config, { kind: "grok-daemon", owner: `grok:${path.basename(paths.dir)}`, operation: `grok-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
-  const state = { schema_id: STATE_SCHEMA, daemon_id: randomUUID(), pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
+  const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: randomUUID(), pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
   await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
   catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
@@ -175,11 +175,69 @@ 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); }
 
 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(); 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()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.then(() => writeState(this.paths.state, snapshot)); if (snapshot.resource_process) this.persisting = this.persisting.then(() => heartbeatDaemonProcess(snapshot.config, snapshot.resource_process).catch(() => {})); return this.persisting; }
+  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.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) { 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, 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; const parent = value?.parent_provider_session_id ?? value?.parentSessionId ?? root; if (typeof id !== "string" || !id || typeof parent !== "string" || !parent) return; this.bridge.registerModelSession?.(id, id, this.state.config, parent); const prior = this.descendants.get(id); this.descendants.set(id, { provider_session_id: id, parent_provider_session_id: parent, status: value?.status ?? value?.state ?? (fallback === "unknown" ? prior?.status ?? fallback : fallback), source }); }
+  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"); }
+  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;
+    if (typeof id !== "string" || !id || typeof parent !== "string" || !parent) return;
+    if (id === parent) throw new DaemonError("session_parent_conflict", "Grok child Session cannot be its own native parent", false, { provider_session_id: id, observed_parent_provider_session_id: parent });
+    const prior = this.sessions.get(id);
+    if (prior?.parent_provider_session_id && prior.parent_provider_session_id !== parent) {
+      throw new DaemonError("session_parent_conflict", "Grok child Session was observed with conflicting native parents", false, {
+        provider_session_id: id,
+        retained_parent_provider_session_id: prior.parent_provider_session_id,
+        observed_parent_provider_session_id: parent
+      });
+    }
+    const parentSession = this.sessions.get(parent);
+    const rootProviderSessionId = prior?.root_provider_session_id
+      ?? parentSession?.root_provider_session_id
+      ?? root;
+    const cwd = value?.cwd ?? prior?.cwd ?? parentSession?.cwd ?? this.state.config?.cwd ?? null;
+    // A descendant is a managed native Session, not merely a liveness item.
+    // Register it in the same registry used by inspect/hook.resolve so a
+    // parentless inspection cannot downgrade it into a second root.
+    this.sessions.set(id, {
+      ...prior,
+      provider_session_id: id,
+      adapter_session_id: prior?.adapter_session_id ?? id,
+      parent_provider_session_id: parent,
+      root_provider_session_id: rootProviderSessionId,
+      cwd,
+      native_root_receipt: prior?.native_root_receipt ?? null
+    });
+    this.bridge.registerModelSession?.(id, id, this.state.config, parent);
+    const descendant = this.descendants.get(id);
+    const attempt = value.attempt_id;
+    const retired = descendant?.retired_attempt_ids ?? [];
+    if (attempt && retired.includes(attempt)) return;
+    const spawned = value.sessionUpdate === "subagent_spawned";
+    const newAttempt = spawned && typeof attempt === "string" && attempt !== descendant?.attempt_id;
+    const terminal = status => ["completed", "failed", "cancelled"].includes(status);
+    const status = value?.status ?? value?.state ?? (fallback === "unknown" ? descendant?.status ?? fallback : fallback);
+    if (attempt && descendant?.attempt_id && attempt !== descendant.attempt_id && !newAttempt) throw new DaemonError("native_child_execution_ambiguous", "Grok child event has no matching native spawn attempt", false, { session_id: id, attempt_id: attempt });
+    if (source === "x.ai/subagent/event" && terminal(status) && descendant?.attempt_id && !attempt) throw new DaemonError("native_child_execution_ambiguous", "Grok terminal event omits the retained child attempt identity", false, { session_id: id });
+    if (!newAttempt && terminal(descendant?.status) && status === "running") {
+      if (value.stale_activity || attempt === descendant.attempt_id && attempt) return;
+      const error = { code: "native_child_execution_ambiguous", message: "Grok child activity follows a terminal result without native new-attempt evidence", details: { session_id: id } };
+      this.descendants.set(id, { ...descendant, activity_status: "running", outcome_error: error });
+      if (spawned) throw new DaemonError(error.code, error.message, false, error.details);
+      return;
+    }
+    if (!newAttempt && terminal(descendant?.status) && terminal(status) && descendant.status !== status) throw new DaemonError("native_child_outcome_conflict", "Grok child has contradictory terminal outcomes", false, { session_id: id, previous: descendant.status, observed: status });
+    this.descendants.set(id, {
+      provider_session_id: id,
+      parent_provider_session_id: parent,
+      status,
+      source,
+      ...(attempt || descendant?.attempt_id ? { attempt_id: attempt ?? descendant.attempt_id } : {}),
+      ...(newAttempt && descendant?.attempt_id ? { retired_attempt_ids: [...retired, descendant.attempt_id] } : retired.length ? { retired_attempt_ids: retired } : {}),
+      ...(!newAttempt && !terminal(status) && descendant?.outcome_error ? { outcome_error: descendant.outcome_error } : {})
+    });
+  }
   observeSubagentEvent(message) {
     const root = message?.params?.sessionId, update = message?.params?.update;
     const kind = String(update?.sessionUpdate ?? update?.type ?? message?.method ?? "");
@@ -192,19 +250,37 @@ export class Runtime {
     this.subagentCalls ??= new Map();
     const key = `${root}:${update?.toolCallId}`;
     const tool = update?._meta?.["x.ai/tool"]?.name ?? (kind === "tool_call" ? update.title : null);
-    if (tool) this.subagentCalls.set(key, tool);
-    const name = this.subagentCalls.get(key), output = update?.rawOutput;
+    if (["spawn_subagent", "get_command_or_subagent_output"].includes(tool) && !this.subagentCalls.has(key)) this.subagentCalls.set(key, { name: tool, input: update.rawInput, attempts: new Map([...this.descendants].map(([id, child]) => [id, child.attempt_id])) });
+    const call = this.subagentCalls.get(key), name = call?.name, output = update?.rawOutput;
+    if (call && update.rawInput) call.input = update.rawInput;
     if (kind !== "tool_call_update" || update.status !== "completed") return;
     if (name === "spawn_subagent" && output?.type === "Text") {
       const id = /^subagent_id:\s*(\S+)\s*$/m.exec(output.text ?? "")?.[1];
-      if (id) this.recordDescendant({ session_id: id }, root, "x.ai/tool/spawn_subagent", "running");
+      if (id) this.recordDescendant({ session_id: id, stale_activity: !call.attempts.has(id) || call.attempts.get(id) !== this.descendants.get(id)?.attempt_id }, root, "x.ai/tool/spawn_subagent", "running");
     }
     if (name === "get_command_or_subagent_output" && output?.type === "TaskOutput") {
-      const result = output.Result;
-      if (this.descendants.has(result?.task_id)) this.recordDescendant({ session_id: result.task_id, status: result.status }, root, "x.ai/tool/TaskOutput", "unknown");
+      const results = output.Result ? [output.Result] : output.MultiResult?.results ?? [];
+      if (!Array.isArray(results)) throw new DaemonError("native_child_outcome_unavailable", "Grok TaskOutput has a malformed result list");
+      // TaskNotFound is prose in the native contract; identity comes from the
+      // matching tool input, never by scraping its diagnostic message.
+      if (output.TaskNotFound && typeof call.input?.task_id === "string") results.push({ task_id: call.input.task_id, status: "not_found" });
+      let firstError;
+      for (const result of results) {
+        const child = this.descendants.get(result?.task_id);
+        if (!child || call.attempts.get(result.task_id) !== child.attempt_id) continue;
+        if (result.status === "not_found") {
+          const error = new DaemonError("native_child_outcome_unavailable", "Grok cannot retrieve the owned child's native outcome", false, { session_id: result.task_id, tool_call_id: update.toolCallId });
+          this.descendants.set(result.task_id, { ...child, outcome_error: errorPayload(error) });
+          firstError ??= error;
+          continue;
+        }
+        if (!["running", "completed", "failed", "cancelled"].includes(result.status)) throw new DaemonError("native_child_outcome_unavailable", "Grok child returned an unknown native outcome", false, { session_id: result.task_id, status: result.status });
+        this.recordDescendant({ session_id: result.task_id, status: result.status, attempt_id: child.attempt_id }, root, "x.ai/tool/TaskOutput", "unknown");
+      }
+      if (firstError) throw firstError;
     }
   }
-  topology(root) { 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); }
   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) {
@@ -225,13 +301,15 @@ export class Runtime {
     const running = [];
     for (const session of [...this.sessions.values()].filter(item => !item.parent_provider_session_id)) {
       const id = session.provider_session_id;
+      const before = new Map(this.descendants);
       let observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId: id, liveSession: true }));
-      this.track(observed);
+      this.track(observed, before);
       const rootActive = Boolean(this.active);
       if (cancel && (rootActive || this.treeRunning(observed))) {
         await cancelSessionWithBridge(this.bridge, this.options({ sessionId: id, liveSession: true }));
+        const beforeCancelledInspection = new Map(this.descendants);
         observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId: id, liveSession: true }));
-        this.track(observed);
+        this.track(observed, beforeCancelledInspection);
       }
       if (this.active || this.treeRunning(observed)) running.push(id);
     }
@@ -247,8 +325,9 @@ export class Runtime {
     if (name === "session.prompt" && this.sessions.has(sessionId)) this.sessions.get(sessionId).native_root_receipt = null;
     try {
       await this.persist({ active_tree: true, active_operation: name });
+      const before = new Map(this.descendants);
       const result = await task();
-      this.track(result);
+      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 };
       // Archive requires an idle tree before entering this exclusive section
@@ -262,12 +341,12 @@ export class Runtime {
   async dispatch(operation, params) {
     const assertDispatch = captureDispatchGuard(this);
     if (operation === "daemon.ready") return { ready: this.ready, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config };
-    if (operation === "daemon.status") { let observationError; if (!this.active) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { ...await this.dispatch("daemon.ready", {}), observation_error: observationError ?? null }; }
+    if (operation === "daemon.status") { let observationError; if (!this.active) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { ...await this.dispatch("daemon.ready", {}), observation_error: observationError ?? this.state.observation_error ?? null }; }
     if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); const observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); this.track(observed); session = this.sessions.get(sessionId); if (!session || session.root_provider_session_id !== roots[0].provider_session_id) throw new DaemonError("hook_identity_unknown", "hook Session is not a member of the retained native tree"); await this.persist(); } return { daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }; }
     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; });
     if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch }); this.loadedSessionId = params.sessionId; return result; }, params.sessionId); }
     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 result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result); await this.persist(); return { ...result, settled: !this.active && !this.treeRunning(result), descendants: this.topology(result.provider_session_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(); return { ...result, settled: !this.active && !this.treeRunning(result), descendants: this.topology(result.provider_session_id) }; }
     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") {
@@ -282,7 +361,7 @@ export class Runtime {
     }
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }
-  async shutdown() { await this.bridge.close(); await finishDaemonProcess(this.state.config, this.state.resource_process); await unlink(path.join(this.paths.home, "auth.json")).catch(error => { if (error.code !== "ENOENT") throw error; }); await this.persist({ shutdown_state: "clean", stopped_at: new Date().toISOString() }); await new Promise((resolve) => this.server.close(resolve)); await removeSocket(this.paths.socket, this.paths.dir); }
+  async shutdown() { await closeManagedBridge(this.state.config, this.state, this.bridge); await finishDaemonProcess(this.state.config, this.state.resource_process); await unlink(path.join(this.paths.home, "auth.json")).catch(error => { if (error.code !== "ENOENT") throw error; }); await this.persist({ shutdown_state: "clean", stopped_at: new Date().toISOString() }); await new Promise((resolve) => this.server.close(resolve)); await removeSocket(this.paths.socket, this.paths.dir); }
 }
 
 export async function serveDaemon(stateDir) {
@@ -290,11 +369,19 @@ export async function serveDaemon(stateDir) {
   const bridge = new AcpBridge({ ...state.config, 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 sessionId = message?.params?.sessionId;
     if (!runtime || !sessionId) return;
-    runtime.observeToolCall(message); runtime.observeSubagentEvent(message);
+    try {
+      runtime.observeToolCall(message); runtime.observeSubagentEvent(message);
+    } catch (error) {
+      // Native notifications are fire-and-forget. Persist topology conflicts
+      // for the next inspect/status call instead of creating an unhandled
+      // rejection that can kill the daemon without a causal receipt.
+      try { await runtime.persist({ observation_error: errorPayload(error) }); } catch { /* status/inspect will report the original native failure */ }
+    }
     const session = runtime.sessions.get(sessionId);
     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 bridge.start(); runtime = new Runtime(paths, state, bridge, initialized);
+  } }); const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "grok-provider", publish: snapshot => writeState(paths.state, snapshot) }); runtime = new Runtime(paths, state, bridge, initialized);
+  await heartbeatDaemonProcess(state.config, state.resource_process);
   await removeSocket(paths.socket, paths.dir); const server = net.createServer((connection) => { connection.setEncoding("utf8"); let buffer = ""; connection.on("data", (chunk) => { buffer += chunk; const newline = buffer.indexOf("\n"); if (newline < 0) return; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); void (async () => { let request; try { request = JSON.parse(line); if (request.schema_id !== REQUEST_SCHEMA || !request.id || !request.operation) throw new DaemonError("daemon_protocol_mismatch", "invalid daemon request"); const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}), () => runtime.dispatch("session.inspect", request.params ?? {})); connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`); if (result?._shutdown) setImmediate(() => void runtime.shutdown().then(() => process.exit(0)).catch(error => runtime.persist({ shutdown_state: "cleanup_failed", cleanup_error: errorPayload(error) }))); } catch (error) { connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`); } })(); }); }); runtime.server = server; await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false }); runtime.ready = true; return await new Promise(() => {});
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

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

@@ -35,7 +35,7 @@ function errorPayload(error) { return { code: error.code ?? "operation_failed",
 async function writePlugin(paths, config) {
   const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
   const helper = new URL("./native-hook-command.mjs", import.meta.url).href;
-  const source = `import { invokeNativeHook } from ${JSON.stringify(helper)};\nconst candidate = command => typeof command === "string" && command.length > 0;\nconst participating = new Set();\nconst invoke = async payload => await invokeNativeHook({bin:process.env.DD_OPENCODE_DD_FLOW_BIN,args:["opencode","event","handle","--project-root",process.env.DD_OPENCODE_PROJECT_ROOT,"--json"],payload,home:process.env.DD_FLOW_HOME,timeoutMs:15000});\nexport const DdFlowPlugin=async({client,project,directory})=>{ const envelope=async(phase,input,extra={})=>{ const response=await client.session.get({path:{id:input.sessionID}}); if(response?.error||!response?.data) throw Object.assign(new Error("OpenCode Session identity is unavailable"),{code:"opencode_session_identity_unavailable"}); const session=response.data; return {schema_id:"dd-flow/opencode-tool-event@1",event_id:[input.sessionID,input.callID,phase].join(":"),phase,daemon_id:process.env.DD_OPENCODE_DAEMON_ID,server_version:process.env.DD_OPENCODE_SERVER_VERSION,plugin_sha256:process.env.DD_OPENCODE_PLUGIN_SHA256,session:{provider_session_id:input.sessionID,parent_provider_session_id:session.parentID??null,agent_id:process.env.DD_OPENCODE_AGENT,directory:session.directory??directory,project_id:session.projectID??project?.id},message_id:input.messageID??null,tool_call_id:input.callID,tool:input.tool,profile:{provider:process.env.DD_OPENCODE_PROVIDER,model:process.env.DD_OPENCODE_MODEL,variant:process.env.DD_OPENCODE_VARIANT,agent:process.env.DD_OPENCODE_AGENT},...extra}; }; return {"tool.execute.before":async(input,output)=>{ const command=output.args?.command; if(!candidate(command)) return; const result=await invoke(await envelope("before",input,{input:output.args})); if(result?.observed) participating.add(input.callID); const updated=result?.hookSpecificOutput?.updatedInput; if(updated) Object.assign(output.args,updated); },"tool.execute.after":async(input,output)=>{ if(!participating.delete(input.callID)) return; await invoke(await envelope("after",input,{input:input.args,outcome:{status:"completed",title:output.title}})); }}; };\n`;
+  const source = `import { hookBudget, invokeNativeHook } from ${JSON.stringify(helper)};\nconst candidate = command => typeof command === "string" && command.length > 0;\nconst participating = new Set();\nconst invoke = async (payload,budget) => await invokeNativeHook({bin:process.env.DD_OPENCODE_DD_FLOW_BIN,args:["opencode","event","handle","--project-root",process.env.DD_OPENCODE_PROJECT_ROOT,"--json"],payload,home:process.env.DD_FLOW_HOME,timeoutMs:budget.remaining("admission",15000)});\nexport const DdFlowPlugin=async({client,project,directory})=>{ const envelope=async(phase,input,extra,budget)=>{ const response=await budget.run(()=>client.session.get({path:{id:input.sessionID}}),"identity"); if(response?.error||!response?.data) throw Object.assign(new Error("OpenCode Session identity is unavailable"),{code:"opencode_session_identity_unavailable"}); const session=response.data; return {schema_id:"dd-flow/opencode-tool-event@1",event_id:[input.sessionID,input.callID,phase].join(":"),phase,daemon_id:process.env.DD_OPENCODE_DAEMON_ID,server_version:process.env.DD_OPENCODE_SERVER_VERSION,plugin_sha256:process.env.DD_OPENCODE_PLUGIN_SHA256,session:{provider_session_id:input.sessionID,parent_provider_session_id:session.parentID??null,agent_id:process.env.DD_OPENCODE_AGENT,directory:session.directory??directory,project_id:session.projectID??project?.id},message_id:input.messageID??null,tool_call_id:input.callID,tool:input.tool,profile:{provider:process.env.DD_OPENCODE_PROVIDER,model:process.env.DD_OPENCODE_MODEL,variant:process.env.DD_OPENCODE_VARIANT,agent:process.env.DD_OPENCODE_AGENT},...extra}; }; return {"tool.execute.before":async(input,output)=>{ const command=output.args?.command; if(!candidate(command)) return; const budget=hookBudget(); const result=await invoke(await envelope("before",input,{input:output.args},budget),budget); if(result?.observed) participating.add(input.callID); const updated=result?.hookSpecificOutput?.updatedInput; if(updated) Object.assign(output.args,updated); },"tool.execute.after":async(input,output)=>{ if(!participating.delete(input.callID)) return; const budget=hookBudget(); await invoke(await envelope("after",input,{input:input.args,outcome:{status:"completed",title:output.title}},budget),budget); }}; };\n`;
   const checksum = createHash("sha256").update(source).digest("hex"); await writeFile(path.join(directory, "dd-flow.js"), source, { mode: 0o600 }); return checksum;
 }
 async function prepare(paths, config, authSource) {
@@ -67,10 +67,10 @@ export const stopDaemon = async options => { const timeoutMs = options.timeoutMs
 
 export class Runtime {
   constructor(paths, state, client, child, providerProcess) { this.paths = paths; this.state = state; this.client = client; this.child = child; this.providerProcess = providerProcess; this.sessions = new Map((state.sessions ?? []).map(x => [x.provider_session_id, x])); this.active = null; this.persisting = Promise.resolve(); }
-  persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.then(async () => { await writeJson(this.paths.state, snapshot); await heartbeatDaemonProcess(snapshot.config, snapshot.resource_process).catch(() => {}); await heartbeatDaemonProcess(snapshot.config, this.providerProcess).catch(() => {}); }); return this.persisting; }
+  persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.then(() => writeJson(this.paths.state, snapshot)); return this.persisting; }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
   async childTree(id, seen = new Set()) { if (seen.has(id)) return []; seen.add(id); const direct = await this.client.children(id) ?? []; const nested = []; for (const child of direct) nested.push(child, ...await this.childTree(child.id, seen)); return nested; }
-  async describe(id) { const [info, messages, children, statuses] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id), this.client.statuses()]); if (path.resolve(info.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode Session directory is outside the controlled workspace", false, { session_directory: info.directory, workspace: this.state.config.cwd }); const status = statuses?.[id]?.type ?? "idle", parent = info.parentID ?? null, existing = this.sessions.get(id); const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: parent ? (this.sessions.get(parent)?.root_provider_session_id ?? parent) : (existing?.root_provider_session_id ?? id), cwd: info.directory }; this.sessions.set(id, record); for (const child of children) if (!this.sessions.has(child.id)) this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID ?? id, root_provider_session_id: record.root_provider_session_id, cwd: child.directory }); const unsettledChildren = children.filter(child => (statuses?.[child.id]?.type ?? "idle") !== "idle").map(child => child.id); const lastAssistant = messages.findLast(message => message.info?.role === "assistant"); const assistantText = (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""); await this.observeModels(id, messages, parent); this.journaledTools ??= new Map(); journalToolObservations(this.state.config.journal, messages.flatMap(message => (message.parts ?? []).map(part => openCodeToolObservation(part, id, message.info?.id))), this.journaledTools); return { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? null, model: lastAssistant?.info?.modelID ?? null, reasoning: lastAssistant?.info?.variant ?? null, mode: info.agent ?? null }, assistant_text: assistantText, info, status, settled: status === "idle" && unsettledChildren.length === 0, unsettled_children: unsettledChildren, children, usage: usageSnapshot(messages, id), history_sha256: historyDigest(messages), message_count: messages.length }; }
+  async describe(id) { const [info, messages, children, statuses] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id), this.client.statuses()]); if (path.resolve(info.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode Session directory is outside the controlled workspace", false, { session_directory: info.directory, workspace: this.state.config.cwd }); const status = statuses?.[id]?.type ?? "idle", parent = info.parentID ?? null, existing = this.sessions.get(id); const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: parent ? (this.sessions.get(parent)?.root_provider_session_id ?? parent) : (existing?.root_provider_session_id ?? id), cwd: info.directory }; this.sessions.set(id, record); for (const child of children) if (!this.sessions.has(child.id)) this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID ?? id, root_provider_session_id: record.root_provider_session_id, cwd: child.directory }); const unsettledChildren = children.filter(child => (statuses?.[child.id]?.type ?? "idle") !== "idle").map(child => child.id); const lastAssistant = messages.findLast(message => message.info?.role === "assistant"); const assistantText = (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""); await this.observeModels(id, messages, parent); this.journaledTools ??= new Map(); journalToolObservations(this.state.config.journal, messages.flatMap(message => (message.parts ?? []).map(part => openCodeToolObservation(part, id, message.info?.id))), this.journaledTools); return { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? null, model: lastAssistant?.info?.modelID ?? null, reasoning: lastAssistant?.info?.variant ?? null, mode: info.agent ?? null }, assistant_text: assistantText, info, status, settled: status === "idle" && unsettledChildren.length === 0, unsettled_children: unsettledChildren, tree_observations: children.map(child => ({ provider_session_id: child.id, status: statuses?.[child.id]?.type ?? "idle", settled: (statuses?.[child.id]?.type ?? "idle") === "idle" })), children, usage: usageSnapshot(messages, id), history_sha256: historyDigest(messages), message_count: messages.length }; }
   async observeModels(id, messages, parent = null) {
     this.modelMessages ??= new Set();
     for (const message of messages ?? []) {
@@ -208,6 +208,8 @@ export async function serveDaemon(stateDir) {
     providerProcess = await registerDaemonProcess(state.config, { kind: "opencode-provider", owner: `opencode:${path.basename(paths.dir)}`, operation: `opencode-provider:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
     child = spawn(target.command, target.args, { cwd: state.config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", "inherit", "inherit"] });
     await confirmDaemonProcess(state.config, providerProcess, child);
+    await heartbeatDaemonProcess(state.config, state.resource_process);
+    await heartbeatDaemonProcess(state.config, providerProcess);
     state.provider_process = providerProcess; state.provider_pid = child.pid; await writeJson(paths.state, state);
     const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const deadline = Date.now() + 15_000; while (Date.now() < deadline) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } } await client.health(); const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths); const server = net.createServer(connection => { connection.setEncoding("utf8"); let buffer = ""; connection.on("data", chunk => { buffer += chunk; const i = buffer.indexOf("\n"); if (i < 0) return; void (async () => { let request; try { request = JSON.parse(buffer.slice(0, i)); const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}), () => runtime.dispatch("session.inspect", request.params ?? {})); connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`); if (result?._shutdown) setImmediate(() => runtime.shutdown().then(() => process.exit(0)).catch(error => runtime.persist({ shutdown_state: "cleanup_failed", cleanup_error: errorPayload(error) }))); } catch (error) { connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`); } })(); }); }); runtime.server = server; await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false, server_port: port }); return await new Promise(() => {});
   } catch (error) {

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

@@ -5,7 +5,7 @@ import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "
 import net from "node:net";
 import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 import {
   AcpBridge,
@@ -228,13 +228,6 @@ export class DaemonRuntime {
     Object.assign(this.state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...this.sessions.values()] });
     const snapshot = structuredClone(this.state);
     this.persisting = this.persisting.then(() => writeState(this.paths.state, snapshot));
-    const resourceProcess = this.state.resource_process;
-    if (resourceProcess?.id && resourceProcess.lease_token) {
-      this.persisting = this.persisting.then(async () => {
-        try { await heartbeatDaemonProcess(this.state.config, resourceProcess); }
-        catch { /* A crashed client is recovered through the durable lease. */ }
-      });
-    }
     return this.persisting;
   }
 
@@ -262,6 +255,8 @@ export class DaemonRuntime {
           // be non-resident and unsubscribable while their request is alive.
           const [resident, topology] = await Promise.all([
             this.bridge.request("zcode/session/resident", { sessionId: adapterSessionId }, 5_000),
+            // childSessionIds is complete on every page. This diagnostic reads
+            // identities only, not ended outcomes or a settlement verdict.
             this.bridge.request("zcode/session/retainedSubagents", { sessionId: adapterSessionId }, 5_000),
           ]);
           diagnostics = {
@@ -586,7 +581,7 @@ export class DaemonRuntime {
   async shutdown() {
     // prepareStop has already closed the owned bridge. Signal shutdown may get
     // here directly, so close remains idempotent.
-    await this.bridge.close();
+    await closeManagedBridge(this.state.config, this.state, this.bridge);
     await this.persist({ active_tree: false, shutdown_state: "clean", stopped_at: new Date().toISOString() });
     const resourceProcess = this.state.resource_process;
     if (resourceProcess?.id && resourceProcess.lease_token) {
@@ -603,8 +598,9 @@ export async function serveDaemon(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");
   const bridge = new AcpBridge({ ...state.config, env: { ...state.config.env, DD_FLOW_DAEMON_ID: state.daemon_id } });
-  const initialized = await bridge.start();
+  const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "zcode-provider", publish: snapshot => writeState(paths.state, snapshot) });
   const runtime = new DaemonRuntime(paths, state, bridge, initialized);
+  await heartbeatDaemonProcess(state.config, state.resource_process);
   await removeSocket(paths.socket, paths.dir);
   const server = net.createServer((connection) => {
     connection.setEncoding("utf8"); let buffer = "";

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

@@ -188,6 +188,7 @@ export class AcpBridge {
     this.child.on("error", (error) => { error.code ??= "bridge_exited"; this.rejectAll(error); });
     this.child.on("exit", (code) => { const error = new Error(`zcode-acp exited ${code}${this.bridgeStderr.trim() ? `: ${this.bridgeStderr.trim()}` : ""}`); error.code = "bridge_exited"; this.rejectAll(error); });
     readline.createInterface({ input: this.child.stdout }).on("line", (line) => this.receive(line));
+    if (this.options.onSpawn) await this.options.onSpawn(this.child);
     return await this.request("initialize", {
       protocolVersion: 1,
       clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, elicitation: { form: {} } },
@@ -455,10 +456,47 @@ async function resume(bridge, sessionId, cwd) {
   return sessionId;
 }
 
+/** Ended children are paginated by the native API (20 by default). A partial
+ * directory is never settlement evidence, including during teardown. */
+export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000, retained = false) {
+  const deadline = performance.now() + timeoutMs;
+  const cursors = new Set(), ended = new Map();
+  let first, cursor;
+  for (;;) {
+    const remaining = deadline - performance.now();
+    if (remaining <= 0) fail("ZCode child observation deadline expired", "native_topology_incomplete");
+    const response = await bridge.request(retained ? "zcode/session/retainedSubagents" : "zcode/session/subagents", { sessionId, ...(cursor ? { endedCursor: cursor } : {}) }, remaining);
+    if (retained && response?.sessionId !== sessionId) fail("Retained ZCode child directory has a foreign Session identity", "native_topology_incomplete");
+    const page = retained ? response.topology : response;
+    if (performance.now() >= deadline) fail("ZCode child observation deadline expired", "native_topology_incomplete");
+    if (!page || !Array.isArray(page.running)) fail("ZCode child directory is unavailable", "native_topology_incomplete");
+    if (!first) first = page;
+    if (!page.ended) {
+      if (cursor) fail("ZCode child page omitted ended outcomes", "native_topology_incomplete");
+      return page; // Older qualified bridges expose an unpaginated completed array.
+    }
+    if (!Array.isArray(page.ended.items) || !Number.isSafeInteger(page.ended.total) || page.ended.total < 0
+      || page.revision !== first.revision || page.ended.total !== first.ended.total) fail("ZCode child directory changed or is malformed during pagination", "native_topology_incomplete");
+    for (const child of page.ended.items) {
+      if (typeof child.childSessionId !== "string" || !child.childSessionId) fail("ZCode ended child has no identity", "native_topology_incomplete");
+      const prior = ended.get(child.childSessionId);
+      if (prior && JSON.stringify(prior) !== JSON.stringify(child)) fail("ZCode child pages contain conflicting outcomes", "native_topology_incomplete");
+      ended.set(child.childSessionId, child);
+    }
+    cursor = page.ended.nextCursor;
+    if (!cursor) {
+      if (ended.size !== first.ended.total) fail("ZCode child directory is incomplete", "native_topology_incomplete");
+      return { ...first, ended: { total: first.ended.total, items: [...ended.values()] } };
+    }
+    if (typeof cursor !== "string" || cursors.has(cursor) || !Number.isSafeInteger(first.revision)) fail("ZCode child pagination has no advancing, versioned cursor", "native_topology_incomplete");
+    cursors.add(cursor);
+  }
+}
+
 async function inspect(bridge, sessionId) {
   const [read, subagents] = await Promise.all([
     bridge.request("zcode/session/read", { sessionId }),
-    bridge.request("zcode/session/subagents", { sessionId }),
+    readZcodeSubagents(bridge, sessionId),
   ]);
   let usage = null, usage_observation_error = null;
   try { usage = await readZcodeUsage(bridge, sessionId); }
@@ -521,9 +559,8 @@ export async function observeClosedZcodeTree(bridge, root, retainedChildren = []
       const resident = await bridge.request("zcode/session/resident", { sessionId }, timeout());
       if (resident?.sessionId !== sessionId || typeof resident.resident !== "boolean") throw new Error("Invalid residency identity or state");
       residents.push(resident);
-      const retained = await bridge.request("zcode/session/retainedSubagents", { sessionId }, timeout());
-      const tree = retained?.topology;
-      if (retained?.sessionId !== sessionId || !Array.isArray(tree?.childSessionIds)
+      const tree = await readZcodeSubagents(bridge, sessionId, deadline - performance.now(), true);
+      if (!Array.isArray(tree?.childSessionIds)
         || tree.childSessionIds.some(id => typeof id !== "string" || !id || id === sessionId)
         || !Array.isArray(tree?.running) || !Array.isArray(tree?.ended?.items)
         || !Number.isSafeInteger(tree.ended.total) || tree.ended.total < 0
@@ -562,7 +599,7 @@ async function cancelTree(bridge, sessionId, before, providerSessionId, retained
     await new Promise((resolve) => setTimeout(resolve, 1000));
     const timeout = Math.max(1, deadline - Date.now());
     [after, read] = await Promise.all([
-      bridge.request("zcode/session/subagents", { sessionId }, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
+      readZcodeSubagents(bridge, sessionId, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
       bridge.request("zcode/session/read", { sessionId }, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
     ]);
     root_status = read?.projection?.status ?? read?.session?.status ?? null;
@@ -588,7 +625,7 @@ export async function cancelChildWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
   const childSessionId = text(options.childSessionId, "--child-session-id");
-  const before = await bridge.request("zcode/session/subagents", { sessionId: identity.adapterSessionId });
+  const before = await readZcodeSubagents(bridge, identity.adapterSessionId);
   const child = (before.running ?? []).find((item) => item.childSessionId === childSessionId);
   if (!child) fail(`ZCode has no running child ${childSessionId}`, "child_not_running");
   const taskId = child.taskId ?? child.agentId;
@@ -597,7 +634,7 @@ export async function cancelChildWithBridge(bridge, options) {
   let after = before;
   for (let attempt = 0; attempt < 6; attempt += 1) {
     await new Promise((resolve) => setTimeout(resolve, 1000));
-    after = await bridge.request("zcode/session/subagents", { sessionId: identity.adapterSessionId });
+    after = await readZcodeSubagents(bridge, identity.adapterSessionId);
     if (!(after.running ?? []).some((item) => item.childSessionId === childSessionId)) break;
   }
   if ((after.running ?? []).some((item) => item.childSessionId === childSessionId)) {
@@ -752,22 +789,19 @@ async function forwardUsageBestEffort(options, providerSessionId, usage, toolCal
 }
 
 export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContract) {
-  // Behavioural evidence: dd-eval production-invocations probes on 2026-09-13
-  // and 2026-09-22. The latter exercised public commands, file-backed JSON,
-  // concurrent children and continuation on bridge contract @2.
-  // Pin both providers of native event identity, not a string in the bundle.
-  // 60af0d3 adds retainedSubagents without changing native event forwarding.
-  const qualifiedTuples = new Map([
-    ["e9f1868c0fdb863537ed910ee3828b9be96b8c2fd805473f63b439e1113266b8", new Set(["e0600fe3c46e215695f257e65aa6f674ced998d8", "60af0d31e13076a313d9770f10aa70f7c94742cf"])],
-    ["500ae84fa2cb8dd74c1264e5f3d3709c004c59b58899f1b0c3e205137a0ef466", new Set(["8c0a893f3c26a0b96cb138acf762db84c800298b", "f4d47b517073f9bdb8d4eba3d0d59ce66c6a2833"])],
-    // ZCode Desktop 3.14.3 retains CLI 0.16.9; the published-engine native probe
-    // passed root, concurrent child, and same-child continuation on this binary.
-    ["b1df2ef3e5bd76c4af3ecb296bc003a10d3f13191a26610bd0ba940feadad529", new Set(["f4d47b517073f9bdb8d4eba3d0d59ce66c6a2833"])],
+  // The native app bundle is an auto-updated runtime.  Its whole-file SHA is
+  // evidence for provenance, not a protocol identity: an unchanged bridge
+  // must not reject every normal ZCode patch release.  The bridge contract is
+  // the compatibility boundary; native event identity is checked by the
+  // lifecycle observer and receipts during the bounded qualification probe.
+  const qualifiedBridgeCommits = new Map([
+    ["e0600fe3c46e215695f257e65aa6f674ced998d8", ZCODE_HARNESS_CONTRACT],
+    ["60af0d31e13076a313d9770f10aa70f7c94742cf", ZCODE_HARNESS_CONTRACT],
+    ["8c0a893f3c26a0b96cb138acf762db84c800298b", ZCODE_HARNESS_CONTRACT],
+    ["f4d47b517073f9bdb8d4eba3d0d59ce66c6a2833", "dd-zcode-harness@2"],
+    ["5a8c89ab716a4b2ccc50df81cb4d204ff5c06368", "dd-zcode-harness@2"],
   ]);
-  const qualified = qualifiedTuples.get(sha256)?.has(bridgeCommit) === true
-    && (bridgeCommit === "f4d47b517073f9bdb8d4eba3d0d59ce66c6a2833"
-      ? harnessContract === "dd-zcode-harness@2"
-      : harnessContract === ZCODE_HARNESS_CONTRACT);
+  const qualified = qualifiedBridgeCommits.get(bridgeCommit) === harnessContract;
   return { status: qualified ? "qualified" : "unqualified", mechanism: "cli-invocation@1", sha256,
     capabilities: qualified ? ["root", "concurrent_children", "child_continuation"] : [],
     native_nested_children: false, reason: qualified ? null : "native_event_contract_unqualified" };
@@ -801,8 +835,11 @@ export async function createSessionWithBridge(bridge, options, initialized) {
   // fact that allocation was already admitted.
   await options.onSessionAliasAllocated?.({ adapter_session_id: created.sessionId, cwd });
   bridge.allocationObservers?.set(created.sessionId, async identity => {
-    if (identity.cwd !== cwd) fail("ZCode allocation workspace mismatch", "session_identity_mismatch");
-    await options.onSessionAllocated?.(identity);
+    // ZCode 0.46.x emits adapter/provider identities on this notification but
+    // does not repeat the workspace. The cwd from session/new is authoritative
+    // for this live bridge; reject only an explicitly conflicting workspace.
+    if (identity.cwd !== undefined && identity.cwd !== cwd) fail("ZCode allocation workspace mismatch", "session_identity_mismatch");
+    await options.onSessionAllocated?.({ ...identity, cwd });
   });
   const resolved = await bridge.request("zcode/session/resolve", { sessionId: created.sessionId });
   const providerSessionId = resolved.providerSessionId;
@@ -918,7 +955,7 @@ export async function cancelSession(options) {
 export async function cancelSessionWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
-  const before = await bridge.request("zcode/session/subagents", { sessionId: identity.adapterSessionId }).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
+  const before = await readZcodeSubagents(bridge, identity.adapterSessionId).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
   return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId, options.knownChildSessionIds) });
 }
 
@@ -931,7 +968,7 @@ export async function forkSessionWithBridge(bridge, options) {
   requireJournal(options);
   if (!options.target || typeof options.target !== "object") fail("explicit --target-json is required");
   const identity = await controlledIdentity(bridge, options);
-  const topology = await bridge.request("zcode/session/subagents", { sessionId: identity.adapterSessionId });
+  const topology = await readZcodeSubagents(bridge, identity.adapterSessionId);
   if ((topology.running ?? []).length) fail("cannot fork while background children are running");
   const result = await bridge.request("session/fork", { sessionId: identity.adapterSessionId, target: options.target });
   if (!result.forkedSessionId) fail("ZCode fork returned no provider Session ID");

package/dist/harness-runtime/lib/delegation-instructions.d.mts

@@ -1,5 +1,5 @@
 export type DelegationWork = { work_id: string; start_command: string; launch_policy?: string };
-export type DelegationInput = { harness: string; stage: string; capacity: number; works?: DelegationWork[] };
+export type DelegationInput = { harness: string; stage: string; capacity: number; works?: DelegationWork[]; totalWorks?: number; remainingWorks?: number };
 export function delegationAdapter(harness: string): string | null;
 export function delegationContract(harness: string): string;
 export function workerDelegationTask(input: { workId: string; startCommand: string; launchPolicy?: string }): string;