@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.155

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

@@ -5,10 +5,10 @@ import { canonicalNativeOperation } from './adapter-timeouts.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { prepareDaemonRequest } from "./native-request-proof.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
-import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
+import { errorRecord, isNativeHookObservationLoss, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
 import { ToolObservations, acpToolObservation } from "./tool-observations.mjs";
-import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
-import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
+import { acceptNativeHookRequest, readNativeHookFailures, writeNativeHookFailure } from "./native-hook-command.mjs";
+import { parseLifecycleCommand, continuationCommand, commandOption } from "./lifecycle-command.mjs";
 import { ObservationClock } from "./observation-clock.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
@@ -43,7 +43,8 @@ const errorPayload = errorRecord;
 function shellQuote(value) { return `'${String(value).replace(/'/g, "'\\''")}'`; }
 
 function executable(command, args = []) { const resolved = command ?? process.env.DD_GROK_BIN ?? "grok"; return /\.[cm]?js$/.test(resolved) ? { command: process.execPath, args: [resolved, ...args] } : { command: resolved, args }; }
-export function isolatedEnv(config) { return { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}), ...managedFlowEnv(config) }; }
+export function isolatedEnv(config) { return { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}), ...managedFlowEnv(config),
+  DD_GROK_STATE_DIR: !config.noFlow && config.daemonId ? config.runtime_owner?.state_dir : undefined }; }
 function within(candidate, root) { const resolved = path.resolve(candidate); const parent = path.resolve(root); return resolved === parent || resolved.startsWith(`${parent}${path.sep}`); }
 
 async function writeIsolatedConfig(paths) {
@@ -185,7 +186,7 @@ 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(options.stateDir) }); }
 
 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(); }
+  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.promptCreators = new Map(); this.childCreators = new Map(); this.childSpawnWaiters = 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; }
   async reduceTerminal(outcome) {
     const session = this.sessions.get(outcome.session_id), turn = session?.native_prompt_operation;
@@ -234,7 +235,7 @@ export class Runtime {
   }
   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) {
+  recordDescendant(value, root, source, fallback, nativeSpawn = false) {
     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;
@@ -273,6 +274,14 @@ export class Runtime {
       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 });
+    if (nativeSpawn && spawned && typeof attempt === "string" && attempt && source === "x.ai/subagent/event") {
+      const promptId = value.parent_prompt_id;
+      const creator = typeof promptId === "string" && promptId ? this.promptCreators.get(JSON.stringify([parent, promptId])) : null;
+      const old = this.childCreators.get(id);
+      if (old && old.attempt === attempt && (old.parent !== parent || typeof promptId === "string" && promptId && old.promptId !== promptId)) throw new DaemonError("native_child_execution_ambiguous", "Grok child attempt has conflicting native creator", false, { session_id: id });
+      if (creator) this.childCreators.set(id, { parent, promptId, attempt, creator });
+      else if (newAttempt) this.childCreators.delete(id);
+    }
     this.sessions.set(id, {
       ...prior,
       provider_session_id: id,
@@ -296,6 +305,7 @@ export class Runtime {
       ...(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 } : {})
     });
+    if (this.childCreators.has(id)) for (const wake of this.childSpawnWaiters.get(id) ?? []) wake();
     if (spawned && typeof value.model === "string" && value.model.trim()) {
       return { sessionId: id, parentSessionId: parent, attemptId: attempt ?? null, parentPromptId: value.parent_prompt_id ?? null, model: value.model.trim() };
     }
@@ -307,7 +317,7 @@ export class Runtime {
     const modelFacts = [];
     if (/subagent/i.test(kind)) {
       for (const value of [update?.subagent, update?.subagentInfo, update?.child, update?.result, update]) {
-        const fact = this.recordDescendant(value, root, "x.ai/subagent/event", /fail|error/i.test(kind) ? "failed" : /cancel/i.test(kind) ? "cancelled" : /complete|finish|done/i.test(kind) ? "completed" : "running");
+        const fact = this.recordDescendant(value, root, "x.ai/subagent/event", /fail|error/i.test(kind) ? "failed" : /cancel/i.test(kind) ? "cancelled" : /complete|finish|done/i.test(kind) ? "completed" : "running", value === update);
         if (fact) modelFacts.push(fact);
       }
     }
@@ -396,7 +406,7 @@ export class Runtime {
     assertDaemonDispatch(this.paths?.dir);
     if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true);
     this.active = name;
-    const current = this.nativeHookOperation = { operationId, sessionId, generation: (this.hookGeneration = (this.hookGeneration ?? 0) + 1), requests: new Map() };
+    const current = this.nativeHookOperation = { operationId, sessionId, generation: (this.hookGeneration = (this.hookGeneration ?? 0) + 1), requests: new Map(), guard: captureDispatchGuard(this) };
     let rejectHook;
     const hookFailed = new Promise((_, reject) => { rejectHook = reject; });
     void hookFailed.catch(() => {});
@@ -406,15 +416,27 @@ export class Runtime {
     // and local archive export must not erase an unrelated Session's receipt.
     if (name === "session.prompt" && this.sessions.has(sessionId)) {
       const session = this.sessions.get(sessionId);
+      if (typeof operationId === "string" && operationId) {
+        current.nativePromptId = randomUUID();
+        // Retain only for this daemon lifetime: a late native spawn or hook
+        // cannot be safely distinguished from an expired one by a timer.
+        // After restart the in-memory correlation is deliberately unavailable.
+        this.promptCreators.set(JSON.stringify([sessionId, current.nativePromptId]), current);
+      }
       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 };
+      session.native_prompt_operation = { daemon_id: this.state.daemon_id, connection_id: this.bridge.connectionId, operation_id: operationId, generation: current.generation,
+        ...(current.nativePromptId ? { native_prompt_id: current.nativePromptId } : {}) };
     }
     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.observeHookFailures(current);
+      if (current.error) throw current.error;
+      const hookDiagnostics = (this.bridge.lifecycleDiagnostics ?? []).filter(item => item.operation_id === current.operationId && item.generation === current.generation);
+      if (hookDiagnostics.length) result.native_hook_diagnostics = [...new Map([...(result.native_hook_diagnostics ?? []), ...hookDiagnostics].map(item => [JSON.stringify(item), item])).values()];
       await this.drainTerminal();
       this.track(result, before);
       const session = this.sessions.get(result.provider_session_id);
@@ -429,41 +451,131 @@ export class Runtime {
       // root-turn proof, not proof that any descendants have stopped. A lost
       // response, bridge error, or failure before dispatch earns no receipt.
       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"); }
+      try { await this.persist({ active_tree: true, active_operation: null }); }
       catch (storage) { error.cleanup_error = errorRecord(storage); }
       throw error;
     }
-    finally { clearInterval(timer); current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; this.active = null; }
+    finally { clearInterval(timer); if (!current.nativePromptId) current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; this.active = null; }
   }
   async observeHookFailures(current = this.nativeHookOperation) {
-    if (!current || this.nativeHookOperation !== current || current.reading) return;
-    current.reading = true;
-    try { await readNativeHookFailures(this.paths.dir, current.requests, current, error => {
-      if (!isProvenShellCorrection(error)) current.reject(error);
-    }); } finally { current.reading = false; }
+    if (!current || this.nativeHookOperation !== current) return;
+    while (current.reading) {
+      await current.reading;
+      if (this.nativeHookOperation !== current) return;
+    }
+    const reading = readNativeHookFailures(this.paths.dir, current.requests, current, error => this.acceptHookFailure(current, error));
+    current.reading = reading;
+    try { await reading; } finally { if (current.reading === reading) current.reading = null; }
+  }
+  acceptHookFailure(current, error) {
+    if (this.nativeHookOperation !== current) return;
+    const unconfirmed = error.details?.native_hook_binding?.native_creator === "unconfirmed";
+    if (!unconfirmed && isProvenShellCorrection(error)) return;
+    if (unconfirmed || isNativeHookObservationLoss(error)) {
+      const diagnostic = { ...errorRecord(error), session_id: current.sessionId, operation_id: current.operationId,
+        generation: current.generation, delivery_stage: "hook_observation", completeness: "incomplete" };
+      this.bridge.lifecycleDiagnostics ??= [];
+      this.bridge.lifecycleDiagnostics.push(diagnostic);
+      try { void Promise.resolve(this.bridge.journal?.write("native_hook_observation_failure", diagnostic)).catch(() => {}); } catch { /* diagnostic is optional */ }
+      return;
+    }
+    current.reject(error);
   }
   async acceptHook(identity, sessionId, payload) {
     const input = payload?.tool_input ?? payload?.toolInput;
     const command = input?.command ?? input?.cmd;
     if ((payload?.hook_event_name ?? payload?.hookEventName) !== "PreToolUse" || typeof command !== "string" || (!["lifecycle", "auxiliary"].includes(parseLifecycleCommand(command).participation) && !continuationCommand(command))) return identity;
-    const current = this.nativeHookOperation, tool = payload.tool_use_id ?? payload.toolUseId ?? payload.tool_call_id;
-    const root = current?.sessionId ?? this.loadedSessionId;
+    const active = this.nativeHookOperation, tool = payload.tool_use_id ?? payload.toolUseId ?? payload.tool_call_id;
+    const root = identity.rootProviderSessionId;
+    const source = sessionId !== root ? this.childCreators.get(sessionId) : null;
+    // An older Grok may not surface creator metadata. Preserve its ordinary
+    // stateful handler, but never turn the current prompt into guessed proof.
+    if (sessionId !== root && !source) return identity;
+    const current = sessionId !== root ? source?.creator : active;
     const pending = [...(this.bridge.pending?.values() ?? [])].some(request => request.method === "session/prompt" && request.sessionId === root);
-    if (!current || !pending || identity.rootProviderSessionId !== root || !tool) throw new DaemonError("native_hook_unproven", "Native hook has no exact active Session operation");
-    const binding = await hookBudget(1_000, null).run(() => acceptNativeHookRequest(this.paths.dir, { daemon_id: this.state.daemon_id, operation_id: current.operationId, turn_generation: current.generation, provider_session_id: sessionId, root_provider_session_id: root, tool_call_id: tool, event: "PreToolUse", command_sha256: createHash("sha256").update(command).digest("hex"), native_cwd: payload.cwd ?? null }, current), "hook_binding");
-    if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "Native hook operation changed during acceptance");
+    const nativePrompt = payload.prompt_id ?? payload.promptId;
+    if (!current || current.sessionId !== root || !tool || sessionId === root && (!pending || active !== current)
+      || sessionId === root && typeof nativePrompt === "string" && nativePrompt && nativePrompt !== current.nativePromptId
+      || sessionId !== root && (source.parent !== identity.parentProviderSessionId || this.promptCreators.get(JSON.stringify([source.parent, source.promptId])) !== current))
+      throw new DaemonError("native_hook_unproven", "Native hook has no exact source-bound Session operation");
+    current.guard(); assertDaemonDispatch(this.paths.dir);
+    const nativePayload = { ...payload, _meta: { ...(payload._meta ?? {}), ddGrok: { ...identity } } };
+    const binding = await acceptNativeHookRequest(this.paths.dir, { daemon_id: this.state.daemon_id, operation_id: current.operationId, turn_generation: current.generation,
+      provider_session_id: sessionId, root_provider_session_id: root, parent_provider_session_id: identity.parentProviderSessionId ?? null,
+      tool_call_id: tool, event: "PreToolUse", command_sha256: createHash("sha256").update(command).digest("hex"), native_cwd: payload.cwd ?? null,
+      native_creator: source || typeof nativePrompt === "string" && nativePrompt && nativePrompt === current.nativePromptId ? "confirmed" : "unconfirmed",
+      ...(source ? { source_harness: "grok-acp", native_command: command, native_payload: nativePayload } : {}) }, current);
+    current.guard();
+    if (sessionId === root && this.nativeHookOperation !== current || sessionId !== root && this.childCreators.get(sessionId) !== source)
+      throw new DaemonError("native_hook_unproven", "Native hook operation changed during acceptance");
     current.requests.set(binding.request_id, { current, binding });
-    return { ...identity, nativeHookBinding: binding };
+    const parsed = parseLifecycleCommand(command);
+    const fastAck = Boolean(source && parsed.kind === "standalone" && parsed.invocation.operation === "work_start" && commandOption(parsed.invocation, "invocation-id"));
+    return { ...identity, nativeHookBinding: binding, ...(fastAck ? { fastAck: true } : {}) };
+  }
+  async waitForChildCreator(sessionId, deadlineAt) {
+    const remaining = deadlineAt - Date.now();
+    if (this.childCreators.has(sessionId) || !Number.isSafeInteger(deadlineAt) || remaining <= 0 || remaining > 30_000) return;
+    // Leave most of the existing host budget to the legacy handler if this
+    // provider omits the optional spawn correlation; do not poll the provider.
+    const waitMs = Math.floor(remaining / 3);
+    if (!waitMs) return;
+    await new Promise(resolve => {
+      const waiters = this.childSpawnWaiters.get(sessionId) ?? new Set();
+      const wake = () => { clearTimeout(timer); waiters.delete(wake); if (!waiters.size) this.childSpawnWaiters.delete(sessionId); resolve(); };
+      const timer = setTimeout(wake, waitMs);
+      waiters.add(wake); this.childSpawnWaiters.set(sessionId, waiters);
+    });
+  }
+  hookOwner(binding) {
+    if (!binding?.request_id) return null;
+    const owners = new Set([this.nativeHookOperation, ...this.promptCreators.values()]);
+    for (const owner of owners) {
+      if (!owner || owner.operationId !== binding.operation_id || owner.generation !== binding.turn_generation) continue;
+      const accepted = owner.requests.get(binding.request_id);
+      if (accepted?.current === owner && JSON.stringify(accepted.binding) === JSON.stringify(binding)) return owner;
+    }
+    return null;
   }
   async dispatch(operation, params, operationId = null) {
     const assertDispatch = captureDispatchGuard(this);
     if (["session.create", "session.prompt", "session.fork", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     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 && !this.state.shutdown?.phases?.tree) 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 await this.acceptHook({ daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }, sessionId, params.payload); }
-    if (operation === "hook.failed") { await this.observeHookFailures(); return { observed: true }; }
+    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 || session.parent_provider_session_id) && !this.childCreators.has(sessionId) && this.promptCreators.size) { await this.waitForChildCreator(sessionId, params.hookDeadlineAt); 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 await this.acceptHook({ daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }, sessionId, params.payload); }
+    if (operation === "hook.verify") {
+      if (params.daemonId !== this.state.daemon_id) throw new DaemonError("native_hook_unproven", "Native hook daemon identity differs");
+      const owner = this.hookOwner(params.binding);
+      if (!owner) throw new DaemonError("native_hook_unproven", "Native hook has no matching retained operation");
+      owner.guard(); assertDaemonDispatch(this.paths.dir);
+      return { verified: true, nativeHookBinding: params.binding };
+    }
+    if (operation === "hook.failed") {
+      if (params.binding !== undefined || params.failure !== undefined) {
+        const binding = params.binding, failure = params.failure;
+        const current = this.hookOwner(binding);
+        while (current?.reading) await current.reading;
+        const accepted = current?.requests.get(binding?.request_id);
+        if (!current || this.hookOwner(binding) !== current || accepted?.current !== current || JSON.stringify(accepted.binding) !== JSON.stringify(binding)
+          || typeof failure?.code !== "string" || typeof failure?.message !== "string")
+          throw new DaemonError("native_hook_unproven", "Hook failure has no exact current owned delivery");
+        current.guard(); assertDaemonDispatch(this.paths.dir);
+        if (this.nativeHookOperation !== current) {
+          // The creator has returned. Retain the bound failure under its
+          // original operation, without rejecting the newer productive turn.
+          await writeNativeHookFailure(this.paths.dir, binding, reportedError(failure, "Native hook failed"));
+          return { observed: true, retained: true };
+        }
+        current.requests.delete(binding.request_id);
+        const error = reportedError(failure, "Native hook failed");
+        error.details = { ...error.details, native_hook_binding: binding };
+        this.acceptHookFailure(current, error);
+        return { observed: true };
+      }
+      await this.observeHookFailures(); return { observed: true };
+    }
     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.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch, operationId, nativePromptId: this.nativeHookOperation?.nativePromptId }); 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 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; }

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

@@ -153,12 +153,14 @@ export async function promptSessionWithBridge(bridge, options) {
   const local = { ...options, rootProviderSessionId: options.rootProviderSessionId ?? sessionId }; const initial_usage_error = await forwardUsageBestEffort(local, sessionId, await sessionUsage(bridge, sessionId), sessionToolCalls(local, bridge, sessionId));
   options.assertDispatch?.();
   bridge.dispatchOperationId = options.operationId;
-  const cursor = bridge.toolCursor(); const textCursor = bridge.assistantTextCursor(sessionId); const turn = await bridge.request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }] }, null, { idleSessionId: sessionId, idleTimeoutMs: options.livenessTimeoutMs ?? options.timeoutMs ?? 600_000 });
+  const diagnosticsCursor = bridge.lifecycleDiagnostics?.length ?? 0;
+  const cursor = bridge.toolCursor(); const textCursor = bridge.assistantTextCursor(sessionId); const turn = await bridge.request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }], ...(options.nativePromptId ? { _meta: { promptId: options.nativePromptId } } : {}) }, null, { idleSessionId: sessionId, idleTimeoutMs: options.livenessTimeoutMs ?? options.timeoutMs ?? 600_000 });
   try {
   await bridge.flush();
   const evidence = await inspect(bridge, sessionId, local); evidence.tool_calls = recordToolCalls(local, bridge, sessionId, cursor); const usage_ingest_error = await forwardUsageBestEffort(local, sessionId, evidence.usage, evidence.tool_calls); if (initial_usage_error) evidence.initial_usage_error = initial_usage_error; if (usage_ingest_error) evidence.usage_ingest_error = usage_ingest_error;
   if (!options.allowBackground && (evidence.subagents?.subagents ?? []).length) { await cancelTree(bridge, sessionId); fail("background Grok Build subagents cannot outlive the one-shot dd-grok connection"); }
-  return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, assistant_text: bridge.assistantTextSince(sessionId, textCursor), turn, profile: profileReceipt, evidence });
+  const diagnostics = (bridge.lifecycleDiagnostics ?? []).slice(diagnosticsCursor).filter(item => item.session_id === sessionId);
+  return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, assistant_text: bridge.assistantTextSince(sessionId, textCursor), turn, profile: profileReceipt, evidence, ...(diagnostics.length ? { native_hook_diagnostics: diagnostics } : {}) });
   } catch (error) { throw Object.assign(new Error("Grok native Turn completed but mandatory observation failed", { cause: error }), { code: "native_outcome_observation_failed", retryable: false,
     details: { provider_session_id: sessionId, native_outcome: { status: "completed", turn }, observation_error: errorRecord(error), settled: false, journal_locator: options.journal } }); }
 }

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

@@ -1,6 +1,7 @@
 import { managedFlowEnv } from './managed-flow-env.mjs';
 import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
+import { operationProgressReporter } from './operation-progress.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { prepareDaemonRequest } from "./native-request-proof.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
@@ -13,7 +14,7 @@ import net from "node:net";
 import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon, assertDaemonDispatch, assertDaemonRestartable } from "./daemon-operations.mjs";
 import { waitForSettlement } from "./session-settlement.mjs";
 import { nativeExecutionReceipt } from "./native-children.mjs";
-import { errorRecord, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
+import { diagnosticJson, errorRecord, isNativeHookObservationLoss, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
 import { checkObservedProfile, observeModel, observedFields, readModelObservations } from "./model-observations.mjs";
 import os from "node:os";
 import path from "node:path";
@@ -21,7 +22,9 @@ import { parse as parseJsonc } from "jsonc-parser";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { OpenCodeClient, OpenCodeError, historyDigest, usageSnapshot, nativeModel } from "./dd-opencode.mjs";
 import { safeProviderError } from "./provider-overload-policy.mjs";
-import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
+import { acceptNativeHookRequest, hookBudget, readNativeHookFailures, writeNativeHookFailure, retainNativeWorkStart } from "./native-hook-command.mjs";
+import { isDeepStrictEqual } from "node:util";
+import { parseLifecycleCommand } from "./lifecycle-command.mjs";
 import { assertStartupChild, retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-opencode/daemon-request@1", RESPONSE_SCHEMA = "dd-opencode/daemon-response@1", STATE_SCHEMA = "dd-opencode/daemon-state@2", ARCHIVE_SCHEMA = "dd-opencode/session-archive@2";
@@ -68,7 +71,7 @@ const errorPayload = errorRecord;
 
 async function writePlugin(paths, config) {
   const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
-  const source = `import { makeOpenCodePlugin } from ${JSON.stringify(new URL("./opencode-plugin.mjs", import.meta.url).href)};\nexport default makeOpenCodePlugin(${JSON.stringify({ stateDir: paths.dir, daemonId: config.daemonId, version: config.version, ddFlowBin: config.ddFlowBin, nodeBin: process.execPath, ddFlowHome: config.ddFlowHome, projectRoot: config.projectRoot, resourceHome: config.resourceHome })});\n`;
+  const source = `import { makeOpenCodePlugin } from ${JSON.stringify(new URL("./opencode-plugin.mjs", import.meta.url).href)};\nexport default makeOpenCodePlugin(${JSON.stringify({ stateDir: paths.dir, daemonId: config.daemonId, version: config.version, ddFlowBin: config.ddFlowBin, nodeBin: process.execPath, ddFlowHome: config.ddFlowHome, projectRoot: config.projectRoot, resourceHome: config.resourceHome, nativeWorkStartAdmission: true })});\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) {
@@ -188,7 +191,9 @@ export class Runtime {
         throw new DaemonError("session_identity_mismatch", "OpenCode retained Session identity is invalid or duplicated");
       this.sessions.set(record.provider_session_id, record);
     }
-    this.active = null; this.persisting = Promise.resolve(); }
+    // ponytail: retained participating hooks live until daemon retirement;
+    // add durable per-tool retirement only if long-lived Sessions need it.
+    this.active = null; this.persisting = Promise.resolve(); this.retainedHookRequests = new Map(); }
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.catch(() => {}).then(() => writeJson(this.paths.state, snapshot)); return this.persisting; }
   retainSession(info, root) {
     const id = info.id, parent = info.fork ? null : info.parentID ?? null, retained = this.sessions.get(id);
@@ -211,13 +216,14 @@ export class Runtime {
       throw new OpenCodeError("opencode_unavailable", "OpenCode child directory binding is not yet observable");
     return this.retainSession(info, root);
   }
-  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()) {
+  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, ...(result?.native_hook_diagnostic ? { native_hook_diagnostic: JSON.parse(diagnosticJson(result.native_hook_diagnostic)) } : {}) })}\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(), onProgress = async () => {}) {
     if (seen.has(id)) throw new DaemonError("session_identity_mismatch", "OpenCode native topology contains a cycle");
     seen.add(id); const direct = await this.ownedChildren(id), nested = [];
+    await onProgress(`children:${id}:${createHash('sha256').update(JSON.stringify(direct)).digest('hex')}`);
     for (const child of direct) {
       if (!child.id || child.parentID !== id) throw new DaemonError("session_identity_mismatch", "OpenCode child has a foreign native parent");
-      nested.push(child, ...await this.childTree(child.id, seen));
+      nested.push(child, ...await this.childTree(child.id, seen, onProgress));
     }
     return nested;
   }
@@ -416,8 +422,27 @@ export class Runtime {
     current.reading = readNativeHookFailures(this.paths.dir, current.requests, current, error => this.retainHookFailure(current, error));
     try { await current.reading; } finally { current.reading = null; }
   }
-  retainHookFailure(current, error) {
-    if (this.nativeHookOperation !== current || isProvenShellCorrection(error)) return;
+  async retainHookFailure(current, error, unconfirmed = false) {
+    if (this.nativeHookOperation !== current) return;
+    if (unconfirmed || error.details?.native_hook_binding?.native_creator === 'unconfirmed') {
+      // A Session/tree association is not the native creator Turn. Preserve
+      // the real refusal, but do not abort the prompt merely being observed.
+      const diagnostic = { code: 'native_hook_failed', native_creator: 'unconfirmed', observer_operation_id: current.operationId, observer_turn_generation: current.generation, primary_error: errorRecord(error) };
+      (current.hookDiagnostics ??= []).push(diagnostic);
+      try { await this.journal('native_hook_observation_unavailable', { provider_session_id: current.sessionId, native_hook_diagnostic: diagnostic }); }
+      catch (storage) { process.stderr.write(`${diagnosticJson({ native_hook_diagnostic: diagnostic, journal_error: errorRecord(storage) })}\n`); }
+      return;
+    }
+    if (isProvenShellCorrection(error)) return;
+    if (isNativeHookObservationLoss(error)) {
+      // A timed-out observer has not established whether the owned CLI ran.
+      // The CLI still owns admission and the native turn owns its outcome.
+      const diagnostic = errorRecord(error);
+      (current.hookDiagnostics ??= []).push(diagnostic);
+      try { await this.journal("native_hook_observation_unavailable", { provider_session_id: current.sessionId, native_hook_diagnostic: diagnostic }); }
+      catch (storage) { process.stderr.write(`${diagnosticJson({ native_hook_diagnostic: diagnostic, journal_error: errorRecord(storage) })}\n`); }
+      return;
+    }
     error.details = { ...error.details, provider_session_id: current.sessionId, native_outcome: "unknown", native_turn_items: { observed: true, possible_effects: true, pending: true } };
     current.failure ??= error;
   }
@@ -425,12 +450,46 @@ export class Runtime {
     const assertDispatch = captureDispatchGuard(this);
     if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     if (operation === "daemon.status") { const { password, ...config } = this.state.config; return { daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, auth_status: this.state.auth_status, shutdown_state: this.state.shutdown_state, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config }; }
+    if (operation === "hook.register") {
+      if (!this.state.config.runtime_owner || !this.state.config.ddFlowBin) return {};
+      assertDaemonDispatch(this.paths.dir);
+      const payload = params.payload, observer = this.nativeHookOperation ?? this.lastNativeHookOperation;
+      if (typeof params.sessionId !== "string" || !params.sessionId || typeof payload?.message_id !== "string" || !payload.message_id
+        || typeof payload?.tool_call_id !== "string" || !payload.tool_call_id || !observer?.sessionId) throw new DaemonError("native_hook_unproven", "Native Work start lacks physical callback identity");
+      this.retainedWorkStarts ??= new Map();
+      const tool = `${payload.message_id}:${payload.tool_call_id}`;
+      const accepted = await retainNativeWorkStart(this.paths.dir, { daemon_id: this.state.daemon_id, source_harness: "opencode-server",
+        root_provider_session_id: observer.sessionId, provider_session_id: params.sessionId, parent_provider_session_id: null,
+        tool_call_id: tool, event: "PreToolUse", native_command: payload.input?.command, native_cwd: null,
+        native_payload: { schema_id: "dd-flow/opencode-tool-event@1", phase: "before", event_id: [this.state.daemon_id, params.sessionId, payload.message_id, payload.tool_call_id].join(":"),
+          daemon_id: this.state.daemon_id, message_id: payload.message_id, tool_call_id: tool, tool: "shell", input: payload.input,
+          session: { provider_session_id: params.sessionId } } }, observer, this.retainedWorkStarts);
+      return accepted ? { fastAck: true, nativeHookBinding: accepted } : {};
+    }
     if (operation === "hook.resolve") {
-      const current = this.nativeHookOperation, sessionId = params.sessionId, payload = params.payload;
+      const payload = params.payload;
+      if (params.deferWorkStart === true && !this.state.config.noFlow && this.state.config.runtime_owner && this.state.config.ddFlowBin
+        && ["before", "after"].includes(payload?.phase) && typeof params.sessionId === "string" && params.sessionId
+        && typeof payload.message_id === "string" && payload.message_id && typeof payload.tool_call_id === "string" && payload.tool_call_id
+        && typeof payload.input?.command === "string") {
+        const analysis = parseLifecycleCommand(payload.input.command);
+        if (analysis.participation === "none" && !analysis.unresolved) {
+          // No lifecycle authority is involved. Native SSE/history still own
+          // source-bound progress; an unknown child callback is only a hint.
+          return { observationOnly: true, daemonId: this.state.daemon_id, sessionId: params.sessionId,
+            messageId: payload.message_id, toolCallId: payload.tool_call_id, command: payload.input.command };
+        }
+      }
+      if (params.deferWorkStart === true && params.payload?.phase === "before") {
+        const pending = await this.dispatch("hook.register", params);
+        if (pending.fastAck === true) return pending;
+      }
+      const current = this.nativeHookOperation, sessionId = params.sessionId;
       if (!current || !sessionId || typeof payload?.input?.command !== "string" || typeof payload.tool_call_id !== "string" || !payload.tool_call_id || typeof payload.message_id !== "string" || !payload.message_id || !["before", "after"].includes(payload.phase))
         throw new DaemonError("native_hook_unproven", "OpenCode hook has no exact active operation");
       let owned = sessionId === current.sessionId || this.sessions.get(sessionId)?.root_provider_session_id === current.sessionId;
       try {
+        const guard = current.guard ?? captureDispatchGuard(this); guard();
         const tree = await this.childTree(current.sessionId);
         if (sessionId !== current.sessionId && !tree.some(child => child.id === sessionId && !child.fork)) throw new DaemonError("foreign_session", "OpenCode hook Session is outside the owned native tree");
         owned = true;
@@ -440,29 +499,66 @@ export class Runtime {
         if (payload.input.workdir !== undefined && typeof payload.input.workdir !== "string") throw new DaemonError("native_hook_unproven", "OpenCode hook workdir must be a string");
         if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode operation changed during hook identity observation");
         const accepted = await acceptNativeHookRequest(this.paths.dir, { daemon_id: this.state.daemon_id, operation_id: current.operationId, turn_generation: current.generation,
-          provider_session_id: sessionId, root_provider_session_id: current.sessionId, tool_call_id: `${payload.message_id}:${payload.tool_call_id}`, event: payload.phase === "after" ? "PostToolUse" : "PreToolUse",
+          provider_session_id: sessionId, root_provider_session_id: current.sessionId, native_creator: 'unconfirmed', tool_call_id: `${payload.message_id}:${payload.tool_call_id}`, event: payload.phase === "after" ? "PostToolUse" : "PreToolUse",
           command_sha256: createHash("sha256").update(payload.input.command).digest("hex"), native_cwd: path.resolve(native.directory, payload.input.workdir ?? ".") }, current);
         if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode operation changed during hook acceptance");
-        current.requests.set(accepted.request_id, { current, binding: accepted }); return { nativeHookBinding: accepted, nativeSession: {
+        guard(); current.requests.set(accepted.request_id, { current, binding: accepted, guard }); return { nativeHookBinding: accepted, nativeSession: {
           id: native.id, directory: native.directory, parentID: native.parentID, projectID: native.projectID,
           model: { providerID: native.model?.providerID, id: native.model?.id, variant: native.model?.variant }
         } };
       } catch (error) {
-        if (owned) this.retainHookFailure(current, error);
+        if (owned) await this.retainHookFailure(current, error, true);
         throw error;
       }
     }
     if (operation === "hook.verify") {
       const current = this.nativeHookOperation, binding = params.binding;
+      if (binding?.native_admission === "assigned_work_start") {
+        const retained = this.retainedWorkStarts?.get(params.requestId);
+        if (!retained || !isDeepStrictEqual(retained.binding, binding)) throw new DaemonError("native_hook_unproven", "Unknown native Work start callback");
+        retained.guard(); assertDaemonDispatch(this.paths.dir);
+        const root = binding.root_provider_session_id, id = binding.provider_session_id;
+        const report = operationProgressReporter();
+        const checkpoint = cursor => report('verification_progress', { native_request_id: cursor, session_id: id });
+        const tree = await this.childTree(root, new Set(), checkpoint), child = tree.find(node => node.id === id);
+        if (id !== root && (!child || child.fork)) throw new DaemonError("foreign_session", "Native Work start is outside its controlled tree");
+        const native = await this.client.inspect(id);
+        await checkpoint(`session:${id}:${createHash('sha256').update(JSON.stringify(native)).digest('hex')}`);
+        if (native.id !== id || native.fork || !path.isAbsolute(native.directory ?? "") || child && native.parentID !== child.parentID
+          || id === root && native.parentID) throw new DaemonError("native_hook_identity_conflict", "Native Work start ancestry is contradictory");
+        const input = binding.native_payload.input;
+        if (input.workdir !== undefined && typeof input.workdir !== "string") throw new DaemonError("native_hook_unproven", "Native Work start has invalid workdir");
+        retained.guard();
+        const cwd = path.resolve(native.directory, input.workdir ?? "."), parent = native.parentID ?? null;
+        const verified = { ...binding, parent_provider_session_id: parent, native_cwd: cwd, native_ancestry: "confirmed",
+          native_payload: { ...binding.native_payload, input: { ...input, workdir: cwd }, session: { provider_session_id: id, parent_provider_session_id: parent, directory: cwd },
+            profile: { provider: native.model?.providerID, model: native.model?.id, variant: native.model?.variant ?? "default" } } };
+        return { verified: true, registeredHookBinding: binding, nativeHookBinding: verified };
+      }
+      if (params.phase === "after") {
+        const retained = this.retainedHookRequests.get(binding?.request_id);
+        if (!retained || JSON.stringify(retained.binding) !== JSON.stringify(binding)) throw new DaemonError("native_hook_unproven", "OpenCode after hook has no retained original delivery");
+        assertDaemonDispatch(this.paths.dir); retained.guard();
+        return { current: true, retained: true };
+      }
       if (!current || binding?.operation_id !== current.operationId || binding?.turn_generation !== current.generation
         || JSON.stringify(current.requests.get(binding?.request_id)?.binding) !== JSON.stringify(binding)) throw new DaemonError("native_hook_unproven", "OpenCode hook generation is no longer current");
+      const accepted = current.requests.get(binding.request_id); assertDaemonDispatch(this.paths.dir); accepted.guard();
+      if (params.retain_after === true && binding.event === "PreToolUse") this.retainedHookRequests.set(binding.request_id, { binding, guard: accepted.guard });
       return { current: true };
     }
     if (operation === "hook.failed") {
       if (params.failure) {
-        await this.dispatch("hook.verify", { binding: params.binding });
         if (JSON.stringify(params.failure.details?.native_hook_binding) !== JSON.stringify(params.binding) || !params.failure.details?.receipt_error || typeof params.failure.code !== "string" || typeof params.failure.message !== "string") throw new DaemonError("native_hook_receipt_invalid", "OpenCode fallback hook error is not bound");
-        this.retainHookFailure(this.nativeHookOperation, reportedError(params.failure, "Native hook failed"));
+        const current = this.nativeHookOperation, binding = params.binding;
+        const isCurrent = current && binding?.operation_id === current.operationId && binding?.turn_generation === current.generation
+          && JSON.stringify(current.requests.get(binding?.request_id)?.binding) === JSON.stringify(binding);
+        await this.dispatch("hook.verify", isCurrent ? { binding } : { binding, phase: "after" });
+        // The caller's write failed. Do not acknowledge the fallback until the
+        // same owner-bound failure is durable; a late after never poisons the
+        // currently active, different prompt.
+        await writeNativeHookFailure(this.paths.dir, binding, reportedError(params.failure, "Native hook failed"));
+        if (!isCurrent) return { observed: true, retained: true };
       }
       await this.observeHookFailures(); return { observed: true };
     }
@@ -497,8 +593,9 @@ export class Runtime {
     if (operation === "session.inspect" || operation === "session.resume") { const result = await this.describe(params.sessionId); await this.persist(); return result; }
     if (operation === "session.prompt") { await this.requireSettled(params.sessionId); return this.productive(operation, async () => {
       this.state.operations ??= {}; const key = operationId ?? randomUUID(), retained = this.state.operations[key];
-      const current = { operationId: key, sessionId: params.sessionId, generation: (this.state.hook_generation ?? 0) + 1, requests: new Map(), failure: null };
+      const current = { operationId: key, sessionId: params.sessionId, generation: (this.state.hook_generation ?? 0) + 1, requests: new Map(), failure: null, guard: assertDispatch };
       this.state.hook_generation = current.generation; this.nativeHookOperation = current;
+      this.lastNativeHookOperation = current;
       const checkHookFailures = async () => { await this.observeHookFailures(current); if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode prompt generation changed"); if (current.failure) throw current.failure; };
       let reply;
       try { assertDispatch(); reply = await this.client.prompt(params.sessionId, { prompt: params.prompt, messageId: retained?.message_id ?? `msg_${randomUUID().replaceAll("-", "")}`, retained,
@@ -523,6 +620,7 @@ export class Runtime {
       if (!result.route_conformance.matches) throw new DaemonError("invocation_directory_mismatch", "Owned OpenCode Session moved during execution", false, { ...result.route_violations[0], native_outcome: result.terminal_status, settled: result.settled, result });
       result.response_message_id = reply.info.id;
       result.observed_profile = { ...reply_profile, mode: result.info.agent ?? reply_profile.mode };
+      if (current.hookDiagnostics?.length) result.native_hook_diagnostics = current.hookDiagnostics;
       checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: expectedAgent }, result.observed_profile); result.usage_ingest_errors = await this.reconcileUsage(result); return result; }); }
     if (operation === "session.fork") { const source = await this.requireSettled(params.sessionId); return this.productive(operation, async () => {
       const info = await this.client.fork(params.sessionId, params.messageId);

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

@@ -2,7 +2,6 @@ import { createHash, randomUUID } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { ToolObservations, openCodeToolObservation } from "./tool-observations.mjs";
 import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
-import { assertNativeLine } from "./native-streams.mjs";
 import { operationProgressReporter } from "./operation-progress.mjs";
 import { classifyRecoveryError as classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 
@@ -98,7 +97,7 @@ export class OpenCodeClient {
       const options = { signal: controller.signal };
       const pending = input === undefined ? domain[name](options) : domain[name](input, options);
       void pending.catch(() => {}); await onDispatched?.(); const result = await pending;
-      assertNativeLine(JSON.stringify(result ?? null)); return result;
+      return result;
     } catch (cause) {
       if (cause instanceof OpenCodeError || cause.code === "operation_observation_lost") throw cause;
       if (cause._tag === "SessionNotFoundError" || cause._tag === "NotFoundError") throw new OpenCodeError("session_not_found", "OpenCode native Session is unavailable");
@@ -329,9 +328,13 @@ export class OpenCodeClient {
                 const child = (await childrenOf(id, visited)).find(child => child.id === item.info.metadata.childID);
                 if (child) await observe(child.id, visited);
               }
-              if (item.info.role === "user" || item.info.role === "synthetic" && !(
-                item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) === id
-                || item.info.metadata?.source === "shell" && shellCursors.has(item.info.metadata.shellID)))
+              // Native continuation messages are synthetic, including retries
+              // without metadata. Only actual user input crosses the owned
+              // operation boundary. Claimed child/shell delivery is validated
+              // separately before it can settle a background task.
+              if (item.info.role === "user" || item.info.role === "synthetic" && (
+                item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) !== id
+                || item.info.metadata?.source === "shell" && !shellCursors.has(item.info.metadata.shellID)))
                 throw new OpenCodeError("opencode_foreign_input", "OpenCode received input outside the owned operation", false, { session_id: id, message_id: item.info.id, role: item.info.role, source: item.info.metadata?.source });
             }
             const terminal = rootMessages.slice(deliveredIndex + 1).findLast(item => item.info.role === "idle");
@@ -344,8 +347,8 @@ export class OpenCodeClient {
           // A background child's native completion notification is delivered
           // asynchronously. An idle parent before that delivery is not the
           // completion of the coordinating operation.
-          const deliveredNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "subagent").map(item => item.info.metadata.childID));
-          const shellNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "shell").map(item => item.info.metadata.shellID));
+          const deliveredNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) === id).map(item => item.info.metadata.childID));
+          const shellNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "shell" && shellCursors.has(item.info.metadata.shellID)).map(item => item.info.metadata.shellID));
           unsettled ||= [...backgroundShells].some(shell => !shellNotifications.has(shell));
           for (const item of current) for (const part of item.parts) {
             if (part.tool === "subagent" && part.state?.input?.background === true) {

package/dist/harness-runtime/lib/dd-zcode-daemon.d.mts

@@ -0,0 +1 @@
+export function callDaemon(stateDir: string, operation: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;