@deksden-com/dd-flow-cli 0.9.0-beta.106 → 0.9.0-beta.108

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.108
+
+### Patch Changes
+
+- Route native tool hooks through the prepared hook store and skip storage entirely for unrelated tools. Give ZCode daemon readiness a bounded 30-second window and clean up the exact registered provider process if any managed daemon fails to start, preserving the primary startup error.
+
+## 0.9.0-beta.107
+
+### Patch Changes
+
+- Give a corrective successor only for proven no-effect PROTOCOLIZE, PLAN, PLAN-REVIEW, and Work input errors, including invalid corrected PLAN schemas and missing evidence references; keep broken runtime artifacts fatal. Tell PLAN reviewers the exact workspace-relative PLAN path. Apply ZCode's profile as one unarmed configuration phase and verify the final native profile before productive work, so transient native mode notifications cannot masquerade as drift.
+
 ## 0.9.0-beta.106
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.106",
-  "cli_commit": "41377cb4915163be7220cc90928ea8a0f50683d0",
-  "built_at": "2026-09-27T00:48:48.042Z",
+  "cli_version": "0.9.0-beta.108",
+  "cli_commit": "0df3cd1e7201f27baeeb07f1c4f2b69ed6e2399b",
+  "built_at": "2026-09-27T04:24:32.044Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

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

@@ -0,0 +1,48 @@
+import { AppError, errorRecord } from "../shared/errors.js";
+import { parseCommandArgs } from "../services/lifecycle-command.js";
+/** 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 parsed = parseCommandArgs(args.slice(3));
+    const projectRoot = parsed.options.get("project-root")?.[0];
+    if (!isNativeHookIngress(args) || parsed.positional.length || !projectRoot || projectRoot === "__dd_flow_flag__")
+        throw new AppError("usage", "Native hook requires --project-root", 2);
+    for (const [name, values] of parsed.options)
+        if (!["project-root", "json"].includes(name) || values.length !== 1 || name === "json" && values[0] !== "__dd_flow_flag__")
+            throw new AppError("usage", `Invalid native hook option: ${name}`, 2);
+    const [hooks, { createContext }, { resolveDdFlowHome }] = await Promise.all([
+        import("../services/hooks.js"), import("../runtime/context.js"), import("../storage/paths.js")
+    ]);
+    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; }
+    };
+    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;
+    try {
+        return await handler(context, { projectRoot, stdin });
+    }
+    finally {
+        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());
+        process.stdout.write(`${JSON.stringify(await dispatchNativeHook(args, stdin, process.env))}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        process.stderr.write(`${JSON.stringify({ ok: false, error: record })}\n`);
+        return record.exitCode;
+    }
+}

package/dist/cli/run-cli.js

@@ -8,6 +8,7 @@ import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../servic
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
 import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, bindLifecyclePublishedPacket, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, retainObservedLifecycleSemantics, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
+import { dispatchNativeHook, isNativeHookIngress } from "./native-hook-ingress.js";
 import { migrateStoreWriter } from "../storage/writer-migration.js";
 import { helpForArgs } from "./help.js";
 import { AppError, isAppError } from "../shared/errors.js";
@@ -129,6 +130,10 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             return 0;
         }
         const suppliedInvocationId = optionalOption(parseArgs(output.args.slice(2)), "invocation-id");
+        if (isNativeHookIngress(output.args)) {
+            writeJson(io.stdout, await dispatchNativeHook(output.args, await readStdin(io.stdin), env));
+            return 0;
+        }
         if (output.args[0] === "run" && ["drive", "control"].includes(output.args[1] ?? "")) {
             const controlArgs = parseArgs(output.args.slice(2));
             requiredOption(controlArgs, "run");
@@ -411,6 +416,8 @@ function resolveProjectRootBeforeRouting(args, env) {
     }
 }
 function databaseModeForCommand(args, classification) {
+    if (isNativeHookIngress(args))
+        return "hook";
     const [family, command] = args;
     // Managed attempts are issued only from a prepared store. Opening that
     // existing writer must not run migrations before their input is admitted.

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
+import { isNativeHookIngress } from "./cli/native-hook-ingress.js";
 const args = process.argv.slice(2);
 const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle" && !args.includes("--help") && !args.includes("-h");
 const exitCode = managedHook
     ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
-    : await (await import("./cli/run-cli.js")).runCli(args);
+    : isNativeHookIngress(args) && !args.includes("--help") && !args.includes("-h")
+        ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)
+        : await (await import("./cli/run-cli.js")).runCli(args);
 process.exitCode = exitCode;
-export {};

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

@@ -12,7 +12,7 @@ import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
 import { AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, runtimeProcess, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
 class DaemonError extends AgyError {}
@@ -206,12 +206,7 @@ export async function startDaemon(options) {
     }
     throw new DaemonError("daemon_start_failed", "Antigravity daemon did not become ready", true);
   } catch (error) {
-    await cleanupFailedStart(config, resourceProcess, child, error);
-    const persisted = await readState(paths.dir).catch(() => null);
-    if (persisted?.provider_process) {
-      try { await runtimeProcess(config, "stop", { id: persisted.provider_process.id, "lease-token": persisted.provider_process.lease_token }); }
-      catch (cleanup) { error.details = { ...error.details, provider_cleanup_failed: errorPayload(cleanup), provider_process_id: persisted.provider_process.id }; }
-    }
+    await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), config.daemonId);
     throw error;
   }
 }
@@ -251,7 +246,10 @@ export class Runtime {
     void this.readyPromise.catch(() => {});
     this.providerProcess = await registerDaemonProcess(this.config, { kind: "agy-provider", owner: `agy:${path.basename(this.paths.dir)}`, operation: `agy-provider:${path.basename(this.paths.dir)}`, stdout: this.paths.log, stderr: this.paths.log });
     const providerProcess = this.providerProcess;
-    this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    try { await this.persist({ provider_process: providerProcess }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
+    try { this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
     const providerChild = this.child;
     let allowProviderFinalization;
     const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
@@ -283,7 +281,7 @@ export class Runtime {
       });
     });
     void this.providerFinalization.catch(() => {});
-    try { await confirmDaemonProcess(this.config, providerProcess, this.child); await heartbeatDaemonProcess(this.config, providerProcess); await this.persist({ provider_process: providerProcess, provider_pid: this.child.pid }); }
+    try { await confirmDaemonProcess(this.config, providerProcess, this.child); await this.persist({ provider_pid: this.child.pid }); await heartbeatDaemonProcess(this.config, providerProcess); }
     catch (error) { await cleanupFailedStart(this.config, providerProcess, this.child, error); throw error; }
     finally { allowProviderFinalization(); }
     let readyTimer;

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

@@ -9,7 +9,7 @@ import { spawn } from "node:child_process";
 import { waitForSettlement } from "./session-settlement.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { CodexBridge, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 const requestSchema = "dd-codex/daemon-request@1";
 const responseSchema = "dd-codex/daemon-response@1";
@@ -90,7 +90,7 @@ export async function startDaemon(options) {
   await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 60_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed" }); }
-  catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs); }
 

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

@@ -12,7 +12,7 @@ import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
 import { cancelSessionWithBridge, createSessionWithBridge, doctor, forkSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge } from "./dd-grok.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-grok/daemon-request@1";
 const RESPONSE_SCHEMA = "dd-grok/daemon-response@1";
@@ -171,7 +171,7 @@ export async function startDaemon(options) {
   const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: daemonId, pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config: { ...config, daemonId }, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
   await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
-  catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), daemonId); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs); }
 

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

@@ -5,7 +5,7 @@ import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "
 import net from "node:net";
 import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
-import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 import {
   AcpBridge,
@@ -197,7 +197,7 @@ export async function startDaemon(options) {
   await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const deadline = Date.now() + 15_000;
+    const deadline = Date.now() + 30_000;
     while (Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 100));
       try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); }
@@ -205,7 +205,7 @@ export async function startDaemon(options) {
     }
     throw new DaemonError("daemon_start_failed", "daemon did not become ready", true);
   } catch (error) {
-    await cleanupFailedStart(config, resourceProcess, child, error);
+    await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), state.daemon_id);
     throw error;
   }
 }

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

@@ -666,6 +666,8 @@ async function controlledIdentity(bridge, options) {
 }
 
 async function applyProfile(bridge, sessionId, requested, assertDispatch = () => {}) {
+  const identity = bridge.modelSessions?.get(sessionId);
+  if (identity) identity.armed = false;
   assertDispatch();
   if (requested.mode) await bridge.request("session/set_mode", { sessionId, modeId: requested.mode });
   assertDispatch();
@@ -674,10 +676,11 @@ async function applyProfile(bridge, sessionId, requested, assertDispatch = () =>
   if (requested.model) await bridge.request("session/setModel", { sessionId, modelId: requested.provider ? `${requested.provider}\\${requested.model}` : requested.model });
   assertDispatch();
   const read = await bridge.request("zcode/session/read", { sessionId });
+  await bridge.notifications;
   const observed = observedProfile(read);
   await bridge.recordModel?.(sessionId, observed, "zcode/session/read.applied");
   const receipt = assertProfile(requested, observed);
-  const identity = bridge.modelSessions?.get(sessionId); if (identity) identity.armed = true;
+  if (identity) identity.armed = true;
   return receipt;
 }
 

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

@@ -196,14 +196,17 @@ export async function startManagedBridge({ config, state, bridge, kind, publish
   state.pid = process.pid;
   await publish(state);
   const provider = config.runtime_owner ? await registerDaemonProcess(config, { kind, owner: config.runtime_owner.owner_id, operation: kind }) : null;
-  bridge.options.onSpawn = async child => {
-    await confirmDaemonProcess(config, provider, child);
-    await heartbeatDaemonProcess(config, provider);
-    state.provider_pid = child.pid;
+  try {
     state.provider_process = provider;
     await publish(state);
-  };
-  try { return await bridge.start(); }
+    bridge.options.onSpawn = async child => {
+      await confirmDaemonProcess(config, provider, child);
+      state.provider_pid = child.pid;
+      await publish(state);
+      await heartbeatDaemonProcess(config, provider);
+    };
+    return await bridge.start();
+  }
   catch (error) { await cleanupFailedStart(config, provider, bridge.child, error); throw error; }
 }
 
@@ -260,6 +263,25 @@ export async function cleanupFailedStart(config, record, child, original) {
   }
 }
 
+/** The provider has its own process group. A failed daemon start must settle
+ * that exact retained process as well as the daemon; PID-only cleanup is unsafe. */
+export async function cleanupFailedDaemonStart(config, daemonRecord, daemonChild, original, readState, daemonId) {
+  await cleanupFailedStart(config, daemonRecord, daemonChild, original);
+  if (!daemonRecord) return;
+  try {
+    const state = await readState();
+    const owner = config.runtime_owner;
+    if (!state || state.daemon_id !== daemonId || state.resource_process?.id !== daemonRecord.id || state.resource_process?.lease_token !== daemonRecord.lease_token
+      || (owner && (state.config?.runtime_owner?.owner_id !== owner.owner_id || path.resolve(state.config?.runtime_owner?.state_dir ?? "") !== path.resolve(owner.state_dir)))) {
+      throw Object.assign(new Error("Failed daemon state no longer matches the startup owner"), { code: "daemon_cleanup_identity_mismatch" });
+    }
+    const provider = state.provider_process;
+    if (provider) await runtimeProcess(config, "stop", { id: provider.id, "lease-token": provider.lease_token });
+  } catch (cleanup) {
+    original.details = { ...original.details, provider_cleanup_failed: errorRecord(cleanup) };
+  }
+}
+
 export async function stopProcessGroup(child, graceMs = 1_000) {
   if (!child?.pid) return;
   // Harness bridges are detached on Unix, so their own process group is the

package/dist/harness-runtime/lib/native-hook-command.d.mts

@@ -1 +1,3 @@
 export function invokeNativeHook(input: { bin: string; args: string[]; payload: unknown; home?: string | undefined; timeoutMs?: number }): Promise<Record<string, unknown> & { timing?: Record<string, number> }>;
+export function hookBudget(timeoutMs?: number, deadlineAt?: number | null): { remaining(phase: string): number };
+export function readNativeHookInput(stream: NodeJS.ReadStream, budget: { remaining(phase: string): number }, maxBytes?: number): Promise<string>;

package/dist/services/lifecycle-invocations.js

@@ -1302,8 +1302,6 @@ export async function awaitLifecycleInvocation(context, input) {
         checkCommand(initial, input.command);
         // A terminal command is immutable evidence.  Do not require a now-gone
         // caller payload merely to replay its recorded result.
-        if (["issued", "observed"].includes(initial.status))
-            await input.prepare?.();
     }
     catch (error) {
         if (!(error instanceof AppError) || !(["usage", "invocation_command_mismatch", "invocation_command_invalid"].includes(error.code) || error.details.phase === "prepare"))
@@ -1311,6 +1309,22 @@ export async function awaitLifecycleInvocation(context, input) {
         Object.assign(error.details, settleLifecyclePreparationRejection(context, input.id, error));
         throw error;
     }
+    if (["issued", "observed"].includes(initial.status)) {
+        try {
+            await input.prepare?.();
+        }
+        catch (error) {
+            if (!(error instanceof AppError) || (error.details.effect !== undefined && error.details.effect !== "no_effect"))
+                throw error;
+            const details = { ...error.details, phase: "prepare", effect: "no_effect" };
+            const recoverable = error.exitCode === 2 && ["validation", "schema_validation"].includes(error.code)
+                ? error.details.recoverable !== false
+                : isRetryableLifecycleRejection(error.code, details);
+            Object.assign(error.details, { phase: "prepare", effect: "no_effect", recoverable });
+            Object.assign(error.details, settleLifecyclePreparationRejection(context, input.id, error));
+            throw error;
+        }
+    }
     const timeoutMs = input.timeoutMs ?? 30000;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60000)
         throw new AppError("invocation_timeout_invalid", "Receipt timeout must be within 1..60000 ms", 1);

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

@@ -265,7 +265,7 @@ function finishPlanReviewOwned(context, input) {
     if (evidenceFailures.length)
         throw new AppError("review_evidence_invalid", "PLAN-REVIEW reviewer evidence is incomplete, stale, or not isolated", 2, { errors: evidenceFailures });
     if (decision.outcome !== "accepted")
-        throw new AppError("validation", "Unsupported PLAN-REVIEW decision outcome", 2, { outcome: decision.outcome });
+        throw new AppError("validation", "Unsupported PLAN-REVIEW decision outcome", 2, { outcome: decision.outcome, phase: "prepare", effect: "no_effect", recoverable: true });
     // A completed reviewer can legitimately report `blocked` when an upstream
     // plan uncertainty prevents it from approving its aspect. That is evidence
     // for the coordinator to classify and fix in this one review pass, not an
@@ -283,21 +283,21 @@ function finishPlanReviewOwned(context, input) {
         throw new AppError("review_evidence_invalid", "Reviewer findings and coordinator decisions must use unique known canonical references, with every material finding decided", 2, { material_finding_ids: materialFindingIds, decided_finding_ids: decisionFindingIds, unknown_decisions: unknownDecisions });
     if (needsCorrection) {
         if (decision.correction.status !== "applied")
-            throw new AppError("validation", "Reviewer findings require an in-place correction receipt", 2);
+            throw new AppError("validation", "Reviewer findings require an in-place correction receipt", 2, { phase: "prepare", effect: "no_effect", recoverable: true });
         if (decision.correction.previous_plan_revision !== reviewedPlanRevision || planRevision <= reviewedPlanRevision || decision.correction.changed_paths.length === 0)
-            throw new AppError("validation", "Applied PLAN correction must advance revision and list changed paths", 2, { reviewed_plan_revision: reviewedPlanRevision, final_plan_revision: planRevision });
+            throw new AppError("validation", "Applied PLAN correction must advance revision and list changed paths", 2, { reviewed_plan_revision: reviewedPlanRevision, final_plan_revision: planRevision, phase: "prepare", effect: "no_effect", recoverable: true });
     }
     else if (decision.correction.status !== "not_required" || planRevision !== reviewedPlanRevision || currentPlanChecksum !== contextFile.system?.plan_checksum) {
-        throw new AppError("validation", "A clean PLAN review must not claim an unverified correction", 2);
+        throw new AppError("validation", "A clean PLAN review must not claim an unverified correction", 2, { phase: "prepare", effect: "no_effect", recoverable: true });
     }
     const prepared = prepareVnextPlanArtifacts(context, { projectRoot, workspaceRoot: run.workspace_root, runId: run.id, home, protocols: protocolIdsForReview(home) });
     if (prepared.failures.length)
-        throw new AppError("validation", "Corrected PLAN artifacts have validation errors", 2, { errors: prepared.failures });
+        throw new AppError("validation", "Corrected PLAN artifacts have validation errors", 2, { errors: prepared.failures, phase: "prepare", effect: "no_effect", recoverable: true });
     if (needsCorrection) {
         // Regeneration above is authoritative. A valid PLAN correction need not
         // change the derived CODE tasks (for example, a clarified explanation).
         if (decision.correction.changed_paths.some((item) => item.endsWith("code-work-batch.json")))
-            throw new AppError("validation", "Generated CODE batch must not be listed as an agent-authored correction", 2, { changed_paths: decision.correction.changed_paths });
+            throw new AppError("validation", "Generated CODE batch must not be listed as an agent-authored correction", 2, { changed_paths: decision.correction.changed_paths, phase: "prepare", effect: "no_effect", recoverable: true });
     }
     const finalPlanChecksum = planSetChecksum(home, run.workspace_root);
     const finalBatchChecksum = prepared.batchChecksum;
@@ -358,7 +358,7 @@ function reviewGroups(home, workspaceRoot) {
                     if (dependencyGroup && dependencyGroup !== key)
                         dependencies.add(dependencyGroup);
                 }
-            groups.push({ key, protocol_id: protocolId, aspect_ids: group.aspect_ids, depends_on: [...dependencies].sort(), task: `Review PLAN group ${key}: ${group.aspect_ids.join(", ")}. Read run://${path.basename(home)}/03-plan/${protocolId}/aspect-map.json and the referenced plan. Try to falsify ambiguous behavior and missing verification. For every selected check that starts fixture/reset, service, or client processes, verify that they share the intended data/configuration world and that any runtime entrypoint requiring change is explicit in a Work task and verification and ordered before its consumer. planned_write_areas are coordination hints, not ownership. Do not edit plan or product files. Return one aspect entry for every assigned aspect, with exact evidence references and concise findings. Finish with the JSON contract supplied in your work prompt.` });
+            groups.push({ key, protocol_id: protocolId, aspect_ids: group.aspect_ids, depends_on: [...dependencies].sort(), task: `Review PLAN group ${key}: ${group.aspect_ids.join(", ")}. Read run://${path.basename(home)}/03-plan/${protocolId}/aspect-map.json and .memory-bank/protocol/${protocolId}/plan.json under workspace_root. Cite the PLAN using that workspace-relative path, not a run:// ref. Try to falsify ambiguous behavior and missing verification. For every selected check that starts fixture/reset, service, or client processes, verify that they share the intended data/configuration world and that any runtime entrypoint requiring change is explicit in a Work task and verification and ordered before its consumer. planned_write_areas are coordination hints, not ownership. Do not edit plan or product files. Return one aspect entry for every assigned aspect, with exact evidence references and concise findings. Finish with the JSON contract supplied in your work prompt.` });
         }
     }
     return groups;

package/dist/services/vnext-plan.js

@@ -126,7 +126,7 @@ export function prepareVnextPlanFinish(context, input) {
     assertProtocolWorkspace(run.workspace_root, protocols);
     const prepared = prepareVnextPlanArtifacts(context, { projectRoot, workspaceRoot: run.workspace_root, runId: run.id, home, protocols });
     if (prepared.failures.length)
-        throw new AppError("validation", "PLAN artifacts have validation errors", 2, { errors: prepared.failures });
+        throw new AppError("validation", "PLAN artifacts have validation errors", 2, { errors: prepared.failures, phase: "prepare", effect: "no_effect", recoverable: true });
     return prepared;
 }
 export function finishVnextPlan(context, input) {
@@ -148,7 +148,7 @@ function finishVnextPlanOwned(context, input) {
     const batch = path.join(root, "code-work-batch.json");
     const prepared = input.prepared ?? prepareVnextPlanFinish(context, input);
     if (prepared.failures.length)
-        throw new AppError("validation", "PLAN artifacts have validation errors", 2, { errors: prepared.failures });
+        throw new AppError("validation", "PLAN artifacts have validation errors", 2, { errors: prepared.failures, phase: "prepare", effect: "no_effect", recoverable: true });
     const work = context.db.get("SELECT work_id FROM works WHERE project_id = ? AND run_id = ? AND task = ? AND status = 'running' ORDER BY created_at DESC LIMIT 1", [project.id, run.id, planTask]);
     if (!work)
         throw new AppError("invalid_work_state", "PLAN has no running Work", 1);

package/dist/services/vnext-protocolize.js

@@ -183,11 +183,19 @@ export function finishVnextProtocolize(context, input) {
     const resultFile = prepareProtocolizeResultPath(requireRunHome(run), input.resultFile);
     const result = input.result ?? readResult(resultFile, { projectRoot, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: requireRunHome(run) });
     validateSchema({ schemaName: "vnext-protocolize-result", file: resultFile, data: result, projectRoot, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: requireRunHome(run) });
-    if (result.outcome !== "protocolized")
-        throw new AppError("validation", "PROTOCOLIZE may finish only as protocolized; use stage pause for every user question", 2);
     const acceptedObligations = acceptedSpecifyObligations(context, projectRoot, run.id, path.join(requireRunHome(run), "01-specify", "specify.json"));
-    const obligations = effectiveObligations(result, acceptedObligations);
-    validateDelivery(projectRoot, result, obligations);
+    let obligations;
+    try {
+        if (result.outcome !== "protocolized")
+            throw new AppError("validation", "PROTOCOLIZE may finish only as protocolized; use stage pause for every user question", 2);
+        obligations = effectiveObligations(result, acceptedObligations);
+        validateDelivery(projectRoot, result, obligations);
+    }
+    catch (error) {
+        if (!(error instanceof AppError) || error.code !== "validation" || error.exitCode !== 2)
+            throw error;
+        throw new AppError(error.code, error.message, error.exitCode, { ...error.details, phase: "prepare", effect: "no_effect", recoverable: true });
+    }
     const resolvedPolicy = requireVnextWorkspaceRoute({ projectRoot, runId: run.id, runHome: requireRunHome(run), workspaceRoot: run.workspace_root, stage: "protocolize" });
     const receipt = readWorkspaceRouteReceipt(root);
     const workspaceRoot = run.workspace_root;

package/package.json

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