@deksden-com/dd-flow-cli 0.9.0-beta.120 → 0.9.0-beta.122

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.122
+
+### Patch Changes
+
+- Generate a deterministic RUN-local verification matrix from accepted requirements, PLAN and exact check receipts; publish retained input/output packets and show their paths in shared Stage/Work instructions.
+- Recognize one unambiguous lifecycle command through the shared Bash grammar instead of rejecting all shell composition; retain scoped authority, execution-directory and foreground checks.
+- Share native hook deadlines through subprocess and SQLite admission, retain bounded phase diagnostics and the first ZCode failure, and prepare Stage archive/Git work outside the writer.
+- Admit the tested ZCode ACP 0.52 bridge and retain explicitly configured native storage routes across daemon lifecycle calls.
+
 ## 0.9.0-beta.120
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,11 +1,11 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.120",
-  "cli_commit": "a9385404a7a9fced5e4cfdcdb656e534c06d1401",
-  "built_at": "2026-09-28T22:25:15.635Z",
+  "cli_version": "0.9.0-beta.122",
+  "cli_commit": "b03c699ac77fa596e684408c8e46e8710edbe9f6",
+  "built_at": "2026-09-30T01:56:09.576Z",
   "built_with_canon": {
-    "version": "4.1.1",
-    "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",
+    "version": "4.1.2",
+    "commit": "0cf38231406614cfeb0a96001ba0201de2316e47",
     "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/hook-ingress.js

@@ -21,11 +21,12 @@ export async function runHookIngress(args) {
             throw new AppError("usage", "--project-root requires a value", 2);
         if (parsed.options.has("json") && parsed.options.get("json")?.[0] !== "__dd_flow_flag__")
             throw new AppError("usage", "--json does not take a value", 2);
-        const budget = hookBudget(ingressBudgetMs);
+        const budget = hookBudget(ingressBudgetMs, process.env.DD_FLOW_HOOK_DEADLINE_AT ? Number(process.env.DD_FLOW_HOOK_DEADLINE_AT) : null);
         const stdin = await readNativeHookInput(process.stdin, budget);
         const payload = parseJsonObject(stdin || "{}", "native hook stdin");
         const command = lifecycleCommandFromPayload(payload);
-        if (event !== "PreToolUse" || !command || (parseLifecycleCommand(command).kind === "none" && !continuationCommand(command))) {
+        const analysis = command ? parseLifecycleCommand(command) : { kind: "none", unresolved: false };
+        if (event !== "PreToolUse" || !command || (analysis.kind === "none" && !analysis.unresolved && !continuationCommand(command))) {
             process.stdout.write("{}\n");
             return 0;
         }
@@ -46,7 +47,7 @@ export async function runHookIngress(args) {
 // A bounded CLI subprocess, not a detached writer: its successful reply follows COMMIT.
 if (process.argv[1] === workerFile) {
     try {
-        const stdin = await readNativeHookInput(process.stdin, hookBudget(ingressBudgetMs));
+        const stdin = await readNativeHookInput(process.stdin, hookBudget(ingressBudgetMs, process.env.DD_FLOW_HOOK_DEADLINE_AT ? Number(process.env.DD_FLOW_HOOK_DEADLINE_AT) : null));
         const payload = parseJsonObject(stdin, "native hook stdin");
         const started = performance.now();
         const { verifyCodexHookDelivery } = await import("../services/codex-hook-delivery.js");

package/dist/cli/native-hook-ingress.js

@@ -1,11 +1,22 @@
 import { AppError, errorRecord } from "../shared/errors.js";
 import { parseCommandArgs } from "../services/lifecycle-command.js";
+import { channel } from "node:diagnostics_channel";
 /** These ingress commands consume a prepared store; they never prepare it. */
 export function isNativeHookIngress(args) {
     return args[2] === "handle" && ((args[1] === "event" && ["agy", "grok", "droid", "opencode", "zcode"].includes(args[0] ?? ""))
         || args[0] === "zcode" && args[1] === "hook");
 }
 export async function dispatchNativeHook(args, stdin, env) {
+    const started = performance.now();
+    const deadline = env.DD_FLOW_HOOK_DEADLINE_AT === undefined ? undefined : Number(env.DD_FLOW_HOOK_DEADLINE_AT);
+    if (deadline !== undefined && !Number.isSafeInteger(deadline))
+        throw new AppError("hook_deadline_invalid", "Native hook deadline must be an absolute millisecond timestamp", 1, { effect: "unknown" });
+    const phase = (name) => {
+        if (deadline !== undefined && deadline <= Date.now())
+            throw new AppError("native_hook_timeout", "Native hook deadline expired", 1, { phase: name, effect: "unknown" });
+        process.stderr.write(`${JSON.stringify({ kind: "native_hook_phase", phase: name, elapsed_ms: Math.round(performance.now() - started), ...(deadline !== undefined ? { remaining_ms: Math.max(0, deadline - Date.now()) } : {}) })}\n`);
+    };
+    phase("import");
     const parsed = parseCommandArgs(args.slice(3));
     const projectRoot = parsed.options.get("project-root")?.[0];
     if (!isNativeHookIngress(args) || parsed.positional.length || !projectRoot || projectRoot === "__dd_flow_flag__")
@@ -16,27 +27,48 @@ export async function dispatchNativeHook(args, stdin, env) {
     const [hooks, { createContext }, { resolveDdFlowHome }] = await Promise.all([
         import("../services/hooks.js"), import("../runtime/context.js"), import("../storage/paths.js")
     ]);
+    phase("imported");
     let opened;
     // Reuse the actual envelope validators and shell parser. They return for
     // unrelated tools before their first DB access, without duplicating policy.
     const context = {
         env, ddFlowHome: resolveDdFlowHome(env), now: () => new Date().toISOString(),
-        get db() { return (opened ??= createContext(env, "hook")).db; }
+        get db() {
+            if (!opened) {
+                phase("store_open");
+                opened = createContext(env, "hook");
+                phase("store_opened");
+            }
+            return opened.db;
+        }
     };
     const handler = args[0] === "agy" ? hooks.handleAgyEvent : args[0] === "grok" ? hooks.handleGrokEvent
         : args[0] === "droid" ? hooks.handleDroidEvent : args[0] === "opencode" ? hooks.handleOpenCodeEvent
             : args[1] === "hook" ? hooks.handleZcodeHook : hooks.handleZcodeEvent;
+    const timing = channel("dd-flow.sqlite.ingress");
+    // This command owns one synchronous store; there is no concurrent handler here.
+    let previousPhase;
+    const log = (value) => {
+        const record = value;
+        if (record.phase === previousPhase)
+            return;
+        previousPhase = record.phase;
+        process.stderr.write(`${JSON.stringify({ kind: "native_hook_phase", phase: record.phase, elapsed_ms: Math.round(performance.now() - started), ...(record.remaining_ms !== undefined ? { remaining_ms: record.remaining_ms } : {}) })}\n`);
+    };
+    timing.subscribe(log);
     try {
+        phase("receipt");
         return await handler(context, { projectRoot, stdin });
     }
     finally {
+        timing.unsubscribe(log);
         opened?.db.close?.();
     }
 }
 export async function runNativeHookIngress(args) {
     try {
         const { readNativeHookInput, hookBudget } = await import("../harness-runtime/lib/native-hook-command.mjs");
-        const stdin = await readNativeHookInput(process.stdin, hookBudget());
+        const stdin = await readNativeHookInput(process.stdin, hookBudget(25_000, process.env.DD_FLOW_HOOK_DEADLINE_AT ? Number(process.env.DD_FLOW_HOOK_DEADLINE_AT) : null));
         process.stdout.write(`${JSON.stringify(await dispatchNativeHook(args, stdin, process.env))}\n`);
         return 0;
     }

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

@@ -15,7 +15,7 @@ async function hook(options) {
   const payload = JSON.parse(await readNativeHookInput(process.stdin, budget) || "{}"), event = options.event;
   try {
   const observationMs = budget.remaining("observation");
-  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload, daemonId: options["daemon-id"], deadlineAt: Date.now() + observationMs }, observationMs, requestId);
+  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload, daemonId: options["daemon-id"], deadlineAt: budget.deadlineAt }, observationMs, requestId);
   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 ?? {};
@@ -28,7 +28,10 @@ async function hook(options) {
   } catch (error) {
     // A failed socket cannot be used to report its own failure. The daemon
     // reads only receipts matching request IDs it actually accepted this turn.
-    try { await writeJsonAtomic(path.join(options["state-dir"], "hook-failures", `${requestId}.json`), { request_id: requestId, observed_at: new Date().toISOString(), code: error.code ?? "agy_hook_rejected", message: error.message, details: { ...error.details, effect: "unknown" } }); }
+    const correctable = event === "PreToolUse" && error.code === "lifecycle_shell_syntax_invalid" && error.details?.effect === "no_effect"
+      && error.details?.recoverable === true && error.details?.disposition === "pre_cli_shell_refusal";
+    try { await writeJsonAtomic(path.join(options["state-dir"], "hook-failures", `${requestId}.json`), { request_id: requestId, observed_at: new Date().toISOString(), code: error.code ?? "agy_hook_rejected", message: error.message,
+      details: { ...error.details, effect: correctable ? "no_effect" : "unknown", ...(correctable ? { native_pre_cli_refusal: true } : {}) } }); }
     catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
     throw error;
   }
@@ -49,4 +52,4 @@ try {
   else if (family === "session") { if (command === "fork") throw Object.assign(new Error("Antigravity native headless fork is unsupported; use deterministic_replay"), { code: "agy_headless_fork_unsupported" }); const operation = command === "status" ? "inspect" : command; result = await callDaemon(common.stateDir, `session.${operation}`, { sessionId: options["session-id"], ...(command === "create" || command === "prompt" ? { prompt: await prompt(options) } : {}), tree: options.tree === true }, common.timeoutMs ?? 1_800_000); }
   else throw new Error("usage: dd-agy doctor | hooks install|check | daemon start|status|stop | session create|prompt|inspect|resume|cancel|fork [options] --json");
   process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
-} catch (error) { if (process.argv.includes("hook") && process.argv.includes("handle")) { process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.code ?? "agy_hook_rejected" })}\n`); process.exit(0); } process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1); }
+} catch (error) { if (process.argv.includes("hook") && process.argv.includes("handle")) { process.stdout.write(`${JSON.stringify({ decision: "deny", reason: `${error.code ?? "agy_hook_rejected"}: ${error.message ?? "Native hook refused this tool call"}` })}\n`); process.exit(0); } process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1); }

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

@@ -404,6 +404,21 @@ export class Runtime {
   }
   async rejectHook(error, event, payload, current = this.active) {
     if (current && this.active !== current) return;
+    const correctable = current && event === "PreToolUse" && error.code === "lifecycle_shell_syntax_invalid"
+      && error.details?.effect === "no_effect" && error.details?.recoverable === true
+      && error.details?.disposition === "pre_cli_shell_refusal" && error.details?.native_pre_cli_refusal === true;
+    if (correctable && current.hookCorrectionGeneration !== current.generation) {
+      // The request was correlated with this still-active Turn by
+      // observeHookFailures. Persist before allowing native same-Turn recovery.
+      const correction = { code: error.code, message: error.message, details: error.details, event, conversation_id: payload.conversationId ?? null,
+        daemon_id: this.config.daemonId, operation_id: current.operationId, turn_generation: current.generation };
+      try {
+        await this.journal("hook_correction", { correction });
+        await this.persist({ last_hook_correction: correction });
+        current.hookCorrectionGeneration = current.generation;
+        return;
+      } catch (storage) { error = Object.assign(new Error("Could not persist native hook correction"), { code: "native_hook_receipt_invalid", details: { effect: "unknown", primary_error: correction, receipt_error: storage.message } }); }
+    }
     const rejection = this.state.last_hook_rejection && this.state.last_hook_rejection.turn_generation === current?.generation ? this.state.last_hook_rejection : { code: error.code ?? "agy_hook_rejected", message: error.message ?? String(error), details: error.details, event, conversation_id: payload.conversationId ?? null, tool: payload.toolCall?.name ?? null, daemon_id: this.config.daemonId, operation_id: current?.operationId ?? null, turn_generation: current?.generation ?? null };
     this.state.last_hook_rejection = rejection;
     if (current && this.active === current) { this.active = null; current.reject(new DaemonError(rejection.code, rejection.message, false, rejection)); }
@@ -417,6 +432,7 @@ export class Runtime {
       try { failure = JSON.parse(await readFile(path.join(this.paths.dir, "hook-failures", `${requestId}.json`), "utf8")); }
       catch (error) { if (error.code === "ENOENT") continue; failure = { code: "native_hook_receipt_invalid", message: error.message }; }
       if (failure.request_id !== undefined && failure.request_id !== requestId) continue;
+      this.hookRequests.delete(requestId);
       await this.rejectHook(Object.assign(new Error(failure.message ?? "Native hook failed"), { code: failure.code, details: failure.details }), binding.event, binding.payload, binding.current);
     }
   }

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

@@ -315,7 +315,7 @@ export class Runtime {
     // creation/end_turn receipt can then establish an idle root. Dispatch
     // clears that receipt before sending any subsequent productive request.
     const receipt = this.sessions.get(result?.provider_session_id)?.native_root_receipt;
-    if (status === "unknown" && ["created", "end_turn", "cancelled"].includes(receipt?.kind)) return false;
+    if (status === "unknown" && ["created", "end_turn", "cancelled", "failed"].includes(receipt?.kind)) return false;
     return !["completed", "failed", "cancelled", "stopped", "idle"].includes(status);
   }
   async refreshTree(cancel = false) {
@@ -356,7 +356,17 @@ export class Runtime {
       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; }
+    } catch (error) {
+      // A matched JSON-RPC error completes this native prompt request. It is
+      // root-turn proof, not proof that any descendants have stopped. A lost
+      // response, bridge error, or failure before dispatch earns no receipt.
+      const response = error?.details?.terminal_response;
+      if (name === "session.prompt" && response?.method === "session/prompt" && response.session_id === sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) session.native_root_receipt = { kind: "failed", daemon_id: this.state.daemon_id, request_id: response.request_id };
+      }
+      await this.persist({ active_tree: true, active_operation: null }); throw error;
+    }
     finally { this.active = null; }
   }
   async dispatch(operation, params) {

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

@@ -124,8 +124,19 @@ export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 3
   });
 }
 
+const ZCODE_ROUTING_ENV = ["ZCODE_HOME", "ZCODE_STORAGE_DIR", "ZCODE_SESSION_DB_PATH"];
+
+function nativeRoutingEnv() {
+  return Object.fromEntries(ZCODE_ROUTING_ENV.filter(key => process.env[key] !== undefined)
+    .map(key => [key, absolute(process.env[key], key)]));
+}
+
+function sameNativeRouting(previous, config) {
+  return ZCODE_ROUTING_ENV.every(key => (previous?.env?.[key] ?? null) === (config.env?.[key] ?? null));
+}
+
 function sameConfig(state, config) {
-  return ["cwd", "journal", "bin", "zcodePath", "ddFlowBin", "ddFlowHome", "projectRoot", "resourceHome", "livenessTimeoutMs", "requestTimeoutMs"].every((key) => (state.config?.[key] ?? null) === (config[key] ?? null));
+  return sameNativeRouting(state.config, config) && ["cwd", "journal", "bin", "zcodePath", "ddFlowBin", "ddFlowHome", "projectRoot", "resourceHome", "livenessTimeoutMs", "requestTimeoutMs"].every((key) => (state.config?.[key] ?? null) === (config[key] ?? null));
 }
 
 export async function startDaemon(options) {
@@ -145,7 +156,7 @@ export async function startDaemon(options) {
     ddFlowHome: options.ddFlowHome ? absolute(options.ddFlowHome, "--dd-flow-home") : null,
     projectRoot: options.projectRoot ? absolute(options.projectRoot, "--project-root") : null,
     resourceHome: process.env.DD_FLOW_RESOURCE_HOME ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null,
-    env: options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home"), ...(options.ddFlowBin ? { DD_FLOW_BIN: absolute(options.ddFlowBin, "--dd-flow-bin") } : {}) } : {},
+    env: { ...nativeRoutingEnv(), ...(options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home"), ...(options.ddFlowBin ? { DD_FLOW_BIN: absolute(options.ddFlowBin, "--dd-flow-bin") } : {}) } : {}) },
     livenessTimeoutMs: positiveDuration(options.livenessTimeoutMs, "livenessTimeoutMs", DEFAULT_LIVENESS_TIMEOUT_MS),
     requestTimeoutMs: optionalDuration(options.requestTimeoutMs, "requestTimeoutMs", DEFAULT_REQUEST_TIMEOUT_MS),
   };
@@ -159,7 +170,10 @@ export async function startDaemon(options) {
   } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; }
 
   const previous = await readState(paths.dir);
-  if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
+  if (previous?.shutdown_state === "clean") {
+    if (!sameNativeRouting(previous.config, config)) throw new DaemonError("daemon_config_mismatch", "retained ZCode native storage routing changed");
+    await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
+  }
   if (previous?.shutdown_state === "running" && previous.active_tree) {
     throw new DaemonError("invalid_harness_crash", "the previous daemon died with an active or unproven Session tree", false, { daemon_id: previous.daemon_id });
   }
@@ -237,6 +251,7 @@ export class DaemonRuntime {
     const generation = this.activeGeneration ?? this.controlGeneration ?? 0;
     return {
       ...this.state.config, ...params, knownChildSessionIds: known?.known_child_session_ids ?? [], adapterSessionId: adapter,
+      neverPromptedRootProof: this.neverPromptedRootProof(params.sessionId),
       daemonId: this.state.daemon_id, allowBackground: true, liveSession: this.liveAdapters.has(adapter),
       assertDispatch: () => { if (generation !== (this.controlGeneration ?? 0)) throw new DaemonError("operation_cancelled", "ZCode prompt was cancelled before native dispatch"); },
       // The bridge owns the quiet timer; the daemon owns the durable status.
@@ -304,6 +319,12 @@ export class DaemonRuntime {
         // A late identity is evidence, not permission to resurrect a completed
         // request or overwrite another operation's ownership.
         this.track(identity);
+        const allocated = this.sessions.get(identity.provider_session_id);
+        if (allocated && this.activeProductive === "session.create" && current?.allocation?.adapter_session_id === identity.adapter_session_id
+          && allocated.prompt_dispatched === undefined) {
+          allocated.prompt_dispatched = false;
+          allocated.created_by_daemon_id = this.state.daemon_id;
+        }
         if (!current || current.allocation?.adapter_session_id !== identity.adapter_session_id) {
           await this.persist({});
           return;
@@ -344,6 +365,8 @@ export class DaemonRuntime {
       topology: topology ?? existing?.topology ?? null,
       known_child_session_ids: [...new Set([...(existing?.known_child_session_ids ?? zcodeChildSessionIds(existing?.topology)), ...zcodeChildSessionIds(topology)])],
       completed_turns: existing?.completed_turns ?? 0,
+      prompt_dispatched: existing?.prompt_dispatched,
+      created_by_daemon_id: existing?.created_by_daemon_id,
       close_receipt: result.close?.closed === true ? result : existing?.close_receipt ?? null,
     }); }
     if (result?.adapter_session_id) this.liveAdapters.add(result.adapter_session_id);
@@ -397,10 +420,9 @@ export class DaemonRuntime {
 
   async requireSettled(params) {
     if (this.sessions.get(params.sessionId)?.close_receipt) throw new DaemonError("session_closed", "Closed Session requires explicit recovery");
-    const known = this.sessions.get(params.sessionId);
     // A freshly created ZCode Session has no prior Turn and is not yet exposed
     // by the provider's subagent index. Its first prompt is therefore safe.
-    if (known && (known.completed_turns ?? 0) === 0) return null;
+    if (this.neverPromptedRootProof(params.sessionId)) return null;
     const observed = await inspectSessionWithBridge(this.bridge, this.options(params));
     const runningChildren = observed.subagents?.running ?? [];
     if (this.treeRunning(observed)) {
@@ -410,6 +432,21 @@ export class DaemonRuntime {
     return observed;
   }
 
+  neverPromptedRootProof(sessionId) {
+    const known = this.sessions.get(sessionId);
+    return known?.prompt_dispatched === false && known.created_by_daemon_id === this.state.daemon_id
+      && known.parent_provider_session_id === null && known.root_provider_session_id === sessionId
+      && Array.isArray(known.known_child_session_ids) && known.known_child_session_ids.length === 0
+      ? { source: "owned_daemon_create_without_prompt", daemon_id: this.state.daemon_id, provider_session_id: sessionId }
+      : null;
+  }
+
+  async markPromptDispatched(sessionId) {
+    const known = this.sessions.get(sessionId);
+    if (known) known.prompt_dispatched = true;
+    await this.persist();
+  }
+
   async dispatch(operation, params) {
     if (operation === "daemon.status") return {
       daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket,
@@ -447,11 +484,11 @@ export class DaemonRuntime {
         dispatched_at: new Date().toISOString(),
         request_timeout_ms: this.state.config.requestTimeoutMs,
       };
-      const result = await this.productive(operation, async () => { await this.requireSettled(params); return await promptSessionWithBridge(this.bridge, { ...this.options(params), timeoutMs: request.request_timeout_ms }); }, request);
+      const result = await this.productive(operation, async () => { await this.requireSettled(params); await this.markPromptDispatched(params.sessionId); return await promptSessionWithBridge(this.bridge, { ...this.options(params), timeoutMs: request.request_timeout_ms }); }, request);
       const session = this.sessions.get(result.provider_session_id); if (session) session.completed_turns = (session.completed_turns ?? 0) + 1;
       await this.persist(); return result;
     }
-    if (operation === "session.fork") return await this.productive(operation, async () => { await this.requireSettled(params); return await forkSessionWithBridge(this.bridge, this.options(params)); });
+    if (operation === "session.fork") return await this.productive(operation, async () => { await this.requireSettled(params); await this.markPromptDispatched(params.sessionId); return await forkSessionWithBridge(this.bridge, this.options(params)); });
     if (operation === "session.inspect" || operation === "session.resume") {
       const closed = this.sessions.get(params.sessionId)?.close_receipt;
       if (closed) {
@@ -467,7 +504,8 @@ export class DaemonRuntime {
             && Array.isArray(receipt.topology.child_session_ids)) return receipt;
         }
         const known = [...new Set([...topology.child_session_ids, ...(previous?.topology?.child_session_ids ?? [])])];
-        const observation = { ...closed, ...await observeClosedZcodeTree(this.bridge, params.sessionId, known), observed_at: new Date().toISOString() };
+        const emptyRoot = this.neverPromptedRootProof(params.sessionId);
+        const observation = { ...closed, ...await observeClosedZcodeTree(this.bridge, params.sessionId, known, emptyRoot && closed.close?.closed === true ? {...emptyRoot,close_confirmed:true} : null), observed_at: new Date().toISOString() };
         // Observations are not ownership inventory: their timestamps must not
         // invalidate a drain fence on every read.
         this.state.settlement_observations ??= {};
@@ -525,6 +563,20 @@ export class DaemonRuntime {
       }
       const options = this.options({ sessionId: session.provider_session_id, adapterSessionId: session.adapter_session_id });
       let observed;
+      // A daemon-owned allocation with no productive dispatch cannot have
+      // children, and native ZCode has no durable read index for it yet. Close
+      // that resident directly; do not send cancellation for default stop.
+      const emptyRoot = !cancel && !this.activeProductive ? this.neverPromptedRootProof(session.provider_session_id) : null;
+      if (emptyRoot) {
+        const close = await this.bridge.request("zcode/session/close", { sessionId: session.adapter_session_id });
+        const observation = close?.closed === true
+          ? await observeClosedZcodeTree(this.bridge, session.provider_session_id, [], { ...emptyRoot, close_confirmed: true })
+          : { settled: false, topology: { root_session_id: session.provider_session_id, child_session_ids: [], complete: false } };
+        this.track({ provider_session_id: session.provider_session_id, adapter_session_id: session.adapter_session_id, cancellation_requested: false, close_requested: true, close, ...observation });
+        await this.persist({ active_tree: observation.settled !== true });
+        if (observation.settled !== true) unsettled.push(session.provider_session_id);
+        continue;
+      }
       if (!cancel) observed = await inspectSessionWithBridge(this.bridge, options);
       if (cancel || !observed || this.treeRunning(observed)) {
         if (!cancel) unsettled.push(session.provider_session_id);

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

@@ -1,6 +1,7 @@
 import { observedTimeout } from "./observation-clock.mjs";
 import { ToolObservations, acpToolObservation, zcodePhysicalSession } from "./tool-observations.mjs";
 import { invokeNativeHook } from "./native-hook-command.mjs";
+import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
@@ -19,7 +20,7 @@ const LATE_RESPONSE_GRACE_MS = 5_000;
 
 function fail(message, code) { const error = new Error(message); if (code) error.code = code; throw error; }
 function fatalLifecycleError(error) {
-  return ["invocation_unknown", "invocation_identity_mismatch", "invocation_identity_conflict", "invocation_receipt_missing", "invocation_command_mismatch", "invocation_scope_mismatch", "invocation_generation_stale", "invocation_expired", "zcode_parent_identity_missing", "zcode_tool_identity_conflict"].includes(error?.code);
+  return ["invocation_unknown", "invocation_identity_mismatch", "invocation_identity_conflict", "invocation_receipt_missing", "invocation_command_mismatch", "invocation_scope_mismatch", "invocation_generation_stale", "invocation_expired", "zcode_parent_identity_missing", "zcode_tool_identity_conflict", "native_hook_timeout", "native_hook_failed", "native_hook_response_invalid", "hook_storage_unprepared", "storage_write_failed"].includes(error?.code);
 }
 function absolute(value, label) { if (!value || !path.isAbsolute(value)) fail(`${label} must be an absolute path`); return path.resolve(value); }
 function text(value, label) { if (typeof value !== "string" || !value.trim()) fail(`${label} is required`); return value.trim(); }
@@ -233,13 +234,14 @@ export class AcpBridge {
         // A validated no-effect rejection is returned through the invocation
         // ledger. It is evidence, not a poisoned ACP Session.
         const fatal = fatalLifecycleError(error);
-        if (!this.notificationError || fatal) this.notificationError = error;
+        const current = this.options.onLifecycleNotification === observer;
+        if (current && (!this.notificationError || fatal && !fatalLifecycleError(this.notificationError) && this.notificationError.code !== "profile_integrity_violation")) this.notificationError = error;
         // A missing/foreign authority is not a recoverable CLI validation
         // result. Stop admitting productive requests immediately; the managed
         // controller still owns physical stop/drain and evidence capture.
-        if (fatal) this.rejectAll(error);
+        if (fatal && current) this.rejectAll(this.notificationError ?? error);
         try {
-          await this.journal.write("notification_failure", { code: error.code ?? "invocation_observation_failed", message: error.message,
+          await this.journal.write("notification_failure", { code: error.code ?? "invocation_observation_failed", message: error.message, ...(error.details ? { details: error.details } : {}),
             session_id: message.params?.sessionId ?? null, tool_call_id: update?.toolCallId ?? null, event_time: now(), delivery_stage: "lifecycle_receipt", completeness: "incomplete" });
         } catch (persistenceError) {
           process.stderr.write(`${JSON.stringify({ code: error.code, message: error.message, persistence_error: persistenceError.message })}\n`);
@@ -270,7 +272,9 @@ export class AcpBridge {
         const unknown = ["native_timeout", "native_backend_dead", "native_backend_pipe_broken", "native_outcome_unknown"].includes(nativeCode);
         error.code = unknown ? nativeCode : /payment required|quota|usage balance exhausted|insufficient.?credit|billing/i.test(messageText) ? "provider_quota_exhausted" : /rate.?limit|too many requests/i.test(messageText) ? "provider_rate_limited" : /\b429\b/.test(messageText) ? "provider_limit_unknown" : "acp_request_failed";
         error.retryable = error.code === "provider_rate_limited";
-        error.details = { acp_code: message.error.code ?? null, ...(data ? { native: data } : {}), ...(details ? { provider_details: details } : {}), ...(providerDetails ? { provider_update: provider } : {}) };
+        error.details = { acp_code: message.error.code ?? null,
+          terminal_response: { method: pending.method, session_id: pending.sessionId, request_id: message.id },
+          ...(data ? { native: data } : {}), ...(details ? { provider_details: details } : {}), ...(providerDetails ? { provider_update: provider } : {}) };
         pending.reject(error);
       }
       else { pending.resolve(message.result ?? {}); }
@@ -279,7 +283,7 @@ export class AcpBridge {
     if (message.method) this.notifications = this.notifications
       .then(async () => { await this.observeModelUpdate(message); await this.options.onNotification?.(message); })
       .catch(async (error) => {
-        const failure = { code: error.code ?? "notification_observation_failed", message: error.message, session_id: message.params?.sessionId ?? null, tool_call_id: message.params?.update?.toolCallId ?? null, event_time: now(), delivery_stage: "acp_evidence", completeness: "incomplete" };
+        const failure = { code: error.code ?? "notification_observation_failed", message: error.message, ...(error.details ? { details: error.details } : {}), session_id: message.params?.sessionId ?? null, tool_call_id: message.params?.update?.toolCallId ?? null, event_time: now(), delivery_stage: "acp_evidence", completeness: "incomplete" };
         try { await this.journal.write("notification_failure", failure); }
         catch (persistenceError) { process.stderr.write(`${JSON.stringify({ ...failure, persistence_error: persistenceError.message })}\n`); }
         // Evidence loss does not retroactively revoke a committed native hook.
@@ -549,7 +553,7 @@ export function zcodeChildSessionIds(snapshot) {
 // Read residency BEFORE each durable topology snapshot. An inactive node cannot
 // add descendants; a resident node never proves settlement, even when idle.
 // No resolve/read/subagents extension here: those may implicitly resume.
-export async function observeClosedZcodeTree(bridge, root, retainedChildren = []) {
+export async function observeClosedZcodeTree(bridge, root, retainedChildren = [], neverPromptedRootProof = null) {
   const pending = new Set([root, ...retainedChildren]), residents = [], snapshots = [];
   const deadline = performance.now() + 30_000;
   try {
@@ -559,6 +563,15 @@ export async function observeClosedZcodeTree(bridge, root, retainedChildren = []
       const resident = await bridge.request("zcode/session/resident", { sessionId }, timeout());
       if (resident?.sessionId !== sessionId || typeof resident.resident !== "boolean") throw new Error("Invalid residency identity or state");
       residents.push(resident);
+      // A newly allocated root is not durable in ZCode until its first prompt.
+      // This is an explicit owned-daemon ledger fact, never error→empty inference.
+      if (sessionId === root && resident.resident === false && pending.size === 1
+        && neverPromptedRootProof?.source === "owned_daemon_create_without_prompt"
+        && neverPromptedRootProof.close_confirmed === true
+        && neverPromptedRootProof.provider_session_id === root && typeof neverPromptedRootProof.daemon_id === "string") {
+        snapshots.push({ sessionId, childSessionIds: [], running: [], ended: {total:0,items:[]}, provenance: neverPromptedRootProof });
+        continue;
+      }
       const tree = await readZcodeSubagents(bridge, sessionId, deadline - performance.now(), true);
       if (!Array.isArray(tree?.childSessionIds)
         || tree.childSessionIds.some(id => typeof id !== "string" || !id || id === sessionId)
@@ -575,7 +588,7 @@ export async function observeClosedZcodeTree(bridge, root, retainedChildren = []
   }
 }
 
-async function cancelTree(bridge, sessionId, before, providerSessionId, retainedChildren = []) {
+async function cancelTree(bridge, sessionId, before, providerSessionId, retainedChildren = [], neverPromptedRootProof = null) {
   const knownChildren = new Set(retainedChildren);
   const remember = snapshot => {
     for (const id of zcodeChildSessionIds(snapshot)) knownChildren.add(id);
@@ -614,7 +627,7 @@ async function cancelTree(bridge, sessionId, before, providerSessionId, retained
   let close = null;
   try { close = await bridge.request("zcode/session/close", { sessionId }); }
   catch (error) { close = { closed: false, error: { code: error.code ?? "close_failed", message: error.message } }; }
-  const observation = close?.closed === true ? await observeClosedZcodeTree(bridge, providerSessionId, [...knownChildren])
+  const observation = close?.closed === true ? await observeClosedZcodeTree(bridge, providerSessionId, [...knownChildren], neverPromptedRootProof ? {...neverPromptedRootProof,close_confirmed:true} : null)
     : { topology: { root_session_id: providerSessionId, child_session_ids: [...knownChildren], complete: false }, settled: false };
   return { cancellations, before, after, root_status, cancellation_requested: true, close_requested: true, close, ...observation };
 }
@@ -711,9 +724,8 @@ function flowForwarder(options, rootProviderSessionId, bridge) {
     const childId = notification.params?.update?._meta?.zcodeRuntime?.childSessionId;
     const observed = bridge?.modelProfiles?.get(childId ?? rootProviderSessionId) ?? {};
     if (childId && !observed.model) await observeModel({ journal: options.journal, harness: "zcode-acp", sessionId: childId, parentSessionId: rootProviderSessionId, requested: profile(options), observed, source: "zcode.child_tool_event", evidence: "unavailable" });
-    // Native PreToolUse has already admitted (or denied) the command. ACP is
-    // intentionally only journal/model evidence: its serialized delivery can
-    // lag behind execution and must never mint a second lifecycle receipt.
+    // This serialized path is model evidence only. The independent observer
+    // below owns qualified ACP admission; do not mint a second receipt here.
   };
 }
 
@@ -751,6 +763,8 @@ export async function zcodeInvocationObserver(options, rootProviderSessionId, se
     const command = update.rawInput?.command ?? update.rawInput?.cmd;
     const toolName = update._meta?.claudeCode?.toolName;
     if (!["Bash", "bash", "execute"].includes(toolName) || typeof command !== "string") return;
+    const analysis = parseLifecycleCommand(command);
+    if (analysis.kind === "none" && !analysis.unresolved && !continuationCommand(command)) return;
     const parent = session === rootProviderSessionId ? null : owners.get(native.parentToolCallId);
     if (session !== rootProviderSessionId && !parent) throw Object.assign(new Error("Native child has no confirmed immediate parent tool owner"), { code: "zcode_parent_identity_missing" });
     await send({ bin: options.ddFlowBin, home: options.ddFlowHome,
@@ -806,6 +820,7 @@ export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContrac
     ["91a1470650f5fd6105f9863fd31d1cad7b90a109", "dd-zcode-harness@2"],
     ["b9e0f5106dddb439b76186278bd9be5f45dbf3ef", "dd-zcode-harness@2"],
     ["636b14181d5c9a95476055079836fd6b58169f58", "dd-zcode-harness@2"],
+    ["4621fabd3f517ecdd349dfebebae9077c01d2f2b", "dd-zcode-harness@2"],
   ]);
   const qualified = qualifiedBridgeCommits.get(bridgeCommit) === harnessContract;
   return { status: qualified ? "qualified" : "unqualified", mechanism: "cli-invocation@1", sha256,
@@ -963,7 +978,7 @@ export async function cancelSessionWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
   const before = await readZcodeSubagents(bridge, identity.adapterSessionId).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
-  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId, options.knownChildSessionIds) });
+  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId, options.knownChildSessionIds, options.neverPromptedRootProof) });
 }
 
 export async function forkSession(options) {

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

@@ -56,7 +56,7 @@ export const lifecycleRetryInstruction = `${lifecycleCommandCompletionInstructio
 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.",
   "In a controller-managed fanout, the coordinator ends the entry Turn after the Work graph is returned; the controller dispatches children. A completed child or Work is not Stage success: settle the declared graph and Stage gate before finishing.",
-  "Execute each runtime-issued lifecycle operation as a standalone call. Invocation IDs are internal authority; never add, copy or invent one.",
+  "Execute each runtime-issued lifecycle operation and its arguments exactly. One literal lifecycle call may be composed with ordinary shell commands; preserve conditions, stdin and redirects, and never replay the surrounding shell chain after failure. Invocation IDs are internal authority; never add, copy or invent one.",
   lifecycleRetryInstruction
 ].join(" ");
 
@@ -68,13 +68,13 @@ export function workerDelegationTask({ workId, startCommand, launchPolicy }) {
   return [
     `Complete one already-declared Work: ${workId}.`,
     context,
-    "Your first technical action must be this exact standalone lifecycle command:",
+    "Your first technical action must be this exact lifecycle command:",
     startCommand,
     "Execute the issued operation and target exactly. Lifecycle invocation IDs are internal runtime authority and are intentionally omitted; never add or invent them. Preserve any explicit native receipt handle that the command does contain.",
     "Use the native shell's inherited working directory. Do not set or override a workdir/cwd field for this lifecycle command.",
     "Continue only if it succeeds and returns the authoritative Work packet.",
     lifecycleRetryInstruction,
-    "After a successful start, complete the assigned Work, write its required result, invoke its exact standalone work finish command, then stop.",
+    "After a successful start, complete the assigned Work, write its required result, invoke its exact work finish command, then stop.",
     "Do not start another Work, create a child, change dependencies, ask the user, or treat a quiet sibling as failed. You cannot ask the user or pause the parent Stage. Missing facts go through this Work's declared result/failure contract; only the coordinator handles Stage HITL."
   ].join("\n");
 }

package/dist/harness-runtime/lib/lifecycle-command.d.mts

@@ -0,0 +1,20 @@
+import type { LifecycleOperation } from "./lifecycle-contract.mjs";
+export type { LifecycleOperation } from "./lifecycle-contract.mjs";
+export interface ParsedCommandArgs { positional: string[]; options: Map<string, string[]> }
+export interface LifecycleInvocation {
+  operation: LifecycleOperation; executable: string; launcher?: string; argv: string[]; env: Record<string, string>; args: ParsedCommandArgs; command: string;
+  rewriteSafe: boolean; wrapped: boolean; heredoc: boolean; sourceRange?: { start: number; end: number }; contexts?: string[]; expectedCwd?: string;
+}
+export type LifecycleAnalysis =
+  | { kind: "none"; unresolved?: true; reason?: string }
+  | { kind: "standalone"; invocation: LifecycleInvocation; supported?: boolean; invocations?: LifecycleInvocation[] }
+  | { kind: "compound"; invocation: LifecycleInvocation; reason: string; supported?: boolean; invocations?: LifecycleInvocation[] };
+export function lifecycleCommandFromPayload(payload: { command?: unknown; tool_input?: unknown }): string | undefined;
+export function parseLifecycleCommand(command: string): LifecycleAnalysis;
+export function continuationCommand(command: string): { operation: string; args: ParsedCommandArgs } | null;
+export function unwrapShellCommand(command: string): string;
+export function parseCommandArgs(argv: string[]): ParsedCommandArgs;
+export function commandOption(invocation: LifecycleInvocation, name: string): string | undefined;
+export function commandHasOption(invocation: LifecycleInvocation, name: string): boolean;
+export function commandPosition(invocation: LifecycleInvocation, index: number): string | undefined;
+export function shellSuffixOffset(command: string): number;