audit-tools 0.42.1 → 0.44.0

package/dist/audit/cli/nextStepCommand.js

@@ -1,6 +1,9 @@
 import { mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { loadAnalyzerPolicy, loadSessionIntent, applyGuidanceFile, runWithBlockedStepBackstop, writeBlockedStepContract, laneAssetsDir, renderFanoutExecutionLines, writeTextFile, } from "audit-tools/shared";
+// The ONE shared table-driven step-emission scaffold. Imported by relative path
+// like every other cross-area shared module this area reaches for.
+import { createStepEmissionScaffold } from "../../shared/steps/stepEmissionScaffold.js";
 import { cleanupStaleArtifactsDir } from "./cleanup.js";
 import { materializeFanoutLanes } from "./fanoutLanes.js";
 import { AUDIT_GATE_SUBMISSION_SCOPE, GATE_LANES, charterExtractionLane, charterExtractionPacketFilename, laneSubmissionPath, mergeLaneShortfalls, recordExpectedLanes, renderLaneShortfallLines, } from "./laneSubmissions.js";
@@ -182,21 +185,16 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
             artifactsDir,
             progressSummary: reason,
         });
+        // The ONE emission that is not a table row, and deliberately so: it runs
+        // BEFORE dispatch, so no result kind exists to dispatch on. An unreadable
+        // or invalid analyzer policy blocks the step rather than degrading to an
+        // empty policy (which would silently drop every recorded consent decision)
+        // — and it still goes through the scaffold's single emission site, so the
+        // "write the step, log it, exactly once" shape is not re-implemented here.
         // Shared blocked-step assembly: the step JSON says WHY on its own via
         // progress.summary — an automated consumer (release smoke, CI) sees only this
         // contract, not the prompt file.
-        const step = await writeBlockedStepContract({
-            tool: "audit-code",
-            contractVersion: STEP_CONTRACT_VERSION,
-            artifactsDir,
-            repoRoot: root,
-            runId: null,
-            reason,
-            artifactPaths: {
-                operator_handoff: join(artifactsDir, "operator-handoff.json"),
-            },
-        });
-        console.log(JSON.stringify(step, null, 2));
+        await NEXT_STEP_EMISSION.emitPlan(blockedStepPlan(operatorHandoffBlock(root, artifactsDir, reason)));
         return;
     }
     const result = await runDeterministicForNextStep({
@@ -210,807 +208,903 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         // session config can opt out). The executor builds its own global-`fetch`
         // adapter when no fetcher is injected. The unit/integration suite never reaches
         // here, so acquisition stays a hermetic no-op in tests.
-        externalAcquisition: {
-            enabled: true,
-            analyzers: analyzerPolicy.analyzers,
-            // Item B: recorded consent decisions ride into admission (granted admits
-            // without a token) and into the consent fold's pending computation.
-            analyzerConsent: analyzerPolicy.analyzer_consent,
-        },
+        externalAcquisition: buildExternalAcquisitionOptions(analyzerPolicy),
         since: getFlag(argv, "--since"),
     });
-    if (result.kind === "complete") {
-        const triage = result.triage;
-        const frictionPending = triage?.action === "dispose";
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "present_report",
-            status: frictionPending ? "ready" : "complete",
-            runId: null,
-            // INV-READY-STEP-CONTINUATION (COR-f6a36670): a ready step whose
-            // stop_condition instructs calling next-step again must carry the
-            // executable continuation command — never leave the host to reconstruct
-            // the invocation from prose.
-            allowedCommands: frictionPending
-                ? [nextStepCommand(root, artifactsDir)]
-                : [],
-            stopCondition: frictionPending
-                ? "Complete friction triage (write open_observations and any dispositions), then call next-step again."
-                : "Present the final audit report and stop.",
-            repoRoot: root,
-            artifactPaths: {
-                final_report: result.finalReportPath,
-                ...(triage ? { friction_record: triage.recordPath } : {}),
-            },
-            prompt: renderPresentReportPrompt(result.finalReportPath, triage),
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
+    // The single dispatch: one table row per result kind, one emission site. A
+    // kind the table does not carry is the semantic-review dispatch (the
+    // scaffold's fallback), exactly as the old fallthrough branch was.
+    await NEXT_STEP_EMISSION.emit(result.kind, {
+        argv,
+        root,
+        artifactsDir,
+        analyzerPolicy,
+        result,
+    });
+}
+function currentStepPlan(params) {
+    return { via: "current", params };
+}
+function blockedStepPlan(params) {
+    return { via: "blocked", params };
+}
+function semanticReviewPlan(params) {
+    return { via: "semantic_review", params };
+}
+/**
+ * The blocked-step shape both blocked paths share — the pre-dispatch config
+ * failure and the `blocked` result kind. Single-sourced so the two cannot drift
+ * into two different operator-handoff contracts.
+ */
+function operatorHandoffBlock(root, artifactsDir, reason) {
+    return {
+        tool: "audit-code",
+        contractVersion: STEP_CONTRACT_VERSION,
+        artifactsDir,
+        repoRoot: root,
+        runId: null,
+        reason,
+        artifactPaths: {
+            operator_handoff: join(artifactsDir, "operator-handoff.json"),
+        },
+    };
+}
+/** The ONE writer dispatch. Each underlying writer is called exactly once here. */
+async function writeAuditStep(plan) {
+    switch (plan.via) {
+        case "current":
+            return await writeCurrentStep(plan.params);
+        case "blocked":
+            return await writeBlockedStepContract(plan.params);
+        case "semantic_review":
+            return await renderSemanticReviewStep(plan.params);
     }
-    if (result.kind === "blocked") {
-        // Same diagnosability contract as the config-blocked step above.
-        const step = await writeBlockedStepContract({
-            tool: "audit-code",
-            contractVersion: STEP_CONTRACT_VERSION,
-            artifactsDir,
-            repoRoot: root,
-            runId: null,
-            reason: result.reason,
-            artifactPaths: {
-                operator_handoff: join(artifactsDir, "operator-handoff.json"),
-            },
-        });
-        console.log(JSON.stringify(step, null, 2));
+}
+/**
+ * Bind one row to its own result variant. The table is keyed BY the result
+ * kind, so the row that runs is by construction the row for `ctx.result.kind`;
+ * the narrowing is stated once here rather than re-checked in every body.
+ */
+function emissionRow(handle) {
+    return (ctx) => handle(ctx, ctx.result);
+}
+/**
+ * The caller-side precondition the analyzer-acquisition chokepoint declares:
+ * an acquisition-bearing step is only emitted for a run whose durable analyzer
+ * policy actually loaded. Refusing here (the terminal backstop turns the throw
+ * into a written blocked step) keeps the alternative — emitting a consent or
+ * install step against no policy — impossible: those steps collect decisions
+ * that have nothing to merge into, and admission would see no recorded
+ * decision at all, making an operator's recorded decline unrepresentable
+ * rather than merely unenforced.
+ */
+function requireLoadedAnalyzerPolicy(policy, stepKind) {
+    if (policy)
         return;
-    }
-    if (result.kind === "design_review_parallel") {
-        // Both passes are unsatisfied — dispatch the contract pass and the
-        // conceptual pass simultaneously. The conceptual pass is shallow (one agent)
-        // or deep (N independent perspective subagents + an independent judge),
-        // resolved JIT from the user-confirmed checkpoint / session config.
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
-        const contract = await prepareContractDispatch({
-            artifactsDir,
-            bundle: result.bundle,
-            maxUnits: conceptualSettings.max_units,
-        });
-        const conceptual = await prepareConceptualPass(artifactsDir, result.bundle, conceptualSettings);
-        const shortfall = mergeLaneShortfalls([
-            contract.shortfall,
-            conceptual.shortfall,
-        ]);
-        const dispatchPrompt = [
-            "# Design review — parallel dispatch",
+    throw new Error(`audit-code next-step: the ${stepKind} step is acquisition-bearing and requires the durable analyzer policy, which was not loaded. Refusing to emit it rather than proceeding with no recorded consent decisions.`);
+}
+/**
+ * The acquisition chokepoint's declared caller obligation, discharged in ONE
+ * place: BOTH halves of the loaded policy ride every acquisition call — the
+ * per-analyzer settings AND the recorded consent decisions. Dropping the
+ * decisions leaves a recorded decline unrepresentable at admission (the
+ * chokepoint would see `undefined` and read it as "not yet decided"), and no
+ * consent token is synthesized here on the operator's behalf: the field is
+ * absent, never an empty string.
+ */
+export function buildExternalAcquisitionOptions(policy) {
+    return {
+        enabled: true,
+        analyzers: policy.analyzers,
+        // Item B: recorded consent decisions ride into admission (granted admits
+        // without a token) and into the consent fold's pending computation.
+        analyzerConsent: policy.analyzer_consent,
+    };
+}
+const emitComplete = emissionRow(async ({ root, artifactsDir }, result) => {
+    const triage = result.triage;
+    const frictionPending = triage?.action === "dispose";
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "present_report",
+        status: frictionPending ? "ready" : "complete",
+        runId: null,
+        // INV-READY-STEP-CONTINUATION (COR-f6a36670): a ready step whose
+        // stop_condition instructs calling next-step again must carry the
+        // executable continuation command — never leave the host to reconstruct
+        // the invocation from prose.
+        allowedCommands: frictionPending
+            ? [nextStepCommand(root, artifactsDir)]
+            : [],
+        stopCondition: frictionPending
+            ? "Complete friction triage (write open_observations and any dispositions), then call next-step again."
+            : "Present the final audit report and stop.",
+        repoRoot: root,
+        artifactPaths: {
+            final_report: result.finalReportPath,
+            ...(triage ? { friction_record: triage.recordPath } : {}),
+        },
+        prompt: renderPresentReportPrompt(result.finalReportPath, triage),
+    });
+});
+const emitBlocked = emissionRow(async ({ root, artifactsDir }, result) => {
+    // The SAME operator-handoff blocked contract the pre-dispatch config
+    // failure emits — built from the one home, never re-typed here.
+    return blockedStepPlan(operatorHandoffBlock(root, artifactsDir, result.reason));
+});
+const emitDesignReviewParallel = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Both passes are unsatisfied — dispatch the contract pass and the
+    // conceptual pass simultaneously. The conceptual pass is shallow (one agent)
+    // or deep (N independent perspective subagents + an independent judge),
+    // resolved JIT from the user-confirmed checkpoint / session config.
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
+    const contract = await prepareContractDispatch({
+        artifactsDir,
+        bundle: result.bundle,
+        maxUnits: conceptualSettings.max_units,
+    });
+    const conceptual = await prepareConceptualPass(artifactsDir, result.bundle, conceptualSettings);
+    const shortfall = mergeLaneShortfalls([
+        contract.shortfall,
+        conceptual.shortfall,
+    ]);
+    const dispatchPrompt = [
+        "# Design review — parallel dispatch",
+        "",
+        ...renderLaneShortfallLines(shortfall),
+        "Run the two design-review passes concurrently. Do not wait for one before starting the other.",
+        "",
+        `1. ${contract.instructionLine}`,
+        `2. ${conceptual.instructionLines.join("\n   ")}`,
+        "",
+        "When the contract results and the conceptual results have both been written, run:",
+        "",
+        `  ${continueCommand}`,
+        "",
+    ].join("\n");
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "design_review_parallel",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Dispatch the contract and conceptual review subagents in parallel, then run next-step once both results are written.",
+        repoRoot: root,
+        artifactPaths: {
+            ...contract.artifactPaths,
+            ...conceptual.artifactPaths,
+        },
+        prompt: dispatchPrompt,
+        access: {
+            read_paths: [...contract.readPaths, ...conceptual.readPaths],
+            write_paths: [...contract.writePaths, ...conceptual.writePaths],
+        },
+        submissionShortfall: shortfall,
+    });
+});
+const emitDesignReviewContract = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Only the contract pass remains — dispatched exactly as in the parallel
+    // branch. This branch is reached whenever the conceptual pass is already
+    // done, i.e. late in a run the host itself drove, which is precisely when
+    // rendering the adversarial review into the host's own prompt would have it
+    // grade its own work (see prepareContractDispatch).
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const contract = await prepareContractDispatch({
+        artifactsDir,
+        bundle: result.bundle,
+        maxUnits: resolveConceptualReviewSettings(result.bundle).max_units,
+    });
+    const dispatchPrompt = [
+        "# Design review — contract pass",
+        "",
+        ...renderLaneShortfallLines(contract.shortfall),
+        contract.instructionLine,
+        "",
+        "When the contract results have been written, run:",
+        "",
+        `  ${continueCommand}`,
+        "",
+    ].join("\n");
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "design_review_contract",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Dispatch the contract review subagent, then run next-step once the contract results are written.",
+        repoRoot: root,
+        artifactPaths: contract.artifactPaths,
+        prompt: dispatchPrompt,
+        access: {
+            read_paths: contract.readPaths,
+            write_paths: contract.writePaths,
+        },
+        submissionShortfall: contract.shortfall,
+    });
+});
+const emitDesignReviewConceptual = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Only the conceptual pass remains — shallow (one agent) or deep (N
+    // independent perspective subagents + an independent judge), resolved JIT
+    // from the user-confirmed checkpoint / session config.
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
+    const conceptual = await prepareConceptualPass(artifactsDir, result.bundle, conceptualSettings);
+    const prompt = [
+        "# Design review — conceptual pass",
+        "",
+        ...renderLaneShortfallLines(conceptual.shortfall),
+        conceptual.instructionLines.join("\n"),
+        "",
+        "When the conceptual results have been written, run:",
+        "",
+        `  ${continueCommand}`,
+        "",
+    ].join("\n");
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "design_review_conceptual",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: conceptual.deep
+            ? "Dispatch the conceptual perspective subagents in parallel, then the independent judge, then run next-step once the merged conceptual results are written."
+            : "Write conceptual review findings to the results path, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            design_review_conceptual_results: conceptual.conceptualResultsPath,
+            ...conceptual.artifactPaths,
+        },
+        prompt,
+        access: {
+            read_paths: conceptual.readPaths,
+            write_paths: conceptual.writePaths,
+        },
+        submissionShortfall: conceptual.shortfall,
+    });
+});
+const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result) => {
+    // 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);
+    const ceiling = resolveCharterCeiling(result.bundle.intent_checkpoint);
+    const kinds = charterExtractionKindsForCeiling(ceiling);
+    // Channel purity is a property of the INPUT (design resolution 4): each
+    // lane gets a tool-materialized evidence packet holding only its channel's
+    // material. Packets are (re)written on every emission — they derive from
+    // the bundle + disk, so re-materializing is idempotent and keeps a resumed
+    // lane's evidence current.
+    const packetPaths = [];
+    const laneSpecs = await Promise.all(kinds.map(async (kind) => {
+        const lane = charterExtractionLane(kind);
+        const submissionPath = laneSubmissionPath(artifactsDir, lane);
+        const packetPath = join(laneAssetsDir(artifactsDir), charterExtractionPacketFilename(kind));
+        await writeTextFile(packetPath, await materializeCharterPacket({ root, bundle: result.bundle, kind }));
+        packetPaths.push(packetPath);
+        return {
+            id: lane,
+            label: `Charter ${kind} author (blind lane)`,
+            promptFilename: `charter-extraction-${kind}-prompt.md`,
+            promptText: renderCharterKindLanePrompt(result.bundle, {
+                kind,
+                submissionPath,
+                packetPath,
+            }),
+        };
+    }));
+    const fanout = await materializeFanoutLanes({
+        artifactsDir,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: laneSpecs,
+    });
+    const completedLanes = fanout.lanes.filter((lane) => lane.resultExists);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "charter_extraction",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            "# audit-code charter extraction (per-kind blind lanes)",
             "",
-            ...renderLaneShortfallLines(shortfall),
-            "Run the two design-review passes concurrently. Do not wait for one before starting the other.",
+            ...renderLaneShortfallLines(fanout.shortfall),
+            "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.",
             "",
-            `1. ${contract.instructionLine}`,
-            `2. ${conceptual.instructionLines.join("\n   ")}`,
+            ...renderFanoutExecutionLines({
+                lanes: fanout.pendingLanes.map((lane) => ({
+                    label: lane.label,
+                    promptPath: lane.promptPath,
+                    resultPath: lane.resultPath,
+                })),
+            }),
             "",
-            "When the contract results and the conceptual results have both been written, run:",
+            ...(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}`,
             "",
-        ].join("\n");
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "design_review_parallel",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Dispatch the contract and conceptual review subagents in parallel, then run next-step once both results are written.",
-            repoRoot: root,
-            artifactPaths: {
-                ...contract.artifactPaths,
-                ...conceptual.artifactPaths,
-            },
-            prompt: dispatchPrompt,
-            access: {
-                read_paths: [...contract.readPaths, ...conceptual.readPaths],
-                write_paths: [...contract.writePaths, ...conceptual.writePaths],
+            "Read and follow only the new step prompt returned by that command.",
+            "",
+        ].join("\n"),
+        access: {
+            // Prompts + packets only: the lanes' whole input is materialized, so no
+            // repo/artifact read grant exists to leak another channel's evidence.
+            read_paths: [...fanout.readPaths, ...packetPaths],
+            write_paths: fanout.writePaths,
+        },
+        submissionShortfall: fanout.shortfall,
+    });
+});
+const emitCharterDelta = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Phase C.2 charter delta-mining (conceptual, teleological): an INDEPENDENT
+    // delta-miner reads the assembled charters (authored by a different pass, blind
+    // 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).
+    // Always-materialized (design resolution 2): the miner prompt is a lane FILE.
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const submissionPath = laneSubmissionPath(artifactsDir, GATE_LANES.charter_delta);
+    const lanePrompt = renderCharterDeltaPrompt(result.bundle, { submissionPath });
+    const fanout = await materializeFanoutLanes({
+        artifactsDir,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: [
+            {
+                id: GATE_LANES.charter_delta,
+                label: "Independent charter delta-miner",
+                promptFilename: "charter-delta-prompt.md",
+                promptText: lanePrompt,
             },
-            submissionShortfall: shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "design_review_contract") {
-        // Only the contract pass remains — dispatched exactly as in the parallel
-        // branch. This branch is reached whenever the conceptual pass is already
-        // done, i.e. late in a run the host itself drove, which is precisely when
-        // rendering the adversarial review into the host's own prompt would have it
-        // grade its own work (see prepareContractDispatch).
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const contract = await prepareContractDispatch({
-            artifactsDir,
-            bundle: result.bundle,
-            maxUnits: resolveConceptualReviewSettings(result.bundle).max_units,
-        });
-        const dispatchPrompt = [
-            "# Design review — contract pass",
+        ],
+    });
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "charter_delta",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            "# audit-code charter delta-mining",
             "",
-            ...renderLaneShortfallLines(contract.shortfall),
-            contract.instructionLine,
+            ...renderLaneShortfallLines(fanout.shortfall),
+            "The assembled charters are ready for the INDEPENDENT delta-miner (it did not author them).",
             "",
-            "When the contract results have been written, run:",
+            ...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}`,
             "",
-        ].join("\n");
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "design_review_contract",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Dispatch the contract review subagent, then run next-step once the contract results are written.",
-            repoRoot: root,
-            artifactPaths: contract.artifactPaths,
-            prompt: dispatchPrompt,
-            access: {
-                read_paths: contract.readPaths,
-                write_paths: contract.writePaths,
+            "Read and follow only the new step prompt returned by that command.",
+            "",
+        ].join("\n"),
+        access: {
+            read_paths: [
+                ...fanout.readPaths,
+                join(artifactsDir, "charter_register.json"),
+            ],
+            write_paths: fanout.writePaths,
+        },
+        submissionShortfall: fanout.shortfall,
+    });
+});
+const emitCharterClarification = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Phase D triangulation loop: the tool has already run the deterministic loop
+    // (partition → VOI-rank → risk-gate → split by attention) and surfaces the
+    // interactive queue here. The host relays each SYMMETRIC question and writes the
+    // answers back; the executor applies them + re-splits (interruptible: unanswered
+    // questions leave-open). Only reached at a deep+ ceiling with attention > 0 and
+    // ≥1 open interactive question.
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const answersPath = laneSubmissionPath(artifactsDir, GATE_LANES.charter_clarification);
+    const ceiling = resolveCharterCeiling(result.bundle.intent_checkpoint);
+    const clarificationPrompt = renderCharterClarificationPrompt(result.bundle, {
+        answersPath,
+        continueCommand,
+        ceiling,
+    });
+    const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.charter_clarification, promptText: clarificationPrompt }]);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "charter_clarification",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Relay each charter-alignment question to the user, write the answers to the answers path, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            charter_clarification_answers: answersPath,
+        },
+        prompt: [
+            ...renderLaneShortfallLines(shortfall),
+            clarificationPrompt,
+        ].join("\n"),
+        access: {
+            read_paths: [join(artifactsDir, "charter_clarification.json")],
+            write_paths: [answersPath],
+        },
+        submissionShortfall: shortfall,
+    });
+});
+const emitSystemicChallenge = emissionRow(async ({ root, artifactsDir }, result) => {
+    // Phase E second-order adversary (loop-until-dry): the tool has opened the loop
+    // and computed the language-neutral aggregate-metrics digest. The host dispatches
+    // 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.
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const submissionPath = laneSubmissionPath(artifactsDir, GATE_LANES.systemic_challenge);
+    const metrics = result.bundle.systemic_challenge?.metrics ?? aggregateMetricsDigest(result.bundle);
+    const adversaryPrompt = renderSecondOrderAdversaryPrompt({
+        round: (result.bundle.systemic_challenge?.rounds.length ?? 0) + 1,
+        priorFindingCount: result.bundle.systemic_challenge?.findings.length ?? 0,
+        metrics,
+        submissionPath,
+    });
+    // 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,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: [
+            {
+                id: GATE_LANES.systemic_challenge,
+                label: "Second-order adversary (improvement-seeking challenge)",
+                promptFilename: "systemic-challenge-prompt.md",
+                promptText: adversaryPrompt,
             },
-            submissionShortfall: contract.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "design_review_conceptual") {
-        // Only the conceptual pass remains — shallow (one agent) or deep (N
-        // independent perspective subagents + an independent judge), resolved JIT
-        // from the user-confirmed checkpoint / session config.
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
-        const conceptual = await prepareConceptualPass(artifactsDir, result.bundle, conceptualSettings);
-        const prompt = [
-            "# Design review — conceptual pass",
+        ],
+    });
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "systemic_challenge",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            "# audit-code systemic challenge (second-order adversary)",
+            "",
+            ...renderLaneShortfallLines(fanout.shortfall),
+            "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,
+                })),
+            }),
             "",
-            ...renderLaneShortfallLines(conceptual.shortfall),
-            conceptual.instructionLines.join("\n"),
+            "The executor must write its findings JSON to:",
             "",
-            "When the conceptual results have been written, run:",
+            `  ${submissionPath}`,
+            "",
+            "An EMPTY findings array is the deliberate loop terminator (this round found nothing new).",
+            "",
+            "When the result file exists, run:",
             "",
             `  ${continueCommand}`,
             "",
-        ].join("\n");
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "design_review_conceptual",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: conceptual.deep
-                ? "Dispatch the conceptual perspective subagents in parallel, then the independent judge, then run next-step once the merged conceptual results are written."
-                : "Write conceptual review findings to the results path, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                design_review_conceptual_results: conceptual.conceptualResultsPath,
-                ...conceptual.artifactPaths,
-            },
-            prompt,
-            access: {
-                read_paths: conceptual.readPaths,
-                write_paths: conceptual.writePaths,
-            },
-            submissionShortfall: conceptual.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "charter_extraction") {
-        // 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);
-        const ceiling = resolveCharterCeiling(result.bundle.intent_checkpoint);
-        const kinds = charterExtractionKindsForCeiling(ceiling);
-        // Channel purity is a property of the INPUT (design resolution 4): each
-        // lane gets a tool-materialized evidence packet holding only its channel's
-        // material. Packets are (re)written on every emission — they derive from
-        // the bundle + disk, so re-materializing is idempotent and keeps a resumed
-        // lane's evidence current.
-        const packetPaths = [];
-        const laneSpecs = await Promise.all(kinds.map(async (kind) => {
-            const lane = charterExtractionLane(kind);
-            const submissionPath = laneSubmissionPath(artifactsDir, lane);
-            const packetPath = join(laneAssetsDir(artifactsDir), charterExtractionPacketFilename(kind));
-            await writeTextFile(packetPath, await materializeCharterPacket({ root, bundle: result.bundle, kind }));
-            packetPaths.push(packetPath);
-            return {
-                id: lane,
-                label: `Charter ${kind} author (blind lane)`,
-                promptFilename: `charter-extraction-${kind}-prompt.md`,
-                promptText: renderCharterKindLanePrompt(result.bundle, {
-                    kind,
-                    submissionPath,
-                    packetPath,
-                }),
-            };
-        }));
-        const fanout = await materializeFanoutLanes({
-            artifactsDir,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: laneSpecs,
-        });
-        const completedLanes = fanout.lanes.filter((lane) => lane.resultExists);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "charter_extraction",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                "# audit-code charter extraction (per-kind blind lanes)",
-                "",
-                ...renderLaneShortfallLines(fanout.shortfall),
-                "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,
-                    })),
-                }),
-                "",
-                ...(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: {
-                // Prompts + packets only: the lanes' whole input is materialized, so no
-                // repo/artifact read grant exists to leak another channel's evidence.
-                read_paths: [...fanout.readPaths, ...packetPaths],
-                write_paths: fanout.writePaths,
-            },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "charter_delta") {
-        // Phase C.2 charter delta-mining (conceptual, teleological): an INDEPENDENT
-        // delta-miner reads the assembled charters (authored by a different pass, blind
-        // 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).
-        // Always-materialized (design resolution 2): the miner prompt is a lane FILE.
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const submissionPath = laneSubmissionPath(artifactsDir, GATE_LANES.charter_delta);
-        const lanePrompt = renderCharterDeltaPrompt(result.bundle, { submissionPath });
-        const fanout = await materializeFanoutLanes({
-            artifactsDir,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: [
-                {
-                    id: GATE_LANES.charter_delta,
-                    label: "Independent charter delta-miner",
-                    promptFilename: "charter-delta-prompt.md",
-                    promptText: lanePrompt,
-                },
+            "Read and follow only the new step prompt returned by that command.",
+            "",
+        ].join("\n"),
+        access: {
+            read_paths: [
+                ...fanout.readPaths,
+                join(artifactsDir, "systemic_challenge.json"),
             ],
-        });
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "charter_delta",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                "# audit-code charter delta-mining",
-                "",
-                ...renderLaneShortfallLines(fanout.shortfall),
-                "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: [
-                    ...fanout.readPaths,
-                    join(artifactsDir, "charter_register.json"),
-                ],
-                write_paths: fanout.writePaths,
-            },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "charter_clarification") {
-        // Phase D triangulation loop: the tool has already run the deterministic loop
-        // (partition → VOI-rank → risk-gate → split by attention) and surfaces the
-        // interactive queue here. The host relays each SYMMETRIC question and writes the
-        // answers back; the executor applies them + re-splits (interruptible: unanswered
-        // questions leave-open). Only reached at a deep+ ceiling with attention > 0 and
-        // ≥1 open interactive question.
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const answersPath = laneSubmissionPath(artifactsDir, GATE_LANES.charter_clarification);
-        const ceiling = resolveCharterCeiling(result.bundle.intent_checkpoint);
-        const clarificationPrompt = renderCharterClarificationPrompt(result.bundle, {
-            answersPath,
+            write_paths: fanout.writePaths,
+        },
+        submissionShortfall: fanout.shortfall,
+    });
+});
+const emitConfirmIntent = emissionRow(async ({ root, artifactsDir, argv }, result) => {
+    const intentCheckpointPath = join(artifactsDir, "intent_checkpoint.json");
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const preDigest = computeScopePreDigest(result.bundle, root, getFlag(argv, "--since"));
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "confirm_intent",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Write intent_checkpoint.json with the confirmed scope and intent, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            intent_checkpoint: intentCheckpointPath,
+        },
+        prompt: renderConfirmIntentPrompt(preDigest, {
+            intentCheckpointPath,
             continueCommand,
-            ceiling,
-        });
-        const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.charter_clarification, promptText: clarificationPrompt }]);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "charter_clarification",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Relay each charter-alignment question to the user, write the answers to the answers path, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                charter_clarification_answers: answersPath,
-            },
-            prompt: [
-                ...renderLaneShortfallLines(shortfall),
-                clarificationPrompt,
-            ].join("\n"),
-            access: {
-                read_paths: [join(artifactsDir, "charter_clarification.json")],
-                write_paths: [answersPath],
-            },
-            submissionShortfall: shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "systemic_challenge") {
-        // Phase E second-order adversary (loop-until-dry): the tool has opened the loop
-        // and computed the language-neutral aggregate-metrics digest. The host dispatches
-        // 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.
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const submissionPath = laneSubmissionPath(artifactsDir, GATE_LANES.systemic_challenge);
-        const metrics = result.bundle.systemic_challenge?.metrics ?? aggregateMetricsDigest(result.bundle);
-        const adversaryPrompt = renderSecondOrderAdversaryPrompt({
-            round: (result.bundle.systemic_challenge?.rounds.length ?? 0) + 1,
-            priorFindingCount: result.bundle.systemic_challenge?.findings.length ?? 0,
-            metrics,
-            submissionPath,
-        });
-        // 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,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: [
-                {
-                    id: GATE_LANES.systemic_challenge,
-                    label: "Second-order adversary (improvement-seeking challenge)",
-                    promptFilename: "systemic-challenge-prompt.md",
-                    promptText: adversaryPrompt,
-                },
-            ],
-        });
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "systemic_challenge",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                "# audit-code systemic challenge (second-order adversary)",
-                "",
-                ...renderLaneShortfallLines(fanout.shortfall),
-                "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: [
-                    ...fanout.readPaths,
-                    join(artifactsDir, "systemic_challenge.json"),
-                ],
-                write_paths: fanout.writePaths,
-            },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "confirm_intent") {
-        const intentCheckpointPath = join(artifactsDir, "intent_checkpoint.json");
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const preDigest = computeScopePreDigest(result.bundle, root, getFlag(argv, "--since"));
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "confirm_intent",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Write intent_checkpoint.json with the confirmed scope and intent, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                intent_checkpoint: intentCheckpointPath,
+            unresolvedConstraintClauses: unresolvedConstraintClauses(result.bundle.intent_checkpoint),
+        }),
+    });
+});
+const emitAnalyzerConsent = emissionRow(async ({ root, artifactsDir, analyzerPolicy }, result) => {
+    // Acquisition-bearing row: the durable policy must have loaded.
+    requireLoadedAnalyzerPolicy(analyzerPolicy, "analyzer_consent");
+    const decisionsPath = laneSubmissionPath(artifactsDir, GATE_LANES.analyzer_consent);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const consentPrompt = renderAnalyzerConsentPrompt({
+        pending: result.pending,
+        decisionsPath,
+        continueCommand,
+    });
+    const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.analyzer_consent, promptText: consentPrompt }]);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "analyzer_consent",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Present the consent offer to the operator, write their decisions to the decisions path, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            analyzer_consent_decisions: decisionsPath,
+        },
+        prompt: [...renderLaneShortfallLines(shortfall), consentPrompt].join("\n"),
+        submissionShortfall: shortfall,
+    });
+});
+const emitAnalyzerInstall = emissionRow(async ({ root, artifactsDir, analyzerPolicy }, result) => {
+    // Acquisition-bearing row: the durable policy must have loaded.
+    requireLoadedAnalyzerPolicy(analyzerPolicy, "analyzer_install");
+    const decisionsPath = laneSubmissionPath(artifactsDir, GATE_LANES.analyzer_decisions);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const installPrompt = renderAnalyzerInstallPrompt({
+        unresolved: result.unresolved,
+        decisionsPath,
+        continueCommand,
+    });
+    const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.analyzer_decisions, promptText: installPrompt }]);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "analyzer_install",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Write analyzer install decisions to the results path, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            analyzer_decisions: decisionsPath,
+        },
+        prompt: [...renderLaneShortfallLines(shortfall), installPrompt].join("\n"),
+        submissionShortfall: shortfall,
+    });
+});
+const emitEdgeReasoning = emissionRow(async ({ root, artifactsDir }, result) => {
+    const edgeReasoningResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.edge_reasoning);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const basePrompt = buildEdgeReasoningPrompt(result.candidates);
+    const contentHash = edgeReasoningContentHash(result.candidates);
+    // A prior malformed submission was quarantined (not silently destroyed) —
+    // 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);
+    // 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,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: [
+            {
+                id: GATE_LANES.edge_reasoning,
+                label: "Edge-reasoning rewrites",
+                promptFilename: "edge-reasoning-prompt.md",
+                promptText: rejectionNotice
+                    ? `${basePrompt}\n\n${rejectionNotice}`
+                    : basePrompt,
             },
-            prompt: renderConfirmIntentPrompt(preDigest, {
-                intentCheckpointPath,
+        ],
+    });
+    const edgeReasoningPromptPath = fanout.lanes[0].promptPath;
+    const shortfallLines = renderLaneShortfallLines(fanout.shortfall);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "edge_reasoning_dispatch",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            ...shortfallLines,
+            renderEdgeReasoningDispatchPrompt({
+                promptPath: edgeReasoningPromptPath,
+                resultsPath: edgeReasoningResultsPath,
                 continueCommand,
-                unresolvedConstraintClauses: unresolvedConstraintClauses(result.bundle.intent_checkpoint),
+                contentHash,
+                candidateCount: result.candidates.length,
             }),
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "analyzer_consent") {
-        const decisionsPath = laneSubmissionPath(artifactsDir, GATE_LANES.analyzer_consent);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const consentPrompt = renderAnalyzerConsentPrompt({
-            pending: result.pending,
-            decisionsPath,
-            continueCommand,
-        });
-        const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.analyzer_consent, promptText: consentPrompt }]);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "analyzer_consent",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Present the consent offer to the operator, write their decisions to the decisions path, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                analyzer_consent_decisions: decisionsPath,
-            },
-            prompt: [...renderLaneShortfallLines(shortfall), consentPrompt].join("\n"),
-            submissionShortfall: shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "analyzer_install") {
-        const decisionsPath = laneSubmissionPath(artifactsDir, GATE_LANES.analyzer_decisions);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const installPrompt = renderAnalyzerInstallPrompt({
-            unresolved: result.unresolved,
-            decisionsPath,
-            continueCommand,
-        });
-        const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.analyzer_decisions, promptText: installPrompt }]);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "analyzer_install",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Write analyzer install decisions to the results path, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                analyzer_decisions: decisionsPath,
-            },
-            prompt: [...renderLaneShortfallLines(shortfall), installPrompt].join("\n"),
-            submissionShortfall: shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "edge_reasoning") {
-        const edgeReasoningResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.edge_reasoning);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const basePrompt = buildEdgeReasoningPrompt(result.candidates);
-        const contentHash = edgeReasoningContentHash(result.candidates);
-        // A prior malformed submission was quarantined (not silently destroyed) —
-        // 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);
-        // 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,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: [
-                {
-                    id: GATE_LANES.edge_reasoning,
-                    label: "Edge-reasoning rewrites",
-                    promptFilename: "edge-reasoning-prompt.md",
-                    promptText: rejectionNotice
-                        ? `${basePrompt}\n\n${rejectionNotice}`
-                        : basePrompt,
-                },
-            ],
-        });
-        const edgeReasoningPromptPath = fanout.lanes[0].promptPath;
-        const shortfallLines = renderLaneShortfallLines(fanout.shortfall);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "edge_reasoning_dispatch",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                ...shortfallLines,
-                renderEdgeReasoningDispatchPrompt({
-                    promptPath: edgeReasoningPromptPath,
-                    resultsPath: edgeReasoningResultsPath,
-                    continueCommand,
-                    contentHash,
-                    candidateCount: result.candidates.length,
-                }),
-            ].join("\n"),
-            access: {
-                read_paths: [edgeReasoningPromptPath],
-                write_paths: [edgeReasoningResultsPath],
-            },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "intent_equivalence") {
-        const verdictPath = laneSubmissionPath(artifactsDir, GATE_LANES.intent_equivalence);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const status = deriveIntentEquivalenceStatus(result.bundle);
-        const pending = status.kind === "prose_judgment_pending" ? status : undefined;
-        const fullPrompt = [
-            "# Intent-equivalence judgment (bounded)",
-            "",
-            "The intent checkpoint's PROSE changed since the planning artifacts derived",
-            "(structured fields are identical — this is wording only). Judge whether the",
-            "two prose forms express the SAME audit intent. Judge STRICTLY: any change",
-            "in scope, emphasis, constraint, or goal — however small — is `changed`.",
-            "Only pure rephrasing (wording, ordering, formatting) is `equivalent`.",
-            "An `equivalent` verdict keeps every planning artifact fresh; `changed`",
-            "re-derives the planning cascade against the new intent.",
-            "",
-            "## Prior prose normal form (what planning derived against)",
-            "",
-            "```json",
-            pending?.prior_prose ?? "(unavailable — re-run next-step)",
-            "```",
-            "",
-            "## Current prose normal form",
-            "",
-            "```json",
-            pending?.current_prose ?? "(unavailable — re-run next-step)",
-            "```",
-            "",
-            "## Verdict contract",
-            "",
-            "Write EXACTLY this JSON object (no extra fields) to:",
-            "",
-            `  ${verdictPath}`,
-            "",
-            "```json",
-            JSON.stringify({
-                verdict: "equivalent | changed",
-                judged_pair: {
-                    prior_hash: pending?.prior_hash ?? "",
-                    new_hash: pending?.new_hash ?? "",
-                },
-            }, null, 2),
-            "```",
-            "",
-            "`judged_pair` must carry the two hashes shown above verbatim — they bind",
-            "the verdict to this exact pair; a checkpoint edited again mid-judgment is",
-            "detected and re-judged.",
-            "",
-            `Then run: ${continueCommand}`,
-            "",
-        ].join("\n");
-        const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.intent_equivalence, promptText: fullPrompt }]);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "intent_equivalence",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            stopCondition: "Write the equivalence verdict to the results path, then run next-step.",
-            repoRoot: root,
-            artifactPaths: {
-                intent_equivalence_verdict: verdictPath,
-            },
-            prompt: [...renderLaneShortfallLines(shortfall), fullPrompt].join("\n"),
-            access: {
-                read_paths: [],
-                write_paths: [verdictPath],
+        ].join("\n"),
+        access: {
+            read_paths: [edgeReasoningPromptPath],
+            write_paths: [edgeReasoningResultsPath],
+        },
+        submissionShortfall: fanout.shortfall,
+    });
+});
+const emitIntentEquivalence = emissionRow(async ({ root, artifactsDir }, result) => {
+    const verdictPath = laneSubmissionPath(artifactsDir, GATE_LANES.intent_equivalence);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const status = deriveIntentEquivalenceStatus(result.bundle);
+    const pending = status.kind === "prose_judgment_pending" ? status : undefined;
+    const fullPrompt = [
+        "# Intent-equivalence judgment (bounded)",
+        "",
+        "The intent checkpoint's PROSE changed since the planning artifacts derived",
+        "(structured fields are identical — this is wording only). Judge whether the",
+        "two prose forms express the SAME audit intent. Judge STRICTLY: any change",
+        "in scope, emphasis, constraint, or goal — however small — is `changed`.",
+        "Only pure rephrasing (wording, ordering, formatting) is `equivalent`.",
+        "An `equivalent` verdict keeps every planning artifact fresh; `changed`",
+        "re-derives the planning cascade against the new intent.",
+        "",
+        "## Prior prose normal form (what planning derived against)",
+        "",
+        "```json",
+        pending?.prior_prose ?? "(unavailable — re-run next-step)",
+        "```",
+        "",
+        "## Current prose normal form",
+        "",
+        "```json",
+        pending?.current_prose ?? "(unavailable — re-run next-step)",
+        "```",
+        "",
+        "## Verdict contract",
+        "",
+        "Write EXACTLY this JSON object (no extra fields) to:",
+        "",
+        `  ${verdictPath}`,
+        "",
+        "```json",
+        JSON.stringify({
+            verdict: "equivalent | changed",
+            judged_pair: {
+                prior_hash: pending?.prior_hash ?? "",
+                new_hash: pending?.new_hash ?? "",
             },
-            submissionShortfall: shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "critical_flow_fallback") {
-        const fallbackResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.critical_flow_fallback);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        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.";
-        // Always-materialized (design resolution 2): the (potentially ~340-line)
-        // flow-stub prompt is a lane FILE, never inlined into the step prompt. The
-        // results-path section is the lane materializer's, not this emitter's.
-        const lanePrompt = basePrompt;
-        const fanout = await materializeFanoutLanes({
-            artifactsDir,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: [
-                {
-                    id: GATE_LANES.critical_flow_fallback,
-                    label: "Critical-flow fallback enrichment",
-                    promptFilename: "critical-flow-fallback-prompt.md",
-                    promptText: lanePrompt,
-                },
-            ],
-        });
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "critical_flow_fallback",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                "# audit-code critical-flow fallback",
-                "",
-                ...renderLaneShortfallLines(fanout.shortfall),
-                ...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: fanout.readPaths,
-                write_paths: fanout.writePaths,
+        }, null, 2),
+        "```",
+        "",
+        "`judged_pair` must carry the two hashes shown above verbatim — they bind",
+        "the verdict to this exact pair; a checkpoint edited again mid-judgment is",
+        "detected and re-judged.",
+        "",
+        `Then run: ${continueCommand}`,
+        "",
+    ].join("\n");
+    const shortfall = await recordExpectedLanes(artifactsDir, AUDIT_GATE_SUBMISSION_SCOPE, [{ lane: GATE_LANES.intent_equivalence, promptText: fullPrompt }]);
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "intent_equivalence",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        stopCondition: "Write the equivalence verdict to the results path, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            intent_equivalence_verdict: verdictPath,
+        },
+        prompt: [...renderLaneShortfallLines(shortfall), fullPrompt].join("\n"),
+        access: {
+            read_paths: [],
+            write_paths: [verdictPath],
+        },
+        submissionShortfall: shortfall,
+    });
+});
+const emitCriticalFlowFallback = emissionRow(async ({ root, artifactsDir }, result) => {
+    const fallbackResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.critical_flow_fallback);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    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.";
+    // Always-materialized (design resolution 2): the (potentially ~340-line)
+    // flow-stub prompt is a lane FILE, never inlined into the step prompt. The
+    // results-path section is the lane materializer's, not this emitter's.
+    const lanePrompt = basePrompt;
+    const fanout = await materializeFanoutLanes({
+        artifactsDir,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: [
+            {
+                id: GATE_LANES.critical_flow_fallback,
+                label: "Critical-flow fallback enrichment",
+                promptFilename: "critical-flow-fallback-prompt.md",
+                promptText: lanePrompt,
             },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    if (result.kind === "synthesis_narrative") {
-        const narrativeResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.synthesis_narrative);
-        const continueCommand = nextStepCommand(root, artifactsDir);
-        const basePrompt = result.bundle.audit_findings
-            ? renderSynthesisNarrativePrompt(result.bundle.audit_findings)
-            : "# Synthesis narrative\n\nNo findings report is available; write an empty themes array.";
-        // 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.
-        // The results-path section is the lane materializer's, not this emitter's.
-        const lanePrompt = basePrompt;
-        const fanout = await materializeFanoutLanes({
-            artifactsDir,
-            runId: AUDIT_GATE_SUBMISSION_SCOPE,
-            lanes: [
-                {
-                    id: GATE_LANES.synthesis_narrative,
-                    label: "Synthesis narrative (themes / exec summary / top risks)",
-                    promptFilename: "synthesis-narrative-prompt.md",
-                    promptText: lanePrompt,
-                },
-            ],
-        });
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "synthesis_narrative",
-            status: "ready",
-            runId: null,
-            allowedCommands: [continueCommand],
-            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: fanout.artifactPaths,
-            prompt: [
-                "# audit-code synthesis narrative",
-                "",
-                ...renderLaneShortfallLines(fanout.shortfall),
-                ...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,
+        ],
+    });
+    return currentStepPlan({
+        artifactsDir,
+        stepKind: "critical_flow_fallback",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            "# audit-code critical-flow fallback",
+            "",
+            ...renderLaneShortfallLines(fanout.shortfall),
+            ...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: fanout.readPaths,
+            write_paths: fanout.writePaths,
+        },
+        submissionShortfall: fanout.shortfall,
+    });
+});
+const emitSynthesisNarrative = emissionRow(async ({ root, artifactsDir }, result) => {
+    const narrativeResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.synthesis_narrative);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    const basePrompt = result.bundle.audit_findings
+        ? renderSynthesisNarrativePrompt(result.bundle.audit_findings)
+        : "# Synthesis narrative\n\nNo findings report is available; write an empty themes array.";
+    // 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.
+    // The results-path section is the lane materializer's, not this emitter's.
+    const lanePrompt = basePrompt;
+    const fanout = await materializeFanoutLanes({
+        artifactsDir,
+        runId: AUDIT_GATE_SUBMISSION_SCOPE,
+        lanes: [
+            {
+                id: GATE_LANES.synthesis_narrative,
+                label: "Synthesis narrative (themes / exec summary / top risks)",
+                promptFilename: "synthesis-narrative-prompt.md",
+                promptText: lanePrompt,
             },
-            submissionShortfall: fanout.shortfall,
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    const step = await renderSemanticReviewStep({
-        root,
+        ],
+    });
+    return currentStepPlan({
         artifactsDir,
-        activeReviewRun: result.activeReviewRun,
-        selectedExecutor: result.selectedExecutor,
-        inProcessMadeProgress: result.inProcessMadeProgress,
-        ingestIssues: result.ingestIssues,
+        stepKind: "synthesis_narrative",
+        status: "ready",
+        runId: null,
+        allowedCommands: [continueCommand],
+        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: fanout.artifactPaths,
+        prompt: [
+            "# audit-code synthesis narrative",
+            "",
+            ...renderLaneShortfallLines(fanout.shortfall),
+            ...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,
+        },
+        submissionShortfall: fanout.shortfall,
     });
-    console.log(JSON.stringify(step, null, 2));
-}
+});
+/**
+ * The step-emission dispatch table: exactly one row per host-actionable result
+ * kind. Typed as a TOTAL record over the kind union, so a kind added upstream
+ * with no row here is a compile error rather than a step that silently falls
+ * through to the semantic-review dispatch.
+ *
+ * Exported together with the handled-kinds set below so a drift guard imports
+ * the real thing instead of reconstructing it by reading a branch chain.
+ */
+export const NEXT_STEP_EMISSION_TABLE = {
+    complete: emitComplete,
+    blocked: emitBlocked,
+    design_review_parallel: emitDesignReviewParallel,
+    design_review_contract: emitDesignReviewContract,
+    design_review_conceptual: emitDesignReviewConceptual,
+    charter_extraction: emitCharterExtraction,
+    charter_delta: emitCharterDelta,
+    charter_clarification: emitCharterClarification,
+    systemic_challenge: emitSystemicChallenge,
+    confirm_intent: emitConfirmIntent,
+    analyzer_consent: emitAnalyzerConsent,
+    analyzer_install: emitAnalyzerInstall,
+    edge_reasoning: emitEdgeReasoning,
+    intent_equivalence: emitIntentEquivalence,
+    critical_flow_fallback: emitCriticalFlowFallback,
+    synthesis_narrative: emitSynthesisNarrative,
+};
+/**
+ * The one emission site for `audit-code next-step`. Rows return plans; this
+ * writes and logs exactly once, whichever row (or the fallback) produced it.
+ */
+const NEXT_STEP_EMISSION = createStepEmissionScaffold({
+    table: NEXT_STEP_EMISSION_TABLE,
+    // `semantic_review` is deliberately the FALLBACK rather than a row: the
+    // validation boundary here has always been "anything unmatched is a
+    // semantic-review dispatch", never an error on an unrecognized kind.
+    fallback: (ctx) => {
+        const result = ctx.result;
+        return semanticReviewPlan({
+            root: ctx.root,
+            artifactsDir: ctx.artifactsDir,
+            activeReviewRun: result.activeReviewRun,
+            selectedExecutor: result.selectedExecutor,
+            inProcessMadeProgress: result.inProcessMadeProgress,
+            ingestIssues: result.ingestIssues,
+        });
+    },
+    write: writeAuditStep,
+    // The tool's only externally-observable per-invocation contract.
+    log: (step) => {
+        console.log(JSON.stringify(step, null, 2));
+    },
+});
+/**
+ * The handled-kinds set, DERIVED from the table's own keys — never a second,
+ * hand-listed copy that could disagree with the table it describes. A drift
+ * guard consumes this as the real B side of its seam assertion.
+ */
+export const NEXT_STEP_EMISSION_KINDS = NEXT_STEP_EMISSION.handledKeys;
 //# sourceMappingURL=nextStepCommand.js.map