@deksden-com/dd-flow-cli 0.9.0-beta.116 → 0.9.0-beta.118

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.118
+
+### Patch Changes
+
+- Admit the tested ZCode bridge fix for managed turns that remain active after a frozen event watermark, and allow 30 seconds for Antigravity's version check during doctor and daemon startup.
+
+## 0.9.0-beta.117
+
+### Patch Changes
+
+- Preserve Grok child model facts, replay owned Codex tool events, and let CODE collect aggregate-check evidence before semantic acceptance.
+
 ## 0.9.0-beta.116
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.116",
-  "cli_commit": "c30f54c04930f51d7982c49369a96bca51eabe65",
-  "built_at": "2026-09-27T20:17:11.827Z",
+  "cli_version": "0.9.0-beta.118",
+  "cli_commit": "19b1d443644710c4d17e02a7175a5e556e7d8f8e",
+  "built_at": "2026-09-28T12:22:30.459Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

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

@@ -11,7 +11,7 @@ import { agyWorkspaceHooks } from "./agy-hooks.mjs";
 import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
-import { AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
+import { AGY_VERSION_TIMEOUT_MS, AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
 import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
@@ -189,7 +189,7 @@ export async function startDaemon(options) {
   if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
   if (previous?.shutdown_state === "running" && previous.active_tree) throw new DaemonError("invalid_harness_crash", "previous Antigravity daemon died with an active or unproven tree");
   await removeSocket(paths); await prepare(paths, config);
-  const version = (await runAgy(config.bin, ["--version"], { cwd: config.cwd, env: sanitizedEnv(config), timeoutMs: 10_000 })).stdout.trim();
+  const version = (await runAgy(config.bin, ["--version"], { cwd: config.cwd, env: sanitizedEnv(config), timeoutMs: AGY_VERSION_TIMEOUT_MS })).stdout.trim();
   const resourceProcess = await registerDaemonProcess(config, { kind: "agy-daemon", owner: `agy:${path.basename(paths.dir)}`, operation: `agy-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
   const retained = retainedAgyState(previous, config.resumeSessionId);
   await writeJson(paths.state, { schema_id: STATE_SCHEMA, daemon_id: config.daemonId, shutdown_state: "starting", active_tree: false, unclaimed_activity: retained.unclaimed_activity ?? false, retained_tree_settlement: retained.retained_tree_settlement ?? null, versions: { agy: version }, config, sessions: [], session_observations: retained.session_observations ?? [], descendants: retained.descendants ?? [], tool_calls: retained.tool_calls ?? [], completed_tool_steps: retained.completed_tool_steps ?? [], tool_identity_complete: retained.tool_identity_complete !== false, turn_generation: retained.turn_generation ?? 0, last_result: retained.last_result ?? null, resource_process: resourceProcess });

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

@@ -6,6 +6,7 @@ import path from "node:path";
 import { checkObservedProfile } from "./model-observations.mjs";
 
 const DEFAULT_MODEL = "gemini-3.1-pro-high";
+export const AGY_VERSION_TIMEOUT_MS = 30_000;
 
 export class AgyError extends Error {
   constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
@@ -50,7 +51,7 @@ export function assertProfile(requested, observed) { return checkObservedProfile
 export async function doctor(options = {}) {
   const bin = options.bin ?? process.env.DD_AGY_BIN ?? "agy", temporary = await mkdtemp(path.join(os.tmpdir(), "dd-agy-doctor-"));
   try {
-    const version = (await runAgy(bin, ["--version"], { timeoutMs: 10_000 })).stdout.trim();
+    const version = (await runAgy(bin, ["--version"], { timeoutMs: AGY_VERSION_TIMEOUT_MS })).stdout.trim();
     const models = await runAgy(bin, [`--gemini_dir=${temporary}`, "--app_data_dir=runtime", "models"], { timeoutMs: options.timeoutMs ?? 30_000 });
     const modelIds = models.stdout.split(/\r?\n/).map(line => line.split(/\s+/)[0]).filter(Boolean);
     if (!modelIds.includes(options.model ?? DEFAULT_MODEL)) throw new AgyError("agy_model_unavailable", `required Antigravity model is unavailable: ${options.model ?? DEFAULT_MODEL}`);

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

@@ -11,6 +11,7 @@ import os from "node:os";
 import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
+import { observeModel, readModelObservations } from "./model-observations.mjs";
 import { cancelSessionWithBridge, createSessionWithBridge, doctor, forkSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge } from "./dd-grok.mjs";
 import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
@@ -201,16 +202,6 @@ export class Runtime {
     // A descendant is a managed native Session, not merely a liveness item.
     // Register it in the same registry used by inspect/hook.resolve so a
     // parentless inspection cannot downgrade it into a second root.
-    this.sessions.set(id, {
-      ...prior,
-      provider_session_id: id,
-      adapter_session_id: prior?.adapter_session_id ?? id,
-      parent_provider_session_id: parent,
-      root_provider_session_id: rootProviderSessionId,
-      cwd,
-      native_root_receipt: prior?.native_root_receipt ?? null
-    });
-    this.bridge.registerModelSession?.(id, id, this.state.config, parent);
     const descendant = this.descendants.get(id);
     const attempt = value.attempt_id;
     const retired = descendant?.retired_attempt_ids ?? [];
@@ -229,6 +220,16 @@ export class Runtime {
       return;
     }
     if (!newAttempt && terminal(descendant?.status) && terminal(status) && descendant.status !== status) throw new DaemonError("native_child_outcome_conflict", "Grok child has contradictory terminal outcomes", false, { session_id: id, previous: descendant.status, observed: status });
+    this.sessions.set(id, {
+      ...prior,
+      provider_session_id: id,
+      adapter_session_id: prior?.adapter_session_id ?? id,
+      parent_provider_session_id: parent,
+      root_provider_session_id: rootProviderSessionId,
+      cwd,
+      native_root_receipt: prior?.native_root_receipt ?? null
+    });
+    this.bridge.registerModelSession?.(id, id, this.state.config, parent);
     this.descendants.set(id, {
       provider_session_id: id,
       parent_provider_session_id: parent,
@@ -238,13 +239,20 @@ export class Runtime {
       ...(newAttempt && descendant?.attempt_id ? { retired_attempt_ids: [...retired, descendant.attempt_id] } : retired.length ? { retired_attempt_ids: retired } : {}),
       ...(!newAttempt && !terminal(status) && descendant?.outcome_error ? { outcome_error: descendant.outcome_error } : {})
     });
+    if (spawned && typeof value.model === "string" && value.model.trim()) {
+      return { sessionId: id, parentSessionId: parent, attemptId: attempt ?? null, parentPromptId: value.parent_prompt_id ?? null, model: value.model.trim() };
+    }
   }
   observeSubagentEvent(message) {
     const root = message?.params?.sessionId, update = message?.params?.update;
     const kind = String(update?.sessionUpdate ?? update?.type ?? message?.method ?? "");
-    if (!root) return;
+    if (!root) return [];
+    const modelFacts = [];
     if (/subagent/i.test(kind)) {
-      for (const value of [update?.subagent, update?.subagentInfo, update?.child, update?.result, update]) this.recordDescendant(value, root, "x.ai/subagent/event", /fail|error/i.test(kind) ? "failed" : /cancel/i.test(kind) ? "cancelled" : /complete|finish|done/i.test(kind) ? "completed" : "running");
+      for (const value of [update?.subagent, update?.subagentInfo, update?.child, update?.result, update]) {
+        const fact = this.recordDescendant(value, root, "x.ai/subagent/event", /fail|error/i.test(kind) ? "failed" : /cancel/i.test(kind) ? "cancelled" : /complete|finish|done/i.test(kind) ? "completed" : "running");
+        if (fact) modelFacts.push(fact);
+      }
     }
     // list_running omits completed children. Retain native tool receipts, never
     // extract identities from the model's prose or from arbitrary shell output.
@@ -254,7 +262,7 @@ export class Runtime {
     if (["spawn_subagent", "get_command_or_subagent_output"].includes(tool) && !this.subagentCalls.has(key)) this.subagentCalls.set(key, { name: tool, input: update.rawInput, attempts: new Map([...this.descendants].map(([id, child]) => [id, child.attempt_id])) });
     const call = this.subagentCalls.get(key), name = call?.name, output = update?.rawOutput;
     if (call && update.rawInput) call.input = update.rawInput;
-    if (kind !== "tool_call_update" || update.status !== "completed") return;
+    if (kind !== "tool_call_update" || update.status !== "completed") return modelFacts;
     if (name === "spawn_subagent" && output?.type === "Text") {
       const id = /^subagent_id:\s*(\S+)\s*$/m.exec(output.text ?? "")?.[1];
       if (id) this.recordDescendant({ session_id: id, stale_activity: !call.attempts.has(id) || call.attempts.get(id) !== this.descendants.get(id)?.attempt_id }, root, "x.ai/tool/spawn_subagent", "running");
@@ -280,6 +288,7 @@ export class Runtime {
       }
       if (firstError) throw firstError;
     }
+    return modelFacts;
   }
   topology(root) { if (this.state.observation_error) { const error = this.state.observation_error; throw new DaemonError(error.code, error.message, false, error.details); } return [...this.descendants.values()].filter((child) => child.parent_provider_session_id === root); }
   observeToolCall(message) { this.toolObservations ??= new ToolObservations(); this.toolObservations.add(acpToolObservation(message, { harness: "grok-acp" })); const sessionId = message?.params?.sessionId; if (sessionId) this.toolUsage.set(sessionId, this.toolObservations.summary(sessionId)); }
@@ -377,7 +386,14 @@ export async function serveDaemon(stateDir) {
     const sessionId = message?.params?.sessionId;
     if (!runtime || !sessionId) return;
     try {
-      runtime.observeToolCall(message); runtime.observeSubagentEvent(message);
+      runtime.observeToolCall(message);
+      for (const fact of runtime.observeSubagentEvent(message)) {
+        const source = { channel: "x.ai/subagent_spawned", scope: "configured", attempt_id: fact.attemptId, parent_prompt_id: fact.parentPromptId,
+          event_sha256: createHash("sha256").update(JSON.stringify(fact)).digest("hex") };
+        await observeModel({ journal: state.config.journal, harness: "grok-acp", sessionId: fact.sessionId, parentSessionId: fact.parentSessionId,
+          requested: state.config, observed: { model: fact.model }, source, evidence: "configured" });
+        bridge.modelProfiles?.set(fact.sessionId, { model: fact.model });
+      }
     } catch (error) {
       // Native notifications are fire-and-forget. Persist topology conflicts
       // for the next inspect/status call instead of creating an unhandled
@@ -388,6 +404,12 @@ export async function serveDaemon(stateDir) {
     const rootProviderSessionId = session?.root_provider_session_id ?? sessionId;
     await observeAcpToolCall(state.config, { daemonId: state.daemon_id, rootProviderSessionId, parentProviderSessionId: session?.parent_provider_session_id ?? null, observedProfile: bridge.modelProfiles?.get(sessionId) ?? {} }, message);
   } }); const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "grok-provider", publish: snapshot => writeState(paths.state, snapshot) }); runtime = new Runtime(paths, state, bridge, initialized);
+  for (const fact of await readModelObservations(state.config.journal)) {
+    if (fact.harness === "grok-acp" && fact.source?.channel === "x.ai/subagent_spawned" && runtime.sessions.has(fact.session_id)
+      && (runtime.descendants.get(fact.session_id)?.attempt_id ?? null) === (fact.source.attempt_id ?? null) && fact.observed?.model) {
+      bridge.modelProfiles?.set(fact.session_id, { model: fact.observed.model });
+    }
+  }
   scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
   await removeSocket(paths.socket, paths.dir); const server = net.createServer((connection) => { connection.setEncoding("utf8"); let buffer = ""; connection.on("data", (chunk) => { buffer += chunk; const newline = buffer.indexOf("\n"); if (newline < 0) return; const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); void (async () => { let request; try { request = JSON.parse(line); if (request.schema_id !== REQUEST_SCHEMA || !request.id || !request.operation) throw new DaemonError("daemon_protocol_mismatch", "invalid daemon request"); const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}), () => runtime.dispatch("session.inspect", request.params ?? {})); connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`); if (result?._shutdown) setImmediate(() => void runtime.shutdown().then(() => process.exit(0)).catch(error => runtime.persist({ shutdown_state: "cleanup_failed", cleanup_error: errorPayload(error) }))); } catch (error) { connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`); } })(); }); }); runtime.server = server; await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false }); runtime.ready = true; return await new Promise(() => {});
 }

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

@@ -77,7 +77,9 @@ async function inspect(bridge, sessionId, options) {
   const [info, topology, usage] = await Promise.all([sessionInfo(bridge, sessionId), subagents(bridge, sessionId), sessionUsage(bridge, sessionId)]);
   const native = info?.data ?? info ?? {}, model = typeof native.model === "string" ? native.model : native.model?.modelId ?? null;
   const current = model ? { model, provider: native.provider ?? null, reasoning: native.reasoningEffort ?? null, mode: native.mode ?? null } : bridge.modelProfiles?.get(sessionId) ?? { model: null, provider: null, reasoning: null, mode: null };
-  await observeModel({ journal: options.journal, harness: "grok-acp", sessionId, requested: profile(options), observed: current, source: model ? "x.ai/session/info" : "native.model_source_incomplete", evidence: model ? "configured" : "unavailable", reason: model ? null : "session_info_omits_model" });
+  await observeModel({ journal: options.journal, harness: "grok-acp", sessionId, requested: profile(options), observed: model ? current : {},
+    source: { channel: "x.ai/session/info", scope: "configured", ...(!model ? { non_asserting: true } : {}) },
+    evidence: model ? "configured" : "unavailable", reason: model ? null : "session_info_omits_model" });
   return { info, subagents: topology, usage, observed_profile: model ? current : { model: null, provider: null, reasoning: null, mode: null } };
 }
 
@@ -139,7 +141,6 @@ export async function createSessionWithBridge(bridge, options, initialized) {
   const created = await bridge.request("session/new", { cwd, mcpServers: [], ...(options.authMethodId ? { authMethodId: options.authMethodId } : {}) });
   const providerSessionId = text(created.sessionId, "Grok Build sessionId");
   bridge.registerModelSession?.(providerSessionId, providerSessionId, requested);
-  await observeModel({ journal: options.journal, harness: "grok-acp", sessionId: providerSessionId, requested, observed: observedProfile(initialized, requested), source: "acp.initialize.modelState" });
   const profileReceipt = assertProfile(requested, observedProfile(initialized, requested));
   await options.onSessionCreated?.({ provider_session_id: providerSessionId, adapter_session_id: providerSessionId, cwd });
   const local = { ...options, initialized, rootProviderSessionId: providerSessionId }; const initial_usage_error = await forwardUsageBestEffort(local, providerSessionId, await sessionUsage(bridge, providerSessionId), sessionToolCalls(local, bridge, providerSessionId));

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

@@ -805,6 +805,7 @@ export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContrac
     ["5a8c89ab716a4b2ccc50df81cb4d204ff5c06368", "dd-zcode-harness@2"],
     ["91a1470650f5fd6105f9863fd31d1cad7b90a109", "dd-zcode-harness@2"],
     ["b9e0f5106dddb439b76186278bd9be5f45dbf3ef", "dd-zcode-harness@2"],
+    ["636b14181d5c9a95476055079836fd6b58169f58", "dd-zcode-harness@2"],
   ]);
   const qualified = qualifiedBridgeCommits.get(bridgeCommit) === harnessContract;
   return { status: qualified ? "qualified" : "unqualified", mechanism: "cli-invocation@1", sha256,

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

@@ -51,7 +51,7 @@ export function delegationContract(harness) {
 
 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 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 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.`;
+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.`;
 
 export const stageLifecycleInstruction = [
   "The project root identifies this RUN; use the Stage packet's declared execution workspace and absolute artifact paths. Do not change a native Session's working directory to a workspace provisioned for a later Stage.",

package/dist/harness-runtime/lib/model-observations.mjs

@@ -35,10 +35,11 @@ export async function observeModel({ journal, harness, sessionId, parentSessionI
   await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
   return withRunnerLock(file, async () => {
     const events = await readModelObservations(journal);
-    const replay = source?.event_sha256 ? events.find(item => item.session_id === sessionId && item.source?.event_sha256 === source.event_sha256) : null;
+    const replay = source?.event_sha256 ? events.find(item => item.harness === harness && item.session_id === sessionId && item.source?.event_sha256 === source.event_sha256) : null;
     if (replay) return replay;
     const channel = source?.channel ?? evidence;
-    const previous = events.findLast(item => item.harness === harness && item.session_id === sessionId && (item.source?.channel ?? item.evidence) === channel);
+    const previous = events.findLast(item => item.harness === harness && item.session_id === sessionId && (item.source?.channel ?? item.evidence) === channel
+      && (item.source?.attempt_id ?? null) === (source?.attempt_id ?? null));
     const normalizedReason = text(reason)?.slice(0, 200) ?? null;
     if (previous && JSON.stringify(previous.observed) === JSON.stringify(profile) && previous.reason === normalizedReason && previous.evidence === evidence) return previous;
     const previousKnown = events.findLast(item => item.harness === harness && item.session_id === sessionId && item.evidence === evidence && item.observed?.model);
@@ -62,16 +63,32 @@ export async function observeModel({ journal, harness, sessionId, parentSessionI
   });
 }
 
-export function modelAttribution(events) {
+export function modelAttribution(events, expectedSessions = []) {
   const sessions = new Map();
   for (const event of events) {
     const key = `${event.harness}:${event.session_id}`;
     const session = sessions.get(key) ?? { harness: event.harness, session_id: event.session_id, parent_session_id: event.parent_session_id, requested: event.requested, observations: [] };
+    session.parent_session_id ??= event.parent_session_id;
+    if (!session.requested || !Object.values(session.requested).some(Boolean)) session.requested = event.requested;
     session.observations.push(event); sessions.set(key, session);
   }
+  const observedIds = new Set([...sessions.values()].map(session => session.session_id));
+  const missingSessions = expectedSessions.filter(session => typeof session === "string" ? !observedIds.has(session)
+    : !sessions.has(`${session.harness}:${session.session_id}`));
   const models = [...new Set(events.map(event => event.observed?.model).filter(Boolean))];
-  const incomplete = !events.length || [...sessions.values()].some(session => session.observations.some(event => event.evidence === "unavailable" || !event.observed?.model));
+  const incomplete = !events.length || missingSessions.length > 0 || [...sessions.values()].some(session => {
+    const known = session.observations.filter(event => event.observed?.model);
+    if (!known.length) return true;
+    const knownScopes = new Set(known.map(event => `${event.evidence}:${event.source?.scope ?? "session"}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`));
+    return session.observations.some(event => {
+      if (event.evidence !== "unavailable") return false;
+      if (event.source?.non_asserting) return false;
+      const scope = event.source?.scope;
+      return !scope || !knownScopes.has(`configured:${scope}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`)
+        && !knownScopes.has(`response:${scope}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`);
+    });
+  });
   return { models, mixed: models.length > 1 || events.some(event => event.observed?.model && event.requested?.model && event.observed.model !== event.requested.model),
     observation_completeness: incomplete ? "incomplete" : "available_native_sources", transitions: events.filter(event => event.kind === "model_changed"),
-    sessions: [...sessions.values()], usage_attribution: "session_totals_unattributed_to_model", note: "Native settings/events do not prove undisclosed server routing or per-model token costs." };
+    sessions: [...sessions.values()], missing_sessions: missingSessions, usage_attribution: "session_totals_unattributed_to_model", note: "Native settings/events do not prove undisclosed server routing or per-model token costs." };
 }

package/dist/harness-runtime/lib/tool-observations.d.mts

@@ -8,10 +8,12 @@ export interface ToolEvent {
 }
 export class ToolObservations {
   calls: Map<string, ToolEvent>;
+  turns: Map<string, { session: { harness_id: string; session_id: string }; turn_id: string; started: boolean; completed: boolean }>;
   gaps: Set<string>;
   add(event: ToolEvent | null): void;
-  summary(sessionId?: string, cursor?: Set<string>): { total: number; failures: number; pending: number; by_tool: Record<string, number>; completeness: string; sessions: Array<{ session: { harness_id: string; session_id: string }; total: number; failures: number; pending: number; by_tool: Record<string, number> }>; reasons: string[] };
+  observeTurn(event: { session: { harness_id: string; session_id: string }; turn_id: string; started?: boolean; completed?: boolean }): void;
+  summary(sessionId?: string, cursor?: Set<string>): { total: number; failures: number; pending: number; by_tool: Record<string, number>; completeness: string; outcome_completeness: string; sessions: Array<{ session: { harness_id: string; session_id: string }; total: number; failures: number; pending: number; by_tool: Record<string, number> }>; reasons: string[] };
   cursor(): Set<string>;
 }
 export function codexToolObservation(record: Record<string, unknown>, sessionId: string): ToolEvent | null;
-export function replayToolJournal(file: string, options: { harness: string; rootSessionId: string; adapterSessionId?: string }, reducer?: ToolObservations): ToolObservations;
+export function replayToolJournal(file: string, options: { harness: string; rootSessionId: string; adapterSessionId?: string; text?: string; expectedSessionIds?: string[] }, reducer?: ToolObservations): ToolObservations;

package/dist/harness-runtime/lib/tool-observations.mjs

@@ -3,7 +3,14 @@ import fs from "node:fs";
 /** Canonical physical-session tool accounting. Native decoding lives below;
  * consumers never have to inspect provider envelopes or aggregate tokens. */
 export class ToolObservations {
-  constructor() { this.calls = new Map(); this.gaps = new Set(); }
+  constructor() { this.calls = new Map(); this.turns = new Map(); this.gaps = new Set(); }
+  observeTurn(event) {
+    if (!event?.session?.harness_id || !event.session.session_id || !event.turn_id) { this.gaps.add("turn_identity_missing"); return; }
+    const key = JSON.stringify([event.session, event.turn_id]);
+    const old = this.turns.get(key);
+    this.turns.set(key, { ...old, ...event, started: old?.started || event.started || false,
+      completed: old?.completed || event.completed || false });
+  }
   add(event) {
     if (!event) return;
     if (event.reason) { this.gaps.add(event.reason); return; }
@@ -13,10 +20,12 @@ export class ToolObservations {
     const old = this.calls.get(key);
     // Replay and late starts cannot undo a terminal outcome. Conflicting
     // terminal facts remain visible rather than silently choosing success.
-    const terminal = value => ["completed", "failed"].includes(value);
-    if (old && terminal(old.status) && terminal(event.status) && old.status !== event.status) this.gaps.add("conflicting_tool_outcomes");
+    const proven = value => ["completed", "failed"].includes(value);
+    if (old && proven(old.status) && proven(event.status) && old.status !== event.status) this.gaps.add("conflicting_tool_outcomes");
     this.calls.set(key, { ...old, ...event, name: event.name ?? old?.name ?? "unknown",
-      status: old?.status === "failed" || event.status === "failed" ? "failed" : terminal(old?.status) ? old.status : event.status ?? old?.status ?? "unknown" });
+      status: old?.status === "failed" || event.status === "failed" ? "failed"
+        : old?.status === "completed" || event.status === "completed" ? "completed"
+        : old?.status === "unknown" || event.status === "unknown" ? "unknown" : "running" });
   }
   summary(sessionId, cursor) {
     const by_tool = {}, sessions = new Map(), reasons = new Set(this.gaps); let total = 0, failures = 0, pending = 0;
@@ -30,6 +39,12 @@ export class ToolObservations {
       if (!["completed", "failed"].includes(value.status)) { pending++; session.pending++; }
       sessions.set(id, session);
     }
+    if (!cursor) for (const turn of this.turns.values()) {
+      if (sessionId !== undefined && turn.session.session_id !== sessionId) continue;
+      const id = JSON.stringify(turn.session);
+      sessions.set(id, sessions.get(id) ?? { session: turn.session, parent_session: null, total: 0, failures: 0, pending: 0, by_tool: {} });
+      if (!turn.started || !turn.completed) reasons.add("turn_lifecycle_incomplete");
+    }
     return { schema_id: "dd-flow/tool-summary@1", scope: "physical_sessions", measurement: "observed_invocations", origin: "native_tool_events", aggregation: cursor ? "delta" : "cumulative", total, failures, pending, by_tool,
       sessions: [...sessions.values()], completeness: reasons.size ? "partial" : "complete", outcome_completeness: pending ? "partial" : "complete", reasons: [...reasons] };
   }
@@ -66,7 +81,7 @@ export function acpToolObservation(message, { harness = "zcode-acp", rootSession
   const transport = message.params?.sessionId;
   if (adapterSessionId && transport !== adapterSessionId) return null;
   const root = rootSessionId ?? transport;
-  const session = harness === "zcode-acp" ? zcodePhysicalSession(update, root) : root;
+  const session = harness === "zcode-acp" ? zcodePhysicalSession(update, root) : harness === "grok-acp" ? transport : root;
   if (!session || !update.toolCallId) return { reason: "tool_identity_missing" };
   return { session: identity(harness, session), parent_session: session !== root ? identity(harness, root) : null,
     transport_session_id: transport, call_id: update.toolCallId, name: update._meta?.["x.ai/tool"]?.name ?? update._meta?.claudeCode?.toolName ?? update.title?.split(":", 1)[0], status: status(update.status) };
@@ -85,22 +100,31 @@ export function codexToolObservation(record, sessionId) {
   const p = record.payload ?? {};
   if (["function_call", "custom_tool_call"].includes(p.type)) return { session: identity("codex-desktop", sessionId), call_id: p.call_id, name: p.name, status: "running" };
   if (["function_call_output", "custom_tool_call_output"].includes(p.type)) {
-    return { session: identity("codex-desktop", sessionId), call_id: p.call_id, status: containsFailure(p) ? "failed" : "completed" };
+    return { session: identity("codex-desktop", sessionId), call_id: p.call_id, status: structuredFailure(p.output) ? "failed" : "unknown" };
   }
   return null;
 }
 
-function containsFailure(value) {
-  if (Array.isArray(value)) return value.some(containsFailure);
-  if (typeof value === "string") {
-    if (/(?:^|\n)exit=(?:[1-9]\d*)\b|Process exited with code [1-9]\d*/.test(value)) return true;
-    if (/^[{[]/.test(value.trim())) { try { return containsFailure(JSON.parse(value)); } catch {} }
-    return false;
-  }
+function structuredFailure(value) {
   if (!value || typeof value !== "object") return false;
-  if (value.ok === false || value.is_error === true || value.isError === true || value.error === true || typeof value.error === "string") return true;
-  if (typeof value.exit_code === "number" && value.exit_code !== 0) return true;
-  return Object.values(value).some(containsFailure);
+  return value.ok === false || value.is_error === true || value.isError === true || value.error === true
+    || typeof value.exit_code === "number" && value.exit_code !== 0;
+}
+
+const codexTools = new Set(["commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall", "collabAgentToolCall", "webSearch", "imageView", "imageGeneration", "sleep"]);
+const codexNonTools = new Set(["userMessage", "hookPrompt", "agentMessage", "functionCallOutput", "plan", "reasoning", "subAgentActivity", "enteredReviewMode", "exitedReviewMode", "contextCompaction"]);
+export function codexAppServerObservation(message) {
+  if (!["item/started", "item/completed"].includes(message?.method)) return null;
+  const { threadId, turnId, item } = message.params ?? {};
+  if (!item || codexNonTools.has(item.type)) return null;
+  if (!codexTools.has(item.type)) return { reason: "codex_item_type_unsupported" };
+  if (!threadId || !item.id) return { reason: "tool_identity_missing" };
+  const native = item.status;
+  const failed = ["failed", "declined", "interrupted"].includes(native) || item.type === "commandExecution" && typeof item.exitCode === "number" && item.exitCode !== 0;
+  const completed = message.method === "item/completed" && (native === undefined || native === "completed");
+  const known = native === undefined || ["inProgress", "completed", "failed", "declined", "interrupted"].includes(native);
+  return { session: identity("codex-desktop", threadId), epoch: turnId ?? "", call_id: item.id, name: item.type,
+    status: !known ? "unknown" : failed ? "failed" : completed ? "completed" : "running", ...(!known ? { reason: "codex_item_status_unsupported" } : {}) };
 }
 
 export function openCodeToolObservation(part, sessionId, messageId) {
@@ -121,7 +145,7 @@ export function agyToolObservation(step, rootSessionId) {
  * carries physical identities; an ACP connection identity never crosses out. */
 export function replayToolJournal(file, options, reducer = new ToolObservations()) {
   let bytes;
-  try { bytes = fs.readFileSync(file, "utf8"); } catch (error) { reducer.gaps.add(error.code === "ENOENT" ? "journal_missing" : "journal_unreadable"); return reducer; }
+  try { bytes = options.text ?? fs.readFileSync(file, "utf8"); } catch (error) { reducer.gaps.add(error.code === "ENOENT" ? "journal_missing" : "journal_unreadable"); return reducer; }
   const lines = bytes.split("\n"); let session = options.rootSessionId, transport = options.adapterSessionId;
   for (const [index, line] of lines.entries()) {
     if (!line.trim()) continue;
@@ -135,7 +159,14 @@ export function replayToolJournal(file, options, reducer = new ToolObservations(
       if (e.kind === "inbound" || m.method) add(acpToolObservation(m, { ...options, rootSessionId: session, adapterSessionId: transport }));
     } else if (options.harness === "codex-desktop") {
       if (e.type === "session_meta" && e.payload?.id !== session) { reducer.gaps.add("session_identity_mismatch"); break; }
-      add(codexToolObservation(e, session));
+      if (m.params?.threadId && options.expectedSessionIds && !options.expectedSessionIds.includes(m.params.threadId)) continue;
+      if (["turn/started", "turn/completed"].includes(m.method)) {
+        const params = m.params ?? {};
+        if (params.threadId && params.turn?.id) reducer.observeTurn({ session: identity("codex-desktop", params.threadId), turn_id: params.turn.id,
+          started: m.method === "turn/started", completed: m.method === "turn/completed" && params.turn.status === "completed" });
+        else reducer.gaps.add("turn_identity_missing");
+      }
+      add(codexAppServerObservation(m) ?? codexToolObservation(e, session));
     } else if (options.harness === "droid-cli") {
       if (e.type === "session_start" && e.id !== session) { reducer.gaps.add("session_identity_mismatch"); break; }
       for (const event of droidToolObservations(e, session)) add(event);

package/dist/schemas/code-verification.schema.json

@@ -1,14 +1,16 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "dd-flow/code-verification@2",
+  "$id": "dd-flow/code-verification@3",
   "type": "object",
   "additionalProperties": false,
   "required": ["schema_id", "verdict", "summary", "unresolved", "deviations"],
   "properties": {
-    "schema_id": {"const": "dd-flow/code-verification@2"},
-    "verdict": {"enum": ["passed", "needs_repair", "blocked"]},
+    "schema_id": {"enum": ["dd-flow/code-verification@2", "dd-flow/code-verification@3"]},
+    "verdict": {"enum": ["passed", "needs_repair", "needs_checks", "blocked"]},
     "summary": {"type": "string", "minLength": 1},
     "unresolved": {"type": "array", "items": {"type": "string", "minLength": 1}},
-    "deviations": {"type": "array", "items": {"type": "string", "minLength": 1}}
-  }
+    "deviations": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "document_updates": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}
+  },
+  "allOf": [{"if": {"properties": {"schema_id": {"const": "dd-flow/code-verification@2"}}}, "then": {"properties": {"verdict": {"enum": ["passed", "needs_repair", "blocked"]}}, "not": {"required": ["document_updates"]}}}]
 }

package/dist/services/run-observations.js

@@ -79,32 +79,67 @@ export function runObservations(context, projectId, runId) {
                 reasons.push("lineage_evidence_invalid");
             }
         }
-    // Native transcript adapters need no managed controller journal.
-    for (const session of sessions)
-        if (session.transcript_path && ![...sources.values()].some(s => s.session.harness_id === session.harness && s.session.session_id === (session.provider_session_id ?? session.session_id))) {
-            add(`transcript:${session.harness}:${session.provider_session_id ?? session.session_id}`, session.provider_session_id ?? session.session_id, session.transcript_path, home, "current", session.harness);
-        }
     const reducer = new ToolObservations();
     for (const reason of reasons)
         reducer.gaps.add(reason);
+    const expectedCodexIds = sessions.filter(session => session.harness === "codex-desktop").map(session => session.provider_session_id ?? session.session_id);
+    const replay = (source, sessionId) => {
+        const file = path.join(home, source.path);
+        let fd = null;
+        try {
+            const actual = fs.realpathSync(file);
+            if (!inside(home, actual))
+                throw new Error("journal escaped owned home");
+            fd = fs.openSync(actual, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            if (!fs.fstatSync(fd).isFile())
+                throw new Error("journal is not a regular file");
+            replayToolJournal(file, { harness: source.session.harness_id, rootSessionId: sessionId, text: fs.readFileSync(fd, "utf8"), ...(source.session.harness_id === "codex-desktop" ? { expectedSessionIds: expectedCodexIds } : {}) }, reducer);
+        }
+        catch {
+            source.status = "unavailable";
+            source.reason = "journal_unavailable_during_read";
+        }
+        finally {
+            if (fd !== null)
+                fs.closeSync(fd);
+        }
+    };
     for (const source of sources.values()) {
-        if (source.status !== "available") {
-            reducer.gaps.add(source.reason ?? "journal_unavailable");
+        if (source.status !== "available")
             continue;
-        }
-        replayToolJournal(path.join(home, source.path), { harness: source.session.harness_id, rootSessionId: source.session.session_id }, reducer);
+        replay(source, source.session.session_id);
+    }
+    const covered = () => new Set(reducer.summary().sessions.map(item => JSON.stringify(item.session)));
+    // A managed root journal can contain all of its children's native events.
+    // Select transcript fallback only after replay reveals an actual gap.
+    for (const session of sessions) {
+        const nativeId = session.provider_session_id ?? session.session_id;
+        if (!session.transcript_path || covered().has(JSON.stringify({ harness_id: session.harness, session_id: nativeId })))
+            continue;
+        const id = `transcript:${session.harness}:${nativeId}`;
+        add(id, nativeId, session.transcript_path, home, "current", session.harness);
+        const source = sources.get(id);
+        if (source?.status === "available")
+            replay(source, nativeId);
     }
+    for (const source of sources.values())
+        if (source.status !== "available"
+            && !covered().has(JSON.stringify(source.session)))
+            reducer.gaps.add(source.reason ?? "journal_unavailable");
     const expected = [...new Map(sessions.map(s => { const session = { harness_id: s.harness, session_id: s.provider_session_id ?? s.session_id }; return [JSON.stringify(session), session]; })).values()];
     const expectedIds = new Set(expected.map(s => JSON.stringify(s)));
     for (const [key, event] of reducer.calls)
         if (!expectedIds.has(JSON.stringify(event.session))) {
             reducer.calls.delete(key);
-            reducer.gaps.add("tool_session_not_bound_to_run");
+        }
+    for (const [key, event] of reducer.turns)
+        if (!expectedIds.has(JSON.stringify(event.session))) {
+            reducer.turns.delete(key);
         }
     const summary = reducer.summary();
     const observed = new Set(summary.sessions.map(s => JSON.stringify(s.session)));
     const missing = expected.filter(s => !observed.has(JSON.stringify(s)));
-    const completeness = missing.length || summary.completeness !== "complete" ? "partial" : "complete";
+    const completeness = missing.length || summary.completeness !== "complete" || summary.outcome_completeness !== "complete" ? "partial" : "complete";
     return { schema_id: "dd-flow/run-observations@1", home, sources: [...sources.values()], tools: { ...summary,
             completeness, status: observed.size === 0 ? "unavailable" : completeness === "complete" ? "measured" : "partial",
             observed_sessions: expected.length - missing.length, expected_sessions: expected.length, unavailable_sessions: missing.map(s => s.session_id), missing_sessions: missing,

package/dist/services/vnext-code.js

@@ -2,6 +2,7 @@ import { managedLifecycleCommand } from "./lifecycle-invocations.js";
 import { stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 import { ensureAggregateRepair, ensureRepairIntent } from "./repair-intents.js";
 import { runWorkspaceBootstrap } from "./workspace-bootstrap.js";
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
@@ -220,6 +221,12 @@ export async function finishVnextCode(context, input) {
         });
     }
     const finalReceipts = receipts;
+    if (verification.verdict === "needs_checks") {
+        return { ok: true, run_id: run.id, stage, outcome: "verification_required", verification,
+            receipts: finalReceipts.map(receipt => ({ id: receipt.id, receipt_path: receipt.receipt_path, input_hash: receipt.input_hash, status: receipt.status })),
+            next: { kind: "verification_required", finish_command: finishCommand(context, run.id, projectRoot, input.verificationFile) },
+            instruction: "Aggregate receipts are available. Keep CODE running. Inspect them, update code-verification.json to passed or needs_repair, then invoke only the issued successor finish_command. A material document change belongs to the registered fresh repair Work, not this coordinator Session." };
+    }
     const projectedVerification = verificationProjection(works, finalReceipts, { historicalReceipts: finalReceipts, runId: run.id, runHome: home });
     const unresolvedAcceptance = (projectedVerification.acceptance ?? []).filter((item) => item.status === "unresolved");
     if (unresolvedAcceptance.length)
@@ -331,6 +338,15 @@ export function prepareVnextCodeRepair(context, input) {
         if (previous)
             return { kind: "replay", project, run, previous };
     }
+    if (input.semanticUnresolved?.length && input.verificationPath) {
+        const previous = codeWorks(context, project.id, run.id).find(work => {
+            const repair = packet(work)?.repair;
+            return Boolean(repair && repair.verification_path === input.verificationPath
+                && JSON.stringify(repair.semantic_unresolved) === JSON.stringify(unique(input.semanticUnresolved ?? [])));
+        });
+        if (previous)
+            return { kind: "replay", project, run, previous };
+    }
     if (typeof input.objective !== "string" || !input.objective.trim())
         throw new AppError("validation", "Repair objective must not be empty", 2);
     if (input.semanticUnresolved !== undefined && (!Array.isArray(input.semanticUnresolved) || input.semanticUnresolved.some(value => typeof value !== "string" || !value.trim())))
@@ -346,10 +362,12 @@ export function prepareVnextCodeRepair(context, input) {
     }
     if ([Boolean(input.checkReceiptId), Boolean(input.reviewFindings?.length), Boolean(input.semanticUnresolved?.length)].filter(Boolean).length !== 1)
         throw new AppError("validation", "Repair requires exactly one evidence source", 2);
+    let semanticVerification = input.verification;
     if (input.semanticUnresolved?.length) {
         if (!input.verificationPath)
             throw new AppError("usage", "Semantic repair requires a verification file", 2);
         const verification = input.verification ?? readVerification(context, { file: input.verificationPath, projectRoot: run.workspace_root, runId: run.id, runRoot: home });
+        semanticVerification = verification;
         if (input.verification !== undefined)
             validateSchema({ schemaName: "code-verification", file: input.verificationPath, data: verification, projectRoot: run.workspace_root, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: home });
         const unresolved = verification.unresolved.length ? verification.unresolved : [verification.summary];
@@ -417,7 +435,17 @@ export function prepareVnextCodeRepair(context, input) {
         acceptance: uniqueBy(invariantPackets.flatMap((value) => value.acceptance), (value) => JSON.stringify(value)),
         // A CODE-REVIEW repair changes delivered code/evidence, never the
         // already accepted PLAN or its ownership declaration.
-        document_updates: [],
+        document_updates: semanticRepair ? uniqueBy((semanticVerification?.document_updates ?? []).map(relative => {
+            const declared = invariantPackets.flatMap(value => value.document_updates).find(value => value.path === relative);
+            if (!declared)
+                throw new AppError("document_update_unknown", "CODE verification selected a document absent from accepted Work ownership", 2, { path: relative });
+            const file = path.resolve(run.workspace_root, relative);
+            if (!file.startsWith(`${path.resolve(run.workspace_root)}${path.sep}`))
+                throw new AppError("document_update_invalid", "CODE verification document path escapes the workspace", 2, { path: relative });
+            const exists = fs.existsSync(file);
+            return { ...declared, action: exists ? "update" : "create",
+                baseline_sha256: exists ? crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") : null };
+        }), value => value.path) : [],
         required_read: unique([...(receipt ? [receipt.receipt_path] : input.reviewFindings?.flatMap((finding) => finding.evidence_refs) ?? []), ...(semanticRepair && input.verificationPath ? [input.verificationPath] : []), ...packets.flatMap((value) => value.required_read)]),
         discovery_boundary: unique(packets.flatMap((value) => value.discovery_boundary)),
         // These are collision-avoidance hints. Receipt paths enrich the coordinator
@@ -517,15 +545,15 @@ function coordinatorPrompt(context, input) {
         "Do not choose a provider delegation tool from this stage prompt. At each work_fanout boundary, stop at the Work-graph boundary; the shared controller supplies the selected adapter's native tool, exact parameters, child task, and wait contract. It launches only entries listed in graph.ready and uses at most the qualified capacity. Every registered CODE Work runs in a fresh child Session, including a serial dependency chain. The coordinator launches those children only through the controller-supplied native delegation instruction; it must never invoke a Work start_command itself. Each child receives its complete packet from dd-flow and runs its own exact start_command. After a Work finishes, the controller uses the graph returned by work finish to launch newly ready Work. To refresh the parent graph yourself use the exact command: " + runtimeCommand(context, ["work", "ls", "--run", input.run.id, "--ready", "--project-root", input.projectRoot, "--json"]),
         "A quiet child is still running until the harness reports its turn completed, failed, cancelled or explicitly needs attention. An elapsed nominal wait, silence, or no new artifact is not an unresponsive-worker failure. Never interrupt, replace, relaunch, or stage-block a still-running child for that reason, even if an external controller asks. Long work finish and stage finish commands emit check progress on stderr. After you issue the exact CODE stage finish command, wait for that same command to return once: a completed command with a non-zero exit and structured `code_gate_failed` output is its terminal result, not a reason to keep waiting. A repair_required continuation already registered the repair: end this Turn. Do not invoke that Work's start_command from the coordinator Session, inspect its PID, start a second finish command, or infer failure from quiet output. Close a disposable child only after its Work is accepted or explicitly failed/cancelled and the harness reports the turn settled.",
         `A repairable engine, harness, or environment failure is not a user question. Write the evidence summary to ${path.join(requireHome(input.run), "works", input.rootWork.work_id, "block-summary.md")}, then record it with a separate command: ${runtimeCommand(context, ["stage", "block", input.run.id, "--stage", "code", "--work", input.rootWork.work_id, "--kind", "<engine|harness|environment>", "--code", "<stable-code>", "--summary-file", `@run/works/${input.rootWork.work_id}/block-summary.md`, "--retryable", "--project-root", input.projectRoot, "--json"])}. Choose kind and stable-code from evidence; this example is not an executable continuation. Repair it externally, then run the exact unblock_command returned by dd-flow and continue this same stage.`,
-        `When every CODE and repair Work is completed, write ${path.join(input.root, "code-verification.json")} using the exact contract below. Mark passed only when all accepted requirements and current-gate acceptance criteria are implemented or explicitly evidenced; list every remaining issue in unresolved. Every evidence_refs item must already exist as a relative workspace path or run://${input.run.id}/ path. Do not claim a browser or other check receipt that was not retained. Then finish: ${finishCommand(context, input.run.id, input.projectRoot, path.join(input.root, "code-verification.json"))}`,
+        `When every CODE and repair Work is completed, write ${path.join(input.root, "code-verification.json")} using the exact contract below. If closing an accepted document depends on aggregate checks that have not run yet, use verdict needs_checks; the first finish returns receipts and a successor finish_command while CODE remains open. After checking those receipts, use needs_repair with document_updates naming only assigned documents that must change, or passed if the current documents already prove acceptance. Mark passed only when all accepted requirements and current-gate acceptance criteria are implemented or explicitly evidenced; list every remaining issue in unresolved. Every evidence_refs item must already exist as a relative workspace path or run://${input.run.id}/ path. Do not claim a browser or other check receipt that was not retained. Then finish: ${finishCommand(context, input.run.id, input.projectRoot, path.join(input.root, "code-verification.json"))}`,
         "A code_gate_failed response with continuation.kind=repair_required has already registered one repair Work with all failed receipts. End this Turn so the controller can dispatch it in a fresh child. Do not recreate the repair, copy origin IDs, write a repair task file or execute the child start command yourself. After repair, update semantic verification and finish again.",
         "</execution_commands>",
         "",
         "<verification_contract>",
         "```json",
-        JSON.stringify({ schema_id: "dd-flow/code-verification@2", verdict: "passed", summary: "Evidence-backed conclusion.", unresolved: [], deviations: [] }, null, 2),
+        JSON.stringify({ schema_id: "dd-flow/code-verification@3", verdict: "passed", summary: "Evidence-backed conclusion.", unresolved: [], deviations: [], document_updates: [] }, null, 2),
         "```",
-        "Allowed verdict values are passed, needs_repair, and blocked. The example is valid JSON using passed; choose exactly one value.",
+        "Allowed verdict values are passed, needs_checks, needs_repair, and blocked. The example is valid JSON using passed; choose exactly one value. A verification_required result is successful receipt gathering, not Stage completion; use its issued successor command after updating this file.",
         "The CLI verifies graph coverage and executes all deterministic checks. Do not duplicate its report; record only your semantic conclusion and evidence.",
         "</verification_contract>",
         "",

package/dist/services/vnext-plan-review.js

@@ -331,9 +331,11 @@ function preparedExisting(context, input) {
     return { ok: true, resumed: true, run_id: input.run.id, stage, outcome: "review_required", work_id: input.workId, id: binding.work_session_id, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), orchestration, plan_review: { requested_mode: input.requested, effective_mode: input.effective, policy_source: policySource(input.run), groups: input.groups }, next: { dispatch_command: dispatchCommand(context, input.run.id, input.projectRoot), finish_command: finishCommand(context, input.run.id, input.projectRoot, path.join(input.root, "decision.json")) } };
 }
 function orchestratorPrompt(context, input) {
-    const { template, revision, capacity } = input;
+    const { revision, capacity } = input;
     const decision = path.join(input.root, "decision.json");
     const workspaceContract = ["<workspace_contract>", `- route: ${input.workspaceRoute.route}`, `- feature branch: ${input.workspaceRoute.feature_branch ?? "not applicable"}`, `- base commit: ${input.workspaceRoute.base_ref ?? "not applicable"}`, `- read/write workspace: ${input.run.workspace_root}`, "The CLI verified this frozen route. All plan and correction writes belong in the named workspace; project root remains only the stable lifecycle identity. Do not create, switch, merge or delete branches/worktrees.", "</workspace_contract>"].join("\n");
+    const acceptanceOwnership = "For every deferred acceptance or document update, identify the named CODE Work owner, its causal checks, and when it can truthfully close the obligation. Aggregate checks run only after implementation Work completes: assign a CODE owner to pending documents and use CODE needs_checks → verification_required → repair after those receipts. A promise that MERGE or an unnamed readiness owner will finish acceptance is a material PLAN finding; bootstrap workspace readiness is not proof of the new feature.";
+    const template = [acceptanceOwnership, input.template].join("\n\n");
     const reviewerLaunch = capacity.source === "external_policy"
         ? `After dispatch, return at the Work-graph boundary. The shared runtime launches the queued reviewer Works as separate external Sessions, at most ${capacity.available_slots} in parallel under the RUN's frozen profiles. Do not launch native children, create provider roots, run a capacity probe, or record this external limit as native capacity. Reviewers are read-only leaf workers. Continue the semantic decision only after their Work receipts settle; do not substitute a missing result or relaunch a settled reviewer.`
         : "After dispatch, stop at the Work-graph boundary. The shared controller supplies the selected adapter's native tool, exact parameters, child task, and wait contract; do not choose a provider tool from this stage prompt or substitute a shell command. It launches at most the qualified capacity at once and starts unchanged queued Works only after the current wave settles. A launch rejected before it starts is not review evidence: do not create a replacement. Each reviewer must be a genuinely fresh harness child Session; the lifecycle adapter binds that observed Session, so do not bind or supply a Session ID manually. Reviewers are read-only and must not create children. As soon as a reviewer result is accepted, release that reviewer Session when the harness permits.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.116",
+  "version": "0.9.0-beta.118",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {