audit-tools 0.55.5 → 0.55.7

package/dist/audit/cli/nextStepCommand.js

@@ -7,19 +7,20 @@ import { validateAuditArguments, NEXT_STEP_ARGUMENTS } from "./argumentContract.
 import { functionalPreflightStep } from "./functionalPreflight.js";
 import { SEMANTIC_REVIEW_DEMAND } from "../../shared/types/stepContract.js";
 import { INDEPENDENT_CONTEXT, SEPARATE_CONTEXT_OR_SELF } from "../../shared/prompts.js";
-// sites-pinned: tests/audit/next-step-helpers.test.ts, tests/audit/charter-emit-order.test.ts, tests/audit/executor-registry-sync.test.ts, tests/audit/pipeline-integration.test.ts
+// sites-pinned: tests/audit/next-step-helpers.test.ts, tests/audit/charter-emit-order.test.ts, tests/audit/executor-registry-sync.test.ts, tests/audit/pipeline-integration.test.ts, tests/audit/review-file-map-context.test.ts, tests/audit/artifacts-dir-rollover.test.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { loadAnalyzerPolicy, loadSessionIntent, applyGuidanceFile, applyGuidanceText, runWithBlockedStepBackstop, writeBlockedStepContract, laneAssetsDir, hostScratchDir, renderFanoutExecutionLines, writeTextFile, writeJsonFile, toPromptPathToken, AUDIT_FINDINGS_FILENAME, } from "audit-tools/shared";
+import { loadAnalyzerPolicy, loadSessionIntent, applyGuidanceFile, applyGuidanceText, runWithBlockedStepBackstop, writeBlockedStepContract, laneAssetsDir, hostScratchDir, renderFanoutExecutionLines, writeJsonFile, toPromptPathToken, AUDIT_FINDINGS_FILENAME, } 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 { rollOverFinishedRun } from "../io/rollover.js";
 import { materializeFanoutLanes } from "./fanoutLanes.js";
-import { AUDIT_GATE_SUBMISSION_SCOPE, GATE_LANES, charterExtractionCoverageFilename, charterExtractionLane, charterExtractionPacketFilename, laneSubmissionPath, mergeLaneShortfalls, recordExpectedLanes, renderLaneShortfallLines, systemicChallengeLane, } from "./laneSubmissions.js";
-import { buildCharterPacketManifest, materializeCharterPacket, } from "../orchestrator/charterPackets.js";
+import { AUDIT_GATE_SUBMISSION_SCOPE, GATE_LANES, charterExtractionLane, laneSubmissionPath, mergeLaneShortfalls, recordExpectedLanes, renderLaneShortfallLines, systemicChallengeLane, } from "./laneSubmissions.js";
+import { carriedCharterLane } from "../orchestrator/charterPackets.js";
 import { buildEdgeReasoningPrompt, edgeReasoningContentHash, } from "../orchestrator/edgeReasoning.js";
-import { renderContractReviewPrompt, } from "../orchestrator/designReviewPrompt.js";
+import { designReviewFileMapContext, renderContractReviewPrompt, } from "../orchestrator/designReviewPrompt.js";
 import { resolveIntentLensSelection } from "../orchestrator/lensSelection.js";
 import { prepareConceptualDispatch, resolveConceptualReviewSettings, } from "./conceptualDispatch.js";
 import { buildDesignReReviewSection } from "../orchestrator/designReviewSnapshot.js";
@@ -33,12 +34,13 @@ import { renderCharterComparisonPrompt } from "./charterComparisonPrompt.js";
 import { renderCharterFidelityPrompt } from "./charterFidelityPrompt.js";
 import { buildCharterFidelityPacket } from "../orchestrator/charterFidelityPacket.js";
 import { renderCharterClarificationPrompt } from "./charterClarificationPrompt.js";
-import { renderSecondOrderAdversaryPrompt } from "../systemic/secondOrderAdversaryPrompt.js";
+import { adversaryFileMapContext, renderSecondOrderAdversaryPrompt, } from "../systemic/secondOrderAdversaryPrompt.js";
 import { aggregateMetricsDigest } from "../systemic/aggregateMetricsDigest.js";
 import { resolveCharterCeiling } from "../orchestrator/charterExtractionExecutor.js";
 import { ensureSupervisorDirs } from "../io/runArtifacts.js";
 import { persistConfigErrorHandoff, } from "./reviewRun.js";
 import { renderSemanticReviewStep, prepareSemanticReviewWorkload } from "./semanticReviewStep.js";
+import { lookupRunSince } from "../io/runSnapshot.js";
 import { renderConfirmIntentPrompt } from "./confirmIntentStep.js";
 import { writeCurrentStep, STEP_CONTRACT_VERSION } from "./steps.js";
 import { nextStepCommand, renderAnalyzerConsentPrompt, renderAnalyzerInstallPrompt, renderEdgeReasoningDispatchPrompt, renderPresentReportPrompt, } from "./prompts.js";
@@ -46,7 +48,7 @@ import { getArtifactsDir, getFlag, hasFlag, getRootDir, getTimeoutMs, warnIfNotG
 // Import the helpers used locally, then re-export the full helper surface so
 // existing imports remain valid (an `export … from` clause creates no local
 // bindings, so the locally-used names must be imported explicitly).
-import { runDeterministicForNextStep, renderDesignReviewRejectionNotice, renderEdgeReasoningRejectionNotice, } from "./nextStepHelpers.js";
+import { runDeterministicForNextStep, renderDesignReviewRejectionNotice, renderEdgeReasoningRejectionNotice, writeCharterLaneAssets, } from "./nextStepHelpers.js";
 export { tryConsumeSubmission, consumeArraySubmission, consumeObjectSubmission, renderDesignReviewRejectionNotice, renderEdgeReasoningRejectionNotice, buildTerminalStep, handleGraphEnrichmentBranch, handleDesignReviewBranch, handleSynthesisNarrativeBranch, executeAndRecord, checkFinalizationCycle, checkNoProgressBeforeDispatch, runDeterministicForNextStep, } from "./nextStepHelpers.js";
 /**
  * The two host-facing notices every design-review pass prepends to its prompt:
@@ -76,10 +78,11 @@ async function designReviewNotesSection(artifactsDir, bundle, pass) {
  * packet it prepares first. Settings therefore stay an INPUT here rather than
  * being resolved inside, which keeps each branch's write ordering unchanged.
  */
-async function prepareConceptualPass(artifactsDir, bundle, settings) {
+async function prepareConceptualPass(artifactsDir, sourceRoot, bundle, settings) {
     const notesSection = await designReviewNotesSection(artifactsDir, bundle, "conceptual");
     return prepareConceptualDispatch({
         artifactsDir,
+        sourceRoot,
         bundle,
         settings,
         ...notesSection,
@@ -109,8 +112,13 @@ async function prepareContractDispatch(opts) {
     // it is told which lenses the operator selected, from the ONE resolution every
     // draw reads.
     const lenses = resolveIntentLensSelection(opts.bundle.intent_checkpoint?.lens_selection);
+    const reviewOptions = {
+        max_units: opts.maxUnits,
+        ...(lenses === undefined ? {} : { lenses }),
+    };
     const fanout = await materializeFanoutLanes({
         artifactsDir: opts.artifactsDir,
+        sourceRoot: opts.sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -120,14 +128,14 @@ async function prepareContractDispatch(opts) {
                 ...SEMANTIC_REVIEW_DEMAND,
                 label: "Contract review (adversarial)",
                 promptFilename: "design-review-contract-prompt.md",
+                // The prompt carries the call-site map's summary; the complete map is
+                // this read-only, bound file.
+                generatedContext: [designReviewFileMapContext(opts.bundle, reviewOptions).contextFile],
                 // No results-path section here: `materializeFanoutLanes` appends the one
                 // canonical footer (bound path + the read-only-executor alternative) to
                 // every lane prompt it writes.
                 promptText: [
-                    renderContractReviewPrompt(opts.bundle, {
-                        max_units: opts.maxUnits,
-                        ...(lenses === undefined ? {} : { lenses }),
-                    }),
+                    renderContractReviewPrompt(opts.bundle, reviewOptions),
                     ...[notesSection.reReviewSection, notesSection.rejectionNotice]
                         .filter((section) => Boolean(section))
                         .flatMap((section) => ["", section]),
@@ -142,7 +150,7 @@ async function prepareContractDispatch(opts) {
             contract_prompt: promptPath,
             contract_results: resultsPath,
         },
-        readPaths: [promptPath],
+        readPaths: [promptPath, ...fanout.lanes[0].generatedContextPaths],
         writePaths: [resultsPath],
         shortfall: fanout.shortfall,
     };
@@ -188,16 +196,20 @@ export async function cmdNextStep(argv) {
     }));
 }
 async function cmdNextStepBody(argv, root, artifactsDir) {
+    // Rollover (owner decision 2026-10-08, "keep the artifacts dir"): a run that
+    // ENDED — its terminal step presented a promoted report — becomes this run's
+    // starting point: its derived work stays for the staleness DAG to judge, and
+    // everything that belonged to it goes. A run whose report was never promoted
+    // has no run-ended marker; the fold's terminal step presents and promotes it,
+    // so it is not rolled over. Must run BEFORE the sweep, the mkdir and applyGuidanceFile
+    // below (fresh guidance must never be swept), and before the fold loads the
+    // bundle (a retained `complete` state would short-circuit every derivation).
+    await rollOverFinishedRun(artifactsDir);
     // Pre-run sweep (docs-14; one rule, 74c89b226ab9b9cd): clear a stale working
     // dir so the fresh run starts clean — one whose run is `not_started` (junk
-    // from a run that never got going) or `complete` with its promotion already
-    // finished (a leftover from an rm that failed). The rule is the same one the
-    // `cleanup` verb applies; a `complete` dir with work left is a live
-    // continuation the fold's terminal step presents and promotes, so it survives
-    // entry. Must run BEFORE the mkdir below and BEFORE applyGuidanceFile (fresh
-    // guidance must never be swept). Inside the backstop, a malformed
-    // audit_state.json re-throw becomes a blocked-step contract rather than a raw
-    // crash.
+    // from a run that never got going). The rule is the same one the `cleanup`
+    // verb applies. Inside the backstop, a malformed audit_state.json re-throw
+    // becomes a blocked-step contract rather than a raw crash.
     await cleanupStaleArtifactsDir(artifactsDir);
     // Inside the backstop (AGY review catch): a supervisor-dir IO failure must
     // yield a blocked step too. The backstop's own writer needs no pre-created
@@ -248,18 +260,21 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         await NEXT_STEP_EMISSION.emitPlan(currentStepPlan(preflight));
         return;
     }
+    const timeoutMs = getTimeoutMs(argv);
+    const deadline = { at: Date.now() + timeoutMs };
     const result = await runDeterministicForNextStep({
         root,
         artifactsDir,
         selfCliPath: resolve(argv[1] ?? process.argv[1] ?? ""),
-        timeoutMs: getTimeoutMs(argv),
+        timeoutMs,
+        deadline,
         narrativeEnabled: true,
         analyzers: analyzerPolicy.analyzers,
         // Slice D: enable external-analyzer acquisition on the real CLI path (default-on;
         // 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: buildExternalAcquisitionOptions(analyzerPolicy),
+        externalAcquisition: { ...buildExternalAcquisitionOptions(analyzerPolicy), deadline },
         autoFix: {
             ...(hasFlag(argv, "--auto-fix") ? { enabled: true } : {}),
             dryRun: hasFlag(argv, "--dry-run"),
@@ -274,6 +289,7 @@ async function cmdNextStepBody(argv, root, artifactsDir) {
         advisoryNotice: result.advisoryNotice,
         argv,
         root,
+        sourceRoot: result.sourceRoot,
         artifactsDir,
         analyzerPolicy,
         result,
@@ -355,7 +371,7 @@ async function withReadyInspection(plan, ctx) {
     if (plan.via !== "current" || !ctx || !inspectionRun)
         return plan;
     const { handoff, resultPaths } = await prepareSemanticReviewWorkload({
-        root: ctx.root, artifactsDir: ctx.artifactsDir,
+        root: ctx.root, sourceRoot: ctx.sourceRoot, artifactsDir: ctx.artifactsDir,
         bundle: ctx.result.bundle, activeReviewRun: inspectionRun,
     });
     return {
@@ -396,27 +412,23 @@ async function writeAuditStep(plan) {
     }
 }
 /**
- * Insert the fold's drained advisory lines just under a prompt's first line —
- * its `# <title>` heading — where session-scoped advisories belong: before the
- * instructions they qualify.
+ * The task above can end with "run next-step and follow only the new prompt",
+ * and the carry is stated on one step only, so the lead tells the reader to act
+ * on the report first.
+ */
+const CARRIED_REPORT_LEAD = "Before you run next-step, read the report below on results from earlier work.";
+/**
+ * Append the fold's drained advisory lines AFTER a prompt's own instructions.
  *
- * A prompt that does not start with a heading (or has no second line) is
- * returned unchanged rather than spliced somewhere meaningless. Every audit
- * plan's prompt opens with its heading — each row is a literal template
- * starting with `# ` — so this is the degenerate-input arm, not the norm.
+ * The lines report on OTHER work — the results of an earlier review step — so
+ * they do not qualify this step's instructions, and the step states its own
+ * task first (owner, 2026-10-06, after the 2026-10-05 dogfood run put hundreds
+ * of carried lines between a design-review heading and its instructions).
  */
 function withAdvisoryNoticeInPrompt(prompt, advisoryNotice) {
     if (advisoryNotice === undefined || advisoryNotice.length === 0)
         return prompt;
-    const headingEnd = prompt.indexOf("\n");
-    if (!prompt.startsWith("# ") || headingEnd < 0)
-        return prompt;
-    return [
-        prompt.slice(0, headingEnd),
-        "",
-        ...advisoryNotice,
-        prompt.slice(headingEnd + 1),
-    ].join("\n");
+    return [prompt.trimEnd(), "", CARRIED_REPORT_LEAD, "", ...advisoryNotice].join("\n");
 }
 /**
  * Apply the fold's drained advisory lines to a step plan.
@@ -523,7 +535,7 @@ function renderIgnoredReviewNoticeLines(settings) {
         ? [settings.ignored_review_notice, ""]
         : [];
 }
-const emitDesignReviewParallel = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitDesignReviewParallel = emissionRow(async ({ root, sourceRoot, 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 lanes + an independent judge),
@@ -532,10 +544,11 @@ const emitDesignReviewParallel = emissionRow(async ({ root, artifactsDir }, resu
     const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
     const contract = await prepareContractDispatch({
         artifactsDir,
+        sourceRoot,
         bundle: result.bundle,
         maxUnits: conceptualSettings.max_units,
     });
-    const conceptual = await prepareConceptualPass(artifactsDir, result.bundle, conceptualSettings);
+    const conceptual = await prepareConceptualPass(artifactsDir, sourceRoot, result.bundle, conceptualSettings);
     const shortfall = mergeLaneShortfalls([
         contract.shortfall,
         conceptual.shortfall,
@@ -574,7 +587,7 @@ const emitDesignReviewParallel = emissionRow(async ({ root, artifactsDir }, resu
         submissionShortfall: shortfall,
     });
 });
-const emitDesignReviewContract = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitDesignReviewContract = emissionRow(async ({ root, sourceRoot, 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
@@ -584,6 +597,7 @@ const emitDesignReviewContract = emissionRow(async ({ root, artifactsDir }, resu
     const conceptualSettings = resolveConceptualReviewSettings(result.bundle);
     const contract = await prepareContractDispatch({
         artifactsDir,
+        sourceRoot,
         bundle: result.bundle,
         maxUnits: conceptualSettings.max_units,
     });
@@ -616,13 +630,13 @@ const emitDesignReviewContract = emissionRow(async ({ root, artifactsDir }, resu
         submissionShortfall: contract.shortfall,
     });
 });
-const emitDesignReviewConceptual = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitDesignReviewConceptual = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     // Only the conceptual pass remains — shallow (one agent) or deep (N
     // independent perspective lanes + 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 conceptual = await prepareConceptualPass(artifactsDir, sourceRoot, result.bundle, conceptualSettings);
     const prompt = [
         "# Design review — conceptual pass",
         "",
@@ -656,7 +670,7 @@ const emitDesignReviewConceptual = emissionRow(async ({ root, artifactsDir }, re
         submissionShortfall: conceptual.shortfall,
     });
 });
-const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitCharterExtraction = emissionRow(async ({ root, sourceRoot, 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
@@ -672,23 +686,28 @@ const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result)
     // lane's evidence current.
     // Promise.all retains `kinds` order. The materializer derives the packet
     // read paths from that ordered lane list, never from IO completion order.
-    const laneSpecs = await Promise.all(kinds.map(async (kind) => {
+    // A kind whose packet is unchanged since the previous register's lane was
+    // written is CARRIED by the merge (`carriedCharterLane`): no lane is asked
+    // to re-author it. Its packet and coverage are still written — the merge
+    // checks the carried lane's citations against them.
+    const laneResults = (await Promise.all(kinds.map(async (kind) => {
         const lane = charterExtractionLane(kind);
         const submissionPath = laneSubmissionPath(artifactsDir, lane);
-        const packetPath = join(laneAssetsDir(artifactsDir), charterExtractionPacketFilename(kind));
-        const packet = await materializeCharterPacket({
-            root,
-            bundle: result.bundle,
-            kind,
-        });
-        await writeTextFile(packetPath, packet.markdown);
         // The manifest the lane reads, persisted for the ingest pass: coverage
         // folds into the register and the delivered line runs are what a
         // citation is checked against.
-        await writeJsonFile(join(laneAssetsDir(artifactsDir), charterExtractionCoverageFilename(kind)), buildCharterPacketManifest(kind, packet.excerpts, packet.coverage));
+        const { packetPath, packet, digest } = await writeCharterLaneAssets({
+            sourceRoot,
+            artifactsDir,
+            bundle: result.bundle,
+            kind,
+        });
+        if (carriedCharterLane(result.bundle, kind, digest) !== undefined) {
+            return undefined;
+        }
         return {
             id: lane,
-            semanticInputRevision: hashContent(packet.markdown),
+            semanticInputRevision: digest,
             fileCount: new Set(packet.excerpts.map(excerpt => excerpt.source_path)).size,
             ...SEMANTIC_REVIEW_DEMAND,
             contextPaths: [packetPath],
@@ -700,9 +719,12 @@ const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result)
                 packetPath,
             }),
         };
-    }));
+    })));
+    const carriedKinds = kinds.filter((_, index) => laneResults[index] === undefined);
+    const laneSpecs = laneResults.filter((spec) => spec !== undefined);
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: laneSpecs,
     });
@@ -732,6 +754,12 @@ const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result)
                 })),
             }),
             "",
+            ...(carriedKinds.length > 0
+                ? [
+                    `Carried from the previous extraction (their evidence packet is unchanged — no lane is asked to re-author them): ${carriedKinds.join(", ")}.`,
+                    "",
+                ]
+                : []),
             ...(completedLanes.length > 0
                 ? [
                     `Already complete (results on disk — do NOT redo these lanes): ${completedLanes
@@ -756,7 +784,7 @@ const emitCharterExtraction = emissionRow(async ({ root, artifactsDir }, result)
         submissionShortfall: fanout.shortfall,
     });
 });
-const emitCharterComparison = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitCharterComparison = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     // Steps 2–3 of the charter layer: the comparison reader (it authored none of
     // the three lane DAGs) confirms the tool's correspondence candidates and
     // records the typed differences; the tool assembles, routes and pre-checks at
@@ -778,6 +806,7 @@ const emitCharterComparison = emissionRow(async ({ root, artifactsDir }, result)
     const lanePrompt = renderCharterComparisonPrompt(result.bundle, { submissionPath, laneGraphPaths });
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -829,7 +858,7 @@ const emitCharterComparison = emissionRow(async ({ root, artifactsDir }, result)
         submissionShortfall: fanout.shortfall,
     });
 });
-const emitCharterFidelity = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitCharterFidelity = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     // Step 4 of the charter layer: a SEPARATE lane judges, per finding candidate,
     // whether the sources genuinely differ. Blind by input: the tool materializes
     // a packet holding the accounts, their citations and the source slices at
@@ -837,11 +866,12 @@ const emitCharterFidelity = emissionRow(async ({ root, artifactsDir }, result) =
     const continueCommand = nextStepCommand(root, artifactsDir);
     const submissionPath = laneSubmissionPath(artifactsDir, GATE_LANES.charter_fidelity);
     const packetPath = join(laneAssetsDir(artifactsDir), "charter-fidelity-packet.md");
-    const fidelityPacket = await buildCharterFidelityPacket(result.bundle, root);
+    const fidelityPacket = await buildCharterFidelityPacket(result.bundle, sourceRoot);
     await writeFile(packetPath, fidelityPacket, "utf8");
     const lanePrompt = renderCharterFidelityPrompt({ submissionPath, packetPath });
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -926,8 +956,8 @@ const emitCharterClarification = emissionRow(async ({ root, artifactsDir }, resu
         submissionShortfall: shortfall,
     });
 });
-// sites-pinned: tests/audit/systemic-round-identity.test.ts
-const emitSystemicChallenge = emissionRow(async ({ root, artifactsDir }, result) => {
+// sites-pinned: tests/audit/systemic-round-identity.test.ts, tests/audit/review-file-map-context.test.ts
+const emitSystemicChallenge = emissionRow(async ({ root, sourceRoot, 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
@@ -956,6 +986,7 @@ const emitSystemicChallenge = emissionRow(async ({ root, artifactsDir }, result)
     // FILE — the adversary is a SEPARATE agent by lane class, on every host.
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         roundId: lane,
         lanes: [
@@ -965,6 +996,7 @@ const emitSystemicChallenge = emissionRow(async ({ root, artifactsDir }, result)
                 fileCount: result.bundle.repo_manifest?.files.length ?? 0,
                 ...SEMANTIC_REVIEW_DEMAND,
                 contextPaths: evidencePaths,
+                generatedContext: [adversaryFileMapContext(result.bundle).contextFile],
                 label: "Second-order adversary (improvement-seeking challenge)",
                 promptFilename: "systemic-challenge-prompt.md",
                 promptText: adversaryPrompt,
@@ -1015,10 +1047,13 @@ const emitSystemicChallenge = emissionRow(async ({ root, artifactsDir }, result)
         submissionShortfall: fanout.shortfall,
     });
 });
-const emitConfirmIntent = emissionRow(async ({ root, artifactsDir, argv }, result) => {
+const emitConfirmIntent = emissionRow(async ({ root, sourceRoot, artifactsDir, argv }, result) => {
     const intentCheckpointPath = join(artifactsDir, "intent_checkpoint.json");
     const continueCommand = nextStepCommand(root, artifactsDir);
-    const preDigest = await computeScopePreDigest(result.bundle, root, getFlag(argv, "--since"));
+    // The `--since` commit the fold resolved and recorded for this run, so the
+    // pre-digest names the same delta the planning draw uses.
+    const sinceFlag = getFlag(argv, "--since");
+    const preDigest = await computeScopePreDigest(result.bundle, sourceRoot, sinceFlag === undefined ? undefined : await lookupRunSince(artifactsDir, sinceFlag));
     let bootstrappedGuidance;
     if (!result.bundle.intent_checkpoint) {
         try {
@@ -1103,7 +1138,7 @@ const emitAnalyzerInstall = emissionRow(async ({ root, artifactsDir, analyzerPol
         submissionShortfall: shortfall,
     });
 });
-const emitEdgeReasoning = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitEdgeReasoning = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     const edgeReasoningResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.edge_reasoning);
     const continueCommand = nextStepCommand(root, artifactsDir);
     const basePrompt = buildEdgeReasoningPrompt(result.candidates);
@@ -1130,6 +1165,7 @@ const emitEdgeReasoning = emissionRow(async ({ root, artifactsDir }, result) =>
     // step so the K-of-N/result-exists semantics stay single-sourced.
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -1260,7 +1296,7 @@ const emitIntentEquivalence = emissionRow(async ({ root, artifactsDir }, result)
         submissionShortfall: shortfall,
     });
 });
-const emitCriticalFlowFallback = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitCriticalFlowFallback = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     const fallbackResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.critical_flow_fallback);
     const continueCommand = nextStepCommand(root, artifactsDir);
     const manifestPath = toPromptPathToken(join(artifactsDir, "critical_flows.json"));
@@ -1273,6 +1309,7 @@ const emitCriticalFlowFallback = emissionRow(async ({ root, artifactsDir }, resu
     const lanePrompt = basePrompt;
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -1320,7 +1357,7 @@ const emitCriticalFlowFallback = emissionRow(async ({ root, artifactsDir }, resu
         submissionShortfall: fanout.shortfall,
     });
 });
-const emitSynthesisNarrative = emissionRow(async ({ root, artifactsDir }, result) => {
+const emitSynthesisNarrative = emissionRow(async ({ root, sourceRoot, artifactsDir }, result) => {
     const narrativeResultsPath = laneSubmissionPath(artifactsDir, GATE_LANES.synthesis_narrative);
     const continueCommand = nextStepCommand(root, artifactsDir);
     // The complete findings report, named in the prompt AND granted below. The
@@ -1339,6 +1376,7 @@ const emitSynthesisNarrative = emissionRow(async ({ root, artifactsDir }, result
     const lanePrompt = basePrompt;
     const fanout = await materializeFanoutLanes({
         artifactsDir,
+        sourceRoot,
         runId: AUDIT_GATE_SUBMISSION_SCOPE,
         lanes: [
             {
@@ -1430,6 +1468,7 @@ const NEXT_STEP_EMISSION = createStepEmissionScaffold({
         const result = ctx.result;
         return semanticReviewPlan({
             root: ctx.root,
+            sourceRoot: ctx.sourceRoot,
             artifactsDir: ctx.artifactsDir,
             activeReviewRun: result.activeReviewRun,
             bundle: result.bundle,
@@ -1441,7 +1480,9 @@ const NEXT_STEP_EMISSION = createStepEmissionScaffold({
     },
     // The drained advisory lines decorate the PLAN inside the one writer, so
     // they reach every row (and the fallback) without a second splice per row.
-    write: async (plan, ctx) => writeAuditStep(await withReadyInspection(withAdvisoryNotice(plan, ctx?.advisoryNotice), ctx)),
+    // They decorate LAST: the ready-inspection section is part of this step's
+    // own task, and the carried report follows the whole task.
+    write: async (plan, ctx) => writeAuditStep(withAdvisoryNotice(await withReadyInspection(plan, ctx), ctx?.advisoryNotice)),
     // The tool's only externally-observable per-invocation contract.
     log: (step) => {
         console.log(JSON.stringify(step, null, 2));