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

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

@@ -1,7 +1,9 @@
+import { managedFlowEnv } from './managed-flow-env.mjs';
 import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { ObservationClock } from "./observation-clock.mjs";
+import { prepareDaemonRequest } from "./native-request-proof.mjs";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
@@ -28,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.
@@ -90,7 +93,7 @@ async function removeSocket(socket, dir) {
 const errorPayload = errorRecord;
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
-  const request = { schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
+  const request = prepareDaemonRequest({ schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params });
   return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: RESPONSE_SCHEMA, harness: 'zcode', timeoutMs });
 }
 
@@ -110,22 +113,21 @@ function sameConfig(state, config) {
 }
 
 export async function startDaemon(options) {
+  if (options.noFlow) options = { ...options, ddFlowHome: undefined, ddFlowBin: undefined, projectRoot: undefined };
   const paths = locations(options.stateDir);
   const hasFlowContext = Boolean(options.ddFlowHome || options.projectRoot || options.ddFlowBin);
-  if (hasFlowContext && (!options.ddFlowHome || !options.projectRoot)) {
-    throw new DaemonError("flow_context_incomplete", "--dd-flow-home and --project-root must be provided together for ZCode lifecycle forwarding");
+  if (hasFlowContext && (!options.ddFlowHome || !options.projectRoot || !options.ddFlowBin)) {
+    throw new DaemonError("flow_context_incomplete", "--dd-flow-home, --dd-flow-bin and --project-root must be provided together for ZCode lifecycle forwarding");
   }
   const config = {
     cwd: absolute(options.cwd, "--cwd"),
     journal: absolute(options.journal, "--journal"),
     bin: options.bin ?? null,
     zcodePath: options.zcodePath ?? null,
-    // The worker itself invokes `dd-flow` from PATH.  Use that same executable
-    // for the trusted event bridge unless a pinned executable was supplied.
-    ddFlowBin: hasFlowContext ? (options.ddFlowBin ? absolute(options.ddFlowBin, "--dd-flow-bin") : "dd-flow") : null,
+    ddFlowBin: hasFlowContext ? absolute(options.ddFlowBin, "--dd-flow-bin") : null,
     ddFlowHome: options.ddFlowHome ? absolute(options.ddFlowHome, "--dd-flow-home") : null,
     projectRoot: options.projectRoot ? absolute(options.projectRoot, "--project-root") : null,
-    resourceHome: process.env.DD_FLOW_RESOURCE_HOME ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null,
+    resourceHome: !options.noFlow && process.env.DD_FLOW_RESOURCE_HOME ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null,
     env: { ...nativeRoutingEnv(), ...(options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home"), ...(options.ddFlowBin ? { DD_FLOW_BIN: absolute(options.ddFlowBin, "--dd-flow-bin") } : {}) } : {}) },
     livenessTimeoutMs: positiveDuration(options.livenessTimeoutMs, "livenessTimeoutMs", DEFAULT_LIVENESS_TIMEOUT_MS),
     requestTimeoutMs: optionalDuration(options.requestTimeoutMs, "requestTimeoutMs", DEFAULT_REQUEST_TIMEOUT_MS),
@@ -373,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);
@@ -385,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,
@@ -571,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");
@@ -683,8 +696,7 @@ export class DaemonRuntime {
 }
 
 export function zcodeBridgeEnv(config, daemonId) {
-  return { ...config.env, DD_FLOW_DAEMON_ID: daemonId,
-    DD_FLOW_RUNTIME_OWNER: config.runtime_owner ? JSON.stringify(config.runtime_owner) : undefined };
+  return { ...config.env, ...managedFlowEnv(config, daemonId) };
 }
 
 export async function serveDaemon(stateDir) {

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" });
@@ -49,7 +60,7 @@ export function delegationContract(harness) {
   return `dd-flow/delegation/${key}@${["codex", "opencode"].includes(key) ? 2 : 1}`;
 }
 
-export const lifecycleCommandCompletionInstruction = "Run runtime-issued lifecycle CLI calls in the foreground, never with a native background or detached-shell option. A shell tool may yield before the lifecycle process exits. Retain and poll its exact process/session handle to completion, including inside a tool wrapper; empty interim output is not a CLI result. Read final stdout or response_file before deciding continuation, and never reissue the command while it is pending.";
+export const lifecycleCommandCompletionInstruction = "Run runtime-issued lifecycle CLI calls in the foreground, never with a native background or detached-shell option. A shell tool may yield before the lifecycle process exits. Retain and poll its exact process/session handle to completion, including inside a tool wrapper; empty interim output is not a CLI result. If a wrapper returns 'Script running with cell ID …', use that wrapper's wait tool to finish the same cell before expecting an inner shell session handle; do not execute the command again. Read final stdout or response_file before deciding continuation, and never reissue the command while it is pending.";
 
 export const lifecycleRetryInstruction = `${lifecycleCommandCompletionInstruction} A failure is not permission to replay a lifecycle command. For proven effect=no_effect with recoverable=true and retry_command, correct the input and execute that exact issued successor. A check failure can retain receipts while leaving Work running: correct the evidenced cause first, then use the CLI's exact retry_command for an intentional fresh check attempt; never replay a check merely because Work is unsettled. If a successful CODE finish returns outcome=verification_required, inspect the retained receipts, update its verification file, and use only next.finish_command: the Stage is still running and the previous invocation ID is consumed. If continuation.kind=repair_required, or a successful result has outcome=repair_required and a repair Work ID, end this Turn for the registered repair child; use any retry_command only after that repair settles and verification is refreshed. Unknown effects require reconciliation, never replay. A committed effect without an explicit continuation is not retryable. A native shell launch refusal before the CLI starts permits correcting only that shell-form error and retrying the same exact command. Otherwise report the primary error and stop; never invent IDs, call hooks directly, or run status as a substitute.`;
 
@@ -71,7 +82,9 @@ export function workerDelegationTask({ workId, startCommand, launchPolicy }) {
     "Your first technical action must be this exact lifecycle command:",
     startCommand,
     "Execute the issued operation and target exactly. Lifecycle invocation IDs are internal runtime authority and are intentionally omitted; never add or invent them. Preserve any explicit native receipt handle that the command does contain.",
-    "Use the native shell's inherited working directory. Do not set or override a workdir/cwd field for this lifecycle command.",
+    startCommand.startsWith("cd '")
+      ? "Execute the literal cd shell prefix exactly; it routes this command into its runtime-owned private execution copy. Do not invent native spawn fields. After start, obey the packet's read_only/write scopes and prefix subsequent issued lifecycle commands with the same literal cd route. A review copy never grants permission to write reviewed inputs. The runtime independently checks the CLI process directory."
+      : "Use the native shell's inherited working directory. Do not set or override a workdir/cwd field for this lifecycle command.",
     "Continue only if it succeeds and returns the authoritative Work packet.",
     lifecycleRetryInstruction,
     "After a successful start, complete the assigned Work, write its required result, invoke its exact work finish command, then stop.",
@@ -109,7 +122,7 @@ export function renderDelegationInstructions({ harness, stage, capacity, works =
 
 export function renderCapacityInstructions({ harness, maximum }) {
   const adapter = requireAdapter(harness);
-  if (!Number.isInteger(maximum) || maximum < 1) throw new Error("Invalid native capacity limit");
+  if (!Number.isInteger(maximum) || maximum < 1 || maximum > 15) throw new Error("Native capacity limit must be an integer from 1 through 15");
   return [
     `Adapter delegation contract: ${delegationContract(harness)}.`,
     "This is a technical native-subagent capacity qualification, not product work.",

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/lifecycle-command.mjs

@@ -255,6 +255,7 @@ export function parseCommandArgs(argv) {
   const positional = [], options = new Map();
   for (let index = 0; index < argv.length; index++) {
     const value = argv[index];
+    if (value === "--") { positional.push(...argv.slice(index + 1)); break; }
     if (value?.startsWith("--")) {
       const equals = value.indexOf("=");
       if (equals > 2) { const key = value.slice(2, equals); options.set(key, [...(options.get(key) ?? []), value.slice(equals + 1)]); continue; }

package/dist/harness-runtime/lib/managed-daemon.d.mts

@@ -8,5 +8,6 @@ export function confirmDaemonProcess(config: RuntimeConfig, record: ProcessBindi
 export function assertDaemonOwnership(stateDir: string, dispatch?: Record<string, unknown>, assertCurrent?: () => void): Promise<void>;
 export function heartbeatDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined): Promise<void>;
 export function finishDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined, state?: string, reason?: string): Promise<void>;
+export function cleanupFailedDaemonStart(config: RuntimeConfig, record: ProcessBinding | null, child: ChildProcess | null, original: Error & { details?: Record<string, unknown> }, readState: () => Promise<Record<string, unknown>>, daemonId: string): Promise<void>;
 export function completeBudgetOperation(stateDir: string, request: { id: string; operation: string; params?: { sessionId?: string } }, result: unknown, observe?: () => Promise<Record<string, unknown>>): Promise<Record<string, unknown>>;
 export function stopProcessGroup(child: ChildProcess | null | undefined, graceMs?: number, options?: { detached?: boolean; settlementMs?: number }): Promise<void>;

package/dist/harness-runtime/lib/managed-daemon.mjs

@@ -61,14 +61,16 @@ export async function prepareRuntimeOwner(config, stateDir, env = process.env) {
 export async function assertDaemonOwnership(stateDir, dispatch = {}, assertCurrent = () => {}, progress = async () => {}, waiting = async () => {}) {
   const gate = async () => {
     assertCurrent();
+    let confirmed = false;
     for (const lease of leases.values()) {
       if (lease.stateDir !== path.resolve(stateDir)) continue;
       await reconfirmLease(lease, assertCurrent);
       assertCurrent();
+      confirmed = true;
     }
+    if (confirmed) await progress('ownership_confirmed');
   };
   await gate();
-  await progress('ownership_confirmed');
   const state = JSON.parse(await readFile(path.join(stateDir, "daemon.json"), "utf8"));
   const owner = bindRuntimeOwner({ runtime_owner: state.config?.runtime_owner ?? null }, {});
   if (!owner) return;
@@ -264,7 +266,7 @@ async function executeRuntimeProcess(config, action, options = {}, { timeoutMs,
   const poisonKey = token => JSON.stringify([path.resolve(resourceHome), options.id, token ?? null]);
   if (action !== "status" && options.id) {
     const poison = maintenancePoison.get(poisonKey(options["lease-token"])) ?? maintenancePoison.get(poisonKey(null));
-    if (poison) throw poison;
+    if (poison && !(action === "finish" && poison.finish === JSON.stringify(options))) throw poison.error;
   }
   const args = ["runtime", "process", action];
   for (const [key, value] of Object.entries(options)) if (value !== null && value !== undefined) args.push(`--${key}`, String(value));
@@ -275,9 +277,13 @@ async function executeRuntimeProcess(config, action, options = {}, { timeoutMs,
     try { output = await runBoundedCommand({ bin: ddFlowBin, args: [...args, "--json"], cwd: config.cwd,
       env: { ...(config.env ?? {}), DD_FLOW_HOME: ddFlowHome, DD_FLOW_RESOURCE_HOME: resourceHome }, timeoutMs,
       timeoutCode: action === "heartbeat" ? "process_heartbeat_timeout" : "process_maintenance_timeout", inheritDeadline: false, cleanupWithinBudget: true,
-      maintenanceProgress: { action, processId: options.id ?? null, startupMs: Math.min(timeoutMs, RENEWAL_POLICY.startupMs), inactivityMs: RENEWAL_POLICY.attemptMs }, signal }); }
+      // Storage silence is not loss of authority: the original command/lease
+      // deadline remains finite, including slow I/O and multiple bounded reads.
+      maintenanceProgress: { action, processId: options.id ?? null, startupMs: Math.min(timeoutMs, RENEWAL_POLICY.startupMs), inactivityMs: timeoutMs }, signal }); }
     catch (error) {
-      if (action !== "status" && options.id && error.details?.cleanup_unconfirmed) maintenancePoison.set(poisonKey(options["lease-token"]), error);
+      if (action !== "status" && options.id && error.details?.cleanup_unconfirmed) maintenancePoison.set(poisonKey(options["lease-token"]), {
+        error, ...(action === "finish" && error.code === "process_maintenance_timeout" ? { finish: JSON.stringify(options) } : {})
+      });
       throw error;
     }
     let result;
@@ -393,7 +399,9 @@ export async function heartbeatDaemonProcess(config, record) {
   if (lease.closing) throw Object.assign(new Error("Managed process is closing"), { code: "process_closing" });
   if (lease.lost) throw lease.error;
   if (lease.error && !maintenanceRetryable(lease.error)) throw lease.error;
-  if (!renewalRemaining(lease.renewal)) throw lease.error;
+  if (!renewalRemaining(lease.renewal)) throw lease.error ?? Object.assign(new Error("Managed lease authority has expired before heartbeat dispatch"), {
+    code: "process_ownership_unknown", details: { process_id: record.id, reason: "lease_authority_expired" }
+  });
   if (lease.pending) return await lease.pending;
   lease.pending = (async () => {
     try {
@@ -425,7 +433,7 @@ export async function finishDaemonProcess(config, process, state = "stopped", re
     // A predecessor owns its transport fence; finish gets an independent
     // settlement window only after that flight physically settled.
     const settlement = createRenewalState(); settlement.uncertainSince = performance.now();
-    const result = await retryBookkeeping(timeoutMs => runtimeProcess(config, "finish", { id: process.id, "lease-token": process.lease_token, state, reason }, { timeoutMs }), settlement);
+    const result = await retryBookkeeping(timeoutMs => runtimeProcess(config, "finish", { id: process.id, "lease-token": process.lease_token, state, reason }, { timeoutMs }), settlement, true);
     if (result?.ok !== true) throw Object.assign(new Error("managed process finish was not accepted"), { code: "process_lease_lost", details: { process_id: process.id } });
     leases.delete(key);
   }
@@ -453,11 +461,16 @@ async function reconfirmLease(lease, assertCurrent) {
     return;
   }
 }
-async function retryBookkeeping(action, renewal = createRenewalState()) {
+async function retryBookkeeping(action, renewal = createRenewalState(), repeatFinish = false) {
   renewal.uncertainSince ??= performance.now();
   for (;;) {
     try { return await action(renewalRemaining(renewal)); }
-    catch (error) { if (!maintenanceRetryable(error) || !renewalFailure(renewal)) throw error; await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(renewal), renewalRemaining(renewal)))); }
+    catch (error) {
+      // Exact finish is an idempotent terminal-state CAS, not productive IO.
+      // Its old helper may still commit the same finish; all other writes stay fenced.
+      if (!(maintenanceRetryable(error) || repeatFinish && error.code === "process_maintenance_timeout" && error.details?.cleanup_unconfirmed === true) || !renewalFailure(renewal)) throw error;
+      await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(renewal), renewalRemaining(renewal))));
+    }
   }
 }
 
@@ -482,7 +495,10 @@ function requireTimelyMaintenance(renewal, action, receipt, record) {
 export async function cleanupFailedStart(config, record, child, original) {
   try {
     await stopProcessGroup(child);
+    const stopped = child?.pid ? { pid: child.pid, pgid: process.platform === "win32" ? null : child.pid,
+      settled: true, physical_exit: "ESRCH", observed_at: new Date().toISOString() } : undefined;
     await finishDaemonProcess(config, record, "failed", original.code ?? "startup_failed");
+    return stopped;
   } catch (cleanup) {
     original.details = { ...original.details, cleanup_failed: errorRecord(cleanup), process_id: record?.id ?? null, pid: child?.pid ?? null };
   }
@@ -491,7 +507,7 @@ export async function cleanupFailedStart(config, record, child, original) {
 /** The provider has its own process group. A failed daemon start must settle
  * that exact retained process as well as the daemon; PID-only cleanup is unsafe. */
 export async function cleanupFailedDaemonStart(config, daemonRecord, daemonChild, original, readState, daemonId) {
-  await cleanupFailedStart(config, daemonRecord, daemonChild, original);
+  const stopped = await cleanupFailedStart(config, daemonRecord, daemonChild, original);
   if (!daemonRecord) return;
   try {
     const state = await readState();
@@ -502,6 +518,15 @@ export async function cleanupFailedDaemonStart(config, daemonRecord, daemonChild
     }
     const provider = state.provider_process;
     if (provider) await runtimeProcess(config, "stop", { id: provider.id, "lease-token": provider.lease_token });
+    // Confirmation can fail before the registry learns the child's PID. The
+    // owned child handle still proves its physical exit, not a productive ACK.
+    if (stopped && !original.details?.cleanup_failed && !original.details?.provider_cleanup_failed && state.pid === stopped.pid && !provider && state.provider_pid == null && owner) {
+      original.details = { ...original.details, startup_child_cleanup: {
+        ...stopped, daemon_id: daemonId, process_id: daemonRecord.id,
+        owner_id: owner.owner_id, project_id: owner.project_id, run_id: owner.run_id,
+        operation_id: owner.operation_id, state_dir: owner.state_dir
+      } };
+    }
   } catch (cleanup) {
     original.details = { ...original.details, provider_cleanup_failed: errorRecord(cleanup) };
   }
@@ -587,29 +612,39 @@ async function stopOwnedChild(child, graceMs, detached, settlementMs) {
 
 /** A daemon acknowledgement is not a completed stop until its endpoint closes. */
 export async function confirmDaemonStopped(request, socket, timeoutMs = 30_000, { readState } = {}) {
-  const deadline = performance.now() + timeoutMs;
   const expected = await readState?.();
   const identity = state => state?.daemon_id ?? state?.config?.daemonId;
   if (readState && (!identity(expected) || !Number.isSafeInteger(expected?.pid) || expected.pid < 1)) throw Object.assign(new Error('daemon stop has no retained incarnation/PID proof'), { code: 'daemon_cleanup_identity_mismatch' });
   const failure = async observer => {
     const state = await readState?.();
-    if (expected && identity(state) !== identity(expected)) throw Object.assign(new Error("daemon incarnation changed during stop"), { code: "daemon_identity_mismatch" });
+    if (expected && (identity(state) !== identity(expected) || state?.pid !== expected.pid)) throw Object.assign(new Error("daemon incarnation changed during stop"), { code: "daemon_identity_mismatch" });
     const primary = state?.shutdown_state === "cleanup_failed" ? state.cleanup_error : null;
     if (primary) throw Object.assign(new Error(primary.message), primary, { details: { ...primary.details, socket, phase: "confirm_daemon_stop", observer_error: errorRecord(observer) } });
     throw observer;
   };
-  let result;
+  let result, observationError;
   try { result = await request(); }
-  catch (error) { return await failure(error); }
-  if (result?.stopped !== true) return await failure(Object.assign(new Error("stop acknowledgement does not prove shutdown"), { code: "daemon_stop_incomplete" }));
+  catch (error) {
+    if (!expected || !["daemon_timeout", "daemon_not_running", "daemon_connection_closed", "operation_observation_lost"].includes(error.code)) return await failure(error);
+    observationError = error;
+  }
+  if (!observationError && result?.stopped !== true) return await failure(Object.assign(new Error("stop acknowledgement does not prove shutdown"), { code: "daemon_stop_incomplete" }));
+  // The RPC wait and physical retirement are separate phases. A lost ACK
+  // consumes the former, not the existing confirmation budget.
+  const deadline = performance.now() + timeoutMs;
   for (;;) {
     const state = await readState?.();
-    if (expected && identity(state) !== identity(expected)) return await failure(Object.assign(new Error("daemon incarnation changed"), { code: "daemon_identity_mismatch" }));
+    if (expected && (identity(state) !== identity(expected) || state?.pid !== expected.pid)) return await failure(Object.assign(new Error("daemon incarnation changed"), { code: "daemon_identity_mismatch" }));
+    if (state?.shutdown_state === "cleanup_failed") return await failure(observationError ?? Object.assign(new Error("daemon cleanup failed"), { code: "daemon_stop_incomplete" }));
     let endpointPresent = true;
     try { await lstat(socket); } catch (error) { if (error.code === "ENOENT") endpointPresent = false; else throw error; }
     let daemonPresent = false;
     if (expected?.pid) { try { process.kill(expected.pid, 0); daemonPresent = true; } catch (error) { if (error.code !== "ESRCH") daemonPresent = true; } }
     if (!endpointPresent && !daemonPresent) {
+      if (observationError) {
+        if (state?.shutdown_state === "clean" && state.active_tree === false && !state.cleanup_error) return { stopped: true, clean: true };
+        return await failure(observationError);
+      }
       if (readState && result.clean === true && (state?.shutdown_state !== 'clean' || state.active_tree !== false)) return await failure(Object.assign(new Error('daemon clean ACK conflicts with its retained state'), { code: 'daemon_stop_incomplete' }));
       return result;
     }