audit-tools 0.51.7 → 0.51.9

package/dist/remediate/steps/contractPipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contractPipeline.d.ts","sourceRoot":"","sources":["../../../src/remediate/steps/contractPipeline.ts"],"names":[],"mappings":"AAwBA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,WAAW,EAGhB,KAAK,SAAS,EACd,KAAK,aAAa,EASnB,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EACL,wBAAwB,EACxB,KAAK,cAAc,EACpB,MAAM,wCAAwC,CAAC;AAkBhD,OAAO,EACL,oBAAoB,EAKpB,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAC;AAqE1B,OAAO,EAKL,KAAK,+BAA+B,EACpC,KAAK,WAAW,EACjB,MAAM,wCAAwC,CAAC;AAGhD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAGzF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAE,WAAW,EAAoB,MAAM,cAAc,CAAC;AAgE7D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AASrD,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,oEAAoE,CAAC;IACrF;;;;;OAKG;IACH,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,EAAE,EAAE,MAAM,CAAC;QACX,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,qDAAqD;IACrD,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAMD,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,CAAC,CAWhC;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAGf;AAiFD,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,4BAA4B,EAClC,KAAK,EAAE,OAAO,GAAG,SAAS,EAC1B,QAAQ,GAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAU,GAC7D,OAAO,CAAC,cAAc,CAAC,CAoCzB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,GAC/E,MAAM,CAiBR;AAED,MAAM,WAAW,uBAAuB;IACtC,0EAA0E;IAC1E,QAAQ,EAAE,4BAA4B,EAAE,CAAC;IACzC,+EAA+E;IAC/E,OAAO,EAAE;QAAE,IAAI,EAAE,4BAA4B,CAAC;QAAC,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,EAAE,CAAC;CAC9E;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,uBAAuB,CAAC,CA0DlC;AAID,MAAM,WAAW,2BAA2B;IAC1C,mEAAmE;IACnE,4BAA4B,EAAE,OAAO,CAAC;IACtC,6EAA6E;IAC7E,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACpC,2BAA2B,CAa7B;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU5E;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAID,MAAM,WAAW,SAAS;IACxB,cAAc,EAAE,uDAAuD,CAAC;IACxE,4DAA4D;IAC5D,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,gBAAgB,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrE,uEAAuE;IACvE,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,8CAA8C;IAC9C,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,uFAAuF;IACvF,gBAAgB,EAAE,aAAa,EAAE,CAAC;IAClC;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,EACzB,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAgEf;AAiDD,gFAAgF;AAChF,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAsB,gCAAgC,CACpD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAgBrC;AAID;;;;GAIG;AAGH,KAAK,oBAAoB,GAAG,4BAA4B,GAAG,mBAAmB,GAAG,4BAA4B,CAAC;AAE9G;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAM/B,eAAe,EAAE,WAAW,CAAC,iBAAiB,CAAC,GAAG,SAAS,GAC1D,oBAAoB,CAYtB;AAmLD,KAAK,YAAY,GACb;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnF;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAapE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA4CtF;AAID,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAsB,qCAAqC,CACzD,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,CAAC,CAkEhC;AAID,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,wCAAwC,CAC5D,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,MAA2C,EACjD,MAAM,CAAC,EAAE,+BAA+B,GACvC,OAAO,CAAC,6BAA6B,CAAC,CAKxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,+BAA+B,CACnD,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,MAA2C,EACjD,MAAM,CAAC,EAAE,+BAA+B,GACvC,OAAO,CAAC;IAAE,KAAK,EAAE,uBAAuB,GAAG,qBAAqB,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAkClG;AAoFD;;;GAGG;AACH,wBAAsB,qCAAqC,CACzD,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAa1C;AAgBD,4EAA4E;AAC5E,QAAA,MAAM,sBAAsB;;CAElB,CAAC;AAEX,KAAK,mBAAmB,GAAG,MAAM,OAAO,sBAAsB,CAAC;AAE/D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,mBAAmB,CAEjF;AAiaD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,4BAA4B,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9E,uDAAuD;IACvD,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;IACtE,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACxD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AA8VD,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,QAAQ,EAAE,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,EACxC,QAAQ,EAAE,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,GACzC,gBAAgB,CAwBlB;AAq6CD;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAEzD,CAAC;AAEF;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAsCjC;AAwBD;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,wBAAwB,EAAE,CAAC;AACpC,YAAY,EAAE,cAAc,EAAE,CAAC;AAI/B;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAGnE;AAqED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,4BAA4B;IAC3C,6EAA6E;IAC7E,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,MAAM,GACd,4BAA4B,CAqC9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,8BAA8B,CAClD,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAmB1C;AA6BD;;;;;;GAMG;AACH,wBAAsB,sCAAsC,CAC1D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CAInB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,yBAAyB;IACxC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE,MAAM,GACd,yBAAyB,CAU3B;AAED;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAChD,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,EAAE,CAAC,CAuEnB;AAED;;;;;;;GAOG;AACH,wBAAsB,uCAAuC,CAC3D,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,MAA2C,GAChD,OAAO,CAAC,IAAI,CAAC,CAwXf"}
+{"version":3,"file":"contractPipeline.d.ts","sourceRoot":"","sources":["../../../src/remediate/steps/contractPipeline.ts"],"names":[],"mappings":"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"}

package/dist/remediate/steps/contractPipeline.js

@@ -1,3 +1,6 @@
+// sites-pinned: tests/remediate/contract-pipeline.test.ts
+// (the promotion
+// computes no finding field FindingSchema would drop)
 /**
  * Contract-pipeline gate for ALL remediation starts (both paths).
  *
@@ -22,10 +25,10 @@
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rename, rm } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { writeJsonFile, readOptionalJsonFile, formatValidationIssues, hashContent, isRecord, withFsRetry, projectApprovedFindings, captureStepBoundaryFriction, climbOutOfAuditTools, partitionCommandsByDeclaredShape, normalizeRepoPath, repoRelativePath, toPosixPath, neutralProjectFacts, } from "audit-tools/shared";
+import { writeJsonFile, readOptionalJsonFile, formatValidationIssues, hashContent, isRecord, withFsRetry, projectApprovedFindings, captureStepBoundaryFriction, climbOutOfAuditTools, partitionCommandsByDeclaredShape, splitSequentialCommandChain, normalizeRepoPath, repoRelativePath, toPosixPath, neutralProjectFacts, } from "audit-tools/shared";
 import { createStepEmissionScaffold, } from "../../shared/steps/stepEmissionScaffold.js";
 import { OBLIGATION_KIND_PRIORITY, } from "../contractPipeline/obligationKinds.js";
-import { CP_ARTIFACT_NAMES, contractArtifactExists, contractArtifactFilePath, contractInputFilePath, contractPipelineDir, detectStaleArtifacts, envelopePayload, envelopeSemanticHash, isEnvelope, pathASeedFilePath, payloadSemanticHash, readContractArtifact, stampToolCreatedAt, writeContractArtifact, writeDerivedContractArtifact, } from "../contractPipeline/artifactStore.js";
+import { CP_ARTIFACT_NAMES, contractArtifactExists, contractArtifactFilePath, contractInputFilePath, contractPipelineDir, detectStaleArtifacts, dropReviewSnapshot, envelopePayload, envelopeSemanticHash, isEnvelope, pathASeedFilePath, payloadSemanticHash, readContractArtifact, stampToolCreatedAt, writeContractArtifact, writeDerivedContractArtifact, } from "../contractPipeline/artifactStore.js";
 import { readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, decompositionRiskEvidence, adversarialDepthForTier, roundTripGranularityForTier, } from "../riskSignal.js";
 import { phaseOrdinalForObligations, moduleSlug, moduleSlugForObligationId, renderPhaseCutSection, detectContractTokenCycles, } from "../contractPipeline/phaseCut.js";
 import { ensurePhaseCutArtifact, readPhaseCutArtifact } from "../contractPipeline/phaseCutArtifact.js";
@@ -34,6 +37,7 @@ import { deriveObligationLedger, deriveFinalizedModuleContracts, buildTestValida
 import { ensureNodeId, toBlockId } from "../contractPipeline/idRegistry.js";
 import { captureReviewSnapshot, computeReReviewDelta, isReviewArtifact, readReviewSnapshot, renderReReviewSection, reviewSnapshotExists, } from "../contractPipeline/reviewSnapshot.js";
 import { captureTestPlanCarry, readTestPlanCarry, } from "../contractPipeline/testPlanCarry.js";
+import { CYCLIC_SEAM_BREAK_STRATEGIES, CYCLIC_SEAM_RESOLUTION_STATUSES, isCyclicSeamBreakStrategy, sketchValues, } from "../contractPipeline/sketchSource.js";
 import { readRepairState, writeRepairState, counterexamplesByIdOf, counterexampleKeyOf, counterexampleWaiversPath, foldCounterexampleWaivers, waivedAcceptedIds, waivedJudgeAcceptedIds, } from "../contractPipeline/repairState.js";
 import { renderContractPipelinePrompt, renderContractRepairPrompt, CONTRACT_PIPELINE_PHASE_ORDER, PHASE_TO_ARTIFACT, } from "./contractPipelinePrompts.js";
 // The seven cross-artifact validators this module used to call one by one are
@@ -213,6 +217,24 @@ export async function archiveContractArtifact(artifactsDir, name, label, renameF
     const canonicalSource = contractArtifactFilePath(artifactsDir, name);
     const hasInput = existsSync(inputSource);
     const hasCanonical = existsSync(canonicalSource);
+    // The `invalid` label rejects the artifact this snapshot is the verdict FOR, so
+    // the snapshot dies with it — unconditionally, and before the nothing-to-
+    // archive short-circuit below, so an orphaned snapshot is cleaned up too. A
+    // surviving copy is worse than an absent one: ingest captures a fresh snapshot
+    // only AFTER its own staleness pass, so the NEXT invocation would diff the new
+    // payload against a verdict about content the reviewer never saw. Dropped even
+    // when the history move itself fails, because the re-emit that follows tells
+    // the worker to overwrite the input in place — the old verdict is void either
+    // way.
+    //
+    // The `stale` label must NOT drop it, and that asymmetry is the whole point:
+    // staleness is what re-opens a review phase, and the diff-based re-review only
+    // fires when a prior snapshot is there to diff against. Dropping on the stale
+    // path would silently turn every staleness re-emit back into the blind full
+    // review this mechanism exists to avoid.
+    if (label === "invalid") {
+        await dropReviewSnapshot(artifactsDir, name);
+    }
     if (!hasInput && !hasCanonical)
         return { originalFree: true };
     const historyDir = join(contractPipelineDir(artifactsDir), "history");
@@ -457,6 +479,69 @@ async function hashSeedSourcePaths(root, auditFindingsPath, affectedFiles) {
     }
     return digests;
 }
+/** The tool-named host lane: the operator's drift acceptances land here. */
+export function seedSourceAcceptancesPath(artifactsDir) {
+    return join(contractPipelineDir(artifactsDir), "seed-source-acceptances.json");
+}
+/**
+ * Read the operator's acceptances, keyed by the same path normalization the
+ * mismatch side uses. A malformed entry is DROPPED, never widened: an acceptance
+ * missing its rationale or its decider records no decision, and treating it as
+ * one would turn a shape defect into a silent bypass of the alarm.
+ */
+export async function readSeedSourceAcceptances(artifactsDir) {
+    const raw = await readOptionalJsonFile(seedSourceAcceptancesPath(artifactsDir));
+    const byPath = new Map();
+    if (!isRecord(raw) || !Array.isArray(raw.acceptances))
+        return byPath;
+    for (const entry of raw.acceptances) {
+        if (!isRecord(entry))
+            continue;
+        const path = entry.path;
+        const rationale = entry.rationale;
+        const acceptedBy = entry.accepted_by;
+        if (typeof path !== "string" ||
+            path.trim().length === 0 ||
+            typeof rationale !== "string" ||
+            rationale.trim().length === 0 ||
+            typeof acceptedBy !== "string" ||
+            acceptedBy.trim().length === 0) {
+            continue;
+        }
+        byPath.set(normalizeRepoPath(path), {
+            path: path.trim(),
+            rationale: rationale.trim(),
+            accepted_by: acceptedBy.trim(),
+        });
+    }
+    return byPath;
+}
+/**
+ * The seed paths the operator's acceptance file covers, applied to the drifted
+ * set under the ONE path normalization both sides share; everything else blocks.
+ *
+ * This is the accept path and it is deliberately the ONLY automatic one: the
+ * gate cannot tell a benign drift from a falsifying one, and the one predicate
+ * that claimed to (cited line counts) was unsound — see {@link SeedSourceAcceptance}.
+ */
+export async function partitionSeedSourceDrift(artifactsDir, mismatches) {
+    if (mismatches.length === 0)
+        return { accepted: [], blocking: [] };
+    const acceptances = await readSeedSourceAcceptances(artifactsDir);
+    if (acceptances.size === 0)
+        return { accepted: [], blocking: [...mismatches] };
+    const accepted = [];
+    const blocking = [];
+    for (const mismatch of mismatches) {
+        const acceptance = acceptances.get(normalizeRepoPath(mismatch.path));
+        if (acceptance) {
+            accepted.push({ ...acceptance, mismatch });
+            continue;
+        }
+        blocking.push(mismatch);
+    }
+    return { accepted, blocking };
+}
 /**
  * Seed source-digest binding — re-hash every path the path_a seed recorded and
  * report the ones that moved. Pure over (root, seed): the caller decides what a
@@ -587,14 +672,37 @@ async function evaluateJudgeGate(artifactsDir) {
         return { kind: "proceed" };
     }
     const judgeHash = judgeEnvelope.content_hash;
+    // ONE-TIME UPGRADE EFFECT: `computeHash` now serializes with
+    // `stableStringify` (artifactStore.ts), so a repair-ledger entry recorded
+    // before that change stores a key-order-sensitive `judge_hash` the recomputed
+    // value can never equal. A run sitting mid-repair-loop across the upgrade
+    // therefore misses on this compare and escalates ONCE as "not converging".
+    // Deliberate: the escalation is fail-safe (the operator resolves it and the
+    // loop re-enters on the freshly hashed report), and back-compat code for a
+    // value the next read recomputes would be carried forever for one run.
     const alreadyHandled = repairState.repairs.some((repair) => repair.judge_hash === judgeHash);
     // Map judge.repair_directive.target if present; if absent, infer from classifications.
+    //
+    // No `design_spec` normalization. The validator and the shared `JudgeRepairTarget`
+    // union now derive from ONE declaration of the repair-target vocabulary
+    // (`contractPipeline/sketchSource.ts`), so `design_spec` — the pre-redesign name
+    // for `finalized_module_contracts` — is not a value the type admits and not a
+    // value the validator accepts. The branch that rewrote it used to be the only
+    // thing keeping a legacy name working, and carried a cast that erased the very
+    // check it was performing.
+    //
+    // `counterexample` is admitted by the contract and refused HERE, at the one
+    // place that would have to act on it: this loop's repair renderer has a schema
+    // sketch for the three contract artifacts only (see REPAIR_TARGET_SCHEMA), so a
+    // directive naming the critic's own report falls back to the inferred contract
+    // repair rather than being carried into a renderer that cannot honour it.
     const rawDirective = judge.repair_directive;
     const directive = rawDirective
         ? {
-            target: (rawDirective.target === "design_spec"
-                ? "finalized_module_contracts"
-                : rawDirective.target),
+            target: rawDirective.target === "counterexample" ||
+                rawDirective.target === "design_spec"
+                ? inferRepairDirective(judge).target
+                : rawDirective.target,
             instruction: rawDirective.instruction,
         }
         : inferRepairDirective(judge);
@@ -682,6 +790,11 @@ export async function evaluateCritiqueGate(artifactsDir) {
     const repairState = await readRepairState(artifactsDir);
     const critiqueRepairs = repairState.critique_repairs ?? [];
     const critiqueHash = env.content_hash;
+    // ONE-TIME UPGRADE EFFECT, the critique gate's twin of the judge site above:
+    // a `critique_hash` recorded before `computeHash` moved to `stableStringify`
+    // cannot equal the recomputed value, so an in-flight design-repair loop
+    // crossing the upgrade escalates once as a stall instead of re-emitting.
+    // Fail-safe and deliberately not mitigated — see that site for the reasoning.
     const alreadyHandled = critiqueRepairs.some((r) => r.critique_hash === critiqueHash);
     // Idempotent re-entry: this exact critique already drove a repair (its design
     // repair has not yet produced a fresh critique). Re-emit the same repair.
@@ -1077,13 +1190,21 @@ async function readModuleContractWriteTargets(artifactsDir) {
 async function buildNodeWriteScopeResolver(artifactsDir) {
     const decomposedModules = await readDecomposedModules(artifactsDir);
     const contractTargetsBySlug = await readModuleContractWriteTargets(artifactsDir);
-    const moduleScopesBySlug = decomposedModules
-        .map((m) => ({
+    const moduleScopesBySlug = decomposedModules.map((m) => ({
         slug: moduleSlug(m.name),
         files: m.file_scope,
         targets: contractTargetsBySlug.get(moduleSlug(m.name)) ?? [],
-    }))
-        .sort((a, b) => b.slug.length - a.slug.length);
+    }));
+    // The join is the EXACT one (`idRegistry.moduleSlugForObligationId`), not a
+    // longest-prefix match. Longest-prefix guessed whenever one module slug
+    // prefixed another: with `auth` and `auth-service` both decomposed the guess
+    // resolved correctly by luck of the sort, but with `auth-service` out of
+    // scope, `OBL-auth-service-contract` matched `auth` and the node silently
+    // took `auth`'s targets — another module's write boundary, granted without
+    // anyone choosing it. The suffix grammar makes the unresolvable case
+    // UNRESOLVABLE, which the empty-scope refusal below already reports loudly.
+    const scopeBySlug = new Map(moduleScopesBySlug.map((m) => [m.slug, m]));
+    const knownSlugs = new Set(scopeBySlug.keys());
     const resolve = (node) => {
         const declared = [...new Set(node.output_files ?? node.files_likely_touched ?? [])];
         const obligationIds = [
@@ -1093,7 +1214,8 @@ async function buildNodeWriteScopeResolver(artifactsDir) {
         const inherited = new Set();
         const ownedTargets = new Set();
         for (const id of obligationIds) {
-            const owner = moduleScopesBySlug.find((m) => id.startsWith(`OBL-${m.slug}-`));
+            const slug = moduleSlugForObligationId(id, knownSlugs);
+            const owner = slug === null ? undefined : scopeBySlug.get(slug);
             if (!owner)
                 continue;
             // file_scope inheritance is the scope-less fallback ONLY; the contract's
@@ -1602,15 +1724,33 @@ const PRE_CRITIC_REQUIRED_GATES = new Set([
  * a classified blocked step on a mismatch — rather than spending the whole
  * design pipeline on content that no longer holds the findings the seed
  * enumerates. Runs first, before anything is ingested or derived.
+ *
+ * The refusal names the operator's ACCEPT lane: a drift the operator has
+ * reviewed and judged not to invalidate the findings is recorded in
+ * `seed-source-acceptances.json` and stops blocking. That lane exists because
+ * the gate cannot tell a version bump from a behaviour change, and the honest
+ * answer to "can the tool tell?" is no — see `SeedSourceAcceptance`.
  */
 const seedSourceDigestGate = async (ctx) => {
     if (!ctx.pathASeedPath)
         return null;
     const seed = await readOptionalJsonFile(ctx.pathASeedPath);
-    const mismatches = await detectSeedSourceDigestMismatches(ctx.root, seed);
-    if (mismatches.length === 0)
+    const allMismatches = await detectSeedSourceDigestMismatches(ctx.root, seed);
+    if (allMismatches.length === 0)
+        return null;
+    // A digest is a WHOLE-FILE byte binding, so it moves for changes no finding is
+    // about — a release `version` bump in `package.json` moved the digest of every
+    // finding that cited it and blocked the run. The operator's acceptance file is
+    // the way to say "reviewed, and the findings still hold"; anything it does not
+    // cover still blocks. The tool cannot infer this (see `SeedSourceAcceptance`),
+    // so it enforces the record's shape and the join, never the judgment.
+    const { accepted, blocking } = await partitionSeedSourceDrift(ctx.artifactsDir, allMismatches);
+    if (blocking.length === 0)
         return null;
-    const lines = mismatches
+    const acceptedLines = accepted
+        .map((entry) => `- \`${entry.path}\` — accepted by ${entry.accepted_by}: ${entry.rationale}`)
+        .join("\n");
+    const lines = blocking
         .map((mismatch) => `- \`${mismatch.path}\` — recorded \`${mismatch.expected.slice(0, 12)}…\`, ` +
         `now ${mismatch.actual ? `\`${mismatch.actual.slice(0, 12)}…\`` : "**unreadable**"}`)
         .join("\n");
@@ -1625,8 +1765,19 @@ ${lines}
 The findings this pipeline is designing against were derived from the recorded content, so re-deriving them is the only thing that makes the design sound again. Decide with the user:
 
 1. **Re-run the audit extraction** against the current tree, so the findings describe the code as it now stands; or
-2. **Restore the drifted sources** to the content the audit read, if the change was unintended.
+2. **Restore the drifted sources** to the content the audit read, if the change was unintended; or
+3. **Accept the drift**, when the operator has reviewed it and the findings still hold — a release version bump touches no finding the seed enumerates. Write to \`${seedSourceAcceptancesPath(ctx.artifactsDir)}\`:
+
+\`\`\`json
+{
+  "acceptances": [
+    { "path": "<the path above, repo-relative>", "rationale": "<why the findings still hold>", "accepted_by": "<who decided>" }
+  ]
+}
+\`\`\`
 
+The tool does not and cannot infer this: it can see that bytes moved and cannot see whether a finding citing those bytes is still true. Record an acceptance ONLY for a decision the operator actually made — the record names its decider.
+${acceptedLines ? `\nAlready accepted this run (not blocking):\n\n${acceptedLines}\n` : ""}
 Only as an explicit LAST resort — an accepted, recorded decision to design against findings that no longer match the code — delete \`${ctx.pathASeedPath}\` and re-run next-step. That rebuilds the seed from the CURRENT sources while keeping the OLD findings, which clears this alarm without re-deriving anything.`,
         stopCondition: "Stop — the contract pipeline is blocked on a source whose content no longer matches the audit seed.",
     };
@@ -2142,10 +2293,21 @@ Each node's source_finding_ids must name exactly one canonical audit work block,
             violations: pathARefusals,
         });
     }
+    // ONE payload read for the whole promotion boundary, shared by the integrity
+    // gate and the contract-obligation gates below. Both consume the SAME
+    // post-archive payloads, and nothing between these two consumers writes an
+    // artifact — so a second read bought no freshness and re-paid the whole
+    // read-and-parse of every contract-pipeline artifact (plus the repair-state
+    // and finding-enumeration reads it carries), on the path every plan promotion
+    // walks. The freshness RULE is unchanged and still enforced: the read below is
+    // `readCrossGatePayloads`, which refuses before this invocation's ingestion +
+    // staleness-archive pass, so neither consumer can be handed a pre-archive
+    // snapshot.
+    const crossGatePayloads = await readCrossGatePayloads(ctx);
     // DAG referential integrity + bidirectional coverage (ARC-86b18f1b-2), run
     // before the traceability check so specific referential violations are
     // reported first (traceability is a superset check).
-    const outcomes = await evaluateContractPipelineCrossGateOutcomes(await readCrossGatePayloads(ctx));
+    const outcomes = await evaluateContractPipelineCrossGateOutcomes(crossGatePayloads);
     const integrity = gateOutcomeOf(outcomes, "implementation_dag_integrity");
     if (!integrity?.evaluated) {
         return await dagRegenerationPlan(ctx, {
@@ -2183,7 +2345,7 @@ The previous implementation_dag was rejected and archived. Every node must trace
     // must pass before a plan is promoted. These are the invariants that keep the
     // workflow correct regardless of host strength, so they are enforced here,
     // never left to host discretion.
-    const obligationGate = await evaluateContractObligationsPromotionGate(ctx.artifactsDir, ctx.root, await readCrossGatePayloads(ctx));
+    const obligationGate = await evaluateContractObligationsPromotionGate(ctx.artifactsDir, ctx.root, crossGatePayloads);
     if (!obligationGate.ok) {
         return await dagRegenerationPlan(ctx, {
             heading: "Contract-Obligation Gates Failed",
@@ -2400,13 +2562,13 @@ Two files, both required — the record alone is not a break:
   "cycles": [
     {
       "members": ["<obligation-id>", "..."],
-      "break_strategy": "mediator | single_authority",
+      "break_strategy": "${sketchValues(CYCLIC_SEAM_BREAK_STRATEGIES)}",
       "designated_obligation_id": "<the mediating obligation, or the single authority — must exist in the rewritten ledger>",
       "resolution_description": "<what was changed and why>",
       "exception_registration": "<if single_authority: the named scoped exception; otherwise null>"
     }
   ],
-  "status": "resolved"
+  "status": "${sketchValues(CYCLIC_SEAM_RESOLUTION_STATUSES)}"
 }
 \`\`\`
 
@@ -2451,10 +2613,14 @@ const cyclicSeamRecheckGate = async (ctx) => {
             continue;
         const members = cycleRecord.members.filter((member) => typeof member === "string");
         const strategy = cycleRecord.break_strategy;
-        if (strategy !== "mediator" && strategy !== "single_authority") {
+        // The vocabulary is the shared declaration the prompt sketch also renders
+        // (`contractPipeline/sketchSource.ts`). It was two inline literals here and
+        // a hand-written alternation in the prompt — three statements of one rule,
+        // in two modules, none of which the contract validator checked at all.
+        if (!isCyclicSeamBreakStrategy(strategy)) {
             rejection =
                 `Cycle [${members.join(", ")}] declares break_strategy ` +
-                    `${JSON.stringify(strategy ?? null)}, which is neither "mediator" nor "single_authority".`;
+                    `${JSON.stringify(strategy ?? null)}, which is not one of: ${CYCLIC_SEAM_BREAK_STRATEGIES.join(", ")}.`;
             break;
         }
         const authored = {
@@ -2859,6 +3025,7 @@ async function buildReReviewSection(phase, artifactsDir) {
 }
 // ── DAG → extracted plan conversion ──────────────────────────────────────────
 // ── Obligation-kind → lens/severity mappings ──────────────────────────────────
+// <!-- comment-symbol-exempt: names deliberately-retired symbols; this block records that history -->
 /**
  * The obligation-kind vocabulary, in priority order (higher index = higher
  * priority; `invariant` is highest).
@@ -3044,12 +3211,19 @@ export async function checkWriteScopePathsAgainstTrackedTree(root, paths, label)
     return writeScopeCorpusViolations(corpus, paths, label);
 }
 export function normalizeBlockTargetedCommands(commands, blockId) {
+    // The ONE mechanical repair: a bare `&&` chain already MEANS "these
+    // invocations, in order", which is what two entries mean, so it is split here
+    // rather than spending a whole DAG regeneration on it (open-bugs: one dispatch
+    // emitted `npm run build && npm run check` on 23 nodes and the DAG was
+    // regenerated twice for a defect with a mechanical answer). Everything the
+    // split cannot faithfully restate — a pipe, a redirect, `;`, substitution, an
+    // inadmissible half — still takes the bounded re-emit below.
     const partitioned = partitionCommandsByDeclaredShape(commands, (kind, raw) => kind === "empty"
         ? `Block "${blockId}" declares an empty targeted_commands entry.`
         : `Block "${blockId}" declares the targeted_commands entry ${JSON.stringify(raw)}, ` +
             `which carries shell chaining, substitution or redirection. A targeted command is ` +
             `executed verbatim through a shell, so it must be one invocation — split it into ` +
-            `separate entries.`);
+            `separate entries.`, splitSequentialCommandChain);
     return { targeted_commands: partitioned.commands, refusals: partitioned.refusals };
 }
 /**
@@ -3074,32 +3248,49 @@ export async function collectDagWriteScopeRefusals(artifactsDir, root) {
     return refusals;
 }
 /**
- * Path-A canonical-block membership validation, run BEFORE anything is promoted
- * (OBL-seam-prep-remediate-core-inv-2 / COR-114e4941). These are exactly the
- * checks the promoter itself performs while building its node→canonical-group
- * map — but there they THROW out of `promoteImplementationDagToExtractedPlan`,
- * an unclassified stack that wedged every subsequent next-step. Hoisted here so
- * an invalid `source_finding_ids` declaration takes the same bounded re-emit as
- * every other promotion rejection, with no gate having executed past it.
+ * The ONE Path-A canonical-group membership evaluator, in ONE body.
  *
- * Returns one line per violation; empty means the DAG is promotable on this
- * axis (or Path A is not in play at all).
+ * The promoter and the pre-promotion gate ask the byte-identical question — is
+ * each DAG node's `source_finding_ids` declaration a canonical audit work block,
+ * exactly once each? — and they used to answer it with two hand-mirrored copies
+ * of the same forty lines: one returning refusal lines, one throwing. Two copies
+ * of an identity rule drift, and a drift between THESE two is the worst kind:
+ * the gate would certify a DAG promotable and the promoter would then throw on
+ * it, or (worse) the gate would refuse a DAG the promoter would have accepted,
+ * wedging a run behind a rule nothing in the emitter can satisfy.
+ *
+ * So the body is `ok`/`refusals`, plus the node→canonical-group map the promoter
+ * needs for its projection, and each caller renders what it needs from the SAME
+ * result. `refusals` is empty exactly when the DAG is promotable on this axis;
+ * `byNodeId` is populated exactly on that path.
+ *
+ * The caller supplies `nodes` and `approvedSource` because they read them for
+ * their own purposes too (the gate must not read the DAG twice; the promoter
+ * filters the canonical group map through its own sort).
  */
-export async function collectPathARefusals(artifactsDir) {
-    const dag = envelopePayload(await readContractArtifact(artifactsDir, "implementation_dag"));
-    const nodes = Array.isArray(dag?.nodes) ? dag.nodes : [];
+function evaluatePathACanonicalGroups(params) {
+    const { nodes, approvedSource, seedPresent } = params;
+    const byNodeId = new Map();
     if (nodes.length === 0)
-        return [];
-    if (!nodes.some((node) => Array.isArray(node.source_finding_ids)))
-        return [];
-    const pathASeed = await readOptionalJsonFile(pathASeedFilePath(artifactsDir));
-    const approvedSource = pathASeed
-        ? projectApprovedFindings(await readOptionalJsonFile(pathASeed.audit_findings_path))
-        : undefined;
+        return { refusals: [], byNodeId };
+    if (!nodes.some((node) => Array.isArray(node.source_finding_ids))) {
+        return { refusals: [], byNodeId };
+    }
     if (!approvedSource) {
-        return [
-            "implementation_dag declares source_finding_ids but no Path-A seed is present, so the ids cannot be joined to a canonical audit work block.",
-        ];
+        return {
+            refusals: [
+                "implementation_dag declares source_finding_ids but no Path-A seed is present, so the ids cannot be joined to a canonical audit work block.",
+            ],
+            byNodeId,
+        };
+    }
+    if (!seedPresent) {
+        return {
+            refusals: [
+                "implementation_dag declares source_finding_ids but no Path-A seed is present, so the ids cannot be joined to a canonical audit work block.",
+            ],
+            byNodeId,
+        };
     }
     const signature = (ids) => JSON.stringify([...ids].sort((left, right) => compareCodeUnits(left, right)));
     const canonicalGroups = new Map(approvedSource.workBlocks.map((block) => [
@@ -3129,12 +3320,45 @@ export async function collectPathARefusals(artifactsDir) {
             refusals.push(`implementation_dag node "${nodeId}" duplicates a canonical audit work block.`);
         }
         usedGroups.add(groupSignature);
+        byNodeId.set(nodeId, canonicalGroup);
     }
-    if (refusals.length === 0 &&
-        usedGroups.size !== canonicalGroups.size) {
+    if (refusals.length === 0 && usedGroups.size !== canonicalGroups.size) {
         refusals.push("implementation_dag source_finding_ids do not cover every canonical audit work block exactly once.");
     }
-    return refusals;
+    return { refusals, byNodeId };
+}
+/**
+ * Path-A canonical-block membership validation, run BEFORE anything is promoted
+ * (OBL-seam-prep-remediate-core-inv-2 / COR-114e4941). These are exactly the
+ * checks the promoter itself performs while building its node→canonical-group
+ * map — but there they THROW out of `promoteImplementationDagToExtractedPlan`,
+ * an unclassified stack that wedged every subsequent next-step. Hoisted here so
+ * an invalid `source_finding_ids` declaration takes the same bounded re-emit as
+ * every other promotion rejection, with no gate having executed past it.
+ *
+ * The checks themselves are {@link evaluatePathACanonicalGroups} — the ONE body
+ * both this gate and the promoter call, so the gate can never certify a DAG the
+ * promoter then refuses.
+ *
+ * Returns one line per violation; empty means the DAG is promotable on this
+ * axis (or Path A is not in play at all).
+ */
+export async function collectPathARefusals(artifactsDir) {
+    const dag = envelopePayload(await readContractArtifact(artifactsDir, "implementation_dag"));
+    const nodes = Array.isArray(dag?.nodes) ? dag.nodes : [];
+    if (nodes.length === 0)
+        return [];
+    if (!nodes.some((node) => Array.isArray(node.source_finding_ids)))
+        return [];
+    const pathASeed = await readOptionalJsonFile(pathASeedFilePath(artifactsDir));
+    const approvedSource = pathASeed
+        ? projectApprovedFindings(await readOptionalJsonFile(pathASeed.audit_findings_path))
+        : undefined;
+    return evaluatePathACanonicalGroups({
+        nodes,
+        approvedSource,
+        seedPresent: pathASeed !== undefined,
+    }).refusals;
 }
 /**
  * Convert a completed ImplementationDAG into the extracted-plan.json format
@@ -3194,14 +3418,14 @@ export async function promoteImplementationDagToExtractedPlan(artifactsDir, root
             contractSlugToName.set(moduleSlug(mod.name), mod.name);
         }
     }
-    const contractSlugsByLength = [...contractSlugToName.keys()].sort((a, b) => b.length - a.length);
+    const contractSlugs = new Set(contractSlugToName.keys());
     const moduleContractsForNode = (node) => {
         const names = new Set();
         for (const obligationId of [
             ...(node.satisfies_obligations ?? []),
             ...(node.verification_obligation_ids ?? []),
         ]) {
-            const slug = moduleSlugForObligationId(obligationId, contractSlugsByLength);
+            const slug = moduleSlugForObligationId(obligationId, contractSlugs);
             const name = slug === null ? undefined : contractSlugToName.get(slug);
             if (name !== undefined)
                 names.add(name);
@@ -3232,35 +3456,21 @@ export async function promoteImplementationDagToExtractedPlan(artifactsDir, root
     const canonicalItemsByNodeId = new Map();
     if (approvedSource &&
         nodes.some((node) => Array.isArray(node.source_finding_ids))) {
-        const signature = (ids) => JSON.stringify([...ids].sort((left, right) => compareCodeUnits(left, right)));
-        const canonicalGroups = new Map(approvedSource.workBlocks.map((block) => [
-            signature(block.finding_ids),
-            [...block.finding_ids].sort((left, right) => compareCodeUnits(left, right)),
-        ]));
-        const usedGroups = new Set();
-        for (const [index, node] of nodes.entries()) {
-            const nodeId = ensureNodeId(node.id, index);
-            const sourceIds = node.source_finding_ids;
-            if (!Array.isArray(sourceIds) || sourceIds.length === 0) {
-                throw new Error(`implementation_dag node "${nodeId}" must declare source_finding_ids for Path-A promotion.`);
-            }
-            const uniqueIds = [...new Set(sourceIds)];
-            if (uniqueIds.length !== sourceIds.length) {
-                throw new Error(`implementation_dag node "${nodeId}" repeats a source_finding_ids member.`);
-            }
-            const groupSignature = signature(uniqueIds);
-            const canonicalGroup = canonicalGroups.get(groupSignature);
-            if (!canonicalGroup) {
-                throw new Error(`implementation_dag node "${nodeId}" source_finding_ids do not match a canonical audit work block.`);
-            }
-            if (usedGroups.has(groupSignature)) {
-                throw new Error(`implementation_dag node "${nodeId}" duplicates a canonical audit work block.`);
-            }
-            usedGroups.add(groupSignature);
-            canonicalItemsByNodeId.set(nodeId, canonicalGroup);
+        // The SAME evaluator `collectPathARefusals` runs as the pre-promotion gate.
+        // The projection this loop used to build inline was a second copy of that
+        // gate's rule, and the two could disagree about which declarations are
+        // canonical — the gate certifying a DAG this throws on, or the reverse.
+        // This side renders refusals as the THROW the promoter's contract promises.
+        const evaluation = evaluatePathACanonicalGroups({
+            nodes,
+            approvedSource,
+            seedPresent: true,
+        });
+        if (evaluation.refusals.length > 0) {
+            throw new Error(evaluation.refusals.join("\n"));
         }
-        if (usedGroups.size !== canonicalGroups.size) {
-            throw new Error("implementation_dag source_finding_ids do not cover every canonical audit work block exactly once.");
+        for (const [nodeId, canonicalGroup] of evaluation.byNodeId) {
+            canonicalItemsByNodeId.set(nodeId, [...canonicalGroup]);
         }
     }
     let findings = nodes.map((node, index) => {
@@ -3299,14 +3509,24 @@ export async function promoteImplementationDagToExtractedPlan(artifactsDir, root
             evidence: obligationEvidence.length > 0
                 ? obligationEvidence
                 : [node.description ?? node.title ?? `Contract-pipeline task ${id}`],
-            concrete_change: node.description ?? "",
+            // NO `concrete_change`. It was `node.description` a second time — `summary`
+            // above already carries exactly that — and no consumer ever read it:
+            // `FindingSchema` never declared it, so the dispatch boundary's
+            // `FindingSchema.parse` stripped it, and no reader recovered it from the
+            // plan in between. A field the pipeline computes onto a finding that
+            // reaches no consumer is not computed.
             contract_goal_id: dag?.goal_id,
             contract_obligation_ids: contractObligations,
             verification_obligation_ids: verificationObligations,
-            addresses_counterexamples: addressedCounterexamples,
             targeted_commands: node.targeted_commands ?? [],
-            preconditions: node.preconditions ?? [],
-            expected_changes: node.expected_changes ?? "",
+            // NO `addresses_counterexamples`, `preconditions`, or `expected_changes`.
+            // Each is a DAG-node fact whose only readers are the node-side gates
+            // (`validateImplementationDAGIntegrity` and `validateCounterexampleThreading`
+            // in `src/remediate/validation/contractPipelineGates.ts`) — they read it
+            // off the NODE, never off a finding. Copied onto the finding they were
+            // declared on no schema, read by no consumer, and dropped by the dispatch
+            // boundary's `FindingSchema.parse`. The counterexample ids still reach the
+            // finding where they ARE consumed: folded into `evidence` above.
         };
     });
     if (approvedSource && canonicalItemsByNodeId.size > 0) {
@@ -3331,12 +3551,9 @@ export async function promoteImplementationDagToExtractedPlan(artifactsDir, root
                 contract_goal_id: dag?.goal_id,
                 contract_obligation_ids: contractObligations,
                 verification_obligation_ids: verificationObligations,
-                addresses_counterexamples: [
-                    ...new Set(node.addresses_counterexamples ?? []),
-                ],
                 targeted_commands: [...(node.targeted_commands ?? [])],
-                preconditions: [...(node.preconditions ?? [])],
-                expected_changes: node.expected_changes ?? "",
+                // The node-only fields are deliberately NOT copied here — see the
+                // sibling block above for why.
             };
         });
     }