audit-tools 0.51.7 → 0.51.9

package/dist/remediate/phases/closeVerifyHeadEvidence.d.ts

@@ -0,0 +1,154 @@
+import type { Evidence } from "../../shared/types/remediationOutcome.js";
+import type { Finding, PerFindingDisposition, RemediationItemState } from "../state/types.js";
+/**
+ * CDC-25/CDC-26 (INV-ISC-EVIDENCE-EMITTED) — the PRODUCER for the two
+ * evidence-bearing terminal dispositions. `verified_already_fixed` and
+ * `refuted` are reachable from a real run ONLY through
+ * `RemediationItemState.disposition_override`, and the writer
+ * (`buildRemediationOutcomesReport` in `close.ts`) refuses that override unless
+ * the item also carries a complete `evidence` triple and the module stamp that
+ * recorded it. Nothing wrote those three fields, so both dispositions were
+ * dead letters: the only route from a determination to run state was a human
+ * transcribing a markdown document no code reads.
+ *
+ * This leg is that producer, and it is a REAL determination rather than a
+ * record of one: it re-reads the finding's own CITED location at TWO refs and
+ * decides from what it read. The triple it records names the file and the line
+ * it actually read (that is the whole content of INV-ISC-EVIDENCE-EMITTED — the
+ * recorded triple must name what was read), so a triple naming a location this
+ * leg never opened cannot be produced here.
+ *
+ * ── WHY TWO READS, NEVER ONE ────────────────────────────────────────────────
+ * Let B be the commit the AUDIT read when it produced the finding, and HEAD the
+ * commit the fix has landed on by the time this leg runs (close.ts executes the
+ * closing action BEFORE its verify legs, so HEAD contains the remediation
+ * result — the same point `verifyAnalyzerLeads` and the combined-test leg
+ * read). A read at HEAD ALONE cannot support either verdict:
+ *
+ *   span at B | span at HEAD | result
+ *   ----------|--------------|------------------------------------------
+ *   present   | absent       | `verified_already_fixed` — the code the audit
+ *             |              | read is gone; the fix landed.
+ *   absent    | (any)        | `refuted` — the audit read a location that
+ *             |              | never showed the span it quoted.
+ *   present   | present      | WITHHELD — the cited code still stands, so
+ *             |              | this leg makes no determination at all.
+ *   B unknown/unreadable     | WITHHELD, with the reason.
+ *
+ * The single-read form this leg used to carry was WRONG in both directions, and
+ * the two errors were mirror images. It called "span still present at HEAD"
+ * `refuted` on the stated ground that "the cited location never showed the
+ * defect" — an inference no read at HEAD can make. A span still standing proves
+ * only that the code the finding quoted is still there; if the defect was real
+ * when the audit read it, it is still real. Symmetrically it called "span absent
+ * at HEAD" `verified_already_fixed`, when an absent span has TWO causes: the
+ * code changed after the audit read it (the fix landed), or the span was never
+ * in the file (a misquote — the `refuted` case). B is what tells them apart, so
+ * without B neither verdict is reachable and every candidate is withheld.
+ *
+ * ── WHERE B COMES FROM, AND WHY IT IS USUALLY UNKNOWN ───────────────────────
+ * B must be a commit the AUDIT itself recorded. A remediation-side commit is
+ * NOT B: code can change between the audit and the remediation run, so a span
+ * absent at the remediation's own start could be a fix made in between rather
+ * than a misquote — the very confusion this leg exists to avoid. The obvious
+ * candidate, the host-handoff `baseline_commit`, is exactly that remediation-
+ * side value and is therefore refused here BY NAME.
+ *
+ * The audit-side search (the findings contract and `Finding` schema, the report
+ * intake path, `intake.ts`, `plan.ts`) finds no recorded upstream commit: the
+ * `Finding` fields are the quote grounding (`quoted_text`), the plan-time
+ * content hash (`hash_at_plan_time`, stamped by the REMEDIATOR at plan time),
+ * the evidence lane, the verification status and the analyzer provenance —
+ * none of which is a rev. `audit-findings.json`'s only envelope fields are
+ * `contract_version` and the derived `summary`. The audit artifacts that DO
+ * carry a rev (`artifact_metadata.git_history_baseline.head`) are internal
+ * staleness caches and are never promoted into the deliverable the remediator
+ * consumes. So at the time this leg was written B was UNKNOWN on every real
+ * run, and every candidate resolved to WITHHELD.
+ *
+ * The resolution is NOT to invent a B and not to keep the false single-read
+ * rule: it is to make B an OPTIONAL INPUT with a RESOLVER SEAM, so the rule
+ * above is the shipped rule and a later packet that stamps the audit's rev only
+ * has to supply the value. `HeadEvidenceOverrides.findingBase` is that seam.
+ * Absent means "no B was supplied"; a caller that supplies one gets the
+ * two-read determination, and any B that does not resolve to a real commit in
+ * this repo is refused as unknown rather than read.
+ *
+ * PROVENANCE IS STRUCTURAL. Only `resolved_no_change` items are considered: the
+ * host has already asserted "I changed nothing because nothing needed
+ * changing", so this leg CONFIRMS or leaves that assertion standing — it can
+ * never manufacture a disposition for an item nobody resolved. The outcome is
+ * then still subject to the writer's own backstop, which refuses a triple whose
+ * mechanism contradicts the disposition (`mechanismContradictsOutcome`) or that
+ * arrives incomplete; a mechanism/disposition pair is reachable here only
+ * because the branch above chose both together.
+ *
+ * It is a close-gate VERIFY leg, never a `CLOSING_ACTIONS` entry: it runs
+ * beside `verifyAnalyzerLeads`, dispatches no host work, and a run with no
+ * qualifying item is a no-op.
+ */
+/**
+ * The commit the AUDIT read when it produced the findings — the `B` of the
+ * two-read rule above. Production passes none: nothing in the audit contract
+ * records one (see the module header), so a real run resolves to WITHHELD
+ * rather than to a fabricated verdict.
+ */
+export interface FindingBase {
+    /** Full commit id the audit read. Resolved against the repo before use. */
+    commit: string;
+}
+export interface HeadEvidenceOverrides {
+    /**
+     * Test-injectable source; production callers pass none. Reads one file's
+     * content at a ref — the seam BOTH of the leg's reads go through, so a test
+     * can drive the two-read rule without a second commit on disk.
+     */
+    readAtRef?: (root: string, ref: string, file: string) => Promise<string | undefined>;
+    /**
+     * The audit-read commit `B`, when a caller has one. Absent (the production
+     * default) means B is unknown and no candidate can be determined.
+     */
+    findingBase?: FindingBase;
+}
+/**
+ * One candidate item's fate. A withheld record deliberately carries no
+ * `disposition`/`evidence`: it is the statement that NEITHER was determined,
+ * and giving it a triple would be giving it the very shape this whole leg
+ * exists to keep meaningful.
+ */
+export type HeadEvidenceRecord = {
+    finding_id: string;
+    determined: true;
+    disposition: PerFindingDisposition;
+    evidence: Evidence;
+} | {
+    finding_id: string;
+    determined: false;
+    /** Why an item that qualified was NOT determined — recorded, never silent. */
+    reason: string;
+};
+export interface HeadEvidenceOutcome {
+    /** False when no item was a candidate (leg is a no-op). */
+    ran: boolean;
+    /** The commit this leg's HEAD reads were made against; null when HEAD did not resolve. */
+    head: string | null;
+    /** The audit-read commit `B`, when one was supplied AND resolved; null otherwise. */
+    base: string | null;
+    /** Per finding_id, the triple + disposition this leg RECORDED onto the item. */
+    recorded: Record<string, HeadEvidenceRecord>;
+    /** Candidate items the leg declined to determine, with the reason. */
+    withheld: HeadEvidenceRecord[];
+}
+/** The module stamp carried into `recorded_by_module` (the ATTRIBUTION ROUND-TRIP). */
+export declare const HEAD_EVIDENCE_MODULE = "closeVerifyHeadEvidence";
+export declare function verifyHeadEvidenceAgainstFindings(params: {
+    state: {
+        plan?: {
+            findings?: Finding[];
+        } | undefined;
+        items?: Record<string, RemediationItemState> | undefined;
+    };
+    root: string;
+    overrides?: HeadEvidenceOverrides;
+}): Promise<HeadEvidenceOutcome>;
+//# sourceMappingURL=closeVerifyHeadEvidence.d.ts.map

package/dist/remediate/phases/closeVerifyHeadEvidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeVerifyHeadEvidence.d.ts","sourceRoot":"","sources":["../../../src/remediate/phases/closeVerifyHeadEvidence.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACrF;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IACE,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,IAAI,CAAC;IACjB,WAAW,EAAE,qBAAqB,CAAC;IACnC,QAAQ,EAAE,QAAQ,CAAC;CACpB,GACD;IACE,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,KAAK,CAAC;IAClB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEN,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,GAAG,EAAE,OAAO,CAAC;IACb,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qFAAqF;IACrF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,gFAAgF;IAChF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC7C,sEAAsE;IACtE,QAAQ,EAAE,kBAAkB,EAAE,CAAC;CAChC;AAUD,uFAAuF;AACvF,eAAO,MAAM,oBAAoB,4BAA4B,CAAC;AAuL9D,wBAAsB,iCAAiC,CAAC,MAAM,EAAE;IAC9D,KAAK,EAAE;QAAE,IAAI,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;SAAE,GAAG,SAAS,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAAG,SAAS,CAAA;KAAE,CAAC;IACjH,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACnC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAyF/B"}

package/dist/remediate/phases/closeVerifyHeadEvidence.js

@@ -0,0 +1,242 @@
+import { enumerateTrackedFilePaths, fileContentAtRef, gitRefExists, headCommit, isBareBasename, normalizeForMatch, quoteMatches, resolveBasenameToTrackedPath, stripEmittedLinePrefix, toPosixPath, } from "audit-tools/shared";
+const NO_OP = {
+    ran: false,
+    head: null,
+    base: null,
+    recorded: {},
+    withheld: [],
+};
+/** The module stamp carried into `recorded_by_module` (the ATTRIBUTION ROUND-TRIP). */
+export const HEAD_EVIDENCE_MODULE = "closeVerifyHeadEvidence";
+/**
+ * How wide an emitted `NNN| ` line prefix this leg will strip when asking
+ * whether a quote is absent. The emitter's own widths are per-delivery, and no
+ * delivery manifest reaches close — so rather than guess one width, the leg
+ * strips the widest prefix the emitted form can carry. That direction is the
+ * safe one: over-stripping can only turn a "present" into a withheld record,
+ * never an absent into a false `verified_already_fixed`.
+ */
+const PREFIX_WIDTH_MAX = 8;
+/** Which cited anchor this leg will read, or `undefined` when none carries a quoted span. */
+function anchorFor(finding) {
+    for (const location of finding.affected_files ?? []) {
+        const quoted = location.quoted_text;
+        if (typeof quoted === "string" && quoted.trim().length > 0) {
+            return { path: location.path, quoted };
+        }
+    }
+    return undefined;
+}
+/** The cited 1-based line the triple names, or `""` when the finding cites no line. */
+function citedLineLabel(finding) {
+    for (const location of finding.affected_files ?? []) {
+        if (location.line_start === undefined)
+            continue;
+        const end = location.line_end ?? location.line_start;
+        return end === location.line_start ? `${location.line_start}` : `${location.line_start}-${end}`;
+    }
+    return "";
+}
+/**
+ * Resolve a cited path to the repo-relative path it names, or `undefined` when
+ * nothing is there. A bare basename resolves against the tracked corpus exactly
+ * as the grounding pass resolves it (INV-B3-3), so a nested `advance.ts` is not
+ * false-negatived into looking like a phantom path.
+ */
+function resolveCitedFile(cited, corpus) {
+    const trimmed = cited.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (!isBareBasename(trimmed))
+        return toPosixPath(trimmed);
+    return resolveBasenameToTrackedPath(trimmed, corpus);
+}
+/**
+ * Whether a quoted span is present in `content` — the ONE predicate both reads
+ * go through, so B and HEAD cannot disagree about what "present" means, and
+ * neither can drift from the grounding pass whose identical test admitted the
+ * finding (S7 tier-1).
+ *
+ * The emitted-`NNN| `-prefix branch strips the QUOTE, not the content, exactly
+ * as `checkCitations` does (`quoteMatches(content, stripEmittedLinePrefix(quote,
+ * width))`) — the prefix is attached to the span the worker was shown, so it
+ * rides the quote. Stripping the CONTENT instead is not the same operation and
+ * is silently wrong: it de-prefixes the file's other lines rather than the
+ * quote's, so a quote that was genuinely recoverable reads as absent.
+ *
+ * The ambiguity is applied to BOTH reads, not only to HEAD: a quote the emitted
+ * prefix was not stripped from reads as ABSENT under the raw test even when the
+ * code is right there, so admitting that shape on one side and not the other
+ * would let the prefix alone manufacture a verdict.
+ */
+function spanPresence(content, quoted) {
+    if (normalizeForMatch(quoted).length === 0) {
+        return { kind: "withheld", reason: "the cited quoted_text span is empty after normalization" };
+    }
+    if (quoteMatches(content, quoted))
+        return { kind: "present" };
+    if (quoteMatches(content, stripEmittedLinePrefix(quoted, PREFIX_WIDTH_MAX))) {
+        return { kind: "ambiguous" };
+    }
+    return { kind: "absent" };
+}
+/**
+ * Determine one item from its finding's own cited anchor, read at BOTH B and
+ * HEAD. Returns the disposition + triple, or a reason why no determination was
+ * possible.
+ */
+async function determine(params) {
+    const { root, head, base, corpus, finding, readAtRef } = params;
+    const anchor = anchorFor(finding);
+    if (!anchor) {
+        // Too little evidence to decide. Stated, never guessed at: this is the
+        // per-file lane's normal shape (it carries an `evidence` array, not
+        // `quoted_text` spans), so the leg must decline rather than infer a defect
+        // claim out of prose the finding never bound to a location.
+        return { withheld: "the finding carries no verbatim quoted_text span on any cited location" };
+    }
+    const file = resolveCitedFile(anchor.path, corpus);
+    if (!file) {
+        return { withheld: `cited path '${anchor.path}' does not resolve to a tracked file` };
+    }
+    const shortHead = head.slice(0, 12);
+    const baseContent = await readAtRef(root, base, file);
+    if (baseContent === undefined) {
+        return { withheld: `'${file}' is not a readable file at the audit-read commit ${base.slice(0, 12)}` };
+    }
+    const basePresence = spanPresence(baseContent, anchor.quoted);
+    if (basePresence.kind === "withheld")
+        return { withheld: basePresence.reason };
+    if (basePresence.kind === "ambiguous") {
+        return {
+            withheld: "the cited span matches at the audit-read commit only after stripping an emitted line prefix, so its presence there cannot be established",
+        };
+    }
+    const line = citedLineLabel(finding);
+    if (basePresence.kind === "present") {
+        const headContent = await readAtRef(root, head, file);
+        if (headContent === undefined) {
+            return { withheld: `'${file}' is not a readable file at HEAD` };
+        }
+        const headPresence = spanPresence(headContent, anchor.quoted);
+        if (headPresence.kind === "withheld")
+            return { withheld: headPresence.reason };
+        if (headPresence.kind === "ambiguous") {
+            return {
+                withheld: "the cited span matches at HEAD only after stripping an emitted line prefix, so its absence there cannot be established",
+            };
+        }
+        if (headPresence.kind === "present") {
+            // The code the finding quoted still stands at both reads. That is not a
+            // refutation: a span still present proves only that the code is still
+            // there — if the defect was real at B, it is still real at HEAD. This leg
+            // makes no claim about the English of the finding, so it declines.
+            return {
+                withheld: `the cited span is present both at the audit-read commit ${base.slice(0, 12)} and at HEAD ${shortHead}, ` +
+                    "so this leg cannot tell a still-standing defect from a finding the code never showed",
+            };
+        }
+        return {
+            disposition: "verified_already_fixed",
+            evidence: {
+                file,
+                line,
+                mechanism: "read_at_head_verification",
+                mechanism_detail: `read '${file}' at the audit-read commit ${base.slice(0, 12)} and at HEAD ${shortHead}: ` +
+                    "the cited span the finding quotes was present there and is no longer present, so the defect it cites was fixed by the time of the HEAD read",
+            },
+        };
+    }
+    // Absent at B, whatever HEAD says: the cited location never showed the quoted
+    // span, so the finding's own citation cannot evidence the defect it claims.
+    // HEAD is not read at all here — its state cannot change this verdict, and a
+    // read we do not need is a read whose result we would have to ignore.
+    return {
+        disposition: "refuted",
+        evidence: {
+            file,
+            line,
+            mechanism: "read_at_head_refutation",
+            mechanism_detail: `read '${file}' at the audit-read commit ${base.slice(0, 12)}: the cited span the finding quotes ` +
+                "is not present there, so the cited location never showed the defect the finding claims",
+        },
+    };
+}
+export async function verifyHeadEvidenceAgainstFindings(params) {
+    const { state, root, overrides } = params;
+    const findingsById = new Map((state.plan?.findings ?? []).map((finding) => [finding.id, finding]));
+    // Provenance first: only a `resolved_no_change` item is a candidate, because
+    // only there has the host asserted a no-change resolution for this leg to
+    // confirm. An item that already carries an override is left alone — a
+    // determination someone else recorded is not this leg's to overwrite.
+    const candidates = [];
+    for (const item of Object.values(state.items ?? {})) {
+        if (item.status !== "resolved_no_change")
+            continue;
+        if (item.disposition_override !== undefined)
+            continue;
+        const finding = findingsById.get(item.finding_id);
+        if (!finding)
+            continue;
+        candidates.push({ item, finding });
+    }
+    if (candidates.length === 0)
+        return NO_OP;
+    const withholdAll = (head, reason) => ({
+        ran: true,
+        head,
+        base: null,
+        recorded: {},
+        withheld: candidates.map(({ finding }) => ({
+            finding_id: finding.id,
+            determined: false,
+            reason,
+        })),
+    });
+    // No resolvable HEAD means no read-at-HEAD determination exists to record, so
+    // the leg refuses to run rather than record a triple it cannot stand behind.
+    const head = await headCommit(root);
+    if (head === null) {
+        return withholdAll(null, "no resolvable HEAD — a read-at-HEAD determination cannot be made");
+    }
+    // B is an INPUT, never a guess, and it is verified before it is read: a
+    // supplied commit that does not resolve in THIS repo is not a read the leg can
+    // honestly attribute a triple to, so it is refused as unknown rather than
+    // handed to `git show`. `gitRefExists` is what distinguishes "the caller gave
+    // us a B this repo does not have" from "the caller gave us none" — both end in
+    // the same withhold, but only one of them is a caller error worth naming.
+    const base = overrides?.findingBase?.commit;
+    if (base === undefined) {
+        return withholdAll(head, "no audit-read commit is recorded for these findings, so neither a verification nor a refutation can be determined");
+    }
+    if (!(await gitRefExists(root, base))) {
+        return withholdAll(head, `the supplied audit-read commit '${base}' does not resolve to a commit in this repository`);
+    }
+    const corpus = await enumerateTrackedFilePaths(root);
+    const readAtRef = overrides?.readAtRef ??
+        ((readRoot, ref, file) => fileContentAtRef(readRoot, ref, file));
+    const recorded = {};
+    const withheld = [];
+    for (const { item, finding } of candidates) {
+        const verdict = await determine({ root, head, base, corpus, finding, readAtRef });
+        if ("withheld" in verdict) {
+            withheld.push({
+                finding_id: finding.id,
+                determined: false,
+                reason: verdict.withheld,
+            });
+            continue;
+        }
+        item.disposition_override = verdict.disposition;
+        item.evidence = verdict.evidence;
+        item.recorded_by_module = HEAD_EVIDENCE_MODULE;
+        recorded[finding.id] = {
+            finding_id: finding.id,
+            determined: true,
+            disposition: verdict.disposition,
+            evidence: verdict.evidence,
+        };
+    }
+    return { ran: true, head, base, recorded, withheld };
+}
+//# sourceMappingURL=closeVerifyHeadEvidence.js.map

package/dist/remediate/phases/closeVerifyHeadEvidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeVerifyHeadEvidence.js","sourceRoot":"","sources":["../../../src/remediate/phases/closeVerifyHeadEvidence.ts"],"names":[],"mappings":"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"}

package/dist/remediate/state/runStatus.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The single authority for the `RemediationState` RUN status lifecycle.
+ *
+ * `RemediationState.status` is the canonical coarse phase of a remediation run;
+ * the load gate (`validateState` in `./store.ts`) admits exactly these values
+ * and the run-status invariant test asserts against this array. Nothing outside
+ * this module may re-enumerate them.
+ *
+ * Why this module exists. The vocabulary used to exist in three unlinked
+ * copies: the inline union on `RemediationState.status`, the module-private
+ * accepted-status Set the load gate rejects unknown states with, and a third
+ * literal written inside the test. Nothing joined them, so the load gate
+ * and the type could drift apart with no red build — and the assertion
+ * ("`documenting` is not a status") was a tautology over a literal the test
+ * itself wrote, so a `documenting` status reintroduced into the type would have
+ * passed it silently. The array below is the ONE declaration; the type, the
+ * load gate and the test all derive from it. [[write-only-data-looks-authoritative]]
+ *
+ * Deliberately mirrors `ITEM_STATUSES` in `./itemStatus.ts` (a `const` tuple
+ * plus a derived union type) so the two halves of remediation state read the
+ * same way.
+ */
+/**
+ * Every status a remediation RUN can hold, in lifecycle order.
+ *
+ * `documenting` is deliberately absent: the document phase was dissolved, and
+ * planning transitions DIRECTLY to implementing. Adding it back is a red — see
+ * the run-status invariant test, which reads this array rather than restating
+ * it.
+ */
+export declare const REMEDIATION_RUN_STATUSES: readonly ["pending", "planning", "waiting_for_clarification", "implementing", "triage", "waiting_for_triage", "closing", "complete"];
+export type RemediationRunStatus = (typeof REMEDIATION_RUN_STATUSES)[number];
+/** Runtime membership test for the load gate — derived, never re-listed. */
+export declare function isRemediationRunStatus(value: unknown): value is RemediationRunStatus;
+//# sourceMappingURL=runStatus.d.ts.map

package/dist/remediate/state/runStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runStatus.d.ts","sourceRoot":"","sources":["../../../src/remediate/state/runStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,sIAS3B,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7E,4EAA4E;AAC5E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAKpF"}

package/dist/remediate/state/runStatus.js

@@ -0,0 +1,46 @@
+/**
+ * The single authority for the `RemediationState` RUN status lifecycle.
+ *
+ * `RemediationState.status` is the canonical coarse phase of a remediation run;
+ * the load gate (`validateState` in `./store.ts`) admits exactly these values
+ * and the run-status invariant test asserts against this array. Nothing outside
+ * this module may re-enumerate them.
+ *
+ * Why this module exists. The vocabulary used to exist in three unlinked
+ * copies: the inline union on `RemediationState.status`, the module-private
+ * accepted-status Set the load gate rejects unknown states with, and a third
+ * literal written inside the test. Nothing joined them, so the load gate
+ * and the type could drift apart with no red build — and the assertion
+ * ("`documenting` is not a status") was a tautology over a literal the test
+ * itself wrote, so a `documenting` status reintroduced into the type would have
+ * passed it silently. The array below is the ONE declaration; the type, the
+ * load gate and the test all derive from it. [[write-only-data-looks-authoritative]]
+ *
+ * Deliberately mirrors `ITEM_STATUSES` in `./itemStatus.ts` (a `const` tuple
+ * plus a derived union type) so the two halves of remediation state read the
+ * same way.
+ */
+/**
+ * Every status a remediation RUN can hold, in lifecycle order.
+ *
+ * `documenting` is deliberately absent: the document phase was dissolved, and
+ * planning transitions DIRECTLY to implementing. Adding it back is a red — see
+ * the run-status invariant test, which reads this array rather than restating
+ * it.
+ */
+export const REMEDIATION_RUN_STATUSES = [
+    "pending",
+    "planning",
+    "waiting_for_clarification",
+    "implementing",
+    "triage",
+    "waiting_for_triage",
+    "closing",
+    "complete",
+];
+/** Runtime membership test for the load gate — derived, never re-listed. */
+export function isRemediationRunStatus(value) {
+    return (typeof value === "string" &&
+        REMEDIATION_RUN_STATUSES.includes(value));
+}
+//# sourceMappingURL=runStatus.js.map

package/dist/remediate/state/runStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runStatus.js","sourceRoot":"","sources":["../../../src/remediate/state/runStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,SAAS;IACT,UAAU;IACV,2BAA2B;IAC3B,cAAc;IACd,QAAQ;IACR,oBAAoB;IACpB,SAAS;IACT,UAAU;CACF,CAAC;AAIX,4EAA4E;AAC5E,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACxB,wBAA8C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAChE,CAAC;AACJ,CAAC"}

package/dist/remediate/state/store.d.ts

@@ -1,6 +1,47 @@
+import { SKIP_WRITE } from "audit-tools/shared";
 import { RemediationPlan, RemediationItemState, ClarificationRequest, ClosingPlan, CoverageLedger, RemediationHostHandoffRecord } from "./types.js";
+import { type RemediationRunStatus } from "./runStatus.js";
+/**
+ * The schema version stamped on every persisted `state.json`.
+ *
+ * The VALUE is unchanged from the literal three modules already spelled out
+ * (the host-handoff parser, the state-shaping helper in `nextStep.ts`, and the
+ * test fixtures). What changes is that it is now ONE declaration that the store
+ * actually writes and reads back, rather than a constant a reader FABRICATED
+ * onto the loaded value to satisfy its own parser — see `parseCurrentState`'s
+ * call site in `steps/dispatch/hostHandoff.ts`. An identity that the reader
+ * supplies itself is not a check; it is the check's answer written in advance.
+ *
+ * A run's state is COSTLY / AUTHORED state in the sense
+ * `audit-tools/shared/io/schemaVersion.ts` names: it records work an operator
+ * or a host has already done, and it cannot be rebuilt from anything else on
+ * disk. That module's policy is therefore THROW on a mismatch — silently
+ * discarding a state would read as "this run never started" and destroy the
+ * plan, the item ledger and every recorded acceptance with it.
+ *
+ * ABSENT IS NOT A MISMATCH, and the distinction is deliberate here rather than
+ * inherited. Every run already in flight when this field was introduced has a
+ * `state.json` with no `contract_version`; treating its absence as a mismatch
+ * would refuse to load exactly the runs this field exists to protect. An
+ * unstamped state is read under the CURRENT version's semantics (it was written
+ * by a release whose shape this one still admits — that is what makes the field
+ * safe to add), and the next write stamps it. A stamped-but-DIFFERENT version
+ * is the case that throws, because at that point the file positively claims
+ * another release's semantics rather than merely predating the field.
+ *
+ * Same asymmetry as `intent_checkpoint` (absent ⇒ nothing to check; present
+ * and different ⇒ refuse loudly), inverted for a version that is newly added
+ * rather than newly REQUIRED.
+ */
+export declare const REMEDIATION_STATE_CONTRACT_VERSION: "remediate-code-state/v1alpha1";
 export interface RemediationState {
-    status: "pending" | "planning" | "waiting_for_clarification" | "implementing" | "triage" | "waiting_for_triage" | "closing" | "complete";
+    /**
+     * Schema version of this persisted state. Optional on the TYPE because a
+     * state written before the field existed is a legal input; see
+     * {@link REMEDIATION_STATE_CONTRACT_VERSION} for how it reads.
+     */
+    contract_version?: typeof REMEDIATION_STATE_CONTRACT_VERSION;
+    status: RemediationRunStatus;
     plan?: RemediationPlan;
     items?: Record<string, RemediationItemState>;
     clarifications?: ClarificationRequest[];
@@ -86,8 +127,17 @@ export declare class StateStore {
      * current state (or null), passes it to `fn`, and writes the returned state
      * before releasing the lock. No other holder can interleave between the load
      * and the save. INV-remediate-state-02 + INV-remediate-state-03.
+     *
+     * Returning the shared `SKIP_WRITE` sentinel from `fn` is the no-op: the write
+     * is skipped and this resolves with the state that was READ. The skip decision
+     * is taken inside the SAME held lock as the write it avoids, so it cannot race
+     * a concurrent writer. Whole-run verbs that routinely change nothing — the
+     * `recover-ingest` retry loop is the live one — otherwise replace `state.json`
+     * with byte-identical content on every pass, which makes "did anything
+     * change?" unanswerable from the file and rewrites an artifact other readers
+     * treat as the run's ground truth.
      */
-    mutate(fn: (current: RemediationState | null) => Promise<RemediationState>): Promise<RemediationState>;
+    mutate(fn: (current: RemediationState | null) => Promise<RemediationState | typeof SKIP_WRITE>): Promise<RemediationState>;
     /**
      * Save state.json unconditionally (no TOCTOU protection, no read — so a
      * corrupt on-disk state never blocks recovery). Prefer `mutate` for

package/dist/remediate/state/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/remediate/state/store.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,cAAc,EACd,4BAA4B,EAE7B,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EACF,SAAS,GACT,UAAU,GACV,2BAA2B,GAC3B,cAAc,GACd,QAAQ,GACR,oBAAoB,GACpB,SAAS,GACT,UAAU,CAAC;IACf,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC7C,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACxC,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,YAAY,CAAC,EAAE,4BAA4B,CAAC;CAC7C;AAuID,eAAO,MAAM,eAAe,QAA+B,CAAC;AAU5D,qBAAa,UAAU;IAWnB,OAAO,CAAC,YAAY;IAEpB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAZlC;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;gBAGvD,YAAY,EAAE,MAAM,EAEX,cAAc,CAAC,EAAE,MAAM,YAAA;IAoBpC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;;;;;OAQG;IACG,SAAS,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAInD;;;;;OAKG;IACG,MAAM,CACV,EAAE,EAAE,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,KAAK,OAAO,CAAC,gBAAgB,CAAC,GAClE,OAAO,CAAC,gBAAgB,CAAC;IAa5B;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAMxD"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/remediate/state/store.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,cAAc,EACd,4BAA4B,EAE7B,MAAM,YAAY,CAAC;AAEpB,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,kCAAkC,EAC7C,+BAAwC,CAAC;AAK3C,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,kCAAkC,CAAC;IAC7D,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC7C,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACxC,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,YAAY,CAAC,EAAE,4BAA4B,CAAC;CAC7C;AA+ID,eAAO,MAAM,eAAe,QAA+B,CAAC;AAU5D,qBAAa,UAAU;IAWnB,OAAO,CAAC,YAAY;IAEpB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAZlC;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;gBAGvD,YAAY,EAAE,MAAM,EAEX,cAAc,CAAC,EAAE,MAAM,YAAA;IA4CpC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;;;;;OAQG;IACG,SAAS,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAInD;;;;;;;;;;;;;;OAcG;IACG,MAAM,CACV,EAAE,EAAE,CACF,OAAO,EAAE,gBAAgB,GAAG,IAAI,KAC7B,OAAO,CAAC,gBAAgB,GAAG,OAAO,UAAU,CAAC,GACjD,OAAO,CAAC,gBAAgB,CAAC;IA4B5B;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAMxD"}