runward 0.14.2 → 0.15.0

package/README.md

@@ -61,12 +61,16 @@ New here? Follow [your first mission in 15 minutes](docs/first-mission.md).
 |---|---|
 | `runward init` | Scaffold the mission structure (wizard: entry mode, stopping tier, tool profiles) |
 | `runward check` | **Gate audit**: which deliverable, expected at which phase, is missing, started, or filled — exit code 1 on gaps |
-| `runward check --strict` | **Conformance gate**: verifies each phase's rule-conformance manifest — every CRITICAL/HIGH craft rule mapped to the phase is accounted for (applied with a `file:line`/test, deviated with an ADR, or reasoned `n/a`). **Deterministic and zero-LLM**: it proves a decision was traced, never the code's quality, and cannot be jailbroken by injection — rerun it and get the same verdict |
+| `runward check --strict` | **Conformance gate**: verifies each phase's rule-conformance manifest — every CRITICAL/HIGH craft rule mapped to the phase is accounted for (applied with evidence, deviated with an ADR, or reasoned `n/a`) — **and verifies the evidence itself**: typed pointers (`file:PATH[:LINE][#SYMBOL]`, `test:PATH[::NAME]`, `adr:NNNN`) must resolve to real, non-empty content; a signed rule's evidence must match the rule's `signature:`; a stale pointer (drift) fails the gate. **Deterministic and zero-LLM**: it proves a decision was traced and points at something real, never the code's quality, and cannot be jailbroken by injection — rerun it and get the same verdict |
+| `runward check --freeze` | **Seal a green gate**: hashes every resolvable evidence file into `runward/evidence-lock.json` (SHA-256, committed). A sealed file that later changes or disappears fails `check --strict` until you re-verify and re-seal — silent post-merge erosion becomes loud. Refuses to seal a red gate |
+| `runward manifest` | **Conformance-table plumbing**: overview of the four gated manifests; `--sync` scaffolds the *form* — missing rows appended with an empty status (the gate refuses them until you decide), renamed rules migrated in place — and never touches the *content*: no status set, no evidence written, no row deleted |
+| `runward rules` | **The rule set as data**: the effective set (your mission's copy, else the package's) with impact, phases, OWASP ASI and signatures; `--json` is a stable, versioned machine contract for dashboards, editor extensions and CI annotations |
+| `runward explain <rule>` | **The why, inline**: a rule's contract (impact, phases, ASI, signature, rationale) and its full text — no doctrine excavation; renamed slugs answer with their migration |
 | `runward status` | Mission snapshot: current gate, decision journal (ADRs), workflows |
 | `runward doctor` | Environment and installation checks |
 | `runward update` | Refresh `runward/workflows/` from the package — mission state never touched, local edits preserved unless `--force` |
 | `runward characterize` | **Read-only inventory** of an existing codebase (brownfield / retro-documentation) → `runward/characterization.md`: dependencies and lockfiles, entrypoints, CI, tests, git-log shape. Deterministic and zero-LLM; it parses artifacts at rest and never runs, builds, or writes to your code. Facts, not decisions — reconstructing the *why* stays yours |
-| `runward compliance <regime>` | **Assemble a regime-framed evidence pack** (`iso-42001`, `nist-ai-rmf`, `eu-ai-act`) from the mission's artifacts → `runward/compliance/…`: a human readiness *draft* (OWASP ASI coverage, rule-conformance status, ADR journal, with the operator-only sections flagged) **and a machine-readable OSCAL** component-definition to feed your GRC/auditor tool. Deterministic, read-only, zero-LLM — supporting evidence, never a compliance claim |
+| `runward compliance <regime>` | **Assemble a regime-framed evidence pack** (`iso-42001`, `nist-ai-rmf`, `eu-ai-act`) from the mission's artifacts → `runward/compliance/…`: a human readiness *draft* (OWASP ASI coverage, rule-conformance status, ADR journal, with the operator-only sections flagged) **and a machine-readable OSCAL** component-definition to feed your GRC/auditor tool. Deterministic, read-only, zero-LLM — supporting evidence, never a compliance claim. The regime mapping is **versioned data** (`--regime-version` pins the lens; the pack stamps which version produced it) |
 
 Global flags: `--yes`, `--dry-run`, `--verbose`, `--no-color`. Exit codes: 0 success, 1 gaps/warnings, 2 missing prerequisite.
 
@@ -93,7 +97,7 @@ your-project/
 │   │   └── observability-schema.md
 │   ├── contracts/               # port contracts (versioned, additive, tolerant reader)
 │   ├── runbook.md               # recovery runbook for the team that inherits the system
-│   ├── adapters/                # inert samples that run the gate at each harness seam (git, CI, Claude Code)
+│   ├── adapters/                # inert samples that run the gate at each harness seam (git, GitHub/GitLab CI, Claude Code)
 │   └── workflows/               # the method, executable by your agent
 └── .claude/ | .cursor/          # tool profiles (--tools)
 ```
@@ -116,6 +120,8 @@ Phase 5 is transverse: it starts at day zero, not after the incident.
 ## What makes it different
 
 - **The gate you own — deterministic and zero-LLM.** `runward check --strict` is a non-probabilistic, operator-owned exit-code gate: it cannot be jailbroken by injection (no model in the gate path) and reruns byte-for-byte. Every competitor gates on LLM generation plus human prose review; this one does not depend on an LLM to pass.
+- **The gate verifies the evidence, not just the row.** A pointer must resolve to real, non-empty content; a symbol or test name must actually be there; a rule can declare the shape its evidence must contain (`signature:` — the founding cited-not-applied incident is now caught deterministically); a stale pointer fails the gate; a sealed gate (`--freeze`) makes later erosion loud. Still bytes, never judgment — and never a model.
+- **runward gates itself.** This repository carries its own `runward/` mission, and CI requires `runward check --strict` green on runward's own code — including under network isolation. The discipline is demonstrated, not claimed.
 - **Audit-ready evidence, not compliance theatre.** Craft rules carry an OWASP ASI (Top 10 for Agentic Applications) mapping — a universal, region-agnostic security posture — so the conformance manifest reads as supporting evidence. Security-only by default; it maps to your regime when you need one — ISO/IEC 42001 (global), NIST AI RMF (US), or the EU AI Act art. 13 technical file (EU) — see [`docs/compliance/`](docs/compliance/). An input to that work — never a conformity assessment, never a claim to certify.
 - **Never a runtime.** Runward writes nothing into `.git/`, installs nothing, and runs nothing of yours — it frames, gates and hands off. Your runtime and model are swappable adapters behind a port; the thing you depend on is never Runward.
 - **Floor, not MVP deck.** The floor is the smallest *running* system that proves value on real traffic. A presentation is not a floor.

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 /**
  * Runward CLI — after the spec: ship and run.
- * Commands: init (wizard), check (gate audit), status, doctor, update, characterize.
+ * Commands: init (wizard), check (gate audit), status, doctor, update, characterize,
+ * compliance (evidence pack), manifest (table plumbing), rules / explain (rule-set surface).
  */
 import { Command } from "commander";
 import { VERSION } from "./lib/paths.js";
@@ -13,6 +14,8 @@ import { doctorCommand } from "./commands/doctor.js";
 import { updateCommand } from "./commands/update.js";
 import { characterizeCommand } from "./commands/characterize.js";
 import { complianceCommand } from "./commands/compliance.js";
+import { manifestCommand } from "./commands/manifest.js";
+import { rulesCommand, explainCommand } from "./commands/rules.js";
 import { TOOL_IDS } from "./lib/tools.js";
 // Exit codes: 0 = success · 1 = gaps/warnings · 2 = missing prerequisite or CLI misuse (typo, unknown flag)
 process.on("uncaughtException", (err) => {
@@ -61,7 +64,8 @@ program
     .command("check")
     .description("can I cross the gate — gate audit, exit 1 on gaps (CI-friendly)")
     .option("-p, --path <path>", "project directory")
-    .option("--strict", "also verify the floor rule-conformance manifest (deterministic)")
+    .option("--strict", "also verify the rule-conformance manifests: rows, typed pointers, signatures, drift, seal (deterministic)")
+    .option("--freeze", "seal a green strict gate: hash the evidence into runward/evidence-lock.json (implies --strict)")
     .option("--hooks", "run operator hooks from runward/hooks.json around the audit (opt-in)")
     .option("--coverage", "advisory: report deliverable + decision-ratification coverage (does not gate)")
     .action(checkCommand);
@@ -86,11 +90,32 @@ program
     .option("-p, --path <path>", "project directory (default: .)")
     .option("--mine", "also propose candidate retroactive ADRs as DRAFT hypotheses (deterministic git archaeology, no model call)")
     .action(characterizeCommand);
+program
+    .command("manifest")
+    .description("rule-conformance manifest overview; --sync scaffolds missing rows and migrates renamed slugs (form only, never content)")
+    .option("-p, --path <path>", "project directory")
+    .option("--sync", "write: append missing rows with an empty status, rewrite renamed slugs, create missing sections")
+    .action(manifestCommand);
+program
+    .command("rules")
+    .description("the effective rule set (mission copy, else package); --json is a stable machine contract")
+    .option("-p, --path <path>", "project directory")
+    .option("--json", "machine output: { runward, source, count, rules } sorted by slug (versioned, additive)")
+    .option("--phase <id>", "only the rules mapped to this phase (architect | topology | floor | govern)")
+    .action(rulesCommand);
+program
+    .command("explain")
+    .description("print a rule's contract (impact, phases, why, signature) and its full text — the rationale inline")
+    .argument("<rule>", "rule slug (see `runward rules`)")
+    .option("-p, --path <path>", "project directory")
+    .option("--json", "machine output: the rule plus its body")
+    .action(explainCommand);
 program
     .command("compliance")
     .description("assemble a regime-framed evidence pack from the mission (deterministic, read-only; a readiness draft, never a compliance claim)")
     .argument("[regime]", "iso-42001 | nist-ai-rmf | eu-ai-act")
     .option("-p, --path <path>", "project directory")
+    .option("--regime-version <version>", "regime mapping version (default: highest shipped, see regimes/)")
     .action(complianceCommand);
 // exitOverride lets us map Commander's own errors onto runward's exit-code contract:
 // a parse error (unknown command/option, missing/excess argument) is operator misuse → 2,

package/dist/commands/check.js

@@ -1,20 +1,29 @@
+import { writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { analyze, findMissionRoot } from "../lib/mission.js";
-import { conformance, driftReport, unratifiedAdrs, decisionCoverage } from "../lib/conformance.js";
+import { conformance, driftReport, unratifiedAdrs, decisionCoverage, ruleSignatures, GATED_DELIVERABLES } from "../lib/conformance.js";
+import { evidenceReport, verifyEvidenceLock, renderEvidenceLock, EVIDENCE_LOCK } from "../lib/evidence.js";
 import { behavioralProof } from "../lib/behavioral-proof.js";
+import { verifyFindings, VERIFY_FINDINGS } from "../lib/verify-findings.js";
 import { runHooks } from "../lib/hooks.js";
-import { c, createHeader, section, status } from "../lib/styles.js";
+import { c, createHeader, isNonInteractive, section, status } from "../lib/styles.js";
 import { VERSION } from "../lib/paths.js";
 /**
  * Gate audit — the gap analysis: which deliverable, expected at which
  * phase, is present, started, or still a raw template.
- * With --strict, also verifies the floor rule-conformance manifest (see
- * docs/adr/ADR-0001): every CRITICAL/HIGH rule mapped to the floor phase must be
- * accounted for. It checks the presence of a traced decision, never the quality
- * of the implementation — that stays the operator's judgment at the gate.
+ * With --strict, also verifies the rule-conformance manifests (ADR-0001): every
+ * CRITICAL/HIGH rule mapped to a build phase must be accounted for, applied
+ * evidence must point at something real (ADR-0019/0020/0021 — typed pointers,
+ * non-vacuity, signatures, drift, seal). It checks the presence and shape of a
+ * traced decision, never the quality of the implementation — that stays the
+ * operator's judgment at the gate.
+ * With --freeze (implies --strict), a green gate is sealed: the resolvable
+ * evidence files are hashed into runward/evidence-lock.json (ADR-0021).
  * Exit codes: 0 = current gate clean, 1 = gaps, 2 = no mission found.
  */
 export async function checkCommand(opts) {
+    if (opts.freeze)
+        opts.strict = true; // a seal certifies a strict crossing
     const root = findMissionRoot(resolve(process.cwd(), opts.path ?? "."));
     if (!root) {
         console.error(status.error("No runward/ mission found here or above. Run `runward init` first."));
@@ -55,19 +64,15 @@ export async function checkCommand(opts) {
     }
     let strictGaps = 0;
     if (opts.strict) {
-        const CONFORMANCE = [
-            { 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" },
-        ];
         console.log(section("Rule conformance (--strict)"));
         let checked = 0;
-        const drift = [];
-        for (const { phase, deliverable, label } of CONFORMANCE) {
-            for (const d of driftReport(mission, deliverable))
-                drift.push(`${label} · ${d.rule} — ${d.problem}`);
+        const signatures = ruleSignatures(mission);
+        for (const { phase, deliverable, label } of GATED_DELIVERABLES) {
             const { expected, violations } = conformance(mission, phase, deliverable);
+            // The evidence layer (ADR-0019/0020) and drift (blocking since ADR-0021) join the
+            // same verdict: a traced decision whose pointer is hollow or stale is a gap.
+            violations.push(...evidenceReport(mission, deliverable, signatures));
+            violations.push(...driftReport(mission, deliverable));
             // Non-vacuity (ADR-0002): when no rules are currently mapped to a phase, conformance()
             // still raises a `(mapping)` violation if the mapping was stripped below its pinned
             // floor. Only skip when there is genuinely nothing to report — never discard that signal.
@@ -85,11 +90,20 @@ export async function checkCommand(opts) {
         }
         if (checked === 0)
             console.log("  " + c.darkGray("no CRITICAL/HIGH rules mapped to a build phase"));
-        if (drift.length > 0) {
-            console.log(section("Drift (advisory)"));
-            for (const d of drift)
-                console.log(`  ${c.warning("◑")} ${c.white(d)}`);
-            console.log("  " + c.darkGray("advisory — an applied pointer no longer resolves; verify it. Does not fail the gate."));
+        // Under --freeze the old seal is being replaced, not verified — otherwise a changed
+        // sealed file would make re-sealing impossible (the seal violation reddens the gate
+        // that freeze requires green). Everything else must still be green to seal.
+        const seal = opts.freeze ? { present: false, count: 0, violations: [] } : verifyEvidenceLock(mission);
+        if (seal.present) {
+            console.log(section("Evidence seal (--strict)"));
+            if (seal.violations.length === 0) {
+                console.log(`  ${status.success(`seal intact — ${seal.count} evidence file(s), sealed ${seal.sealedAt ?? "?"}`)}`);
+            }
+            else {
+                for (const v of seal.violations)
+                    console.log(`  ${c.error("✗")} ${c.white(v.rule)}${c.darkGray(" — " + v.problem)}`);
+                strictGaps += seal.violations.length;
+            }
         }
         const unratified = unratifiedAdrs(mission);
         if (unratified.length > 0) {
@@ -123,6 +137,15 @@ export async function checkCommand(opts) {
             }
             console.log(section("Semantic check (advisory, above the gate)"));
             console.log("  " + c.darkGray("the gate proved every CRITICAL/HIGH rule was traced — not that the code applies it. Before you cross, run the verify workflow (runward/workflows/verify.md): an adversarial cite-vs-apply pass, ideally on a different model. Advisory, agent-executed, never blocks the gate (ADR-0007)."));
+            const vf = verifyFindings(mission);
+            if (!vf.present) {
+                console.log("  " + c.darkGray(`no verify findings recorded yet — the workflow writes them to runward/${VERIFY_FINDINGS}.`));
+            }
+            else {
+                const freshness = vf.fresh ? c.success(" · fresh") : c.warning(" · stale (a gated manifest changed since — re-run the verify workflow)");
+                console.log(`  ${c.success("✓")} ${c.darkGray("verify findings")} ${c.white(`runward/${VERIFY_FINDINGS}`)} ${c.darkGray(`(${vf.date})`)}${freshness}`);
+                console.log("  " + c.darkGray("advisory — runward reports presence and freshness, never reads a verdict. The findings inform your crossing; they never gate it."));
+            }
         }
     }
     if (opts.coverage) {
@@ -166,6 +189,25 @@ export async function checkCommand(opts) {
         console.log("\n" + status.warning(`${parts.join(" · ")}. No phase closes without its artifact — and, under --strict, without its CRITICAL/HIGH rules accounted for.`));
         process.exitCode = 1;
     }
+    if (opts.freeze) {
+        console.log(section("Evidence seal — freeze (ADR-0021)"));
+        if (gaps || strictGaps || hookFailed) {
+            console.log("  " + status.error("refusing to seal a red gate — a seal certifies a crossing, not a hope. Close the gaps above, then re-run `runward check --freeze`."));
+        }
+        else {
+            const sealedAt = isNonInteractive() && process.env.RUNWARD_NOW ? process.env.RUNWARD_NOW : new Date().toISOString().slice(0, 10);
+            const content = renderEvidenceLock(mission, sealedAt);
+            const count = Object.keys(JSON.parse(content).files).length;
+            if (process.env.RUNWARD_DRY_RUN === "1") {
+                console.log("  " + c.darkGray(`dry-run — would seal ${count} evidence file(s) into runward/${EVIDENCE_LOCK}`));
+            }
+            else {
+                writeFileSync(join(mission, EVIDENCE_LOCK), content);
+                console.log(`  ${status.success(`sealed ${count} evidence file(s) into runward/${EVIDENCE_LOCK} — commit it`)}`);
+                console.log("  " + c.darkGray("a sealed file that later changes or disappears fails `check --strict` until you re-verify and re-seal."));
+            }
+        }
+    }
     // Transmission surface: name the next gesture, so the operating agent can hand the human a decision.
     console.log(section("Next"));
     if (gaps === 0 && strictGaps === 0 && hookFailed === 0) {

package/dist/commands/compliance.js

@@ -1,6 +1,7 @@
 import { basename, join, resolve } from "node:path";
 import { findMissionRoot } from "../lib/mission.js";
 import { gatherComplianceInputs, renderIso42001Readiness, renderNistAiRmf, renderEuAiAct, renderOscal } from "../lib/compliance.js";
+import { loadRegime, regimeLensId } from "../lib/regimes.js";
 import { makeWriter } from "../lib/write.js";
 import { c, createHeader, isNonInteractive, section, status } from "../lib/styles.js";
 import { VERSION } from "../lib/paths.js";
@@ -8,23 +9,34 @@ import { VERSION } from "../lib/paths.js";
  * Assemble a regime-framed compliance evidence pack (ADR-0016) — deterministic, read-only, zero-LLM,
  * outside the gate. Reads the mission's real artifacts (rule→OWASP ASI, conformance manifests, ADR
  * journal, governance docs) and writes an assessment-readiness *draft*, explicitly flagging what only
- * the operator can supply. Never a compliance claim.
- * Exit codes: 0 = draft written, 2 = no mission / unsupported regime.
+ * the operator can supply. Never a compliance claim. The regime mapping is versioned data (ADR-0022):
+ * `--regime-version` pins the lens; the selected lens is stamped into the draft and the OSCAL.
+ * Exit codes: 0 = draft written, 2 = no mission / unsupported regime / unknown mapping version.
  */
 const REGIMES = {
-    "iso-42001": { label: "ISO/IEC 42001", render: renderIso42001Readiness, file: "iso-42001-readiness.md" },
-    "nist-ai-rmf": { label: "NIST AI RMF", render: renderNistAiRmf, file: "nist-ai-rmf-readiness.md" },
-    "eu-ai-act": { label: "EU AI Act (Annex IV)", render: renderEuAiAct, file: "eu-ai-act-readiness.md" },
+    "iso-42001": { render: renderIso42001Readiness, file: "iso-42001-readiness.md" },
+    "nist-ai-rmf": { render: renderNistAiRmf, file: "nist-ai-rmf-readiness.md" },
+    "eu-ai-act": { render: renderEuAiAct, file: "eu-ai-act-readiness.md" },
 };
 export async function complianceCommand(regime, opts) {
     const key = (regime ?? "").toLowerCase();
-    console.log(createHeader(`Runward v${VERSION} — compliance`, key ? REGIMES[key]?.label ?? key : "regime required"));
     if (!key || !(key in REGIMES)) {
+        console.log(createHeader(`Runward v${VERSION} — compliance`, key || "regime required"));
         console.error(status.error(`Usage: runward compliance <regime>. Supported: ${Object.keys(REGIMES).join(", ")}.`));
         console.log("  " + c.darkGray("The manifest is universal (OWASP ASI); the regime is a lens (ADR-0015). Default posture is security-only — no regime named."));
         process.exit(2);
     }
     const spec = REGIMES[key];
+    let lens;
+    try {
+        lens = loadRegime(key, opts.regimeVersion);
+    }
+    catch (e) {
+        console.log(createHeader(`Runward v${VERSION} — compliance`, key));
+        console.error(status.error(e instanceof Error ? e.message : String(e)));
+        process.exit(2);
+    }
+    console.log(createHeader(`Runward v${VERSION} — compliance`, `${lens.label} — mapping version ${lens.version}`));
     const root = findMissionRoot(resolve(process.cwd(), opts.path ?? "."));
     if (!root) {
         console.error(status.error("No runward/ mission found here or above. Run `runward init` first."));
@@ -35,11 +47,11 @@ export async function complianceCommand(regime, opts) {
     const generatedAt = isNonInteractive() && process.env.RUNWARD_NOW ? process.env.RUNWARD_NOW : new Date().toISOString().slice(0, 10);
     console.log(section("Assembling (read-only, deterministic)"));
     const inputs = gatherComplianceInputs(mission);
-    const md = spec.render(inputs, generatedAt);
+    const md = spec.render(inputs, generatedAt, lens);
     const w = makeWriter({ force: true, dryRun, root }); // generated artifacts — always refresh
     w.write(join(mission, "compliance", spec.file), md);
     // OSCAL export — regime-neutral, machine-readable; the interop layer (ADR-0016) so the evidence flows into GRC/auditor tools.
-    w.write(join(mission, "compliance", "oscal-component-definition.json"), renderOscal(inputs, basename(root), generatedAt));
+    w.write(join(mission, "compliance", "oscal-component-definition.json"), renderOscal(inputs, basename(root), generatedAt, regimeLensId(lens)));
     const mappedAsi = [...inputs.asiCoverage.values()].filter((v) => v.length).length;
     console.log(section("Assembled"));
     console.log(`  ${c.primaryBold("ASI coverage")}   ${c.white(`${mappedAsi}/10 categories mapped to a rule`)}`);

package/dist/commands/init.js

@@ -1,13 +1,16 @@
 import { join, resolve } from "node:path";
-import { readdirSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { checkbox, input, select } from "@inquirer/prompts";
-import { TEMPLATES, EXAMPLE_MISSION, MISSION_LAYOUT, VERSION } from "../lib/paths.js";
+import { TEMPLATES, EXAMPLE_MISSION, EXAMPLE_CODE, MISSION_LAYOUT, VERSION } from "../lib/paths.js";
 import { TOOL_PROFILES, TOOL_IDS, baselineSkills } from "../lib/tools.js";
 import { makeWriter } from "../lib/write.js";
 import { c, createHeader, isNonInteractive, section, status } from "../lib/styles.js";
 /** Recursively copy a shipped directory tree (used to lay down the filled reference mission). */
+const COPY_SKIP = new Set(["node_modules", "package-lock.json", ".DS_Store"]);
 function copyTree(w, srcDir, destDir) {
     for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+        if (COPY_SKIP.has(entry.name))
+            continue;
         const src = join(srcDir, entry.name);
         const dest = join(destDir, entry.name);
         if (entry.isDirectory())
@@ -64,6 +67,10 @@ export async function initCommand(opts) {
     if (example) {
         // Lay down the filled request-triage reference: every gate is green out of the box.
         copyTree(w, EXAMPLE_MISSION, mission);
+        // The manifests carry verified evidence pointers into code/ (ADR-0019): ship the reference
+        // floor with them, so the gate is green because the evidence resolves — not unchecked.
+        if (existsSync(EXAMPLE_CODE))
+            copyTree(w, EXAMPLE_CODE, join(root, "code"));
         // The reference omits the three non-gated scaffolding notes; add them as blank templates so the scaffold stays complete.
         for (const extra of ["reference-stack.md", "shared-bricks.md", "gap-analysis.md"]) {
             w.copy(join(TEMPLATES, "mission", extra), join(mission, extra));

package/dist/commands/manifest.js

@@ -0,0 +1,72 @@
+import { writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { findMissionRoot } from "../lib/mission.js";
+import { GATED_DELIVERABLES } from "../lib/conformance.js";
+import { syncManifest } from "../lib/manifest-sync.js";
+import { c, createHeader, section, status } from "../lib/styles.js";
+import { VERSION } from "../lib/paths.js";
+/**
+ * Rule-conformance manifest plumbing (ADR-0023). Read-only overview by default;
+ * --sync scaffolds the FORM (missing rows with empty status, renamed slugs migrated,
+ * missing sections created) and never touches the content: no status set, no evidence
+ * written, no row deleted. The decision stays the operator's.
+ * Exit codes: 0 = done, 2 = no mission found.
+ */
+export async function manifestCommand(opts) {
+    const root = findMissionRoot(resolve(process.cwd(), opts.path ?? "."));
+    if (!root) {
+        console.error(status.error("No runward/ mission found here or above. Run `runward init` first."));
+        process.exit(2);
+    }
+    const mission = join(root, "runward");
+    const dryRun = process.env.RUNWARD_DRY_RUN === "1";
+    console.log(createHeader(`Runward v${VERSION} — manifest ${opts.sync ? "sync" : "overview"}`, root));
+    let toFill = 0;
+    for (const { phase, deliverable, label } of GATED_DELIVERABLES) {
+        const r = syncManifest(mission, phase, deliverable, label);
+        console.log(section(`${label} (runward/${deliverable})`));
+        if (r.fileMissing) {
+            console.log("  " + c.darkGray("deliverable missing — `runward init` scaffolds it; sync only edits existing files"));
+            continue;
+        }
+        if (r.migrated.length)
+            for (const m of r.migrated)
+                console.log(`  ${c.warning("◑")} renamed slug: ${c.white(`${m.from} → ${m.to}`)}${opts.sync ? c.darkGray(" — rewritten, status and evidence untouched") : c.darkGray(" — --sync rewrites it")}`);
+        if (r.removed.length)
+            for (const m of r.removed)
+                console.log(`  ${c.warning("◑")} ${c.white(m.slug)}${c.darkGray(` — removed in ${m.since} (${m.reason}); delete the row yourself`)}`);
+        if (r.duplicates.length)
+            for (const d of r.duplicates)
+                console.log(`  ${c.warning("◑")} duplicate: ${c.white(d)}`);
+        if (r.unknown.length)
+            for (const u of r.unknown)
+                console.log(`  ${c.warning("◑")} unknown rule slug: ${c.white(u)}${c.darkGray(" — typo? not in runward/rules/; fix or remove the row yourself")}`);
+        if (r.added.length) {
+            toFill += r.added.length;
+            const verb = opts.sync ? (r.sectionCreated ? "section created, rows scaffolded" : "rows scaffolded (empty status — the gate refuses them until you decide)") : "missing — --sync scaffolds the rows";
+            console.log(`  ${opts.sync ? c.success("✓") : c.error("✗")} ${c.white(`${r.added.length} expected rule(s) not accounted for`)} ${c.darkGray("— " + verb)}`);
+            for (const a of r.added)
+                console.log(`     ${c.darkGray("·")} ${c.white(a)}`);
+        }
+        if (!r.migrated.length && !r.removed.length && !r.duplicates.length && !r.unknown.length && !r.added.length) {
+            console.log("  " + status.success("table in sync with the mapped rule set"));
+        }
+        if (opts.sync && r.content !== null) {
+            if (dryRun)
+                console.log("  " + c.info("dry-run — would rewrite ") + c.white(`runward/${deliverable}`));
+            else
+                writeFileSync(join(mission, deliverable), r.content);
+        }
+    }
+    console.log(section("Next"));
+    if (opts.sync && toFill > 0) {
+        console.log(`  Fill each scaffolded row — a status (${c.primary("applied | deviated | n/a")}) and its evidence (${c.primary("file:PATH[:LINE][#SYMBOL]")}, ${c.primary("test:PATH[::NAME]")}, ${c.primary("adr:NNNN")} or prose) — then ${c.primary("runward check --strict")}.`);
+    }
+    else if (!opts.sync && toFill > 0) {
+        console.log(`  Run ${c.primary("runward manifest --sync")} to scaffold the missing rows, then fill them and ${c.primary("runward check --strict")}.`);
+    }
+    else {
+        console.log(`  Nothing to scaffold. ${c.primary("runward check --strict")} ${c.darkGray("verifies the decisions themselves.")}`);
+    }
+    console.log();
+}

package/dist/commands/rules.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { findMissionRoot } from "../lib/mission.js";
+import { readRuleSet, ruleSetDir, parseRule, ruleBody } from "../lib/rules.js";
+import { RULE_MIGRATIONS } from "../lib/rule-migrations.js";
+import { c, createHeader, section, status } from "../lib/styles.js";
+import { VERSION } from "../lib/paths.js";
+/**
+ * The machine surface of the rule set (ADR-0024). `rules` lists the effective set
+ * (mission copy when present, else the package); `--json` is a versioned, additive
+ * contract: { runward, source, count, rules } sorted by slug. `explain <rule>` prints
+ * the rule's contract surface and its full body — the why, inline. Read-only, zero-LLM.
+ * Exit codes: 0 = ok, 2 = unknown rule slug.
+ */
+function effectiveDir(path) {
+    const root = findMissionRoot(resolve(process.cwd(), path ?? "."));
+    return ruleSetDir(root ? join(root, "runward") : null);
+}
+export async function rulesCommand(opts) {
+    const { dir, source } = effectiveDir(opts.path);
+    let rules = readRuleSet(dir);
+    if (opts.phase)
+        rules = rules.filter((r) => r.phases.includes(opts.phase));
+    if (opts.json) {
+        // Versioned, additive contract (ADR-0024) — fields are added, never renamed or repurposed.
+        console.log(JSON.stringify({ runward: VERSION, source, count: rules.length, rules }, null, 2));
+        return;
+    }
+    console.log(createHeader(`Runward v${VERSION} — rules`, `${rules.length} rule(s) · source: ${source}${opts.phase ? ` · phase: ${opts.phase}` : ""}`));
+    const phases = ["architect", "topology", "floor", "govern"];
+    for (const ph of opts.phase ? [opts.phase] : [...phases, ""]) {
+        const subset = ph === "" ? rules.filter((r) => r.phases.length === 0 || r.phases.every((p) => !phases.includes(p))) : rules.filter((r) => r.phases.includes(ph));
+        if (subset.length === 0)
+            continue;
+        console.log(section(ph === "" ? "Unmapped (advisory)" : `Phase · ${ph}`));
+        for (const r of subset) {
+            const sig = r.signature ? c.primary(" ·signed") : "";
+            console.log(`  ${c.white(r.slug.padEnd(42))} ${c.darkGray(r.impact.padEnd(9))}${c.darkGray(r.asi.join(","))}${sig}`);
+        }
+    }
+    console.log(section("Next"));
+    console.log(`  ${c.primary("runward explain <rule>")} ${c.darkGray("prints a rule's why and full text ·")} ${c.primary("runward rules --json")} ${c.darkGray("is the machine contract.")}`);
+    console.log();
+}
+export async function explainCommand(slug, opts) {
+    const { dir, source } = effectiveDir(opts.path);
+    const file = join(dir, `${slug}.md`);
+    if (!existsSync(file)) {
+        const m = RULE_MIGRATIONS[slug];
+        if (m?.to)
+            console.error(status.error(`Unknown rule "${slug}" — renamed to '${m.to}' in ${m.since} (${m.reason}). Try: runward explain ${m.to}`));
+        else if (m)
+            console.error(status.error(`Unknown rule "${slug}" — removed in ${m.since} (${m.reason}).`));
+        else
+            console.error(status.error(`Unknown rule "${slug}" — not in ${source === "mission" ? "runward/rules/" : "the package rule set"}. \`runward rules\` lists the slugs.`));
+        process.exit(2);
+    }
+    const content = readFileSync(file, "utf8");
+    const rule = parseRule(slug, content);
+    if (opts.json) {
+        console.log(JSON.stringify({ runward: VERSION, source, rule: { ...rule, body: ruleBody(content) } }, null, 2));
+        return;
+    }
+    console.log(createHeader(`Runward v${VERSION} — explain`, rule.title));
+    console.log(section("Contract"));
+    console.log(`  ${c.primaryBold("Slug")}       ${c.white(rule.slug)}`);
+    console.log(`  ${c.primaryBold("Impact")}     ${c.white(rule.impact)}${rule.phases.length ? c.darkGray(`  · phases: ${rule.phases.join(", ")}`) : c.darkGray("  · advisory (no gated phase)")}`);
+    if (rule.asi.length)
+        console.log(`  ${c.primaryBold("OWASP ASI")}  ${c.white(rule.asi.join(", "))}`);
+    if (rule.signature)
+        console.log(`  ${c.primaryBold("Signature")}  ${c.white(`/${rule.signature}/i`)} ${c.darkGray("— applied evidence must point at content matching this (ADR-0020)")}`);
+    if (rule.why)
+        console.log(`  ${c.primaryBold("Why")}        ${c.white(rule.why)}`);
+    console.log(section("Rule"));
+    console.log(ruleBody(content));
+}