runward 0.13.0 → 0.13.2

package/README.md

@@ -137,7 +137,9 @@ Read the doctrine: [Concevoir et exécuter des systèmes agentiques (FR)](https:
 
 ## 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)).
+Two vendor-neutral files are **always written**, so the method works on any agent with no profile at all: `AGENTS.md` (the standard charter read by Codex, Cursor, Copilot, Windsurf, Cline, Zed, Amp, opencode, Junie, Warp and more), and the **phase skills** at `.agents/skills/runward-<phase>/SKILL.md` — the converged `SKILL.md` seam read by 14+ harnesses, which surface each build phase's craft rules *by relevance* at the point of action (subordinate to the gate: a skill loaded but not applied still fails `check --strict`).
+
+Tool profiles (`--tools`) add harness-specific wiring on top: **Claude Code** (`/rw-*` commands + `.claude/skills/`), **Cursor**, **GitHub Copilot**, **Gemini CLI**, **Windsurf** (charter files), **Continue.dev** (`.continue/rules/`), **JetBrains Junie** and **Trae** (`.<harness>/skills/`). The mission structure itself is plain markdown in your repo. More profiles welcome (see [ROADMAP.md](ROADMAP.md)).
 
 ## License
 

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import { join, resolve } from "node:path";
 import { readdirSync } from "node:fs";
 import { checkbox, input, select } from "@inquirer/prompts";
 import { TEMPLATES, EXAMPLE_MISSION, MISSION_LAYOUT, VERSION } from "../lib/paths.js";
-import { TOOL_PROFILES, TOOL_IDS } from "../lib/tools.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). */
@@ -100,6 +100,10 @@ export async function initCommand(opts) {
     }
     console.log(section("Agent charter"));
     w.copy(join(TEMPLATES, "targets", "AGENTS.md"), join(root, "AGENTS.md"));
+    // Vendor-neutral phase skills (ADR-0018): the converged SKILL.md alias read by 14+ harnesses.
+    console.log(section("Phase skills (.agents/skills — vendor-neutral, relevance-loaded)"));
+    for (const f of baselineSkills(root))
+        w.write(f.path, f.content);
     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))

package/dist/commands/status.js

@@ -3,7 +3,8 @@ import { join, resolve } 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. */
+/** Mission snapshot: phase progress, decision journal, activity, workflows —
+ *  a transmission-ready "where the mission stands", read-only from the mission files. */
 export async function statusCommand(opts) {
     const root = findMissionRoot(resolve(process.cwd(), opts.path ?? "."));
     if (!root) {
@@ -13,7 +14,7 @@ export async function statusCommand(opts) {
     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
+    // Mission title + current gate
     console.log(section("Mission"));
     const framingPath = join(mission, "framing.md");
     if (existsSync(framingPath)) {
@@ -21,6 +22,25 @@ export async function statusCommand(opts) {
         console.log(`  ${c.white(title)}`);
     }
     console.log(`  ${c.primaryBold("Current gate")}  ${c.white(report.currentPhase)}`);
+    // Phase progress across the gated arc — where the mission stands, gate by gate
+    console.log(section("Phase progress"));
+    const currentIndex = report.phases.findIndex((p) => !p.complete);
+    report.phases.forEach((p, i) => {
+        const filled = p.artifacts.filter((a) => a.state === "filled").length;
+        const total = p.artifacts.length;
+        const isCurrent = i === currentIndex;
+        const mark = p.complete ? c.success("✓") : isCurrent ? c.primary("▸") : c.darkGray("○");
+        const label = p.complete ? c.white(p.spec.label) : isCurrent ? c.primaryBold(p.spec.label) : c.gray(p.spec.label);
+        const count = p.complete ? c.darkGray(`${filled}/${total}`) : c.white(`${filled}/${total}`);
+        console.log(`  ${mark} ${label}  ${count}${isCurrent ? c.primary("  ← you are here") : ""}`);
+        // Under the current phase, name exactly what is still open.
+        if (isCurrent) {
+            for (const a of p.artifacts.filter((a) => a.state !== "filled")) {
+                console.log(`      ${c.darkGray("○")} ${c.gray(a.artifact.label)} ${c.darkGray(`(${a.state})`)}`);
+            }
+        }
+    });
+    // Decision journal — the ADRs, dated
     console.log(section("Decision journal"));
     const adrDir = join(mission, "adr");
     const adrs = existsSync(adrDir)
@@ -38,12 +58,44 @@ export async function statusCommand(opts) {
         }
         if (adrs.length > 5)
             console.log(c.darkGray(`  … and ${adrs.length - 5} more`));
+        console.log(c.darkGray(`  ${adrs.length} decision(s) traced`));
+    }
+    // Activity — the most recently touched deliverable, so a receiving team sees the last movement
+    console.log(section("Activity"));
+    let latest = null;
+    for (const p of report.phases) {
+        for (const a of p.artifacts) {
+            const abs = join(mission, a.artifact.relPath);
+            if (!existsSync(abs))
+                continue;
+            const st = statSync(abs);
+            if (!st.isFile())
+                continue;
+            const date = st.mtime.toISOString().slice(0, 10);
+            if (!latest || date > latest.date)
+                latest = { date, label: a.artifact.label };
+        }
     }
+    if (latest)
+        console.log(`  ${c.primaryBold("Last touched")}  ${c.white(latest.date)}  ${c.darkGray(latest.label)}`);
+    else
+        console.log(c.darkGray("  no deliverable written yet"));
+    // Workflows
     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\``));
+    // Next — the transmission surface: name the next gesture, never leave the reader guessing
+    console.log(section("Next"));
+    if (currentIndex === -1) {
+        console.log(`  All gated deliverables are filled. Run ${c.primary("runward check --strict")} to confirm on evidence, then ${c.primary("runward compliance <regime>")} for the evidence pack.`);
+    }
+    else {
+        const cur = report.phases[currentIndex];
+        const open = cur.artifacts.filter((a) => a.state !== "filled").length;
+        console.log(`  Fill the ${open} open deliverable(s) in ${c.white(cur.spec.label)}, then run ${c.primary("runward check")} to cross the gate on evidence.`);
+    }
     console.log();
 }

package/dist/lib/tools.js

@@ -17,11 +17,61 @@ const rulesBody = [
     "with a dated re-evaluation trigger. Complexity is added only on an objective trigger — no trigger, no change.",
     "",
 ].join("\n");
+const PHASE_SKILLS = [
+    {
+        phase: "architect", label: "architecture",
+        when: "posing the architecture of an agentic system: domain ports, the model boundary, the integration protocol, or any structural design decision taken before the stack",
+    },
+    {
+        phase: "topology", label: "execution topology",
+        when: "deciding where each port's adapter runs and under which data sovereignty: placement family, the secrets/network boundary, or third-party trace export",
+    },
+    {
+        phase: "floor", label: "the executable floor",
+        when: "building the smallest executable floor: the single orchestrator, the model port, deterministic guards, persistence, or baseline observability",
+    },
+    {
+        phase: "govern", label: "governance",
+        when: "governing an agentic system: the threat model, prompt-injection defense, evaluation, observability, resilience, or any sensitive-action approval",
+    },
+];
+/** The shared body — identical guidance across harnesses; only the packaging frontmatter differs. */
+const skillBody = (s) => [
+    `# Runward — ${s.label} craft`,
+    "",
+    `Use this when ${s.when}.`,
+    "",
+    `Confront the CRITICAL/HIGH craft rules mapped to the \`${s.phase}\` phase in \`runward/rules/\` — each rule's \`phases:\` frontmatter declares where it applies — at the point of action, not from memory. Account for each in the deliverable's \`## Rule conformance\` manifest: \`applied\` with a \`file:line\` or test, \`deviated\` with an ADR, or \`n/a\` with a reason.`,
+    "",
+    "This skill helps you *apply* the rules; it does not enforce them. `runward check --strict` is the sole authority and verifies the manifest deterministically. A rule surfaced here but not accounted for still fails the gate.",
+    "",
+].join("\n");
+/** SKILL.md open-format: name + description (the relevance trigger) + body. */
+const skillMd = (s) => [
+    "---",
+    `name: runward-${s.phase}`,
+    `description: Runward ${s.label} craft rules. Use when ${s.when}.`,
+    "---",
+    "",
+    skillBody(s),
+].join("\n");
+/** Emit the four phase skills as SKILL.md folders under `<root>/<...dir>/runward-<phase>/SKILL.md`. */
+const skillsAt = (root, ...dir) => PHASE_SKILLS.map((s) => ({ path: join(root, ...dir, `runward-${s.phase}`, "SKILL.md"), content: skillMd(s) }));
+/**
+ * The vendor-neutral phase skills at `.agents/skills/` — the converged SKILL.md alias read by
+ * 14+ harnesses, no agent privileged. Always written alongside AGENTS.md, like the rules.
+ */
+export function baselineSkills(root) {
+    return skillsAt(root, ".agents", "skills");
+}
 export const TOOL_PROFILES = [
     {
         id: "claude",
-        label: "Claude Code (.claude/commands/rw-*)",
-        files: (root) => WORKFLOWS.map((wf) => ({ path: join(root, ".claude", "commands", `rw-${wf}.md`), content: pointer(wf) })),
+        label: "Claude Code (.claude/commands/rw-* + .claude/skills/)",
+        files: (root) => [
+            ...WORKFLOWS.map((wf) => ({ path: join(root, ".claude", "commands", `rw-${wf}.md`), content: pointer(wf) })),
+            ...skillsAt(root, ".claude", "skills"),
+        ],
     },
     {
         id: "cursor",
@@ -55,5 +105,25 @@ export const TOOL_PROFILES = [
                 content: "# Runward\n\n" + rulesBody,
             }],
     },
+    {
+        id: "continue",
+        label: "Continue.dev (.continue/rules/runward-*)",
+        files: (root) => PHASE_SKILLS.map((s) => ({
+            path: join(root, ".continue", "rules", `runward-${s.phase}.md`),
+            content: ["---", `name: Runward ${s.label} craft`, `description: Use when ${s.when}.`, "alwaysApply: false", "---", "", skillBody(s)].join("\n"),
+        })),
+    },
+    {
+        id: "junie",
+        label: "JetBrains Junie (.junie/skills/)",
+        files: (root) => skillsAt(root, ".junie", "skills"),
+    },
+    {
+        id: "trae",
+        label: "Trae (.trae/skills/)",
+        files: (root) => skillsAt(root, ".trae", "skills"),
+    },
 ];
 export const TOOL_IDS = TOOL_PROFILES.map((t) => t.id);
+/** The gated build phases that get a relevance-loaded phase skill (ADR-0018). */
+export const SKILL_PHASES = PHASE_SKILLS.map((s) => s.phase);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runward",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "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",

package/templates/targets/AGENTS.md

@@ -17,6 +17,7 @@ This project is delivered with the Runward method: floor first, evolution on evi
 - 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`.
 - Current phase and gates: see `runward/framing.md` (Definition of Ready) and each workflow's Definition of Done. Do not skip a gate on assertion; pass it on evidence.
+- Offer to wire the gate at your harness's lifecycle seam — git `pre-commit`, a CI required check, or a turn-end hook — from the inert samples in `runward/adapters/` (its README has the exact command). Propose it to the operator and act only on their explicit approval; never wire it silently. runward installs nothing itself (ADR-0012): you are the operator's hands, and the operator owns the gate.
 - Show before you build: for any deliverable meant for humans, produce a reviewable preview first.
 - Never mark a phase done if its Definition of Done is not demonstrably met.