audit-tools 0.28.0

package/dist/remediate/review/reviewGate.d.ts

@@ -0,0 +1,72 @@
+import type { Finding, FindingSeverity, FindingConfidence } from "audit-tools/shared";
+import { type ReviewNecessity, type ImplementationCost } from "./reviewNecessity.js";
+export declare const REVIEW_REQUEST_SCHEMA_VERSION: "remediate-code-review-request/v1";
+export declare const REVIEW_RESOLUTION_SCHEMA_VERSION: "remediate-code-review-resolution/v1";
+/** One reviewable item, with the tool-owned deterministic fields populated. */
+export interface ReviewItemEntry {
+    finding_id: string;
+    title: string;
+    severity: FindingSeverity;
+    confidence: FindingConfidence;
+    lens: string;
+    summary: string;
+    affected_files: string[];
+    necessity: ReviewNecessity;
+    /** Deterministic reason this item landed in its tier. */
+    rationale: string;
+    implementation_cost: ImplementationCost;
+}
+/** A review-necessity tier with its items (most-review-needed tiers first). */
+export interface ReviewTierGroup {
+    necessity: ReviewNecessity;
+    label: string;
+    description: string;
+    items: ReviewItemEntry[];
+}
+/** The halt artifact presented to the user (`review_request.json`). */
+export interface ReviewRequest {
+    schema_version: typeof REVIEW_REQUEST_SCHEMA_VERSION;
+    plan_id: string;
+    total: number;
+    counts: Record<ReviewNecessity, number>;
+    /** Non-empty tiers only, ordered most-review-needed first. */
+    tiers: ReviewTierGroup[];
+}
+/** The user's verdict (`review_resolution.json`). */
+export interface ReviewResolution {
+    plan_id?: string;
+    /** Finding ids the user disapproved — do NOT act on these. */
+    disapproved_findings?: string[];
+    /** Whole tiers the user disapproved (e.g. "decline everything strategic"). */
+    disapproved_tiers?: ReviewNecessity[];
+}
+export interface ReviewDecision {
+    /** Finding ids approved to proceed to implementation. */
+    approved_ids: string[];
+    /** Disapproved items, each with the recorded reason for its terminal disposition. */
+    declined: Array<{
+        finding_id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Build the tiered review request from a finding set. Deterministic: the same
+ * findings always produce the same tiers/entries. Empty tiers are omitted, but
+ * `counts` always carries all three keys so the caller can report the full
+ * distribution.
+ */
+export declare function buildReviewRequest(findings: readonly Finding[], planId: string): ReviewRequest;
+/**
+ * Apply the user's resolution to a request: every item is either approved (act
+ * on it) or declined (recorded terminal disposition with a reason). An item is
+ * declined if its id is in `disapproved_findings` OR its tier is in
+ * `disapproved_tiers`. Everything else is approved — the default is to act,
+ * because the gate's job is to let the user REMOVE items, not to require
+ * opting every item in. An absent/empty resolution approves everything.
+ *
+ * Crucially, declined items are returned with an explicit reason so the caller
+ * records a terminal disposition (e.g. `ignored`) rather than silently closing
+ * them — the exact failure this gate exists to prevent.
+ */
+export declare function applyReviewResolution(request: ReviewRequest, resolution: ReviewResolution | null | undefined): ReviewDecision;
+//# sourceMappingURL=reviewGate.d.ts.map

package/dist/remediate/review/reviewGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewGate.d.ts","sourceRoot":"","sources":["../../../src/remediate/review/reviewGate.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAKxB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,6BAA6B,EAAG,kCAA2C,CAAC;AACzF,eAAO,MAAM,gCAAgC,EAAG,qCAA8C,CAAC;AAE/F,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,kBAAkB,CAAC;CACzC;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,eAAe,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,OAAO,6BAA6B,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IACxC,8DAA8D;IAC9D,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,8EAA8E;IAC9E,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,qFAAqF;IACrF,QAAQ,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzD;AAsBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,MAAM,EAAE,MAAM,GACb,aAAa,CAyBf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GAC9C,cAAc,CAyBhB"}

package/dist/remediate/review/reviewGate.js

@@ -0,0 +1,112 @@
+// Review-approval gate engine — builds the tiered item-set the user
+// approves/disapproves, and consumes their verdict.
+//
+// This is the single review surface for both paths. It replaced the classic
+// per-block implementation-risk preview, which fired AFTER the contract pipeline
+// collapsed the N original findings into M implementation-DAG nodes: the
+// block-level preview showed M node "findings" while the individual design-review
+// / free-form findings bundled inside a quality-tail node were never surfaced —
+// they got bulk-dispositioned ("direction recorded") inside the node's worker,
+// invisibly (the 2026-06-15 failure this gate exists to prevent). This engine
+// instead operates BEFORE that collapse: Path A gates the original findings at
+// intake; Path B gates the deduped/grounded node findings at the planning point.
+// Every judgment-heavy item is presented for an explicit decision before the
+// pipeline can mark it terminal-without-change.
+//
+// Tool owns the structure (tiering, rationale, cost, which items must be shown);
+// the host fills only the semantic pros/cons slots when presenting. Disapproved
+// items become a RECORDED terminal disposition, never a silent close.
+import { classifyReviewNecessity, partitionByReviewNecessity, REVIEW_NECESSITY_ORDER, REVIEW_NECESSITY_LABELS, } from "./reviewNecessity.js";
+export const REVIEW_REQUEST_SCHEMA_VERSION = "remediate-code-review-request/v1";
+export const REVIEW_RESOLUTION_SCHEMA_VERSION = "remediate-code-review-resolution/v1";
+function firstPath(finding) {
+    return (finding.affected_files ?? []).map((f) => f.path).filter(Boolean);
+}
+function toEntry(finding) {
+    const classification = classifyReviewNecessity(finding);
+    return {
+        finding_id: finding.id,
+        title: finding.title,
+        severity: finding.severity,
+        confidence: finding.confidence,
+        lens: finding.lens,
+        summary: finding.summary,
+        affected_files: firstPath(finding),
+        necessity: classification.necessity,
+        rationale: classification.rationale,
+        implementation_cost: classification.implementation_cost,
+    };
+}
+/**
+ * Build the tiered review request from a finding set. Deterministic: the same
+ * findings always produce the same tiers/entries. Empty tiers are omitted, but
+ * `counts` always carries all three keys so the caller can report the full
+ * distribution.
+ */
+export function buildReviewRequest(findings, planId) {
+    const buckets = partitionByReviewNecessity(findings);
+    const counts = {
+        strategic: buckets.strategic.length,
+        concrete: buckets.concrete.length,
+        mechanical: buckets.mechanical.length,
+    };
+    const tiers = [];
+    for (const necessity of REVIEW_NECESSITY_ORDER) {
+        const classified = buckets[necessity];
+        if (classified.length === 0)
+            continue;
+        tiers.push({
+            necessity,
+            label: REVIEW_NECESSITY_LABELS[necessity].title,
+            description: REVIEW_NECESSITY_LABELS[necessity].description,
+            items: classified.map((c) => toEntry(c.finding)),
+        });
+    }
+    return {
+        schema_version: REVIEW_REQUEST_SCHEMA_VERSION,
+        plan_id: planId,
+        total: findings.length,
+        counts,
+        tiers,
+    };
+}
+/**
+ * Apply the user's resolution to a request: every item is either approved (act
+ * on it) or declined (recorded terminal disposition with a reason). An item is
+ * declined if its id is in `disapproved_findings` OR its tier is in
+ * `disapproved_tiers`. Everything else is approved — the default is to act,
+ * because the gate's job is to let the user REMOVE items, not to require
+ * opting every item in. An absent/empty resolution approves everything.
+ *
+ * Crucially, declined items are returned with an explicit reason so the caller
+ * records a terminal disposition (e.g. `ignored`) rather than silently closing
+ * them — the exact failure this gate exists to prevent.
+ */
+export function applyReviewResolution(request, resolution) {
+    const disapprovedIds = new Set(resolution?.disapproved_findings ?? []);
+    const disapprovedTiers = new Set(resolution?.disapproved_tiers ?? []);
+    const approved_ids = [];
+    const declined = [];
+    for (const tier of request.tiers) {
+        const tierDisapproved = disapprovedTiers.has(tier.necessity);
+        for (const item of tier.items) {
+            if (tierDisapproved) {
+                declined.push({
+                    finding_id: item.finding_id,
+                    reason: `Disapproved by the user at the review gate — declined the entire "${item.necessity}" tier.`,
+                });
+            }
+            else if (disapprovedIds.has(item.finding_id)) {
+                declined.push({
+                    finding_id: item.finding_id,
+                    reason: `Disapproved by the user at the review gate (review-necessity: ${item.necessity}).`,
+                });
+            }
+            else {
+                approved_ids.push(item.finding_id);
+            }
+        }
+    }
+    return { approved_ids, declined };
+}
+//# sourceMappingURL=reviewGate.js.map

package/dist/remediate/review/reviewGate.js.map

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

package/dist/remediate/review/reviewNecessity.d.ts

@@ -0,0 +1,53 @@
+import type { Finding } from "audit-tools/shared";
+/**
+ * How much of the USER's judgment a finding needs before it is acted on.
+ * - `strategic`  — design/architecture/cross-cutting decision; the user's call.
+ *                  These are exactly the items that "flitted into the ether".
+ * - `concrete`   — a real fix with some design latitude; worth a confirmation.
+ * - `mechanical` — obvious, low-risk, high-confidence; FYI / rubber-stamp.
+ */
+export type ReviewNecessity = "strategic" | "concrete" | "mechanical";
+/** Coarse, deterministic effort signal derived from blast radius. */
+export type ImplementationCost = "high" | "medium" | "low";
+export interface ReviewClassification {
+    necessity: ReviewNecessity;
+    /** Deterministic, human-readable reason this finding landed in its tier. */
+    rationale: string;
+    implementation_cost: ImplementationCost;
+}
+export interface ClassifiedFinding {
+    finding: Finding;
+    classification: ReviewClassification;
+}
+/** Most-review-needed first. Used to order tiers in the gate prompt. */
+export declare const REVIEW_NECESSITY_ORDER: readonly ReviewNecessity[];
+/** Short human label + what the tier means, for rendering the gate. */
+export declare const REVIEW_NECESSITY_LABELS: Record<ReviewNecessity, {
+    title: string;
+    description: string;
+}>;
+/**
+ * Classify a single finding by how much user review it needs. Pure and
+ * deterministic over the canonical `Finding` contract — the same finding always
+ * lands in the same tier, so the gate can never depend on host discretion.
+ *
+ * Ordered rules, first match wins for the tier:
+ *  1. The architecture lens IS the design-review lens — always strategic. This
+ *     single rule closes the exact 2026-06-15 failure (42 architecture findings
+ *     hidden in quality-tail blocks).
+ *  2. A high-severity systemic (cross-cutting) issue is a direction decision,
+ *     not a local fix — strategic.
+ *  3. Any remaining high-severity finding is a real, bounded fix worth a
+ *     confirmation — concrete.
+ *  4. Informational findings need no behavior change — mechanical.
+ *  5. Low-severity + high-confidence is a rote fix — mechanical.
+ *  6. Everything else (medium, or low/medium-confidence) — concrete.
+ */
+export declare function classifyReviewNecessity(finding: Finding): ReviewClassification;
+/**
+ * Classify and group a set of findings into review-necessity tiers, preserving
+ * input order within each tier. The returned record always has all three keys
+ * (possibly empty), so the gate renders a stable set of buckets.
+ */
+export declare function partitionByReviewNecessity(findings: readonly Finding[]): Record<ReviewNecessity, ClassifiedFinding[]>;
+//# sourceMappingURL=reviewNecessity.d.ts.map

package/dist/remediate/review/reviewNecessity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewNecessity.d.ts","sourceRoot":"","sources":["../../../src/remediate/review/reviewNecessity.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,CAAC;AAEtE,qEAAqE;AACrE,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,eAAe,CAAC;IAC3B,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,kBAAkB,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,oBAAoB,CAAC;CACtC;AAED,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,EAAE,SAAS,eAAe,EAI5D,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,eAAe,EACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgBvC,CAAC;AAeF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,oBAAoB,CAwD9E;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,MAAM,CAAC,eAAe,EAAE,iBAAiB,EAAE,CAAC,CAW9C"}

package/dist/remediate/review/reviewNecessity.js

@@ -0,0 +1,129 @@
+// Deterministic review-necessity classification — the tool-owned core of the
+// review-approval gate (docs/backlog.md "Review-necessity approval gate").
+//
+// The 2026-06-15 self-remediation reported "17/17 resolved" but underneath only
+// 12 of 42 design-review (architecture) findings got a code change; 30 were
+// silently auto-dispositioned ("direction recorded") inside quality-tail blocks
+// and never surfaced to the user. The durable fix is to enforce, in the TOOL,
+// that every finding is bucketed by how much user review it needs BEFORE it can
+// reach a terminal disposition — so judgment-heavy items are presented for
+// approve/disapprove rather than swept closed on host discretion.
+//
+// This module owns the deterministic structure: the tier each finding lands in,
+// why, and a coarse implementation-cost signal. The semantic pros/cons are an
+// LLM slot the gate prompt requires the host to fill — but the tool guarantees
+// the item is SHOWN and tiered (tool owns structure; LLM owns judgment).
+/** Most-review-needed first. Used to order tiers in the gate prompt. */
+export const REVIEW_NECESSITY_ORDER = [
+    "strategic",
+    "concrete",
+    "mechanical",
+];
+/** Short human label + what the tier means, for rendering the gate. */
+export const REVIEW_NECESSITY_LABELS = {
+    strategic: {
+        title: "Strategic — your call",
+        description: "Design/architecture or cross-cutting decisions. Genuine tradeoffs only you should make.",
+    },
+    concrete: {
+        title: "Concrete — some latitude",
+        description: "Real fixes with a clear-ish path but a design choice worth a yes/no.",
+    },
+    mechanical: {
+        title: "Mechanical — FYI",
+        description: "Obvious, low-risk, high-confidence cleanups; minimal review.",
+    },
+};
+const HIGH_SEVERITIES = new Set(["critical", "high"]);
+/**
+ * Coarse implementation-cost from blast radius: systemic or wide-reaching
+ * findings cost more. Deterministic — never an LLM call.
+ */
+function deriveImplementationCost(finding) {
+    const fileCount = finding.affected_files?.length ?? 0;
+    if (finding.systemic === true || fileCount >= 4)
+        return "high";
+    if (fileCount >= 2)
+        return "medium";
+    return "low";
+}
+/**
+ * Classify a single finding by how much user review it needs. Pure and
+ * deterministic over the canonical `Finding` contract — the same finding always
+ * lands in the same tier, so the gate can never depend on host discretion.
+ *
+ * Ordered rules, first match wins for the tier:
+ *  1. The architecture lens IS the design-review lens — always strategic. This
+ *     single rule closes the exact 2026-06-15 failure (42 architecture findings
+ *     hidden in quality-tail blocks).
+ *  2. A high-severity systemic (cross-cutting) issue is a direction decision,
+ *     not a local fix — strategic.
+ *  3. Any remaining high-severity finding is a real, bounded fix worth a
+ *     confirmation — concrete.
+ *  4. Informational findings need no behavior change — mechanical.
+ *  5. Low-severity + high-confidence is a rote fix — mechanical.
+ *  6. Everything else (medium, or low/medium-confidence) — concrete.
+ */
+export function classifyReviewNecessity(finding) {
+    const implementation_cost = deriveImplementationCost(finding);
+    const severity = finding.severity;
+    const isHighSeverity = HIGH_SEVERITIES.has(severity);
+    if (finding.lens === "architecture") {
+        return {
+            necessity: "strategic",
+            rationale: "Design-review (architecture) finding — a structural/design judgment that is your call, not a mechanical fix.",
+            implementation_cost,
+        };
+    }
+    if (finding.systemic === true && isHighSeverity) {
+        return {
+            necessity: "strategic",
+            rationale: "High-severity systemic issue — cross-cutting, so acting on it is a direction decision rather than a local change.",
+            implementation_cost,
+        };
+    }
+    if (isHighSeverity) {
+        return {
+            necessity: "concrete",
+            rationale: "High-impact but bounded fix — the path is clear, but its severity warrants a confirmation before acting.",
+            implementation_cost,
+        };
+    }
+    if (severity === "info") {
+        return {
+            necessity: "mechanical",
+            rationale: "Informational finding — no behavior change required; surfaced for awareness.",
+            implementation_cost,
+        };
+    }
+    if (severity === "low" && finding.confidence === "high") {
+        return {
+            necessity: "mechanical",
+            rationale: "Low-severity, high-confidence finding — a rote/mechanical fix needing little review.",
+            implementation_cost,
+        };
+    }
+    return {
+        necessity: "concrete",
+        rationale: "Concrete fix with some design latitude — worth a quick yes/no before acting.",
+        implementation_cost,
+    };
+}
+/**
+ * Classify and group a set of findings into review-necessity tiers, preserving
+ * input order within each tier. The returned record always has all three keys
+ * (possibly empty), so the gate renders a stable set of buckets.
+ */
+export function partitionByReviewNecessity(findings) {
+    const buckets = {
+        strategic: [],
+        concrete: [],
+        mechanical: [],
+    };
+    for (const finding of findings) {
+        const classification = classifyReviewNecessity(finding);
+        buckets[classification.necessity].push({ finding, classification });
+    }
+    return buckets;
+}
+//# sourceMappingURL=reviewNecessity.js.map

package/dist/remediate/review/reviewNecessity.js.map

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

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

@@ -0,0 +1,3 @@
+export declare const CLOSING_ACTIONS: readonly ["commit", "push", "open-pr", "publish", "tag", "none", "custom"];
+export type ClosingAction = (typeof CLOSING_ACTIONS)[number];
+//# sourceMappingURL=closingActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closingActions.d.ts","sourceRoot":"","sources":["../../../src/remediate/state/closingActions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,4EAQlB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/remediate/state/closingActions.js

@@ -0,0 +1,10 @@
+export const CLOSING_ACTIONS = [
+    "commit",
+    "push",
+    "open-pr",
+    "publish",
+    "tag",
+    "none",
+    "custom",
+];
+//# sourceMappingURL=closingActions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closingActions.js","sourceRoot":"","sources":["../../../src/remediate/state/closingActions.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,QAAQ;IACR,MAAM;IACN,SAAS;IACT,SAAS;IACT,KAAK;IACL,MAAM;IACN,QAAQ;CACA,CAAC"}

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

@@ -0,0 +1,40 @@
+/**
+ * The single authority for the `RemediationItem` status lifecycle.
+ *
+ * `RemediationItemState.status` is the canonical state of a remediation item;
+ * every classification of it (terminal? skip? in-progress?) and every mapping
+ * derived from it (coverage disposition, outcomes-contract status) is defined
+ * HERE and imported elsewhere. Nothing outside this module may re-enumerate the
+ * status values: the exhaustive `Record<RemediationItemStatus, …>` maps below
+ * make adding a status a compile error at each unhandled mapping rather than a
+ * silent drift across the close / coverage / dispatch code paths.
+ */
+import type { RemediationOutcomeStatus } from "audit-tools/shared";
+import type { PerFindingDisposition } from "./types.js";
+/**
+ * Every status a remediation item can hold, in lifecycle order: the in-progress
+ * states (`pending`…`verified`), the success states (`resolved`,
+ * `resolved_no_change`), the failure state (`blocked`), and the settled-no-act
+ * states (`deemed_inappropriate`, `ignored`).
+ */
+export declare const ITEM_STATUSES: readonly ["pending", "tested", "tested_successfully", "refactored", "verified", "resolved", "resolved_no_change", "blocked", "deemed_inappropriate", "ignored"];
+export type RemediationItemStatus = (typeof ITEM_STATUSES)[number];
+/** Whether the item is still mid-flight (see {@link IN_PROGRESS_STATUSES}). */
+export declare function isInProgressStatus(status: string): boolean;
+/** Whether a status is terminal — no further implement work, and a worker result must never resurrect it. `blocked` is NOT terminal. */
+export declare function isTerminalStatus(status: string): boolean;
+/**
+ * Whether a status is VERIFIED-COMPLETE: the node produced and verified its
+ * declared output (`resolved` / `resolved_no_change`). A skipped node
+ * (`ignored` / `deemed_inappropriate`) and a `blocked` node are explicitly NOT
+ * verified-complete — INV-RS-01: a SKIP disposition never satisfies a dependency
+ * edge, so a dependent of a skipped/blocked node stays ineligible.
+ */
+export declare function isVerifiedCompleteStatus(status: string | undefined): boolean;
+/** Whether a status is a SKIP — a settled decision not to act (terminal but never verified-complete, INV-RS-01). */
+export declare function isSkipStatus(status: string): boolean;
+/** Map an item status to its per-finding coverage disposition. */
+export declare function statusToDisposition(status: string): PerFindingDisposition;
+/** Map a coverage disposition to its outcomes-contract status. */
+export declare function dispositionToOutcomeStatus(disposition: PerFindingDisposition): RemediationOutcomeStatus;
+//# sourceMappingURL=itemStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"itemStatus.d.ts","sourceRoot":"","sources":["../../../src/remediate/state/itemStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIxD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,iKAWhB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAkBnE,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE1D;AAmCD,wIAAwI;AACxI,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAK5E;AAED,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpD;AAuBD,kEAAkE;AAClE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAIzE;AAkBD,kEAAkE;AAClE,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,qBAAqB,GACjC,wBAAwB,CAE1B"}

package/dist/remediate/state/itemStatus.js

@@ -0,0 +1,138 @@
+/**
+ * The single authority for the `RemediationItem` status lifecycle.
+ *
+ * `RemediationItemState.status` is the canonical state of a remediation item;
+ * every classification of it (terminal? skip? in-progress?) and every mapping
+ * derived from it (coverage disposition, outcomes-contract status) is defined
+ * HERE and imported elsewhere. Nothing outside this module may re-enumerate the
+ * status values: the exhaustive `Record<RemediationItemStatus, …>` maps below
+ * make adding a status a compile error at each unhandled mapping rather than a
+ * silent drift across the close / coverage / dispatch code paths.
+ */
+// ── Canonical status enum ───────────────────────────────────────────────────
+/**
+ * Every status a remediation item can hold, in lifecycle order: the in-progress
+ * states (`pending`…`verified`), the success states (`resolved`,
+ * `resolved_no_change`), the failure state (`blocked`), and the settled-no-act
+ * states (`deemed_inappropriate`, `ignored`).
+ */
+export const ITEM_STATUSES = [
+    "pending",
+    "tested",
+    "tested_successfully",
+    "refactored",
+    "verified",
+    "resolved",
+    "resolved_no_change",
+    "blocked",
+    "deemed_inappropriate",
+    "ignored",
+];
+// ── In-progress partition ───────────────────────────────────────────────────
+/**
+ * Statuses an item holds while still being worked. An item left in one of these
+ * at close was force-closed mid-flight (no terminal disposition was reached), so
+ * the close phase records it as a failed outcome and preserves the original
+ * state — it is NOT a legitimate run-ending status.
+ */
+const IN_PROGRESS_STATUSES = new Set([
+    "pending",
+    "tested",
+    "tested_successfully",
+    "refactored",
+    "verified",
+]);
+/** Whether the item is still mid-flight (see {@link IN_PROGRESS_STATUSES}). */
+export function isInProgressStatus(status) {
+    return IN_PROGRESS_STATUSES.has(status);
+}
+// ── Terminal / verified-complete / skip partitions ───────────────────────────
+/**
+ * Statuses that legitimately END a run with no further implement work: the two
+ * success states plus the two settled-no-act (SKIP) states. `blocked` is
+ * deliberately NOT terminal — triage retries it — so a blocked item leaves the
+ * run non-terminal and routes to triage rather than closing.
+ */
+const TERMINAL_STATUSES = new Set([
+    "resolved",
+    "resolved_no_change",
+    "ignored",
+    "deemed_inappropriate",
+]);
+/**
+ * The subset of terminal statuses where the node produced AND verified its
+ * declared output (`resolved` / `resolved_no_change`). A SKIP
+ * (`ignored` / `deemed_inappropriate`) and a `blocked` node are explicitly NOT
+ * verified-complete — INV-RS-01: a SKIP disposition never satisfies a dependency
+ * edge, so a dependent of a skipped/blocked node stays ineligible.
+ */
+const VERIFIED_COMPLETE_STATUSES = new Set([
+    "resolved",
+    "resolved_no_change",
+]);
+/** Settled decisions not to act on a finding (`ignored` / `deemed_inappropriate`). */
+const SKIP_STATUSES = new Set([
+    "ignored",
+    "deemed_inappropriate",
+]);
+/** Whether a status is terminal — no further implement work, and a worker result must never resurrect it. `blocked` is NOT terminal. */
+export function isTerminalStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+/**
+ * Whether a status is VERIFIED-COMPLETE: the node produced and verified its
+ * declared output (`resolved` / `resolved_no_change`). A skipped node
+ * (`ignored` / `deemed_inappropriate`) and a `blocked` node are explicitly NOT
+ * verified-complete — INV-RS-01: a SKIP disposition never satisfies a dependency
+ * edge, so a dependent of a skipped/blocked node stays ineligible.
+ */
+export function isVerifiedCompleteStatus(status) {
+    return (status !== undefined &&
+        VERIFIED_COMPLETE_STATUSES.has(status));
+}
+/** Whether a status is a SKIP — a settled decision not to act (terminal but never verified-complete, INV-RS-01). */
+export function isSkipStatus(status) {
+    return SKIP_STATUSES.has(status);
+}
+// ── Status → coverage disposition (PerFindingDisposition) ────────────────────
+/**
+ * The one status→disposition map (INV-CL-05). Exhaustive over the status enum.
+ * Non-terminal statuses map to `force_closed_unresolved` so a force-closed item
+ * is surfaced in the coverage ledger rather than silently dropped.
+ */
+const STATUS_TO_DISPOSITION = {
+    resolved: "resolved",
+    resolved_no_change: "resolved_no_change",
+    ignored: "ignored",
+    deemed_inappropriate: "deemed_inappropriate",
+    // Non-terminal (blocked + in-progress) → surfaced, not dropped.
+    blocked: "force_closed_unresolved",
+    pending: "force_closed_unresolved",
+    tested: "force_closed_unresolved",
+    tested_successfully: "force_closed_unresolved",
+    refactored: "force_closed_unresolved",
+    verified: "force_closed_unresolved",
+};
+/** Map an item status to its per-finding coverage disposition. */
+export function statusToDisposition(status) {
+    return (STATUS_TO_DISPOSITION[status] ?? "force_closed_unresolved");
+}
+// ── Coverage disposition → outcomes-contract status ──────────────────────────
+/**
+ * The one disposition→outcome map. `RemediationOutcomeStatus` (the shared
+ * outcomes wire contract) is a strict function of the coverage disposition, so
+ * the close phase derives the outcome from {@link statusToDisposition} rather
+ * than keeping its own parallel status→outcome table.
+ */
+const DISPOSITION_TO_OUTCOME_STATUS = {
+    resolved: "resolved",
+    resolved_no_change: "verified_no_change",
+    ignored: "ignored",
+    deemed_inappropriate: "inappropriate",
+    force_closed_unresolved: "blocked",
+};
+/** Map a coverage disposition to its outcomes-contract status. */
+export function dispositionToOutcomeStatus(disposition) {
+    return DISPOSITION_TO_OUTCOME_STATUS[disposition];
+}
+//# sourceMappingURL=itemStatus.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"itemStatus.js","sourceRoot":"","sources":["../../../src/remediate/state/itemStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,+EAA+E;AAE/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,SAAS;IACT,QAAQ;IACR,qBAAqB;IACrB,YAAY;IACZ,UAAU;IACV,UAAU;IACV,oBAAoB;IACpB,SAAS;IACT,sBAAsB;IACtB,SAAS;CACD,CAAC;AAIX,+EAA+E;AAE/E;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAwB;IAC1D,SAAS;IACT,QAAQ;IACR,qBAAqB;IACrB,YAAY;IACZ,UAAU;CACX,CAAC,CAAC;AAEH,+EAA+E;AAC/E,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,OAAO,oBAAoB,CAAC,GAAG,CAAC,MAA+B,CAAC,CAAC;AACnE,CAAC;AAED,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAwB;IACvD,UAAU;IACV,oBAAoB;IACpB,SAAS;IACT,sBAAsB;CACvB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAwB;IAChE,UAAU;IACV,oBAAoB;CACrB,CAAC,CAAC;AAEH,sFAAsF;AACtF,MAAM,aAAa,GAAG,IAAI,GAAG,CAAwB;IACnD,SAAS;IACT,sBAAsB;CACvB,CAAC,CAAC;AAEH,wIAAwI;AACxI,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,iBAAiB,CAAC,GAAG,CAAC,MAA+B,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAA0B;IACjE,OAAO,CACL,MAAM,KAAK,SAAS;QACpB,0BAA0B,CAAC,GAAG,CAAC,MAA+B,CAAC,CAChE,CAAC;AACJ,CAAC;AAED,oHAAoH;AACpH,MAAM,UAAU,YAAY,CAAC,MAAc;IACzC,OAAO,aAAa,CAAC,GAAG,CAAC,MAA+B,CAAC,CAAC;AAC5D,CAAC;AAED,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,qBAAqB,GAAyD;IAClF,QAAQ,EAAE,UAAU;IACpB,kBAAkB,EAAE,oBAAoB;IACxC,OAAO,EAAE,SAAS;IAClB,oBAAoB,EAAE,sBAAsB;IAC5C,gEAAgE;IAChE,OAAO,EAAE,yBAAyB;IAClC,OAAO,EAAE,yBAAyB;IAClC,MAAM,EAAE,yBAAyB;IACjC,mBAAmB,EAAE,yBAAyB;IAC9C,UAAU,EAAE,yBAAyB;IACrC,QAAQ,EAAE,yBAAyB;CACpC,CAAC;AAEF,kEAAkE;AAClE,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,OAAO,CACL,qBAAqB,CAAC,MAA+B,CAAC,IAAI,yBAAyB,CACpF,CAAC;AACJ,CAAC;AAED,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,6BAA6B,GAA4D;IAC7F,QAAQ,EAAE,UAAU;IACpB,kBAAkB,EAAE,oBAAoB;IACxC,OAAO,EAAE,SAAS;IAClB,oBAAoB,EAAE,eAAe;IACrC,uBAAuB,EAAE,SAAS;CACnC,CAAC;AAEF,kEAAkE;AAClE,MAAM,UAAU,0BAA0B,CACxC,WAAkC;IAElC,OAAO,6BAA6B,CAAC,WAAW,CAAC,CAAC;AACpD,CAAC"}