@deksden-com/dd-flow-cli 0.9.0-beta.138 → 0.9.0-beta.139

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

@@ -12,13 +12,15 @@ import { spawn } from "node:child_process";
 import net from "node:net";
 import { durableDaemonDispatch, completeDaemonShutdown, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon, assertDaemonDispatch, assertDaemonRestartable } from "./daemon-operations.mjs";
 import { waitForSettlement } from "./session-settlement.mjs";
-import { errorRecord } from "./operation-errors.mjs";
+import { errorRecord, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
 import { checkObservedProfile, observeModel } 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 { prepareRuntimeOwner, cleanupFailedStart, 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";
@@ -65,7 +67,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({ 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 })});\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) {
@@ -189,13 +191,15 @@ export class Runtime {
   }
   async describe(id) {
     const [info, messages, children, statuses] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id), this.client.statuses()]);
-    if (!info.directory || path.resolve(info.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode Session directory is outside the controlled workspace");
     const parent = info.fork ? null : info.parentID ?? null, existing = this.sessions.get(id);
+    if (info.id !== id || !existing && (!parent || !this.sessions.has(parent) || info.fork)
+      || existing && (existing.parent_provider_session_id ?? null) !== parent) throw new DaemonError("foreign_session", "OpenCode Session is not in the retained owned tree");
     const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent,
       root_provider_session_id: parent ? this.sessions.get(parent)?.root_provider_session_id ?? parent : existing?.root_provider_session_id ?? id, cwd: info.directory };
     this.sessions.set(id, record);
     for (const child of children) {
-      if (!child.directory || path.resolve(child.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode child has another workspace");
+      const retained = this.sessions.get(child.id);
+      if (child.fork || retained && retained.parent_provider_session_id !== child.parentID) throw new DaemonError("session_identity_mismatch", "OpenCode child ancestry changed");
       this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID, root_provider_session_id: record.root_provider_session_id, cwd: child.directory });
     }
     const pending = new Map();
@@ -204,6 +208,18 @@ export class Runtime {
       pending.set(session, { ...value, shells: this.client.shells ? (await this.client.shells(session)).filter(shell => shell.status === "running") : [] });
     }
     const busy = session => Boolean(statuses[session] && statuses[session].type !== "idle") || Object.values(pending.get(session)).some(items => items.length > 0);
+    for (const child of children) {
+      const history = await this.client.messages(child.id);
+      const index = history.findLastIndex(message => message.info.role === "user" && message.info.sessionID === child.id);
+      const terminal = index >= 0 && history.slice(index + 1).findLast(message => message.info.role === "idle" && message.info.sessionID === child.id);
+      if (!terminal || busy(child.id)) continue;
+      const outcome = terminal.info.outcome;
+      if (!["succeeded", "failed", "interrupted"].includes(outcome)) continue;
+      Object.assign(child, { status: outcome === "succeeded" ? "completed" : outcome === "failed" ? "failed" : "cancelled",
+        terminal_turn_id: history[index].info.id, native_source: "opencode.v2.session.execution",
+        native_turn_items: { observed: true, possible_effects: true, pending: false },
+        ...(terminal.info.error ? { provider_error: safeProviderError(terminal.info.error) } : {}) });
+    }
     const unsettledChildren = children.filter(child => busy(child.id)).map(child => child.id), status = busy(id) ? "busy" : "idle";
     const lastAssistant = messages.findLast(message => message.info?.role === "assistant");
     const inputIndex = messages.findLastIndex(message => message.info.role === "user");
@@ -214,6 +230,8 @@ export class Runtime {
     if (this.state.config.journal) journalToolObservations(this.state.config.journal, messages.flatMap(message => (message.parts ?? []).map(part => openCodeToolObservation(part, id, message.info?.id))), this.journaledTools);
     return { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? info.model?.providerID ?? null, model: lastAssistant?.info?.modelID ?? info.model?.id ?? null, reasoning: lastAssistant?.info?.variant ?? info.model?.variant ?? "default", mode: info.agent ?? null },
       assistant_text: (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""), info, status,
+      route_conformance: { matches: [info, ...children].every(session => session.directory && path.resolve(session.directory) === path.resolve(this.state.config.cwd)), expected: this.state.config.cwd, actual: info.directory ?? null, actual_provenance: "native_session_readback" },
+      route_violations: [info, ...children].filter(session => !session.directory || path.resolve(session.directory) !== path.resolve(this.state.config.cwd)).map(session => ({ provider_session_id: session.id, expected: this.state.config.cwd, actual: session.directory ?? null, actual_provenance: "native_session_readback" })),
       settled: status === "idle" && !unsettledChildren.length, unsettled_children: unsettledChildren,
       tree_session_ids: treeIds, unsettled_sessions: treeIds.filter(busy),
       tree_observations: treeIds.map(session => ({ provider_session_id: session, status: busy(session) ? "running" : "idle", settled: !busy(session) })),
@@ -237,6 +255,7 @@ export class Runtime {
   }
   async requireSettled(id) {
     const value = await this.describe(id);
+    if (!value.route_conformance.matches) throw new DaemonError("invocation_directory_mismatch", "Owned OpenCode Session has an unexpected workspace", false, { effect: "no_effect", ...value.route_violations[0], native_outcome: value.terminal_status, settled: value.settled });
     if (!value.settled) throw new DaemonError("tree_not_settled", "OpenCode Session is not idle", false, { session_id: id, status: value.status });
     const config = this.state.config;
     if (config.provider && config.model) checkObservedProfile({ ...config, reasoning: config.variant, mode: value.parent_provider_session_id ? "dd-flow-worker" : config.agent }, value.observed_profile);
@@ -256,30 +275,87 @@ export class Runtime {
     } catch (cause) {
       const error = completed ? new DaemonError("operation_observation_lost", "OpenCode returned but its durable observation could not be saved; do not resend", false, { result, cause: errorPayload(cause) }) : cause;
       const failures = [];
-      try { await this.persist({ active_tree: error.details?.effect === "no_effect" ? priorActive : true, active_operation: null }); } catch (secondary) { failures.push(errorPayload(secondary)); }
+      try { await this.persist({ active_tree: error.details?.effect === "no_effect" && error.details?.native_turn_items?.possible_effects !== true ? priorActive : true, active_operation: null }); } catch (secondary) { failures.push(errorPayload(secondary)); }
       try { await this.journal(`${name}.failed`, null); } catch (secondary) { failures.push(errorPayload(secondary)); }
       if (failures.length) error.details = { ...error.details, observation_errors: failures };
       throw error;
     } finally { this.active = null; }
   }
   async cancelTree(id, seen = new Set()) {
+    if (!this.sessions.has(id)) throw new DaemonError("foreign_session", "cannot cancel a Session without daemon ownership");
     if (seen.has(id)) return [];
+    const native = await this.client.inspect(id), retained = this.sessions.get(id);
+    if (native.id !== id || (retained.parent_provider_session_id ?? null) !== (native.fork ? null : native.parentID ?? null)) throw new DaemonError("session_identity_mismatch", "OpenCode cancellation Session ancestry changed");
     seen.add(id);
     const errors = []; let children = [];
     try { children = await this.client.children(id); } catch (error) { errors.push({ session_id: id, phase: "children", ...errorPayload(error) }); }
     for (const child of children) {
-      if (child.parentID !== id || !child.directory || path.resolve(child.directory) !== path.resolve(this.state.config.cwd)) {
+      if (child.parentID !== id || child.fork || this.sessions.has(child.id) && this.sessions.get(child.id).parent_provider_session_id !== id) {
         errors.push({ session_id: child.id, phase: "identity", code: "session_identity_mismatch" }); continue;
       }
-      errors.push(...await this.cancelTree(child.id, seen));
+      this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: id, root_provider_session_id: this.sessions.get(id)?.root_provider_session_id ?? id, cwd: child.directory });
+      try { errors.push(...await this.cancelTree(child.id, seen)); }
+      catch (error) { errors.push({ session_id: child.id, phase: "cancel_child", ...errorPayload(error) }); }
     }
     try { await this.client.abort(id); } catch (error) { errors.push({ session_id: id, phase: "abort", ...errorPayload(error) }); }
     return errors;
   }
+  async observeHookFailures(current = this.nativeHookOperation) {
+    if (!current || this.nativeHookOperation !== current) return;
+    if (current.reading) return await current.reading;
+    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;
+    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;
+  }
   async dispatch(operation, params, operationId = null) {
     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.resolve") {
+      const current = this.nativeHookOperation, sessionId = params.sessionId, payload = params.payload;
+      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 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;
+        const native = await this.client.inspect(sessionId), retained = this.sessions.get(sessionId), child = tree.find(item => item.id === sessionId);
+        if (native.id !== sessionId || child && (native.parentID !== child.parentID || native.fork) || retained && (retained.parent_provider_session_id ?? null) !== (native.fork ? null : native.parentID ?? null)) throw new DaemonError("native_hook_identity_conflict", "OpenCode hook Session ancestry changed");
+        if (!native.directory) throw new DaemonError("native_hook_unproven", "OpenCode hook Session directory is unavailable");
+        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",
+          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: {
+          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);
+        throw error;
+      }
+    }
+    if (operation === "hook.verify") {
+      const current = this.nativeHookOperation, binding = params.binding;
+      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");
+      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"));
+      }
+      await this.observeHookFailures(); return { observed: true };
+    }
     if (operation === "daemon.doctor") {
       const info = await this.client.health();
       await this.client.call("model.list", { location: { directory: this.state.config.cwd } });
@@ -311,26 +387,33 @@ 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];
-      assertDispatch(); const reply = await this.client.prompt(params.sessionId, { prompt: params.prompt, messageId: retained?.message_id ?? `msg_${randomUUID().replaceAll("-", "")}`, retained,
+      const current = { operationId: key, sessionId: params.sessionId, generation: (this.state.hook_generation ?? 0) + 1, requests: new Map(), failure: null };
+      this.state.hook_generation = current.generation; this.nativeHookOperation = 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,
       save: async receipt => { this.state.operations[key] = receipt; await this.persist(); },
-      assertDispatch, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
+      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),
       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" })
-    }); const assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
+    }); await checkHookFailures(); }
+      finally { current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; }
+      const assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
       const expectedAgent = this.sessions.get(params.sessionId)?.parent_provider_session_id ? "dd-flow-worker" : this.state.config.agent;
       const reply_profile = { provider: reply.info.providerID ?? null, model: reply.info.modelID ?? null, reasoning: reply.info.variant ?? null, mode: reply.info.mode ?? null };
       checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: expectedAgent }, reply_profile);
       let result;
       try { result = await this.describe(params.sessionId); }
-      catch (error) { return { provider_session_id: params.sessionId, adapter_session_id: params.sessionId, assistant_text, response_message_id: reply.info.id, observed_profile: reply_profile, settled: false, settlement_observation_error: errorPayload(error) }; }
+      catch (error) { return { provider_session_id: params.sessionId, adapter_session_id: params.sessionId, assistant_text, response_message_id: reply.info.id, terminal_turn_id: reply.admission_message_id, terminal_status: "completed", native_outcome: "succeeded", observed_profile: reply_profile, settled: false, settlement_observation_error: errorPayload(error) }; }
       result.assistant_text = assistant_text;
+      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 };
       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);
-      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.parentID ?? params.sessionId, root_provider_session_id: this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId, cwd: info.directory };
+      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.fork ? null : info.parentID ?? params.sessionId, root_provider_session_id: info.fork ? info.id : this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId, cwd: info.directory };
       this.sessions.set(info.id, created);
       try {
         const fork = await this.describe(info.id);

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

@@ -4,6 +4,7 @@ import { ToolObservations, openCodeToolObservation } from "./tool-observations.m
 import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
 import { assertNativeLine } from "./native-streams.mjs";
 import { operationProgressReporter } from "./operation-progress.mjs";
+import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 
 export const OPENCODE_PROTOCOL = 2;
 export class OpenCodeError extends Error {
@@ -27,17 +28,16 @@ export function normalizeMessage(message, sessionID) {
 }
 
 export function providerFailure(native, sessionId, turnId) {
-  const message = String(native?.message ?? "OpenCode execution failed"), status = native?.status, type = String(native?.type ?? "unknown");
-  const quota = status === 402 || /quota|balance exhausted|insufficient.?credit|billing|payment required/i.test(message);
-  const code = quota ? "provider_quota_exhausted" : status === 401 || status === 403 ? "provider_auth_failed"
-    : /overload|server.?busy/i.test(`${type} ${message}`) || status === 503 ? "provider_capacity_transient"
-    : /rate.?limit|too many requests/i.test(message) ? "provider_rate_limited"
-    : status === 429 ? "provider_limit_unknown" : "opencode_provider_failed";
+  const status = native?.status, type = String(native?.type ?? "unknown");
+  const category = classifyProviderError(native), code = category === "provider_failed" ? "opencode_provider_failed" : category;
   // Never forward response.body or provider credentials into controller/Judge.
   return new OpenCodeError(code, `OpenCode native execution failed (${type}${status ? `, HTTP ${status}` : ""})`,
     ["provider_capacity_transient", "provider_rate_limited"].includes(code), {
       provider_session_id: sessionId, session_id: sessionId, turn_id: turnId, native_error_type: type,
       native_turn_id: turnId, terminal_status: "failed",
+      provider_error: safeProviderError(native),
+      will_retry: native?.willRetry === true, native_retry_active: native?.willRetry === true,
+      native_turn_items: { observed: true, possible_effects: true, pending: false },
       ...(Number.isInteger(status) ? { http_status: status } : {}), observed_at: new Date().toISOString(), native_source: "opencode.v2.session.execution" });
 }
 
@@ -48,11 +48,16 @@ export class OpenCodeClient {
       baseUrl: this.baseUrl.href, headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` }
     }));
   }
-  async call(method, input, { timeoutMs, progress, onDispatched, productive = false } = {}) {
+  async call(method, input, { timeoutMs, progress, onDispatched, productive = false, signal } = {}) {
     const observation = this.readObservation?.();
     timeoutMs ??= observation?.timeoutMs ?? this.timeoutMs; progress ??= observation?.progress;
     const api = await this.ready, controller = new AbortController();
-    const timer = observedTimeout(() => controller.abort(), timeoutMs, { progress });
+    let timer;
+    const abort = () => { controller.abort(); clearInterval(timer); };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    timer = observedTimeout(() => controller.abort(), timeoutMs, { progress });
+    if (signal?.aborted) clearInterval(timer);
     try {
       const keys = method.split("."), name = keys.pop(), domain = keys.reduce((value, key) => value?.[key], api);
       if (typeof domain?.[name] !== "function") throw new OpenCodeError("opencode_capability_missing", `OpenCode v2 does not expose ${method}`);
@@ -68,7 +73,7 @@ export class OpenCodeClient {
       if (productive || controller.signal.aborted) throw Object.assign(lost(`OpenCode observer lost during ${method}`, { method }), { cause });
       throw Object.assign(new OpenCodeError("opencode_unavailable", `OpenCode ${method} observation failed`, true,
         { method, native_type: cause._tag ?? cause.name ?? null, native_reason: cause.reason ?? null }), { cause });
-    } finally { clearInterval(timer); }
+    } finally { clearInterval(timer); signal?.removeEventListener("abort", abort); }
   }
   async health() {
     const info = await this.call("server.info", undefined, { timeoutMs: 5_000 });
@@ -95,7 +100,8 @@ export class OpenCodeClient {
   async children(id) { return (await this.pages("session.list", { parentID: id })).map(info => ({ ...info, directory: info.location?.directory })); }
   async messages(id) { return (await this.pages("message.list", { sessionID: id })).map(message => normalizeMessage(message, id)); }
   inbox(id) { return this.call("session.inbox.list", { sessionID: id }); }
-  async shells(id) { const result = await this.call("shell.list", { location: { directory: this.directory } }); return result.data.filter(item => item.metadata?.sessionID === id); }
+  async shellDirectory(id) { const api = await this.ready; return typeof api.session?.get === "function" ? (await this.inspect(id)).directory : this.directory; }
+  async shells(id) { const directory = await this.shellDirectory(id); const result = await this.call("shell.list", { location: { directory } }); return result.data.filter(item => item.metadata?.sessionID === id).map(item => ({ ...item, location: item.location ?? { directory } })); }
   async pending(id) {
     const [inbox, forms, permissions] = await Promise.all([this.inbox(id), this.call("session.form.list", { sessionID: id }), this.call("permission.list", { sessionID: id })]);
     const value = { inbox, forms: forms.data ?? forms, permissions: permissions.data ?? permissions };
@@ -117,7 +123,7 @@ export class OpenCodeClient {
     const result = await this.call("session.interrupt", { sessionID: id, resume: false }, { productive: true });
     const api = await this.ready;
     if (typeof api.shell?.list === "function") for (const shell of await this.shells(id)) {
-      if (shell.status === "running") await this.call("shell.remove", { id: shell.id, location: { directory: this.directory } }, { productive: true });
+      if (shell.status === "running") await this.call("shell.remove", { id: shell.id, location: shell.location }, { productive: true });
     }
     return result;
   }
@@ -127,7 +133,7 @@ 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, livenessTimeoutMs = this.timeoutMs }) {
+    save, onModelMessages, 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" });
@@ -144,6 +150,21 @@ export class OpenCodeClient {
     const publish = operationProgressReporter(), known = new Set([id, ...baseline.keys()]), signatures = new Map(), shellCursors = new Map(), liveSeen = new Set();
     let progress = 0, marker, stream;
     const liveParts = new Map(), liveShells = new Map(), backgroundShells = new Set();
+    const completedTools = new Set(), outputReads = new Map(), shellLocations = new Map();
+    const observationErrors = { count: 0 };
+    const observeOutput = (shellID, location) => {
+      if (outputReads.has(shellID) || !location?.directory) return;
+      const cursor = shellCursors.get(shellID) ?? 0;
+      const pending = this.call("shell.output", { id: shellID, location, cursor, limit: 65536 }, { signal: streamAbort.signal })
+        .then(async output => { const data = output.data ?? output; if (!streamAbort.signal.aborted && data.cursor > cursor) { shellCursors.set(shellID, data.cursor); await advance(); } })
+        .catch(async error => {
+          if (streamAbort.signal.aborted) return;
+          const diagnostic = { method: "shell.output", shell_id: shellID, native_type: error.details?.native_type ?? error.cause?._tag ?? null, http_status: error.cause?.status ?? null };
+          observationErrors.count++; observationErrors.first ??= diagnostic; observationErrors.last = diagnostic;
+          if (observationErrors.count === 1) await onObservationError?.(error);
+        }).finally(() => outputReads.delete(shellID));
+      outputReads.set(shellID, pending); void pending.catch(() => {});
+    };
     const advance = async (observedAt = Date.now()) => { marker = { cursor: ++progress, observed_at: observedAt }; await publish("native_progress", { session_id: id, observed_at: new Date(marker.observed_at).toISOString() }); };
     let connected;
     const connection = new Promise(resolve => { connected = resolve; });
@@ -157,7 +178,8 @@ export class OpenCodeClient {
           && ["session.text.delta", "session.reasoning.delta", "session.tool.input.delta", "session.tool.progress"].includes(event.type)) {
           liveSeen.add(event.id); if (liveSeen.size > 1024) liveSeen.delete(liveSeen.values().next().value);
           const key = `${data.sessionID}:${data.assistantMessageID}:${data.id ?? ""}`, signature = requestDigest(data.metadata ?? null);
-          if (event.type === "session.tool.progress" && typeof data.metadata?.shellID === "string") liveShells.set(key, data.metadata.shellID);
+          if (event.type === "session.tool.progress" && completedTools.has(key)) continue;
+          if (event.type === "session.tool.progress" && typeof data.metadata?.shellID === "string" && !completedTools.has(key)) liveShells.set(key, data.metadata.shellID);
           if (typeof data.delta === "string" && data.delta.length || event.type === "session.tool.progress" && liveParts.get(key) !== signature) {
             liveParts.set(key, signature); await advance(event.created);
           }
@@ -189,6 +211,7 @@ export class OpenCodeClient {
       }
       for (;;) {
         try {
+          await checkHookFailures?.();
           const events = await this.logs(id, state.cursor);
           let delivered = state.delivered === true, terminal = state.terminal;
           for (const event of events) {
@@ -198,6 +221,7 @@ export class OpenCodeClient {
             if (delivered && ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted"].includes(event.type)) terminal = { type: event.type, error: event.data.error };
             state = { ...state, cursor: event.durable.seq, delivered, terminal }; 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 messages = await this.messages(session);
@@ -211,19 +235,24 @@ export class OpenCodeClient {
                 signatures.set(key, { signature: next, seen, highWater: Math.max(before?.highWater ?? 0, encoded.length) });
               }
               for (const part of item.parts) {
-                let shellID = part.type === "tool" ? part.state?.metadata?.shellID ?? liveShells.get(`${session}:${item.info.id}:${part.id}`) : null;
+                const toolKey = `${session}:${item.info.id}:${part.id}`;
+                if (part.type === "tool" && ["running", "streaming", "pending"].includes(part.state?.status)) runningTools = true;
+                if (part.type === "tool" && !["running", "streaming", "pending"].includes(part.state?.status)) { completedTools.add(toolKey); liveShells.delete(toolKey); }
+                let shellID = part.type === "tool" ? part.state?.metadata?.shellID ?? liveShells.get(toolKey) : null;
                 if (!shellID && part.tool === "shell" && part.state?.status === "running") {
                   // Tool progress metadata is volatile in the CLI. Reconcile
                   // only an unambiguous native shell in this current message.
                   const candidates = (await this.shells(session)).filter(shell => shell.time.started >= item.info.created);
-                  if (candidates.length === 1) shellID = candidates[0].id;
+                  if (candidates.length === 1) { shellID = candidates[0].id; shellLocations.set(shellID, candidates[0].location); }
                 }
                 if (!shellID) continue;
                 const cursor = shellCursors.get(shellID) ?? 0;
                 shellCursors.set(shellID, cursor); // Zero-output shells still own their native notification.
                 if (part.tool === "shell" && part.state?.metadata?.status === "running") backgroundShells.add(shellID);
-                const output = await this.call("shell.output", { id: shellID, location: { directory: this.directory }, cursor, limit: 65536 }), data = output.data ?? output;
-                if (data.cursor > cursor) { shellCursors.set(shellID, data.cursor); await advance(); }
+                if (!completedTools.has(toolKey)) {
+                  if (!shellLocations.has(shellID)) shellLocations.set(shellID, (await this.shells(session)).find(shell => shell.id === shellID)?.location);
+                  observeOutput(shellID, shellLocations.get(shellID));
+                }
               }
             }
             for (const child of await this.children(session)) {
@@ -258,7 +287,7 @@ export class OpenCodeClient {
               state = { ...state, delivered: true, terminal: { type: `session.execution.${terminal.info.outcome}`, error: terminal.info.error } }; await save?.(state);
             }
           }
-          const statuses = await this.statuses(); let unsettled = false;
+          const statuses = await this.statuses(); let unsettled = runningTools;
           // A background child's native completion notification is delivered
           // asynchronously. An idle parent before that delivery is not the
           // completion of the coordinating operation.
@@ -278,18 +307,20 @@ export class OpenCodeClient {
             if (typeof api.shell?.list === "function") unsettled ||= (await this.shells(session)).some(shell => shell.status === "running");
           }
           if (state.delivered && state.terminal && !unsettled) {
+            await checkHookFailures?.();
             if (state.terminal.type === "session.execution.failed") throw providerFailure(state.terminal.error, id, messageId);
             if (state.terminal.type === "session.execution.interrupted") throw new OpenCodeError("opencode_execution_interrupted", "OpenCode execution was interrupted", false, { provider_session_id: id, turn_id: messageId });
             const final = current.findLast(item => item.info.completed !== undefined && item.info.finish && item.info.finish !== "tool-calls");
             if (!final) throw lost("OpenCode terminal has no current assistant response", { session_id: id, message_id: messageId });
             if (final.info.error) throw providerFailure(final.info.error, id, messageId);
-            return { ...final, admission_message_id: messageId, log_cursor: state.cursor };
+            return { ...final, admission_message_id: messageId, log_cursor: state.cursor, ...(observationErrors.count ? { observation_errors: observationErrors } : {}) };
           }
         } catch (error) {
+          await checkHookFailures?.();
           if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].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() });
+        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 } : {}) });
         await delay(Math.max(5, Math.min(500, livenessTimeoutMs / 4)));
       }
     } finally { clearInterval(connectionTimer); this.readObservation = priorObservation; streamAbort.abort(); await stream; }

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

@@ -30,6 +30,7 @@ import {
 } from "./dd-zcode.mjs";
 
 const REQUEST_SCHEMA = "dd-zcode/daemon-request@1";
+import { settledNativeTree } from "./native-children.mjs";
 const RESPONSE_SCHEMA = "dd-zcode/daemon-response@1";
 const STATE_SCHEMA = "dd-zcode/daemon-state@1";
 // ACP silence starts diagnostics; it is not a provider-failure deadline.
@@ -374,6 +375,7 @@ export class DaemonRuntime {
     current.reject = error => { if (this.nativeHookOperation !== current || current.error) return; current.error = error; this.bridge.lifecycleFailure ??= error; this.bridge.notificationError = this.bridge.lifecycleFailure; this.bridge.rejectAll(this.bridge.lifecycleFailure); rejectHook(this.bridge.lifecycleFailure); };
     const timer = setInterval(() => { void this.observeHookFailures(current).catch(error => current.reject(error)); }, 100);
     try {
+      if (name === "session.prompt") this.state.last_native_failure = null;
       await this.persist({ active_tree: true, active_operation: name, ...(request ? { active_request: request } : {}) });
       const result = await Promise.race([task(), hookFailed]);
       this.track(result);
@@ -386,6 +388,9 @@ export class DaemonRuntime {
       // after a late/partial create: the native Session existed, but the
       // daemon state no longer carried the only correlation to it.
       const active = this.state?.active_request;
+      const response = error?.details?.terminal_response;
+      if (name === "session.prompt" && response?.method === "session/prompt" && error.details.provider_session_id)
+        this.state.last_native_failure = { provider_session_id: error.details.provider_session_id, request_id: response.request_id };
       try {
         await hookBudget(1_000, null).run(() => this.persist({
           active_operation: null,
@@ -572,7 +577,14 @@ export class DaemonRuntime {
       if (this.sessions.has(result.provider_session_id)) this.track(result, result.subagents);
       else if (result.adapter_session_id) this.liveAdapters.add(result.adapter_session_id);
       await this.persist({ active_tree: this.treeRunning(result) || Boolean(this.activeProductive) });
-      return { ...result, settled: !this.treeRunning(result) && !this.activeProductive };
+      const settled = !this.treeRunning(result) && !this.activeProductive;
+      const failure = this.state.last_native_failure;
+      const nativeChildren = (result.evidence ?? result).subagents;
+      const childIds = [...new Set([...(this.sessions.get(result.provider_session_id)?.known_child_session_ids ?? []), ...zcodeChildSessionIds(nativeChildren)])];
+      const childStates = new Map([...(nativeChildren?.ended?.items ?? nativeChildren?.completed ?? []), ...(nativeChildren?.running ?? []).map(child => ({ ...child, status: "running" }))].map(child => [child.childSessionId ?? child.sessionId, child.status]));
+      const rootSettled = !this.activeProductive && failure?.provider_session_id === result.provider_session_id && (result.evidence ?? result).read?.projection?.status === "idle";
+      return { ...result, settled, ...settledNativeTree(result.provider_session_id, childIds.map(childSessionId => ({ childSessionId, status: childStates.get(childSessionId) ?? "unknown" })), settled, rootSettled),
+        ...(failure?.provider_session_id === result.provider_session_id ? { terminal_turn_id: String(failure.request_id) } : {}) };
     }
     if (operation === "session.cancel") {
       if (!this.sessions.has(params.sessionId)) throw new DaemonError("session_identity_mismatch", "cancellation Session is not owned by this daemon");

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

@@ -15,6 +15,7 @@ import { commandText } from "./process-json.mjs";
 import { readNativeLines, streamNativeDiagnostics, nativeObservationError } from "./native-streams.mjs";
 import { operationProgressReporter } from "./operation-progress.mjs";
 import { safeNativeFailure } from "./native-children.mjs";
+import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 
 import { readZcodeUsage } from "./zcode-usage.mjs";
 const ZCODE_HARNESS_CONTRACT = "dd-zcode-harness@1";
@@ -218,9 +219,12 @@ export class AcpBridge {
     // ZCode emits this as `session/update`; Grok Build wraps the same ACP
     // payload in `_x.ai/session_notification`.  Preserve either provider's
     // native error before its generic JSON-RPC terminal response arrives.
-    if (typeof message.params?.sessionId === "string" && update?.sessionUpdate === "retry_state" && update.type === "failed") {
+    if (typeof message.params?.sessionId === "string" && update?.sessionUpdate === "retry_state") {
       for (const pending of this.pending.values()) {
-        if (pending.method === "session/prompt" && pending.sessionId === message.params.sessionId && !pending.providerError) pending.providerError = { ...update, observed_at: now(), provider_session_id: pending.sessionId, source: message.method };
+        if (pending.method === "session/prompt" && pending.sessionId === message.params.sessionId) {
+          pending.nativeRetryActive = update.type !== "failed";
+          if (update.type === "failed") pending.providerError = { ...update, observed_at: now(), provider_session_id: pending.sessionId, source: message.method };
+        }
       }
     }
     if (message.method === "session/update" && message.params?.update?.sessionUpdate === "agent_message_chunk" && message.params.update.content?.type === "text") {
@@ -283,11 +287,17 @@ export class AcpBridge {
         const error = new Error(messageText);
         const nativeCode = typeof data?.code === "string" ? data.code : typeof data?.native_code === "string" ? data.native_code : null;
         const unknown = ["native_timeout", "native_backend_dead", "native_backend_pipe_broken", "native_outcome_unknown"].includes(nativeCode);
-        error.code = unknown ? nativeCode : /payment required|quota|usage balance exhausted|insufficient.?credit|billing/i.test(messageText) ? "provider_quota_exhausted" : /rate.?limit|too many requests/i.test(messageText) ? "provider_rate_limited" : /\b429\b/.test(messageText) ? "provider_limit_unknown" : "acp_request_failed";
-        error.retryable = error.code === "provider_rate_limited";
+        const nativeFailure = { ...(provider ?? {}), ...(data ?? {}),
+          code: [provider?.code, data?.code, data?.native_code].filter(value => typeof value === "string").join(" "), message: messageText };
+        const category = pending.method === "session/prompt" ? classifyProviderError(nativeFailure) : "provider_failed";
+        error.code = unknown ? nativeCode : category === "provider_failed" ? "acp_request_failed" : category;
+        error.retryable = ["provider_rate_limited", "provider_capacity_transient"].includes(error.code);
         error.details = { acp_code: message.error.code ?? null,
           observed_at: provider?.observed_at ?? now(), provider_session_id: pending.sessionId ?? null, source: "acp.error_response", request_id: message.id,
           terminal_response: { method: pending.method, session_id: pending.sessionId, request_id: message.id },
+          ...(pending.method === "session/prompt" ? { native_source: "acp.error_response", terminal_status: "failed", turn_id: String(message.id), native_turn_id: String(message.id), provider_error: safeProviderError(nativeFailure),
+            native_retry_active: pending.nativeRetryActive === true, will_retry: nativeFailure.willRetry === true,
+            native_turn_items: { observed: this.toolSummary(pending.sessionId).completeness === "complete", possible_effects: this.toolSummary(pending.sessionId).total > 0, pending: this.toolSummary(pending.sessionId).pending > 0 } } : {}),
           ...(data ? { native: data } : {}), ...(details ? { provider_details: details } : {}), ...(providerDetails ? { provider_update: provider } : {}) };
         pending.reject(error);
       }
@@ -1046,6 +1056,9 @@ export async function promptSessionWithBridge(bridge, options) {
     idleSessionId: identity.adapterSessionId,
     idleTimeoutMs: options.livenessTimeoutMs ?? 600_000,
     inactivityMode: "diagnostic",
+  }).catch(error => {
+    if (error.details?.terminal_response?.session_id === identity.adapterSessionId) error.details.provider_session_id = identity.providerSessionId;
+    throw error;
   });
   const stopReason = typeof turn?.stopReason === "string" ? turn.stopReason : null;
   const completionEvidence = turn?._meta?.zcodeCompletionEvidence;

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

@@ -1,6 +1,7 @@
 export type DelegationWork = { work_id: string; start_command: string; launch_policy?: string };
 export type DelegationInput = { harness: string; stage: string; capacity: number; works?: DelegationWork[]; totalWorks?: number; remainingWorks?: number };
 export function delegationAdapter(harness: string): string | null;
+export function renderNativeChildFollowupInstruction(harness: string, childId: string): string | null;
 export function delegationContract(harness: string): string;
 export const lifecycleRetryInstruction: string;
 export const lifecycleCommandCompletionInstruction: string;

package/dist/harness-runtime/lib/delegation-instructions.mjs

@@ -37,6 +37,17 @@ export function delegationAdapter(harness) {
   return Object.hasOwn(aliases, harness) ? aliases[harness] : null;
 }
 
+/** Only documented same-child APIs may continue an existing native worker. */
+export function renderNativeChildFollowupInstruction(harness, childId) {
+  if (typeof childId !== "string" || !childId) return null;
+  const adapter = delegationAdapter(harness), target = JSON.stringify(childId);
+  if (adapter === "codex") return `Use collaboration.followup_task with target: ${target} and message: "Continue the same assigned Work after the transient provider overload; do not restart it or repeat committed lifecycle commands." Do not spawn a replacement.`;
+  if (adapter === "opencode") return `Use the native subagent tool with sessionID: ${target} and prompt: "Continue the same assigned Work after the transient provider overload; do not restart it or repeat committed lifecycle commands." Keep the same model and reasoning. Do not spawn a replacement.`;
+  if (adapter === "droid") return `Use the native Task tool with resume: ${target}, subagent_type: "dd-flow-worker", and prompt: "Continue the same assigned Work after the transient provider overload; do not restart it or repeat committed lifecycle commands." Omit model and complexity overrides. Do not spawn a replacement.`;
+  if (adapter === "grok") return `Use the native send_subagent_message tool with subagent_id: ${target}, delivery: "queue", and text: "Continue the same assigned Work after the transient provider overload; do not restart it or repeat committed lifecycle commands." Retain its accepted message_id and wait on the same subagent. If admission is uncertain, do not resend. Do not spawn a replacement.`;
+  return null;
+}
+
 function requireAdapter(harness) {
   const key = delegationAdapter(harness);
   if (!key) throw Object.assign(new Error(`Unsupported delegation adapter: ${harness}`), { code: "delegation_contract_unsupported" });

package/dist/harness-runtime/lib/lease-renewal.mjs

@@ -25,7 +25,8 @@ export function maintenanceRetryable(error) {
   let retryable = false;
   // Inspect only bounded typed causes from our maintenance transport, never text.
   for (let depth = 0; error && depth < 8; depth++, error = error.cause ?? error.details?.cause) {
-    if (error.details?.cleanup_unconfirmed === true) return false;
+    if (error.details?.cleanup_unconfirmed === true || error.cleanup_error || error.details?.cleanup_error
+      || error.details?.store_cleanup_errors?.length || error.details?.transaction_cleanup_error || error.details?.transaction_close_error) return false;
     if (error.details?.effect === "unknown") return false;
     if (["process_lease_lost", "controller_lease_lost", "process_maintenance_receipt_invalid", "runtime_owner_mismatch"].includes(error.code)) return false;
     if (error.code === "process_ownership_unknown" && error.details?.reason === "physical_identity_unavailable" && ["process_confirmation", "observer_registration"].includes(error.details.phase) && error.details.effect === "no_effect" && error.details.native_dispatch_started === false) retryable = true;

package/dist/harness-runtime/lib/native-children.d.mts

@@ -1,4 +1,5 @@
 export const NATIVE_CHILD_CONTRACT_VERSION: "native-children@1";
+export function settledNativeTree(root: string, children: Record<string, unknown>[], settled: boolean, rootSettled?: boolean): Record<string, unknown>;
 export function safeNativeFailure(value: unknown): Record<string, unknown> | undefined;
 export interface NativeChild {
   session_id: string;
@@ -9,6 +10,7 @@ export interface NativeChild {
   terminal_turn_id?: string;
   terminal_observed_at?: string;
   provider_error?: unknown;
+  native_source?: "opencode.v2.session.execution" | "agy.result" | "acp.error_response" | "droid.agent_turn_outcome" | "grok.subagent.event";
   native_turn_items?: { observed?: boolean; possible_effects?: boolean; pending?: boolean };
 }
 export function normalizeNativeChildren(receipt: Record<string, unknown>, rootSessionId: string): NativeChild[];