runward 0.13.1 → 0.13.3

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/check.js

@@ -1,6 +1,7 @@
 import { join, resolve } from "node:path";
 import { analyze, findMissionRoot } from "../lib/mission.js";
 import { conformance, driftReport, unratifiedAdrs, decisionCoverage } from "../lib/conformance.js";
+import { behavioralProof } from "../lib/behavioral-proof.js";
 import { runHooks } from "../lib/hooks.js";
 import { c, createHeader, section, status } from "../lib/styles.js";
 import { VERSION } from "../lib/paths.js";
@@ -96,6 +97,27 @@ export async function checkCommand(opts) {
             strictGaps += unratified.length;
         }
         if (checked > 0 && strictGaps === 0) {
+            // The two proofs, made legible together: this gate is the DOCUMENTARY proof (decisions traced);
+            // the BEHAVIORAL proof is the operator's test suite. runward reads the pointer, never runs the code.
+            console.log(section("Behavioral proof (advisory, above the gate)"));
+            console.log("  " + c.darkGray("this gate is the documentary proof: the decisions are traced. runward did not run your code — it is not a runtime. The behavioral proof is your test suite."));
+            const bp = behavioralProof(mission, root);
+            if (!bp.declared) {
+                console.log("  " + c.darkGray("no behavioral proof declared — add `Behavioral proof: <command>` to runward/floor.md §2 (and optionally `Proof artifact: <path>`)."));
+            }
+            else {
+                if (bp.command)
+                    console.log(`  ${c.darkGray("prove behavior with:")} ${c.white(bp.command)}`);
+                if (bp.artifact) {
+                    if (!bp.present)
+                        console.log(`  ${c.warning("◑")} ${c.darkGray("proof artifact")} ${c.white(bp.artifact)} ${c.warning("missing — run the command to produce it")}`);
+                    else {
+                        const fresh = bp.fresh === undefined ? "" : bp.fresh ? c.success(" · fresh") : c.warning(" · stale (older than the code — re-run)");
+                        console.log(`  ${c.success("✓")} ${c.darkGray("proof artifact")} ${c.white(bp.artifact)} ${c.darkGray(`(${bp.date})`)}${fresh}`);
+                    }
+                }
+                console.log("  " + c.darkGray("advisory — runward reports presence and freshness, never runs or reads the result. You cross on both proofs."));
+            }
             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)."));
         }

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/lib/behavioral-proof.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+export function behavioralProof(mission, root) {
+    const floor = join(mission, "floor.md");
+    if (!existsSync(floor))
+        return { declared: false };
+    const text = readFileSync(floor, "utf8");
+    const cmd = text.match(/^\s*[*_]*Behavioral proof[*_]*\s*:\s*`?([^`\n]+?)`?\s*$/mi);
+    const art = text.match(/^\s*[*_]*Proof artifact[*_]*\s*:\s*`?([^`\n]+?)`?\s*$/mi);
+    if (!cmd && !art)
+        return { declared: false };
+    const proof = { declared: true, command: cmd?.[1]?.trim(), artifact: art?.[1]?.trim() };
+    if (proof.artifact) {
+        const abs = join(root, proof.artifact);
+        proof.present = existsSync(abs);
+        if (proof.present) {
+            const st = statSync(abs);
+            proof.date = st.mtime.toISOString().slice(0, 10);
+            const codeDir = join(root, "code");
+            const newest = existsSync(codeDir) ? newestSourceMtime(codeDir) : 0;
+            proof.fresh = newest === 0 ? undefined : st.mtimeMs >= newest;
+        }
+    }
+    return proof;
+}
+/** Newest mtime of a tracked source file under a dir — read-only, node_modules and dotfiles skipped. */
+function newestSourceMtime(dir) {
+    let newest = 0;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const e of entries) {
+        if (e.name === "node_modules" || e.name.startsWith("."))
+            continue;
+        const p = join(dir, e.name);
+        if (e.isDirectory())
+            newest = Math.max(newest, newestSourceMtime(p));
+        else if (/\.(ts|tsx|js|jsx|py|go|rs|java|rb)$/.test(e.name))
+            newest = Math.max(newest, statSync(p).mtimeMs);
+    }
+    return newest;
+}

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/examples/request-triage/runward/floor.md

@@ -37,6 +37,10 @@
 - **Verdict**: criterion met on the replayed sample and the first live week. The gate to `iterate` requires the full two-week live window per the criterion's wording — one more week of live measurement before the gate is crossed. Partial by duration, not by result.
 - **Observability check**: confirmed — a full trajectory (intake, model proposal, per-field guard outcome, routing decision, persistence) reconstructs from a single request ID; verified on 10 randomly drawn requests.
 
+**Behavioral proof**: `cd code && npm test`
+
+> 14 deterministic tests, no key, no network — including the guard refusing, fail-closed, a record whose action-bearing fields are still model-proposed (ADR-0002). The gate above proves the *decision* to guard was traced; this proves the guard *runs*. runward reports the pointer, never runs it.
+
 ## 3. Gaps and deviations
 
 | Gap / deviation | Impact | Agreed with sponsor |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runward",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "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/mission/floor.md

@@ -34,6 +34,11 @@
 - **Verdict**: [criterion met / partially met / not met — and what that means for the gate.]
 - **Observability check**: [confirmation that a full trajectory reconstructs from a single request ID.]
 
+**Behavioral proof**: `[the command that proves the floor's behavior, e.g. cd code && npm test]`
+**Proof artifact**: [optional — a result file the command writes, e.g. code/test-results.json; runward reports it present/fresh, never runs or reads it]
+
+> The gate above is the *documentary* proof (the decisions are traced). This line is the *behavioral* proof (your code actually runs). runward never executes it — it is not a runtime; on a green `--strict` it only reports the pointer, and the artifact's presence and freshness if you name one.
+
 ## 3. Gaps and deviations
 
 [Anything shipped differently from the architecture note, and anything the measurement revealed. Deviations were agreed with the sponsor, never silent.]