@deksden-com/dd-flow-cli 0.9.0-beta.123 → 0.9.0-beta.127

package/dist/services/stage-pause.js

@@ -14,6 +14,7 @@ import { appendFlowRunTimelineEvent, pauseFlowRunStage, resumeFlowRunStage } fro
 import { bindSessionForResume, refreshRunWorkProjection } from "./work-registry.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
 import { runtimeCommand } from "./runtime-command.js";
+import { prepareAgentOutputFile } from "../storage/agent-output.js";
 export { flowCommand } from "./runtime-command.js";
 export function prepareStagePause(context, input) {
     if (typeof input.question !== "string" || !input.question.trim())
@@ -38,6 +39,7 @@ export function pauseStageForUser(context, input) {
     const questionPath = path.join(pauseRoot, "question.md");
     fs.mkdirSync(pauseRoot, { recursive: true });
     publishImmutableInput(questionPath, Buffer.from(question), "hitl_question_conflict");
+    const answerInputPath = prepareAgentOutputFile(path.join(pauseRoot, "answer-input.md"));
     const now = context.now();
     context.db.writeTransaction(() => {
         const paused = context.db.run("UPDATE works SET status = 'paused', updated_at = ? WHERE work_id = ? AND status = 'running'", [now, work.work_id]);
@@ -46,7 +48,6 @@ export function pauseStageForUser(context, input) {
         pauseFlowRunStage(context, { projectRoot, runId: run.id, stage: stage.stage, workId: work.work_id, pauseId, questionPath });
         context.db.afterCommit(() => refreshRunWorkProjection(context, project.id, run.id));
     });
-    const answerInputPath = path.join(pauseRoot, "answer-input.md");
     const resume = stageResumeCommand(context, { runId: run.id, stage: stage.stage, workId: work.work_id, projectRoot, answerInputPath });
     const resumeTemplate = `Write the complete user answer exactly to ${quote([answerInputPath])}, then run:\n${resume}`;
     return {
@@ -146,7 +147,7 @@ export function resumeStageAfterUser(context, input) {
 export function stagePauseCommand(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = requireRun(context, project.id, input.runId);
-    const questionInputPath = path.join(requireRunHome(run), "works", input.workId, "question-input.md");
+    const questionInputPath = prepareAgentOutputFile(path.join(requireRunHome(run), "works", input.workId, "question-input.md"));
     return managedLifecycleCommand(context, runtimeCommand(context, ["stage", "pause", shortEntityReference(input.runId), "--stage", input.stage, "--work", shortEntityReference(input.workId), "--question-file", questionInputPath, "--project-root", input.projectRoot, "--json"]));
 }
 /** Render separate file-write and lifecycle-call instructions for HITL. */

package/dist/services/usage.js

@@ -369,7 +369,7 @@ function usageRowsForPhysicalSessions(context, links, observedAt, stage) {
             : completedTurn?.completed_at ?? sessionLinks.map((item) => item.completed_at ?? observedAt).sort().at(-1);
         const endedAt = stage?.completedAt ?? (Date.parse(naturalEnd) > Date.parse(observedAt) ? observedAt : naturalEnd);
         const harnessUsage = isExternalHarness(link.harness)
-            ? readHarnessUsageWindow(context, link.harness, link.project_id, link.provider_session_id, startedAt, endedAt, observedAt)
+            ? readHarnessUsageWindow(context, link.harness, link.project_id, link.provider_session_id, startedAt, endedAt, observedAt, Boolean(stage))
             : null;
         const parsed = harnessUsage ?? readCodexTranscriptWindow(link.transcript_path, nativeSessionId(link), startedAt, endedAt);
         return {
@@ -393,18 +393,29 @@ function hasInclusiveUsageSnapshot(context, projectId, harness, providerSessionI
         return false;
     return Boolean(context.db.get("SELECT 1 FROM harness_usage_snapshots WHERE project_id = ? AND harness = ? AND provider_session_id = ? AND usage_scope = 'execution_tree_inclusive' AND observed_at <= ? LIMIT 1", [projectId, harness, providerSessionId, observedAt]));
 }
-function readHarnessUsageWindow(context, harness, projectId, providerSessionId, startedAt, endedAt, observedAt) {
+function readHarnessUsageWindow(context, harness, projectId, providerSessionId, startedAt, endedAt, observedAt, stageWindow) {
     if (!providerSessionId)
         return { status: "not_observable", diagnostic: "provider_session_id_missing" };
     const snapshots = context.db.all(`SELECT completeness, observed_at, total_tokens, input_tokens, cache_read_input_tokens, cache_write_input_tokens, output_tokens, reasoning_output_tokens
        FROM harness_usage_snapshots
       WHERE project_id = ? AND harness = ? AND provider_session_id = ? AND observed_at <= ?
       ORDER BY observed_at, id`, [projectId, harness, providerSessionId, observedAt]);
-    const last = snapshots.find((snapshot) => Date.parse(snapshot.observed_at) > Date.parse(endedAt))
+    const last = (!stageWindow ? snapshots.find((snapshot) => Date.parse(snapshot.observed_at) > Date.parse(endedAt)) : undefined)
         ?? snapshots.filter((snapshot) => Date.parse(snapshot.observed_at) <= Date.parse(endedAt)).at(-1);
     const before = snapshots.filter((snapshot) => Date.parse(snapshot.observed_at) <= Date.parse(startedAt)).at(-1);
     if (!last || !before || last === before)
         return { status: "not_yet_emitted", diagnostic: `${harness}_usage_window_incomplete` };
+    // Cumulative counters outside an attempt's boundaries cannot establish its
+    // spend: adjacent attempts would otherwise charge overlapping intervals.
+    if (stageWindow && (Date.parse(before.observed_at) !== Date.parse(startedAt)
+        || Date.parse(last.observed_at) !== Date.parse(endedAt)
+        || before.completeness !== "complete" || last.completeness !== "complete")) {
+        return { status: "not_observable", diagnostic: `${harness}_stage_window_unconfirmed` };
+    }
+    if (stageWindow && ["total_tokens", "input_tokens", "cache_read_input_tokens", "cache_write_input_tokens", "output_tokens", "reasoning_output_tokens"]
+        .some(key => last[key] !== null && before[key] !== null && last[key] < before[key])) {
+        return { status: "not_observable", diagnostic: `${harness}_stage_counter_reset` };
+    }
     if (harness === "droid-cli" && (last.completeness !== "complete" || before.completeness !== "complete"))
         return { status: "not_observable", diagnostic: "droid-cli_usage_window_partial" };
     const delta = (value, baseline) => value === null || baseline === null ? null : Math.max(0, value - baseline);

package/dist/services/verification-matrix.js

@@ -7,6 +7,7 @@ import { checkReceiptEvidenceValid, checkReceipts, effectiveCheckDeclarations }
 import { acceptStagePacket, prepareStagePacket, publishStagePacket, resolveStagePublicationPath } from "./stage-report-renderer.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
 export const verificationMatrixContract = "dd-flow/verification-matrix@1";
+export const finalCheckCoverageContract = "dd-flow/final-check-coverage@1";
 /** A view of already validated facts: never a gate or a receipt selector. */
 export function buildVerificationMatrix(input) {
     const sourceCatalog = new Map();
@@ -178,6 +179,10 @@ export function prepareRunVerificationMatrix(context, input) {
     let finalBindings;
     if (input.stage === "merge") {
         const gate = readSource("merge_gate", "run", "07-merge/merge-gate.json");
+        if (index.final_check_coverage_contract === finalCheckCoverageContract) {
+            for (const role of final ? ["baseline", "source", "target"] : ["baseline", "source"])
+                readSource(`check_profile_${role}`, "run", `07-merge/check-profile-${role}.json`);
+        }
         const semanticRefs = new Set(plans.flatMap(plan => plan.acceptance.flatMap(entry => entry.check_refs.map(id => `${plan.protocol_id}/${id}`))));
         policyChecks = gate.checks.filter(check => !semanticRefs.has(check.canonical_ref ?? check.id));
         if (final) {
@@ -224,6 +229,20 @@ export function prepareRunVerificationMatrix(context, input) {
             return { id: check.id, canonical_ref: ref, declaration: check, result: portable, disposition: "unavailable", reason: "receipt_file_missing" };
         const bytes = fs.readFileSync(receiptFile);
         sources.push({ role: `receipt:${ref}`, root: "run", path: portable.receipt_path, sha256: digest(bytes) });
+        const retainedReceipt = JSON.parse(bytes.toString("utf8"));
+        for (const artifact of retainedReceipt.artifacts ?? []) {
+            if (path.isAbsolute(artifact.path) || artifact.path.includes("\0") || artifact.path.split(/[\\/]/).includes(".."))
+                throw new AppError("verification_matrix_path_invalid", "Native artifact must remain inside its evidence directory", 1, { path: artifact.path });
+            const artifactPath = slash(path.join(path.dirname(portable.receipt_path), "artifacts", artifact.path));
+            const artifactFile = safePath(home, artifactPath);
+            if (fs.existsSync(artifactFile))
+                sources.push({ role: `artifact:${ref}:${artifact.path}`, root: "run", path: artifactPath, sha256: digest(fs.readFileSync(artifactFile)) });
+        }
+        if (receipt.status !== "aborted" && fs.existsSync(receipt.completion_path)) {
+            const completionPath = portable.completion_path;
+            const completionFile = safePath(home, completionPath);
+            sources.push({ role: `completion:${ref}`, root: "run", path: completionPath, sha256: digest(fs.readFileSync(completionFile)) });
+        }
         return { id: check.id, canonical_ref: ref, declaration: check, result: portable, disposition: valid ? "retained" : "unavailable", ...(!valid ? { reason: "receipt_evidence_invalid" } : {}) };
     });
     const works = context.db.all("SELECT work_id, payload_json FROM works WHERE project_id = ? AND run_id = ?", [input.projectId, input.runId]).flatMap(work => {
@@ -238,6 +257,8 @@ export function prepareRunVerificationMatrix(context, input) {
     const markdown = prepareStagePacket(safePath(home, `${root}/verification-matrix.md`), Buffer.from(renderVerificationMatrix(matrix)));
     packets.push(json, markdown);
     const metadata = { contract: verificationMatrixContract, role: header.role, completeness: header.completeness, source_fingerprint: matrix.header.source_fingerprint, json: { path: slash(path.relative(home, json.file)), sha256: json.sha256 }, markdown: { path: slash(path.relative(home, markdown.file)), sha256: markdown.sha256 } };
+    if (index.final_check_coverage_contract === finalCheckCoverageContract)
+        metadata.coverage_contract = finalCheckCoverageContract;
     const predecessors = (index.stage_runs ?? []).filter(item => item.stage !== input.stage && item.status === "done").map(item => ({ stage: item.stage, ...(item.attempt ? { attempt: item.attempt } : {}), ...(item.data_sha256 ? { data_sha256: item.data_sha256 } : {}) }));
     return { projectId: input.projectId, runId: input.runId, stage: input.stage, home, attempt, generation, packets, matrix, metadata, predecessors };
 }
@@ -297,6 +318,8 @@ export function latestRunVerificationMatrix(context, projectId, runId, stage, ro
         const md = { file: mdFile, bytes: mdBytes, sha256: paired.sha256 };
         const json = { file: packet.file, bytes, sha256: packet.sha256 };
         const metadata = { contract: verificationMatrixContract, role: matrix.header.role, completeness: matrix.header.completeness, source_fingerprint: matrix.header.source_fingerprint, json: { path: slash(path.relative(run.run_root, packet.file)), sha256: packet.sha256 }, markdown: { path: slash(path.relative(run.run_root, mdFile)), sha256: md.sha256 } };
+        if (index.final_check_coverage_contract === finalCheckCoverageContract)
+            metadata.coverage_contract = finalCheckCoverageContract;
         const sourcePackets = matrix.sources.filter(source => (source.role.startsWith("plan:") || source.role === "code_work_batch") && source.root === "run").map(source => {
             const file = safePath(run.run_root, source.path, false);
             const retained = rows.map(row => JSON.parse(row.payload_json)).find(item => item.run_id === runId && item.stage === stage && item.attempt === attempt && resolveStagePublicationPath(context, projectId, runId, item.file) === file && item.sha256 === source.sha256);
@@ -314,7 +337,13 @@ export function latestRunVerificationMatrix(context, projectId, runId, stage, ro
 }
 function portableReceipt(receipt, home) {
     const relative = (file) => slash(path.relative(home, safePath(home, path.relative(home, file))));
-    return { ...receipt, receipt_path: relative(receipt.receipt_path), completion_path: relative(receipt.completion_path), stdout_path: relative(receipt.stdout_path), stderr_path: relative(receipt.stderr_path), artifacts: receipt.artifacts.map(item => ({ ...item, path: relative(item.path) })) };
+    return { ...receipt, receipt_path: relative(receipt.receipt_path), completion_path: relative(receipt.completion_path), stdout_path: relative(receipt.stdout_path), stderr_path: relative(receipt.stderr_path), artifacts: receipt.artifacts.map(item => {
+            const artifactPath = path.isAbsolute(item.path) ? path.relative(path.join(path.dirname(receipt.receipt_path), "artifacts"), item.path) : item.path;
+            if (path.isAbsolute(artifactPath) || artifactPath.includes("\0") || artifactPath.split(/[\\/]/).includes(".."))
+                throw new AppError("verification_matrix_path_invalid", "Native artifact must remain inside its evidence directory", 1, { path: item.path });
+            safePath(home, path.join(path.dirname(relative(receipt.receipt_path)), "artifacts", artifactPath));
+            return { ...item, path: slash(artifactPath) };
+        }) };
 }
 function safePath(root, relative, inspectFilesystem = true) {
     if (path.isAbsolute(relative) || relative.split(/[\\/]/).includes(".."))

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

@@ -18,7 +18,7 @@ import { withStageSettlement, prepareFlowRunStageAttachment } from "./runs.js";
 import { vnextStageDirectory } from "../domain/stage-catalog.js";
 import { acceptStageReport, prepareStageReport } from "./stage-report-renderer.js";
 import { prepareRunVerificationMatrix, acceptVerificationMatrix, commitVerificationMatrixStart, resumeVerificationMatrix, verificationMatrixInstruction, latestRunVerificationMatrix, publishVerificationMatrix } from "./verification-matrix.js";
-import { applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
+import { currentStagePrompt, applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
 import { readFanoutDescriptor, writeFanoutDescriptor } from "./vnext-fanout.js";
 import { stageGraphScope } from "./stage-work-graph.js";
 import { prepareVnextMergeRequest } from "./vnext-merge.js";
@@ -26,6 +26,8 @@ import { validateVnextCodeHandoff } from "./vnext-plan.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
 import { prepareJsonFile, prepareOutputFile } from "../cli/input-preparation.js";
 import { reviewerSourceInputs, reviewerSourceInstruction } from "./review-copy.js";
+import { reviewDefEvidence } from "./review-deferral.js";
+import { stageSuccessor } from "./vnext-contracts.js";
 const stage = "code-review";
 const stageDir = vnextStageDirectory(stage);
 const baselineAspects = ["goal_traceability", "coding_standards_design_review", "verification_evidence_review"];
@@ -75,11 +77,11 @@ export function startVnextCodeReview(context, input, prepared = prepareVnextCode
     if (prepared.resumed) {
         if (effectiveMode(prepared.home, run).mode !== "off")
             resumeVerificationMatrix(context, project.id, run.id, stage);
-        const externalContext = applyExternalStageContext({ stageRoot: root, promptPath: existingPrompt, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+        const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath: existingPrompt, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
         const binding = bindStageCoordinatorWork(context, { workId: rootWork.work_id, hookEventId: input.hookEventId, stage, promptPath: existingPrompt, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
-        const prompt = fs.readFileSync(existingPrompt, "utf8");
+        const delivered = currentStagePrompt(context, existingPrompt);
         const orchestration = prepared.orchestration;
-        return { ok: true, resumed: true, run_id: run.id, stage, stage_status: prepared.prior, id: binding.work_session_id, prompt_path: existingPrompt, worker_prompt_markdown: prompt, ...(externalContext ? { external_context: externalContext } : {}), ...(orchestration ? { orchestration } : {}), next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
+        return { ok: true, resumed: true, run_id: run.id, stage, stage_status: prepared.prior, id: binding.work_session_id, ...delivered, ...(externalContext ? { external_context: externalContext } : {}), ...(orchestration ? { orchestration } : {}), next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
     }
     const { mode, cycle, groups, batch, items, template, checks, codeReportSha256 } = prepared;
     prepareFlowRunStageAttachment(context, { projectRoot, runId: run.id, stage, dir: stageDir, status: "running", dataSchemaId: "dd-flow/stage-report@1" }, true);
@@ -95,17 +97,17 @@ export function startVnextCodeReview(context, input, prepared = prepareVnextCode
         fs.writeFileSync(path.join(root, "decision.json"), `${JSON.stringify(disabledReviewDecision(), null, 2)}\n`);
         const prompt = `<stage_identity>\n- RUN: ${run.id}\n- stage: code-review\n- mode: off\n</stage_identity>\n\nCODE-REVIEW is disabled by the frozen RUN configuration. Finish with: ${finishCommand(context, run.id, projectRoot, path.join(root, "decision.json"))}\n${stageLifecycleInstruction}\n`;
         fs.writeFileSync(promptPath, prompt);
-        const externalContext = applyExternalStageContext({ stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+        const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
         const binding = bindStageCoordinatorWork(context, { workId: rootWork.work_id, hookEventId: input.hookEventId, stage, promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
         const attachmentInput = { projectRoot, runId: run.id, stage, dir: stageDir, status: "running", dataSchemaId: "dd-flow/stage-report@1" };
         attachFlowRunStage(context, attachmentInput, prepareFlowRunStageAttachment(context, attachmentInput));
-        return { ok: true, run_id: run.id, stage, mode: mode.mode, mode_source: mode.source, id: binding.work_session_id, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), ...(externalContext ? { external_context: externalContext } : {}), next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
+        return { ok: true, run_id: run.id, stage, mode: mode.mode, mode_source: mode.source, id: binding.work_session_id, ...currentStagePrompt(context, promptPath), ...(externalContext ? { external_context: externalContext } : {}), next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
     }
     const batchFile = path.join(root, "review-work-batch.json");
     fs.writeFileSync(batchFile, `${JSON.stringify(batch, null, 2)}\n`);
     const prompt = `${orchestratorPrompt(context, { projectRoot, run, root, rootWork, mode: mode.mode, groups, template, checks })}\n${stageLifecycleInstruction}\n${verificationMatrixInstruction(prepared.matrix?.metadata ?? null, prepared.home, "reviewing whether current evidence proves the accepted obligations")}\n`;
     fs.writeFileSync(promptPath, prompt);
-    const externalContext = applyExternalStageContext({ stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+    const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
     const binding = bindStageCoordinatorWork(context, { workId: rootWork.work_id, hookEventId: input.hookEventId, stage, promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
     const registered = addWorkBatch(context, { parentWorkId: rootWork.work_id, value: batch, prepared: items, stage, cycle });
     const orchestration = writeFanoutDescriptor(root, { stage, parent_work_id: rootWork.work_id, dispatch: "none", capacity_required: true, scope: stageGraphScope(context, project.id, run.id, stage) });
@@ -113,7 +115,7 @@ export function startVnextCodeReview(context, input, prepared = prepareVnextCode
     const attachment = prepareFlowRunStageAttachment(context, attachmentInput);
     commitVerificationMatrixStart(context, prepared.matrix, () => attachFlowRunStage(context, attachmentInput, attachment));
     appendFlowRunTimelineEvent(context, project.id, run.id, { type: "code_review_started", work_id: rootWork.work_id, mode: mode.mode, mode_source: mode.source, groups, registered });
-    return { ok: true, run_id: run.id, stage, mode: mode.mode, mode_source: mode.source, id: binding.work_session_id, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), ...(externalContext ? { external_context: externalContext } : {}), orchestration, review: { groups, works: registered }, next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
+    return { ok: true, run_id: run.id, stage, mode: mode.mode, mode_source: mode.source, id: binding.work_session_id, ...currentStagePrompt(context, promptPath), ...(externalContext ? { external_context: externalContext } : {}), orchestration, review: { groups, works: registered }, next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
 }
 export function prepareVnextCodeReviewRepair(context, input) {
     if (!Array.isArray(input.findingIds) || !input.findingIds.length || input.findingIds.some(id => typeof id !== "string" || !id.trim()))
@@ -196,6 +198,7 @@ export async function finishVnextCodeReview(context, input) {
     validateSchema({ schemaName: "code-review-decision", file: decisionFile, data: decision, projectRoot: run.workspace_root, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: home });
     const cycle = reviewContext.cycle ?? "initial";
     const reviewers = reviewerWorks(context, project.id, run.id, cycle);
+    const defEvidence = decision.findings.filter(item => item.disposition === "defer").map(item => reviewDefEvidence(run.workspace_root, item.def_id));
     if (mode !== "off") {
         assertCodeReviewCoverage(reviewGroups(home), reviewers);
         const incomplete = reviewers.filter((work) => work.status !== "completed");
@@ -204,6 +207,8 @@ export async function finishVnextCodeReview(context, input) {
         for (const work of reviewers)
             validateReviewerResult(context, work, run);
         const canonical = reviewDecisionForRepair(decision, reviewers);
+        if (reviewContext.accepted_decision && JSON.stringify(reviewContext.def_evidence ?? []) !== JSON.stringify(defEvidence))
+            throw new AppError("deferral_invalid", "Accepted DEF evidence changed during review repair", 2);
         const checkRefsByFinding = validateRepairChecks(context, { projectId: project.id, runId: run.id, decision: canonical.decision });
         let repairs = reviewRepairWorks(context, project.id, run.id, root, cycle);
         const frozenShaFile = path.join(root, ".decision-sha256");
@@ -215,7 +220,7 @@ export async function finishVnextCodeReview(context, input) {
             // Accept the value once. Repairs consume this decision, not a mutable
             // operator file. Reuse the existing context artifact and review cycle.
             const contextFile = path.join(root, "review-context.json"), temporary = `${contextFile}.tmp-${crypto.randomUUID()}`;
-            fs.writeFileSync(temporary, `${JSON.stringify({ ...reviewContext, accepted_decision: decision }, null, 2)}\n`);
+            fs.writeFileSync(temporary, `${JSON.stringify({ ...reviewContext, accepted_decision: decision, def_evidence: defEvidence }, null, 2)}\n`);
             fs.renameSync(temporary, contextFile);
             const repair = addVnextCodeReviewRepair(context, { projectRoot, runId: run.id, findingIds: fixIds, checkRefsByFinding, decisionReasonsByFinding: Object.fromEntries(canonical.decision.findings.map((item) => [item.finding_ref, item.reason])), objective: `Resolve accepted CODE-REVIEW findings: ${fixIds.join(", ")}` });
             const retained = latestRunVerificationMatrix(context, project.id, run.id, stage, "input");
@@ -263,6 +268,9 @@ export async function finishVnextCodeReview(context, input) {
     const prepareMerge = nextAction === "start_merge" ? prepareVnextMergeRequest(context, { projectRoot, runId: run.id, acceptedPaths }) : null;
     if (matrix)
         Object.assign(report.semantic, { verification_matrix: matrix.metadata });
+    if (JSON.stringify(defEvidence) !== JSON.stringify(decision.findings.filter(item => item.disposition === "defer").map(item => reviewDefEvidence(run.workspace_root, item.def_id))))
+        throw new AppError("deferral_invalid", "DEF evidence changed while final checks ran", 2);
+    Object.assign(report.semantic, { def_evidence: defEvidence });
     const preparedReport = prepareStageReport(report);
     const completionInput = { projectRoot, runId: run.id, stage, status: "done", data: "stage-report.json", dataSchemaId: "dd-flow/stage-report@1", report: "stage-report.md", stageReport: "stage-report.html", dataSha256: preparedReport.sha256, git: report.mechanical.git };
     withStageSettlement(context, () => {
@@ -286,7 +294,7 @@ export async function finishVnextCodeReview(context, input) {
         }
         refreshRunWorkProjection(context, project.id, run.id);
     });
-    return { ok: true, run_id: run.id, stage, outcome, report_path: path.join(root, "stage-report.json"), next_action: nextAction, ...(mergeRequest ? { merge_request: mergeRequest, next: { kind: "start_stage", stage: "merge", command: managedLifecycleCommand(context, runtimeCommand(context, ["stage", "start", run.id, "--stage", "merge", "--project-root", projectRoot, "--json", "--progress-jsonl"])) } } : {}) };
+    return { ok: true, run_id: run.id, stage, outcome, report_path: path.join(root, "stage-report.json"), next_action: nextAction, ...(mergeRequest ? { merge_request: mergeRequest, next: stageSuccessor(context, { projectRoot, runId: run.id, stage: "merge", command: runtimeCommand(context, ["stage", "start", run.id, "--stage", "merge", "--project-root", projectRoot, "--json", "--progress-jsonl"]) }) } : {}) };
 }
 export function readCodeReviewDecision(file, accepted, explicit = false, prepared) {
     if (!accepted)
@@ -356,7 +364,10 @@ export function assertCodeReviewCoverage(groups, reviewers) {
 export function reviewerTask(home, group) { return `Read-only independent CODE review for ${group.key}. Assess every assigned aspect exactly once: ${group.aspect_ids.join(", ")}. Read the accepted PLAN, ${path.join(home, "05-code", "stage-report.json")}, and any files needed under the bounded CODE evidence root ${path.join(home, "05-code")}. Verify that universal and exclusive constraints (only, any, all, never, whole) and stated exceptions were not narrowed. For every changed mutation guarded by membership, ownership, authorization or parent lifecycle state, trace the decision to the write boundary: the predicate must remain in the write statement or the guard and write must share one explicit transaction with the needed lock. A separate earlier read is not proof of current authority or lifecycle state; report a material finding when this invariant is broken. Evidence closes a claim only when it exercises the named failure mechanism; a sequential negative test does not prove a concurrency race, and proof limits cannot waive an accepted obligation. Report only material, evidenced defects: a violated obligation or rule, direct evidence, impact, and minimum required outcome. Do not report taste, cosmetics, or untargeted refactoring. Use local finding ids FIND-001, FIND-002, and so on; dd-flow adds the Work-qualified canonical reference. Return dd-flow/code-review-result@1.`; }
 function orchestratorPrompt(context, input) { const { template, checks } = input; const decision = path.join(input.root, "decision.json"); return ["<stage_identity>", `- RUN: ${input.run.id}`, `- root Work: ${input.rootWork.work_id}`, `- stage: ${stage}`, `- mode: ${input.mode}`, "</stage_identity>", "", "<trusted_runtime_context>", `- project root: ${input.projectRoot}`, `- immutable write workspace: ${input.run.workspace_root}`, `- stage workspace: ${input.root}`, `- bounded CODE evidence root: ${path.join(input.run.run_root, "05-code")}`, "CODE passed its declared checks; each check proves only its named contour and proof limits, not complete semantic acceptance. Conduct independent quality review and do not manually rerun every declared check.", "</trusted_runtime_context>", "", "<review_groups>", ...input.groups.map((group) => `- ${group.key}: ${group.aspect_ids.join(", ")}`), "</review_groups>", "", "<execution_commands>", "Do not choose a provider delegation tool from this stage prompt. At the Work-graph boundary, return immediately; the shared controller supplies the selected adapter's native tool, exact parameters, child task, and wait contract. Each reviewer Work must run in one fresh child session. The coordinator must never invoke a Work start_command itself: a child runs its exact start_command after native delegation. Reviewers are read-only and must not create subagents. Do not interrupt a quiet worker.", "Ready reviewer Works: " + runtimeCommand(context, ["work", "ls", "--run", input.run.id, "--ready", "--project-root", input.projectRoot, "--json"]), `Write the decision to this exact absolute path, not a relative look-alike: ${decision}`, `Finish only after every reviewer Work settles and that exact file exists: ${finishCommand(context, input.run.id, input.projectRoot, decision)}`, "Reviewer results use local FIND-NNN ids. Classify them by the canonical WRK-.../FIND-NNN finding_ref returned by dd-flow. Fix P0/P1. Fix bounded safe P2 by default; defer only a legitimate P2 with a named DEF. P3 is an observation or a reasoned rejection, not automatic repair/DEF. For every disposition fix, check_refs is mandatory: choose the one or more causal checks from the accepted list below that the repair must rerun. Do not guess a CHK id or copy every check. The first successful Finish freezes this decision and creates one repair Work when needed. Do not invoke that Work's start_command from the coordinator Session: end this Turn so the controller can launch a fresh child, then call the returned next.finish_command after it completes. Internal invocation IDs are runtime-owned and must not be copied or reused. Review is not repeated.", "If the aggregate gate fails with repair_required, its repair Work is already registered with all causal checks. End this Turn so the controller launches a fresh child. Do not copy receipt IDs, create another repair, invoke its start_command in the coordinator, or edit invisibly in the root orchestrator.", `Accepted repair checks: ${JSON.stringify(checks)}`, "```json", JSON.stringify({ schema_id: "dd-flow/code-review-decision@3", summary: "Evidence-backed conclusion.", findings: [{ finding_ref: "WRK-001-review/FIND-001", disposition: "fix | defer | reject | duplicate", reason: "Why this classification is correct.", check_refs: ["CHK-CAUSAL-CHECK only when disposition is fix"], def_id: "DEF-0001 only for an allowed P2 deferral", duplicate_of: "canonical finding_ref only for duplicate" }] }, null, 2), "```", "</execution_commands>", "", "<stage_instructions>", template, "</stage_instructions>", ""].join("\n"); }
 function canonicalReviewEvidence(decision, reviewers) {
-    const known = new Set(canonicalCodeFindings(reviewers).map((item) => item.finding_ref));
+    const known = new Map(canonicalCodeFindings(reviewers).map((item) => [item.finding_ref, item.finding]));
+    const refs = decision.findings.map(item => item.finding_ref);
+    if (new Set(refs).size !== refs.length || refs.some(ref => !known.has(ref)))
+        throw new AppError("review_evidence_invalid", "CODE decisions must use unique known canonical finding references", 2, { finding_refs: refs });
     const items = new Map(decision.findings.map((item) => [item.finding_ref, item]));
     const duplicates = new Set();
     for (const item of decision.findings.filter((entry) => entry.disposition === "duplicate")) {
@@ -372,6 +383,9 @@ function canonicalReviewEvidence(decision, reviewers) {
         }
         if (!cursor)
             throw new AppError("review_evidence_invalid", "Duplicate finding chain must end at a decided canonical finding", 2, { finding_ref: item.finding_ref });
+        if (["p0", "p1"].includes(known.get(item.finding_ref).priority) && cursor.disposition !== "fix") {
+            throw new AppError("review_material_disposition_invalid", "P0/P1 duplicate findings must resolve to a fixed canonical finding", 2, { finding_ref: item.finding_ref, canonical_finding_ref: cursor.finding_ref, disposition: cursor.disposition });
+        }
         duplicates.add(item.finding_ref);
     }
     return {
@@ -422,8 +436,7 @@ function validateDecision(context, input) {
         if (item.disposition === "fix" && !repaired.some((work) => requiredChecks.every((ref) => reviewCheckRefs(work).includes(ref))))
             throw new AppError("review_repair_check_missing", "A fixed CODE-REVIEW finding needs a repair Work that retains every selected causal check", 2, { finding_ref: findingRef, check_refs: requiredChecks });
         if (finding.priority === "p2" && item.disposition === "defer") {
-            if (!item.def_id || !fs.existsSync(path.join(input.workspaceRoot, ".memory-bank", "defs", `${item.def_id}.md`)))
-                throw new AppError("deferral_invalid", "A deferred P2 requires a named durable DEF", 2, { finding_ref: findingRef, def_id: item.def_id ?? null });
+            reviewDefEvidence(input.workspaceRoot, item.def_id);
         }
         if (finding.priority === "p3" && item.disposition === "defer")
             throw new AppError("deferral_invalid", "P3 observations are not deferred as DEF", 2, { finding_ref: findingRef });

package/dist/services/vnext-code.js

@@ -4,6 +4,7 @@ import { ensureAggregateRepair, ensureRepairIntent } from "./repair-intents.js";
 import { runWorkspaceBootstrap } from "./workspace-bootstrap.js";
 import crypto from "node:crypto";
 import fs from "node:fs";
+import { prepareAgentOutputFile } from "../storage/agent-output.js";
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { resolveProjectRoot } from "../storage/paths.js";
@@ -21,11 +22,12 @@ import { vnextStageDirectory } from "../domain/stage-catalog.js";
 import { acceptStageReport, prepareStageReport } from "./stage-report-renderer.js";
 import { prepareVnextMergeRequest } from "./vnext-merge.js";
 import { assertStageStartHookEvent } from "./hooks.js";
-import { applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
+import { currentStagePrompt, applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
 import { readFanoutDescriptor, writeFanoutDescriptor } from "./vnext-fanout.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
 import { prepareJsonSchema, prepareOutputFile } from "../cli/input-preparation.js";
 import { prepareRunVerificationMatrix, acceptVerificationMatrix, commitVerificationMatrixStart, resumeVerificationMatrix, verificationMatrixInstruction, publishVerificationMatrix, latestRunVerificationMatrix } from "./verification-matrix.js";
+import { stageSuccessor } from "./vnext-contracts.js";
 const stage = "code";
 const stageDir = vnextStageDirectory("code");
 /** A controller prepares slow, deterministic project tooling before it asks an
@@ -93,12 +95,13 @@ export async function startVnextCode(context, input, prepared = prepareVnextCode
     const { projectRoot, project, run, root, promptPath, rootWork, sourceRepairAttempt } = prepared;
     assertRunMutationAllowed(context, project.id, run.id);
     assertStageStartHookEvent(context, { projectId: project.id, eventKey: input.hookEventId, runId: run.id, stage, projectRoot, ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
+    prepareAgentOutputFile(path.join(requireHome(run), "works", rootWork.work_id, "block-summary.md"));
     if (prepared.resumed) {
         resumeVerificationMatrix(context, project.id, run.id, stage);
-        const externalContext = applyExternalStageContext({ stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+        const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
         bindStageCoordinatorWork(context, { workId: rootWork.work_id, hookEventId: input.hookEventId, stage, promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
         const orchestration = prepared.orchestration ?? writeFanoutDescriptor(root, { stage, parent_work_id: rootWork.work_id, dispatch: "none", capacity_required: true, scope: stageGraphScope(context, project.id, run.id, stage) });
-        return { ok: true, resumed: true, run_id: run.id, stage, stage_status: prepared.existingStage, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), ...(externalContext ? { external_context: externalContext } : {}), orchestration, graph: codeWorkGraph(context, project.id, run.id), next: { refresh_graph_command: runtimeCommand(context, ["work", "ls", "--run", run.id, "--ready", "--project-root", projectRoot, "--json"]), finish_command: finishCommand(context, input.runId, projectRoot, path.join(root, "code-verification.json")) } };
+        return { ok: true, resumed: true, run_id: run.id, stage, stage_status: prepared.existingStage, ...currentStagePrompt(context, promptPath), ...(externalContext ? { external_context: externalContext } : {}), orchestration, graph: codeWorkGraph(context, project.id, run.id), next: { refresh_graph_command: runtimeCommand(context, ["work", "ls", "--run", run.id, "--ready", "--project-root", projectRoot, "--json"]), finish_command: finishCommand(context, input.runId, projectRoot, path.join(root, "code-verification.json")) } };
     }
     if (!sourceRepairAttempt)
         prepareFlowRunStageAttachment(context, { projectRoot, runId: run.id, stage, dir: stageDir, status: "running", dataSchemaId: "dd-flow/stage-report@1" }, true);
@@ -108,7 +111,7 @@ export async function startVnextCode(context, input, prepared = prepareVnextCode
     const graph = codeWorkGraph(context, project.id, run.id);
     const prompt = `${coordinatorPrompt(context, { projectRoot, run, root, rootWork, readiness, template: prepared.template, capacity: prepared.capacity, graph })}\n${stageLifecycleInstruction}\n${verificationMatrixInstruction(prepared.matrix?.metadata ?? null, prepared.home, "implementation and code-verification.json")}\n`;
     fs.writeFileSync(promptPath, prompt);
-    const externalContext = applyExternalStageContext({ stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+    const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
     const binding = bindStageCoordinatorWork(context, {
         workId: rootWork.work_id,
         hookEventId: input.hookEventId,
@@ -139,8 +142,7 @@ export async function startVnextCode(context, input, prepared = prepareVnextCode
         stage,
         root_work_id: rootWork.work_id,
         id: binding.work_session_id,
-        prompt_path: promptPath,
-        worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"),
+        ...currentStagePrompt(context, promptPath),
         ...(externalContext ? { external_context: externalContext } : {}),
         graph,
         orchestration,
@@ -332,7 +334,7 @@ export async function finishVnextCode(context, input) {
         outcome: "accepted",
         report_path: path.join(root, "stage-report.json"),
         next_action: next,
-        ...(next === "start_code_review" ? { next: { kind: "start_stage", stage: "code-review", command: managedLifecycleCommand(context, runtimeCommand(context, ["stage", "start", run.id, "--stage", "code-review", "--project-root", projectRoot, "--json"])) } } : next === "start_merge" ? { merge_request: mergeRequest, next: { kind: "start_stage", stage: "merge", command: managedLifecycleCommand(context, runtimeCommand(context, ["stage", "start", run.id, "--stage", "merge", "--project-root", projectRoot, "--json", "--progress-jsonl"])) } } : {})
+        ...(next === "start_code_review" ? { next: stageSuccessor(context, { projectRoot, runId: run.id, stage: "code-review", command: runtimeCommand(context, ["stage", "start", run.id, "--stage", "code-review", "--project-root", projectRoot, "--json"]) }) } : next === "start_merge" ? { merge_request: mergeRequest, next: stageSuccessor(context, { projectRoot, runId: run.id, stage: "merge", command: runtimeCommand(context, ["stage", "start", run.id, "--stage", "merge", "--project-root", projectRoot, "--json", "--progress-jsonl"]) }) } : {})
     };
 }
 export function registerAggregateCodeRepair(context, input) {
@@ -539,7 +541,7 @@ function receiptRepairPaths(workspaceRoot, receipt) {
     }
     return [...paths].sort();
 }
-function coordinatorPrompt(context, input) {
+export function coordinatorPrompt(context, input) {
     const { graph, capacity, template } = input;
     return [
         "<stage_identity>",

package/dist/services/vnext-contracts.js

@@ -1 +1,10 @@
-export {};
+import { isControllerManagedInvocation, managedLifecycleCommand } from "./lifecycle-invocations.js";
+/** Successor authority belongs to the controller, not the finishing Session.
+ * Manual flows still need an executable next step. Current-stage finish and
+ * paused/child Work commands do not pass through this boundary. */
+export function stageSuccessor(context, input) {
+    const next = { ...input.metadata, kind: "start_stage", stage: input.stage };
+    return isControllerManagedInvocation(context, input.projectRoot, input.runId)
+        ? { ...next, controller_owned: true, stop_turn: true, instruction: "This Stage is complete. End this Turn now and await the controller's next Stage assignment. Do not start the successor Stage or prepare its command." }
+        : { ...next, command: managedLifecycleCommand(context, input.command) };
+}

package/dist/services/vnext-execution-profile.js

@@ -1,18 +1,89 @@
 import fs from "node:fs";
 import path from "node:path";
+import crypto from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { AppError } from "../shared/errors.js";
+import { canonicalPath } from "../storage/paths.js";
 import { isExecutionRouting } from "./execution-policy.js";
+export const RUN_OPERATIONAL_DECISION_CONTRACT = "run-operational-decision@1";
+const object = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const text = (value) => typeof value === "string" && Boolean(value.trim());
+const keys = (value, allowed) => object(value) && Object.keys(value).every(key => allowed.includes(key));
+/** Structural validation only: acceptance is supplied by the caller, never inferred from settings. */
+export function validateRunOperationalDecision(value, settings) {
+    if (!object(value) || value.schema_id !== RUN_OPERATIONAL_DECISION_CONTRACT || !text(value.id)
+        || !object(value.scope) || !text(value.scope.project_root) || !path.isAbsolute(value.scope.project_root)
+        || [value.scope.eval_id, value.scope.execution_id].some(item => item !== undefined && !text(item))
+        || !object(value.settings) || !object(value.settings.merge_delivery) || value.settings.merge_delivery.strategy !== settings.merge_delivery.strategy
+        || !object(value.settings.merge_cleanup) || value.settings.merge_cleanup.source !== settings.merge_cleanup.source
+        || !object(value.policy) || !text(value.policy.path) || !text(value.policy.sha256) || !/^[a-f0-9]{64}$/.test(value.policy.sha256)
+        || !Array.isArray(value.policy.clauses) || !value.policy.clauses.length || !value.policy.clauses.every(text)
+        || !object(value.acceptance) || !text(value.acceptance.source) || !text(value.acceptance.reference)
+        || value.exception !== undefined && (!object(value.exception) || !text(value.exception.reason) || !text(value.exception.owner)
+            || !text(value.exception.review_at) || !Number.isFinite(Date.parse(value.exception.review_at))
+            || value.exception.expires_at !== undefined && (!text(value.exception.expires_at) || !Number.isFinite(Date.parse(value.exception.expires_at))))) {
+        throw new AppError("operational_decision_invalid", "Operational decision requires explicit acceptance, scoped authority and matching settings", 2);
+    }
+    if (!keys(value, ["schema_id", "id", "scope", "settings", "policy", "acceptance", "exception", "declaration"])
+        || !keys(value.scope, ["project_root", "eval_id", "execution_id"])
+        || !keys(value.settings, ["merge_delivery", "merge_cleanup"])
+        || !keys(value.settings.merge_delivery, ["strategy"]) || !keys(value.settings.merge_cleanup, ["source"])
+        || !keys(value.policy, ["path", "sha256", "clauses"]) || !keys(value.acceptance, ["source", "reference"])
+        || value.exception !== undefined && !keys(value.exception, ["reason", "owner", "review_at", "expires_at"])
+        || value.declaration !== undefined && !keys(value.declaration, ["bytes", "sha256"]))
+        throw new AppError("operational_decision_invalid", "Operational decision contains unsupported authority fields", 2);
+    if (value.declaration !== undefined) {
+        if (!object(value.declaration) || !text(value.declaration.bytes) || !text(value.declaration.sha256)
+            || crypto.createHash("sha256").update(value.declaration.bytes).digest("hex") !== value.declaration.sha256)
+            throw new AppError("operational_decision_invalid", "Original operational declaration checksum does not match", 2);
+        let declaration;
+        try {
+            declaration = JSON.parse(value.declaration.bytes);
+        }
+        catch {
+            throw new AppError("operational_decision_invalid", "Original operational declaration must be JSON", 2);
+        }
+        if (!object(declaration) || !keys(declaration, ["schema_id", "id", "scope", "settings", "policy", "acceptance", "exception"])
+            || declaration.scope !== undefined && !keys(declaration.scope, ["project_root", "eval_id", "execution_id"])
+            || ["schema_id", "id", "settings", "policy", "acceptance", "exception"].some(key => !isDeepStrictEqual(declaration[key], value[key])))
+            throw new AppError("operational_decision_invalid", "Materialized decision changed the accepted declaration", 2);
+    }
+    return value;
+}
+/** Machine validation of declared policy bytes, not an NLP interpretation of Markdown. */
+export function assertOperationalDecisionSource(decision, projectRoot, now) {
+    if (canonicalPath(decision.scope.project_root, false) !== canonicalPath(projectRoot, false))
+        throw new AppError("operational_decision_scope_mismatch", "Operational decision belongs to another project", 2);
+    const file = path.resolve(projectRoot, decision.policy.path);
+    const relative = path.relative(fs.realpathSync(projectRoot), fs.existsSync(file) ? fs.realpathSync(file) : file);
+    if (relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative) || relative === ".." || !fs.existsSync(file) || crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") !== decision.policy.sha256)
+        throw new AppError("operational_decision_policy_changed", "Operational decision policy source checksum does not match an owned file", 2, { file });
+    if (decision.exception?.expires_at && Date.parse(decision.exception.expires_at) <= Date.parse(now))
+        throw new AppError("operational_decision_expired", "Explicit operational decision expiration has passed", 2);
+}
 const relativePath = path.join(".memory-bank", "dd-flow", "project-execution.json");
 /** The project owns defaults; a RUN snapshots them once and never re-infers them. */
 export function loadVnextExecutionProfile(projectRoot) {
+    return loadVnextExecutionProfileSnapshot(projectRoot).profile;
+}
+/** Parse and identify the same source bytes; a second read cannot bind another declaration. */
+export function loadVnextExecutionProfileSnapshot(projectRoot) {
     const file = path.join(projectRoot, relativePath);
+    let bytes;
     let value;
     try {
-        value = JSON.parse(fs.readFileSync(file, "utf8"));
+        bytes = fs.readFileSync(file);
+        value = JSON.parse(bytes.toString("utf8"));
     }
     catch (error) {
         throw new AppError("execution_profile_missing", "vNext flow requires .memory-bank/dd-flow/project-execution.json", 1, { file, cause: String(error) });
     }
+    return { profile: validateVnextExecutionProfile(value), bytes };
+}
+/** Pure shared admission contract for project-execution@2 and @3. */
+export function validateVnextExecutionProfile(value) {
+    if (!object(value))
+        throw new AppError("execution_profile_invalid", "Project execution profile must be an object", 1);
     const profile = value;
     if ((profile.schema_id !== "dd-flow/project-execution@2" && profile.schema_id !== "dd-flow/project-execution@3")
         || (profile.stage_session_mode !== undefined && profile.stage_session_mode !== "same_session" && profile.stage_session_mode !== "new_session")
@@ -25,8 +96,10 @@ export function loadVnextExecutionProfile(projectRoot) {
         || !profile.code_bootstrap || typeof profile.code_bootstrap.command !== "string" || !profile.code_bootstrap.command.trim()
         || typeof profile.code_bootstrap.policy_ref !== "string" || !profile.code_bootstrap.policy_ref.trim()
         || (profile.execution === undefined ? profile.schema_id === "dd-flow/project-execution@3" : !isExecutionRouting(profile.execution))) {
-        throw new AppError("execution_profile_invalid", "Project execution profile does not match its supported dd-flow schema", 1, { file });
+        throw new AppError("execution_profile_invalid", "Project execution profile does not match its supported dd-flow schema", 1);
     }
+    if (profile.operational_decision !== undefined)
+        validateRunOperationalDecision(profile.operational_decision, profile);
     return { ...profile, stage_session_mode: profile.stage_session_mode ?? "same_session", code_review_mode: profile.code_review_mode ?? "off" };
 }
 export function executionProfilePath(projectRoot) { return path.join(projectRoot, relativePath); }

package/dist/services/vnext-fanout.js

@@ -10,6 +10,7 @@ import { storageSessionId } from "./session-identity.js";
 import { reconcileUnfinishedChecks } from "./code-checks.js";
 import { vnextStageDirectory } from "../domain/stage-catalog.js";
 import { stageWorkIds, stageGraphScope } from "./stage-work-graph.js";
+import { eligibleCodexChildOverload } from "./codex-capacity.js";
 export const subagentCapacityKey = "runtime.subagent.available_slots";
 /** External concurrency is policy, never evidence of native child qualification. */
 export function getStageFanoutCapacity(context, input) {
@@ -143,6 +144,10 @@ export async function reconcileVnextFanout(context, input) {
             continue;
         }
         const link = active[0];
+        if (value.harness_id === "codex-desktop" && eligibleCodexChildOverload(child, value.parent_session_id)) {
+            issues.push({ code: "child_capacity_pending", work_id: link.work_id, session_id: child.session_id });
+            continue;
+        }
         const pendingCheck = () => context.db.get("SELECT 1 FROM check_receipts WHERE project_id = ? AND run_id = ? AND work_id = ? AND status = 'running' LIMIT 1", [project.id, input.runId, link.work_id]);
         if (pendingCheck()) {
             const run = context.db.get("SELECT workspace_root, run_root FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);