@deksden-com/dd-flow-cli 0.9.0-beta.95 → 0.9.0-beta.96

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.96
+
+### Patch Changes
+
+- 4769ad6: Settle early lifecycle rejections against their native calls, reconcile retained provider capacity before continuing, and preserve causal outcomes across AGY, Grok, Droid, OpenCode, Codex, and ZCode adapters.
+
 ## 0.9.0-beta.95
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,11 +1,11 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.95",
-  "cli_commit": "4c8c5e8456d684a7887c8bfdd1afc24ae874ff6c",
-  "built_at": "2026-09-22T06:50:54.211Z",
+  "cli_version": "0.9.0-beta.96",
+  "cli_commit": "cb6c669ff3f24115ac0a4d2c04c8877eb8683bc6",
+  "built_at": "2026-09-22T12:33:21.451Z",
   "built_with_canon": {
     "version": "4.1.1",
-    "commit": "d1a6081ab15ab92ac917ff5d037121a40c709db1",
+    "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",
     "flow_contract": "dd-flow-canonical-2026-08",
     "repo_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank",
     "memorybank_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank/.memory-bank",

package/dist/cli/run-cli.js

@@ -89,9 +89,25 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         output = parseOutputOptions(args);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        writeJson(io.stderr, { ok: false, error: { code: "usage", message } });
-        return 2;
+        const rejection = isAppError(error) ? error : new AppError("usage", error instanceof Error ? error.message : String(error), 2);
+        Object.assign(rejection.details, { phase: "prepare", effect: "no_effect", recoverable: true, ...rejection.details });
+        try {
+            const command = quote(["dd-flow", ...args]), event = observedLifecycleNativeEvent(createRouterContext(env), command, env.DD_FLOW_DAEMON_ID);
+            if (event) {
+                const context = createContext({ ...env }, "hook");
+                try {
+                    observeLifecycleCommand(context, command, event)({ error: rejection });
+                }
+                finally {
+                    context.db.close?.();
+                }
+            }
+        }
+        catch (persistence) {
+            rejection.details.lifecycle_diagnostic_error = String(persistence);
+        }
+        writeJson(io.stderr, { ok: false, error: { code: rejection.code, message: rejection.message, details: rejection.details } });
+        return rejection.exitCode;
     }
     const progress = progressForCommand(output.args);
     let heartbeat;
@@ -284,7 +300,7 @@ export async function runCli(args, io = defaultIo, env = process.env) {
     }
     catch (caught) {
         const error = isAppError(caught) ? caught : new AppError("unexpected", caught instanceof Error ? caught.message : String(caught), 1, { effect: "unknown", cause: { code: caught?.code ?? null, sqlite_extended_code: caught?.errcode ?? null } });
-        if (!settleHook && !invocationSettlement && env.DD_FLOW_DAEMON_ID) {
+        if (!settleHook && !invocationSettlement) {
             let earlyContext;
             try {
                 const command = quote(["dd-flow", ...output.args]);

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
 import { readFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
+import { invokeNativeHook } from "../lib/native-hook-command.mjs";
 import { doctor } from "../lib/dd-agy.mjs";
 import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-agy-daemon.mjs";
 
@@ -10,12 +10,14 @@ const prompt = async options => options["prompt-file"] ? await readFile(options[
 async function stdin() { let value = ""; process.stdin.setEncoding("utf8"); for await (const chunk of process.stdin) value += chunk; return value; }
 async function hook(options) {
   const payload = JSON.parse(await stdin() || "{}"), event = options.event;
-  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload });
+  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload }, 10_000);
+  if (identity.stale) return event === "PreToolUse" ? { decision: "deny", reason: "agy_stale_hook" } : {};
   if (event === "PreToolUse" || event === "PostToolUse") {
     const phase = event === "PreToolUse" ? "before" : "after", args = payload.toolCall?.args ?? {};
-    const normalized = { schema_id: "dd-flow/agy-tool-event@1", event_id: identity.event_id, phase, daemon_id: identity.daemon_id, conversation_id: payload.conversationId, parent_conversation_id: identity.parent_conversation_id, step_index: payload.stepIdx, tool: payload.toolCall?.name, input: args, workspace_paths: payload.workspacePaths, transcript_path: payload.transcriptPath, model: payload.modelName, profile: identity.profile, ...(phase === "after" ? { error: payload.error ?? "" } : {}) };
-    const command = options["dd-flow-bin"] ?? identity.dd_flow_bin, target = /\.[cm]?js$/.test(command) ? { command: process.execPath, args: [command] } : { command, args: [] };
-    await new Promise((resolve, reject) => { const child = spawn(target.command, [...target.args, "agy", "event", "handle", "--project-root", options["project-root"] ?? identity.project_root, "--json"], { env: { ...process.env, DD_FLOW_HOME: options["dd-flow-home"] ?? identity.dd_flow_home }, stdio: ["pipe", "ignore", "pipe"] }); let error = ""; child.stderr.setEncoding("utf8").on("data", chunk => error += chunk); child.on("error", reject); child.on("close", code => code === 0 ? resolve() : reject(new Error(error || "dd-flow rejected Antigravity hook"))); child.stdin.end(`${JSON.stringify(normalized)}\n`); });
+    const normalized = { schema_id: "dd-flow/agy-tool-event@1", event_id: identity.event_id, phase, daemon_id: identity.daemon_id, conversation_id: payload.conversationId, parent_conversation_id: identity.parent_conversation_id, execution_num: payload.executionNum, step_index: payload.stepIdx, tool: payload.toolCall?.name, input: args, workspace_paths: payload.workspacePaths, transcript_path: payload.transcriptPath, model: payload.modelName, profile: identity.profile, ...(phase === "after" ? { error: payload.error ?? "" } : {}) };
+    await invokeNativeHook({ bin: options["dd-flow-bin"] ?? identity.dd_flow_bin,
+      args: ["agy", "event", "handle", "--project-root", options["project-root"] ?? identity.project_root, "--json"],
+      payload: normalized, home: options["dd-flow-home"] ?? identity.dd_flow_home });
   }
   return event === "PreToolUse" ? { decision: "allow" } : {};
 }

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

@@ -284,7 +284,10 @@ export class Runtime {
     if (result.conversation_id && result.conversation_id !== this.init?.conversation_id) {
       await this.journal("foreign_terminal_observed", { conversation_id: result.conversation_id, result });
       const child = this.descendants.get(result.conversation_id);
-      if (child) this.descendants.set(result.conversation_id, { ...child, status: result.status === "SUCCESS" ? "completed" : result.status === "ERROR" ? "failed" : "cancelled" });
+      if (child) {
+        this.descendants.set(result.conversation_id, { ...child, status: result.status === "SUCCESS" ? "completed" : result.status === "ERROR" ? "failed" : "cancelled" });
+        await this.completePendingTurn();
+      }
       return;
     }
     const current = this.active;
@@ -312,7 +315,19 @@ export class Runtime {
             : "agy_provider_failed";
       return current.reject(new DaemonError(code, message, ["agy_provider_quota_exhausted", "agy_provider_rate_limited"].includes(code), { provider_result: result, provider_error_scope: current.previousError && current.previousError === result.error ? "repeated_conversation_error" : "terminal_result", usage_ingest: this.usageIngest }));
     }
-    if (terminalReceipt.settled) { this.active = null; current.resolve(terminalReceipt); }
+    await this.completePendingTurn();
+  }
+  async completePendingTurn() {
+    const current = this.active;
+    if (!current?.terminalResult || current.terminalResult !== this.lastResult) return;
+    await this.persist({ active_tree: !this.receipt().settled });
+    // Hooks can invalidate the tree while persistence is pending. Never
+    // publish a proof captured before that asynchronous boundary.
+    if (this.active !== current) return;
+    const receipt = this.receipt();
+    if (!receipt.settled) { await this.persist({ active_tree: true }); return; }
+    this.active = null;
+    current.resolve(receipt);
   }
   receipt(result = this.lastResult) {
     const assistantText = typeof result?.response === "string" ? result.response : typeof result?.text === "string" ? result.text : null;
@@ -365,10 +380,10 @@ export class Runtime {
     if (!child) throw new DaemonError("agy_child_identity_unconfirmed", "Antigravity hook has no confirmed native parent", true, { conversation_id: conversationId });
     return child;
   }
-  async observeHook(event, payload) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const settled = terminalPending ? this.receipt(this.lastResult) : null; const completed = settled?.settled ? this.active : null; if (completed) this.active = null; const parent = child?.parent_provider_session_id ?? null;
+  async observeHook(event, payload) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const parent = child?.parent_provider_session_id ?? null;
     const observed = payload.model ? observedProfile(payload) : {};
     await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: conversationId, parentSessionId: parent, requested: this.config, observed, source: "native.hook", evidence: payload.model ? "configured" : "unavailable", reason: payload.model ? null : "hook_omits_current_model" });
-    const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, turn_generation: this.turnGeneration, fully_idle: payload.fullyIdle ?? null, termination_reason: payload.terminationReason ?? null, execution: payload.executionNum ?? null, step: payload.stepIdx ?? null, tool: payload.toolCall?.name ?? null, args: payload.toolCall?.args ?? null })).digest("hex"); await this.persist(completed ? { active_tree: false } : {}); await this.journal("hook", { stale, hook_event: event, event_id: eventId, conversation_id: conversationId, turn_generation: this.turnGeneration, execution_num: execution, step_index: step, termination_reason: payload.terminationReason ?? null, fully_idle: payload.fullyIdle ?? null }); completed?.resolve(settled); return { event_id: eventId, daemon_id: this.config.daemonId, parent_conversation_id: parent, profile: observed, requested_profile: { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode }, project_root: this.config.projectRoot, dd_flow_bin: this.config.ddFlowBin, dd_flow_home: this.config.ddFlowHome };
+    const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, fully_idle: payload.fullyIdle ?? null, termination_reason: payload.terminationReason ?? null, execution: payload.executionNum ?? null, step: payload.stepIdx ?? null, tool: payload.toolCall?.name ?? null, args: payload.toolCall?.args ?? null })).digest("hex"); await this.persist(); await this.journal("hook", { stale, hook_event: event, event_id: eventId, conversation_id: conversationId, turn_generation: this.turnGeneration, execution_num: execution, step_index: step, termination_reason: payload.terminationReason ?? null, fully_idle: payload.fullyIdle ?? null }); await this.completePendingTurn(); return { event_id: eventId, daemon_id: this.config.daemonId, parent_conversation_id: parent, profile: observed, requested_profile: { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode }, project_root: this.config.projectRoot, dd_flow_bin: this.config.ddFlowBin, dd_flow_home: this.config.ddFlowHome };
   }
   async finalizeProviderForControl() {
     const pending = this.providerFinalization;

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

@@ -324,11 +324,8 @@ export class DroidRuntime {
     catch (error) {
       receipt = { provider_session_id: binding.provider_session_id, adapter_session_id: binding.provider_session_id, settled: false, settlement_observation_error: errorRecord(error) };
     }
-    // A terminal root turn is not enough to recover the operation while a
-    // child Task or owned provider process is still active.  Leave the
-    // durable binding for the normal settlement observer instead of exposing
-    // a misleading successful receipt.
-    if (receipt.settled !== true) return null;
+    // Native outcome and tree settlement are independent. Retain the former
+    // even while children are running; settled:false keeps capacity reserved.
     const current = this.active;
     if (current?.operationId === operationId && current.turnId === binding.turn_id) {
       current.outcome = outcome; this.lastResult = outcome;

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

@@ -5,7 +5,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import net from "node:net";
-import { durableDaemonDispatch } from "./daemon-operations.mjs";
+import { durableDaemonDispatch as dispatchOperation } from "./daemon-operations.mjs";
 import { waitForSettlement } from "./session-settlement.mjs";
 import os from "node:os";
 import path from "node:path";
@@ -17,6 +17,10 @@ import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmD
 const REQUEST_SCHEMA = "dd-grok/daemon-request@1";
 const RESPONSE_SCHEMA = "dd-grok/daemon-response@1";
 const STATE_SCHEMA = "dd-grok/daemon-state@1";
+// Normalize raw socket callers too, before the shared layer reserves capacity.
+export function durableDaemonDispatch(root, request, action, observe) {
+  return dispatchOperation(root, request.operation === "session.resume" ? { ...request, operation: "session.inspect" } : request, action, observe);
+}
 class DaemonError extends Error { constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; } }
 function absolute(value, label) { if (!value || !path.isAbsolute(value)) throw new DaemonError("invalid_path", `${label} must be an absolute path`); return path.resolve(value); }
 function locations(stateDir) { const dir = absolute(stateDir, "--state-dir"); const localSocket = path.join(dir, "daemon.sock"); return { dir, socket: Buffer.byteLength(localSocket) < 100 ? localSocket : `/tmp/dd-grok-${createHash("sha256").update(dir).digest("hex").slice(0, 24)}.sock`, state: path.join(dir, "daemon.json"), log: path.join(dir, "daemon.log"), home: path.join(dir, "grok-home") }; }
@@ -142,6 +146,8 @@ async function materializeSessionArchive(paths, archiveDir) {
 }
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
+  // Grok resume observes an already-owned Session; it never starts a turn.
+  if (operation === "session.resume") operation = "session.inspect";
   const { socket } = locations(stateDir); const request = { schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
   return await new Promise((resolve, reject) => {
     const client = net.createConnection(socket); let buffer = ""; let settled = false;
@@ -233,13 +239,32 @@ export class Runtime {
     return running;
   }
   async requireSettled() { const running = await this.refreshTree(); if (running.length) throw new DaemonError("tree_not_settled", "daemon still owns a running Session tree", false, { sessions: running }); }
-  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; for (const session of this.sessions.values()) session.native_root_receipt = null; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); this.track(result); const running = this.treeRunning(result); const session = this.sessions.get(result.provider_session_id); if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id }; await this.persist({ active_tree: running, active_operation: null }); return { ...result, descendants: this.topology(result.provider_session_id), settled: !running }; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; } finally { this.active = null; } }
+  async productive(name, task, sessionId) {
+    if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true);
+    this.active = name;
+    // Only a new native turn invalidates its own root proof. Creation, fork
+    // and local archive export must not erase an unrelated Session's receipt.
+    if (name === "session.prompt" && this.sessions.has(sessionId)) this.sessions.get(sessionId).native_root_receipt = null;
+    try {
+      await this.persist({ active_tree: true, active_operation: name });
+      const result = await task();
+      this.track(result);
+      const session = this.sessions.get(result.provider_session_id);
+      if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id };
+      // Archive requires an idle tree before entering this exclusive section
+      // and performs no native work. Its file receipt is not tree evidence.
+      const running = name === "session.archive" ? false : this.treeRunning(result);
+      await this.persist({ active_tree: running, active_operation: null });
+      return { ...result, descendants: this.topology(result.provider_session_id), settled: !running };
+    } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; }
+    finally { this.active = null; }
+  }
   async dispatch(operation, params) {
     const assertDispatch = captureDispatchGuard(this);
     if (operation === "daemon.status") { let observationError; if (!this.active) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { observation_error: observationError ?? null, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config }; }
-    if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); session = { provider_session_id: sessionId, adapter_session_id: sessionId, parent_provider_session_id: roots[0].provider_session_id, root_provider_session_id: roots[0].provider_session_id }; this.sessions.set(sessionId, session); await this.persist(); await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); } return { daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }; }
+    if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); const observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); this.track(observed); session = this.sessions.get(sessionId); if (!session || session.root_provider_session_id !== roots[0].provider_session_id) throw new DaemonError("hook_identity_unknown", "hook Session is not a member of the retained native tree"); await this.persist(); } return { daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }; }
     if (operation === "session.create") return await this.productive(operation, async () => { const result = await createSessionWithBridge(this.bridge, { ...this.options(params), onSessionCreated: async (session) => { this.track(session); this.loadedSessionId = session.provider_session_id; await this.persist(); } }, this.initialized); this.loadedSessionId = result.provider_session_id; return result; });
-    if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch }); this.loadedSessionId = params.sessionId; return result; }); }
+    if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch }); this.loadedSessionId = params.sessionId; return result; }, params.sessionId); }
     if (operation === "session.fork") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await forkSessionWithBridge(this.bridge, this.options(params)); this.loadedSessionId = params.sessionId; return result; }); }
     if (operation === "session.inspect" || operation === "session.resume") { const result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result); await this.persist(); return { ...result, settled: !this.active && !this.treeRunning(result), descendants: this.topology(result.provider_session_id) }; }
     if (operation === "session.cancel") { if (!this.sessions.has(params.sessionId)) throw new DaemonError("session_identity_mismatch", "cancellation Session is not owned by this daemon"); cancelPendingDispatch(this); const result = await cancelSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); await this.persist({ active_tree: Boolean(this.active) || !result.settled }); return result; }

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

@@ -34,7 +34,8 @@ function errorPayload(error) { return { code: error.code ?? "operation_failed",
 
 async function writePlugin(paths, config) {
   const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
-  const source = `import { spawn } from "node:child_process";\nconst candidate = command => typeof command === "string" && command.includes("dd-flow");\nconst participating = new Set();\nconst invoke = async (payload) => await new Promise((resolve,reject)=>{ const bin=process.env.DD_OPENCODE_DD_FLOW_BIN; const js=/\\.[cm]?js$/.test(bin); const child=spawn(js?process.env.DD_OPENCODE_NODE_BIN:bin,[...(js?[bin]:[]),"opencode","event","handle","--project-root",process.env.DD_OPENCODE_PROJECT_ROOT,"--json"],{env:process.env,stdio:["pipe","pipe","pipe"]}); let out="",err=""; child.stdout.on("data",x=>out+=x); child.stderr.on("data",x=>err+=x); child.on("error",reject); child.on("close",code=>code===0?resolve(JSON.parse(out||"{}")):reject(new Error(err||"dd-flow hook failed"))); child.stdin.end(JSON.stringify(payload)+"\\n"); });\nexport const DdFlowPlugin=async({client,project,directory})=>{ const envelope=async(phase,input,extra={})=>{ const session=(await client.session.get({path:{id:input.sessionID}})).data; return {schema_id:"dd-flow/opencode-tool-event@1",event_id:[input.sessionID,input.callID,phase].join(":"),phase,daemon_id:process.env.DD_OPENCODE_DAEMON_ID,server_version:process.env.DD_OPENCODE_SERVER_VERSION,plugin_sha256:process.env.DD_OPENCODE_PLUGIN_SHA256,session:{provider_session_id:input.sessionID,parent_provider_session_id:session?.parentID??null,agent_id:process.env.DD_OPENCODE_AGENT,directory:session?.directory??directory,project_id:session?.projectID??project?.id},message_id:input.messageID??null,tool_call_id:input.callID,tool:input.tool,profile:{provider:process.env.DD_OPENCODE_PROVIDER,model:process.env.DD_OPENCODE_MODEL,variant:process.env.DD_OPENCODE_VARIANT,agent:process.env.DD_OPENCODE_AGENT},...extra}; }; return {"tool.execute.before":async(input,output)=>{ const command=output.args?.command; if(!candidate(command)) return; const result=await invoke(await envelope("before",input,{input:output.args})); if(result?.observed) participating.add(input.callID); const updated=result?.hookSpecificOutput?.updatedInput; if(updated) Object.assign(output.args,updated); },"tool.execute.after":async(input,output)=>{ if(!participating.delete(input.callID)) return; await invoke(await envelope("after",input,{input:input.args,outcome:{status:"completed",title:output.title}})); }}; };\n`;
+  const helper = new URL("./native-hook-command.mjs", import.meta.url).href;
+  const source = `import { invokeNativeHook } from ${JSON.stringify(helper)};\nconst candidate = command => typeof command === "string" && command.length > 0;\nconst participating = new Set();\nconst invoke = async payload => await invokeNativeHook({bin:process.env.DD_OPENCODE_DD_FLOW_BIN,args:["opencode","event","handle","--project-root",process.env.DD_OPENCODE_PROJECT_ROOT,"--json"],payload,home:process.env.DD_FLOW_HOME,timeoutMs:15000});\nexport const DdFlowPlugin=async({client,project,directory})=>{ const envelope=async(phase,input,extra={})=>{ const response=await client.session.get({path:{id:input.sessionID}}); if(response?.error||!response?.data) throw Object.assign(new Error("OpenCode Session identity is unavailable"),{code:"opencode_session_identity_unavailable"}); const session=response.data; return {schema_id:"dd-flow/opencode-tool-event@1",event_id:[input.sessionID,input.callID,phase].join(":"),phase,daemon_id:process.env.DD_OPENCODE_DAEMON_ID,server_version:process.env.DD_OPENCODE_SERVER_VERSION,plugin_sha256:process.env.DD_OPENCODE_PLUGIN_SHA256,session:{provider_session_id:input.sessionID,parent_provider_session_id:session.parentID??null,agent_id:process.env.DD_OPENCODE_AGENT,directory:session.directory??directory,project_id:session.projectID??project?.id},message_id:input.messageID??null,tool_call_id:input.callID,tool:input.tool,profile:{provider:process.env.DD_OPENCODE_PROVIDER,model:process.env.DD_OPENCODE_MODEL,variant:process.env.DD_OPENCODE_VARIANT,agent:process.env.DD_OPENCODE_AGENT},...extra}; }; return {"tool.execute.before":async(input,output)=>{ const command=output.args?.command; if(!candidate(command)) return; const result=await invoke(await envelope("before",input,{input:output.args})); if(result?.observed) participating.add(input.callID); const updated=result?.hookSpecificOutput?.updatedInput; if(updated) Object.assign(output.args,updated); },"tool.execute.after":async(input,output)=>{ if(!participating.delete(input.callID)) return; await invoke(await envelope("after",input,{input:input.args,outcome:{status:"completed",title:output.title}})); }}; };\n`;
   const checksum = createHash("sha256").update(source).digest("hex"); await writeFile(path.join(directory, "dd-flow.js"), source, { mode: 0o600 }); return checksum;
 }
 async function prepare(paths, config, authSource) {
@@ -84,7 +85,23 @@ export class Runtime {
   }
   async requireSettled(id) { const value = await this.describe(id); if (!value.settled) throw new DaemonError("tree_not_settled", "OpenCode Session is not idle", false, { session_id: id, status: value.status }); return value; }
   async reconcileUsage(observed) { const errors = []; try { await forwardUsage(this.state.config, observed.provider_session_id, observed.usage); } catch (error) { errors.push({ session_id: observed.provider_session_id, phase: "usage", ...errorPayload(error) }); } for (const child of observed.children.filter(item => (item.parentID ?? observed.provider_session_id) === observed.provider_session_id)) { try { errors.push(...await this.reconcileUsage(await this.describe(child.id))); } catch (error) { errors.push({ session_id: child.id, phase: "usage_child", ...errorPayload(error) }); } } return errors; }
-  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); await this.persist({ active_tree: !result?.settled, active_operation: null }); await this.journal(name, result); return result; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); await this.journal(`${name}.failed`, null); throw error; } finally { this.active = null; } }
+  async productive(name, task) {
+    if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true);
+    this.active = name; let result, completed = false;
+    try {
+      await this.persist({ active_tree: true, active_operation: name });
+      result = await task(); completed = true;
+      await this.persist({ active_tree: !result?.settled, active_operation: null });
+      await this.journal(name, result); return result;
+    } catch (cause) {
+      const error = completed ? new DaemonError("operation_observation_lost", "OpenCode returned but its durable observation could not be saved; do not resend", false, { result, cause: errorPayload(cause) }) : cause;
+      const failures = [];
+      try { await this.persist({ active_tree: true, active_operation: null }); } catch (secondary) { failures.push(errorPayload(secondary)); }
+      try { await this.journal(`${name}.failed`, null); } catch (secondary) { failures.push(errorPayload(secondary)); }
+      if (failures.length) error.details = { ...error.details, observation_errors: failures };
+      throw error;
+    } finally { this.active = null; }
+  }
   async cancelTree(id, seen = new Set()) {
     if (seen.has(id)) return [];
     seen.add(id);
@@ -170,6 +187,8 @@ export class Runtime {
         },
         ...(params.cancelTree ? { cancel: id => this.cancelTree(id) } : {})
       });
+      // The durable clean receipt must follow the owned physical stop barrier.
+      await stopProcessGroup(this.child);
       await this.persist({ active_tree: false, shutdown_state: "stopping" });
       return { stopped: true, clean: true, _shutdown: true };
     }

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

@@ -21,7 +21,7 @@ export class OpenCodeClient {
     } catch (error) {
       if (error instanceof OpenCodeError) throw error;
       // Aborting HTTP only loses the observer; it does not cancel the provider.
-      throw new OpenCodeError(error.name === "AbortError" ? "operation_observation_lost" : "opencode_unavailable", error.message, true, { method, pathname });
+      throw new OpenCodeError(error.name === "AbortError" || method === "POST" ? "operation_observation_lost" : "opencode_unavailable", error.message, true, { method, pathname });
     } finally { clearTimeout(timer); }
   }
   health() { return this.request("GET", "/global/health", undefined, { directory: null, timeoutMs: 5_000 }); }

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

@@ -857,25 +857,34 @@ export async function promptSessionWithBridge(bridge, options) {
   const stopReason = typeof turn?.stopReason === "string" ? turn.stopReason : null;
   const completionEvidence = turn?._meta?.zcodeCompletionEvidence;
   if (completionEvidence === "inferred" || completionEvidence === "failed") {
-    await bridge.flush();
+    let observationError = null;
+    try { await bridge.flush(); } catch (error) { observationError = { code: error.code ?? "zcode_post_turn_observation_failed", message: error.message ?? String(error) }; }
     const error = new Error(`ZCode completion is ${completionEvidence}, not a confirmed successful native turn`);
     error.code = completionEvidence === "inferred" ? "native_outcome_unknown" : "zcode_turn_not_completed";
     error.retryable = false;
-    error.details = { completion_evidence: completionEvidence, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId };
+    error.details = { completion_evidence: completionEvidence, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...(observationError ? { observation_error: observationError } : {}) };
     throw error;
   }
   if (stopReason && stopReason !== "end_turn") {
     // A close can settle the pending prompt before its terminal event. Do not
     // collect live evidence first: ordinary inspection is allowed to recover
     // an evicted Session, which would undo the just-confirmed close.
-    await bridge.flush();
+    let observationError = null;
+    try { await bridge.flush(); } catch (error) { observationError = { code: error.code ?? "zcode_post_turn_observation_failed", message: error.message ?? String(error) }; }
     const error = new Error(`ZCode ended the provider request with ${stopReason}, not end_turn`);
     error.code = stopReason === "cancelled" ? "zcode_turn_cancelled" : "zcode_turn_not_completed";
-    error.details = { stop_reason: stopReason, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId };
+    error.details = { stop_reason: stopReason, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...(observationError ? { observation_error: observationError } : {}) };
+    throw error;
+  }
+  let evidence;
+  try { await bridge.flush(); evidence = await inspect(bridge, identity.adapterSessionId); }
+  catch (cause) {
+    const error = new Error("ZCode completed the native turn, but post-turn observation failed");
+    error.code = "native_outcome_observation_failed";
+    error.retryable = false;
+    error.details = { native_outcome: { stop_reason: stopReason ?? "end_turn", completion_evidence: completionEvidence ?? "native" }, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, observation_error: { code: cause.code ?? "zcode_post_turn_observation_failed", message: cause.message ?? String(cause) } };
     throw error;
   }
-  await bridge.flush();
-  const evidence = await inspect(bridge, identity.adapterSessionId);
   evidence.tool_calls = bridge.toolSummary(identity.adapterSessionId);
   const usage_ingest_error = await forwardUsageBestEffort(options, identity.providerSessionId, evidence.usage, evidence.tool_calls);
   if (initial_usage_error) evidence.initial_usage_error = initial_usage_error;

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

@@ -64,6 +64,13 @@ export async function assertDaemonOwnership(stateDir, dispatch = {}, assertCurre
     assertCurrent();
     if (result?.ok === true && result.admitted === true && result.process_id === record.id) return;
     if (result?.ok !== true || result.reason !== "provider_capacity" || result.process_id !== record.id) throw Object.assign(new Error("productive runtime admission was not confirmed"), { code: "process_ownership_unknown" });
+    const predecessor = result.blocking_turns?.find(turn => turn?.process_id === record.id
+      && turn?.session_id === dispatch["native-session-id"]
+      && turn?.operation_id !== dispatch["operation-id"]);
+    if (predecessor) throw Object.assign(new Error("the same managed Session has an unsettled productive predecessor; reconcile it before dispatching another Turn"), {
+      code: "settlement_reconciliation_required",
+      details: { session_id: dispatch["native-session-id"], predecessor_operation_id: predecessor.operation_id, predecessor_operation: predecessor.operation }
+    });
     // The daemon, not its disposable socket client, owns this queue. Recheck
     // the RUN fence and process lease on every admission attempt.
     await new Promise(resolve => setTimeout(resolve, 250));

package/dist/services/continuation-outcome.js

@@ -12,7 +12,7 @@ export function assertNoCorrelatedRejection(context, scope) {
     const latest = new Map();
     for (const row of rows) {
         const value = JSON.parse(row.outcome_json);
-        latest.set(value.operation, value);
+        latest.set(JSON.stringify([value.operation, value.session_id ?? null, value.work_id ?? null, value.attempt ?? null]), value);
     }
     for (const value of latest.values())
         if (value.error && !isRegisteredRepair(context, value.error.details.continuation, scope))

package/dist/services/hooks.js

@@ -619,7 +619,8 @@ export function handleGrokEvent(context, input) {
     const daemonId = stringValue(ddGrok.daemonId);
     const agentId = stringValue(hook.agent_id) ?? stringValue(hook.agentId);
     const eventKey = stringValue(hook.event_id) ?? stringValue(hook.eventId) ?? crypto.createHash("sha256").update(JSON.stringify({
-        harness: "grok-acp", providerSessionId, command, turn: hook.turn_id ?? hook.turnId ?? null
+        harness: "grok-acp", providerSessionId, toolUseId: hook.tool_use_id ?? hook.toolUseId ?? null,
+        promptId: hook.prompt_id ?? hook.promptId ?? null, command, turn: hook.turn_id ?? hook.turnId ?? null
     })).digest("hex");
     assertHookEventReplay(context, { projectId: project.id, eventKey, harness: "grok-acp", providerSessionId, parentSessionId, daemonId: daemonId ?? null, sessionId, turnId: stringValue(hook.turn_id) ?? stringValue(hook.turnId) ?? null, eventName: "PreToolUse", toolName: toolName ?? "Bash", matchKey, cwd: expectedRoot });
     const payload = {
@@ -740,6 +741,12 @@ export function handleAgyEvent(context, input) {
     const toolName = stringValue(event.tool);
     if (!directory || !providerSessionId || !daemonId || !eventId || !toolName)
         throw new AppError("agy_session_identity_invalid", "Antigravity event is missing trusted physical identity", 1);
+    const rawInput = objectRecord(event.input);
+    const command = stringValue(rawInput.command) ?? stringValue(rawInput.cmd) ?? stringValue(rawInput.CommandLine);
+    if (event.phase === "before" && command && (lifecycleFacts(command) || continuationCommand(command))
+        && (!Number.isInteger(event.execution_num) || !Number.isInteger(event.step_index))) {
+        throw new AppError("agy_native_call_identity_missing", "Participating Antigravity lifecycle calls require native execution and step identity", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+    }
     const translated = {
         schema_id: "dd-flow/opencode-tool-event@1", source_harness: "antigravity-cli", phase: event.phase, event_id: eventId,
         daemon_id: daemonId, tool_call_id: eventId, tool: toolName, input: event.input,

package/dist/services/lifecycle-invocations.js

@@ -874,7 +874,11 @@ export function observedLifecycleNativeEvent(context, command, daemonId) {
         return null;
     const parsed = parseLifecycleCommand(command);
     const eventKey = parsed.kind === "standalone" ? commandOption(parsed.invocation, "hook-event-id") : undefined;
-    const matches = context.db.all("SELECT project_id, id, event_key, sanitized_summary FROM hook_events WHERE daemon_id = ? AND status = 'observed' AND outcome_json IS NULL", [daemonId]).filter(row => {
+    const matches = context.db.all(daemonId
+        ? "SELECT project_id, id, event_key, sanitized_summary FROM hook_events WHERE daemon_id = ? AND status = 'observed' AND outcome_json IS NULL"
+        : eventKey
+            ? "SELECT project_id, id, event_key, sanitized_summary FROM hook_events WHERE event_key = ? AND status = 'observed' AND outcome_json IS NULL"
+            : "SELECT project_id, id, event_key, sanitized_summary FROM hook_events WHERE harness IN ('antigravity-cli','codex-desktop') AND status = 'observed' AND outcome_json IS NULL", daemonId || eventKey ? [daemonId ?? eventKey] : []).filter(row => {
         if (eventKey && row.event_key !== eventKey)
             return false;
         try {

package/dist/services/run-controller.js

@@ -527,30 +527,40 @@ async function executeController(context, row, manifest, state, assertOwnership,
         if (failure)
             throw failure.reason;
     };
+    const reconcilePromptPredecessor = async (session) => {
+        const prior = state.last_receipt?.settlement;
+        if (!prior || typeof prior !== "object" || Array.isArray(prior) || !["pending", "blocked"].includes(String(prior.state)))
+            return;
+        const receipt = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
+        state.last_receipt = receipt;
+        saveState(context, row, state);
+        const current = receipt.settlement;
+        if (current && typeof current === "object" && !Array.isArray(current) && ["pending", "blocked"].includes(String(current.state))) {
+            throw new AppError("settlement_reconciliation_required", "The managed Session still has an unsettled productive predecessor", 1, { session_id: session.id, settlement: current });
+        }
+    };
     const prompt = async (session, text, operationId) => {
+        await reconcilePromptPredecessor(session);
         const file = path.join(row.state_dir, `turn-${String(state.turns + 1).padStart(5, "0")}.md`);
         fs.writeFileSync(file, `${text}\n`, { flag: "wx", mode: 0o600 });
         state.turns += 1;
         saveState(context, row, state);
         let receipt;
+        const adapter = controllerAdapter(executionContext, row, manifest, session, ["session", "prompt", "--session-id", session.id, "--prompt-file", file, ...sessionArguments(context, manifest, session)], assertOwner, operationId, cancellation.signal);
         try {
-            const adapter = controllerAdapter(executionContext, row, manifest, session, ["session", "prompt", "--session-id", session.id, "--prompt-file", file, ...sessionArguments(context, manifest, session)], assertOwner, operationId, cancellation.signal);
-            try {
-                receipt = await adapter;
-                checkOutcomes();
-                if (fatal)
-                    throw fatal;
-            }
-            catch (error) {
-                if (!fatal && error instanceof AppError && ["run_recovery_guarded", "run_recovery_generation_stale", "controller_owner_mismatch"].includes(error.code))
-                    throw error;
-                await stopAfterFailure(error);
-                cancellation.abort();
-                await adapter.catch(() => { });
-                throw fatal ?? error;
-            }
+            receipt = await adapter;
+            checkOutcomes();
+            if (fatal)
+                throw fatal;
+        }
+        catch (error) {
+            if (!fatal && error instanceof AppError && ["run_recovery_guarded", "run_recovery_generation_stale", "controller_owner_mismatch"].includes(error.code))
+                throw error;
+            await stopAfterFailure(error);
+            cancellation.abort();
+            await adapter.catch(() => { });
+            throw fatal ?? error;
         }
-        finally { /* Adapter settlement is joined before returning. */ }
         state.last_receipt = receipt;
         saveState(context, row, state);
         return receipt;

package/dist/services/runtime-budget.js

@@ -328,10 +328,15 @@ export function reserveProviderTurn(context, record, input) {
             db.exec("COMMIT");
             return { admitted: true, budget_scope: budget.scope_id, reused: true };
         }
-        const active = db.get("SELECT count(*) AS count FROM managed_resources WHERE resource_kind = 'provider-turn' AND json_extract(metadata_json, '$.scope_id') = ? AND json_extract(metadata_json, '$.harness') = ?", [budget.scope_id, harness]).count;
+        const activeTurns = db.all("SELECT process_id, metadata_json FROM managed_resources WHERE resource_kind = 'provider-turn' AND json_extract(metadata_json, '$.scope_id') = ? AND json_extract(metadata_json, '$.harness') = ? ORDER BY created_at, resource_key", [budget.scope_id, harness]);
+        const active = activeTurns.length;
         if (active >= limit) {
+            const blocking_turns = activeTurns.map(turn => {
+                const claim = JSON.parse(turn.metadata_json);
+                return { process_id: turn.process_id, operation_id: claim.operation_id ?? null, operation: claim.operation ?? null, session_id: claim.session_id ?? null };
+            });
             db.exec("COMMIT");
-            return { admitted: false, reason: "provider_capacity", budget_scope: budget.scope_id, harness, limit, active };
+            return { admitted: false, reason: "provider_capacity", budget_scope: budget.scope_id, harness, limit, active, blocking_turns };
         }
         db.run("INSERT INTO managed_resources (resource_kind, resource_key, owner_id, lease_token, lease_expires_at, process_id, metadata_json, created_at, updated_at) VALUES ('provider-turn', ?, ?, ?, ?, ?, ?, ?, ?)", [key, record.owner_id, record.lease_token, record.lease_expires_at, record.id, JSON.stringify({ scope_id: budget.scope_id, harness, operation_id: input.operationId, operation: input.operation, session_id: input.sessionId ?? null, state_dir: metadata.state_dir }), now, now]);
         db.exec("COMMIT");

package/dist/services/vnext-code.js

@@ -527,8 +527,9 @@ function coordinatorPrompt(context, input) {
         "",
         "<verification_contract>",
         "```json",
-        JSON.stringify({ schema_id: "dd-flow/code-verification@2", verdict: "passed | needs_repair | blocked", summary: "Evidence-backed conclusion.", unresolved: [], deviations: [] }, null, 2),
+        JSON.stringify({ schema_id: "dd-flow/code-verification@2", verdict: "passed", summary: "Evidence-backed conclusion.", unresolved: [], deviations: [] }, null, 2),
         "```",
+        "Allowed verdict values are passed, needs_repair, and blocked. The example is valid JSON using passed; choose exactly one value.",
         "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-protocolize.js

@@ -481,7 +481,7 @@ function resultTemplate(obligations = []) {
 }
 function renderPrompt(input) {
     const obligationList = input.obligations.map((obligation) => `- ${obligation.id}: ${obligation.statement}`).join("\n");
-    return ["<work_context>", `- RUN: ${input.runId}`, `- Work: ${input.workId}`, `- Accepted SPECIFY JSON: ${input.specifyPath}`, `- Handoff: ${input.handoff.stage_handoff.effective}`, "</work_context>", "", "<accepted_obligations>", obligationList, "</accepted_obligations>", "", "<frozen_git_policy>", `- route: ${input.policy.route}`, `- integration branch: ${input.policy.integration_branch ?? "not applicable"}`, `- base ref: ${input.policy.base_ref ?? "not applicable"}`, `- feature branch: ${input.policy.feature_branch ?? "not applicable"}`, `- service worktree: ${input.policy.worktree_path ?? "not applicable"}`, `- bootstrap: ${input.policy.bootstrap_status}`, `- decision: ${input.policy.reason}`, "The CLI already created and bootstrapped this workspace at PROTOCOLIZE start. Do not create branches, worktrees, protocol files or Git commits yourself. This transition Work may run from the stable session; edit only the supplied RUN result file.", "</frozen_git_policy>", "", "<catalog>", input.catalog.length ? input.catalog.map((x) => `- ${x}`).join("\n") : "- inactive", "</catalog>", "", "<stage_instructions>", input.template.trim(), "</stage_instructions>", "", "<output_contract>", `Edit only ${input.resultPath}. Keep this exact JSON shape; CLI allocates ids and writes PRT/PSET/feature documents in the already provisioned workspace:\n\n\`\`\`json\n${JSON.stringify(resultTemplate(), null, 2)}\n\`\`\``, "Allocate every supplied R-* and AC-* exactly once in obligation_ownership. The CLI rejects unknown, duplicate or missing obligations, and every member must own at least one AC-*.", "If PROTOCOLIZE itself exposes a material user decision with no reasonable default, do not finish and do not return to SPECIFY. Write the question packet to the named text file, then run the separate standalone lifecycle command below. Do not combine file creation and dd-flow in one shell command:", "```sh", input.pauseCommandTemplate, "```", "Ask the returned user_message and stop. Resume this same PROTOCOLIZE Work using the exact command returned by pause.", `When the answer is incorporated and the result is protocolized, finish:\n\n${input.finishCommand}`, "</output_contract>", ""].join("\n");
+    return ["<work_context>", `- RUN: ${input.runId}`, `- Work: ${input.workId}`, `- Accepted SPECIFY JSON: ${input.specifyPath}`, `- Handoff: ${input.handoff.stage_handoff.effective}`, "</work_context>", "", "<accepted_obligations>", obligationList, "</accepted_obligations>", "", "<frozen_git_policy>", `- route: ${input.policy.route}`, `- integration branch: ${input.policy.integration_branch ?? "not applicable"}`, `- base ref: ${input.policy.base_ref ?? "not applicable"}`, `- feature branch: ${input.policy.feature_branch ?? "not applicable"}`, `- service worktree: ${input.policy.worktree_path ?? "not applicable"}`, `- bootstrap: ${input.policy.bootstrap_status}`, `- decision: ${input.policy.reason}`, "The CLI already created and bootstrapped this workspace at PROTOCOLIZE start. Do not create branches, worktrees, protocol files or Git commits yourself. This transition Work may run from the stable session; edit only the supplied RUN result file.", "</frozen_git_policy>", "", "<catalog>", input.catalog.length ? input.catalog.map((x) => `- ${x}`).join("\n") : "- inactive", "</catalog>", "", "<stage_instructions>", input.template.trim(), "</stage_instructions>", "", "<output_contract>", `Edit only ${input.resultPath}. Keep this exact JSON shape; CLI allocates ids and writes PRT/PSET/feature documents in the already provisioned workspace:\n\n\`\`\`json\n${JSON.stringify(resultTemplate(input.obligations), null, 2)}\n\`\`\``, "obligation_id values and their one-per-obligation entries are prefilled by the CLI. Preserve those IDs exactly; change only member_keys when semantic ownership requires it. The CLI rejects unknown, duplicate or missing obligations, and every member must own at least one AC-*.", "If PROTOCOLIZE itself exposes a material user decision with no reasonable default, do not finish and do not return to SPECIFY. Write the question packet to the named text file, then run the separate standalone lifecycle command below. Do not combine file creation and dd-flow in one shell command:", "```sh", input.pauseCommandTemplate, "```", "Ask the returned user_message and stop. Resume this same PROTOCOLIZE Work using the exact command returned by pause.", `When the answer is incorporated and the result is protocolized, finish:\n\n${input.finishCommand}`, "</output_contract>", ""].join("\n");
 }
 function prepareWorkspaceForProtocolize(context, projectRoot, projectId, run, stageRoot) {
     const receiptPath = path.join(stageRoot, "workspace-route.json");

package/package.json

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