audit-tools 0.55.5 → 0.55.7

package/dist/audit/cli/nextStepHelpers.js

@@ -1,6 +1,6 @@
 import { designReviewInputRevision } from "../orchestrator/designReviewProjection.js";
 import { decodeAuditReviewSubmission, readAuditReviewSubmission, currentAuditReviewInputRevision, auditLaneReviewRequirement } from "./reviewSubmission.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/next-step-integrity-reintake.test.ts
 /**
  * Extracted helpers for the next-step command.
  *
@@ -11,18 +11,20 @@ import { decodeAuditReviewSubmission, readAuditReviewSubmission, currentAuditRev
 import { AnalyzerRunConsentDecisionSchema, readRunConsentUnlocked, updateRunConsentUnlocked } from "../../shared/analyzerRunConsent.js";
 import { mkdir, readFile, unlink } from "node:fs/promises";
 import { join, relative } from "node:path";
-import { advance, ANALYZER_SETTINGS, describeStoppedFold, RunLogger, hashContent, isFileMissingError, isJsonParseError, isRecord, readJsonFile, readSubmissionIngestHistory, readTrailingSubmissionRefusals, persistAnalyzerSettings, writeJsonFile, } from "audit-tools/shared";
+import { AUDIT_FINDINGS_FILENAME, auditFindingsPath, promotedAuditFindingsPath, advance, ANALYZER_SETTINGS, describeStoppedFold, RunLogger, hashContent, isFileMissingError, isJsonParseError, isRecord, readJsonFile, readSubmissionIngestHistory, readTrailingSubmissionRefusals, persistAnalyzerSettings, writeJsonFile, writeTextFile, } from "audit-tools/shared";
 import { loadArtifactBundle, promoteFinalAuditReport, } from "../io/artifacts.js";
+import { ensureRunSourceRoot, removeRunSnapshot, resolveRunSince } from "../io/runSnapshot.js";
+import { markRunEnded } from "../io/rollover.js";
 import { auditReportPath, groundDesignFindings, repoPathUniverse, systemicChallengeSchema, laneAssetsDir, promotedAuditReportPath, } from "audit-tools/shared";
 import { charterExtractionKindsForCeiling } from "./charterExtractionPrompt.js";
 import { archiveCharterPackets } from "../orchestrator/charterPacketArchive.js";
 import { LANE_SUBMISSION_SCHEMAS, charterLaneSchema, describeSubmissionShapeMismatch, unwrapSubmissionArray, } from "./laneValidators.js";
 import { ConceptualJudgeSubmissionSchema, buildConceptualReviewAdjudication, deriveConceptualVerificationStatus, loadConceptualPerspectiveFindings, MalformedConceptualPerspectivesError, readConceptualReviewRoundManifest, SubmittedDesignFindingSchema, suppliedToolVerdictIssue, } from "../types/conceptualAdjudication.js";
-import { advanceAudit, engineMaxTransitions, findExecutorFailure, runSingleAdvanceStep, startAdvanceHeartbeat, MAX_DRAIN_STEPS, } from "../orchestrator/advance.js";
+import { engineMaxTransitions, findExecutorFailure, runSingleAdvanceStep, startAdvanceHeartbeat, MAX_DRAIN_STEPS, } from "../orchestrator/advance.js";
 import { buildDesignReviewSnapshot, isDesignReviewStale, } from "../orchestrator/designReviewSnapshot.js";
 import { computeStaleArtifacts, emitStalenessRecord, isMetadataMigrationStaleness, resetStalenessDedup, } from "../orchestrator/staleness.js";
 import { commitFold, createFoldTransaction, markSubmissionApplied, describeQuarantineLocation, quarantineLocationPhrase, quarantineSubmissionFile, quarantineSurvivalNote, recoverStagedSubmissions, stageLaneSubmission, } from "./foldTransaction.js";
-import { charterClarificationOmits, charterExtractionOmits, intentEquivalenceOmits, synthesisNarrativeOmits, systemicChallengeOmits, } from "../orchestrator/obligationPolicy.js";
+import { charterClarificationOmits, charterComparisonOmits, charterFidelityOmits, charterExtractionOmits, intentEquivalenceOmits, synthesisNarrativeOmits, systemicChallengeOmits, } from "../orchestrator/obligationPolicy.js";
 import { computeArtifactMetadata, computeArtifactStateSignature } from "../orchestrator/artifactMetadata.js";
 import { decideNextStep, PRIORITY, } from "../orchestrator/nextStep.js";
 import { isHostDelegationExecutor } from "../orchestrator/executors.js";
@@ -39,7 +41,8 @@ import { buildPendingAuditTasks } from "./dispatch/packetFilter.js";
 import { buildLineIndex } from "./lineIndex.js";
 import { ingestAuditHostResults, } from "./dispatch/hostHandoff.js";
 import { auditIngestRemedy, } from "../validation/ingestIssueCodes.js";
-import { CHARTER_EXTRACTION_MERGED_FILENAME, AUDIT_GATE_SUBMISSION_SCOPE, GATE_LANES, charterExtractionCoverageFilename, charterExtractionLane, closeDispatchedLaneOutcomes, laneSubmissionPath, laneSubmissionId, recordLaneOutcome, systemicChallengeLane, } from "./laneSubmissions.js";
+import { buildCharterPacketManifest, carriedCharterLane, materializeCharterPacket, } from "../orchestrator/charterPackets.js";
+import { CHARTER_EXTRACTION_MERGED_FILENAME, AUDIT_GATE_SUBMISSION_SCOPE, GATE_LANES, charterExtractionCoverageFilename, charterExtractionLane, charterExtractionPacketFilename, closeDispatchedLaneOutcomes, laneSubmissionPath, laneSubmissionId, recordLaneOutcome, systemicChallengeLane, } from "./laneSubmissions.js";
 import { recordHostResultOutcomes, renderIngestReportLines } from "audit-tools/shared";
 /**
  * Read a lane's submission from the TOOL-COMPUTED path its emission bound —
@@ -90,6 +93,17 @@ export async function tryConsumeSubmission(artifactsDir, lane, tx, currentInputR
         throw error;
     }
 }
+/**
+ * The fold's source root. Throws when read before the fold resolved the run's
+ * snapshot: a content read against the LIVE root would silently break the
+ * frozen-input property, so there is no fallback.
+ */
+export function requireSourceRoot(params) {
+    if (params.sourceRoot === undefined) {
+        throw new Error("next-step: a content read ran before the run's snapshot was resolved");
+    }
+    return params.sourceRoot;
+}
 /**
  * The return-kind set as RUNTIME data, so a drift guard can IMPORT the real set
  * instead of transcribing it into a literal that silently agrees with a second
@@ -153,14 +167,37 @@ async function promoteCompletedReport(artifactsDir) {
         readFile(inPlacePath, "utf8").catch(() => null),
     ]);
     // A missing in-place render alongside an existing promoted file is the
-    // legitimate re-entry AFTER promotion (promotion deletes artifactsDir);
+    // legitimate re-entry AFTER promotion (the next run's rollover deletes it);
     // a PRESENT in-place render that differs is precisely the stale-promotion
     // case and must fall through to promote.
     const alreadyPromoted = promotedText !== null && (inPlaceText === null || promotedText === inPlaceText);
-    if (alreadyPromoted)
-        return promotedPath;
-    const promoted = await promoteFinalAuditReport({ artifactsDir });
-    return promoted.promoted ? promotedPath : inPlacePath;
+    // The machine contract must be one level up before the run may end: the
+    // rollover deletes the in-place copy and re-archives only the append-only
+    // diagnostics (INV 1). Identity, not existence, here too — a PREVIOUS
+    // audit's promoted contract always exists — so a contract whose earlier copy
+    // failed is promoted again rather than taken as archived.
+    const [inPlaceFindings, promotedFindings] = await Promise.all([
+        readFile(auditFindingsPath(artifactsDir)).catch(() => null),
+        readFile(promotedAuditFindingsPath(artifactsDir)).catch(() => null),
+    ]);
+    const findingsCurrent = inPlaceFindings === null || (promotedFindings !== null && inPlaceFindings.equals(promotedFindings));
+    let findingsArchived = true;
+    if (!alreadyPromoted || !findingsCurrent) {
+        const promoted = await promoteFinalAuditReport({ artifactsDir });
+        if (!promoted.promoted)
+            return inPlacePath;
+        findingsArchived = !(promoted.unarchived ?? []).some((member) => member.startsWith(AUDIT_FINDINGS_FILENAME));
+    }
+    // A presented, promoted report ENDS the run, whatever its status (a rendered
+    // report on a stopped fold included — re-reading the same frozen snapshot
+    // would only stop it again): its snapshot goes, and the marker lets the next
+    // next-step roll the dir over (`rollOverFinishedRun`).
+    for (const problem of await removeRunSnapshot(artifactsDir)) {
+        process.stderr.write(`[audit-code] run snapshot cleanup: ${problem}\n`);
+    }
+    if (findingsArchived)
+        await markRunEnded(artifactsDir);
+    return promotedPath;
 }
 /**
  * Build the terminal step for a deterministic fold that has stopped advancing
@@ -217,7 +254,7 @@ function applyRunConsent(options, consent) {
 }
 export async function handleAnalyzerConsentBranch(params, bundle, state, analyzersRef, tx) {
     const pending = pendingAnalyzerConsent({
-        root: params.root,
+        root: requireSourceRoot(params),
         analyzers: analyzersRef.value,
         externalAcquisitionEnabled: params.externalAcquisition?.enabled,
         analyzerConsent: params.externalAcquisition?.analyzerConsent,
@@ -259,7 +296,7 @@ export async function handleGraphEnrichmentBranch(params, bundle, state, analyze
     // plan draw's classifier (`obligationPolicy.ts`) and this fold agree EXACTLY
     // on when the analyzer-install consent / edge-reasoning turns are owed.
     const pauseInputs = {
-        root: params.root,
+        root: requireSourceRoot(params),
         analyzers: analyzersRef.value,
         graphLlmEdgeReasoning: params.graphLlmEdgeReasoning,
     };
@@ -341,6 +378,7 @@ export async function handleGraphEnrichmentBranch(params, bundle, state, analyze
                 // and an unforced call would re-enter a drain.
                 const applied = await runStep({
                     root: params.root,
+                    sourceRoot: requireSourceRoot(params),
                     artifactsDir: params.artifactsDir,
                     analyzers: analyzersRef.value,
                     graphLlmEdgeReasoning: true,
@@ -1019,12 +1057,11 @@ export async function handleDesignReviewBranch(params, bundle, state, tx) {
 }
 /**
  * Drive one "poll the lane → apply+continue, else omit-or-return" gate — the
- * shape common to synthesis_narrative, charter_extraction,
- * charter_clarification, and systemic_challenge. See the section comment
- * above for the two gates that deviate and are not run through this engine.
+ * single-lane lifecycle. Charter extraction, graph enrichment, and design
+ * review retain their custom inner ordering and consumption policies.
  */
 async function runOmittableGate(descriptor, params, bundle, state, tx) {
-    const incoming = await tryConsumeSubmission(params.artifactsDir, descriptor.lane, tx, auditLaneReviewRequirement(descriptor.lane) === "ordinary" ? undefined : () => currentAuditReviewInputRevision(params.root, bundle, descriptor.lane));
+    const incoming = await tryConsumeSubmission(params.artifactsDir, descriptor.lane, tx, auditLaneReviewRequirement(descriptor.lane) === "ordinary" ? undefined : () => currentAuditReviewInputRevision(requireSourceRoot(params), bundle, descriptor.lane));
     if (incoming.status === "malformed") {
         // Not-JSON submission: same quarantine-loudly lifecycle as a mis-shaped one.
         await quarantineMisshapedSubmission(params.artifactsDir, incoming.path, descriptor.lane, incoming.reason);
@@ -1067,6 +1104,7 @@ export async function handleSynthesisNarrativeBranch(params, bundle, state, tx)
         schema: LANE_SUBMISSION_SCHEMAS[GATE_LANES.synthesis_narrative],
         apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "synthesis_narrative_executor",
             narrativeResultsPath: path,
@@ -1078,11 +1116,8 @@ export async function handleSynthesisNarrativeBranch(params, bundle, state, tx)
     }, params, bundle, state, tx);
 }
 /**
- * Handle the `intent_equivalence_executor` polling block (DD-9). Deviates from
- * `runOmittableGate` in ONE way: the consumed verdict is SCHEMA-validated here
- * and a mis-shaped submission is QUARANTINED with a stderr diagnostic (the
- * quarantine-loudly property) instead of being handed to the executor to crash
- * on. Returns:
+ * Handle the `intent_equivalence_executor` polling block (DD-9), using the
+ * common consume-before-omit lifecycle and schema quarantine. Returns:
  *   - `continue`  → a valid verdict was consumed + committed; re-scan.
  *   - `run_omit`  → a deterministic arm owns the resolution (baseline stamp /
  *     gate-version-stale / structured delta) — run the executor, stay drainable.
@@ -1090,32 +1125,20 @@ export async function handleSynthesisNarrativeBranch(params, bundle, state, tx)
  */
 export async function handleIntentEquivalenceBranch(params, bundle, state, tx) {
     const lane = GATE_LANES.intent_equivalence;
-    const incoming = await tryConsumeSubmission(params.artifactsDir, lane, tx);
-    if (incoming.status === "malformed") {
-        await quarantineMisshapedSubmission(params.artifactsDir, incoming.path, lane, incoming.reason);
-        // Fall through: no valid submission — re-emit or deterministically resolve.
-    }
-    else if (incoming.status === "ok") {
-        const parsed = LANE_SUBMISSION_SCHEMAS[lane].safeParse(incoming.value);
-        if (parsed.success) {
-            const applied = await runAuditStepUnlocked({
-                root: params.root,
-                artifactsDir: params.artifactsDir,
-                preferredExecutor: "intent_equivalence_executor",
-                intentEquivalenceVerdictPath: incoming.path,
-                scopeIndexMemo: params.scopeIndexMemo,
-            }, bundle);
-            markSubmissionApplied(tx, incoming.path);
-            return { action: "continue", bundle: applied.updated_bundle };
-        }
-        await quarantineMisshapedSubmission(params.artifactsDir, incoming.path, lane, parsed.error);
-        // Fall through: no valid submission — re-emit or deterministically resolve.
-    }
-    // Single-sourced with the plan draw's classifier (obligationPolicy.ts).
-    if (intentEquivalenceOmits(bundle)) {
-        return { action: "run_omit" };
-    }
-    return { action: "return", result: { kind: "intent_equivalence", state, bundle } };
+    return runOmittableGate({
+        kind: "intent_equivalence",
+        lane,
+        schema: LANE_SUBMISSION_SCHEMAS[lane],
+        apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
+            root: p.root,
+            sourceRoot: requireSourceRoot(p),
+            artifactsDir: p.artifactsDir,
+            preferredExecutor: "intent_equivalence_executor",
+            intentEquivalenceVerdictPath: path,
+            scopeIndexMemo: p.scopeIndexMemo,
+        }, foldBundle),
+        shouldOmit: intentEquivalenceOmits,
+    }, params, bundle, state, tx);
 }
 /**
  * Handle the `critical_flow_fallback_executor` submission-polling block.
@@ -1136,6 +1159,7 @@ export async function handleCriticalFlowFallbackBranch(params, bundle, state, tx
         schema: LANE_SUBMISSION_SCHEMAS[GATE_LANES.critical_flow_fallback],
         apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "critical_flow_fallback_executor",
             criticalFlowFallbackResultsPath: path,
@@ -1157,6 +1181,21 @@ export async function handleCriticalFlowFallbackBranch(params, bundle, state, tx
  *   - a `deep`/`deepest` ceiling with no submission yet → `return` the host step
  *     that renders the charter-extraction prompt.
  */
+/**
+ * Materialize one charter kind's evidence packet and its coverage manifest into
+ * the lane assets and return the packet's digest. The emitter calls it for every
+ * kind (each lane reads its packet), and so does the merge (the executor checks
+ * every lane's citations against its kind's manifest — a CARRIED lane's
+ * included — and folds every kind's coverage into the register). Idempotent:
+ * the packet derives from the bundle and the frozen snapshot.
+ */
+export async function writeCharterLaneAssets(params) {
+    const packetPath = join(laneAssetsDir(params.artifactsDir), charterExtractionPacketFilename(params.kind));
+    const packet = await materializeCharterPacket({ root: params.sourceRoot, bundle: params.bundle, kind: params.kind });
+    await writeTextFile(packetPath, packet.markdown);
+    await writeJsonFile(join(laneAssetsDir(params.artifactsDir), charterExtractionCoverageFilename(params.kind)), buildCharterPacketManifest(params.kind, packet.excerpts, packet.coverage));
+    return { packetPath, packet, digest: hashContent(packet.markdown) };
+}
 export async function handleCharterExtractionBranch(params, bundle, state, tx) {
     const ceiling = resolveCharterCeiling(bundle.intent_checkpoint);
     // Shallow ceiling (default): omit deterministically, no host turn, no lanes.
@@ -1176,13 +1215,33 @@ export async function handleCharterExtractionBranch(params, bundle, state, tx) {
     const kinds = charterExtractionKindsForCeiling(ceiling);
     const universe = new Set((bundle.repo_manifest?.files ?? []).map((file) => file.path));
     const laneValues = new Map();
+    // A kind whose packet did not change since the previous register's lane was
+    // written is CARRIED (the emitter asked no lane for it); every other kind is
+    // authored from a lane submission. The digest is the one each authored lane
+    // records.
+    const carried = new Map();
+    const digests = new Map();
+    for (const kind of kinds) {
+        const { digest } = await writeCharterLaneAssets({
+            sourceRoot: requireSourceRoot(params),
+            artifactsDir: params.artifactsDir,
+            bundle,
+            kind,
+        });
+        digests.set(kind, digest);
+        const reused = carriedCharterLane(bundle, kind, digest);
+        if (reused !== undefined)
+            carried.set(kind, reused);
+    }
     let quarantinedAny = false;
     for (const kind of kinds) {
+        if (carried.has(kind))
+            continue;
         const lane = charterExtractionLane(kind);
         // Staged per lane; an INCOMPLETE set is restored to its bound paths at
         // commit (un-applied), which is exactly the K-of-N resume the design
         // wants — pending lanes survive on disk until every lane is present.
-        const incoming = await tryConsumeSubmission(params.artifactsDir, lane, tx, () => currentAuditReviewInputRevision(params.root, bundle, lane));
+        const incoming = await tryConsumeSubmission(params.artifactsDir, lane, tx, () => currentAuditReviewInputRevision(requireSourceRoot(params), bundle, lane));
         if (incoming.status === "absent")
             continue;
         if (incoming.status === "malformed") {
@@ -1199,7 +1258,7 @@ export async function handleCharterExtractionBranch(params, bundle, state, tx) {
             await quarantineMisshapedSubmission(params.artifactsDir, incoming.path, lane, parsed.error);
         }
     }
-    if (!quarantinedAny && laneValues.size === kinds.length) {
+    if (!quarantinedAny && laneValues.size + carried.size === kinds.length) {
         // Complete + valid: tool-side merge (stable by lane order = canonical kind
         // order), then one executor ingest; unlink lane files only after apply.
         // The post-apply unlink is the standard consumed-submission lifecycle
@@ -1213,10 +1272,11 @@ export async function handleCharterExtractionBranch(params, bundle, state, tx) {
         // lane check itself (owner review of prompt 8, 2026-09-17).
         const merged = {
             // `inputs` was checked at the gate; the merged lane carries the DAG only.
-            lanes: kinds.map((kind) => {
+            lanes: kinds.filter((kind) => !carried.has(kind)).map((kind) => {
                 const { inputs: _declared, ...dag } = laneValues.get(kind).value;
-                return { kind, ...dag };
+                return { kind, packet_sha256: digests.get(kind), ...dag };
             }),
+            carried: [...carried.values()],
         };
         // The merged submission is TOOL-written, so it lives with the other lane
         // assets rather than under `submissions/` (which holds only what a host
@@ -1225,6 +1285,7 @@ export async function handleCharterExtractionBranch(params, bundle, state, tx) {
         await writeJsonFile(mergedPath, merged);
         const applied = await runAuditStepUnlocked({
             root: params.root,
+            sourceRoot: requireSourceRoot(params),
             artifactsDir: params.artifactsDir,
             preferredExecutor: "charter_extraction_executor",
             charterSubmissionPath: mergedPath,
@@ -1276,12 +1337,13 @@ export async function handleCharterComparisonBranch(params, bundle, state, tx) {
         schema: LANE_SUBMISSION_SCHEMAS[GATE_LANES.charter_comparison],
         apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "charter_comparison_executor",
             charterComparisonSubmissionPath: path,
             scopeIndexMemo: p.scopeIndexMemo,
         }, foldBundle),
-        shouldOmit: (b) => !(b.charter_register?.comparison_pending === true),
+        shouldOmit: charterComparisonOmits,
     }, params, bundle, state, tx);
 }
 /**
@@ -1296,12 +1358,13 @@ export async function handleCharterFidelityBranch(params, bundle, state, tx) {
         schema: LANE_SUBMISSION_SCHEMAS[GATE_LANES.charter_fidelity],
         apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "charter_fidelity_executor",
             charterFidelitySubmissionPath: path,
             scopeIndexMemo: p.scopeIndexMemo,
         }, foldBundle),
-        shouldOmit: (b) => !(b.charter_register?.fidelity_pending === true),
+        shouldOmit: charterFidelityOmits,
     }, params, bundle, state, tx);
 }
 /**
@@ -1325,6 +1388,7 @@ export async function handleCharterClarificationBranch(params, bundle, state, tx
         schema: LANE_SUBMISSION_SCHEMAS[GATE_LANES.charter_clarification],
         apply: (_value, path, p, foldBundle) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "charter_clarification_executor",
             clarificationAnswersPath: path,
@@ -1362,6 +1426,7 @@ export async function handleSystemicChallengeBranch(params, bundle, state, tx) {
         schema: systemicChallengeSchema(repoPathUniverse(bundle.repo_manifest)),
         apply: (_value, path, p, foldBundle, staged) => runAuditStepUnlocked({
             root: p.root,
+            sourceRoot: requireSourceRoot(p),
             artifactsDir: p.artifactsDir,
             preferredExecutor: "systemic_challenge_executor",
             systemicChallengePath: path,
@@ -1404,9 +1469,10 @@ export async function executeAndRecord(params, analyzers, decision, index, lastS
             status: "running",
             started_at: startedAt,
         });
-        const indexes = await manifestIndexes(params.root, bundle, ctx.manifestIndexCache);
+        const indexes = await manifestIndexes(requireSourceRoot(params), bundle, ctx.manifestIndexCache);
         const result = await runSingleAdvanceStep(bundle, {
-            root: params.root,
+            root: requireSourceRoot(params),
+            repositoryRoot: params.root,
             artifactsDir: params.artifactsDir,
             analyzers,
             graphLlmEdgeReasoning: params.graphLlmEdgeReasoning,
@@ -1539,8 +1605,8 @@ export async function checkNoProgressBeforeDispatch(ctx) {
             timestamp: new Date().toISOString(),
         });
         // A terminal INTENT, not the built terminal: `buildTerminalStep` can
-        // PROMOTE (which deletes artifactsDir), so it must run after the fold's
-        // commit and outside its hold. The marker above is the in-fold record.
+        // PROMOTE (which writes outside the dir and removes a complete run's
+        // snapshot), so it must run after the fold's commit and outside its hold. The marker above is the in-fold record.
         return {
             kind: "terminal_intent",
             bundle: ctx.bundle,
@@ -1764,6 +1830,21 @@ async function runDeterministicExecutor(bundle, ctx) {
     // silently roll back everything the fold has done (persist-once).
     return { kind: "transition", state: result.updated_bundle };
 }
+/** Adapt only the common outer outcome; handlers retain their lane lifecycle. */
+function omittableObligation(handler) {
+    return async (bundle, ctx) => {
+        const state = deriveAuditState(bundle, { emitStaleness: false });
+        const branch = await handler(ctx.params, bundle, state, ctx.tx);
+        switch (branch.action) {
+            case "return":
+                return { kind: "emit", step: branch.result, state: bundle };
+            case "continue":
+                return { kind: "transition", state: branch.bundle };
+            case "run_omit":
+                return runDeterministicExecutor(bundle, ctx);
+        }
+    };
+}
 /**
  * Build the audit obligation definitions in `PRIORITY` order. Each `execute`
  * relocates the corresponding arm of the hand-rolled `for` loop:
@@ -1808,17 +1889,7 @@ export function buildAuditObligations() {
         // confidence bar, apply the host submission against the carried bundle or
         // emit the host step. No autonomous omit — the host is always available to
         // author the enrichment.
-        critical_flow_fallback_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleCriticalFlowFallbackBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        critical_flow_fallback_current: omittableObligation(handleCriticalFlowFallbackBranch),
         // Graph enrichment: poll the analyzer-decision / edge-reasoning lane
         // artifacts first (emit a host step when one is needed), otherwise run the
         // deterministic enrichment executor.
@@ -1848,104 +1919,31 @@ export function buildAuditObligations() {
         // DD-9 intent-equivalence gate: consume a judge verdict (validated +
         // quarantined-loudly), resolve the deterministic arms in-fold, or emit the
         // bounded prose-equivalence judge step.
-        intent_equivalence_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleIntentEquivalenceBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        intent_equivalence_current: omittableObligation(handleIntentEquivalenceBranch),
         // Charter extraction (Phase C): consume the lane submissions (ingest+gate),
         // omit at a shallow ceiling, or emit the host charter-extraction step.
-        charter_extraction_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleCharterExtractionBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        charter_extraction_current: omittableObligation(handleCharterExtractionBranch),
         // Charter comparison (steps 2–3): consume the comparison submission, settle
         // deterministically when the register is not comparison_pending, or emit the
         // comparison reader's host step.
-        charter_comparison_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleCharterComparisonBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        charter_comparison_current: omittableObligation(handleCharterComparisonBranch),
         // Charter fidelity (step 4): the separate lane's verdicts, or the settle.
-        charter_fidelity_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleCharterFidelityBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        charter_fidelity_current: omittableObligation(handleCharterFidelityBranch),
         // The two design-review passes share one submission-poll handler (it
         // resolves which pass remains).
         design_review_contract_completed: (bundle, ctx) => runDesignReviewObligation(bundle, ctx),
         design_review_conceptual_completed: (bundle, ctx) => runDesignReviewObligation(bundle, ctx),
         // Charter clarification (Phase D triangulation loop).
-        charter_clarification_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleCharterClarificationBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        charter_clarification_current: omittableObligation(handleCharterClarificationBranch),
         // Systemic challenge (Phase E loop-until-dry).
-        systemic_challenge_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleSystemicChallengeBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            return { kind: "transition", state: branch.bundle };
-        },
+        systemic_challenge_current: omittableObligation(handleSystemicChallengeBranch),
         // The audit-task dispatch obligation maps to the host-delegation
         // semantic_review_executor (no deterministic runner) → host review.
         audit_tasks_completed: (bundle, ctx) => runHostDelegationObligation(bundle, ctx),
         // Synthesis narrative: consume the narrative lane; emit the host step when
         // narrative is enabled and not yet supplied, otherwise the deterministic
         // omit runs (fold on).
-        synthesis_narrative_current: async (bundle, ctx) => {
-            const state = deriveAuditState(bundle, { emitStaleness: false });
-            const branch = await handleSynthesisNarrativeBranch(ctx.params, bundle, state, ctx.tx);
-            if (branch.action === "return") {
-                return { kind: "emit", step: branch.result, state: bundle };
-            }
-            if (branch.action === "run_omit") {
-                // Narrative disabled: run the deterministic omit executor so the
-                // status:omitted marker is written and the obligation is satisfied.
-                return runDeterministicExecutor(bundle, ctx);
-            }
-            // continue: a narrative submission was consumed + applied — re-scan.
-            return { kind: "transition", state: branch.bundle };
-        },
+        synthesis_narrative_current: omittableObligation(handleSynthesisNarrativeBranch),
     };
     // The registry's membership and order DERIVE from PRIORITY — never a second
     // hand-enumerated list, so an id cannot be in the scan and absent from the
@@ -1991,15 +1989,20 @@ async function ingestAvailableInspectionResults(bundle, ctx) {
         // so the accept decision sees the same disk truth `runAuditStep`'s batch gate
         // validates against; the audit-task manifest comes from the same bundle.
         const lineIndexForIngest = bundle.repo_manifest
-            ? await buildLineIndex(ctx.params.root, bundle.repo_manifest)
+            ? await buildLineIndex(requireSourceRoot(ctx.params), bundle.repo_manifest)
             : undefined;
+        // The set replayed below. The ingest validates those entries again against
+        // this same tree, so the batch gate cannot refuse what it is handed.
+        const pendingIds = new Set(buildPendingAuditTasks(bundle).map((task) => task.task_id));
         try {
             const ingested = await ingestAuditHostResults({
                 root: ctx.params.root,
+                sourceRoot: requireSourceRoot(ctx.params),
                 artifactsDir: ctx.params.artifactsDir,
                 runId: currentRun.run_id,
                 auditTasks: bundle.audit_tasks ?? [],
                 lineIndex: lineIndexForIngest,
+                pendingTaskIds: pendingIds,
             });
             acceptedResults = ingested.accepted_results;
             ingestIssues = ingested.issues;
@@ -2036,13 +2039,13 @@ async function ingestAvailableInspectionResults(bundle, ctx) {
         // Even a refused-only arrival must be visible on the next host step.
         mergeFoldAdvisoriesInto(ctx.foldAdvisoriesRef.value, { issues: ingestIssues, validationWarnings });
         await writePendingAdvisories(ctx.params.artifactsDir, ctx.foldAdvisoriesRef.value);
-        const pendingIds = new Set(buildPendingAuditTasks(bundle).map((task) => task.task_id));
         const pendingAccepted = acceptedResults.filter((result) => pendingIds.has(result.task_id));
         if (pendingAccepted.length > 0) {
             // Forced, lock-free, against the CARRIED bundle: the fold owns the one
             // hold and the one persist.
             const ingested = await runAuditStepUnlocked({
                 root: ctx.params.root,
+                sourceRoot: requireSourceRoot(ctx.params),
                 artifactsDir: ctx.params.artifactsDir,
                 preferredExecutor: "result_ingestion_executor",
                 auditResultsData: [...pendingAccepted],
@@ -2069,6 +2072,7 @@ async function runHostDelegationObligation(bundle, ctx) {
     // other half).
     const review = await ensureSemanticReviewRunUnlocked({
         root: ctx.params.root,
+        sourceRoot: requireSourceRoot(ctx.params),
         artifactsDir: ctx.params.artifactsDir,
         bundle,
         state,
@@ -2119,7 +2123,12 @@ async function withFoldAdvisories(step, ctx) {
     if (step.kind !== "semantic_review") {
         return {
             ...step,
-            advisoryNotice: renderCarriedAdvisoryLines(carried),
+            // An architecture step that carries a ready-inspection run names that
+            // run's workload in its own task, above the carried report (the
+            // `withReadyInspection` section); the pending items are in it.
+            advisoryNotice: renderCarriedAdvisoryLines(carried, step.inspectionRun !== undefined && step.kind !== "blocked"
+                ? "named_above"
+                : "next_call"),
         };
     }
     return {
@@ -2142,14 +2151,15 @@ async function withFoldAdvisories(step, ctx) {
  * the bullet format and the headings, and the copy had already gone stale
  * against the section it claimed to match.
  *
- * The workload is `next_call` here: this report rides a step of another kind,
- * so no workload is published below it.
+ * The report rides a step of another kind and follows its whole task, so the
+ * workload is `named_above` when that task names a ready-inspection workload,
+ * and `next_call` otherwise.
  */
-function renderCarriedAdvisoryLines(carried) {
+function renderCarriedAdvisoryLines(carried, workload) {
     return renderIngestReportLines({
         issues: carried.ingestIssues,
         remedy: auditIngestRemedy,
-        workload: "next_call",
+        workload,
         advisories: carried.validationWarnings,
     });
 }
@@ -2223,8 +2233,8 @@ function foldHeartbeatRecord(obligation, durationMs) {
  * Drive the deterministic fold for one `next-step` call.
  *
  * Structure mirrors remediate-code's `decideNextStepLoop` (the proven engine
- * consumer): a PREAMBLE (the `index===0` file-integrity re-intake, the analog of
- * remediate's `forceReplan`) then the shared `advance` running audit's `PRIORITY`
+ * consumer): source-integrity refresh under the hold, then the shared
+ * `advance` running audit's `PRIORITY`
  * obligations. Each deterministic executor `transition`s (folding the whole chain
  * into one host round-trip); host-delegation / dispatch / terminal obligations
  * `emit` the host-actionable step.
@@ -2239,13 +2249,24 @@ function foldHeartbeatRecord(obligation, durationMs) {
  * terminal step (present_report when a report is rendered, else blocked).
  */
 export async function runDeterministicForNextStep(params) {
+    // Only explicit deadlines survive across calls. A synthesized budget belongs to
+    // this invocation, even when the caller reuses its original options object.
+    const deadline = params.deadline ?? params.externalAcquisition?.deadline ?? { at: Date.now() + params.timeoutMs };
+    params = {
+        ...params,
+        deadline,
+        ...(params.externalAcquisition ? { externalAcquisition: { ...params.externalAcquisition, deadline } } : {}),
+    };
     // The heartbeat wraps the WHOLE call, throw path included: a drain that dies
     // halfway is exactly when a caller most needs to know how far it got, and the
     // interval beat has no other owner on this path (the fold drives the shared
     // engine directly rather than through `advanceAudit`).
     const heartbeat = startAdvanceHeartbeat();
     try {
-        return await runDeterministicFold(params, heartbeat);
+        const result = await runDeterministicFold(params, heartbeat);
+        // The fold resolved the run's snapshot under its hold; the emission renders
+        // every packet and workload from the same tree.
+        return { ...result, sourceRoot: requireSourceRoot(params) };
     }
     finally {
         heartbeat.stop();
@@ -2265,38 +2286,6 @@ async function runDeterministicFold(params, heartbeat) {
     const analyzersRef = {
         value: params.analyzers,
     };
-    // PREAMBLE — file-integrity re-intake (runs once, like remediate's
-    // forceReplan). When pending audit-task files have changed/vanished since the
-    // manifest was built, re-run intake so planning re-grounds. advanceAudit does
-    // not persist (only runAuditStep does), so this is the same diagnostic-then-
-    // reload the hand loop performed on its first iteration: the warning fires and
-    // the fold below starts from the freshly-loaded disk bundle.
-    {
-        const bundle = await loadArtifactBundle(params.artifactsDir);
-        if (bundle.audit_state?.status !== "complete" && bundle.repo_manifest) {
-            const pendingTasks = buildPendingAuditTasks(bundle);
-            const taskFiles = new Set();
-            for (const task of pendingTasks) {
-                for (const fp of Object.keys(task.file_line_counts ?? {}))
-                    taskFiles.add(fp);
-            }
-            if (taskFiles.size > 0) {
-                const integrity = await checkFileIntegrity(params.root, bundle.repo_manifest, [...taskFiles]);
-                if (!integrity.is_clean) {
-                    // Route this diagnostic OFF stdout: cmdNextStep emits the step
-                    // contract as the sole stdout payload via console.log(JSON.stringify),
-                    // so a console.log here would corrupt the JSON-on-stdout contract.
-                    process.stderr.write(`[audit-code] nextStep: integrity check — ${integrity.changed_files.length} changed, ` +
-                        `${integrity.missing_files.length} missing, ${integrity.io_errors.length} io-error(s); re-running intake.\n`);
-                    await advanceAudit(bundle, {
-                        root: params.root,
-                        artifactsDir: params.artifactsDir,
-                        preferredExecutor: "intake_executor",
-                    });
-                }
-            }
-        }
-    }
     const ctx = {
         params,
         analyzersRef,
@@ -2330,8 +2319,18 @@ async function runDeterministicFold(params, heartbeat) {
         const holdStartMs = Date.now();
         let chargedExecutions;
         let ingestionExecutions = 0;
+        let intakeExecutions = 0;
         await recoverStagedSubmissions(params.artifactsDir);
         const previousConsent = await readRunConsentUnlocked(params.root, params.artifactsDir);
+        // The run's frozen snapshot, under the same hold as the consent record it
+        // shares a lifetime with: created at run start, re-checked out on resume.
+        // Every content read of this fold uses it (`requireSourceRoot`); the
+        // complete-run rule lives in `ensureRunSourceRoot`, shared with every
+        // standalone step command.
+        params.sourceRoot = await ensureRunSourceRoot(params.root, params.artifactsDir);
+        if (params.since !== undefined) {
+            params.since = await resolveRunSince(params.root, params.artifactsDir, params.since);
+        }
         const consent = params.autoFix?.enabled === undefined && !params.autoFix?.dryRun
             ? previousConsent
             : await updateRunConsentUnlocked(params.root, params.artifactsDir, {}, params.autoFix?.enabled, params.autoFix?.dryRun);
@@ -2352,6 +2351,26 @@ async function runDeterministicFold(params, heartbeat) {
         }
         ctx.currentBundleRef.value = startBundle;
         try {
+            // Observe source integrity against the fresh carried authority, under
+            // the same hold and before any old host submission can be ingested.
+            if (startBundle.audit_state?.status !== "complete" && startBundle.repo_manifest) {
+                const taskFiles = [...new Set(buildPendingAuditTasks(startBundle).flatMap((task) => task.file_paths))];
+                if (taskFiles.length > 0) {
+                    const integrity = await checkFileIntegrity(requireSourceRoot(params), startBundle.repo_manifest, taskFiles);
+                    if (!integrity.is_clean) {
+                        process.stderr.write(`[audit-code] nextStep: integrity check - ${integrity.changed_files.length} changed, ` +
+                            `${integrity.missing_files.length} missing, ${integrity.io_errors.length} io-error(s); re-running intake.\n`);
+                        intakeExecutions = 1;
+                        const refreshed = await runSingleAdvanceStep(startBundle, {
+                            root: requireSourceRoot(params), repositoryRoot: params.root, artifactsDir: params.artifactsDir,
+                            preferredExecutor: "intake_executor", scopeIndexMemo: params.scopeIndexMemo,
+                            runLogger: foldLogger, heartbeat,
+                        });
+                        startBundle = refreshed.updated_bundle;
+                        ctx.currentBundleRef.value = startBundle;
+                    }
+                }
+            }
             if (startBundle.audit_tasks && startBundle.audit_state?.status !== "complete" &&
                 deriveAuditState(startBundle, { emitStaleness: false }).obligations.find((obligation) => obligation.id === "planning_artifacts")?.state === "satisfied") {
                 const beforeIngest = startBundle;
@@ -2364,13 +2383,13 @@ async function runDeterministicFold(params, heartbeat) {
                 obligations: trackFoldBundle(buildAuditObligations()),
             }, startBundle, ctx, {
                 maxTransitions: engineMaxTransitions(),
-                maxExecutions: MAX_DRAIN_STEPS - ingestionExecutions,
+                maxExecutions: MAX_DRAIN_STEPS - ingestionExecutions - intakeExecutions,
             });
-            chargedExecutions = engineOutcome.executions + ingestionExecutions;
+            chargedExecutions = engineOutcome.executions + ingestionExecutions + intakeExecutions;
             if (engineOutcome.step && engineOutcome.step.kind !== "terminal_intent" && ARCHITECTURE_WORK_STEPS.has(engineOutcome.step.kind) &&
                 buildPendingAuditTasks(engineOutcome.state).length > 0) {
                 const inspection = await ensureSemanticReviewRunUnlocked({
-                    root: params.root, artifactsDir: params.artifactsDir,
+                    root: params.root, sourceRoot: requireSourceRoot(params), artifactsDir: params.artifactsDir,
                     bundle: engineOutcome.state,
                     state: deriveAuditState(engineOutcome.state, { emitStaleness: false }),
                     obligationId: "audit_tasks_completed",
@@ -2423,14 +2442,14 @@ async function runDeterministicFold(params, heartbeat) {
     // obligation that produces most of it, is what makes "stated on exactly one
     // emitted step, WHICHEVER step that is" true for every kind. A terminal
     // intent is deliberately excluded: it is not a step, and the terminal
-    // conversion below promotes and deletes the artifacts dir — the carry has
-    // nowhere left to be stated, and the run is over.
+    // conversion below promotes — the carry has nowhere left to be stated, and
+    // the run is over.
     if (outcome.step && outcome.step.kind !== "terminal_intent") {
         return await withFoldAdvisories(outcome.step, ctx);
     }
     if (outcome.step) {
         // Guard terminals convert POST-commit, POST-hold: buildTerminalStep can
-        // promote, and promotion deletes artifactsDir.
+        // promote, which writes outside the dir and removes a complete run's snapshot.
         return await buildTerminalStep(params, outcome.step.bundle, outcome.step.state, outcome.step.reason);
     }
     if (outcome.stopped === "budget") {