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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.151
+
+### Patch Changes
+
+- Preserve causal AGY completion and model/role evidence, share bounded recursive
+  runner proof, and continue eligible provider failures with effect-fenced native
+  child admission. Admit the reviewed CP253 ZCode bridge and bind browser facts
+  to stage context without turning an unavailable probe into a baseline gate.
+- Replace blanket release checks with scoped contract receipts and package
+  delivery verification; keep provider, Memory Bank and CLI ownership separate
+  so harness fixes do not launch unrelated acceptance suites.
+
 ## 0.9.0-beta.150
 
 ### Patch Changes

package/README.md

@@ -510,28 +510,23 @@ remain invalid and receive a standalone retry.
 
 ## Verification
 
-For a code merge, start with the cheap common contracts, then select affected
-storage/process/flow checks explicitly and record the selection reason:
-
-```bash
-pnpm gate:merge
-```
-
-For release acceptance, freeze source/canon, build once, then use
-`DD_FLOW_GATE_REPORT_ROOT=/absolute/external/report pnpm gate:release`.
-Node family selection lives in `package.json`, Vitest membership in
-`vitest.config.ts`, and required release receipts in `scripts/release-candidate.mjs`.
-The local and CI profiles cover the same required guarantees; qualification-only
-cases report their prerequisites/skips separately. Tests invoking compiled CLI
-must use the current frozen build, even for a partial merge check.
-For development use `pnpm test:fast`, `pnpm test:core` or `pnpm test:flow` plus
-the affected native contracts; these subsets are not full acceptance.
-New files default to serial core execution. A forced serial fallback is
-`pnpm test:integration --no-file-parallelism --maxWorkers=1`.
-The [test-suite verification runbook](https://github.com/deksden-com/dd-eval/blob/main/runbooks/flow-test-suite-verification.md)
-owns group qualification, complete reports and cross-repository commands.
-
-Manual smoke checks should use a temporary `DD_FLOW_HOME` when they do not intentionally inspect the operator's real local state.
+Checks follow changed contracts, not a merge/release/EVAL event. Inspect
+`pnpm verify:plan`, then run `pnpm test` (or `pnpm gate:merge`) for only missing
+affected contracts. `scripts/verification-policy.mjs` owns impact selection;
+existing Node/Vitest runners retain complete selected-file/case evidence.
+Unknown impact requires an explicit policy mapping, never a full-suite fallback.
+
+There is no mandatory full release gate. Freeze source/canon, build and pack the
+exact artifact, then accept with `DD_FLOW_VERIFICATION_RECEIPT` pointing to the
+scoped verification receipt. Preserve receipts outside the checkout. Unchanged
+contract inputs reuse intact reports; commit/version/build time alone do not
+invalidate behavior evidence. Failed/unknown attempts require investigation,
+not automatic retries. Package identity and registry readback remain mandatory.
+GitHub CI is disabled. Publication does not repeat the accepted package's smoke
+after identical registry tar readback. EVAL preparation is resource readiness,
+not another engine or product test suite.
+The [verification runbook](https://github.com/deksden-com/dd-eval/blob/main/runbooks/flow-test-suite-verification.md)
+owns the local procedure. A scoped PASS is not a claim that every test ran.
 
 ### RUN status during recovery
 

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.150",
-  "cli_commit": "ad05c70447949f295e588546fe27f6abc4640c3f",
-  "built_at": "2026-10-24T17:47:48.856Z",
+  "cli_version": "0.9.0-beta.151",
+  "cli_commit": "89cad0d654601de59b12929240eee4e958b74207",
+  "built_at": "2026-10-25T10:59:05.638Z",
   "built_with_canon": {
     "version": "4.1.2",
     "commit": "925ef10ecc0b683f7feba6f74913e15560842500",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-release146",
-    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-release146/.memory-bank",
-    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-release146/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/harness-runtime/lib/agy-error-boundary.mjs

@@ -1,19 +1,22 @@
 import { parseLifecycleCommand, commandOption, commandPosition } from "./lifecycle-command.mjs";
 import { entityReferenceVariants } from "./entity-references.mjs";
+import { agyTerminalEnvelope, ownedAgyOutput } from "./agy-terminal-envelope.mjs";
 
 /** Ordered native transcript evidence, never assistant text as a success signal. */
-export function recoveredAgyErrorBoundary(text, error, floor = -1) {
+export function recoveredAgyErrorBoundary(text, error, floor = -1, source = null, sessionId = null) {
   let rows;
   try { rows = text.trim().split("\n").filter(Boolean).map(JSON.parse); } catch { return null; }
-  let previous = -1, lastError = null, boundary = null, invocation = null;
+  let previous = -1, lastError = null, boundary = null, invocation = null, call = null;
+  const launches = new Map();
   for (const row of rows) {
     if (!Number.isInteger(row.step_index) || row.step_index <= previous) return null;
     previous = row.step_index;
     if (row.step_index <= (floor ?? -1)) continue;
-    if (row.type === "USER_INPUT") { lastError = null; boundary = null; invocation = null; continue; }
+    if (row.type === "USER_INPUT") { lastError = null; boundary = null; invocation = null; call = null; launches.clear(); continue; }
     if (row.type === "ERROR_MESSAGE") { lastError = row; boundary = null; invocation = null; continue; }
     if (Array.isArray(row.tool_calls)) {
       invocation = null;
+      call = row.tool_calls.length === 1 ? row.tool_calls[0] : null;
       if (row.tool_calls.length === 1 && row.tool_calls[0]?.name === "run_command") {
         let command = row.tool_calls[0]?.args?.CommandLine;
         if (typeof command === "string") {
@@ -23,8 +26,22 @@ export function recoveredAgyErrorBoundary(text, error, floor = -1) {
         }
       }
     }
-    if (!lastError || row.type !== "GENERIC" || row.status !== "DONE" || typeof row.content !== "string" || !row.content.includes("Command exited with code 0.")) continue;
-    const output = row.content.split("Command output:\n")[1]?.replaceAll("\r", "");
+    if (row.type === 'GENERIC' && row.status === 'RUNNING') {
+      const task = row.content?.match(/^Created At: [^\n]+\nTool is running as a background task with task id: ([\w-]+\/task-\d+)\n/);
+      if (task && invocation && (!sessionId || task[1].startsWith(`${sessionId}/`))) launches.set(task[1], launches.has(task[1]) ? null : { invocation, step: row.step_index });
+      call = null; invocation = null; continue;
+    }
+    const envelope = agyTerminalEnvelope(row, call);
+    let launchStep = null;
+    if (envelope?.task_id) {
+      const launch = launches.get(envelope.task_id);
+      invocation = launch && launch.step < row.step_index ? launch.invocation : null;
+      launchStep = launch?.step ?? null;
+    }
+    if (!lastError || envelope?.exit_code !== 0) continue;
+    const retained = envelope.output_reference && source && sessionId ? ownedAgyOutput(envelope.output_reference, source, sessionId, envelope.task_id) : null;
+    const full = retained ? agyTerminalEnvelope({ type: 'GENERIC', status: 'DONE', content: retained.text }) : null;
+    const output = (retained ? full?.exit_code === 0 ? full.output : null : envelope.output)?.replaceAll("\r", "");
     if (!output) continue;
     for (const match of output.matchAll(/^\s*\{/gm)) {
       let receipt;
@@ -51,6 +68,10 @@ export function recoveredAgyErrorBoundary(text, error, floor = -1) {
         && [receipt.run_id, receipt.stage, receipt.work_id].every(value => typeof value === "string" && value)
         && (receipt.outcome !== "paused" || typeof receipt.pause?.id === "string")) boundary = { receipt: { ok: true, outcome: receipt.outcome, run_id: receipt.run_id, stage: receipt.stage, work_id: receipt.work_id,
           lifecycle_operation: "stage_pause", pause: { id: receipt.pause.id } }, error_step: lastError.step_index, boundary_step: row.step_index };
+      if (boundary?.boundary_step === row.step_index) {
+        if (launchStep !== null) boundary.invocation_step = launchStep;
+        if (retained) boundary.output_source = { locator: retained.locator, sha256: retained.sha256 };
+      }
     }
   }
   return boundary && lastError?.error === error ? boundary : null;

package/dist/harness-runtime/lib/agy-terminal-envelope.mjs

@@ -0,0 +1,67 @@
+import { constants, openSync, closeSync, fstatSync, lstatSync, readSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+const taskId = '[\\w-]+/task-\\d+';
+
+export function ownedAgyOutput(reference, source, sessionId, ownerTask = null) {
+  let fd;
+  try {
+    const transcript = fileURLToPath(source.locator), file = fileURLToPath(reference);
+    const system = path.dirname(path.dirname(transcript));
+    if (path.basename(path.dirname(system)) !== sessionId || path.basename(system) !== '.system_generated') return null;
+    const relative = path.relative(system, file);
+    if (!/^(?:steps\/\d+\/output\.txt|tasks\/task-\d+\.log)$/.test(relative) || realpathSync(file) !== file || realpathSync(system) !== system) return null;
+    if (ownerTask) {
+      const number = ownerTask.match(new RegExp(`^${sessionId}/task-(\\d+)$`))?.[1];
+      if (!number || ![`steps/${number}/output.txt`, `tasks/task-${number}.log`].includes(relative)) return null;
+    }
+    const before = lstatSync(file);
+    if (!before.isFile() || before.size > 2 * 1024 * 1024) return null;
+    fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.ino !== before.ino || stat.dev !== before.dev) return null;
+    const bytes = Buffer.alloc(stat.size);
+    let offset = 0;
+    while (offset < bytes.length) { const count = readSync(fd, bytes, offset, bytes.length - offset, offset); if (!count) return null; offset += count; }
+    const after = fstatSync(fd);
+    if (stat.size !== after.size || stat.mtimeMs !== after.mtimeMs) return null;
+    return { text: bytes.toString('utf8'), sha256: createHash('sha256').update(bytes).digest('hex'), locator: reference };
+  } catch { return null; }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+
+/** Only a native envelope is decoded here; stdout cannot introduce terminal authority. */
+export function agyTerminalEnvelope(row, call = null) {
+  if (row?.status !== 'DONE' || typeof row.content !== 'string') return null;
+  let body = row.content.replaceAll('\r\n', '\n'), id = null, cancelled = false;
+  if (row.source === 'SYSTEM' && row.type === 'SYSTEM_MESSAGE') {
+    const match = body.match(new RegExp(`(?:^|\\n)\\[Message\\] timestamp=[^\\n]+ sender=(${taskId}) priority=MESSAGE_PRIORITY_(?:HIGH|LOW) content=Task id "(${taskId})" (finished with result:|was canceled with result:)\\n`));
+    if (!match || match[1] !== match[2]) return null;
+    id = match[1]; cancelled = match[3].startsWith('was canceled');
+    body = body.slice(match.index + match[0].length).replace(/\n<\/SYSTEM_MESSAGE>\s*$/, '');
+  } else if (row.type !== 'GENERIC' || row.source && row.source !== 'MODEL') return null;
+  else {
+    body = body.replace(/^Created At: [^\n]+\nCompleted At: [^\n]+\n/, '');
+    if (call?.name === 'manage_task') {
+      const decode = value => { try { return JSON.parse(value); } catch { return value; } };
+      id = decode(call.args?.TaskId);
+      const action = decode(call.args?.Action);
+      const status = body.match(new RegExp(`^Task: (${taskId})\\nStatus: (DONE|COMPLETED|FAILED|CANCELLED)(?:\\n|$)`));
+      if (action === 'status' && status?.[1] === id) return { task_id: id, task_terminal: true, exit_code: null, command_outcome: status[2] === 'DONE' ? null : status[2].toLowerCase(), output: null };
+      if (action === 'kill' && body.match(new RegExp(`^Task "(${taskId})" cancelled\\.(?:\\n|$)`))?.[1] === id) return { task_id: id, task_terminal: true, exit_code: null, command_outcome: 'cancelled', output: null };
+      return null;
+    }
+  }
+  // This exact wrapper preserves the beginning of the native result, including its exit header.
+  const wrapper = body.match(/^The tool's output was truncated due to being too long\. You can find the full output in a file at (file:\/\/[^\n]+)\.\n\nHere is a preview with the middle of the output truncated:\n/);
+  if (wrapper) body = body.slice(wrapper[0].length);
+  if (cancelled && /^Tool execution was canceled(?:\n|$)/.test(body)) return { task_id: id, task_terminal: true, exit_code: null, command_outcome: 'cancelled', output: null };
+  const header = body.match(/^Command exited with code (-?\d+)\.(?:\n|$)/);
+  if (!header) return null;
+  const exit = Number(header[1]);
+  if (!Number.isSafeInteger(exit)) return null;
+  return { task_id: id, task_terminal: true, exit_code: exit, command_outcome: exit === 0 ? 'completed' : 'failed', output: wrapper ? null : body.split('Command output:\n')[1] ?? null,
+    ...(wrapper ? { output_reference: wrapper[1] } : {}) };
+}

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

@@ -24,6 +24,7 @@ import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
 import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, agyModelArgs, assertProfile, executable, observedProfile, runAgy, usageSnapshot, managedAgyEnv } from "./dd-agy.mjs";
 import { recoveredAgyErrorBoundary } from "./agy-error-boundary.mjs";
+import { agyTerminalEnvelope } from "./agy-terminal-envelope.mjs";
 import { settledNativeTree, nativeExecutionReceipt } from "./native-children.mjs";
 import { retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 import { readNativeLines, streamNativeDiagnostics, nativeObservationError, admitNativeRequestBuffer } from "./native-streams.mjs";
@@ -51,10 +52,10 @@ export function agyTranscriptFacts(text, source, sessionId) {
     const content = typeof event.content === 'string' ? event.content : '';
     const native_source = { ...source, step_index: event.step_index };
     if (event.source === 'SYSTEM' && event.type === 'SYSTEM_MESSAGE' && event.status === 'DONE') {
-      const terminal = content.match(/(?:^|\n)\[Message\] timestamp=[^\n]+ sender=([\w-]+\/task-\d+) priority=MESSAGE_PRIORITY_(?:HIGH|LOW) content=Task id "([\w-]+\/task-\d+)" (finished with result:\nCommand exited with code (-?\d+)\.|was canceled with result:\nTool execution was canceled)(?:\n|$)/);
-      if (terminal && terminal[1] === terminal[2]) {
-        const prior = resources.get(terminal[1]);
-        if (prior) resources.set(prior.resource_id, mergeAgyResource(prior, { ...prior, state: 'stopped', native_outcome: terminal[4] === undefined ? 'cancelled' : Number(terminal[4]) === 0 ? 'completed' : 'failed', terminal_source: native_source }));
+      const terminal = agyTerminalEnvelope(event);
+      if (terminal) {
+        const prior = resources.get(terminal.task_id);
+        if (prior) resources.set(prior.resource_id, mergeAgyResource(prior, { ...prior, state: 'stopped', ...(terminal.command_outcome ? { native_outcome: terminal.command_outcome } : {}), terminal_source: native_source }));
       }
       continue;
     }
@@ -63,13 +64,8 @@ export function agyTranscriptFacts(text, source, sessionId) {
     if (event.type !== 'GENERIC') continue;
     const call = calls.shift();
     if (call?.name === 'manage_task' && event.status === 'DONE') {
-      const decode = value => { try { return JSON.parse(value); } catch { return value; } };
-      const id = decode(call.args?.TaskId), action = decode(call.args?.Action);
-      const prior = resources.get(id);
-      if (prior && action === 'kill' && content.match(/^Created At: [^\n]+\nCompleted At: [^\n]+\nTask "([\w-]+\/task-\d+)" cancelled\.(?:\n|$)/)?.[1] === id)
-        resources.set(id, mergeAgyResource(prior, { ...prior, state: 'stopped', native_outcome: 'cancelled', terminal_source: native_source }));
-      const status = action === 'status' && content.match(/^Created At: [^\n]+\nCompleted At: [^\n]+\nTask: ([\w-]+\/task-\d+)\nStatus: (COMPLETED|FAILED|CANCELLED)\n/);
-      if (prior && status?.[1] === id) resources.set(id, mergeAgyResource(prior, { ...prior, state: 'stopped', native_outcome: status[2].toLowerCase(), terminal_source: native_source }));
+      const terminal = agyTerminalEnvelope(event, call), prior = resources.get(terminal?.task_id);
+      if (prior) resources.set(prior.resource_id, mergeAgyResource(prior, { ...prior, state: 'stopped', ...(terminal.command_outcome ? { native_outcome: terminal.command_outcome } : {}), terminal_source: native_source }));
     }
     if (call?.name === 'invoke_subagent' && event.status === 'DONE') {
       const match = content.match(/^Created At: [^\n]+\nCompleted At: [^\n]+\nCreated the following subagent:\n(\{[\s\S]*?\})\nThe subagent will send you a message/);
@@ -98,7 +94,7 @@ export function mergeAgyResource(prior, next) {
     return { ...prior, state: 'unknown', observation_conflict: true };
   if (prior.observation_conflict || next.observation_conflict || prior.native_outcome && next.native_outcome && prior.native_outcome !== next.native_outcome)
     return { ...prior, state: 'unknown', observation_conflict: true };
-  if (next.native_outcome && (!Number.isSafeInteger(next.native_source?.step_index) || !Number.isSafeInteger(next.terminal_source?.step_index) || next.terminal_source.step_index <= next.native_source.step_index))
+  if (next.terminal_source && (!Number.isSafeInteger(next.native_source?.step_index) || !Number.isSafeInteger(next.terminal_source?.step_index) || next.terminal_source.step_index <= next.native_source.step_index))
     return { ...prior, state: 'unknown', observation_conflict: true };
   if (prior.state === 'stopped' && next.state !== 'stopped') {
     if (next.native_source?.step_index > (prior.terminal_source?.step_index ?? prior.native_source?.step_index))
@@ -578,8 +574,8 @@ export class Runtime {
       if (result.status === "ERROR" && settled && rootStop?.fullyIdle === true && !this.state.last_hook_rejection && current.operationId && this.paths.runtime) {
         const root = this.init.conversation_id, transcript = path.join(this.paths.runtime, "brain", root, ".system_generated", "logs", "transcript.jsonl");
         await captureAgyTranscript(this.paths.runtime, { provider_session_id: root, parent_provider_session_id: root, log_uri: new URL(`file://${transcript}`).href }, root, [root], (text, source) => {
-          const boundary = recoveredAgyErrorBoundary(text, result.error, current.stepFloor);
-          const hook = current.nativeHookEvents?.get(boundary?.boundary_step);
+          const boundary = recoveredAgyErrorBoundary(text, result.error, current.stepFloor, source, root);
+          const hook = current.nativeHookEvents?.get(boundary?.invocation_step ?? boundary?.boundary_step);
           if (boundary && hook) terminalMetadata.recovered_error_boundary = { ...boundary, receipt: { ...boundary.receipt, native_hook_event_key: hook, daemon_instance: this.config.daemonId }, source };
         });
       }

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import { SETUP_STARTUP_MS } from './setup-progress.mjs';
 
 import { checkObservedProfile } from "./model-observations.mjs";
-import { classifyProviderError, safeProviderError, streamRequestKey } from "./provider-overload-policy.mjs";
+import { classifyRecoveryError as classifyProviderError, safeProviderError, streamRequestKey } from "./provider-overload-policy.mjs";
 
 const DEFAULT_MODEL = "gemini-3.1-pro-high";
 export const AGY_VERSION_TIMEOUT_MS = 30_000;
@@ -31,9 +31,9 @@ export function agyTerminalFailure(result, metadata = {}) {
   const identity = result.turn_id ?? result.request_id;
   const turn = typeof identity === "string" && identity ? identity : null;
   const stream = streamRequestKey(metadata.request_proof);
-  const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited"].includes(category) && !turn && !stream;
+  const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(category) && !turn && !stream;
   if (proofMissing) code = "provider_overload_evidence_unavailable";
-  return new AgyError(code, String(native.message ?? "Antigravity returned ERROR"), code === "provider_capacity_transient" || code === "provider_rate_limited", {
+  return new AgyError(code, String(native.message ?? "Antigravity returned ERROR"), ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(code), {
     provider_result: result, ...metadata, provider_error: safeProviderError(native), native_source: "agy.result", terminal_status: result.status === "ERROR" ? "failed" : "cancelled",
     ...(turn ? { turn_id: turn, native_turn_id: turn } : {}),
     ...(proofMissing ? { provider_category: category, reason: "native_turn_identity_unavailable" } : {}),

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

@@ -21,7 +21,7 @@ const metadataReaders = new Map();
 function metadataReader(factory) { if (!metadataReaders.has(factory)) metadataReaders.set(factory, new DroidMetadataReader(factory)); return metadataReaders.get(factory); }
 import { confirmDaemonProcess, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 import { renderAdapterPolicy, lifecycleRetryInstruction } from "./delegation-instructions.mjs";
-import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
+import { classifyRecoveryError as classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 import { settledNativeTree, nativeExecutionReceipt } from "./native-children.mjs";
 
 export const DROID_CONTRACT = "dd-droid-harness@1";
@@ -108,7 +108,7 @@ export function droidTerminalFailure(outcome, sessionId, settled) {
     terminal_status: "failed", native_source: "droid.agent_turn_outcome", observed_at: new Date().toISOString(),
     provider_error: safeProviderError(outcome.error), will_retry: outcome.error.willRetry === true, native_retry_active: outcome.error.willRetry === true,
     native_turn_items: { observed: settled === true, possible_effects: true, pending: settled !== true }
-  }), { retryable: code === "provider_capacity_transient" || code === "provider_rate_limited" });
+  }), { retryable: ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(code) });
 }
 
 

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

@@ -91,9 +91,12 @@ async function prepare(paths, config, authSource) {
     }
   }
   catch (error) { if (error.code !== "ENOENT") throw new DaemonError("opencode_config_invalid", "Portable OpenCode provider config must be valid JSON"); }
-  await writeJson(path.join(paths.config, "opencode", "opencode.json"), { ...portable, ...agentRestrictions, permissions,
-    agents: { ...agentRestrictions.agents, "dd-flow-worker": { mode: "subagent", system: "Execute the assigned dd-flow Work. Follow the issued lifecycle instructions. Do not spawn descendants.", model: `${config.provider}/${config.model}${config.variant !== "default" ? `#${config.variant}` : ""}` } },
-    experimental: { subagent_depth: 1, ...(policies ? { policies } : {}) } });
+  const generatedConfig = { ...portable, ...agentRestrictions, permissions,
+    agents: { ...agentRestrictions.agents, "dd-flow-worker": { ...agentRestrictions.agent?.[config.agent], ...agentRestrictions.agents?.[config.agent], mode: "subagent", system: "Execute the assigned dd-flow Work. Follow the issued lifecycle instructions. Do not spawn descendants.", model: `${config.provider}/${config.model}${config.variant !== "default" ? `#${config.variant}` : ""}` } },
+    experimental: { subagent_depth: 1, ...(policies ? { policies } : {}) } };
+  const configPath = path.join(paths.config, "opencode", "opencode.json");
+  await writeJson(configPath, generatedConfig);
+  config.workerLaunchConfig = { locator: configPath, sha256: createHash('sha256').update(await readFile(configPath)).digest('hex'), primary_agent: config.agent, subagent: 'dd-flow-worker', max_depth: 1 };
   config.pluginSha256 = await writePlugin(paths, config);
 }
 async function bootstrapCredentials(config, client) {
@@ -303,6 +306,8 @@ export class Runtime {
       if (info.sessionID && info.sessionID !== id) throw new DaemonError("session_identity_mismatch", "native message belongs to another Session");
       await observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
         requested: { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent },
+        nativeAgentRole: this.state.config.workerLaunchConfig ? { name: info.mode ?? null, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
+          launch: { ...this.state.config.workerLaunchConfig, root_session_id: this.sessions.get(id)?.root_provider_session_id ?? null } } : null,
         observed: { provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode }, source: { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}:${info.modelID}`).digest("hex") }, evidence: "response" });
       this.modelMessages.add(info.id);
     }

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

@@ -4,7 +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";
+import { classifyRecoveryError as classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 
 export const OPENCODE_PROTOCOL = 2;
 export class OpenCodeError extends Error {
@@ -59,7 +59,7 @@ export function providerFailure(native, sessionId, turnId) {
   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_capacity_transient", "provider_rate_limited", "provider_network_transient"].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),

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

@@ -459,7 +459,7 @@ export class DaemonRuntime {
       if (active && active.session_id !== params.sessionId) throw new DaemonError("session_identity_mismatch", "Retained observation has a foreign active root");
       const cacheScope = `${params.sessionId}:${generation}`;
       if (this.childObservationScope !== cacheScope) { this.childObservationScope = cacheScope; this.childTerminalCache = new Map(); this.childObservationKeys = new Set(); }
-      const subagents = await readZcodeSubagents(this.bridge, root.adapter_session_id, 30_000, true, this.childTerminalCache);
+      const subagents = await readZcodeSubagents(this.bridge, root.adapter_session_id, 30_000, true, this.childTerminalCache, root.provider_session_id);
       if (generation !== (this.controlGeneration ?? 0)) throw new DaemonError("operation_cancelled", "Observation generation was retired");
       if (activeIdentity(this.state.active_request) !== capturedIdentity) throw new DaemonError("operation_cancelled", "Observation belongs to a retired active Turn");
       assertDaemonDispatch(this.paths.dir);

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

@@ -15,7 +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 { classifyRecoveryError as classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
 
 import { readZcodeUsage } from "./zcode-usage.mjs";
 const ZCODE_HARNESS_CONTRACT = "dd-zcode-harness@1";
@@ -200,6 +200,7 @@ export class AcpBridge {
       clientInfo: this.options.clientInfo ?? { name: "dd-zcode", version: "0.1.0" },
     }, this.options.initializeTimeoutMs ?? SETUP_STARTUP_MS);
     publishSetup('native_initialized', 'native-initialize');
+    this.recoveryCapability = initialized?._meta?.zcode?.ddFlowRecovery;
     return initialized;
   }
 
@@ -306,7 +307,7 @@ export class AcpBridge {
           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.retryable = ["provider_rate_limited", "provider_capacity_transient", "provider_network_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 },
@@ -581,13 +582,13 @@ async function resume(bridge, sessionId, cwd) {
 
 /** Ended children are paginated by the native API (20 by default). A partial
  * directory is never settlement evidence, including during teardown. */
-export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000, retained = false, terminalCache = new Map()) {
+export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000, retained = false, terminalCache = new Map(), parentSessionId = sessionId) {
   const clock = new ObservationClock({ timeoutMs });
   const cursors = new Set(), ended = new Map();
   let first, cursor;
   for (;;) {
     if (clock.sample()) fail("ZCode child observation is unavailable", "operation_observation_lost");
-    const response = await bridge.request(retained ? "zcode/session/retainedSubagents" : "zcode/session/subagents", { sessionId, ...(cursor ? { endedCursor: cursor } : {}) }, timeoutMs);
+    const response = await bridge.request(retained ? "zcode/session/retainedSubagents" : "zcode/session/subagents", { sessionId, proofContract: "zcode/retained-child-effects@1", ...(cursor ? { endedCursor: cursor } : {}) }, timeoutMs);
     if (retained && response?.sessionId !== sessionId) fail("Retained ZCode child directory has a foreign Session identity", "native_topology_incomplete");
     const page = retained ? response.topology : response;
     if (!page || !Array.isArray(page.running)) fail("ZCode child directory is unavailable", "native_topology_incomplete");
@@ -615,7 +616,7 @@ export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000,
         const cacheKey = JSON.stringify([child.childSessionId, child.startedAt, child.endedAt]);
         if (terminalCache.has(cacheKey)) { items.push(terminalCache.get(cacheKey)); continue; }
         let terminal;
-        try { terminal = await bridge.request("zcode/session/retainedTerminal", { sessionId: child.childSessionId, startedAt: child.startedAt, endedAt: child.endedAt }, timeoutMs); }
+        try { terminal = await bridge.request("zcode/session/retainedTerminal", { sessionId: child.childSessionId, parentSessionId, startedAt: child.startedAt, endedAt: child.endedAt, proofContract: "zcode/retained-child-effects@1" }, timeoutMs); }
         catch (error) { items.push({ ...child, terminal_metadata_unavailable: error.code ?? "terminal_metadata_unavailable" }); continue; }
         if (terminal?.available !== true) { items.push({ ...child, terminal_metadata_unavailable: "terminal_metadata_unavailable" }); continue; }
         const observedAt = Date.parse(terminal.terminal_observed_at);
@@ -623,9 +624,23 @@ export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000,
           || terminal.startedAt !== child.startedAt || terminal.endedAt !== child.endedAt
           || !Number.isFinite(observedAt) || observedAt < child.startedAt || observedAt > child.endedAt) fail("ZCode terminal failure metadata has foreign identity", "native_child_turn_conflict");
         const providerError = safeNativeFailure(terminal.provider_error);
-        const item = { ...child, terminal_turn_id: terminal.terminal_turn_id, terminal_observed_at: terminal.terminal_observed_at,
+        const proof = terminal.effects_proof;
+        const ref = terminal.continuation_ref;
+        const effectsBound = proof?.schema_id === "zcode/retained-child-effects@1" && proof.session_id === child.childSessionId
+          && proof.started_at === child.startedAt && proof.ended_at === child.endedAt && proof.terminal_turn_id === terminal.terminal_turn_id
+          && proof.settled === true && proof.native_turn_items?.observed === true && proof.native_turn_items?.pending === false;
+        const refBound = effectsBound && ref?.schema_id === "zcode/child-continuation@1" && ref.child_session_id === child.childSessionId
+          && ref.parent_session_id === parentSessionId && ref.started_at === child.startedAt && ref.ended_at === child.endedAt && ref.terminal_turn_id === terminal.terminal_turn_id
+          && typeof ref.agent_id === "string" && /^agent_[\w-]+$/.test(ref.agent_id) && typeof ref.parent_tool_call_id === "string" && ref.parent_tool_call_id
+          && ref.capability === "dd-flow/managed-provider-recovery@1";
+        const item = { ...child, terminal_turn_id: terminal.terminal_turn_id, terminal_observed_at: terminal.terminal_observed_at, native_source: "zcode.retained-terminal",
+          ...(effectsBound ? { native_turn_items: proof.native_turn_items, effects_proof: proof } : {}),
+          ...(refBound ? { continuation_ref: ref } : {}),
+          ...(!effectsBound || !refBound ? { recovery_unavailable_reason: typeof (terminal.continuation_unavailable_reason ?? proof?.reason) === "string" && /^[a-z][a-z0-9_]{0,127}$/.test(terminal.continuation_unavailable_reason ?? proof?.reason) ? terminal.continuation_unavailable_reason ?? proof.reason : !effectsBound ? "native_effects_unproven" : "native_continuation_unproven" } : {}),
           ...(providerError ? { provider_error: providerError } : {}) };
-        terminalCache.set(cacheKey, item);
+        // Effects/topology proof is admission-time authority: never reuse it
+        // across a later inspection merely because the old terminal is cached.
+        if (!proof && !ref) terminalCache.set(cacheKey, item);
         items.push(item);
         clock.sample(child.childSessionId);
       }
@@ -638,10 +653,10 @@ export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000,
   }
 }
 
-async function inspect(bridge, sessionId) {
+async function inspect(bridge, sessionId, parentSessionId = sessionId) {
   const [read, subagents] = await Promise.all([
     bridge.request("zcode/session/read", { sessionId }),
-    readZcodeSubagents(bridge, sessionId),
+    readZcodeSubagents(bridge, sessionId, 30_000, false, new Map(), parentSessionId),
   ]);
   let usage = null, usage_observation_error = null;
   try { usage = await readZcodeUsage(bridge, sessionId); }
@@ -984,6 +999,8 @@ export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContrac
     ["636b14181d5c9a95476055079836fd6b58169f58", "dd-zcode-harness@2"],
     ["4621fabd3f517ecdd349dfebebae9077c01d2f2b", "dd-zcode-harness@2"],
     ["9c5ca6cc81c4eb5065e43f8b7ab6b7cc5ab7ae47", "dd-zcode-harness@2"],
+    // CP253 installed artifact: exact same-child Read continuation and retained proof.
+    ["b18dfdbedaa9330e765315bce0f1a609792d6c91", "dd-zcode-harness@2"],
   ]);
   const qualified = qualifiedBridgeCommits.get(bridgeCommit) === harnessContract;
   return { status: qualified ? "qualified" : "unqualified", mechanism: "cli-invocation@1", sha256,
@@ -1082,14 +1099,22 @@ export async function promptSessionWithBridge(bridge, options) {
   const textCursor = bridge.assistantTextCursor(identity.adapterSessionId);
   options.assertDispatch?.();
   bridge.dispatchOperationId = options.operationId;
-  const turn = await bridge.request("session/prompt", { sessionId: identity.adapterSessionId, prompt: [{ type: "text", text: prompt }] }, timeoutMs, {
+  const managed = options.operationId ? { schema_id: "dd-flow/managed-provider-recovery@1", owner: "controller", operation_id: options.operationId, root_operation_id: options.operationId.replace(/:capacity:\d+:session\.prompt$/, "") } : null;
+  const acknowledged = value => managed && value && Object.keys(managed).every(key => value[key] === managed[key]);
+  if (managed && (bridge.recoveryCapability?.schema_id !== managed.schema_id || bridge.recoveryCapability?.owner !== "controller")) fail("ZCode bridge does not acknowledge controller-owned provider recovery", "provider_recovery_unavailable");
+  const turn = await bridge.request("session/prompt", { sessionId: identity.adapterSessionId, prompt: [{ type: "text", text: prompt }], ...(managed ? { _meta: { zcode: { ddFlowRecovery: managed } } } : {}) }, timeoutMs, {
     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;
+    if (managed && !acknowledged(error.details?.native?._meta?.zcode?.ddFlowRecovery)) {
+      const unknown = new Error("ZCode provider failure omitted managed recovery acknowledgement");
+      unknown.code = "native_outcome_unknown"; unknown.details = { primary_error: errorRecord(error) }; throw unknown;
+    }
     throw error;
   });
+  if (managed && !acknowledged(turn?._meta?.zcode?.ddFlowRecovery)) fail("ZCode bridge omitted the managed recovery acknowledgement", "native_outcome_unknown");
   const stopReason = typeof turn?.stopReason === "string" ? turn.stopReason : null;
   const completionEvidence = turn?._meta?.zcodeCompletionEvidence;
   if (completionEvidence === "inferred" || completionEvidence === "failed") {
@@ -1113,7 +1138,7 @@ export async function promptSessionWithBridge(bridge, options) {
     throw error;
   }
   let evidence;
-  try { await bridge.flush(); evidence = await inspect(bridge, identity.adapterSessionId); }
+  try { await bridge.flush(); evidence = await inspect(bridge, identity.adapterSessionId, identity.providerSessionId); }
   catch (cause) {
     const error = new Error("ZCode completed the native turn, but post-turn observation failed");
     error.code = "native_outcome_observation_failed";
@@ -1141,7 +1166,7 @@ export async function inspectSession(options) {
 export async function inspectSessionWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
-  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...publicEvidence(await inspect(bridge, identity.adapterSessionId)) });
+  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...publicEvidence(await inspect(bridge, identity.adapterSessionId, identity.providerSessionId)) });
 }
 
 export async function cancelSession(options) {

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

@@ -1,7 +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 renderNativeChildFollowupInstruction(harness: string, childId: string | { session_id?: unknown; parent_session_id?: unknown; terminal_turn_id?: unknown; continuation_ref?: unknown }): string | null;
 export function delegationContract(harness: string): string;
 export const lifecycleRetryInstruction: string;
 export const lifecycleCommandCompletionInstruction: string;

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

@@ -39,12 +39,21 @@ export function delegationAdapter(harness) {
 
 /** Only documented same-child APIs may continue an existing native worker. */
 export function renderNativeChildFollowupInstruction(harness, childId) {
+  const child = childId && typeof childId === "object" ? childId : null;
+  childId = child?.session_id ?? 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.`;
+  const message = JSON.stringify("Continue the same assigned Work after the transient provider failure; do not restart it or repeat committed lifecycle commands.");
+  if (adapter === "zcode") {
+    const ref = child?.continuation_ref;
+    if (ref?.schema_id !== "zcode/child-continuation@1" || ref.capability !== "dd-flow/managed-provider-recovery@1" || ref.child_session_id !== childId
+      || ref.parent_session_id !== child.parent_session_id || ref.terminal_turn_id !== child.terminal_turn_id || !/^agent_[\w-]{1,200}$/.test(ref.agent_id ?? "")) return null;
+    return `Use the native SendMessage tool exactly once with to: ${JSON.stringify(ref.agent_id)}, summary: "Continue existing Work", and message: ${message}. Retain messageId and delivery only when the native result supplies them; never invent missing IDs. The adapter verifies typed native completion and successor evidence. Wait for this same agent with TaskOutput. If admission is uncertain, do not resend. Do not spawn a replacement or override model/reasoning.`;
+  }
+  if (adapter === "codex") return `Use collaboration.followup_task with target: ${target} and message: ${message}. Do not spawn a replacement.`;
+  if (adapter === "opencode") return `Use the native subagent tool with sessionID: ${target} and prompt: ${message}. 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: ${message}. 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: ${message}. 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;
 }