runboard 0.1.0 → 1.1.0

package/AGENTS.md

@@ -25,6 +25,7 @@ runboard pulse                # compare the two latest assessments
 runboard roadmap              # Now/Next/Later from the binding constraint
 runboard report --type board-update|baseline|monthly
 runboard status               # one-screen current state
+runboard skills install [--target <dir>] [--force] [--dry-run]   # copy these skills to an agent
 ```
 
 Dimension keys: `build.team`, `build.tools`, `build.techniques`, `run.team`, `run.tools`,
@@ -49,6 +50,11 @@ their results match the CLI exactly.
 `skills/*/SKILL.md` are written to the open SKILL.md standard and run unmodified across
 agent platforms. They own the conversation; the CLI owns the computation.
 
+To install them into your agent, run `runboard skills install`. With no `--target` it
+auto-detects a supported agent (v1: Claude Code → `.claude/skills/`); for any other agent
+pass `--target <its skills dir>` (e.g. `--target .cursor/skills`). Existing skills are not
+overwritten without `--force`, and `--dry-run` previews without writing.
+
 > Note: in published installs, `CLAUDE.md` is provided as a copy/symlink of this file so
 > Claude Code reads the same guidance. In this source repo, `CLAUDE.md` is the
 > contributor/Spec-Kit guide instead — this AGENTS.md is the end-user agent guide.

package/README.md

@@ -41,13 +41,43 @@ history becomes your trajectory record.
 | `runboard roadmap` | Now/Next/Later plan from your binding constraint. |
 | `runboard report --type <t>` | Render a board-ready report from a template. |
 | `runboard status` | One-screen current state. |
+| `runboard skills install [--target <dir>]` | Copy the bundled SKILL.md skills into an agent's skills directory. |
 
 ## Use it from your AI assistant
 
-Portable `skills/` (SKILL.md) and an MCP server (`npx runboard-mcp`) let Claude, Cursor,
-Codex, Copilot, Gemini, and other agents run the assessment conversation and persist
-results through the same core — the numbers are always computed by the tool, never by the
-model.
+Portable `skills/` (SKILL.md) and an MCP server let Claude, Cursor, Codex, Copilot, Gemini,
+and other agents run the assessment conversation and persist results through the same core
+— the numbers are always computed by the tool, never by the model.
+
+The MCP server ships in this same package and runs locally over stdio (no network, no
+account). Add it to your client with one zero-install command:
+
+```jsonc
+{
+  "mcpServers": {
+    "runboard": { "command": "npx", "args": ["-y", "runboard", "mcp"] }
+  }
+}
+```
+
+See [docs/mcp.md](./docs/mcp.md) for Claude Desktop, Cursor, and VS Code setup.
+
+### Installing the skills
+
+SKILL.md is a cross-agent open format, so "installing" a skill just means copying its
+folder to wherever your agent looks for skills. `skills install` does that from the copy
+already bundled in this package — no download, no network:
+
+```bash
+npx runboard@latest skills install                 # auto-detect (Claude Code → .claude/skills/)
+npx runboard@latest skills install --target .cursor/skills   # any other agent
+npx runboard@latest skills install --dry-run       # preview; writes nothing
+npx runboard@latest skills install --force         # overwrite existing copies (e.g. after upgrade)
+```
+
+Without `--target` it auto-detects a supported agent (v1: Claude Code, via a `.claude/`
+directory). For any other agent, point `--target` at its skills directory. Existing skills
+are never overwritten without `--force`. Restart your agent afterward so it discovers them.
 
 ## Contributing
 

package/dist/{chunk-U4SVYBXI.js → chunk-3NNMYWCN.js}

@@ -1,42 +1,14 @@
 #!/usr/bin/env node
 
-// src/core/errors.ts
-var UserError = class extends Error {
-};
+// mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
 
-// src/commands/shared.ts
-import { existsSync } from "fs";
-
-// src/data/paths.ts
-import path from "path";
-function runboardPaths(root = process.cwd()) {
-  const dir = path.join(root, ".runboard");
-  return {
-    root,
-    dir,
-    config: path.join(dir, "config.yaml"),
-    rubric: path.join(dir, "rubric.yaml"),
-    assessmentsDir: path.join(dir, "assessments"),
-    reportsDir: path.join(dir, "reports"),
-    roadmap: path.join(dir, "roadmap.md"),
-    boardHtml: path.join(dir, "board.html")
-  };
-}
-function assessmentFile(root, date) {
-  return path.join(runboardPaths(root).assessmentsDir, `${date}.md`);
-}
-
-// src/commands/shared.ts
-function requireInit(root = process.cwd()) {
-  if (!existsSync(runboardPaths(root).dir)) {
-    throw new UserError("No .runboard/ found here. Run `runboard init` first.");
-  }
-}
-function requireAssessments(dates) {
-  if (dates.length === 0) {
-    throw new UserError("No assessments yet. Run `runboard assess` to record one.");
-  }
-}
+// src/version.ts
+import { readFileSync } from "fs";
+var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+var VERSION = pkg.version;
 
 // src/commands/assess.ts
 import { cancel, intro, isCancel, note, outro, select, text } from "@clack/prompts";
@@ -79,9 +51,30 @@ function isLevel(value) {
 }
 
 // src/data/assessments.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, readdirSync, writeFileSync } from "fs";
 import path2 from "path";
 import { parse, stringify } from "yaml";
+
+// src/data/paths.ts
+import path from "path";
+function runboardPaths(root = process.cwd()) {
+  const dir = path.join(root, ".runboard");
+  return {
+    root,
+    dir,
+    config: path.join(dir, "config.yaml"),
+    rubric: path.join(dir, "rubric.yaml"),
+    assessmentsDir: path.join(dir, "assessments"),
+    reportsDir: path.join(dir, "reports"),
+    roadmap: path.join(dir, "roadmap.md"),
+    boardHtml: path.join(dir, "board.html")
+  };
+}
+function assessmentFile(root, date) {
+  return path.join(runboardPaths(root).assessmentsDir, `${date}.md`);
+}
+
+// src/data/assessments.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var AssessmentError = class extends Error {
 };
@@ -159,14 +152,14 @@ function parseAssessment(text2, fallbackDate) {
 }
 function listAssessmentDates(root = process.cwd()) {
   const dir = runboardPaths(root).assessmentsDir;
-  if (!existsSync2(dir)) {
+  if (!existsSync(dir)) {
     return [];
   }
   return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => path2.basename(f, ".md")).filter((d) => DATE_RE.test(d)).sort();
 }
 function loadAssessment(date, root = process.cwd()) {
   const file = assessmentFile(root, date);
-  return parseAssessment(readFileSync(file, "utf8"), date);
+  return parseAssessment(readFileSync2(file, "utf8"), date);
 }
 function loadAllAssessments(root = process.cwd()) {
   return listAssessmentDates(root).map((date) => loadAssessment(date, root));
@@ -180,7 +173,7 @@ function saveAssessment(a, root = process.cwd(), options = {}) {
   const dir = runboardPaths(root).assessmentsDir;
   mkdirSync(dir, { recursive: true });
   const file = assessmentFile(root, a.date);
-  if (existsSync2(file) && !options.force) {
+  if (existsSync(file) && !options.force) {
     throw new AssessmentError(
       `An assessment for ${a.date} already exists. Re-run with --force to overwrite.`
     );
@@ -190,7 +183,7 @@ function saveAssessment(a, root = process.cwd(), options = {}) {
 }
 
 // src/data/rubric.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
 import { parse as parse2 } from "yaml";
@@ -202,7 +195,7 @@ function shippedRubricPath() {
   ];
   for (const candidate of candidates) {
     try {
-      readFileSync2(candidate);
+      readFileSync3(candidate);
       return candidate;
     } catch {
     }
@@ -262,13 +255,32 @@ function parseDimension(raw) {
 function loadRubric(filePath = shippedRubricPath()) {
   let text2;
   try {
-    text2 = readFileSync2(filePath, "utf8");
+    text2 = readFileSync3(filePath, "utf8");
   } catch {
     throw new Error(`Could not read rubric at ${filePath}.`);
   }
   return parseRubric(text2);
 }
 
+// src/commands/shared.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/core/errors.ts
+var UserError = class extends Error {
+};
+
+// src/commands/shared.ts
+function requireInit(root = process.cwd()) {
+  if (!existsSync2(runboardPaths(root).dir)) {
+    throw new UserError("No .runboard/ found here. Run `runboard init` first.");
+  }
+}
+function requireAssessments(dates) {
+  if (dates.length === 0) {
+    throw new UserError("No assessments yet. Run `runboard assess` to record one.");
+  }
+}
+
 // src/commands/assess.ts
 function today() {
   const d = /* @__PURE__ */ new Date();
@@ -609,7 +621,7 @@ function detectTriggers(assessmentsChrono) {
 }
 
 // src/render/reports.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Eta } from "eta";
@@ -638,7 +650,7 @@ function templatesDir() {
   const candidates = [path4.resolve(here, "../templates"), path4.resolve(here, "../../templates")];
   for (const candidate of candidates) {
     try {
-      readFileSync3(path4.join(candidate, "roadmap.eta"));
+      readFileSync4(path4.join(candidate, "roadmap.eta"));
       return candidate;
     } catch {
     }
@@ -881,24 +893,129 @@ function registerStatus(program) {
   });
 }
 
+// mcp/handlers.ts
+function handleAssess(args) {
+  const sets = Object.entries(args.scores).map(
+    ([key, s]) => `${key}=${s.level}:${s.trajectory}:${s.evidence ?? ""}`
+  );
+  const { date, path: path7 } = runAssess({
+    root: args.root,
+    sets,
+    type: args.type,
+    force: args.force,
+    date: args.date
+  });
+  return { date, path: path7, written: true };
+}
+function handleBoard(ctx) {
+  const { summary, htmlPath } = runBoard({ root: ctx.root, html: ctx.html });
+  return {
+    cells: summary.cells,
+    average: formatAverage(summary.average),
+    trajectoryCounts: summary.trajectoryCounts,
+    ...htmlPath ? { htmlPath } : {}
+  };
+}
+function handlePulse(ctx) {
+  const { path: path7, triggers } = runPulse({ root: ctx.root });
+  return { path: path7, triggers };
+}
+function handleRoadmap(ctx) {
+  const { path: path7 } = runRoadmap({ root: ctx.root });
+  const latest = latestAssessment(ctx.root);
+  if (!latest) throw new Error("unreachable");
+  return { path: path7, bindingConstraint: bindingConstraint(latest) };
+}
+function handleReport(ctx) {
+  const { path: path7 } = runReport({ root: ctx.root, type: ctx.type });
+  return { path: path7 };
+}
+function handleStatus(ctx) {
+  const s = runStatus(ctx.root);
+  return {
+    latestDate: s.latestDate ?? null,
+    average: s.average ?? null,
+    trajectoryCounts: s.trajectoryCounts ?? {},
+    activeTriggers: s.activeTriggers
+  };
+}
+
+// mcp/server.ts
+var scoreShape = z.object({
+  level: z.number().int().min(1).max(5),
+  trajectory: z.enum(["up", "flat", "down", "volatile"]),
+  evidence: z.string().default("")
+});
+function json(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function buildServer() {
+  const server = new McpServer({ name: "runboard", version: VERSION });
+  server.registerTool(
+    "runboard_assess",
+    {
+      description: "Record a 9-dimension assessment (the model supplies scores).",
+      inputSchema: {
+        scores: z.record(z.string(), scoreShape),
+        type: z.enum(["baseline", "pulse", "quarterly", "event"]).optional(),
+        force: z.boolean().optional()
+      }
+    },
+    async (args) => json(handleAssess(args))
+  );
+  server.registerTool(
+    "runboard_board",
+    {
+      description: "Render the board summary; set html to also write board.html.",
+      inputSchema: { html: z.boolean().optional() }
+    },
+    async (args) => json(handleBoard({ html: args.html }))
+  );
+  server.registerTool(
+    "runboard_pulse",
+    {
+      description: "Compare the two latest assessments and flag stuck dimensions.",
+      inputSchema: {}
+    },
+    async () => json(handlePulse({}))
+  );
+  server.registerTool(
+    "runboard_roadmap",
+    { description: "Generate a Now/Next/Later plan from the binding constraint.", inputSchema: {} },
+    async () => json(handleRoadmap({}))
+  );
+  server.registerTool(
+    "runboard_report",
+    {
+      description: "Render a report (board-update | baseline | monthly).",
+      inputSchema: { type: z.enum(["board-update", "baseline", "monthly"]) }
+    },
+    async (args) => json(handleReport({ type: args.type }))
+  );
+  server.registerTool(
+    "runboard_status",
+    { description: "One-screen current state.", inputSchema: {} },
+    async () => json(handleStatus({}))
+  );
+  return server;
+}
+async function startMcpServer() {
+  const server = buildServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
 export {
+  VERSION,
   runboardPaths,
-  latestAssessment,
   shippedRubricPath,
   loadRubric,
   UserError,
-  runAssess,
   registerAssess,
-  formatAverage,
-  bindingConstraint,
-  runBoard,
   registerBoard,
-  runPulse,
   registerPulse,
-  runReport,
   registerReport,
-  runRoadmap,
   registerRoadmap,
-  runStatus,
-  registerStatus
+  registerStatus,
+  startMcpServer
 };

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   UserError,
+  VERSION,
   loadRubric,
   registerAssess,
   registerBoard,
@@ -9,8 +10,9 @@ import {
   registerRoadmap,
   registerStatus,
   runboardPaths,
-  shippedRubricPath
-} from "./chunk-U4SVYBXI.js";
+  shippedRubricPath,
+  startMcpServer
+} from "./chunk-3NNMYWCN.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -63,8 +65,216 @@ ${created.map((c) => `  ${c}`).join("\n")}
   });
 }
 
+// src/commands/skills.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, statSync as statSync2 } from "fs";
+import path2 from "path";
+
+// src/core/skills.ts
+function selectTarget(options, detected) {
+  if (options.target) {
+    return { kind: "explicit", dir: options.target };
+  }
+  if (detected.length === 0) {
+    return { kind: "none" };
+  }
+  if (detected.length === 1) {
+    const only = detected[0];
+    return { kind: "detected", agent: only.agent, dir: only.dir };
+  }
+  return { kind: "ambiguous", dirs: detected };
+}
+function planInstall(bundled, existingNames, options) {
+  const existing = new Set(existingNames);
+  return bundled.map((skill) => {
+    if (!existing.has(skill.name)) {
+      return { name: skill.name, kind: "create" };
+    }
+    if (options.force) {
+      return { name: skill.name, kind: "overwrite" };
+    }
+    return {
+      name: skill.name,
+      kind: "skip",
+      reason: "already present (use --force to overwrite)"
+    };
+  });
+}
+
+// src/data/skills.ts
+import { cpSync, readdirSync, statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function shippedSkillsDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [path.resolve(here, "../skills"), path.resolve(here, "../../skills")];
+  for (const candidate of candidates) {
+    try {
+      if (statSync(candidate).isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+function listBundledSkills(dir = shippedSkillsDir()) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.map((name) => ({ name, sourceDir: path.join(dir, name) })).filter((skill) => isDirectory(skill.sourceDir)).filter((skill) => isFile(path.join(skill.sourceDir, "SKILL.md"))).sort((a, b) => a.name.localeCompare(b.name));
+}
+var AGENT_TABLE = [
+  { agent: "claude-code", marker: ".claude", skillsDir: ".claude/skills" }
+];
+function detectAgentDirs(cwd = process.cwd()) {
+  return AGENT_TABLE.filter((row) => isDirectory(path.join(cwd, row.marker))).map((row) => ({
+    agent: row.agent,
+    dir: path.join(cwd, row.skillsDir)
+  }));
+}
+function existingSkillNames(destination) {
+  try {
+    return readdirSync(destination, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function copySkill(sourceDir, destDir) {
+  const target = path.join(destDir, path.basename(sourceDir));
+  cpSync(sourceDir, target, { recursive: true, force: true });
+}
+function isDirectory(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/skills.ts
+function runSkillsInstall(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const force = opts.force ?? false;
+  const dryRun = opts.dryRun ?? false;
+  const bundled = listBundledSkills();
+  if (bundled.length === 0) {
+    throw new UserError(
+      "No bundled skills found in this runboard install. The package may be corrupt; try reinstalling."
+    );
+  }
+  const destination = resolveDestination(root, opts.target);
+  if (existsSync2(destination) && !statSync2(destination).isDirectory()) {
+    throw new UserError(`Target ${destination} is a file, not a directory.`);
+  }
+  const actions = planInstall(bundled, existingSkillNames(destination), { force });
+  const installed = [];
+  const skipped = [];
+  const failed = [];
+  if (dryRun) {
+    return { destination, dryRun, installed, skipped, failed, actions };
+  }
+  mkdirSync2(destination, { recursive: true });
+  for (const action of actions) {
+    if (action.kind === "skip") {
+      skipped.push(action.name);
+      continue;
+    }
+    const skill = bundled.find((b) => b.name === action.name);
+    if (!skill) {
+      throw new Error(`unreachable: planned skill ${action.name} not in bundle`);
+    }
+    try {
+      copySkill(skill.sourceDir, destination);
+      installed.push(action.name);
+    } catch (err) {
+      failed.push({ name: action.name, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { destination, dryRun, installed, skipped, failed, actions };
+}
+function resolveDestination(root, target) {
+  const resolution = selectTarget(
+    { target: target ? path2.resolve(root, target) : void 0 },
+    detectAgentDirs(root)
+  );
+  switch (resolution.kind) {
+    case "explicit":
+      return resolution.dir;
+    case "detected":
+      return resolution.dir;
+    case "none":
+      throw new UserError(
+        "No agent skills directory detected. Re-run with --target <dir> (e.g. --target .cursor/skills)."
+      );
+    case "ambiguous":
+      throw new UserError(
+        `Multiple agent skills directories detected:
+${resolution.dirs.map((d) => `  ${d.agent}: ${d.dir}`).join("\n")}
+Re-run with --target <dir> to choose one.`
+      );
+  }
+}
+function formatReport(report) {
+  const lines = [];
+  if (report.dryRun) {
+    lines.push("Dry run \u2014 no files will be written.");
+    lines.push(`Destination: ${report.destination}`);
+    for (const action of report.actions) {
+      const label = action.kind === "skip" ? "skip (already present)" : action.kind;
+      lines.push(`  ${action.name.padEnd(14)}${label}`);
+    }
+    return `${lines.join("\n")}
+`;
+  }
+  const failedNames = new Set(report.failed.map((f) => f.name));
+  lines.push(`Installing skills into ${report.destination}`);
+  for (const action of report.actions) {
+    const failure = report.failed.find((f) => f.name === action.name);
+    if (failure) {
+      lines.push(`  \u2717 ${action.name.padEnd(14)}(failed: ${failure.error})`);
+    } else if (action.kind === "skip") {
+      lines.push(
+        `  - ${action.name.padEnd(14)}(skipped: already present, use --force to overwrite)`
+      );
+    } else {
+      const verb = action.kind === "overwrite" ? "overwritten" : "created";
+      lines.push(`  \u2713 ${action.name.padEnd(14)}(${verb})`);
+    }
+  }
+  lines.push("");
+  const tail = failedNames.size > 0 ? `, ${failedNames.size} failed` : "";
+  lines.push(
+    `Installed ${report.installed.length} skill(s), skipped ${report.skipped.length}${tail}. Restart your agent to pick them up.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function registerSkills(program) {
+  const skills = program.command("skills").description("Manage runboard's portable AI skills.");
+  skills.command("install").description("Copy the bundled SKILL.md skills into an agent's skills directory.").option("--target <dir>", "destination directory (overrides auto-detection)").option("--force", "overwrite skills already present at the destination").option("--dry-run", "show what would be installed without writing anything").action((options) => {
+    const report = runSkillsInstall({
+      target: options.target,
+      force: options.force,
+      dryRun: options.dryRun
+    });
+    process.stdout.write(formatReport(report));
+    if (report.failed.length > 0) {
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/cli.ts
-var VERSION = "0.1.0";
 function buildProgram() {
   const program = new Command();
   program.name("runboard").description("Local-first technical-leadership maturity scorecard.").version(VERSION, "-v, --version");
@@ -75,6 +285,10 @@ function buildProgram() {
   registerRoadmap(program);
   registerReport(program);
   registerStatus(program);
+  registerSkills(program);
+  program.command("mcp").description("Start the MCP server over stdio (for tool-calling AI clients).").action(async () => {
+    await startMcpServer();
+  });
   return program;
 }
 async function main(argv) {
@@ -91,12 +305,10 @@ async function main(argv) {
     throw err;
   }
 }
+
+// src/main.ts
 main(process.argv).catch((err) => {
   process.stderr.write(`${err instanceof Error ? err.message : String(err)}
 `);
   process.exit(1);
 });
-export {
-  buildProgram,
-  main
-};

package/dist/mcp.js

@@ -1,137 +1,11 @@
 #!/usr/bin/env node
 import {
-  bindingConstraint,
-  formatAverage,
-  latestAssessment,
-  runAssess,
-  runBoard,
-  runPulse,
-  runReport,
-  runRoadmap,
-  runStatus
-} from "./chunk-U4SVYBXI.js";
+  startMcpServer
+} from "./chunk-3NNMYWCN.js";
 
-// mcp/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// mcp/handlers.ts
-function handleAssess(args) {
-  const sets = Object.entries(args.scores).map(
-    ([key, s]) => `${key}=${s.level}:${s.trajectory}:${s.evidence ?? ""}`
-  );
-  const { date, path } = runAssess({
-    root: args.root,
-    sets,
-    type: args.type,
-    force: args.force,
-    date: args.date
-  });
-  return { date, path, written: true };
-}
-function handleBoard(ctx) {
-  const { summary, htmlPath } = runBoard({ root: ctx.root, html: ctx.html });
-  return {
-    cells: summary.cells,
-    average: formatAverage(summary.average),
-    trajectoryCounts: summary.trajectoryCounts,
-    ...htmlPath ? { htmlPath } : {}
-  };
-}
-function handlePulse(ctx) {
-  const { path, triggers } = runPulse({ root: ctx.root });
-  return { path, triggers };
-}
-function handleRoadmap(ctx) {
-  const { path } = runRoadmap({ root: ctx.root });
-  const latest = latestAssessment(ctx.root);
-  if (!latest) throw new Error("unreachable");
-  return { path, bindingConstraint: bindingConstraint(latest) };
-}
-function handleReport(ctx) {
-  const { path } = runReport({ root: ctx.root, type: ctx.type });
-  return { path };
-}
-function handleStatus(ctx) {
-  const s = runStatus(ctx.root);
-  return {
-    latestDate: s.latestDate ?? null,
-    average: s.average ?? null,
-    trajectoryCounts: s.trajectoryCounts ?? {},
-    activeTriggers: s.activeTriggers
-  };
-}
-
-// mcp/server.ts
-var scoreShape = z.object({
-  level: z.number().int().min(1).max(5),
-  trajectory: z.enum(["up", "flat", "down", "volatile"]),
-  evidence: z.string().default("")
-});
-function json(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
-}
-function buildServer() {
-  const server = new McpServer({ name: "runboard", version: "0.1.0" });
-  server.registerTool(
-    "runboard_assess",
-    {
-      description: "Record a 9-dimension assessment (the model supplies scores).",
-      inputSchema: {
-        scores: z.record(z.string(), scoreShape),
-        type: z.enum(["baseline", "pulse", "quarterly", "event"]).optional(),
-        force: z.boolean().optional()
-      }
-    },
-    async (args) => json(handleAssess(args))
-  );
-  server.registerTool(
-    "runboard_board",
-    {
-      description: "Render the board summary; set html to also write board.html.",
-      inputSchema: { html: z.boolean().optional() }
-    },
-    async (args) => json(handleBoard({ html: args.html }))
-  );
-  server.registerTool(
-    "runboard_pulse",
-    {
-      description: "Compare the two latest assessments and flag stuck dimensions.",
-      inputSchema: {}
-    },
-    async () => json(handlePulse({}))
-  );
-  server.registerTool(
-    "runboard_roadmap",
-    { description: "Generate a Now/Next/Later plan from the binding constraint.", inputSchema: {} },
-    async () => json(handleRoadmap({}))
-  );
-  server.registerTool(
-    "runboard_report",
-    {
-      description: "Render a report (board-update | baseline | monthly).",
-      inputSchema: { type: z.enum(["board-update", "baseline", "monthly"]) }
-    },
-    async (args) => json(handleReport({ type: args.type }))
-  );
-  server.registerTool(
-    "runboard_status",
-    { description: "One-screen current state.", inputSchema: {} },
-    async () => json(handleStatus({}))
-  );
-  return server;
-}
-async function main() {
-  const server = buildServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-main().catch((err) => {
+// mcp/main.ts
+startMcpServer().catch((err) => {
   process.stderr.write(`${err instanceof Error ? err.message : String(err)}
 `);
   process.exit(1);
 });
-export {
-  buildServer
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runboard",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Local-first CLI for the Runboard technical-leadership maturity framework. Deterministic scoring core, portable AI adapters, no phone-home.",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,8 @@
     "test:watch": "vitest",
     "lint": "biome check .",
     "format": "biome format --write .",
-    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build"
+    "mcp:smoke": "node scripts/mcp-smoke.mjs",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build && npm run mcp:smoke"
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",