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

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,15 +14,17 @@ 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 { checkObservedProfile, observeModel } from "./model-observations.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";
 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);
@@ -202,13 +207,23 @@ export class Runtime {
     const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: root, cwd: info.directory };
     this.sessions.set(id, record); return record;
   }
-  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()) {
+  registerObservedChild(info, root) {
+    const owner = this.sessions.get(root);
+    if (!owner || owner.parent_provider_session_id || owner.root_provider_session_id !== root
+      || info.id === root || info.parentID !== root || info.fork)
+      throw new DaemonError("session_identity_mismatch", "OpenCode child is not a direct member of the owned root");
+    if (typeof info.directory !== "string" || !path.isAbsolute(info.directory))
+      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, ...(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;
   }
@@ -299,17 +314,52 @@ export class Runtime {
     return nativeExecutionReceipt(receipt, { daemonId: this.state.daemon_id, revision: before.get(id) ?? 0 });
   }
   async observeModels(id, messages, parent = null) {
-    this.modelMessages ??= new Set();
+    const journal = this.state.config.journal ?? this.paths.journal;
+    if (!this.modelMessages) {
+      this.modelMessages = new Map();
+      for (const event of journal ? await readModelObservations(journal) : []) {
+        if (event.harness !== 'opencode-server' || event.source?.method !== 'session/message' || !event.source.message_id) continue;
+        const key = `${event.session_id}:${event.source.message_id}`;
+        if (event.evidence_conflict) { const prior = this.modelMessages.get(key); if (prior) prior.conflicted = true; continue; }
+        if (!this.modelMessages.has(key)) this.modelMessages.set(key, { source: event.source,
+          known: { parent: event.parent_session_id, root: event.native_agent_role?.launch?.root_session_id,
+            role: event.native_agent_role ?? null, requested: observedFields(event.requested), observed: observedFields(event.observed) } });
+      }
+    }
     for (const message of messages ?? []) {
       const info = message.info;
-      if (info?.role !== "assistant" || !info.id || this.modelMessages.has(info.id)) continue;
+      if (info?.role !== "assistant" || !info.id) continue;
       if (info.sessionID && info.sessionID !== id) throw new DaemonError("session_identity_mismatch", "native message belongs to another Session");
-      await observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
-        requested: { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent },
-        nativeAgentRole: this.state.config.workerLaunchConfig ? { name: info.mode ?? null, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
-          launch: { ...this.state.config.workerLaunchConfig, root_session_id: this.sessions.get(id)?.root_provider_session_id ?? null } } : null,
-        observed: { provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode }, source: { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}:${info.modelID}`).digest("hex") }, evidence: "response" });
-      this.modelMessages.add(info.id);
+      const record = this.sessions.get(id);
+      if (record && (record.parent_provider_session_id ?? null) !== parent)
+        throw new DaemonError("session_identity_mismatch", "OpenCode observed message parent changed");
+      if (!record?.root_provider_session_id || !info.mode) {
+        await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
+          source: { channel: "native.message_observer", scope: "response", non_asserting: true }, evidence: "unavailable", reason: "native_role_binding_unavailable" });
+        continue;
+      }
+      const requested = { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent };
+      const nativeAgentRole = this.state.config.workerLaunchConfig ? { name: info.mode, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
+        launch: { ...this.state.config.workerLaunchConfig, root_session_id: record.root_provider_session_id } } : null;
+      const observed = observedFields({ provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode });
+      const tuple = { parent, root: record.root_provider_session_id, role: nativeAgentRole, requested: observedFields(requested), observed };
+      const key = `${id}:${info.id}`, previous = this.modelMessages.get(key);
+      if (previous?.conflicted) throw new DaemonError("model_observation_identity_conflict", "OpenCode native message has a retained identity/profile conflict", false, { session_id: id, message_id: info.id });
+      const conflicts = (before, after) => before != null && after != null && (typeof before === "object" && typeof after === "object"
+        ? [...new Set([...Object.keys(before), ...Object.keys(after)])].some(field => conflicts(before[field], after[field])) : before !== after);
+      if (previous && !conflicts(previous.known, tuple)) {
+        // Optional disclosure can arrive late. Do not rewrite the old native fact;
+        // remember known values only to detect a later positive contradiction.
+        for (const [field, value] of Object.entries(observed)) if (value != null) previous.known.observed[field] = value;
+        continue;
+      }
+      const source = previous?.source ?? { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}`).digest("hex") };
+      const published = await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent, requested, nativeAgentRole, observed, source, evidence: "response" });
+      if (previous || published?.evidence_conflict) {
+        if (previous) previous.conflicted = true;
+        throw new DaemonError("model_observation_identity_conflict", "OpenCode native message changed its published identity/profile", false, { session_id: id, message_id: info.id });
+      }
+      this.modelMessages.set(key, { known: structuredClone(tuple), source });
     }
   }
   async requireSettled(id) {
@@ -372,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;
   }
@@ -381,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;
@@ -396,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 };
     }
@@ -453,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,
@@ -462,6 +603,9 @@ export class Runtime {
       assertDispatch, checkHookFailures, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
       onDispatched: () => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: params.sessionId }),
       onModelMessages: (id, messages, parent) => this.observeModels(id, messages, parent),
+      onNativeSession: (info, root) => this.registerObservedChild(info, root),
+      rootSessionId: this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId,
+      parentSessionId: this.sessions.get(params.sessionId)?.parent_provider_session_id ?? null,
       onObservationError: error => observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: params.sessionId, requested: this.state.config, source: "native.message_observer", evidence: "unavailable", reason: error.code ?? "observation_unavailable" })
     }); await checkHookFailures(); }
       finally { current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; }
@@ -476,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");
@@ -169,13 +168,32 @@ export class OpenCodeClient {
   import(data) { return this.call("session.import", data, { productive: true }); }
 
   async prompt(id, { prompt, messageId = `msg_${randomUUID().replaceAll("-", "")}`, retained,
-    save, onModelMessages, onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
+    save, onModelMessages, onNativeSession, rootSessionId = id, parentSessionId = null,
+    onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
     validateObservationDuration(livenessTimeoutMs);
     const request = { sessionID: id, id: messageId, text: prompt, delivery: "queue", resume: true }, digest = requestDigest(request);
     if (retained && (retained.request_sha256 !== digest || retained.message_id !== messageId)) throw new OpenCodeError("operation_request_mismatch", "OpenCode operation already binds another prompt", false, { effect: "no_effect" });
     let state = retained ?? { message_id: messageId, request_sha256: digest, phase: "prepared", cursor: 0 };
-    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map();
-    const capture = async session => { for (const child of await this.children(session)) { parents.set(child.id, child.parentID); baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id))); await capture(child.id); } };
+    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map([[id, parentSessionId]]);
+    // The same native lineage guard applies before dispatch and while polling.
+    // Registration precedes message publication; a list ID alone is not ownership.
+    const childrenOf = async (session, visited) => {
+      const children = await this.children(session);
+      for (const child of children) {
+        if (!child?.id || child.parentID !== session || child.fork || session !== rootSessionId || visited.has(child.id)
+          || parents.has(child.id) && parents.get(child.id) !== session || visited.size >= 1024)
+          throw new OpenCodeError("session_identity_mismatch", "OpenCode native child lineage is invalid", false, { session_id: child?.id, parent_session_id: session });
+        visited.add(child.id); parents.set(child.id, session);
+        await onNativeSession?.(child, rootSessionId);
+      }
+      return children;
+    };
+    const capture = async (session, visited = new Set([id])) => {
+      for (const child of await childrenOf(session, visited)) {
+        baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id)));
+        await capture(child.id, visited);
+      }
+    };
     await capture(id);
     if (retained) {
       const index = previous.findIndex(item => item.info.id === messageId);
@@ -258,8 +276,8 @@ export class OpenCodeClient {
           }
           if (state.cursor !== watermark) { state = { ...state, cursor: watermark }; await save?.(state); }
           let runningTools = false;
-          const observe = async (session, visited = new Set()) => {
-            if (visited.has(session)) throw lost("OpenCode topology contains a cycle"); visited.add(session); known.add(session);
+          const observe = async (session, visited = new Set([id])) => {
+            known.add(session);
             const messages = await this.messages(session);
             await onModelMessages?.(session, messages, parents.get(session) ?? null);
             const floor = baseline.get(session) ?? new Set(), current = messages.filter(item => item.info.role === "assistant" && !floor.has(item.info.id));
@@ -291,10 +309,7 @@ export class OpenCodeClient {
                 }
               }
             }
-            for (const child of await this.children(session)) {
-              if (child.parentID !== session) throw lost("OpenCode child has a foreign parent");
-              parents.set(child.id, session); await observe(child.id, visited);
-            }
+            for (const child of await childrenOf(session, visited)) await observe(child.id, visited);
             return current;
           };
           const current = await observe(id), rootMessages = await this.messages(id);
@@ -309,12 +324,17 @@ export class OpenCodeClient {
                 // Native messages and topology are separate reads: a child can
                 // finish between them. Reconcile its ancestry before rejecting
                 // the notification, never trust the notification alone.
-                const child = (await this.children(id)).find(child => child.id === item.info.metadata.childID && child.parentID === id);
-                if (child) { parents.set(child.id, id); await observe(child.id); }
+                const visited = new Set([id]);
+                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");
@@ -327,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) {
@@ -353,7 +373,8 @@ export class OpenCodeClient {
           }
         } catch (error) {
           await checkHookFailures?.();
-          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)) throw error;
+          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)
+            || ["session_identity_mismatch", "model_observation_identity_conflict"].includes(error.code)) throw error;
           await onObservationError?.(error);
         }
         if (clock.sample(marker)) throw lost("OpenCode native progress stopped or observation could not recover", { session_id: id, message_id: messageId, observation: clock.state(), ...(observationErrors.count ? { observation_errors: observationErrors } : {}) });

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>>;