@deksden-com/dd-flow-cli 0.9.0-beta.105 → 0.9.0-beta.107

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @deksden-com/dd-flow-cli
 
+## 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
+
+- Keep all Stage and Work lifecycle commands attached to their shell process until final output arrives, including HITL resume and standalone launch prompts. Resolve a model-facing command's hidden RUN from its issued authority when checking Antigravity workspace routing. Reserve the SQLite writer before reading and publishing the RUN projection so concurrent reviewer completions cannot invalidate it.
+
 ## 0.9.0-beta.105
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.105",
-  "cli_commit": "e55ba4f273ae0873e06ebe9ea75e6a6e1eb8b095",
-  "built_at": "2026-09-26T22:58:06.111Z",
+  "cli_version": "0.9.0-beta.107",
+  "cli_commit": "b1e4fba26b8d9dea7b9b4f6de05aec6be3e21dc2",
+  "built_at": "2026-09-27T03:02:31.051Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

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/delegation-instructions.d.mts

@@ -3,6 +3,7 @@ export type DelegationInput = { harness: string; stage: string; capacity: number
 export function delegationAdapter(harness: string): string | null;
 export function delegationContract(harness: string): string;
 export const lifecycleRetryInstruction: string;
+export const lifecycleCommandCompletionInstruction: string;
 export const stageLifecycleInstruction: string;
 export function workerDelegationTask(input: { workId: string; startCommand: string; launchPolicy?: string }): string;
 export function renderDelegationInstructions(input: DelegationInput): string;

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

@@ -49,7 +49,9 @@ export function delegationContract(harness) {
   return `dd-flow/delegation/${key}@${key === "codex" ? 2 : 1}`;
 }
 
-export const lifecycleRetryInstruction = "A failure is not permission to replay a lifecycle command. For proven effect=no_effect with recoverable=true and retry_command, correct the input and execute that exact issued successor. A check failure can retain receipts while leaving Work running: correct the evidenced cause first, then use the CLI's exact retry_command for an intentional fresh check attempt; never replay a check merely because Work is unsettled. If continuation.kind=repair_required, or a successful result has outcome=repair_required and a repair Work ID, end this Turn for the registered repair child; use any retry_command only after that repair settles and verification is refreshed. Unknown effects require reconciliation, never replay. A committed effect without an explicit continuation is not retryable. A native shell launch refusal before the CLI starts permits correcting only that shell-form error and retrying the same exact command. Otherwise report the primary error and stop; never invent IDs, call hooks directly, or run status as a substitute.";
+export const lifecycleCommandCompletionInstruction = "A shell tool may yield before the lifecycle process exits. Retain and poll its exact process/session handle to completion, including inside a tool wrapper; empty interim output is not a CLI result. Read final stdout or response_file before deciding continuation, and never reissue the command while it is pending.";
+
+export const lifecycleRetryInstruction = `${lifecycleCommandCompletionInstruction} A failure is not permission to replay a lifecycle command. For proven effect=no_effect with recoverable=true and retry_command, correct the input and execute that exact issued successor. A check failure can retain receipts while leaving Work running: correct the evidenced cause first, then use the CLI's exact retry_command for an intentional fresh check attempt; never replay a check merely because Work is unsettled. If continuation.kind=repair_required, or a successful result has outcome=repair_required and a repair Work ID, end this Turn for the registered repair child; use any retry_command only after that repair settles and verification is refreshed. Unknown effects require reconciliation, never replay. A committed effect without an explicit continuation is not retryable. A native shell launch refusal before the CLI starts permits correcting only that shell-form error and retrying the same exact command. Otherwise report the primary error and stop; never invent IDs, call hooks directly, or run status as a substitute.`;
 
 export const stageLifecycleInstruction = [
   "The project root identifies this RUN; use the Stage packet's declared execution workspace and absolute artifact paths. Do not change a native Session's working directory to a workspace provisioned for a later Stage.",

package/dist/services/controller-fanout.js

@@ -3,7 +3,7 @@ import { getVnextFanoutStatus, observeVnextNativeChildren, reconcileVnextFanout,
 import { getFlowRunVariables } from "./runs.js";
 import { dispatchVnextPlanReview } from "./vnext-plan-review.js";
 import { resolveExecutionPolicy } from "./execution-policy.js";
-import { renderDelegationInstructions, stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
+import { lifecycleCommandCompletionInstruction, renderDelegationInstructions, stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 import { assertWorkLaunchReady } from "./work-registry.js";
 function semanticCompletionPrompt(stage, completed) {
     const task = stage === "plan-review"
@@ -30,6 +30,14 @@ export function controllerStageEntryPrompt(stage, command) {
         stageLifecycleInstruction
     ].join("\n\n");
 }
+export function controllerStageResumePrompt(pauseId, command) {
+    return [
+        `The user supplied the raw answer for pause ${pauseId}. Your first tool call must be this exact standalone command:`,
+        command,
+        "Do not alter the answer. Follow the returned packet, then stop at this Stage boundary.",
+        stageLifecycleInstruction
+    ].join("\n\n");
+}
 /** The shared controller owns this former eval-only Work-graph decision. */
 export async function nextControllerFanout(context, input) {
     // Tree settlement is not a Work result. Keep these children visible to the
@@ -62,7 +70,7 @@ export async function nextControllerFanout(context, input) {
         if (fanout.state === "dispatch_required" || fanout.state === "capacity_required")
             return { kind: "wait", reason: "qualified_capacity_required" };
     }
-    const prompt = (action, text) => ({ kind: "prompt", action, prompt: text, fingerprint: JSON.stringify({ stage: input.stage, parent: fanout.parent_work_id, state: fanout.state, graph: fanout.graph_revision }) });
+    const prompt = (action, text) => ({ kind: "prompt", action, prompt: action === "dispatch_work" ? text : `${text}\n\n${lifecycleCommandCompletionInstruction}`, fingerprint: JSON.stringify({ stage: input.stage, parent: fanout.parent_work_id, state: fanout.state, graph: fanout.graph_revision }) });
     if (fanout.state === "coordinator_required")
         return prompt("materialize_graph", `Continue the current ${input.stage} Stage using its authoritative packet. Materialize only its required Work graph with real dependencies. Do not launch children, finish the Stage, or start a successor. Return after registering the graph; the runtime will dispatch its ready Work.`);
     if (fanout.works.failed || fanout.works.cancelled)

package/dist/services/external-work-launch.js

@@ -15,6 +15,7 @@ import { managedInvocationContext } from "./lifecycle-invocations.js";
 import { reviewExecutionCopyHash, reviewSourceFilter, reviewSourceHash, reviewSourcePaths } from "./review-copy.js";
 import { workspaceGitFiles } from "./workspace-files.js";
 import { qualifyAgyHooks } from "../harness-runtime/lib/dd-agy-daemon.mjs";
+import { lifecycleRetryInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 /**
  * Creates an external provider root for one already-created Work.  The launch
  * is not a Work claim: only the worker's trusted `work start` hook binds it.
@@ -106,7 +107,7 @@ export async function launchExternalWork(context, input) {
         if (reviewCopy && reviewSourceHash(run.workspace_root, reviewInputs, reviewBase) !== reviewCopy.source_sha256)
             throw new AppError("read_only_input_changed", "Authoritative review workspace changed after the execution copy was made", 2, { work_id: work.work_id });
         const promptFile = path.join(root, "launch.md");
-        fs.writeFileSync(promptFile, `Start the assigned Work now. Your first tool call must be this exact standalone command:\n\n${workStartCommand(runtimeContext, work)}\n\nUse the packet returned by that command. Do not claim another Work or run this command more than once.${isolatedWorkspace ? `\n\nThe review copy has no .git. Read the captured status/diff or gitless note in ${path.join(isolatedWorkspace, ".dd-flow", "review-evidence")}; do not run Git inside the copy.\n` : "\n"}`);
+        fs.writeFileSync(promptFile, `Start the assigned Work now. Your first tool call must be this exact standalone command:\n\n${workStartCommand(runtimeContext, work)}\n\nUse the packet returned by that command. Do not claim another Work or run this command more than once.\n\n${lifecycleRetryInstruction}${isolatedWorkspace ? `\n\nThe review copy has no .git. Read the captured status/diff or gitless note in ${path.join(isolatedWorkspace, ".dd-flow", "review-evidence")}; do not run Git inside the copy.\n` : "\n"}`);
         const prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60_000);
         assertRunMutationAllowed(context, work.project_id, work.run_id, generation);
         context.db.run("UPDATE work_launches SET status = 'start_requested', provider_session_id = ?, adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [sessionId, JSON.stringify({ create: created, prompt: prompted }), context.now(), operationId]);

package/dist/services/hooks.js

@@ -12,7 +12,7 @@ import { appendAudit } from "./audit.js";
 import { prepareTextFile, prepareJsonText, prepareError } from "../cli/input-preparation.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
 import { assertRecoveryHookCurrent } from "./run-recovery.js";
-import { observeLifecycleInvocation } from "./lifecycle-invocations.js";
+import { observeLifecycleInvocation, observedLifecycleInvocation } from "./lifecycle-invocations.js";
 import { commandHasOption, commandOption, commandPosition, shellSuffixOffset, parseLifecycleCommand, lifecycleCommandFromPayload, continuationCommand } from "./lifecycle-command.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { activeFlowSessionsForProject, recordFlowSessionObservation } from "./sessions.js";
@@ -670,7 +670,7 @@ export function handleDroidEvent(context, input) {
     return handleControlledToolEvent(context, input, event, "droid-cli");
 }
 /** Stable project identity is not the native Session's execution workspace. */
-function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary) {
+function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId) {
     if (facts?.bootstrapStageStart)
         return projectRoot;
     const project = context.db.get("SELECT id FROM projects WHERE root = ?", [projectRoot]);
@@ -686,7 +686,7 @@ function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId,
                 throw error;
         }
     }
-    const reference = work?.run_id ?? facts?.runId ?? auxiliary?.args.options.get("run")?.[0] ?? auxiliary?.args.positional[2];
+    const reference = work?.run_id ?? facts?.runId ?? auxiliary?.args.options.get("run")?.[0] ?? auxiliary?.args.positional[2] ?? issuedRunId;
     if (!reference)
         return projectRoot;
     const run = context.db.get("SELECT id, run_root, workspace_root FROM runs WHERE project_id = ? AND (id = ? OR short_id = ?)", [project.id, reference, reference]);
@@ -774,7 +774,9 @@ function handleControlledToolEvent(context, input, event, harness) {
     const auxiliary = continuationCommand(command);
     if (!lifecycle && !auxiliary)
         return { ok: true, observed: false, reason: "event_not_participating" };
-    const expectedCwd = controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary);
+    const issuedRunId = lifecycle && !lifecycle.runId && !lifecycle.workId && !lifecycle.bootstrapStageStart
+        ? observedLifecycleInvocation(context, command, daemonId)?.scope.runId : null;
+    const expectedCwd = controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId);
     if (observedCwd !== expectedCwd) {
         throw new AppError(`${errorPrefix}_directory_mismatch`, `${label} ${agy ? "launch route" : "Session directory"} does not match the assigned execution workspace`, 1, { expected: expectedCwd, actual: observedCwd, ...(agy ? { actual_provenance: stringValue(event.cwd_provenance) ?? "unknown" } : {}) });
     }

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/merge-server.js

@@ -1,4 +1,5 @@
 import { managedInvocationContext, managedLifecycleCommand } from "./lifecycle-invocations.js";
+import { stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -119,7 +120,7 @@ async function dispatch(context, input) {
         retain();
         runtimeContext = managedInvocationContext(runtimeContext, { harness: runtimeHarness(input.profile), stateDir, sessionId, projectRoot: run.project_root, runId: input.request.run_id, generation });
         const stageCommand = managedLifecycleCommand(runtimeContext, `${flowCommand(runtimeContext)} stage start ${input.request.run_id} --stage merge --project-root ${JSON.stringify(run.project_root)} --json --progress-jsonl`);
-        fs.writeFileSync(promptFile, `Start the assigned MERGE stage now. Your first tool call must be this exact standalone command:\n\n${stageCommand}\n\nTrust and follow the complete stage packet it returns. Continue through merge apply and stage finish. Stop only when the stage reaches a terminal result or explicitly requests user/operator action.\n`);
+        fs.writeFileSync(promptFile, `Start the assigned MERGE stage now. Your first tool call must be this exact standalone command:\n\n${stageCommand}\n\nTrust and follow the complete stage packet it returns. Continue through merge apply and stage finish. Stop only when the stage reaches a terminal result or explicitly requests user/operator action.\n\n${stageLifecycleInstruction}\n`);
         const prompted = await adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60 * 1000, `MERGE ${input.request.merge_request_id} Session ${sessionId} is still running`);
         Object.assign(retained, { response: prompted });
         retain();

package/dist/services/run-controller.js

@@ -23,7 +23,7 @@ import { assertManagedProcessLease, confirmManagedProcess, heartbeatManagedProce
 import { readNativeDaemonState, requireManagedDaemonBinding } from "./managed-daemon-binding.js";
 import { initCodexHome } from "./hooks.js";
 import { launchExternalWork } from "./external-work-launch.js";
-import { controllerNativeChildren, controllerStageEntryPrompt, nextControllerFanout } from "./controller-fanout.js";
+import { controllerNativeChildren, controllerStageEntryPrompt, controllerStageResumePrompt, nextControllerFanout } from "./controller-fanout.js";
 import { claimQueuedMergeRequest } from "./merge-server.js";
 import { prepareVnextCodeWorkspace } from "./vnext-code.js";
 import { requireRun, requireController, controllerReceipt, appendEvent, saveState, retainControllerContinuation, digest, digestBytes, errorRecord } from "./run-controller-state.js";
@@ -613,7 +613,7 @@ async function executeController(context, row, manifest, state, assertOwnership,
                 // The accepted answer is logical intent; only its generation-bound
                 // adapter operation represents a physical dispatch that stop must drain.
                 const command = managedLifecycleCommand(executionContext, `${flowCommand(executionContext)} stage resume ${run.id} --stage ${next.stage} --work ${input.work_id} --project-root ${quote([run.project_root])} --answer-file ${quote([input.file])} --json`, { replaceUnobservedAnswer: true });
-                const receipt = await prompt(state.sessions[state.current_session], `The user supplied the raw answer for pause ${pause.id}. Your first tool call must be this exact standalone command:\n\n${command}\n\nDo not alter the answer. Follow the returned packet, then stop at this Stage boundary.`, `${answer.operation_id}:prompt:${row.generation}`);
+                const receipt = await prompt(state.sessions[state.current_session], controllerStageResumePrompt(pause.id, command), `${answer.operation_id}:prompt:${row.generation}`);
                 const afterAnswer = getFlowRunStatus(executionContext, { projectRoot: run.project_root, runId: run.id });
                 if (afterAnswer.index.stage_runs.some(stage => stage.status === "paused" && stage.pause?.id === pause.id)) {
                     throw new AppError("controller_answer_not_applied", "The answer Turn completed without resuming the assigned HITL pause", 1, { pause_id: pause.id, operation_id: answer.operation_id, stage: next.stage, effect: "no_progress" });

package/dist/services/run-projection.js

@@ -3,6 +3,11 @@ import { reconcileSessionCoverageRows } from "../domain/session-coverage.js";
 import { publicSessionIdentity } from "./session-identity.js";
 import { publishRunProjections } from "./runs.js";
 export function refreshRunSessionProjection(context, projectId, runId) {
+    // Review children can finish concurrently in separate processes. Reserve the
+    // writer before reading the RUN index so a sibling cannot invalidate it.
+    context.db.writeTransaction(() => refreshRunSessionProjectionLocked(context, projectId, runId), "run-projection.refresh");
+}
+function refreshRunSessionProjectionLocked(context, projectId, runId) {
     const run = context.db.get("SELECT id, flow_kind, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]);
     if (!run)
         return;
@@ -60,12 +65,10 @@ export function refreshRunSessionProjection(context, projectId, runId) {
         index.workers = workers;
     index.updated_at = context.now();
     index.runtime_revision = typeof index.runtime_revision === "number" ? index.runtime_revision + 1 : 1;
-    context.db.writeTransaction(() => {
-        const updated = context.db.run("UPDATE runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ? AND index_json = ?", [JSON.stringify(index), index.updated_at, projectId, runId, run.index_json]);
-        if (updated.changes !== 1)
-            throw new Error("RUN projection changed during preparation");
-        context.db.afterCommit(() => publishRunProjections(context, projectId, runId));
-    }, "run-projection.refresh");
+    const updated = context.db.run("UPDATE runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ? AND index_json = ?", [JSON.stringify(index), index.updated_at, projectId, runId, run.index_json]);
+    if (updated.changes !== 1)
+        throw new Error("RUN projection changed during preparation");
+    context.db.afterCommit(() => publishRunProjections(context, projectId, runId));
 }
 function planProjection(context, projectId, protocolId, projectRoot, index) {
     const binding = context.db.get("SELECT plan_id, plan_path, plan_revision, plan_sha256 FROM plan_bindings WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);

package/dist/services/run-recovery-runtime.js

@@ -7,6 +7,7 @@ import { acceptanceCommand, recoveryGuard, recoveryPacketReceipt, requireRecover
 import { managedProcessBinding, processIsAlive, resourceHome } from "./managed-processes.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { requireManagedDaemonBinding } from "./managed-daemon-binding.js";
+import { lifecycleRetryInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 /** Pin retained Session loading and its first acknowledgement Turn, never a general fence bypass. */
 export function prepareRunRecoveryDispatch(context, input) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(input.operationId) || !path.isAbsolute(input.stateDir))
@@ -37,7 +38,7 @@ export function prepareRunRecoveryDispatch(context, input) {
     });
     let dispatch = prepared.dispatch;
     if (!dispatch) {
-        const prompt = `Resume this retained RUN in its existing native Session. Your first tool call must be this exact standalone command:\n\n${acceptanceCommand(context, run.id, prepared.guard.recovery_id, run.project_root)}\n\nFollow the verified recovery packet returned by that command. Preserve completed Work and existing HITL; do not start a successor Stage yourself. Stop at the Stage or declared Work-graph boundary.\n`;
+        const prompt = `Resume this retained RUN in its existing native Session. Your first tool call must be this exact standalone command:\n\n${acceptanceCommand(context, run.id, prepared.guard.recovery_id, run.project_root)}\n\nFollow the verified recovery packet returned by that command. Preserve completed Work and existing HITL; do not start a successor Stage yourself. Stop at the Stage or declared Work-graph boundary.\n\n${lifecycleRetryInstruction}\n`;
         dispatch = { process_id: prepared.record.id, owner_id: prepared.record.owner_id, state_dir: input.stateDir, daemon_id: prepared.binding.daemon_id, operation_id: input.operationId, resume_operation_id: `${input.operationId}:load`, prompt_sha256: crypto.createHash("sha256").update(prompt).digest("hex"), prompt };
     }
     const registry = prepared.record ? getResourceDatabase(resourceHome(context)) : undefined;

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.105",
+  "version": "0.9.0-beta.107",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {