runward 0.14.2 → 0.15.0

package/dist/lib/compliance.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { parseManifest } from "./conformance.js";
+import { parseManifest, GATED_DELIVERABLES } from "./conformance.js";
 import { TEMPLATES } from "./paths.js";
+import { regimeLensId } from "./regimes.js";
 /**
  * Deterministic, read-only assembly of a regime-framed compliance evidence pack (ADR-0016).
  * It reads the mission's real artifacts at rest — the rule→OWASP ASI mapping, the rule-conformance
@@ -51,16 +52,10 @@ function readRules(missionDir) {
     }
     return out;
 }
-/** The three build-phase deliverables that carry a `## Rule conformance` manifest (as `check --strict`). */
-const CONFORMANCE_DELIVERABLES = [
-    ["Architect", "architecture.md"],
-    ["Topology", "execution-topology.md"],
-    ["Floor", "floor.md"],
-    ["Govern", "governance/threat-model.md"],
-];
 function readConformance(missionDir) {
     const out = [];
-    for (const [label, deliverable] of CONFORMANCE_DELIVERABLES) {
+    // The same gated (phase, deliverable) pairs `check --strict` verifies — one source (conformance.ts).
+    for (const { label, deliverable } of GATED_DELIVERABLES) {
         const p = join(missionDir, deliverable);
         if (!existsSync(p))
             continue;
@@ -118,8 +113,10 @@ export function gatherComplianceInputs(missionDir) {
         evalRubric: existsSync(join(missionDir, "governance", "evaluation-rubric.md")),
     };
 }
-/** Render the ISO/IEC 42001 assessment-readiness draft — the technical-evidence layer + the human-gap list. */
-export function renderIso42001Readiness(inputs, generatedAt) {
+/** Render the ISO/IEC 42001 assessment-readiness draft — the technical-evidence layer + the human-gap
+ *  list. The clause references and the operator-required list come from the versioned lens (ADR-0022). */
+export function renderIso42001Readiness(inputs, generatedAt, lens) {
+    const cl = lens.clauses ?? {};
     const L = [];
     const counts = { applied: 0, deviated: 0, "n/a": 0 };
     for (const r of inputs.conformance)
@@ -132,10 +129,11 @@ export function renderIso42001Readiness(inputs, generatedAt) {
     L.push("> **technical-evidence layer and its index**; the applicability, risk-acceptance, policy and management sign-off it");
     L.push("> cannot invent are listed under \"Required from the operator\". This is **supporting evidence**, never certification —");
     L.push("> only an accredited body certifies an AI management system. Verify the current ISO/IEC 42001 text before an audit.");
+    L.push(`> Lens: ${lens.label} (mapping version ${lens.version}) — \`${regimeLensId(lens)}\`.`);
     L.push("");
     L.push("## 1. Agentic-risk coverage (OWASP ASI → your rules)");
     L.push("");
-    L.push("Feeds the ISO 42001 risk assessment (6.1.2) and control selection (6.1.3): which agentic-security risks are addressed by named engineering rules.");
+    L.push(`Feeds the ISO 42001 risk assessment (${cl.riskAssessment}) and control selection (${cl.controlSelection}): which agentic-security risks are addressed by named engineering rules.`);
     L.push("");
     L.push("| ASI | Risk | Rules addressing it |");
     L.push("|---|---|---|");
@@ -146,7 +144,7 @@ export function renderIso42001Readiness(inputs, generatedAt) {
     L.push("");
     L.push("## 2. Control-implementation status (rule conformance)");
     L.push("");
-    L.push(`Feeds the Statement of Applicability's implementation-status + evidence columns (6.1.3). From your mission's manifests: **${counts.applied} applied · ${counts.deviated} deviated · ${counts["n/a"]} n/a** across ${inputs.conformance.length} accounted rule(s).`);
+    L.push(`Feeds the Statement of Applicability's implementation-status + evidence columns (${cl.controlSelection}). From your mission's manifests: **${counts.applied} applied · ${counts.deviated} deviated · ${counts["n/a"]} n/a** across ${inputs.conformance.length} accounted rule(s).`);
     L.push("");
     if (inputs.conformance.length === 0) {
         L.push("_No filled `Rule conformance` manifest found yet — fill the architect/floor/govern deliverables (see `runward check --strict`)._");
@@ -160,7 +158,7 @@ export function renderIso42001Readiness(inputs, generatedAt) {
     L.push("");
     L.push("## 3. Design decisions (ADR journal)");
     L.push("");
-    L.push("The \"key design choices, alternatives, and re-evaluation triggers\" an ISO 42001 auditor expects (records under Annex A control groups).");
+    L.push(`The "key design choices, alternatives, and re-evaluation triggers" an ISO 42001 auditor expects (records under ${cl.annexControls} control groups).`);
     L.push("");
     if (inputs.adrs.length === 0) {
         L.push("_No ratified ADR found in `runward/adr/`._");
@@ -174,22 +172,17 @@ export function renderIso42001Readiness(inputs, generatedAt) {
     L.push("");
     L.push("## 4. Risk & impact inputs (presence)");
     L.push("");
-    L.push(`- Threat model (feeds risk assessment 6.1.2): ${inputs.threatModel ? "**present** — confirm it is filled, not a raw template" : "**missing**"}`);
+    L.push(`- Threat model (feeds risk assessment ${cl.riskAssessment}): ${inputs.threatModel ? "**present** — confirm it is filled, not a raw template" : "**missing**"}`);
     L.push(`- Evaluation rubric (feeds impact/validation analysis): ${inputs.evalRubric ? "**present** — confirm it is filled" : "**missing**"}`);
     L.push("");
     L.push("## Required from the operator / organization (runward cannot produce this)");
     L.push("");
     L.push("These sections are managerial, legal or organizational — no tool can assemble them from engineering artifacts:");
     L.push("");
-    L.push("- **AI policy** (5.2) and **AIMS scope** (4.3).");
-    L.push("- **Statement of Applicability — the applicability decisions and inclusion/exclusion justifications** (6.1.3): runward supplies the status + evidence columns; the *applicability* judgment is yours.");
-    L.push("- **Risk methodology, acceptance criteria and risk-acceptance decisions** (6.1.2, 8.3).");
-    L.push("- **AI system impact assessment report and deployment authorization** (6.1.4).");
-    L.push("- **Objectives and targets** (6.2), **roles and competence** (A.3, 7.2).");
-    L.push("- **Internal audit** (9.2) and **management review** minutes (9.3).");
-    L.push("- **Runtime AI event logs** (A.6.2.8) — produced by the running system, not by runward.");
+    for (const item of lens.operatorRequired)
+        L.push(`- ${item}`);
     L.push("");
-    L.push("_Regime mapping is dated engineering framing, not legal advice; ISO Annex A control counts/templates are behind the paywalled standard — confirm against the purchased text._");
+    L.push(`_Regime mapping is dated engineering framing, not legal advice; ${lens.disclaimerTail}_`);
     L.push("");
     return L.join("\n") + "\n";
 }
@@ -226,8 +219,9 @@ function adrTableLines(inputs) {
     return L;
 }
 /** Render the NIST AI RMF assessment-readiness draft — an ASI↔AI-RMF crosswalk, the MEASURE/TEVV
- *  documentation, and the design decisions; GOVERN and risk-tolerance stay the operator's. */
-export function renderNistAiRmf(inputs, generatedAt) {
+ *  documentation, and the design decisions; GOVERN and risk-tolerance stay the operator's.
+ *  The crosswalk targets and the operator-required functions come from the versioned lens (ADR-0022). */
+export function renderNistAiRmf(inputs, generatedAt, lens) {
     const c = confCounts(inputs);
     const L = [];
     L.push("# NIST AI RMF — assessment-readiness draft");
@@ -236,16 +230,17 @@ export function renderNistAiRmf(inputs, generatedAt) {
     L.push("> deterministically from ratified engineering artifacts (no model call). The AI RMF is **voluntary guidance**");
     L.push("> with no pass/fail and no certification; this populates the MEASURE/documentation evidence and an ASI crosswalk,");
     L.push("> while GOVERN, risk tolerance and go/no-go stay the operator's. Verify the current AI RMF text before use.");
+    L.push(`> Lens: ${lens.label} (mapping version ${lens.version}) — \`${regimeLensId(lens)}\`.`);
     L.push("");
     L.push("## 1. Agentic-risk crosswalk (OWASP ASI → AI RMF)");
     L.push("");
-    L.push("An indicative engineering crosswalk (not NIST-endorsed): each agentic-security risk lands primarily under **MEASURE** (test & evaluate, esp. security & resilience) and **MANAGE** (risk treatment). Confirm subcategory selection against AI RMF §5.");
+    L.push(`An indicative engineering crosswalk (not NIST-endorsed): ${lens.crosswalk?.primary}. Confirm subcategory selection against ${lens.crosswalk?.confirmAgainst}.`);
     L.push("");
     L.push(...asiTableLines(inputs));
     L.push("");
     L.push("## 2. MEASURE / TEVV documentation");
     L.push("");
-    L.push(`Feeds MEASURE 2.x — documented, repeatable test methodology and results. From your mission: **${c.applied} applied · ${c.deviated} deviated · ${c["n/a"]} n/a** across ${inputs.conformance.length} rule(s).`);
+    L.push(`Feeds ${lens.measureRef} — documented, repeatable test methodology and results. From your mission: **${c.applied} applied · ${c.deviated} deviated · ${c["n/a"]} n/a** across ${inputs.conformance.length} rule(s).`);
     L.push(`- Evaluation rubric (test sets, metrics, tooling): ${inputs.evalRubric ? "**present** — confirm it is filled" : "**missing**"}`);
     L.push(`- Threat model (adversarial / risk-source analysis): ${inputs.threatModel ? "**present** — confirm it is filled" : "**missing**"}`);
     L.push("");
@@ -257,41 +252,34 @@ export function renderNistAiRmf(inputs, generatedAt) {
     L.push("");
     L.push("## Required from the operator / organization (runward cannot produce this)");
     L.push("");
-    L.push("- **GOVERN** — policies, roles, accountability, **risk tolerance** (almost entirely organizational).");
-    L.push("- **MAP** — intended purpose, business/legal context, use-case risk enumeration.");
-    L.push("- **MANAGE** — the **go/no-go acceptance** decision, resourcing, response planning.");
-    L.push("- **Profiles** — Current/Target selection, prioritization, the risk-tolerance choices behind them.");
+    for (const item of lens.operatorRequired)
+        L.push(`- ${item}`);
     L.push("");
-    L.push("_Indicative engineering framing, not legal advice; NIST prescribes no report template — confirm against AI 100-1 and the Playbook._");
+    L.push(`_Indicative engineering framing, not legal advice; ${lens.disclaimerTail}_`);
     L.push("");
     return L.join("\n") + "\n";
 }
 /** Render the EU AI Act Annex IV assessment-readiness draft — strong on Point 2 (design/architecture/
  *  validation) and the design-rationale/change history (the ADR journal); RMS, standards, declaration
- *  and post-market plan stay the provider's. */
-export function renderEuAiAct(inputs, generatedAt) {
+ *  and post-market plan stay the provider's. The applicability date, article references, Annex IV
+ *  rows and provider-required list come from the versioned lens (ADR-0022). */
+export function renderEuAiAct(inputs, generatedAt, lens) {
     const L = [];
     L.push("# EU AI Act — Annex IV technical documentation — assessment-readiness draft");
     L.push("");
     L.push(`> **Draft, incomplete — not a conformity assessment.** Assembled by \`runward compliance eu-ai-act\` on ${generatedAt},`);
     L.push("> deterministically from ratified engineering artifacts (no model call). High-risk obligations bind from");
-    L.push("> **2 August 2026** (Annex III). This populates Annex IV Point 2 (design & validation) and the design-rationale");
-    L.push("> history; it does **not** satisfy art. 12 runtime logging, and it is not a signed declaration of conformity.");
+    L.push(`> **${lens.highRisk?.bindFrom}** (${lens.highRisk?.scope}). This populates Annex IV Point 2 (design & validation) and the design-rationale`);
+    L.push(`> history; it does **not** satisfy ${lens.articles?.runtimeLogging} runtime logging, and it is not a signed declaration of conformity.`);
     L.push("> Verify against the Official Journal text before filing.");
+    L.push(`> Lens: ${lens.label} (mapping version ${lens.version}) — \`${regimeLensId(lens)}\`.`);
     L.push("");
     L.push("## Annex IV coverage map");
     L.push("");
     L.push("| Annex IV point | runward supplies | Required from the provider |");
     L.push("|---|---|---|");
-    L.push("| 1. General description | UI, HW/SW/firmware notes | intended purpose, provider, versioning, distribution |");
-    L.push("| 2. Elements & development | **architecture, validation procedures + metrics, cybersecurity (manifest + rubric + threat model); design choices, alternatives, assumptions, pre-determined changes = the ADR journal** | third-party sourcing/licensing, sign-off on test logs |");
-    L.push("| 3. Monitoring & control | accuracy characterization, input-data specs, oversight tooling | fundamental-rights / discrimination risk sourcing |");
-    L.push("| 4. Performance metrics | metric-choice justification (rubric) | — |");
-    L.push("| 5. Risk management (art. 9) | technical inputs (threat model, testing) | **risk acceptance / RMS governance** |");
-    L.push("| 6. Lifecycle changes | engineering change record (ADR journal) | release/change-management governance |");
-    L.push("| 7. Harmonised standards | technical notes | **standards selection** (compliance strategy) |");
-    L.push("| 8. Declaration of conformity | — | **signed legal act (art. 47)** |");
-    L.push("| 9. Post-market monitoring | telemetry/logging backbone | **post-market monitoring plan (art. 72)** |");
+    for (const r of lens.annexIv ?? [])
+        L.push(`| ${r.point} | ${r.supplies} | ${r.provider} |`);
     L.push("");
     L.push("## Point 2 — design decisions (ADR journal, near-verbatim to the Annex IV requirement)");
     L.push("");
@@ -307,11 +295,10 @@ export function renderEuAiAct(inputs, generatedAt) {
     L.push("");
     L.push("## Required from the provider (runward cannot produce this)");
     L.push("");
-    L.push("- **Point 1** general description (intended purpose, provider, versioning) · **Point 5** RMS governance & risk acceptance (art. 9).");
-    L.push("- **Point 7** harmonised-standards selection · **Point 8** the signed **EU declaration of conformity** (art. 47) · **Point 9** the **post-market monitoring plan** (art. 72).");
-    L.push("- **Art. 12 runtime event logs** — produced by the running system, not by runward.");
+    for (const item of lens.operatorRequired)
+        L.push(`- ${item}`);
     L.push("");
-    L.push("_Engineering framing, not legal advice; Annex IV wording moves — confirm against the Official Journal (Reg. (EU) 2024/1689) before filing._");
+    L.push(`_Engineering framing, not legal advice; ${lens.disclaimerTail}_`);
     L.push("");
     return L.join("\n") + "\n";
 }
@@ -332,8 +319,10 @@ const ASI_CATALOG = "https://genai.owasp.org/resource/owasp-top-10-for-agentic-a
  * universal machine-readable layer. Each ASI category is a control whose implementation-status is
  * derived from the mission's conformance manifest; evidence links back to the readiness draft. It is
  * labelled a DRAFT / supporting evidence in the metadata remarks — never a compliance claim.
+ * `lensId` stamps which regime mapping version framed the pack (metadata prop, ADR-0022); the
+ * control structure itself stays regime-neutral.
  */
-export function renderOscal(inputs, missionName, generatedAt) {
+export function renderOscal(inputs, missionName, generatedAt, lensId) {
     const ns = missionName || "mission";
     const irs = Object.keys(ASI_LABELS).map((id) => {
         const slugs = inputs.asiCoverage.get(id) ?? [];
@@ -361,6 +350,7 @@ export function renderOscal(inputs, missionName, generatedAt) {
                 "last-modified": `${generatedAt}T00:00:00Z`,
                 version: generatedAt,
                 "oscal-version": OSCAL_VERSION,
+                ...(lensId ? { props: [{ name: "runward-regime-lens", value: lensId }] } : {}),
                 remarks: "Assessment-readiness DRAFT, assembled deterministically by runward from ratified engineering artifacts (rule to OWASP ASI mapping, conformance manifest, ADR journal). Supporting evidence only — NOT a compliance claim, NOT a certification, NOT a conformity assessment. Applicability, risk acceptance and management sign-off are the operator's.",
             },
             components: [{

package/dist/lib/conformance.js

@@ -3,6 +3,14 @@ import { join, dirname } from "node:path";
 import { TEMPLATES } from "./paths.js";
 import { EXPECTED_MAPPED } from "./constants.js";
 import { RULE_MIGRATIONS } from "./rule-migrations.js";
+/** The gated (phase, deliverable) pairs — the single source `check --strict`, the evidence
+ *  layer and the compliance assembler all read (ADR-0001/0016/0017). */
+export const GATED_DELIVERABLES = [
+    { phase: "architect", deliverable: "architecture.md", label: "Architect" },
+    { phase: "topology", deliverable: "execution-topology.md", label: "Topology" },
+    { phase: "floor", deliverable: "floor.md", label: "Floor" },
+    { phase: "govern", deliverable: "governance/threat-model.md", label: "Govern" },
+];
 const FRONTMATTER = /^---\n([\s\S]*?)\n---/;
 const VALID_STATUS = new Set(["applied", "deviated", "n/a"]);
 /** An n/a reason must be more than a placeholder: real length, not a bracketed template token. */
@@ -15,15 +23,41 @@ function parseRuleMeta(content) {
     const impact = (fm.match(/^impact:\s*(.+)$/m)?.[1] ?? "").trim();
     const phasesRaw = fm.match(/^phases:\s*\[(.*)\]/m)?.[1] ?? "";
     const phases = phasesRaw.split(",").map((s) => s.trim()).filter(Boolean);
-    return { impact, phases };
+    const signature = (fm.match(/^signature:\s*(.+)$/m)?.[1] ?? "").trim();
+    return { impact, phases, signature };
+}
+/** The rule directory the gate reads: the mission's own copy when present, else the package's. */
+export function rulesDir(missionDir) {
+    const missionRules = join(missionDir, "rules");
+    return existsSync(missionRules) ? missionRules : join(TEMPLATES, "rules");
+}
+/** Evidence signatures (ADR-0020): rule slug → the regex source its applied evidence must match. */
+export function ruleSignatures(missionDir) {
+    const dir = rulesDir(missionDir);
+    if (!existsSync(dir))
+        return {};
+    const out = {};
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith(".md"))
+            continue;
+        let sig = "";
+        try {
+            sig = parseRuleMeta(readFileSync(join(dir, f), "utf8")).signature;
+        }
+        catch {
+            continue;
+        }
+        if (sig)
+            out[f.replace(/\.md$/, "")] = sig;
+    }
+    return out;
 }
 /** CRITICAL/HIGH rules mapped to a phase — the set that must be accounted for.
  *  The mapping is a property of the rule definitions: read the mission's own
  *  `runward/rules/` when present, else fall back to the package rules (the
  *  authoritative source — covers missions predating rules-in-mission). */
 export function expectedRules(missionDir, phaseId) {
-    const missionRules = join(missionDir, "rules");
-    const dir = existsSync(missionRules) ? missionRules : join(TEMPLATES, "rules");
+    const dir = rulesDir(missionDir);
     if (!existsSync(dir))
         return [];
     return readdirSync(dir)
@@ -37,8 +71,7 @@ export function expectedRules(missionDir, phaseId) {
 }
 /** Every rule slug in the set (mission's own, else the package) — the universe a manifest row must belong to. */
 export function allRules(missionDir) {
-    const missionRules = join(missionDir, "rules");
-    const dir = existsSync(missionRules) ? missionRules : join(TEMPLATES, "rules");
+    const dir = rulesDir(missionDir);
     if (!existsSync(dir))
         return [];
     return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
@@ -68,18 +101,21 @@ export function parseManifest(content) {
     }
     return rows;
 }
-function adrExists(missionDir, evidence) {
-    const id = evidence.match(/ADR-\d+/i)?.[0].toUpperCase();
-    if (!id)
-        return false;
+/** True when an ADR with exactly this id (e.g. "ADR-3") exists in runward/adr/.
+ *  Anchored on a digit boundary so ADR-1 is not satisfied by ADR-10 / ADR-12
+ *  when filenames are unpadded. */
+export function adrIdExists(missionDir, id) {
     const dir = join(missionDir, "adr");
-    // Anchor on a digit boundary so a `deviated` row citing ADR-1 is not satisfied by
-    // ADR-10 / ADR-12 when filenames are unpadded.
+    const u0 = id.toUpperCase();
     return existsSync(dir) && readdirSync(dir).some((f) => {
         const u = f.toUpperCase();
-        return u.startsWith(id) && !/[0-9]/.test(u.charAt(id.length));
+        return u.startsWith(u0) && !/[0-9]/.test(u.charAt(u0.length));
     });
 }
+function adrExists(missionDir, evidence) {
+    const id = evidence.match(/ADR-\d+/i)?.[0];
+    return id ? adrIdExists(missionDir, id) : false;
+}
 /**
  * The reconstruction lifecycle (ADR-0013/0014). A retroactively reconstructed decision is a
  * *hypothesis* until the operator ratifies it — writes the real *why*, sets a re-evaluation
@@ -129,7 +165,13 @@ export function decisionCoverage(missionDir) {
 }
 // A path token: a file with a known code/doc extension (excludes version numbers like v1.0, "§2").
 const PATH_TOKEN = /[\w./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|md|json|ya?ml|toml|go|rs|java|rb|php|sql|sh|css|scss|html|txt)\b/g;
-/** Advisory drift (ADR-0004): applied pointers whose file path no longer resolves. Existence only. */
+/** File-path tokens carried by an evidence cell — the drift/evidence layer's shared extraction. */
+export function evidencePathTokens(evidence) {
+    return evidence.match(PATH_TOKEN) ?? [];
+}
+/** Drift (ADR-0004, blocking under --strict since ADR-0021): applied pointers whose file path no
+ *  longer resolves. Existence only. Rows carrying typed pointers are diagnosed by the evidence
+ *  layer (ADR-0019) instead — one diagnosis per row, never two. */
 export function driftReport(missionDir, deliverable) {
     const path = join(missionDir, deliverable);
     if (!existsSync(path))
@@ -139,12 +181,14 @@ export function driftReport(missionDir, deliverable) {
     for (const row of parseManifest(readFileSync(path, "utf8"))) {
         if (row.status !== "applied")
             continue;
+        if (/\b(?:file|test|adr):\S/.test(row.evidence))
+            continue; // typed — the evidence layer owns it
         const tokens = row.evidence.match(PATH_TOKEN) ?? [];
         if (tokens.length === 0)
             continue; // pure prose reference — the operator's judgment
         const resolves = tokens.some((t) => bases.some((b) => existsSync(join(b, t))));
         if (!resolves)
-            out.push({ rule: row.rule, problem: `applied pointer does not resolve (drift?): ${row.evidence} — update the pointer or remove the row` });
+            out.push({ rule: row.rule, problem: `applied pointer does not resolve (drift): ${row.evidence} — update the pointer, mark the row deviated with its ADR, or remove it` });
     }
     return out;
 }
@@ -189,7 +233,9 @@ export function conformance(missionDir, phaseId, deliverable) {
             continue;
         }
         if (!VALID_STATUS.has(row.status)) {
-            violations.push({ rule, problem: `invalid status "${row.status}" (use applied | deviated | n/a)` });
+            violations.push({ rule, problem: row.status === ""
+                    ? "status not set — a scaffolded row is not a decision: choose applied | deviated | n/a and fill the Evidence column"
+                    : `invalid status "${row.status}" (use applied | deviated | n/a)` });
             continue;
         }
         if (row.status === "applied" && !row.evidence)

package/dist/lib/constants.js

@@ -1,7 +1,7 @@
 /** Total number of craft rules shipped under templates/rules/. */
 export const EXPECTED_RULES = 60;
 /** Gate adapters shipped under templates/adapters/ (ADR-0012): one per harness seam, plus the port-contract README. */
-export const EXPECTED_ADAPTERS = 4;
+export const EXPECTED_ADAPTERS = 5;
 /** Routed-count floor: minimum CRITICAL/HIGH rules mapped to each build phase (ADR-0002).
  *  Lowering a floor is a deliberate, tracked edit — the `phases:` mapping cannot be silently
  *  stripped to make `check --strict` pass vacuously. */

package/dist/lib/evidence.js

@@ -0,0 +1,222 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { parseManifest, evidencePathTokens, adrIdExists, GATED_DELIVERABLES } from "./conformance.js";
+const POINTER_PREFIX = /\b(file|test|adr):(\S.*)$/;
+/** Parse the typed pointers out of an Evidence cell. One pointer per `;`-separated segment. */
+export function parseEvidencePointers(evidence) {
+    const out = [];
+    for (const segment of evidence.split(";")) {
+        const m = segment.trim().match(POINTER_PREFIX);
+        if (!m)
+            continue;
+        const kind = m[1];
+        const rest = m[2];
+        const raw = `${kind}:${rest.split(/\s/)[0]}`;
+        if (kind === "adr") {
+            const id = rest.match(/^(\d{1,6})\b/)?.[1];
+            if (id)
+                out.push({ kind, raw: `adr:${id}`, adrId: id });
+            continue;
+        }
+        if (kind === "test") {
+            const sep = rest.indexOf("::");
+            const firstWs = rest.search(/\s/);
+            if (sep !== -1 && (firstWs === -1 || sep < firstWs)) {
+                const name = rest.slice(sep + 2).trim().replace(/^["']|["']$/g, "");
+                out.push({ kind, raw, path: clean(rest.slice(0, sep)), testName: name || undefined });
+            }
+            else {
+                out.push({ kind, raw, path: clean(rest.split(/\s/)[0]) });
+            }
+            continue;
+        }
+        // file:PATH[:LINE][#SYMBOL]
+        let token = clean(rest.split(/\s/)[0]);
+        let symbol;
+        const hash = token.indexOf("#");
+        if (hash !== -1) {
+            symbol = token.slice(hash + 1) || undefined;
+            token = token.slice(0, hash);
+        }
+        let line;
+        const ln = token.match(/:(\d+)$/);
+        if (ln) {
+            line = Number(ln[1]);
+            token = token.slice(0, -ln[0].length);
+        }
+        out.push({ kind, raw, path: token, line, symbol });
+    }
+    return out;
+}
+/** Strip the trailing punctuation prose leaves on a token (`src/x.ts),` → `src/x.ts`). */
+function clean(token) {
+    return token.replace(/[),.:]+$/, "");
+}
+/** The same three resolution bases as the drift pass (ADR-0004). */
+export function resolutionBases(missionDir, deliverable) {
+    return [dirname(missionDir), missionDir, dirname(join(missionDir, deliverable))];
+}
+function resolveFile(p, bases) {
+    if (isAbsolute(p))
+        return existsSync(p) ? p : null;
+    for (const b of bases) {
+        const abs = join(b, p);
+        if (existsSync(abs))
+            return abs;
+    }
+    return null;
+}
+function isRegularFile(abs) {
+    try {
+        return statSync(abs).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Blocking evidence checks for one gated deliverable (ADR-0019/0020):
+ * typed pointers verified per type, resolvable pointed files non-empty,
+ * signed rules matched against their signature.
+ */
+export function evidenceReport(missionDir, deliverable, signatures) {
+    const path = join(missionDir, deliverable);
+    if (!existsSync(path))
+        return [];
+    const bases = resolutionBases(missionDir, deliverable);
+    const out = [];
+    for (const row of parseManifest(readFileSync(path, "utf8"))) {
+        if (row.status !== "applied")
+            continue;
+        if (/^\[.*\]$/.test(row.rule))
+            continue; // template placeholder row
+        const pointers = parseEvidencePointers(row.evidence);
+        const resolvedFiles = new Map(); // abs path → content (read once)
+        for (const p of pointers) {
+            if (p.kind === "adr") {
+                if (!adrIdExists(missionDir, `ADR-${p.adrId}`)) {
+                    out.push({ rule: row.rule, problem: `typed pointer adr:${p.adrId} — no matching ADR in runward/adr/` });
+                }
+                continue;
+            }
+            const abs = p.path ? resolveFile(p.path, bases) : null;
+            if (!abs) {
+                out.push({ rule: row.rule, problem: `typed pointer does not resolve: ${p.raw} — update it or remove the row` });
+                continue;
+            }
+            if (!isRegularFile(abs)) {
+                out.push({ rule: row.rule, problem: `typed pointer resolves to a directory, not a file: ${p.raw}` });
+                continue;
+            }
+            const content = readFileSync(abs, "utf8");
+            resolvedFiles.set(abs, content);
+            if (!/\S/.test(content)) {
+                out.push({ rule: row.rule, problem: `typed pointer resolves to an empty file: ${p.raw} — an empty file is not evidence` });
+                continue;
+            }
+            if (p.line !== undefined && content.split("\n").length < p.line) {
+                out.push({ rule: row.rule, problem: `typed pointer ${p.raw} — the file has fewer than ${p.line} lines` });
+            }
+            if (p.symbol !== undefined && !content.includes(p.symbol)) {
+                out.push({ rule: row.rule, problem: `typed pointer ${p.raw} — symbol "${p.symbol}" not found in the file (moved or renamed? update the pointer)` });
+            }
+            if (p.testName !== undefined && !content.includes(p.testName)) {
+                out.push({ rule: row.rule, problem: `typed pointer ${p.raw} — test named "${p.testName}" not found in the file` });
+            }
+        }
+        // Non-vacuity for every row (ADR-0019): a path token that resolves must resolve to real content.
+        for (const t of evidencePathTokens(row.evidence)) {
+            const abs = resolveFile(t, bases);
+            if (!abs || !isRegularFile(abs) || resolvedFiles.has(abs))
+                continue;
+            const content = readFileSync(abs, "utf8");
+            resolvedFiles.set(abs, content);
+            if (!/\S/.test(content)) {
+                out.push({ rule: row.rule, problem: `evidence points at an empty file: ${t} — an empty file is not evidence` });
+            }
+        }
+        // Signature (ADR-0020): a signed rule's applied evidence must contain the rule's shape.
+        const sig = signatures[row.rule];
+        if (sig) {
+            let re;
+            try {
+                re = new RegExp(sig, "i");
+            }
+            catch {
+                out.push({ rule: row.rule, problem: `invalid signature regex in the rule file: /${sig}/ — fix runward/rules/${row.rule}.md` });
+                continue;
+            }
+            if (resolvedFiles.size === 0) {
+                out.push({ rule: row.rule, problem: `this rule declares an evidence signature — point the applied evidence at a file (file: or test:) whose content matches /${sig}/i` });
+            }
+            else if (![...resolvedFiles.values()].some((c) => re.test(c))) {
+                out.push({ rule: row.rule, problem: `evidence does not match the rule's signature /${sig}/i — the pointed content lacks the rule's shape (cited, not applied?)` });
+            }
+        }
+    }
+    return out;
+}
+// ── Evidence sealing (ADR-0021) — an opt-in SHA-256 seal of a green gate ──
+export const EVIDENCE_LOCK = "evidence-lock.json";
+function sha256(abs) {
+    return createHash("sha256").update(readFileSync(abs)).digest("hex");
+}
+/** Every evidence file that resolves across the gated manifests, keyed by project-root-relative path. */
+export function collectSealableEvidence(missionDir) {
+    const root = dirname(missionDir);
+    const files = new Map();
+    for (const { deliverable } of GATED_DELIVERABLES) {
+        const path = join(missionDir, deliverable);
+        if (!existsSync(path))
+            continue;
+        const bases = resolutionBases(missionDir, deliverable);
+        for (const row of parseManifest(readFileSync(path, "utf8"))) {
+            if (row.status !== "applied" || /^\[.*\]$/.test(row.rule))
+                continue;
+            const candidates = [
+                ...parseEvidencePointers(row.evidence).map((p) => p.path).filter((p) => !!p),
+                ...evidencePathTokens(row.evidence),
+            ];
+            for (const t of candidates) {
+                const abs = resolveFile(t, bases);
+                if (abs && isRegularFile(abs))
+                    files.set(relative(root, abs), "");
+            }
+        }
+    }
+    const out = {};
+    for (const rel of [...files.keys()].sort())
+        out[rel] = sha256(join(root, rel));
+    return out;
+}
+/** The lock file content — stable order, byte-idempotent on unchanged evidence. */
+export function renderEvidenceLock(missionDir, sealedAt) {
+    return JSON.stringify({ version: 1, sealedAt, files: collectSealableEvidence(missionDir) }, null, 2) + "\n";
+}
+/** Verify an existing seal. No lock file → no seal check (opt-in by construction). */
+export function verifyEvidenceLock(missionDir) {
+    const lockPath = join(missionDir, EVIDENCE_LOCK);
+    if (!existsSync(lockPath))
+        return { present: false, count: 0, violations: [] };
+    const root = dirname(missionDir);
+    let lock;
+    try {
+        lock = JSON.parse(readFileSync(lockPath, "utf8"));
+    }
+    catch {
+        return { present: true, count: 0, violations: [{ rule: "(seal)", problem: `runward/${EVIDENCE_LOCK} is not valid JSON — re-seal with \`runward check --freeze\` or remove it` }] };
+    }
+    const files = lock.files ?? {};
+    const violations = [];
+    for (const [rel, hash] of Object.entries(files)) {
+        const abs = join(root, rel);
+        if (!existsSync(abs) || !isRegularFile(abs)) {
+            violations.push({ rule: "(seal)", problem: `sealed evidence missing: ${rel} — the file the gate crossed on is gone. Re-verify the pointer, then re-seal with \`runward check --freeze\`` });
+        }
+        else if (sha256(abs) !== hash) {
+            violations.push({ rule: "(seal)", problem: `sealed evidence changed: ${rel} — re-read the pointer, confirm the evidence still holds, then re-seal with \`runward check --freeze\`` });
+        }
+    }
+    return { present: true, sealedAt: lock.sealedAt, count: Object.keys(files).length, violations };
+}