runward 0.6.0 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # Runward
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-0a0a0a?style=for-the-badge)](LICENSE) [![Doctrine: CC BY-ND 4.0](https://img.shields.io/badge/Doctrine-CC%20BY--ND%204.0-C9A45C?style=for-the-badge)](https://github.com/stranxik/designing-and-running-agentic-systems) [![Support via Ko-fi](https://img.shields.io/badge/%E2%98%95%20Support%20via%20Ko--fi-orange?style=for-the-badge)](https://ko-fi.com/stranxik)
+[![npm](https://img.shields.io/npm/v/runward?style=for-the-badge&color=0a0a0a&label=npm)](https://www.npmjs.com/package/runward) [![License: MIT](https://img.shields.io/badge/License-MIT-0a0a0a?style=for-the-badge)](LICENSE) [![Doctrine: CC BY-ND 4.0](https://img.shields.io/badge/Doctrine-CC%20BY--ND%204.0-C9A45C?style=for-the-badge)](https://github.com/stranxik/designing-and-running-agentic-systems) [![Support via Ko-fi](https://img.shields.io/badge/%E2%98%95%20Support%20via%20Ko--fi-orange?style=for-the-badge)](https://ko-fi.com/stranxik)
 
 **From business need to a system that holds in production.**
 
@@ -8,7 +8,7 @@ Your agent builds fast. Runward frames what it builds — six gated phases your
 
 Runward is a delivery framework for agentic systems. It covers the entire mission, from framing to handover — it opens before any spec in greenfield, or picks up where the spec tools stop, and carries through to the run and the handover either way. Three ways in: day one of a new project (Frame is the first gate, before any spec exists), from an existing spec (Spec Kit, OpenSpec or in-house — it becomes the input of framing), or from an existing prototype (brownfield: characterize before touching anything). Then: floor first (the floor: the smallest *running* system that proves value on real traffic), evolution on evidence, governance from day zero, and a handover that makes your team autonomous.
 
-> Spec Kit, OpenSpec and BMAD stop at authoring: specs, plans, implementation. Runward pilots the whole mission — and picks up their output if you use them. What none of them *structures* is the run: governed memory, resilience, execution security, continuous evaluation, transmission.
+> Spec Kit, OpenSpec and BMAD take you to tested, sometimes merged code. Runward pilots the whole mission — and picks up their output if you use them. What none of them *structures* is the run: governed memory, resilience, execution security, continuous evaluation, transmission.
 
 ## Why
 

package/dist/cli.js

@@ -57,6 +57,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("--hooks", "run operator hooks from runward/hooks.json around the audit (opt-in)")
     .action(checkCommand);
 program
     .command("status")

package/dist/commands/check.js

@@ -1,10 +1,16 @@
 import { join } from "node:path";
 import { analyze, findMissionRoot } from "../lib/mission.js";
+import { conformance, driftReport } from "../lib/conformance.js";
+import { runHooks } from "../lib/hooks.js";
 import { c, createHeader, 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.
  * Exit codes: 0 = current gate clean, 1 = gaps, 2 = no mission found.
  */
 export async function checkCommand(opts) {
@@ -16,6 +22,15 @@ export async function checkCommand(opts) {
     const mission = join(root, "runward");
     const report = analyze(mission);
     console.log(createHeader(`Runward v${VERSION} — gate audit`, root));
+    let hookFailed = 0;
+    if (opts.hooks) {
+        const before = runHooks(mission, "before", root);
+        if (before.ran > 0) {
+            console.log(section("Hooks · before"));
+            console.log("  " + (before.failed.length ? status.error(`${before.failed.length}/${before.ran} failed`) : status.success(`${before.ran} ok`)));
+            hookFailed += before.failed.length;
+        }
+    }
     const glyph = {
         "filled": c.success("✓"),
         "in-progress": c.warning("◐"),
@@ -37,14 +52,64 @@ export async function checkCommand(opts) {
                 gaps++;
         }
     }
+    let strictGaps = 0;
+    if (opts.strict) {
+        const CONFORMANCE = [
+            { phase: "architect", deliverable: "architecture.md", label: "Architect" },
+            { 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 { expected, violations } = conformance(mission, phase, deliverable);
+            if (expected.length === 0)
+                continue;
+            checked++;
+            if (violations.length === 0) {
+                console.log(`  ${status.success(`${label}: ${expected.length} rule(s) accounted for`)}`);
+            }
+            else {
+                for (const v of violations)
+                    console.log(`  ${c.error("✗")} ${c.darkGray(label + " · ")}${c.white(v.rule)}${c.darkGray(" — " + v.problem)}`);
+                strictGaps += violations.length;
+            }
+        }
+        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."));
+        }
+    }
+    if (opts.hooks) {
+        const after = runHooks(mission, "after", root);
+        if (after.ran > 0) {
+            console.log(section("Hooks · after"));
+            console.log("  " + (after.failed.length ? status.error(`${after.failed.length}/${after.ran} failed`) : status.success(`${after.ran} ok`)));
+            hookFailed += after.failed.length;
+        }
+    }
     console.log(section("Summary"));
     console.log(`  ${c.primaryBold("Current gate")}  ${c.white(report.currentPhase)}`);
     console.log(`  ${c.primaryBold("ADRs")}          ${c.white(String(report.adrCount))}${report.adrCount === 0 ? c.warning("  — no structural decision locked yet") : ""}`);
-    if (gaps === 0) {
+    if (gaps === 0 && strictGaps === 0 && hookFailed === 0) {
         console.log("\n" + status.success("All expected deliverables are filled. Cross gates on evidence, not on paperwork."));
     }
     else {
-        console.log("\n" + status.warning(`${gaps} deliverable(s) not filled. The gate rule: no phase closes without its artifact.`));
+        const parts = [];
+        if (gaps)
+            parts.push(`${gaps} deliverable(s) not filled`);
+        if (strictGaps)
+            parts.push(`${strictGaps} floor rule-conformance gap(s)`);
+        if (hookFailed)
+            parts.push(`${hookFailed} hook(s) failed`);
+        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;
     }
 }

package/dist/commands/doctor.js

@@ -2,7 +2,8 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { TEMPLATES, MISSION_LAYOUT, VERSION, WORKFLOWS } from "../lib/paths.js";
-import { EXPECTED_RULES } from "../lib/constants.js";
+import { EXPECTED_RULES, EXPECTED_MAPPED } from "../lib/constants.js";
+import { expectedRules } from "../lib/conformance.js";
 import { findMissionRoot } from "../lib/mission.js";
 import { createHeader, section, status } from "../lib/styles.js";
 /**
@@ -34,6 +35,11 @@ export async function doctorCommand() {
     const rulesDir = join(TEMPLATES, "rules");
     const ruleCount = existsSync(rulesDir) ? readdirSync(rulesDir).filter((f) => f.endsWith(".md")).length : 0;
     ruleCount === EXPECTED_RULES ? ok(`${ruleCount} craft rules`) : fail(`craft rules mismatch: ${ruleCount}/${EXPECTED_RULES}`);
+    // Routed-count floor (ADR-0002): the phases: mapping must not be stripped below its pinned minimum.
+    const belowFloor = Object.entries(EXPECTED_MAPPED).filter(([phase, floor]) => expectedRules(TEMPLATES, phase).length < floor);
+    belowFloor.length === 0
+        ? ok(`rule mapping floors met (${Object.entries(EXPECTED_MAPPED).map(([p, f]) => `${p}≥${f}`).join(", ")})`)
+        : fail(`rule mapping below floor: ${belowFloor.map(([p, f]) => `${p} ${expectedRules(TEMPLATES, p).length}/${f}`).join(", ")}`);
     console.log(section("Current directory"));
     const root = findMissionRoot(process.cwd());
     if (!root) {

package/dist/lib/conformance.js

@@ -0,0 +1,149 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { TEMPLATES } from "./paths.js";
+import { EXPECTED_MAPPED } from "./constants.js";
+import { RULE_MIGRATIONS } from "./rule-migrations.js";
+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. */
+function trivialReason(s) {
+    const t = s.trim();
+    return t.length < 8 || /^\[.*\]$/.test(t);
+}
+function parseRuleMeta(content) {
+    const fm = content.match(FRONTMATTER)?.[1] ?? "";
+    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 };
+}
+/** 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");
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".md"))
+        .filter((f) => {
+        const { impact, phases } = parseRuleMeta(readFileSync(join(dir, f), "utf8"));
+        return (impact === "CRITICAL" || impact === "HIGH") && phases.includes(phaseId);
+    })
+        .map((f) => f.replace(/\.md$/, ""))
+        .sort();
+}
+/** 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");
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+}
+/** Parse the "## Rule conformance" markdown table from a deliverable. */
+export function parseManifest(content) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((l) => /^##\s+Rule conformance/i.test(l));
+    if (start === -1)
+        return [];
+    const rows = [];
+    for (let i = start + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^##\s/.test(line))
+            break; // next section
+        if (!line.trim().startsWith("|"))
+            continue;
+        const cols = line.split("|").slice(1, -1).map((c) => c.replace(/`/g, "").trim());
+        if (cols.length < 3)
+            continue;
+        const [rule, status, evidence] = cols;
+        if (/^rule$/i.test(rule) || /^:?-+:?$/.test(rule))
+            continue; // header / separator
+        rows.push({ rule, status: status.toLowerCase(), evidence });
+    }
+    return rows;
+}
+function adrExists(missionDir, evidence) {
+    const id = evidence.match(/ADR-\d+/i)?.[0].toUpperCase();
+    if (!id)
+        return false;
+    const dir = join(missionDir, "adr");
+    return existsSync(dir) && readdirSync(dir).some((f) => f.toUpperCase().startsWith(id));
+}
+// 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. */
+export function driftReport(missionDir, deliverable) {
+    const path = join(missionDir, deliverable);
+    if (!existsSync(path))
+        return [];
+    const bases = [dirname(missionDir), missionDir, dirname(path)];
+    const out = [];
+    for (const row of parseManifest(readFileSync(path, "utf8"))) {
+        if (row.status !== "applied")
+            continue;
+        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` });
+    }
+    return out;
+}
+/** Verify a build phase's conformance manifest against its expected rule set. */
+export function conformance(missionDir, phaseId, deliverable) {
+    const expected = expectedRules(missionDir, phaseId);
+    const violations = [];
+    // Non-vacuity (ADR-0002): the mapping cannot be stripped below its pinned floor.
+    const floor = EXPECTED_MAPPED[phaseId];
+    if (floor !== undefined && expected.length < floor) {
+        violations.push({ rule: "(mapping)", problem: `only ${expected.length} CRITICAL/HIGH rules mapped to '${phaseId}', floor is ${floor} — the mapping may have been stripped; restore the phases: [...] frontmatter on this phase's rules` });
+    }
+    const path = join(missionDir, deliverable);
+    if (!existsSync(path)) {
+        return { expected, violations: expected.map((rule) => ({ rule, problem: `${deliverable} missing` })) };
+    }
+    const rows = parseManifest(readFileSync(path, "utf8"));
+    // Form-lint (ADR-0003): well-formedness before the semantic check. Skip template placeholder tokens.
+    const known = new Set(allRules(missionDir));
+    const counts = new Map();
+    for (const r of rows) {
+        if (/^\[.*\]$/.test(r.rule))
+            continue;
+        counts.set(r.rule, (counts.get(r.rule) ?? 0) + 1);
+    }
+    for (const [rule, n] of counts) {
+        if (!known.has(rule)) {
+            const m = RULE_MIGRATIONS[rule];
+            const hint = m
+                ? (m.to ? ` — renamed to '${m.to}' in ${m.since} (${m.reason})` : ` — removed in ${m.since} (${m.reason})`)
+                : " (typo? not in runward/rules/)";
+            violations.push({ rule, problem: `unknown rule${hint}` });
+        }
+        if (n > 1)
+            violations.push({ rule, problem: `listed ${n} times in the manifest — keep a single row per rule` });
+    }
+    const byRule = new Map(rows.map((r) => [r.rule, r]));
+    for (const rule of expected) {
+        const row = byRule.get(rule);
+        if (!row) {
+            violations.push({ rule, problem: "not accounted for in the Rule conformance manifest — add a row: applied with a file:line/test, deviated with an ADR, or n/a with a reason" });
+            continue;
+        }
+        if (!VALID_STATUS.has(row.status)) {
+            violations.push({ rule, problem: `invalid status "${row.status}" (use applied | deviated | n/a)` });
+            continue;
+        }
+        if (row.status === "applied" && !row.evidence)
+            violations.push({ rule, problem: "applied without an evidence pointer — put a file:line or a test in the Evidence column" });
+        if (row.status === "deviated" && !adrExists(missionDir, row.evidence))
+            violations.push({ rule, problem: "deviated but no matching ADR in runward/adr/ — reference an ADR that exists there" });
+        if (row.status === "n/a" && trivialReason(row.evidence))
+            violations.push({ rule, problem: "n/a with an empty or placeholder reason — give a real one-line reason why it does not apply here" });
+    }
+    return { expected, violations };
+}

package/dist/lib/constants.js

@@ -1,2 +1,6 @@
 /** Total number of craft rules shipped under templates/rules/. */
 export const EXPECTED_RULES = 51;
+/** 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. */
+export const EXPECTED_MAPPED = { architect: 5, floor: 10, govern: 7 };

package/dist/lib/hooks.js

@@ -0,0 +1,26 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function runHooks(missionDir, phase, cwd) {
+    const result = { ran: 0, failed: [] };
+    const path = join(missionDir, "hooks.json");
+    if (!existsSync(path))
+        return result;
+    let cfg;
+    try {
+        cfg = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return result;
+    }
+    for (const cmd of cfg[phase] ?? []) {
+        result.ran++;
+        try {
+            execSync(cmd, { cwd, stdio: "inherit" });
+        }
+        catch {
+            result.failed.push(cmd);
+        }
+    }
+    return result;
+}

package/dist/lib/paths.js

@@ -24,5 +24,5 @@ export const MISSION_LAYOUT = {
 };
 export const WORKFLOWS = [
     "method", "frame", "architect", "floor", "iterate",
-    "govern", "handover", "brownfield", "review", "decision-loop",
+    "govern", "handover", "brownfield", "review", "decision-loop", "verify",
 ];

package/dist/lib/rule-migrations.js

@@ -0,0 +1,7 @@
+export const RULE_MIGRATIONS = {
+    "hexa-llm-boundary-principle": {
+        to: "hexa-move-deterministic-out",
+        reason: "the name is reserved for the founding inversion",
+        since: "v0.7.0",
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runward",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "After the spec: ship and run. A delivery framework for agentic systems — floor first, evolution on evidence, governance from day zero, handover with proof.",
   "keywords": ["agentic", "ai-agents", "spec-driven", "delivery", "governance", "llm", "architecture"],
   "author": "Thibault Souris",

package/templates/mission/architecture.md

@@ -37,6 +37,14 @@
 | Tool registry + middleware chain | [single transversal surface, thin channel] | [—] |
 | One core language, thin model SDK | [no heavy chain framework] | [mature library or proven performance need → sidecar] |
 
+## Rule conformance
+
+> Account for every CRITICAL/HIGH craft rule mapped to the architect phase (`runward/rules/`, frontmatter `phases: [architect]`). `applied` needs a pointer; `deviated` needs an ADR; `n/a` needs a reason. `runward check --strict` verifies this table is complete — it checks a traced decision, not the quality of your architecture.
+
+| Rule | Status | Evidence |
+|---|---|---|
+| [rule-slug] | applied \| deviated \| n/a | [pointer, ADR-id, or reason] |
+
 ## 5. What stays open
 
 [Explicitly undecided: language(s), framework, model provider, hosting. Each is an adapter decision, taken later behind the contracts above, justified by a local technical reason.]

package/templates/mission/floor.md

@@ -17,6 +17,14 @@
 | Deterministic guardrails | [shipped] | [classification, validation, mutation access control] |
 | Baseline observability + cost ceiling | [shipped] | [request ID propagated; per-run ceiling: [value]] |
 
+## Rule conformance
+
+> Account for every CRITICAL/HIGH craft rule mapped to the floor phase (`runward/rules/`, frontmatter `phases: [floor]`). Status: `applied` needs an evidence pointer (a `file:line` or a test); `deviated` needs an ADR reference; `n/a` needs a one-line reason. `runward check --strict` verifies this table is complete and well-formed — it does not judge your implementation; you do, at the gate.
+
+| Rule | Status | Evidence |
+|---|---|---|
+| [rule-slug] | applied \| deviated \| n/a | [file:line, a test, ADR-id, or a reason] |
+
 ## 2. Proof against the success criterion
 
 [The measurement, on real traffic or a representative sample — never on cases picked to impress.]

package/templates/mission/threat-model.md

@@ -48,6 +48,14 @@
 
 **Reminder**: the approval summary is itself an attack surface. It must be deterministic and faithful to the real arguments, or an injected action slips through in the batch. Group low-urgency requests into a prioritized queue with summaries, so approvers are not trained to rubber-stamp.
 
+## Rule conformance
+
+> Account for every CRITICAL/HIGH craft rule mapped to the govern phase (`runward/rules/`, frontmatter `phases: [govern]`). `applied` needs a pointer; `deviated` needs an ADR; `n/a` needs a reason. `runward check --strict` verifies this table is complete — it checks a traced decision, not the quality of your governance.
+
+| Rule | Status | Evidence |
+|---|---|---|
+| [rule-slug] | applied \| deviated \| n/a | [pointer, ADR-id, or reason] |
+
 ## References
 
 - [Related hardening ADR, observability schema, evaluation rubric.]

package/templates/rules/async-job-guardrails.md

@@ -1,6 +1,7 @@
 ---
 title: Background Job Guardrails (Retry, Idempotency, Bounded Concurrency, Job Observability)
 impact: HIGH
+phases: [govern]
 impactDescription: The four non-negotiables of any background job — bounded retry per step, idempotency under concurrency, capped and partitioned concurrency, and queue lag plus failure rate as first-class metrics
 tags: [async, jobs, idempotency, concurrency, retry, observability]
 ---

package/templates/rules/config-secrets-boundary.md

@@ -1,6 +1,7 @@
 ---
 title: Secrets at the Network Boundary, Never in the Model
 impact: CRITICAL
+phases: [floor, govern]
 impactDescription: Makes secret disclosure structurally impossible by keeping the real key out of the model and the domain
 tags: [security, secrets, configuration, boundary]
 ---

package/templates/rules/contracts-governance.md

@@ -1,6 +1,7 @@
 ---
 title: Contract Governance (Versioned, Additive, Expand-then-Contract)
 impact: CRITICAL
+phases: [architect]
 impactDescription: Lets the system evolve without breaking consumers, by governing the contract at the boundary rather than the implementation behind it
 tags: [architecture, contracts, ports, versioning, compatibility]
 ---

package/templates/rules/eval-loop.md

@@ -1,6 +1,7 @@
 ---
 title: Evaluation Loop (Test + Evaluate, Hold-out, Anchored Judge)
 impact: CRITICAL
+phases: [govern]
 impactDescription: Gives a non-deterministic system a trustworthy way to detect behavioural regressions without letting it optimise its own grader
 tags: [evaluation, testing, llm, quality, governance]
 ---

package/templates/rules/frontier-deterministic-boundary.md

@@ -1,6 +1,7 @@
 ---
 title: Deterministic Boundary of the Model
 impact: CRITICAL
+phases: [floor]
 impactDescription: Keeps every fact, figure and decision that can be checked out of the model, so the system is verifiable and cannot hallucinate load-bearing values
 tags: [architecture, llm, frontier, grounding, safety, determinism]
 ---

package/templates/rules/hexa-adapter-pattern.md

@@ -1,6 +1,7 @@
 ---
 title: New Feature = New Adapter
 impact: HIGH
+phases: [architect, floor]
 impactDescription: Keeps core business logic clean and external integrations isolated
 tags: [architecture, hexagonal, adapters, integration]
 ---

package/templates/rules/hexa-architecture.md

@@ -1,6 +1,7 @@
 ---
 title: Hexagonal Architecture Structure
 impact: HIGH
+phases: [architect, floor]
 impactDescription: Enables testability, maintainability, and clean dependency management
 tags: [architecture, hexagonal, structure, testing]
 ---

package/templates/rules/hexa-move-deterministic-out.md

@@ -1,6 +1,7 @@
 ---
 title: Move the Deterministic out of the Model
 impact: CRITICAL
+phases: [floor]
 impactDescription: Reduces LLM costs and latency by moving deterministic logic out of LLM calls
 tags: [architecture, llm, cost-optimization, performance]
 ---

package/templates/rules/hexa-typescript-native.md

@@ -1,6 +1,7 @@
 ---
 title: A Thin Model Abstraction You Own (Not a Heavy Chain Framework)
 impact: HIGH
+phases: [architect]
 impactDescription: Reduces token overhead, improves debuggability, removes volatile dependencies by keeping a light abstraction you control instead of a heavy framework
 tags: [architecture, typescript, llm, frameworks]
 ---

package/templates/rules/process-adr-and-journal.md

@@ -1,6 +1,7 @@
 ---
 title: ADR Discipline and Working Journal
 impact: HIGH
+phases: [architect]
 impactDescription: Makes structural decisions traceable and reversible-by-record, so the system can be picked up by anyone without re-litigating settled choices
 tags: [process, adr, journal, traceability, governance]
 ---

package/templates/rules/provider-llm-auto-detection.md

@@ -1,6 +1,7 @@
 ---
 title: Model Provider as an Adapter (Detected, Never Hardcoded)
 impact: CRITICAL
+phases: [floor]
 impactDescription: Keeps the model behind a port so the provider can change by configuration without touching the core
 tags: [provider, llm, embeddings, ports, configuration, portability]
 ---

package/templates/rules/provider-no-crash-missing-env.md

@@ -1,6 +1,7 @@
 ---
 title: Graceful Degradation of Optional Services
 impact: HIGH
+phases: [floor]
 impactDescription: Lets the app start and run wherever it is deployed, enabling features by available config rather than crashing on a missing variable
 tags: [provider, configuration, resilience, deployment]
 ---

package/templates/rules/resilience-fail-open.md

@@ -1,6 +1,7 @@
 ---
 title: Fail-Open for the Non-Critical, Fail-Closed for the Sensitive
 impact: CRITICAL
+phases: [govern]
 impactDescription: Degrades gracefully where safe and denies safely where it matters, instead of applying one failure policy everywhere
 tags: [resilience, error-handling, availability, safety]
 ---

package/templates/rules/resilience-multi-provider-fallback.md

@@ -1,6 +1,7 @@
 ---
 title: Multi-Provider Fallback
 impact: HIGH
+phases: [govern]
 impactDescription: Ensures LLM availability by falling back to alternative providers
 tags: [resilience, llm, providers, availability]
 ---

package/templates/rules/resilience-retry-backoff.md

@@ -1,6 +1,7 @@
 ---
 title: LLM Retry with Exponential Backoff
 impact: HIGH
+phases: [govern]
 impactDescription: Handles transient LLM failures gracefully without overwhelming the API
 tags: [resilience, llm, retry, error-handling]
 ---

package/templates/rules/security-prompt-injection.md

@@ -1,6 +1,7 @@
 ---
 title: Untrusted Input, Prompt Injection and the Lethal Trifecta
 impact: CRITICAL
+phases: [floor, govern]
 impactDescription: Treats prompt injection as a first-rank, structural threat constrained by architecture rather than detected by heuristics
 tags: [security, llm, injection, trifecta, untrusted-input]
 ---

package/templates/rules/state-event-sourcing.md

@@ -1,6 +1,7 @@
 ---
 title: State as an Immutable Journal (Event Sourcing, Replay, Provenance)
 impact: HIGH
+phases: [floor]
 impactDescription: Makes the agent a stateless reducer over an external, replayable journal, so truth, audit and recovery are structural rather than bolted on
 tags: [state, event-sourcing, replay, provenance, memory]
 ---

package/templates/rules/tools-scope-atomicity.md

@@ -1,6 +1,7 @@
 ---
 title: Tool Scope and Atomicity
 impact: HIGH
+phases: [floor]
 impactDescription: Reduces token usage and improves LLM tool selection accuracy
 tags: [tools, llm, architecture, cost-optimization]
 ---

package/templates/targets/AGENTS.md

@@ -12,7 +12,7 @@ This project is delivered with the Runward method: floor first, evolution on evi
 
 ## How to work
 
-- Apply the craft rules in `runward/rules/` while building: they cover memory scoring, tiered retrieval, event sourcing, request-id propagation, resilience, cost routing, secrets and prompt-injection defenses. When a rule and a habit conflict, the rule wins; deviating from a rule requires an ADR.
+- Apply the craft rules in `runward/rules/` while building — and confront them at the point of action, not from memory. Each rule declares where it applies (`phases:`); a build phase surfaces its CRITICAL/HIGH rules to open and account for in the deliverable's `Rule conformance` manifest: `applied` with a `file:line` or test, `deviated` with an ADR, `n/a` with a reason. When a rule and a habit conflict, the rule wins; deviating requires an ADR. `runward check --strict` verifies the manifest is complete — it checks that a decision was traced, never the quality of the code; you judge that at the gate.
 - Consult `runward/decision-matrix.md` before adding any capability: 22 arbitrations, each with a sober default and an explicit trigger. No trigger, no change.
 - Before any structural decision, run `runward/workflows/decision-loop.md`: verify in the real code, check the sourced state of the art, challenge the source, take a durable position, lock it in an ADR — only then edit.
 - One ADR per structural decision, in `runward/adr/`, with a dated re-evaluation trigger. Use the template `runward/adr/ADR-0000-template.md`.

package/templates/workflows/architect.md

@@ -30,6 +30,8 @@ Use this workflow once framing is decided and structure must follow: "how do we
 
 **Lock structuring choices in ADRs.** Starting topology, core language, legacy integration strategy, bounded-context boundaries: each goes through `decision-loop` — reality-check against reference implementations, sourced state of the art, challenge, durable position, written lock. A decision that is not locked does not enter the architecture note.
 
+**Confront the architect craft rules at the point of deciding.** Open the CRITICAL/HIGH rules mapped to the architect phase (`runward/rules/`, `phases: [architect]`): contract governance, the hexagonal architecture and adapter pattern, the single core language, the ADR-and-journal discipline. Do not work from their names — read them. Account for each in the `Rule conformance` manifest of the architecture note: `applied` with a pointer, `deviated` with an ADR, or `n/a` with a reason. `runward check --strict` verifies that manifest.
+
 **Write the architecture note.** Short, readable, decided: the ports, the default topology and its triggers, what stays open (language, provider), and the target named without being built. A few pages, not a detailed design dossier.
 
 ## Definition of Done
@@ -37,6 +39,7 @@ Use this workflow once framing is decided and structure must follow: "how do we
 - Architecture note produced, boundaries first, stack open.
 - Every port named with contract and initial version; integration protocol stated.
 - One ADR per structuring choice, locked before the note mentions it.
+- Every architect CRITICAL/HIGH rule accounted for in the conformance manifest (`runward check --strict`).
 - Note reviewed via `review` before circulation.
 - Deliverable form matched: the presented architecture note carries an expected delivery form (a readable PDF or HTML); ADRs and contract specs stay as repository markdown.
 

package/templates/workflows/floor.md

@@ -21,6 +21,8 @@ Use this workflow once the architecture is fixed and building must start: "what
 
 **Start from the reference floor, not a blank page.** The starting point is the reference floor (`floor-ts/` in the Runward repository): a clonable hexagonal scaffold that already carries the pure domain, the ports, the adapters, and the middleware chain, with a principle-to-code table mapping each principle to where it lives in the code. Clone it, implement the project's concrete adapters behind the ports fixed in `architect`, and leave intact the structure that keeps the domain testable without the model. Do not reinvent the skeleton; populate it.
 
+**Confront the floor's craft rules at the point of building.** Before writing each piece, open the CRITICAL/HIGH rules mapped to the floor phase — `runward/rules/`, frontmatter `phases: [floor]`: the deterministic frontier guard, the model port and its keyless fallback, provider auto-detection, secrets boundary, prompt-injection defense, the hexagonal architecture and adapter pattern, the event-sourced journal, tool-scope atomicity. Do not work from their names — read them. Account for each in the `Rule conformance` manifest of the floor note: `applied` with a `file:line` or test, `deviated` with an ADR, or `n/a` with a reason. `runward check --strict` verifies that manifest is complete and well-formed (it checks that a decision was traced, never the quality of the code — you judge that at the gate).
+
 **Build exactly these six pieces, and nothing more.**
 
 1. **An entry point matched to actual use.** A minimal interface when a human operates the system (submit, review, approve, decide); an API or tool protocol when another system drives it. It is a primary adapter — plain, replaceable, never touching the domain, and never a demo showcase.
@@ -48,6 +50,7 @@ Lock any structuring decision met during the build through `decision-loop`. Writ
 - Value measured against the observable success criterion.
 - A complete trajectory replays from a single request ID.
 - Every deferral named with its trigger.
+- Every floor CRITICAL/HIGH rule accounted for in the conformance manifest (`runward check --strict` clean).
 - Floor note produced and reviewed.
 
 ## Anti-patterns

package/templates/workflows/govern.md

@@ -35,9 +35,12 @@ The chain carries transversal concerns only — no orchestration, no business lo
 
 **Test and evaluate — both.** Build the test pyramid: unit tests without network (pure domain, mocked model adapter); consumer-driven contract tests that catch drift between schema and real data; integration through the injection container with mock adapters; behavioral evaluations at the top. Then run the continuous evaluation loop: sample the trace stream off the hot path; score hybrid — deterministic checks wherever a guarantee exists, an anchored judge model (pinned version or replayed anchor set) only for the irreducibly behavioral, abstention first. The loop is valid only under a **hold-out the optimizer never sees**; self-tuning stays inside a pre-approved, audited envelope or goes through human validation — never autonomous self-rewriting. The hard floor — safety, security, authorization, audit — stays deterministic; never assemble it from soft judgments. Promote a new model via shadow deployment: same port, real traffic, silent; measure divergence with the same evaluation; roll out in stages with instant rollback.
 
+**Confront the govern craft rules.** Open the CRITICAL/HIGH rules mapped to the govern phase (`runward/rules/`, `phases: [govern]`): the evaluation loop, prompt-injection defense, the secrets boundary, fail-open/fail-closed resilience, provider fallback, retry-with-backoff, background-job guardrails. Account for each in the `Rule conformance` manifest of the threat model: `applied` with a pointer, `deviated` with an ADR, or `n/a` with a reason. `runward check --strict` verifies that manifest.
+
 ## Definition of Done
 
 - All transversal concerns pass through the single middleware chain; a trajectory replays from one request ID.
+- Every govern CRITICAL/HIGH rule accounted for in the conformance manifest (`runward check --strict`).
 - Cost ceilings enforced with stop-and-synthesize behavior.
 - Threat model written; two-of-three trifecta rule enforced while untrusted content is in the context window.
 - Test pyramid in place; evaluation loop running with anchored judge and hold-out.

package/templates/workflows/verify.md

@@ -0,0 +1,33 @@
+# Verify — Advisory Cite-vs-Apply Review (above the gate, never in it)
+
+## When to use
+
+Use this **after** `runward check --strict` is green, and before you cross the gate as the operator. The deterministic gate proves a decision was *traced* for every CRITICAL/HIGH rule (applied with a pointer, deviated with an ADR, n/a with a reason). It cannot prove the code an `applied` row points at **actually applies** the rule rather than merely citing it — that is a semantic judgment. This workflow makes that judgment, adversarially, to inform yours.
+
+It is **advisory**. It produces findings, never a verdict that gates. `runward check --strict` stays the load-bearing decision; you cross it. See [ADR-0007].
+
+## Inputs
+
+- The `Rule conformance` manifests (`floor.md`, `architecture.md`, `governance/threat-model.md`).
+- The code each `applied` row points at.
+
+## Procedure
+
+**Challenge each `applied` claim, adversarially.** For every `applied` row, open its evidence (the `file:line` or test) and default to skepticism: *does this code actually apply the rule it names, or does it only cite it?* Judge through distinct lenses — correctness, does-it-reproduce, security-relevance — and, where you can, run this pass on a **different model** than the one that built the floor, so it does not agree with itself.
+
+**Return a finding per row**: `confirmed` (the code applies the rule), `cited-not-applied` (the row claims applied but the code does not carry the rule), or `uncertain` (needs a human look). Deduplicate overlapping findings; group them by severity.
+
+**Hand the findings to the operator.** They are input to the operator's gate decision, not a gate of their own. A `cited-not-applied` finding is a prompt to fix the code (or downgrade the row to `deviated`/`n/a`) and re-run `check --strict` — never a silent override of the deterministic gate.
+
+## Definition of Done
+
+- Every `applied` row reviewed, with a confirmed / cited-not-applied / uncertain finding.
+- Findings handed to the operator; no exit code produced, no gate blocked.
+- Any `cited-not-applied` finding routed back to the code and re-checked deterministically.
+
+## Anti-patterns
+
+- Treating a clean `verify` pass as "the gate passed" — it is advisory; the deterministic `check --strict` is the gate.
+- Wiring `verify` into CI as a blocking step, or into an exit code — it never blocks.
+- Running `verify` **instead of** `check --strict` — it sits above the deterministic gate, it does not replace it.
+- Running it on the same model that wrote the code and trusting the agreement — use a different lens, ideally a different model.