runboard 0.1.0

package/dist/chunk-U4SVYBXI.js

@@ -0,0 +1,904 @@
+#!/usr/bin/env node
+
+// src/core/errors.ts
+var UserError = class extends Error {
+};
+
+// 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/commands/assess.ts
+import { cancel, intro, isCancel, note, outro, select, text } from "@clack/prompts";
+
+// src/core/types.ts
+var AREAS = ["build", "run", "plan"];
+var LENSES = ["team", "tools", "techniques"];
+var TRAJECTORIES = ["up", "flat", "down", "volatile"];
+var ASSESSMENT_TYPES = ["baseline", "pulse", "quarterly", "event"];
+var DIMENSION_KEYS = AREAS.flatMap(
+  (area) => LENSES.map((lens) => `${area}.${lens}`)
+);
+var TRAJECTORY_GLYPHS = {
+  up: "\u2B06",
+  flat: "\u27A1",
+  down: "\u2B07",
+  volatile: "\u26A0"
+};
+function parseDimensionKey(key) {
+  const [area, lens] = key.split(".");
+  if (!isArea(area) || !isLens(lens)) {
+    throw new Error(`Invalid dimension key: "${key}"`);
+  }
+  return { area, lens };
+}
+function isArea(value) {
+  return typeof value === "string" && AREAS.includes(value);
+}
+function isLens(value) {
+  return typeof value === "string" && LENSES.includes(value);
+}
+function isTrajectory(value) {
+  return typeof value === "string" && TRAJECTORIES.includes(value);
+}
+function isAssessmentType(value) {
+  return typeof value === "string" && ASSESSMENT_TYPES.includes(value);
+}
+function isLevel(value) {
+  return value === 1 || value === 2 || value === 3 || value === 4 || value === 5;
+}
+
+// src/data/assessments.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import path2 from "path";
+import { parse, stringify } from "yaml";
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var AssessmentError = class extends Error {
+};
+function validateScores(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new AssessmentError("Assessment has no scores.");
+  }
+  const obj = raw;
+  const result = {};
+  for (const key of DIMENSION_KEYS) {
+    const cell2 = obj[key];
+    if (!cell2 || typeof cell2 !== "object") {
+      throw new AssessmentError(`Missing score for dimension "${key}".`);
+    }
+    const c = cell2;
+    const level = typeof c.level === "string" ? Number(c.level) : c.level;
+    if (!isLevel(level)) {
+      throw new AssessmentError(`Dimension "${key}" has an invalid level (must be 1-5).`);
+    }
+    if (!isTrajectory(c.trajectory)) {
+      throw new AssessmentError(
+        `Dimension "${key}" has an invalid trajectory (must be up/flat/down/volatile).`
+      );
+    }
+    result[key] = {
+      level,
+      trajectory: c.trajectory,
+      evidence: typeof c.evidence === "string" ? c.evidence : ""
+    };
+  }
+  return result;
+}
+function serializeAssessment(a) {
+  const frontmatter = stringify({
+    date: a.date,
+    type: a.type,
+    scores: a.scores,
+    ...a.notes ? { notes: a.notes } : {}
+  });
+  const body = a.narrative ? `
+${a.narrative.trim()}
+` : "";
+  return `---
+${frontmatter}---
+${body}`;
+}
+function parseAssessment(text2, fallbackDate) {
+  const match = text2.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    throw new AssessmentError("Assessment file is missing YAML frontmatter.");
+  }
+  const raw = parse(match[1]) ?? {};
+  const date = typeof raw.date === "string" ? raw.date : fallbackDate ?? "";
+  if (!DATE_RE.test(date)) {
+    throw new AssessmentError(`Assessment has an invalid date: "${date}".`);
+  }
+  let type = "baseline";
+  if (raw.type !== void 0) {
+    if (!isAssessmentType(raw.type)) {
+      throw new AssessmentError(
+        `Assessment ${date} has an invalid type "${String(raw.type)}" (use baseline, pulse, quarterly, or event).`
+      );
+    }
+    type = raw.type;
+  }
+  const scores = validateScores(raw.scores);
+  const narrative = (match[2] ?? "").trim();
+  return {
+    date,
+    type,
+    scores,
+    ...typeof raw.notes === "string" ? { notes: raw.notes } : {},
+    ...narrative ? { narrative } : {}
+  };
+}
+function listAssessmentDates(root = process.cwd()) {
+  const dir = runboardPaths(root).assessmentsDir;
+  if (!existsSync2(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);
+}
+function loadAllAssessments(root = process.cwd()) {
+  return listAssessmentDates(root).map((date) => loadAssessment(date, root));
+}
+function latestAssessment(root = process.cwd()) {
+  const dates = listAssessmentDates(root);
+  const last = dates[dates.length - 1];
+  return last ? loadAssessment(last, root) : void 0;
+}
+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) {
+    throw new AssessmentError(
+      `An assessment for ${a.date} already exists. Re-run with --force to overwrite.`
+    );
+  }
+  writeFileSync(file, serializeAssessment(a), "utf8");
+  return file;
+}
+
+// src/data/rubric.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { parse as parse2 } from "yaml";
+function shippedRubricPath() {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path3.resolve(here, "../rubric/rubric.yaml"),
+    path3.resolve(here, "../../rubric/rubric.yaml")
+  ];
+  for (const candidate of candidates) {
+    try {
+      readFileSync2(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+function parseRubric(text2) {
+  const raw = parse2(text2);
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Rubric is empty or malformed.");
+  }
+  const obj = raw;
+  const version = typeof obj.version === "string" ? obj.version : "";
+  if (!version) {
+    throw new Error("Rubric is missing a `version`.");
+  }
+  if (!Array.isArray(obj.dimensions)) {
+    throw new Error("Rubric is missing a `dimensions` list.");
+  }
+  const dimensions = obj.dimensions.map(parseDimension);
+  const keys = dimensions.map((d) => d.key);
+  for (const required of DIMENSION_KEYS) {
+    if (!keys.includes(required)) {
+      throw new Error(`Rubric is missing dimension "${required}".`);
+    }
+  }
+  if (keys.length !== DIMENSION_KEYS.length) {
+    throw new Error(
+      `Rubric must have exactly ${DIMENSION_KEYS.length} dimensions; found ${keys.length}.`
+    );
+  }
+  return { version, dimensions };
+}
+function parseDimension(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Rubric dimension is malformed.");
+  }
+  const obj = raw;
+  const key = String(obj.key ?? "");
+  const { area, lens } = parseDimensionKey(key);
+  const title2 = typeof obj.title === "string" ? obj.title : key;
+  const anchorsRaw = obj.anchors;
+  if (!anchorsRaw || typeof anchorsRaw !== "object") {
+    throw new Error(`Dimension "${key}" is missing anchors.`);
+  }
+  const anchorsObj = anchorsRaw;
+  const anchors = {};
+  for (const level of [1, 2, 3, 4, 5]) {
+    const text2 = anchorsObj[String(level)];
+    if (typeof text2 !== "string" || text2.length === 0) {
+      throw new Error(`Dimension "${key}" is missing anchor text for level ${level}.`);
+    }
+    anchors[level] = text2;
+  }
+  return { key, area, lens, title: title2, anchors };
+}
+function loadRubric(filePath = shippedRubricPath()) {
+  let text2;
+  try {
+    text2 = readFileSync2(filePath, "utf8");
+  } catch {
+    throw new Error(`Could not read rubric at ${filePath}.`);
+  }
+  return parseRubric(text2);
+}
+
+// src/commands/assess.ts
+function today() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function parseSetEntry(entry) {
+  const eq = entry.indexOf("=");
+  if (eq < 0)
+    throw new UserError(`Invalid --set "${entry}". Expected <dim>=<level>:<traj>:<evidence>.`);
+  const key = entry.slice(0, eq).trim();
+  const rest = entry.slice(eq + 1);
+  const c1 = rest.indexOf(":");
+  const c2 = rest.indexOf(":", c1 + 1);
+  if (c1 < 0 || c2 < 0) {
+    throw new UserError(`Invalid --set "${entry}". Expected <dim>=<level>:<traj>:<evidence>.`);
+  }
+  const level = Number(rest.slice(0, c1).trim());
+  const trajectory = rest.slice(c1 + 1, c2).trim();
+  const evidence = rest.slice(c2 + 1).trim().replace(/^"(.*)"$/, "$1");
+  return { key, value: { level, trajectory, evidence } };
+}
+function defaultType(root) {
+  return listAssessmentDates(root).length === 0 ? "baseline" : "pulse";
+}
+function resolveType(rawType, root) {
+  if (rawType !== void 0 && !isAssessmentType(rawType)) {
+    throw new UserError(`Invalid --type "${rawType}". Use baseline, pulse, quarterly, or event.`);
+  }
+  return rawType ?? defaultType(root);
+}
+function runAssess(opts) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  const date = opts.date ?? today();
+  const type = resolveType(opts.type, root);
+  const raw = {};
+  for (const entry of opts.sets ?? []) {
+    const { key, value } = parseSetEntry(entry);
+    raw[key] = value;
+  }
+  const scores = validateScores(raw);
+  const assessment = { date, type, scores };
+  const path7 = saveAssessment(assessment, root, { force: opts.force });
+  return { date, path: path7 };
+}
+async function runInteractive(opts) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  const date = opts.date ?? today();
+  const type = resolveType(opts.type, root);
+  const rubric = loadRubric(runboardPaths(root).rubric);
+  intro("Runboard assessment");
+  const raw = {};
+  for (const key of DIMENSION_KEYS) {
+    const dim = rubric.dimensions.find((d) => d.key === key);
+    if (!dim) continue;
+    note([1, 2, 3, 4, 5].map((l) => `${l}  ${dim.anchors[l]}`).join("\n"), dim.title);
+    const level = await select({
+      message: `${dim.title} \u2014 level?`,
+      options: [1, 2, 3, 4, 5].map((l) => ({ value: l, label: `${l}` }))
+    });
+    if (isCancel(level)) return abort();
+    const trajectory = await select({
+      message: "Trajectory?",
+      options: TRAJECTORIES.map((t) => ({ value: t, label: t }))
+    });
+    if (isCancel(trajectory)) return abort();
+    const evidence = await text({ message: "One-line evidence (optional)", defaultValue: "" });
+    if (isCancel(evidence)) return abort();
+    raw[key] = { level, trajectory, evidence };
+  }
+  const scores = validateScores(raw);
+  const path7 = saveAssessment({ date, type, scores }, root, { force: opts.force });
+  outro(`Saved ${path7}. Run \`runboard board\` to see your scorecard.`);
+  return { date, path: path7 };
+}
+function abort() {
+  cancel("Assessment cancelled.");
+  throw new UserError("Assessment cancelled.");
+}
+function registerAssess(program) {
+  program.command("assess").description("Record a 9-dimension assessment (interactive, or --set for agents).").option("--type <type>", "baseline | pulse | quarterly | event").option(
+    "--set <entry>",
+    "non-interactive: <dim>=<level>:<traj>:<evidence> (repeatable)",
+    (val, prev = []) => [...prev, val],
+    []
+  ).option("--force", "overwrite an existing assessment for today").action(async (options) => {
+    const sets = options.set ?? [];
+    if (sets.length > 0) {
+      const { path: path7 } = runAssess({ sets, type: options.type, force: options.force });
+      process.stdout.write(`Saved ${path7}. Run \`runboard board\` to see your scorecard.
+`);
+    } else {
+      await runInteractive({ type: options.type, force: options.force });
+    }
+  });
+}
+
+// src/commands/board.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// src/core/score.ts
+function summarise(assessment) {
+  const cells = DIMENSION_KEYS.map((key) => {
+    const score = assessment.scores[key];
+    return { key, level: score.level, trajectory: score.trajectory };
+  });
+  const total = cells.reduce((sum, cell2) => sum + cell2.level, 0);
+  const average = total / cells.length;
+  const trajectoryCounts = Object.fromEntries(TRAJECTORIES.map((t) => [t, 0]));
+  for (const cell2 of cells) {
+    trajectoryCounts[cell2.trajectory] += 1;
+  }
+  return { cells, average, trajectoryCounts };
+}
+function formatAverage(average) {
+  return average.toFixed(1);
+}
+
+// src/core/constraints.ts
+var TRAJECTORY_RANK = {
+  down: 0,
+  volatile: 1,
+  flat: 2,
+  up: 3
+};
+function rankConstraints(assessment) {
+  return DIMENSION_KEYS.map((key) => ({
+    key,
+    level: assessment.scores[key].level,
+    trajectory: assessment.scores[key].trajectory
+  })).sort((a, b) => {
+    if (a.level !== b.level) return a.level - b.level;
+    const ta = TRAJECTORY_RANK[a.trajectory];
+    const tb = TRAJECTORY_RANK[b.trajectory];
+    if (ta !== tb) return ta - tb;
+    return DIMENSION_KEYS.indexOf(a.key) - DIMENSION_KEYS.indexOf(b.key);
+  });
+}
+function bindingConstraint(assessment) {
+  return rankConstraints(assessment)[0];
+}
+
+// src/render/board-html.ts
+var LEVEL_BG = {
+  1: "#d7263d",
+  2: "#f46036",
+  3: "#2e933c",
+  4: "#1b998b",
+  5: "#2660a4"
+};
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function titleFor(rubric, key) {
+  return rubric.dimensions.find((d) => d.key === key)?.title ?? key;
+}
+function renderBoardHtml(assessment, summary, rubric) {
+  const byKey = new Map(summary.cells.map((c) => [c.key, c]));
+  const constraint = bindingConstraint(assessment);
+  const rows = AREAS.map((area) => {
+    const cells = LENSES.map((lens) => {
+      const key = `${area}.${lens}`;
+      const c = byKey.get(key);
+      if (!c) return "<td></td>";
+      const score = assessment.scores[key];
+      return `<td class="cell" style="background:${LEVEL_BG[c.level]}" title="${escapeHtml(
+        titleFor(rubric, key)
+      )}: ${escapeHtml(score.evidence)}">
+        <span class="lvl">${c.level}</span>
+        <span class="traj">${TRAJECTORY_GLYPHS[c.trajectory]}</span>
+      </td>`;
+    }).join("");
+    const label = area[0]?.toUpperCase() + area.slice(1);
+    return `<tr><th class="area">${label}</th>${cells}</tr>`;
+  }).join("");
+  const counts = summary.trajectoryCounts;
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Runboard \u2014 ${assessment.date}</title>
+<style>
+  body { font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif; margin: 2rem; color: #1a1a1a; }
+  h1 { font-size: 1.4rem; margin: 0 0 .25rem; }
+  .sub { color: #555; margin: 0 0 1.5rem; }
+  table { border-collapse: separate; border-spacing: 6px; }
+  th.area { text-align: right; padding-right: .75rem; font-weight: 600; }
+  th.lens { padding-bottom: .25rem; font-weight: 600; color: #444; }
+  td.cell { width: 90px; height: 70px; border-radius: 8px; color: #fff; text-align: center; vertical-align: middle; }
+  td.cell .lvl { display: block; font-size: 1.8rem; font-weight: 700; line-height: 1; }
+  td.cell .traj { font-size: 1.1rem; }
+  .meta { margin-top: 1.5rem; font-size: 1rem; }
+  .meta strong { font-size: 1.2rem; }
+  .constraint { margin-top: .5rem; padding: .75rem 1rem; background: #f4f4f5; border-radius: 8px; display: inline-block; }
+</style>
+</head>
+<body>
+  <h1>Runboard</h1>
+  <p class="sub">Assessment ${assessment.date}</p>
+  <table>
+    <tr><th></th>${LENSES.map((l) => `<th class="lens">${l[0]?.toUpperCase()}${l.slice(1)}</th>`).join("")}</tr>
+    ${rows}
+  </table>
+  <div class="meta">
+    Average <strong>${formatAverage(summary.average)}</strong> / 5
+    &nbsp;\xB7&nbsp; \u2B06 ${counts.up} &nbsp; \u27A1 ${counts.flat} &nbsp; \u2B07 ${counts.down} &nbsp; \u26A0 ${counts.volatile}
+  </div>
+  <div class="constraint">
+    Biggest constraint: <strong>${escapeHtml(titleFor(rubric, constraint.key))}</strong>
+    (level ${constraint.level}, ${constraint.trajectory})
+  </div>
+</body>
+</html>
+`;
+}
+
+// src/render/heatmap.ts
+import pc from "picocolors";
+function colorForLevel(level) {
+  switch (level) {
+    case 1:
+      return pc.red;
+    case 2:
+      return pc.yellow;
+    case 3:
+      return pc.green;
+    case 4:
+      return pc.cyan;
+    case 5:
+      return pc.blue;
+  }
+}
+function cell(level, trajectory) {
+  const text2 = ` ${level}${TRAJECTORY_GLYPHS[trajectory]} `;
+  return colorForLevel(level)(text2);
+}
+var LENS_HEADERS = {
+  team: "Team",
+  tools: "Tools",
+  techniques: "Techniques"
+};
+var AREA_HEADERS = {
+  build: "Build",
+  run: "Run",
+  plan: "Plan"
+};
+function renderHeatmap(assessment, summary) {
+  const byKey = new Map(
+    summary.cells.map((c) => [c.key, { level: c.level, trajectory: c.trajectory }])
+  );
+  const lines = [];
+  const header = `        ${LENSES.map((l) => LENS_HEADERS[l].padEnd(12)).join("")}`;
+  lines.push(pc.bold(header));
+  for (const area of AREAS) {
+    const cells = LENSES.map((lens) => {
+      const c = byKey.get(`${area}.${lens}`);
+      if (!c) return "".padEnd(12);
+      return cell(c.level, c.trajectory).padEnd(20);
+    });
+    lines.push(`${pc.bold(AREA_HEADERS[area].padEnd(8))}${cells.join("")}`);
+  }
+  const counts = summary.trajectoryCounts;
+  const countLine = `\u2B06 ${counts.up}  \u27A1 ${counts.flat}  \u2B07 ${counts.down}  \u26A0 ${counts.volatile}`;
+  const constraint = bindingConstraint(assessment);
+  lines.push("");
+  lines.push(`Average: ${pc.bold(formatAverage(summary.average))} / 5     ${countLine}`);
+  lines.push(
+    `Biggest constraint: ${pc.bold(constraint.key)} (level ${constraint.level}, ${constraint.trajectory})`
+  );
+  return lines.join("\n");
+}
+
+// src/commands/board.ts
+function runBoard(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  requireAssessments(listAssessmentDates(root));
+  const assessment = latestAssessment(root);
+  if (!assessment) {
+    throw new Error("unreachable");
+  }
+  const summary = summarise(assessment);
+  const text2 = renderHeatmap(assessment, summary);
+  if (opts.html) {
+    const rubric = loadRubric(runboardPaths(root).rubric);
+    const htmlPath = runboardPaths(root).boardHtml;
+    writeFileSync2(htmlPath, renderBoardHtml(assessment, summary, rubric), "utf8");
+    return { text: text2, assessment, summary, htmlPath };
+  }
+  return { text: text2, assessment, summary };
+}
+function registerBoard(program) {
+  program.command("board").description("Render the 3\xD73 heatmap; --html writes a shareable board.html.").option("--html", "also write a self-contained board.html").action((options) => {
+    const { text: text2, htmlPath } = runBoard({ html: options.html });
+    process.stdout.write(`${text2}
+`);
+    if (htmlPath) {
+      process.stdout.write(`
+Wrote ${htmlPath}
+`);
+    }
+  });
+}
+
+// src/commands/pulse.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import path5 from "path";
+
+// src/core/triggers.ts
+var TRIGGER_WINDOW = 3;
+var MAX_LEVEL = 5;
+function detectTriggers(assessmentsChrono) {
+  if (assessmentsChrono.length < TRIGGER_WINDOW) {
+    return [];
+  }
+  const window = assessmentsChrono.slice(-TRIGGER_WINDOW);
+  const triggered = [];
+  for (const key of DIMENSION_KEYS) {
+    const levels = window.map((a) => a.scores[key].level);
+    if (levels[levels.length - 1] >= MAX_LEVEL) {
+      continue;
+    }
+    let stuck = true;
+    for (let i = 1; i < levels.length; i++) {
+      if (levels[i] > levels[i - 1]) {
+        stuck = false;
+        break;
+      }
+    }
+    if (stuck) {
+      triggered.push(key);
+    }
+  }
+  return triggered;
+}
+
+// src/render/reports.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Eta } from "eta";
+
+// src/core/delta.ts
+function computeDeltas(previous, current) {
+  return DIMENSION_KEYS.map((key) => {
+    const from = previous.scores[key];
+    const to = current.scores[key];
+    return {
+      key,
+      from: from.level,
+      to: to.level,
+      change: to.level - from.level,
+      trajectoryFrom: from.trajectory,
+      trajectoryTo: to.trajectory
+    };
+  });
+}
+
+// src/render/reports.ts
+var NOW_LIMIT = 3;
+var NEXT_LIMIT = 5;
+function templatesDir() {
+  const here = path4.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [path4.resolve(here, "../templates"), path4.resolve(here, "../../templates")];
+  for (const candidate of candidates) {
+    try {
+      readFileSync3(path4.join(candidate, "roadmap.eta"));
+      return candidate;
+    } catch {
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+function eta() {
+  return new Eta({ views: templatesDir(), autoTrim: false });
+}
+function title(rubric, key) {
+  return rubric.dimensions.find((d) => d.key === key)?.title ?? key;
+}
+var OUTCOMES = {
+  "build.team": "Build retained engineering capability so delivery no longer depends on individuals.",
+  "build.tools": "Make builds and environments reproducible so releases are predictable.",
+  "build.techniques": "Establish a consistent delivery cadence so output is reliable.",
+  "run.team": "Put clear production ownership in place so incidents are handled, not improvised.",
+  "run.tools": "Extend monitoring so problems are caught before customers feel them.",
+  "run.techniques": "Adopt a defined incident process so outages shrink and don't recur.",
+  "plan.team": "Strengthen leadership\u2013business alignment so engineering is trusted and heard.",
+  "plan.tools": "Maintain a live roadmap so priorities are visible and defensible.",
+  "plan.techniques": "Set a clear strategy and prioritisation method so investment follows value."
+};
+function areaAverage(assessment, area) {
+  const levels = DIMENSION_KEYS.filter((k) => k.startsWith(`${area}.`)).map(
+    (k) => assessment.scores[k].level
+  );
+  return levels.reduce((s, l) => s + l, 0) / levels.length;
+}
+function buildRoadmap(assessment, rubric) {
+  const ranked = rankConstraints(assessment);
+  const belowTarget = ranked.filter((r) => r.level < 3);
+  const nowRanked = (belowTarget.length ? belowTarget : ranked.slice(0, 1)).slice(0, NOW_LIMIT);
+  const nowKeys = new Set(nowRanked.map((r) => r.key));
+  const remaining = ranked.filter((r) => !nowKeys.has(r.key));
+  const nextRanked = remaining.filter((r) => r.level <= 3).slice(0, NEXT_LIMIT);
+  const nextKeys = new Set(nextRanked.map((r) => r.key));
+  const laterRanked = remaining.filter((r) => !nextKeys.has(r.key));
+  const now = nowRanked.map((r) => OUTCOMES[r.key]);
+  const next = nextRanked.map((r) => OUTCOMES[r.key]);
+  const later = laterRanked.map(
+    (r) => `Sustain ${title(rubric, r.key)} (already at level ${r.level}).`
+  );
+  const constraint = bindingConstraint(assessment);
+  const text2 = eta().render("roadmap", {
+    date: assessment.date,
+    constraint: { ...constraint, title: title(rubric, constraint.key) },
+    now,
+    next,
+    later
+  });
+  return { text: text2, now, next, later };
+}
+function buildPulse(previous, current, history) {
+  const deltas = computeDeltas(previous, current);
+  const triggers = detectTriggers(history);
+  const improved = deltas.filter((d) => d.change > 0).map((d) => d.key);
+  const regressed = deltas.filter((d) => d.change < 0).map((d) => d.key);
+  return eta().render("pulse", {
+    date: current.date,
+    prevDate: previous.date,
+    average: formatAverage(summarise(current).average),
+    prevAverage: formatAverage(summarise(previous).average),
+    deltas,
+    triggers,
+    improved,
+    regressed
+  });
+}
+function buildReport(type, assessment, rubric, history) {
+  const summary = summarise(assessment);
+  const average = formatAverage(summary.average);
+  const constraint = bindingConstraint(assessment);
+  const roadmap = buildRoadmap(assessment, rubric);
+  if (type === "board-update") {
+    return eta().render("board-update", {
+      date: assessment.date,
+      average,
+      headline: summary.average >= 3 ? "We are at or above our target operating level." : "We are below our target operating level and investing to close the gap.",
+      areas: AREAS.map((area) => ({
+        title: area[0]?.toUpperCase() + area.slice(1),
+        average: formatAverage(areaAverage(assessment, area)),
+        comment: areaAverage(assessment, area) >= 3 ? "Operating reliably." : "Needs investment."
+      })),
+      constraint: { ...constraint, title: title(rubric, constraint.key) },
+      constraintBusiness: OUTCOMES[constraint.key],
+      now: roadmap.now,
+      triggers: detectTriggers(history).map((k) => title(rubric, k))
+    });
+  }
+  if (type === "baseline") {
+    return eta().render("baseline", {
+      date: assessment.date,
+      average,
+      rows: DIMENSION_KEYS.map((k) => ({
+        title: title(rubric, k),
+        level: assessment.scores[k].level,
+        trajectory: assessment.scores[k].trajectory,
+        evidence: assessment.scores[k].evidence
+      })),
+      constraint: { ...constraint, title: title(rubric, constraint.key) }
+    });
+  }
+  if (type === "monthly") {
+    return eta().render("monthly", {
+      date: assessment.date,
+      average,
+      areas: AREAS.map((area) => ({
+        title: area[0]?.toUpperCase() + area.slice(1),
+        average: formatAverage(areaAverage(assessment, area))
+      })),
+      constraint: { ...constraint, title: title(rubric, constraint.key) }
+    });
+  }
+  throw new UserError(`Unknown report type "${type}". Use board-update, baseline, or monthly.`);
+}
+
+// src/commands/pulse.ts
+function runPulse(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  const all = loadAllAssessments(root);
+  if (all.length < 2) {
+    throw new UserError(
+      "Pulse needs at least two assessments to compare. Run `runboard assess` again later."
+    );
+  }
+  const current = all[all.length - 1];
+  const previous = all[all.length - 2];
+  if (!current || !previous) throw new Error("unreachable");
+  const text2 = buildPulse(previous, current, all);
+  const triggers = detectTriggers(all);
+  const reportsDir = runboardPaths(root).reportsDir;
+  mkdirSync2(reportsDir, { recursive: true });
+  const file = path5.join(reportsDir, `pulse-${current.date}.md`);
+  writeFileSync3(file, text2, "utf8");
+  return { path: file, text: text2, triggers };
+}
+function registerPulse(program) {
+  program.command("pulse").description("Compare the two latest assessments; flag stuck dimensions.").action(() => {
+    const { path: file, triggers } = runPulse();
+    process.stdout.write(`Wrote ${file}
+`);
+    if (triggers.length > 0) {
+      process.stdout.write(`
+Auto-triggers (stuck 3 assessments): ${triggers.join(", ")}
+`);
+    } else {
+      process.stdout.write("\nNothing is stuck across the last three assessments.\n");
+    }
+  });
+}
+
+// src/commands/report.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import path6 from "path";
+function runReport(opts) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  requireAssessments(listAssessmentDates(root));
+  if (!opts.type) {
+    throw new UserError("report requires --type board-update|baseline|monthly.");
+  }
+  const assessment = latestAssessment(root);
+  if (!assessment) throw new Error("unreachable");
+  const rubric = loadRubric(runboardPaths(root).rubric);
+  const history = loadAllAssessments(root);
+  const text2 = buildReport(opts.type, assessment, rubric, history);
+  const reportsDir = runboardPaths(root).reportsDir;
+  mkdirSync3(reportsDir, { recursive: true });
+  const file = path6.join(reportsDir, `${opts.type}-${assessment.date}.md`);
+  writeFileSync4(file, text2, "utf8");
+  return { path: file, text: text2 };
+}
+function registerReport(program) {
+  program.command("report").description("Render a report from a template (board-update | baseline | monthly).").requiredOption("--type <type>", "board-update | baseline | monthly").action((options) => {
+    const { path: path7 } = runReport({ type: options.type });
+    process.stdout.write(`Wrote ${path7}
+`);
+  });
+}
+
+// src/commands/roadmap.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+function runRoadmap(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  requireInit(root);
+  requireAssessments(listAssessmentDates(root));
+  const assessment = latestAssessment(root);
+  if (!assessment) throw new Error("unreachable");
+  const rubric = loadRubric(runboardPaths(root).rubric);
+  const { text: text2 } = buildRoadmap(assessment, rubric);
+  const file = runboardPaths(root).roadmap;
+  writeFileSync5(file, text2, "utf8");
+  return { path: file, text: text2 };
+}
+function registerRoadmap(program) {
+  program.command("roadmap").description("Generate a Now/Next/Later plan from your binding constraint.").action(() => {
+    const { path: path7 } = runRoadmap();
+    process.stdout.write(`Wrote ${path7}
+`);
+  });
+}
+
+// src/commands/status.ts
+function runStatus(root = process.cwd()) {
+  requireInit(root);
+  const all = loadAllAssessments(root);
+  if (all.length === 0) {
+    return { activeTriggers: [], empty: true };
+  }
+  const latest = all[all.length - 1];
+  if (!latest) throw new Error("unreachable");
+  const summary = summarise(latest);
+  return {
+    latestDate: latest.date,
+    average: formatAverage(summary.average),
+    trajectoryCounts: summary.trajectoryCounts,
+    activeTriggers: detectTriggers(all),
+    empty: false
+  };
+}
+function registerStatus(program) {
+  program.command("status").description("One-screen current state.").action(() => {
+    const s = runStatus();
+    if (s.empty) {
+      process.stdout.write("No assessments yet. Run `runboard assess` to record one.\n");
+      return;
+    }
+    const counts = s.trajectoryCounts ?? {};
+    process.stdout.write(
+      [
+        `Latest assessment: ${s.latestDate}`,
+        `Average:           ${s.average} / 5`,
+        `Trajectory:        \u2B06 ${counts.up ?? 0}  \u27A1 ${counts.flat ?? 0}  \u2B07 ${counts.down ?? 0}  \u26A0 ${counts.volatile ?? 0}`,
+        `Active triggers:   ${s.activeTriggers.length ? s.activeTriggers.join(", ") : "none"}`,
+        ""
+      ].join("\n")
+    );
+  });
+}
+
+export {
+  runboardPaths,
+  latestAssessment,
+  shippedRubricPath,
+  loadRubric,
+  UserError,
+  runAssess,
+  registerAssess,
+  formatAverage,
+  bindingConstraint,
+  runBoard,
+  registerBoard,
+  runPulse,
+  registerPulse,
+  runReport,
+  registerReport,
+  runRoadmap,
+  registerRoadmap,
+  runStatus,
+  registerStatus
+};