runward 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thibault Souris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,13 @@
+# Notice — tooling vs canon
+
+This repository (CLI, templates, workflows, examples) is licensed under **MIT**. Use it, fork it, contribute to it.
+
+The doctrine **“Designing and Running Agentic Systems”** (Thibault Souris, 2026, registered deposit) is a separate work, published under **CC BY-ND 4.0**. It is the canon this framework implements. Its text is **not** included in this repository and contributions to this repository must not copy its text.
+
+What this means in practice:
+
+- The **ideas and methods** (the six-phase method, the LLM Boundary Principle, floor-first delivery, evolution on triggers, lethal trifecta rule…) are free by nature. This repository implements them; you can too.
+- The **expression** of the doctrine (its text, figures, layout) is protected: you may share the published PDFs unmodified, you may not create derivative versions of the text.
+- Workflows and templates in this repository are original MIT-licensed writings that implement the method. They are the contribution surface.
+
+Doctrine (FR and EN editions): https://github.com/stranxik/designing-and-running-agentic-systems — also at https://thibaultsouris.fr

package/README.md

@@ -0,0 +1,128 @@
+# 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.**
+
+Your agent builds fast. Runward frames what it builds — six gated phases your agent executes and one human signs off — so what ships actually holds.
+
+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.
+
+## Why
+
+Nearly everything that calls itself agentic today dies somewhere between the demo and production. Not because the model is weak, but because nobody can evaluate a non-deterministic behavior, govern it, or say in advance when it fails. These are architecture problems, not model problems. The industry's own signal is unambiguous: model vendors now deploy engineers directly into client organizations, because the bottleneck has moved from the model to its integration into the real world.
+
+Spec-driven frameworks answered the first half of that problem: write the right thing. Nobody structured the second half: ship it, run it, hand it over. That is why Runward exists.
+
+Agentic systems break four assumptions of classical distributed engineering. The core component is **non-deterministic**: same input, different output, by design. **Input is indistinguishable from instruction**: anything the model reads can try to command it, so prompt injection is structural, not a bug to patch. **Forgetting becomes an engineering problem**: memory that only grows drowns the signal, so decay, invalidation and consolidation have to be designed, not hoped for. And the **blast radius is unprecedented**: an agent with tools acts on the world, so a bad output is no longer just a bad answer.
+
+Runward's answer opens with a founding inversion — the **LLM Boundary Principle**: the architecture constrains the model, never the other way around. That opening posture unfolds into five gestures: boundaries before the stack; start simple, isolate by contract, grow on evidence; keep the deterministic out of the model; explicit state and governed memory; govern, trace and evaluate from day zero. The full base is the method itself: six gated phases (a gate: a checkpoint you cross on evidence, never on assertion), each with a Definition of Ready and a Definition of Done, a 22-arbitration decision matrix, and 51 craft rules. The inversion opens the method; the phases, gestures and rules are what carry it.
+
+## Who it's for — and when
+
+Three profiles, three doors into the same method:
+
+| You are | Where you enter |
+|---|---|
+| **A tech lead with a working prototype** that must now hold production | The brownfield workflow: characterize the existing system before touching anything |
+| **An operator or consultant delivering an agentic system for a client**, especially in a regulated sector | Frame: day one is a conversation with your sponsor, not code |
+| **A team finishing a spec** with Spec Kit, OpenSpec or BMAD | Your spec becomes the input of framing; the gates continue from there |
+
+**When NOT to use it.** An already-specified tooling request with no production stakes. Recurring operations — Runward hands over, it does not operate. A pure content or assistant use case, with no tools and no blast radius. And if you want a framework that decides for you: Runward makes *you* decide, at every gate.
+
+**Monday morning.** Install, run `runward init`, and fill `runward/framing.md` with your sponsor — a conversation, not code. Day one produces a framing note and a mission contract. The first code you write is the floor — weeks in, not months.
+
+**The honest timeline** — the one the mission contract states. Framing takes days. An executable floor takes weeks. Iteration is paced by evidence, and handover ends the mission. No dates promised; gates crossed on proof.
+
+The cost is discipline: one accountable operator, governance from day zero, and every structural decision written as an ADR (Architecture Decision Record: a dated, locked decision with a re-evaluation trigger). The longer version — the three entry scenarios told concretely, the anti-cases, what you hold at the end — is in [When to use Runward, and when not to](docs/when-to-use.md).
+
+## Install
+
+```bash
+npx runward init                 # interactive wizard
+npx runward --yes init           # non-interactive, defaults (CI-friendly)
+npx runward init --tools claude,cursor,copilot,gemini,windsurf
+```
+
+New here? Follow [your first mission in 15 minutes](docs/first-mission.md).
+
+### Commands
+
+| Command | What it does |
+|---|---|
+| `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 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` |
+
+Global flags: `--yes`, `--dry-run`, `--verbose`, `--no-color`. Exit codes: 0 success, 1 gaps/warnings, 2 missing prerequisite.
+
+`init` creates:
+
+```
+your-project/
+├── AGENTS.md                    # vendor-neutral agent charter (the "law" file)
+├── runward/
+│   ├── framing.md               # problem, value, observable success criterion, floor vs target
+│   ├── mission-contract.md      # one-page steering contract: engagements, DoD, gates
+│   ├── architecture.md          # boundaries, ports, integration protocol — stack stays open
+│   ├── decision-matrix.md       # 22 arbitrations: one sober default + one explicit trigger each
+│   ├── reference-stack.md       # default adapter kit per layer, with evolution triggers
+│   ├── shared-bricks.md         # bricks beyond the app: placement families, brick matrix, sovereignty by data class
+│   ├── floor.md                 # the smallest system that proves value on real traffic
+│   ├── adr/                     # one ADR per structural decision, with re-evaluation trigger
+│   ├── rules/                   # 51 craft rules your agent applies while building
+│   ├── governance/
+│   │   ├── threat-model.md      # lethal trifecta, 2-of-3 rule on the context window
+│   │   ├── evaluation-rubric.md # test the deterministic, evaluate the non-deterministic
+│   │   └── observability-schema.md
+│   ├── contracts/               # port contracts (versioned, additive, tolerant reader)
+│   ├── runbook.md               # recovery runbook for the team that inherits the system
+│   └── workflows/               # the method, executable by your agent
+└── .claude/ | .cursor/          # tool profiles (--tools)
+```
+
+## The method: six phases, gated
+
+Each phase has entry conditions (Definition of Ready) and a Definition of Done. You do not move on assertion; you move on evidence.
+
+| Phase | Output | Done when |
+|---|---|---|
+| 1. Frame | `framing.md` | Sponsor validates the observable success criterion and the floor scope |
+| 2. Architect | `architecture.md` + ADRs | Boundaries decided, stack still open |
+| 3. Ship the floor | Running system + `floor.md` | First measured proof against the criterion, on real cases |
+| 4. Iterate on evidence | Increments + ADRs | Every addition traced to an objective trigger |
+| 5. Govern & evaluate | Threat model, rubric, observability | Instrumented from day zero, never retrofitted |
+| 6. Hand over | Handover kit | The team redoes a task autonomously — demonstrated, not declared |
+
+Phase 5 is transverse: it starts at day zero, not after the incident.
+
+## What makes it different
+
+- **Floor, not MVP deck.** The floor is the smallest *running* system that proves value on real traffic. A presentation is not a floor.
+- **Evolution on evidence.** Multi-agent, long-term memory, microservices, a bigger model: each has a sober default and an explicit trigger. No trigger, no complexity. Every switch is an ADR.
+- **Security by architecture, not detection.** Prompt injection is constrained structurally (lethal trifecta, 2-of-3 rule), not filtered heuristically.
+- **Craft rules, not vibes.** 51 engineering craft rules ship with the mission (memory scoring, tiered retrieval, event sourcing, request-id propagation, multi-provider fallback, cost routing, post-turn pipelines, prompt-injection defenses…) — your agent applies them, `runward check` will not invent them. Code examples follow the reference-stack default (a single language in the core — TypeScript by default, an adapter decision like any other: see the decision matrix). The patterns are the contract; the language is the adapter.
+- **One accountable operator, not a simulated team.** One human owns every gate while the agent executes the workflows — see [the operator role](docs/operator-role.md).
+- **Handover as a deliverable.** The mission ends when the receiving team is autonomous, with proof.
+
+## The reference floor
+
+`floor-ts/` is a clonable scaffold that implements the Runward defaults: hexagonal core, the model behind a port (a port: a stable contract behind which implementations swap — here a deterministic echo adapter by default, zero keys, zero network), provider profiles keyed on base URL, middleware chain (logging, access, cost cap, approval), day-zero cost ceiling, secrets redaction, per-call prompt provenance (a SHA-256 of every prompt), suspend-and-rehydrate on human approval, full test pyramid and an evaluation harness. It is expressed in TypeScript because it implements the reference-stack defaults — one language in the core, and which one is an adapter decision like any other. The durable part is what it demonstrates: the ports, the contracts, the middleware chain, the deterministic guard. Port them to your language and the architecture survives. Its README maps each principle to the exact file that implements it. Start a floor by cloning it, not from a blank page.
+
+## Relationship to the canon
+
+Runward is the tooling of the doctrine **“Designing and Running Agentic Systems”** (Thibault Souris, 2026) — a 60-page architecture reference, published separately under CC BY-ND 4.0 in [its own repository](https://github.com/stranxik/designing-and-running-agentic-systems). The doctrine is the canon: read it for the *why*. Runward is MIT: fork it, adapt it, contribute. See [NOTICE.md](NOTICE.md).
+
+Read the doctrine: [Concevoir et exécuter des systèmes agentiques (FR)](https://github.com/stranxik/designing-and-running-agentic-systems/blob/main/Concevoir-et-executer-des-systemes-agentiques-2026.pdf) · [Designing and Running Agentic Systems (EN)](https://github.com/stranxik/designing-and-running-agentic-systems/blob/main/Designing-and-Running-Agentic-Systems-2026.pdf)
+
+## Supported tools
+
+Tool profiles: **Claude Code** (slash commands `/rw-*`), **Cursor** (rules), **GitHub Copilot** (instructions), **Gemini CLI** (GEMINI.md), **Windsurf** (rules). `AGENTS.md` is always written — it is the vendor-neutral standard read by Codex CLI, opencode, Amp and a growing list of agents, so the method works even without a dedicated profile. The mission structure itself is plain markdown in your repo. More profiles welcome (see [ROADMAP.md](ROADMAP.md)).
+
+## License
+
+MIT © Thibault Souris. The doctrine text is licensed separately (CC BY-ND 4.0) and is **not** included in this repository.

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Runward CLI — after the spec: ship and run.
+ * Commands: init (wizard), check (gate audit), status, doctor, update.
+ */
+import { Command } from "commander";
+import { VERSION } from "./lib/paths.js";
+import { c } from "./lib/styles.js";
+import { initCommand } from "./commands/init.js";
+import { checkCommand } from "./commands/check.js";
+import { statusCommand } from "./commands/status.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { updateCommand } from "./commands/update.js";
+// Exit codes: 0 = success · 1 = gaps/warnings · 2 = missing prerequisite
+process.on("uncaughtException", (err) => {
+    if (err.name === "ExitPromptError")
+        process.exit(130); // Ctrl+C in a prompt
+    console.error("\n  " + c.error("✗") + " Unexpected error: " + err.message);
+    if (process.env.VERBOSE)
+        console.error(err.stack);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("\n  " + c.error("✗") + " Async error: " + (reason?.message || reason));
+    if (process.env.VERBOSE)
+        console.error(reason?.stack);
+    process.exit(1);
+});
+const program = new Command();
+program
+    .name("runward")
+    .description("After the spec: ship and run. Delivery framework for agentic systems.")
+    .version(VERSION)
+    .option("--no-color", "disable colored output")
+    .option("--verbose", "detailed logs")
+    .option("--yes", "non-interactive: accept all defaults (CI)")
+    .option("--dry-run", "print planned actions without writing")
+    .hook("preAction", (cmd) => {
+    const opts = cmd.opts();
+    if (opts.color === false)
+        process.env.NO_COLOR = "1";
+    if (opts.verbose)
+        process.env.VERBOSE = "1";
+    if (opts.yes)
+        process.env.RUNWARD_YES = "1";
+    if (opts.dryRun)
+        process.env.RUNWARD_DRY_RUN = "1";
+});
+program
+    .command("init")
+    .description("scaffold the mission structure (interactive wizard, or --yes)")
+    .option("-p, --path <path>", "project directory (default: prompt, or . with --yes)")
+    .option("-t, --tools <list>", "comma-separated tool profiles: claude,cursor,copilot,gemini,windsurf")
+    .option("--force", "overwrite existing files")
+    .action(initCommand);
+program
+    .command("check")
+    .description("can I cross the gate — gate audit, exit 1 on gaps (CI-friendly)")
+    .option("-p, --path <path>", "project directory")
+    .action(checkCommand);
+program
+    .command("status")
+    .description("where am I — mission snapshot: current gate, decision journal, workflows")
+    .option("-p, --path <path>", "project directory")
+    .action(statusCommand);
+program
+    .command("doctor")
+    .description("environment and installation checks")
+    .action(doctorCommand);
+program
+    .command("update")
+    .description("refresh runward/workflows/ and runward/rules/ from this package version (mission state untouched)")
+    .option("-p, --path <path>", "project directory")
+    .option("--force", "overwrite locally modified workflows")
+    .action(updateCommand);
+program.parseAsync();

package/dist/commands/check.js

@@ -0,0 +1,50 @@
+import { join } from "node:path";
+import { analyze, findMissionRoot } from "../lib/mission.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.
+ * Exit codes: 0 = current gate clean, 1 = gaps, 2 = no mission found.
+ */
+export async function checkCommand(opts) {
+    const root = findMissionRoot(join(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 report = analyze(mission);
+    console.log(createHeader(`Runward v${VERSION} — gate audit`, root));
+    const glyph = {
+        "filled": c.success("✓"),
+        "in-progress": c.warning("◐"),
+        "untouched": c.darkGray("○"),
+        "missing": c.error("✗"),
+    };
+    const legendNote = {
+        "filled": "",
+        "in-progress": c.warning(" — placeholders remain"),
+        "untouched": c.darkGray(" — raw template"),
+        "missing": c.error(" — file missing"),
+    };
+    let gaps = 0;
+    for (const phase of report.phases) {
+        console.log(section(phase.spec.label));
+        for (const { artifact, state } of phase.artifacts) {
+            console.log(`  ${glyph[state]} ${c.white(artifact.label)} ${c.darkGray(`(runward/${artifact.relPath})`)}${legendNote[state]}`);
+            if (state !== "filled")
+                gaps++;
+        }
+    }
+    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) {
+        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.`));
+        process.exitCode = 1;
+    }
+}

package/dist/commands/doctor.js

@@ -0,0 +1,75 @@
+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 { findMissionRoot } from "../lib/mission.js";
+import { createHeader, section, status } from "../lib/styles.js";
+/**
+ * Environment and installation checks.
+ * Exit codes: 0 = all good, 1 = warnings, 2 = critical failure.
+ */
+export async function doctorCommand() {
+    console.log(createHeader(`Runward v${VERSION} — doctor`));
+    let warnings = 0;
+    let critical = 0;
+    const ok = (msg) => console.log("  " + status.success(msg));
+    const warn = (msg) => { warnings++; console.log("  " + status.warning(msg)); };
+    const fail = (msg) => { critical++; console.log("  " + status.error(msg)); };
+    console.log(section("Environment"));
+    const nodeMajor = Number(process.versions.node.split(".")[0]);
+    nodeMajor >= 20 ? ok(`node ${process.versions.node}`) : fail(`node ${process.versions.node} — v20+ required`);
+    try {
+        const git = execFileSync("git", ["--version"], { encoding: "utf8" }).trim();
+        ok(git);
+    }
+    catch {
+        warn("git not found — the method assumes versioned mission artifacts");
+    }
+    console.log(section("Package integrity"));
+    const missingTpl = Object.keys(MISSION_LAYOUT).filter((k) => !existsSync(join(TEMPLATES, "mission", k)));
+    missingTpl.length === 0 ? ok(`${Object.keys(MISSION_LAYOUT).length} mission templates`) : fail(`missing templates: ${missingTpl.join(", ")}`);
+    const missingWf = WORKFLOWS.filter((wf) => !existsSync(join(TEMPLATES, "workflows", `${wf}.md`)));
+    missingWf.length === 0 ? ok(`${WORKFLOWS.length} workflows`) : fail(`missing workflows: ${missingWf.join(", ")}`);
+    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}`);
+    console.log(section("Current directory"));
+    const root = findMissionRoot(process.cwd());
+    if (!root) {
+        warn("no runward/ mission here — `runward init` to scaffold one");
+    }
+    else {
+        ok(`mission found at ${root}`);
+        existsSync(join(root, "AGENTS.md")) ? ok("AGENTS.md charter present") : warn("AGENTS.md missing — re-run `runward init`");
+        const gitDir = join(root, ".git");
+        existsSync(gitDir) ? ok("mission is under git") : warn("mission is not a git repository — ADRs and gates should be versioned");
+        const profiles = [];
+        if (existsSync(join(root, ".claude", "commands")) &&
+            readdirSync(join(root, ".claude", "commands")).some((f) => f.startsWith("rw-")))
+            profiles.push("claude");
+        if (existsSync(join(root, ".cursor", "rules", "runward.mdc")))
+            profiles.push("cursor");
+        if (existsSync(join(root, ".github", "copilot-instructions.md")))
+            profiles.push("copilot");
+        if (existsSync(join(root, "GEMINI.md")))
+            profiles.push("gemini");
+        if (existsSync(join(root, ".windsurf", "rules", "runward.md")))
+            profiles.push("windsurf");
+        profiles.length > 0
+            ? ok(`tool profiles: ${profiles.join(", ")}`)
+            : warn("no tool profile detected — AGENTS.md still works with agents that read it");
+    }
+    console.log(section("Verdict"));
+    if (critical > 0) {
+        console.log("  " + status.error(`${critical} critical issue(s), ${warnings} warning(s)`));
+        process.exit(2);
+    }
+    else if (warnings > 0) {
+        console.log("  " + status.warning(`${warnings} warning(s)`));
+        process.exitCode = 1;
+    }
+    else
+        console.log("  " + status.success("all checks passed"));
+    console.log();
+}

package/dist/commands/init.js

@@ -0,0 +1,90 @@
+import { join } from "node:path";
+import { readdirSync } from "node:fs";
+import { checkbox, input, select } from "@inquirer/prompts";
+import { TEMPLATES, MISSION_LAYOUT, VERSION } from "../lib/paths.js";
+import { TOOL_PROFILES, TOOL_IDS } from "../lib/tools.js";
+import { makeWriter } from "../lib/write.js";
+import { c, createHeader, isNonInteractive, section, status } from "../lib/styles.js";
+export async function initCommand(opts) {
+    console.log(createHeader(`Runward v${VERSION}`, "After the spec: ship and run"));
+    const yes = isNonInteractive();
+    const dryRun = process.env.RUNWARD_DRY_RUN === "1";
+    // ── Gather answers (wizard, or defaults with --yes) ──────────────
+    const dir = opts.path
+        ?? (yes ? "." : await input({ message: "Project directory", default: "." }));
+    // The idea seeds the framing note: you arrive with a project, not with paperwork.
+    const idea = yes ? "" : await input({
+        message: "What are you building? (one line — it seeds your framing note)",
+        default: "",
+    });
+    const tools = opts.tools !== undefined
+        ? opts.tools.split(",").map((s) => s.trim()).filter(Boolean)
+        : yes
+            ? ["claude"]
+            : await checkbox({
+                message: "Tool profiles (AGENTS.md is always written)",
+                choices: TOOL_PROFILES.map((t) => ({ value: t.id, name: t.label, checked: t.id === "claude" })),
+            });
+    const entryMode = yes ? "greenfield" : await select({
+        message: "Entry mode",
+        choices: [
+            { value: "greenfield", name: "Greenfield — new system, run the chain from the top" },
+            { value: "brownfield", name: "Brownfield — existing system, characterize before touching" },
+        ],
+    });
+    const tier = yes ? "floor" : await select({
+        message: "Stopping tier (the sponsor's choice — can be revised)",
+        choices: [
+            { value: "framing", name: "Framing only" },
+            { value: "floor", name: "Executable floor, proven on real traffic" },
+            { value: "full chain", name: "Full chain through handover" },
+        ],
+    });
+    const unknown = tools.filter((t) => !TOOL_IDS.includes(t));
+    for (const t of unknown)
+        console.log(status.warning(`Unknown tool profile "${t}" — supported: ${TOOL_IDS.join(", ")}`));
+    // ── Write ─────────────────────────────────────────────────────────
+    const root = join(process.cwd(), dir);
+    const mission = join(root, "runward");
+    const w = makeWriter({ force: opts.force ?? false, dryRun, root });
+    console.log(section("Mission structure"));
+    const prefill = (s) => {
+        let out = s
+            .replace("[greenfield | brownfield M1–M4]", entryMode)
+            .replace("[framing | floor | full chain]", tier);
+        if (idea) {
+            out = out
+                .replace("[system or mission name]", idea)
+                .replace("## 1. Problem\n", `## 1. Problem\n\n> Seed idea (from init): "${idea}" — now replace this with the process as actually observed.\n`);
+        }
+        return out;
+    };
+    for (const [src, dest] of Object.entries(MISSION_LAYOUT)) {
+        w.copy(join(TEMPLATES, "mission", src), join(mission, dest), src === "framing.md" ? prefill : undefined);
+    }
+    console.log(section("Workflows"));
+    for (const wf of readdirSync(join(TEMPLATES, "workflows"))) {
+        w.copy(join(TEMPLATES, "workflows", wf), join(mission, "workflows", wf));
+    }
+    console.log(section("Craft rules"));
+    const rules = readdirSync(join(TEMPLATES, "rules"));
+    for (const r of rules) {
+        w.copy(join(TEMPLATES, "rules", r), join(mission, "rules", r));
+    }
+    console.log(section("Agent charter"));
+    w.copy(join(TEMPLATES, "targets", "AGENTS.md"), join(root, "AGENTS.md"));
+    for (const profile of TOOL_PROFILES.filter((p) => tools.includes(p.id))) {
+        console.log(section(`Profile · ${profile.label}`));
+        for (const f of profile.files(root))
+            w.write(f.path, f.content);
+    }
+    // ── Summary ───────────────────────────────────────────────────────
+    console.log(section("Done"));
+    console.log(status.success(`${w.stats.written} file(s) ${dryRun ? "planned" : "written"}, ${w.stats.skipped} skipped`));
+    console.log(`
+${c.primaryBold("Next steps")}
+  1. Fill ${c.white("runward/framing.md")} — do not architect before the framing gate passes.
+  2. Point your agent at ${c.white("AGENTS.md")} and ${c.white("runward/workflows/method.md")}.
+  3. Run ${c.primary("runward check")} anytime to see which gate you are at.
+${entryMode === "brownfield" ? c.warning("\n  Brownfield entry: start with runward/workflows/brownfield.md — characterize before touching.\n") : ""}`);
+}

package/dist/commands/status.js

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { analyze, findMissionRoot } from "../lib/mission.js";
+import { c, createHeader, section } from "../lib/styles.js";
+import { VERSION, WORKFLOWS } from "../lib/paths.js";
+/** Mission snapshot: phase, ADR journal, framing summary, workflow presence. */
+export async function statusCommand(opts) {
+    const root = findMissionRoot(join(process.cwd(), opts.path ?? "."));
+    if (!root) {
+        console.error(c.error("✗ ") + "No runward/ mission found. Run `runward init` first.");
+        process.exit(2);
+    }
+    const mission = join(root, "runward");
+    const report = analyze(mission);
+    console.log(createHeader(`Runward v${VERSION} — mission status`, root));
+    // Framing summary: first line of Problem + success criterion heading state
+    console.log(section("Mission"));
+    const framingPath = join(mission, "framing.md");
+    if (existsSync(framingPath)) {
+        const title = readFileSync(framingPath, "utf8").split("\n")[0]?.replace(/^#\s*/, "") ?? "";
+        console.log(`  ${c.white(title)}`);
+    }
+    console.log(`  ${c.primaryBold("Current gate")}  ${c.white(report.currentPhase)}`);
+    console.log(section("Decision journal"));
+    const adrDir = join(mission, "adr");
+    const adrs = existsSync(adrDir)
+        ? readdirSync(adrDir).filter((f) => /^ADR-\d+/.test(f) && !f.includes("0000")).sort()
+        : [];
+    if (adrs.length === 0) {
+        console.log(c.darkGray("  no ADR yet — every structural decision must be locked"));
+    }
+    else {
+        for (const f of adrs.slice(-5)) {
+            // Date the ADR from its own `**Date**:` line; fall back to file mtime.
+            const dateLine = readFileSync(join(adrDir, f), "utf8").match(/^\*\*Date\*\*:\s*(\d{4}-\d{2}-\d{2})/m);
+            const date = dateLine ? dateLine[1] : statSync(join(adrDir, f)).mtime.toISOString().slice(0, 10);
+            console.log(`  ${c.primary("•")} ${c.white(f)} ${c.darkGray(date)}`);
+        }
+        if (adrs.length > 5)
+            console.log(c.darkGray(`  … and ${adrs.length - 5} more`));
+    }
+    console.log(section("Workflows"));
+    const missing = WORKFLOWS.filter((wf) => !existsSync(join(mission, "workflows", `${wf}.md`)));
+    if (missing.length === 0)
+        console.log(c.success("  ✓ ") + c.white(`all ${WORKFLOWS.length} workflows present`));
+    else
+        console.log(c.warning("  ! ") + c.white(`missing: ${missing.join(", ")} — run \`runward update\``));
+    console.log();
+}

package/dist/commands/update.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { TEMPLATES, VERSION } from "../lib/paths.js";
+import { findMissionRoot } from "../lib/mission.js";
+import { makeWriter } from "../lib/write.js";
+import { c, createHeader, section, status } from "../lib/styles.js";
+/**
+ * Refresh runward/workflows/ and runward/rules/ from the installed package.
+ * Never touches mission state (framing, architecture, ADRs, governance).
+ * Local edits are preserved unless --force.
+ */
+export async function updateCommand(opts) {
+    const root = findMissionRoot(join(process.cwd(), opts.path ?? "."));
+    if (!root) {
+        console.error(status.error("No runward/ mission found. Run `runward init` first."));
+        process.exit(2);
+    }
+    const dryRun = process.env.RUNWARD_DRY_RUN === "1";
+    console.log(createHeader(`Runward v${VERSION} — update workflows & rules`, root));
+    let same = 0, drifted = 0, added = 0;
+    const w = makeWriter({ force: true, dryRun, root });
+    for (const dir of ["workflows", "rules"]) {
+        console.log(section(dir === "workflows" ? "Workflows" : "Craft rules"));
+        const dest = join(root, "runward", dir);
+        for (const file of readdirSync(join(TEMPLATES, dir))) {
+            const src = readFileSync(join(TEMPLATES, dir, file), "utf8");
+            const destPath = join(dest, file);
+            if (!existsSync(destPath)) {
+                w.write(destPath, src);
+                added++;
+            }
+            else if (readFileSync(destPath, "utf8") === src) {
+                same++;
+            }
+            else if (opts.force) {
+                w.write(destPath, src);
+                drifted++;
+            }
+            else {
+                drifted++;
+                console.log(`  ${c.warning("drift")} ${c.white(`runward/${dir}/${file}`)} ${c.darkGray("(locally modified — --force to overwrite)")}`);
+            }
+        }
+    }
+    console.log(section("Summary"));
+    console.log(`  ${status.success(`${same} up to date`)}   ${added ? status.info(`${added} added`) + "   " : ""}${drifted ? status.warning(`${drifted} drifted${opts.force ? " (overwritten)" : ""}`) : ""}`);
+    console.log(c.darkGray("\n  Mission state (framing, architecture, ADRs, governance) is never touched by update.\n"));
+}

package/dist/lib/constants.js

@@ -0,0 +1,2 @@
+/** Total number of craft rules shipped under templates/rules/. */
+export const EXPECTED_RULES = 51;