runward 0.13.1 → 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/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.1",
+  "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",