audit-tools 0.35.3 → 0.35.6

package/dist/audit/cli/nextStepCommand.js

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { resolveSessionConfig, applyGuidanceFile, runWithBlockedStepBackstop, writeBlockedStepContract, } from "audit-tools/shared";
+import { resolveSessionConfig, applyGuidanceFile, runWithBlockedStepBackstop, writeBlockedStepContract, renderFanoutExecutionLines, } from "audit-tools/shared";
+import { materializeFanoutLanes } from "./fanoutLanes.js";
 import { buildEdgeReasoningPrompt, edgeReasoningContentHash, } from "../orchestrator/edgeReasoning.js";
 import { renderDesignReviewPrompt, renderContractReviewPrompt, } from "../orchestrator/designReviewPrompt.js";
 import { prepareConceptualDispatch, resolveConceptualReviewSettings, } from "./conceptualDispatch.js";
@@ -10,7 +11,7 @@ import { deriveIntentEquivalenceStatus } from "../orchestrator/intentEquivalence
 import { unresolvedConstraintClauses } from "../orchestrator/intentInterpreter.js";
 import { renderSynthesisNarrativePrompt } from "../reporting/synthesisNarrativePrompt.js";
 import { renderCriticalFlowFallbackPrompt } from "../reporting/criticalFlowFallbackPrompt.js";
-import { renderCharterExtractionPrompt } from "./charterExtractionPrompt.js";
+import { charterExtractionKindsForCeiling, renderCharterKindLanePrompt, } from "./charterExtractionPrompt.js";
 import { renderCharterDeltaPrompt } from "./charterDeltaPrompt.js";
 import { renderCharterClarificationPrompt } from "./charterClarificationPrompt.js";
 import { renderSecondOrderAdversaryPrompt } from "../systemic/secondOrderAdversaryPrompt.js";
@@ -22,7 +23,7 @@ import { persistConfigErrorHandoff, } from "./reviewRun.js";
 import { renderSemanticReviewStep } from "./semanticReviewStep.js";
 import { renderConfirmIntentPrompt } from "./confirmIntentStep.js";
 import { writeCurrentStep, STEP_CONTRACT_VERSION } from "./steps.js";
-import { nextStepCommand, renderAnalyzerInstallPrompt, renderEdgeReasoningDispatchPrompt, renderEdgeReasoningStepPrompt, renderPresentReportPrompt, } from "./prompts.js";
+import { nextStepCommand, renderAnalyzerInstallPrompt, renderEdgeReasoningDispatchPrompt, renderPresentReportPrompt, } from "./prompts.js";
 import { getArtifactsDir, getFlag, getAuditorDescriptor, getHostProvider, getRootDir, getTimeoutMs, resolveHostDispatchCapability, warnIfNotGitRepo, } from "./args.js";
 import { resolveCurrentWorkPartitionRuntime } from "./workPartitionRuntime.js";
 // Import the helpers used locally, then re-export the full helper surface so
@@ -362,7 +363,6 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             artifactsDir,
             bundle: result.bundle,
             settings: conceptualSettings,
-            hostCanSelectSubagentModel,
             reReviewSection: conceptualNotesSection || undefined,
         });
         const dispatchPrompt = [
@@ -484,7 +484,6 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             artifactsDir,
             bundle: result.bundle,
             settings: conceptualSettings,
-            hostCanSelectSubagentModel,
             reReviewSection: conceptualNotesSection || undefined,
         });
         const prompt = [
@@ -533,33 +532,94 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         return;
     }
     if (result.kind === "charter_extraction") {
-        // Phase C charter layer (conceptual, teleological): the host extracts the four
-        // charter families per confident subsystem + the deltas it sees; the tool gates
-        // + routes them at ingest. Only reached at a deep+ ceiling (shallow omits
-        // deterministically without a host turn).
-        await mkdir(join(artifactsDir, "incoming"), { recursive: true });
+        // Phase C charter layer (conceptual, teleological): one blind, materialized
+        // LANE per charter kind (design resolution 2 — independence is the shape of
+        // the artifacts, not a merge instruction); the tool merges the per-kind
+        // submissions and gates + routes them at ingest. Only reached at a deep+
+        // ceiling (shallow omits deterministically without a host turn).
         const continueCommand = nextStepCommand(root, artifactsDir, hostDescriptor);
-        const submissionPath = join(artifactsDir, "incoming", "charter-extraction.json");
         const ceiling = resolveCharterCeiling(result.bundle.intent_checkpoint);
+        const kinds = charterExtractionKindsForCeiling(ceiling);
+        const laneSpecs = kinds.map((kind) => {
+            const submissionPath = join(artifactsDir, "incoming", `charter-extraction-${kind}.json`);
+            return {
+                id: `charter_extraction_${kind}`,
+                label: `Charter ${kind} author (blind lane)`,
+                promptFilename: `charter-extraction-${kind}-prompt.md`,
+                resultFilename: `charter-extraction-${kind}.json`,
+                promptText: renderCharterKindLanePrompt(result.bundle, {
+                    kind,
+                    submissionPath,
+                }),
+            };
+        });
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: laneSpecs,
+        });
+        const pendingIds = new Set(fanout.pendingLanes.map((lane) => lane.id));
+        if (await gateHostFanoutOrPause({
+            root,
+            artifactsDir,
+            sessionConfig: effectiveConfig,
+            hostDescriptor,
+            continueCommand,
+            bundle: result.bundle,
+            family: "charter_extraction",
+            units: laneSpecs
+                .filter((spec) => pendingIds.has(spec.id))
+                .map((spec) => ({
+                id: spec.id,
+                estInputBytes: Buffer.byteLength(spec.promptText, "utf8"),
+            })),
+        })) {
+            return;
+        }
+        const completedLanes = fanout.lanes.filter((lane) => lane.resultExists);
         const step = await writeCurrentStep({
             artifactsDir,
             stepKind: "charter_extraction",
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Write the charter families per subsystem to the submission path, then run next-step.",
+            stopCondition: "Execute each pending charter lane prompt (one blind agent per kind — subagents if available, else sequentially), write each lane's submission to its results path, then run next-step.",
             repoRoot: root,
-            artifactPaths: {
-                charter_extraction_submission: submissionPath,
-            },
-            prompt: renderCharterExtractionPrompt(result.bundle, {
-                submissionPath,
-                continueCommand,
-                ceiling,
-            }),
+            artifactPaths: fanout.artifactPaths,
+            prompt: [
+                "# audit-code charter extraction (per-kind blind lanes)",
+                "",
+                "Each charter kind is authored by its OWN blind lane: a lane must not see another lane's prompt or output, so the later stated↔revealed delta is genuine disagreement rather than one author's self-consistent story. The tool merges the per-kind submissions at ingest.",
+                "",
+                ...renderFanoutExecutionLines({
+                    lanes: fanout.pendingLanes.map((lane) => ({
+                        label: lane.label,
+                        promptPath: lane.promptPath,
+                        resultPath: lane.resultPath,
+                    })),
+                    concurrencyHint: hostMaxActiveSubagents,
+                }),
+                "",
+                ...(completedLanes.length > 0
+                    ? [
+                        `Already complete (results on disk — do NOT redo these lanes): ${completedLanes
+                            .map((lane) => lane.label)
+                            .join(", ")}.`,
+                        "",
+                    ]
+                    : []),
+                "When every pending lane's result file exists, run:",
+                "",
+                `  ${continueCommand}`,
+                "",
+                "Read and follow only the new step prompt returned by that command.",
+                "",
+            ].join("\n"),
             access: {
-                read_paths: [join(artifactsDir, "structure_decomposition.json")],
-                write_paths: [submissionPath],
+                read_paths: [
+                    ...fanout.readPaths,
+                    join(artifactsDir, "structure_decomposition.json"),
+                ],
+                write_paths: fanout.writePaths,
             },
         });
         console.log(JSON.stringify(step, null, 2));
@@ -571,27 +631,77 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         // to the gaps) and mines the pairwise deltas + the goal DAG; the tool routes +
         // gates them at ingest. Only reached at a deep+ ceiling whose extraction pass
         // produced ≥1 subsystem (charter_register.deltas_pending).
-        await mkdir(join(artifactsDir, "incoming"), { recursive: true });
+        // Always-materialized (design resolution 2): the miner prompt is a lane FILE.
         const continueCommand = nextStepCommand(root, artifactsDir, hostDescriptor);
         const submissionPath = join(artifactsDir, "incoming", "charter-delta.json");
+        const lanePrompt = renderCharterDeltaPrompt(result.bundle, { submissionPath });
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: [
+                {
+                    id: "charter_delta",
+                    label: "Independent charter delta-miner",
+                    promptFilename: "charter-delta-prompt.md",
+                    resultFilename: "charter-delta.json",
+                    promptText: lanePrompt,
+                },
+            ],
+        });
+        if (await gateHostFanoutOrPause({
+            root,
+            artifactsDir,
+            sessionConfig: effectiveConfig,
+            hostDescriptor,
+            continueCommand,
+            bundle: result.bundle,
+            family: "charter_delta",
+            units: [
+                {
+                    id: "charter_delta",
+                    estInputBytes: Buffer.byteLength(lanePrompt, "utf8"),
+                },
+            ],
+        })) {
+            return;
+        }
         const step = await writeCurrentStep({
             artifactsDir,
             stepKind: "charter_delta",
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Write the mined charter deltas + goal graph to the submission path, then run next-step.",
+            stopCondition: "Execute the delta-miner lane prompt (subagent if available, else yourself), write the mined deltas + goal graph to the results path, then run next-step.",
             repoRoot: root,
-            artifactPaths: {
-                charter_delta_submission: submissionPath,
-            },
-            prompt: renderCharterDeltaPrompt(result.bundle, {
-                submissionPath,
-                continueCommand,
-            }),
+            artifactPaths: fanout.artifactPaths,
+            prompt: [
+                "# audit-code charter delta-mining",
+                "",
+                "The assembled charters are ready for the INDEPENDENT delta-miner (it did not author them).",
+                "",
+                ...renderFanoutExecutionLines({
+                    lanes: fanout.pendingLanes.map((lane) => ({
+                        label: lane.label,
+                        promptPath: lane.promptPath,
+                    })),
+                }),
+                "",
+                "The executor must write its CharterDeltaSubmission JSON to:",
+                "",
+                `  ${submissionPath}`,
+                "",
+                "When the result file exists, run:",
+                "",
+                `  ${continueCommand}`,
+                "",
+                "Read and follow only the new step prompt returned by that command.",
+                "",
+            ].join("\n"),
             access: {
-                read_paths: [join(artifactsDir, "charter_register.json")],
-                write_paths: [submissionPath],
+                read_paths: [
+                    ...fanout.readPaths,
+                    join(artifactsDir, "charter_register.json"),
+                ],
+                write_paths: fanout.writePaths,
             },
         });
         console.log(JSON.stringify(step, null, 2));
@@ -638,7 +748,6 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         // a SEPARATE adversary agent whose mandate is optimization/better-way; it writes
         // the round's improvement findings (true-lens) back, and the executor folds them
         // + decides convergence. An empty submission converges the loop.
-        await mkdir(join(artifactsDir, "incoming"), { recursive: true });
         const continueCommand = nextStepCommand(root, artifactsDir, hostDescriptor);
         const submissionPath = join(artifactsDir, "incoming", "systemic-challenge.json");
         const metrics = result.bundle.systemic_challenge?.metrics ?? aggregateMetricsDigest(result.bundle);
@@ -647,7 +756,20 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             priorFindingCount: result.bundle.systemic_challenge?.findings.length ?? 0,
             metrics,
             submissionPath,
-            continueCommand,
+        });
+        // Always-materialized (design resolution 2): the adversary prompt is a lane
+        // FILE — the adversary is a SEPARATE agent by lane class, on every host.
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: [
+                {
+                    id: "systemic_challenge",
+                    label: "Second-order adversary (improvement-seeking challenge)",
+                    promptFilename: "systemic-challenge-prompt.md",
+                    resultFilename: "systemic-challenge.json",
+                    promptText: adversaryPrompt,
+                },
+            ],
         });
         if (await gateHostFanoutOrPause({
             root,
@@ -672,15 +794,40 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Run a separate second-order-adversary agent (optimization/better-way mandate), write its findings to the submission path, then run next-step. An empty findings array converges the loop.",
+            stopCondition: "Execute the second-order-adversary lane prompt (a separate agent from the one that drove this audit), write its findings to the results path, then run next-step. An empty findings array converges the loop.",
             repoRoot: root,
-            artifactPaths: {
-                systemic_challenge_submission: submissionPath,
-            },
-            prompt: adversaryPrompt,
+            artifactPaths: fanout.artifactPaths,
+            prompt: [
+                "# audit-code systemic challenge (second-order adversary)",
+                "",
+                "This round's adversary lane challenges the audit process itself (optimization/better-way mandate). The adversary must NOT be the agent that drove this audit.",
+                "",
+                ...renderFanoutExecutionLines({
+                    lanes: fanout.pendingLanes.map((lane) => ({
+                        label: lane.label,
+                        promptPath: lane.promptPath,
+                    })),
+                }),
+                "",
+                "The executor must write its findings JSON to:",
+                "",
+                `  ${submissionPath}`,
+                "",
+                "An EMPTY findings array is the deliberate loop terminator (this round found nothing new).",
+                "",
+                "When the result file exists, run:",
+                "",
+                `  ${continueCommand}`,
+                "",
+                "Read and follow only the new step prompt returned by that command.",
+                "",
+            ].join("\n"),
             access: {
-                read_paths: [join(artifactsDir, "systemic_challenge.json")],
-                write_paths: [submissionPath],
+                read_paths: [
+                    ...fanout.readPaths,
+                    join(artifactsDir, "systemic_challenge.json"),
+                ],
+                write_paths: fanout.writePaths,
             },
         });
         console.log(JSON.stringify(step, null, 2));
@@ -744,61 +891,45 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         // name it and the shape error in the re-emitted prompt so the producer
         // fixes the shape instead of resubmitting the same honest mistake forever.
         const rejectionNotice = await renderEdgeReasoningRejectionNotice(artifactsDir);
-        if (hostCanDispatch) {
-            // Dispatch path: isolate the (potentially large) edge-list prompt in a file
-            // and have the host fan it out to one subagent, mirroring the packet review
-            // dispatch contract. The subagent writes the rewrites file; next-step applies.
-            const edgeReasoningPromptPath = join(artifactsDir, "incoming", "edge-reasoning-prompt.md");
-            await writeFile(edgeReasoningPromptPath, rejectionNotice ? `${basePrompt}\n\n${rejectionNotice}` : basePrompt, "utf8");
-            const step = await writeCurrentStep({
-                artifactsDir,
-                stepKind: "edge_reasoning_dispatch",
-                status: "ready",
-                runId: null,
-                allowedCommands: [continueCommand],
-                stopCondition: "Dispatch one subagent to write the edge-reasoning rewrites, then run next-step.",
-                repoRoot: root,
-                artifactPaths: {
-                    edge_reasoning_prompt: edgeReasoningPromptPath,
-                    edge_reasoning_results: edgeReasoningResultsPath,
-                },
-                prompt: renderEdgeReasoningDispatchPrompt({
-                    promptPath: edgeReasoningPromptPath,
-                    resultsPath: edgeReasoningResultsPath,
-                    continueCommand,
-                    contentHash,
-                    candidateCount: result.candidates.length,
-                }),
-                access: {
-                    read_paths: [edgeReasoningPromptPath],
-                    write_paths: [edgeReasoningResultsPath],
+        // Always-materialized (design resolution 2): the (potentially large)
+        // edge-list prompt lives in a lane file on every host — a subagent-capable
+        // host fans it out, any other host reads and follows the same file itself.
+        // The retired inline `edge_reasoning` step kind was this branch's other
+        // arm. Routed through the same lane materializer as every other fan-out
+        // step so the K-of-N/result-exists semantics stay single-sourced.
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: [
+                {
+                    id: "edge_reasoning",
+                    label: "Edge-reasoning rewrites",
+                    promptFilename: "edge-reasoning-prompt.md",
+                    resultFilename: "edge-reasoning.json",
+                    promptText: rejectionNotice
+                        ? `${basePrompt}\n\n${rejectionNotice}`
+                        : basePrompt,
                 },
-            });
-            console.log(JSON.stringify(step, null, 2));
-            return;
-        }
-        // One-step fallback (no callable subagent facility): the host produces the
-        // rewrites itself in a single bounded turn, mirroring the narrative step.
+            ],
+        });
+        const edgeReasoningPromptPath = fanout.lanes[0].promptPath;
         const step = await writeCurrentStep({
             artifactsDir,
-            stepKind: "edge_reasoning",
+            stepKind: "edge_reasoning_dispatch",
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Write the edge-reasoning rewrites to the results path, then run next-step.",
+            stopCondition: "Execute the edge-reasoning lane prompt (subagent if available, else yourself), write the rewrites to the results path, then run next-step.",
             repoRoot: root,
-            artifactPaths: {
-                edge_reasoning_results: edgeReasoningResultsPath,
-            },
-            prompt: renderEdgeReasoningStepPrompt({
-                basePrompt,
+            artifactPaths: fanout.artifactPaths,
+            prompt: renderEdgeReasoningDispatchPrompt({
+                promptPath: edgeReasoningPromptPath,
                 resultsPath: edgeReasoningResultsPath,
                 continueCommand,
                 contentHash,
-                rejectionNotice,
+                candidateCount: result.candidates.length,
             }),
             access: {
-                read_paths: [],
+                read_paths: [edgeReasoningPromptPath],
                 write_paths: [edgeReasoningResultsPath],
             },
         });
@@ -879,12 +1010,13 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
     }
     if (result.kind === "critical_flow_fallback") {
         const fallbackResultsPath = join(artifactsDir, "incoming", "critical-flow-fallback.json");
-        await mkdir(join(artifactsDir, "incoming"), { recursive: true });
         const continueCommand = nextStepCommand(root, artifactsDir, hostDescriptor);
         const basePrompt = result.bundle.critical_flows
             ? renderCriticalFlowFallbackPrompt(result.bundle.critical_flows)
             : "# Critical-flow fallback\n\nNo critical_flows manifest is available; write an empty flows array.";
-        const fullPrompt = [
+        // Always-materialized (design resolution 2): the (potentially ~340-line)
+        // flow-stub prompt is a lane FILE, never inlined into the step prompt.
+        const lanePrompt = [
             basePrompt,
             "## Results path",
             "",
@@ -892,24 +1024,69 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             "",
             `  ${fallbackResultsPath}`,
             "",
-            `Then run: ${continueCommand}`,
-            "",
         ].join("\n");
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: [
+                {
+                    id: "critical_flow_fallback",
+                    label: "Critical-flow fallback enrichment",
+                    promptFilename: "critical-flow-fallback-prompt.md",
+                    resultFilename: "critical-flow-fallback.json",
+                    promptText: lanePrompt,
+                },
+            ],
+        });
+        if (await gateHostFanoutOrPause({
+            root,
+            artifactsDir,
+            sessionConfig: effectiveConfig,
+            hostDescriptor,
+            continueCommand,
+            bundle: result.bundle,
+            family: "critical_flow_fallback",
+            units: [
+                {
+                    id: "critical_flow_fallback",
+                    estInputBytes: Buffer.byteLength(lanePrompt, "utf8"),
+                },
+            ],
+        })) {
+            return;
+        }
         const step = await writeCurrentStep({
             artifactsDir,
             stepKind: "critical_flow_fallback",
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Write the critical-flow fallback enrichment to the results path, then run next-step.",
+            stopCondition: "Execute the critical-flow lane prompt (subagent if available, else yourself), write the enrichment to the results path, then run next-step.",
             repoRoot: root,
-            artifactPaths: {
-                critical_flow_fallback_results: fallbackResultsPath,
-            },
-            prompt: fullPrompt,
+            artifactPaths: fanout.artifactPaths,
+            prompt: [
+                "# audit-code critical-flow fallback",
+                "",
+                ...renderFanoutExecutionLines({
+                    lanes: fanout.pendingLanes.map((lane) => ({
+                        label: lane.label,
+                        promptPath: lane.promptPath,
+                    })),
+                }),
+                "",
+                "The executor must write the CriticalFlowFallbackResult JSON object to:",
+                "",
+                `  ${fallbackResultsPath}`,
+                "",
+                "When the result file exists, run:",
+                "",
+                `  ${continueCommand}`,
+                "",
+                "Read and follow only the new step prompt returned by that command.",
+                "",
+            ].join("\n"),
             access: {
-                read_paths: [],
-                write_paths: [fallbackResultsPath],
+                read_paths: fanout.readPaths,
+                write_paths: fanout.writePaths,
             },
         });
         console.log(JSON.stringify(step, null, 2));
@@ -917,12 +1094,14 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
     }
     if (result.kind === "synthesis_narrative") {
         const narrativeResultsPath = join(artifactsDir, "incoming", "synthesis-narrative.json");
-        await mkdir(join(artifactsDir, "incoming"), { recursive: true });
         const continueCommand = nextStepCommand(root, artifactsDir, hostDescriptor);
         const basePrompt = result.bundle.audit_findings
             ? renderSynthesisNarrativePrompt(result.bundle.audit_findings)
             : "# Synthesis narrative\n\nNo findings report is available; write an empty themes array.";
-        const fullPrompt = [
+        // Always-materialized (design resolution 2): the findings digest (up to 120
+        // findings) is a lane FILE, never inlined into the step prompt. This step
+        // previously carried no access block at all — the lane form declares one.
+        const lanePrompt = [
             basePrompt,
             "## Results path",
             "",
@@ -930,21 +1109,70 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             "",
             `  ${narrativeResultsPath}`,
             "",
-            `Then run: ${continueCommand}`,
-            "",
         ].join("\n");
+        const fanout = await materializeFanoutLanes({
+            artifactsDir,
+            lanes: [
+                {
+                    id: "synthesis_narrative",
+                    label: "Synthesis narrative (themes / exec summary / top risks)",
+                    promptFilename: "synthesis-narrative-prompt.md",
+                    resultFilename: "synthesis-narrative.json",
+                    promptText: lanePrompt,
+                },
+            ],
+        });
+        if (await gateHostFanoutOrPause({
+            root,
+            artifactsDir,
+            sessionConfig: effectiveConfig,
+            hostDescriptor,
+            continueCommand,
+            bundle: result.bundle,
+            family: "synthesis_narrative",
+            units: [
+                {
+                    id: "synthesis_narrative",
+                    estInputBytes: Buffer.byteLength(lanePrompt, "utf8"),
+                },
+            ],
+        })) {
+            return;
+        }
         const step = await writeCurrentStep({
             artifactsDir,
             stepKind: "synthesis_narrative",
             status: "ready",
             runId: null,
             allowedCommands: [continueCommand],
-            stopCondition: "Write the synthesis narrative to the results path, then run next-step.",
+            stopCondition: "Execute the synthesis-narrative lane prompt (subagent if available, else yourself), write the narrative to the results path, then run next-step.",
             repoRoot: root,
-            artifactPaths: {
-                synthesis_narrative_results: narrativeResultsPath,
+            artifactPaths: fanout.artifactPaths,
+            prompt: [
+                "# audit-code synthesis narrative",
+                "",
+                ...renderFanoutExecutionLines({
+                    lanes: fanout.pendingLanes.map((lane) => ({
+                        label: lane.label,
+                        promptPath: lane.promptPath,
+                    })),
+                }),
+                "",
+                "The executor must write the SynthesisNarrative JSON object to:",
+                "",
+                `  ${narrativeResultsPath}`,
+                "",
+                "When the result file exists, run:",
+                "",
+                `  ${continueCommand}`,
+                "",
+                "Read and follow only the new step prompt returned by that command.",
+                "",
+            ].join("\n"),
+            access: {
+                read_paths: fanout.readPaths,
+                write_paths: fanout.writePaths,
             },
-            prompt: fullPrompt,
         });
         console.log(JSON.stringify(step, null, 2));
         return;
@@ -953,14 +1181,11 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         root,
         artifactsDir,
         activeReviewRun: result.activeReviewRun,
-        hostCanDispatch,
         hostMaxActiveSubagents,
         hostContextTokens,
         hostOutputTokens,
         hostModelRoster,
         hostModelId,
-        hostCanRestrictSubagentTools,
-        hostCanSelectSubagentModel,
         selectedExecutor: result.selectedExecutor,
         inProcessMadeProgress: result.inProcessMadeProgress,
         // G2: the RESOLVED descriptor. renderSemanticReviewStep loads the repo INTENT from