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

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.152",
+  "cli_commit": "70ed6da341845d1b7f262b74f6731ac4787aff73",
+  "built_at": "2026-10-26T03:31:35.940Z",
   "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

@@ -14,7 +14,7 @@ import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, tr
 import { waitForSettlement } from "./session-settlement.mjs";
 import { nativeExecutionReceipt } from "./native-children.mjs";
 import { errorRecord, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
-import { checkObservedProfile, observeModel } from "./model-observations.mjs";
+import { checkObservedProfile, observeModel, observedFields, readModelObservations } from "./model-observations.mjs";
 import os from "node:os";
 import path from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
@@ -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) {
@@ -199,6 +202,15 @@ export class Runtime {
     const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: root, cwd: info.directory };
     this.sessions.set(id, record); return record;
   }
+  registerObservedChild(info, root) {
+    const owner = this.sessions.get(root);
+    if (!owner || owner.parent_provider_session_id || owner.root_provider_session_id !== root
+      || info.id === root || info.parentID !== root || info.fork)
+      throw new DaemonError("session_identity_mismatch", "OpenCode child is not a direct member of the owned root");
+    if (typeof info.directory !== "string" || !path.isAbsolute(info.directory))
+      throw new OpenCodeError("opencode_unavailable", "OpenCode child directory binding is not yet observable");
+    return this.retainSession(info, root);
+  }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
   async childTree(id, seen = new Set()) {
     if (seen.has(id)) throw new DaemonError("session_identity_mismatch", "OpenCode native topology contains a cycle");
@@ -296,15 +308,52 @@ export class Runtime {
     return nativeExecutionReceipt(receipt, { daemonId: this.state.daemon_id, revision: before.get(id) ?? 0 });
   }
   async observeModels(id, messages, parent = null) {
-    this.modelMessages ??= new Set();
+    const journal = this.state.config.journal ?? this.paths.journal;
+    if (!this.modelMessages) {
+      this.modelMessages = new Map();
+      for (const event of journal ? await readModelObservations(journal) : []) {
+        if (event.harness !== 'opencode-server' || event.source?.method !== 'session/message' || !event.source.message_id) continue;
+        const key = `${event.session_id}:${event.source.message_id}`;
+        if (event.evidence_conflict) { const prior = this.modelMessages.get(key); if (prior) prior.conflicted = true; continue; }
+        if (!this.modelMessages.has(key)) this.modelMessages.set(key, { source: event.source,
+          known: { parent: event.parent_session_id, root: event.native_agent_role?.launch?.root_session_id,
+            role: event.native_agent_role ?? null, requested: observedFields(event.requested), observed: observedFields(event.observed) } });
+      }
+    }
     for (const message of messages ?? []) {
       const info = message.info;
-      if (info?.role !== "assistant" || !info.id || this.modelMessages.has(info.id)) continue;
+      if (info?.role !== "assistant" || !info.id) continue;
       if (info.sessionID && info.sessionID !== id) throw new DaemonError("session_identity_mismatch", "native message belongs to another Session");
-      await observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
-        requested: { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent },
-        observed: { provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode }, source: { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}:${info.modelID}`).digest("hex") }, evidence: "response" });
-      this.modelMessages.add(info.id);
+      const record = this.sessions.get(id);
+      if (record && (record.parent_provider_session_id ?? null) !== parent)
+        throw new DaemonError("session_identity_mismatch", "OpenCode observed message parent changed");
+      if (!record?.root_provider_session_id || !info.mode) {
+        await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
+          source: { channel: "native.message_observer", scope: "response", non_asserting: true }, evidence: "unavailable", reason: "native_role_binding_unavailable" });
+        continue;
+      }
+      const requested = { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent };
+      const nativeAgentRole = this.state.config.workerLaunchConfig ? { name: info.mode, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
+        launch: { ...this.state.config.workerLaunchConfig, root_session_id: record.root_provider_session_id } } : null;
+      const observed = observedFields({ provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode });
+      const tuple = { parent, root: record.root_provider_session_id, role: nativeAgentRole, requested: observedFields(requested), observed };
+      const key = `${id}:${info.id}`, previous = this.modelMessages.get(key);
+      if (previous?.conflicted) throw new DaemonError("model_observation_identity_conflict", "OpenCode native message has a retained identity/profile conflict", false, { session_id: id, message_id: info.id });
+      const conflicts = (before, after) => before != null && after != null && (typeof before === "object" && typeof after === "object"
+        ? [...new Set([...Object.keys(before), ...Object.keys(after)])].some(field => conflicts(before[field], after[field])) : before !== after);
+      if (previous && !conflicts(previous.known, tuple)) {
+        // Optional disclosure can arrive late. Do not rewrite the old native fact;
+        // remember known values only to detect a later positive contradiction.
+        for (const [field, value] of Object.entries(observed)) if (value != null) previous.known.observed[field] = value;
+        continue;
+      }
+      const source = previous?.source ?? { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}`).digest("hex") };
+      const published = await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent, requested, nativeAgentRole, observed, source, evidence: "response" });
+      if (previous || published?.evidence_conflict) {
+        if (previous) previous.conflicted = true;
+        throw new DaemonError("model_observation_identity_conflict", "OpenCode native message changed its published identity/profile", false, { session_id: id, message_id: info.id });
+      }
+      this.modelMessages.set(key, { known: structuredClone(tuple), source });
     }
   }
   async requireSettled(id) {
@@ -457,6 +506,9 @@ export class Runtime {
       assertDispatch, checkHookFailures, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
       onDispatched: () => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: params.sessionId }),
       onModelMessages: (id, messages, parent) => this.observeModels(id, messages, parent),
+      onNativeSession: (info, root) => this.registerObservedChild(info, root),
+      rootSessionId: this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId,
+      parentSessionId: this.sessions.get(params.sessionId)?.parent_provider_session_id ?? null,
       onObservationError: error => observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: params.sessionId, requested: this.state.config, source: "native.message_observer", evidence: "unavailable", reason: error.code ?? "observation_unavailable" })
     }); await checkHookFailures(); }
       finally { current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; }

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),
@@ -169,13 +169,32 @@ export class OpenCodeClient {
   import(data) { return this.call("session.import", data, { productive: true }); }
 
   async prompt(id, { prompt, messageId = `msg_${randomUUID().replaceAll("-", "")}`, retained,
-    save, onModelMessages, onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
+    save, onModelMessages, onNativeSession, rootSessionId = id, parentSessionId = null,
+    onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
     validateObservationDuration(livenessTimeoutMs);
     const request = { sessionID: id, id: messageId, text: prompt, delivery: "queue", resume: true }, digest = requestDigest(request);
     if (retained && (retained.request_sha256 !== digest || retained.message_id !== messageId)) throw new OpenCodeError("operation_request_mismatch", "OpenCode operation already binds another prompt", false, { effect: "no_effect" });
     let state = retained ?? { message_id: messageId, request_sha256: digest, phase: "prepared", cursor: 0 };
-    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map();
-    const capture = async session => { for (const child of await this.children(session)) { parents.set(child.id, child.parentID); baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id))); await capture(child.id); } };
+    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map([[id, parentSessionId]]);
+    // The same native lineage guard applies before dispatch and while polling.
+    // Registration precedes message publication; a list ID alone is not ownership.
+    const childrenOf = async (session, visited) => {
+      const children = await this.children(session);
+      for (const child of children) {
+        if (!child?.id || child.parentID !== session || child.fork || session !== rootSessionId || visited.has(child.id)
+          || parents.has(child.id) && parents.get(child.id) !== session || visited.size >= 1024)
+          throw new OpenCodeError("session_identity_mismatch", "OpenCode native child lineage is invalid", false, { session_id: child?.id, parent_session_id: session });
+        visited.add(child.id); parents.set(child.id, session);
+        await onNativeSession?.(child, rootSessionId);
+      }
+      return children;
+    };
+    const capture = async (session, visited = new Set([id])) => {
+      for (const child of await childrenOf(session, visited)) {
+        baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id)));
+        await capture(child.id, visited);
+      }
+    };
     await capture(id);
     if (retained) {
       const index = previous.findIndex(item => item.info.id === messageId);
@@ -258,8 +277,8 @@ export class OpenCodeClient {
           }
           if (state.cursor !== watermark) { state = { ...state, cursor: watermark }; await save?.(state); }
           let runningTools = false;
-          const observe = async (session, visited = new Set()) => {
-            if (visited.has(session)) throw lost("OpenCode topology contains a cycle"); visited.add(session); known.add(session);
+          const observe = async (session, visited = new Set([id])) => {
+            known.add(session);
             const messages = await this.messages(session);
             await onModelMessages?.(session, messages, parents.get(session) ?? null);
             const floor = baseline.get(session) ?? new Set(), current = messages.filter(item => item.info.role === "assistant" && !floor.has(item.info.id));
@@ -291,10 +310,7 @@ export class OpenCodeClient {
                 }
               }
             }
-            for (const child of await this.children(session)) {
-              if (child.parentID !== session) throw lost("OpenCode child has a foreign parent");
-              parents.set(child.id, session); await observe(child.id, visited);
-            }
+            for (const child of await childrenOf(session, visited)) await observe(child.id, visited);
             return current;
           };
           const current = await observe(id), rootMessages = await this.messages(id);
@@ -309,8 +325,9 @@ export class OpenCodeClient {
                 // Native messages and topology are separate reads: a child can
                 // finish between them. Reconcile its ancestry before rejecting
                 // the notification, never trust the notification alone.
-                const child = (await this.children(id)).find(child => child.id === item.info.metadata.childID && child.parentID === id);
-                if (child) { parents.set(child.id, id); await observe(child.id); }
+                const visited = new Set([id]);
+                const child = (await childrenOf(id, visited)).find(child => child.id === item.info.metadata.childID);
+                if (child) await observe(child.id, visited);
               }
               if (item.info.role === "user" || item.info.role === "synthetic" && !(
                 item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) === id
@@ -353,7 +370,8 @@ export class OpenCodeClient {
           }
         } catch (error) {
           await checkHookFailures?.();
-          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)) throw error;
+          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)
+            || ["session_identity_mismatch", "model_observation_identity_conflict"].includes(error.code)) throw error;
           await onObservationError?.(error);
         }
         if (clock.sample(marker)) throw lost("OpenCode native progress stopped or observation could not recover", { session_id: id, message_id: messageId, observation: clock.state(), ...(observationErrors.count ? { observation_errors: observationErrors } : {}) });

package/dist/harness-runtime/lib/dd-zcode-daemon.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);