beadcyte 0.4.0

package/src/web/walkthrough.ts

@@ -0,0 +1,133 @@
+// walkthrough.ts — the first-run walkthrough's content and memory (bp-67g.48).
+//
+// A short tour of the things a first-time reader would not guess, in the
+// order they would not guess them. Two rules shape it:
+//
+//   NOTHING EXISTS ONLY HERE. Every step names where the same fact lives
+//   outside the tour (`alsoIn`) — the README, docs/model.md, a hover in the
+//   drawer — because a tour is dismissed once and then it is gone. The bar
+//   kinds come from view-model.ts's own notes, which the Gantt footer shows
+//   on hover, so the tour cannot describe kinds the code does not draw.
+//
+//   NEVER UNASKED TWICE. Seen-ness is one localStorage key. Dismissing or
+//   finishing sets it; the options menu re-opens the tour on request. When
+//   storage is unreadable (a private window, blocked site data) the tour
+//   counts as seen, because showing it on every load is worse than not
+//   showing it — it is one click away in the options menu either way.
+//
+// Pure, so the content can be checked by a test for coverage and pointers.
+
+import { BAR_KIND_NOTES, type BarKind } from "./view-model.ts";
+import type { ViewMode } from "./composables/url-codec";
+
+export const WALKTHROUGH_STORAGE_KEY = "beadcyte:walkthrough";
+
+export interface WalkStep {
+  id: string;
+  title: string;
+  /** Plain sentences; the panel renders them as a paragraph. */
+  body: string;
+  /** Where else this is written down. Printed, so the reader can go there. */
+  alsoIn: string;
+  /** A view worth looking at while reading this step; offered, never forced. */
+  view?: ViewMode;
+  /** Render the bar-kind list under the body. */
+  kinds?: boolean;
+}
+
+export const WALKTHROUGH_STEPS: readonly WalkStep[] = [
+  {
+    id: "timeline",
+    title: "History and a projection on one timeline",
+    body:
+      "Left of the red rule is what happened: real started_at → closed_at bars, with a marker on the ones that shipped. Right of it is a projection. The bar kinds tell the two apart, and the footer under the Gantt counts them by kind:",
+    kinds: true,
+    alsoIn: "README › Gantt; the kind names in the Gantt footer explain themselves on hover",
+    view: "gantt",
+  },
+  {
+    id: "model",
+    title: "The future is a model, not a plan anyone made",
+    body:
+      "Every future bar comes from an estimator — the median of how long comparable shipped work actually took — fed to a greedy scheduler that gives each person their highest-priority ready bead within a calibrated work-in-progress cap. A hatched bar means the scheduler also guessed WHO does it. A finish that says “after” a date is a bound, not a projection: the plan ran past the window.",
+    alsoIn: "docs/model.md; hover Estimate, Starts, Projected finish and the inferred marker in the drawer",
+    view: "gantt",
+  },
+  {
+    id: "triage",
+    title: "Triage ranks the work by eight weighted signals",
+    body:
+      "The score is a weighted sum — PageRank and betweenness over the blocks graph, how many beads this one unblocks, priority, time to impact, urgency, risk and staleness — scaled so the largest value in your repo is 1. Open any bead and the drawer shows its score in the population, then the breakdown; every signal name explains what it measures.",
+    alsoIn: "docs/model.md › Triage; hover any signal name in the drawer",
+  },
+  {
+    id: "views",
+    title: "Five views, five questions",
+    body:
+      "Mine: what should I be doing. Gantt: when. Grid: browse the same set as cards. Table: compare and sort every derived number at once. Incytes: how the whole project is doing — ships per week and, beside them, what the weeks cost in seat hours and tokens, measured behind today and projected ahead (dulled) from the median cost of comparable shipped work; the only view that ignores the filters, and the controls dim to say so.",
+    alsoIn: "README › The tour",
+    view: "table",
+  },
+  {
+    id: "controls",
+    title: "Filters, window, highlight — and the keyboard",
+    body:
+      "Filters narrow which beads are in view; the window decides which dates; highlight paints blocked, over-cap and ready-now onto the Gantt and grid. A dimmed group is one the current view cannot act on. Press ? for the shortcuts: single letters, j and k walk the beads, and nothing fires while you are typing.",
+    alsoIn: "README › Keyboard; the ? overlay",
+  },
+  {
+    id: "done",
+    title: "That is the tour",
+    body:
+      "It will not appear again unless you ask: the options menu (gear, top right) re-opens it. Everything it said is also in the README, docs/model.md and the hovers.",
+    alsoIn: "Options › Walkthrough",
+  },
+];
+
+/** The kinds in the order the timeline reads them, past to future. */
+export const BAR_KIND_ORDER: readonly BarKind[] = [
+  "shipped",
+  "closedNoShip",
+  "inProgressLive",
+  "future",
+  "futureBacklog",
+  "unassigned",
+  "waitUnclaimed",
+  "waitReview",
+];
+
+export function barKindNotes(): Array<{ kind: BarKind; note: string }> {
+  return BAR_KIND_ORDER.map((kind) => ({ kind, note: BAR_KIND_NOTES[kind] }));
+}
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+function storage(): StorageLike | null {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Has this browser seen (or dismissed) the tour? Unreadable storage counts as seen. */
+export function walkthroughSeen(store: StorageLike | null = storage()): boolean {
+  if (!store) return true;
+  try {
+    return store.getItem(WALKTHROUGH_STORAGE_KEY) !== null;
+  } catch {
+    return true;
+  }
+}
+
+export function markWalkthroughSeen(store: StorageLike | null = storage(), at: Date = new Date()): void {
+  if (!store) return;
+  try {
+    store.setItem(WALKTHROUGH_STORAGE_KEY, at.toISOString());
+  } catch {
+    // Nothing to do: the tour stays re-openable and will show again next load.
+  }
+}

package/src/web/watchlist.ts

@@ -0,0 +1,47 @@
+// watchlist.ts — the personal watch list's storage format.
+//
+// Pure and localStorage-free so the format is testable; the store owns the
+// reactive set and calls load/save at the edges.
+
+/** Namespaced so it can't collide with the label-column width or anything
+ *  else this app keeps per browser. */
+export const WATCHLIST_STORAGE_KEY = "beadcyte:watchlist";
+
+/**
+ * Parse a stored watch list. Anything malformed yields an empty list rather
+ * than throwing: this is a convenience feature, and a corrupt value must not
+ * take the app down on boot. Non-string entries and duplicates are dropped,
+ * and order is preserved so the hover list stays stable between sessions.
+ */
+export function parseWatched(raw: string | null | undefined): string[] {
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const v of parsed) {
+    if (typeof v !== "string") continue;
+    const id = v.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
+export function serializeWatched(ids: readonly string[]): string {
+  return JSON.stringify(ids);
+}
+
+/**
+ * Add or remove an id, returning a new list. Newly watched ids go on the end
+ * so the list reads in the order things were added.
+ */
+export function toggleWatched(ids: readonly string[], id: string): string[] {
+  return ids.includes(id) ? ids.filter((x) => x !== id) : [...ids, id];
+}

package/src/web/whatif.ts

@@ -0,0 +1,291 @@
+// whatif.ts — the "diff bead" (bp-q56): a change set applied to a COPY of the
+// beads and roster, re-scheduled by the same pipeline as the real plan, and
+// diffed against it. Nothing here writes; confirming is the apply path
+// (bp-2fq), and until then the change set exports as bd commands to paste.
+//
+// A what-if is a session, not a link: it is not carried in the URL.
+
+import type { Bead, Roster } from "./store";
+import type { Schedule } from "./view-model";
+import type { Mutation } from "./mutations";
+
+export type WhatIfChange =
+  | { kind: "reassign"; id: string; assignee: string | null }
+  | { kind: "priority"; id: string; priority: number }
+  | { kind: "spec-ready"; id: string; ready: boolean }
+  | { kind: "cap"; handle: string; cap: number }
+  | { kind: "idea"; id: string; title: string; type: string; priority: number; hours: number; assignee: string | null };
+
+export const IDEA_PREFIX = "what-if-";
+
+export function isHypothetical(id: string): boolean {
+  return id.startsWith(IDEA_PREFIX);
+}
+
+/** The key a change replaces: one change per target per kind. */
+export function changeKey(c: WhatIfChange): string {
+  switch (c.kind) {
+    case "cap":
+      return `cap:${c.handle}`;
+    case "idea":
+      return `idea:${c.id}`;
+    default:
+      return `${c.kind}:${c.id}`;
+  }
+}
+
+/** Add or replace: a second reassign of the same bead replaces the first. */
+export function upsertChange(changes: readonly WhatIfChange[], c: WhatIfChange): WhatIfChange[] {
+  const k = changeKey(c);
+  return [...changes.filter((x) => changeKey(x) !== k), c];
+}
+
+export function describeChange(c: WhatIfChange, titleOf: (id: string) => string | undefined): string {
+  const name = (id: string) => `${id}${titleOf(id) ? ` · ${titleOf(id)!.slice(0, 40)}` : ""}`;
+  switch (c.kind) {
+    case "reassign":
+      return `${name(c.id)} → ${c.assignee ?? "unassigned"}`;
+    case "priority":
+      return `${name(c.id)} → P${c.priority}`;
+    case "spec-ready":
+      return `${name(c.id)} → ${c.ready ? "spec:ready" : "not spec:ready"}`;
+    case "cap":
+      return `${c.handle}'s cap → ${c.cap}`;
+    case "idea":
+      return `idea: ${c.title} (${c.type}, P${c.priority}, ~${c.hours}h${c.assignee ? `, ${c.assignee}` : ""})`;
+  }
+}
+
+/**
+ * The beads and roster the what-if schedules: deep enough copies that the
+ * real payload is never touched. Ideas become open beads with a hypothetical
+ * id and a size the estimator honours (metadata.whatif.hours).
+ */
+export function applyChanges(
+  beads: readonly Bead[],
+  roster: Roster,
+  changes: readonly WhatIfChange[],
+  now: Date = new Date(),
+): { beads: Bead[]; roster: Roster } {
+  const byId = new Map<string, Bead>(beads.map((b) => [b.id, { ...b, labels: [...(b.labels ?? [])] }]));
+  const humans = roster.humans.map((h) => ({ ...h }));
+  for (const c of changes) {
+    switch (c.kind) {
+      case "reassign": {
+        const b = byId.get(c.id);
+        if (b) b.assignee = c.assignee;
+        break;
+      }
+      case "priority": {
+        const b = byId.get(c.id);
+        if (b) b.priority = c.priority;
+        break;
+      }
+      case "spec-ready": {
+        const b = byId.get(c.id);
+        if (!b) break;
+        const has = b.labels!.includes("spec:ready");
+        if (c.ready && !has) b.labels!.push("spec:ready");
+        if (!c.ready && has) b.labels = b.labels!.filter((l) => l !== "spec:ready");
+        break;
+      }
+      case "cap": {
+        // Authoritative: a what-if cap is not calibrated back (velocity.mjs
+        // honours cap_fixed), or the scenario could never be seen.
+        const h = humans.find((x) => x.handle === c.handle);
+        if (h) {
+          h.cap = c.cap;
+          h.cap_fixed = true;
+        } else humans.push({ handle: c.handle, cap: c.cap, cap_fixed: true });
+        break;
+      }
+      case "idea": {
+        const iso = now.toISOString();
+        byId.set(c.id, {
+          id: c.id,
+          title: `idea · ${c.title}`,
+          status: "open",
+          priority: c.priority,
+          issue_type: c.type,
+          assignee: c.assignee,
+          parent: null,
+          labels: ["spec:ready"],
+          started_at: null,
+          closed_at: null,
+          created_at: iso,
+          updated_at: iso,
+          dependencies: [],
+          metadata: { whatif: { hours: c.hours } },
+          hypothetical: true,
+        });
+        break;
+      }
+    }
+  }
+  return { beads: [...byId.values()], roster: { ...roster, humans } };
+}
+
+/** An idea's own size, in the estimator's units, or null for a real bead. */
+export function ideaEstimateDays(bead: { metadata?: Record<string, unknown> | null }): number | null {
+  const w = (bead.metadata as { whatif?: { hours?: unknown } } | null | undefined)?.whatif;
+  return w && typeof w.hours === "number" && w.hours > 0 ? w.hours / 24 : null;
+}
+
+export interface MovedBead {
+  id: string;
+  title: string;
+  assigneeBefore: string | null;
+  assigneeAfter: string | null;
+  /** Landing, in days from today. */
+  landBefore: number;
+  landAfter: number;
+  /** Positive: lands later. */
+  deltaDays: number;
+  /** The work spans, for the Gantt's ghost bar. */
+  workBefore: { start: number; end: number };
+  workAfter: { start: number; end: number };
+}
+
+export interface FrontierRow {
+  handle: string;
+  before: number;
+  after: number;
+}
+
+export interface PlanDiff {
+  moved: MovedBead[];
+  /** Hypothetical ideas and where they land. */
+  added: Array<{ id: string; title: string; assignee: string | null; land: number | null }>;
+  frontier: FrontierRow[];
+  frontierDays: number;
+  /** Beads whose landing changed by less than the noise floor: not listed. */
+  unchanged: number;
+}
+
+type Entry = { start_day: number; end_day: number; work_start_day?: number; work_end_day?: number; assignee?: string; synthetic_assignee?: boolean };
+
+/**
+ * What changed between two plans over the same (extended) bead set. A move
+ * is a landing shifted by at least a quarter day, or a change of hands.
+ */
+export function diffPlans(
+  before: Schedule,
+  after: Schedule,
+  beadsAfter: readonly Bead[],
+  opts: { frontierDays?: number } = {},
+): PlanDiff {
+  const frontierDays = opts.frontierDays ?? 14;
+  const titleOf = new Map(beadsAfter.map((b) => [b.id, b.title] as const));
+  const moved: MovedBead[] = [];
+  const added: PlanDiff["added"] = [];
+  let unchanged = 0;
+  for (const b of beadsAfter) {
+    const a = after.get(b.id) as Entry | undefined;
+    if (isHypothetical(b.id)) {
+      added.push({ id: b.id, title: b.title, assignee: a?.assignee ?? b.assignee ?? null, land: a ? a.end_day : null });
+      continue;
+    }
+    const p = before.get(b.id) as Entry | undefined;
+    if (!p || !a) continue;
+    const delta = a.end_day - p.end_day;
+    const hands = (p.assignee ?? null) !== (a.assignee ?? null);
+    if (Math.abs(delta) < 0.25 && !hands) {
+      unchanged++;
+      continue;
+    }
+    moved.push({
+      id: b.id,
+      title: titleOf.get(b.id) ?? b.id,
+      assigneeBefore: p.assignee ?? null,
+      assigneeAfter: a.assignee ?? null,
+      landBefore: p.end_day,
+      landAfter: a.end_day,
+      deltaDays: delta,
+      workBefore: { start: p.work_start_day ?? p.start_day, end: p.work_end_day ?? p.end_day },
+      workAfter: { start: a.work_start_day ?? a.start_day, end: a.work_end_day ?? a.end_day },
+    });
+  }
+  moved.sort((x, y) => Math.abs(y.deltaDays) - Math.abs(x.deltaDays) || x.id.localeCompare(y.id));
+
+  // The frontier: how many beads land for each person within N days.
+  const count = (s: Schedule) => {
+    const m = new Map<string, number>();
+    for (const e of s.values() as Iterable<Entry>) {
+      if (!e.assignee) continue;
+      if (e.end_day <= frontierDays) m.set(e.assignee, (m.get(e.assignee) ?? 0) + 1);
+    }
+    return m;
+  };
+  const cb = count(before);
+  const ca = count(after);
+  const handles = [...new Set([...cb.keys(), ...ca.keys()])].sort();
+  const frontier = handles.map((handle) => ({ handle, before: cb.get(handle) ?? 0, after: ca.get(handle) ?? 0 }));
+  return { moved, added, frontier, frontierDays, unchanged };
+}
+
+/** "3d later" / "2d earlier" / "same day" for a delta. */
+export function describeDelta(deltaDays: number): string {
+  const d = Math.abs(deltaDays);
+  const n = d >= 1 ? `${d.toFixed(d >= 10 ? 0 : 1)}d` : `${Math.round(d * 24)}h`;
+  if (d < 0.25) return "same day";
+  return deltaDays > 0 ? `${n} later` : `${n} earlier`;
+}
+
+/**
+ * The change set as bd commands, for confirming by hand until the apply path
+ * exists (bp-2fq). A cap is a roster.json edit, not a bd command, and says so.
+ */
+export function whatIfCommands(changes: readonly WhatIfChange[]): string[] {
+  const out: string[] = [];
+  for (const c of changes) {
+    switch (c.kind) {
+      case "reassign":
+        out.push(c.assignee ? `bd update ${c.id} --assignee ${c.assignee}` : `bd update ${c.id} --assignee ""`);
+        break;
+      case "priority":
+        out.push(`bd update ${c.id} --priority ${c.priority}`);
+        break;
+      case "spec-ready":
+        out.push(`bd update ${c.id} ${c.ready ? "--add-label" : "--remove-label"} spec:ready`);
+        break;
+      case "idea":
+        out.push(`bd create ${JSON.stringify(c.title)} -t ${c.type} -p ${c.priority} -l spec:ready${c.assignee ? ` -a ${c.assignee}` : ""}  # ~${c.hours}h`);
+        break;
+      case "cap":
+        out.push(`# .beadcyte/roster.json: set "cap": ${c.cap} on ${c.handle}`);
+        break;
+    }
+  }
+  return out;
+}
+
+/**
+ * The change set as whitelisted mutations for /api/mutate (bp-2fq), in
+ * order. A cap is not a bd fact — it lives in roster.json — so it is
+ * returned separately for the summary rather than silently dropped.
+ */
+export function mutationsFor(changes: readonly WhatIfChange[]): { mutations: Mutation[]; skipped: WhatIfChange[] } {
+  const mutations: Mutation[] = [];
+  const skipped: WhatIfChange[] = [];
+  for (const c of changes) {
+    switch (c.kind) {
+      case "reassign":
+        if (c.assignee) mutations.push({ action: "assign", id: c.id, assignee: c.assignee });
+        else skipped.push(c); // bd has no whitelisted "unassign"; say so
+        break;
+      case "priority":
+        mutations.push({ action: "priority", id: c.id, priority: c.priority });
+        break;
+      case "spec-ready":
+        mutations.push({ action: c.ready ? "spec-ready" : "unspec-ready", id: c.id });
+        break;
+      case "idea":
+        mutations.push({ action: "create", id: "", title: c.title, type: c.type, priority: c.priority, labels: ["spec:ready"], ...(c.assignee ? { assignee: c.assignee } : {}) });
+        break;
+      case "cap":
+        skipped.push(c);
+        break;
+    }
+  }
+  return { mutations, skipped };
+}

package/src/web/window.ts

@@ -0,0 +1,73 @@
+// window.ts — the time window the chart covers, and its presets.
+//
+// Extracted from store.ts so it can be tested. store.ts imports pinia and a
+// dozen sibling modules with extensionless specifiers, which `node --test`
+// cannot resolve, so nothing in it was reachable from a test — and the preset
+// list turned out to be exactly the kind of thing that needs one: a duplicated
+// copy of this mapping lived in ControlsPanel.vue and silently stopped
+// agreeing the moment a seventh preset was added to one switch and not the
+// other. One definition, one test over it.
+//
+// Pure: no store, no DOM.
+
+import type { WindowSpec } from "./view-model";
+
+export type WindowPreset =
+  | "7d"
+  | "30d"
+  | "90d"
+  | "180d"
+  | "future"
+  | "history"
+  | "all";
+
+/**
+ * Presets in the order they appear in the control, tightest first.
+ *
+ * ±7d is the near-term view, and it is the only preset at which the
+ * estimator's sub-day spread is visible: at ±90d one day is about 6px of an
+ * 1100px plot, so every short bead renders at the Gantt's 2px minimum width
+ * and they all look alike. At ±7d a day is ~78px.
+ */
+export const WINDOW_PRESETS: Array<{ id: WindowPreset; label: string }> = [
+  { id: "7d", label: "±7d" },
+  { id: "30d", label: "±30d" },
+  { id: "90d", label: "±90d" },
+  { id: "180d", label: "±180d" },
+  { id: "future", label: "future" },
+  { id: "history", label: "history" },
+  { id: "all", label: "all" },
+];
+
+/**
+ * The window a preset means, relative to `asOf` (default today).
+ *
+ * `asOf` exists for tests: every preset except `all` is relative to now, so
+ * asserting anything about them against a moving clock is a coin flip.
+ */
+export function windowFromPreset(
+  p: WindowPreset,
+  asOf: Date = new Date(),
+): WindowSpec {
+  const days = (n: number) => {
+    const d = new Date(asOf);
+    d.setDate(d.getDate() + n);
+    return d;
+  };
+  switch (p) {
+    case "7d":
+      return { from: days(-7), to: days(7) };
+    case "30d":
+      return { from: days(-30), to: days(30) };
+    case "90d":
+      return { from: days(-90), to: days(90) };
+    case "180d":
+      return { from: days(-180), to: days(180) };
+    case "future":
+      return { from: new Date(asOf), to: days(180) };
+    case "history":
+      return { from: days(-365), to: new Date(asOf) };
+    case "all":
+      return { from: null, to: null };
+  }
+}

package/src/web/wip.ts

@@ -0,0 +1,83 @@
+// wip.ts — work in flight against the calibrated cap, per person (bp-67g.29).
+//
+// The calibration strip used to say "cap 5→1 · 0.9/wk" per person: accurate,
+// and silent about the thing that matters. On the reference project four of
+// five people were over their calibrated cap by 5–13x, and the text could not
+// say so. These rows put every person on ONE shared scale — per-row scales
+// would make 13 and 3 look alike — with the cap as a notch on the measure and
+// the run past it drawn at its real length.
+//
+// Nothing new is computed: in-flight is a count over the beads, and the cap,
+// its pre-calibration value and the close-rate come off the calibrated roster
+// the scheduler already built. Pure, so the shape is testable.
+
+import type { Bead } from "./store";
+import { IN_FLIGHT_STATUSES } from "./highlights.ts";
+
+/** A roster human as the calibrated roster carries it (see velocity.mjs). */
+export interface CalibratedHuman {
+  handle: string;
+  cap?: number;
+  _rawCap?: number;
+  _closesPerWeek?: number;
+  _hoursPerWeek?: number;
+}
+
+export interface WipRow {
+  handle: string;
+  inFlight: number;
+  cap: number;
+  /** The cap before calibration; equal to `cap` when nothing moved. */
+  rawCap: number;
+  /** In-flight past the cap, 0 when within it. */
+  over: number;
+  closesPerWeek: number;
+  hoursPerWeek: number;
+}
+
+export const DEFAULT_CAP = 5;
+
+/**
+ * One row per roster human, worst ratio first so the people to talk to are
+ * at the top. A person with nothing in flight still gets a row: absence is
+ * part of the picture.
+ */
+export function wipRows(beads: readonly Bead[], humans: readonly CalibratedHuman[]): WipRow[] {
+  const inFlight = new Map<string, number>();
+  for (const b of beads) {
+    if (!b.assignee || !IN_FLIGHT_STATUSES.includes(b.status)) continue;
+    inFlight.set(b.assignee, (inFlight.get(b.assignee) ?? 0) + 1);
+  }
+  return humans
+    .map((h) => {
+      const cap = h.cap ?? DEFAULT_CAP;
+      const n = inFlight.get(h.handle) ?? 0;
+      return {
+        handle: h.handle,
+        inFlight: n,
+        cap,
+        rawCap: h._rawCap ?? cap,
+        over: Math.max(0, n - cap),
+        closesPerWeek: h._closesPerWeek ?? 0,
+        hoursPerWeek: h._hoursPerWeek ?? 0,
+      };
+    })
+    .sort((a, b) => b.inFlight / b.cap - a.inFlight / a.cap || a.handle.localeCompare(b.handle));
+}
+
+/** The scale every row shares: the largest in-flight or cap across everyone, never below 1. */
+export function wipScaleMax(rows: readonly WipRow[]): number {
+  return Math.max(1, ...rows.map((r) => Math.max(r.inFlight, r.cap)));
+}
+
+/** "cap 5→1" when calibration moved it, "cap 5" when it did not. */
+export function capBlurb(row: WipRow): string {
+  return row.rawCap !== row.cap ? `cap ${row.rawCap}→${row.cap}` : `cap ${row.cap}`;
+}
+
+/** "0.9/wk · 12h/wk", or "no ships" when the window saw none. */
+export function rateBlurb(row: WipRow): string {
+  if (row.closesPerWeek <= 0) return "no ships";
+  const hours = row.hoursPerWeek > 0 ? ` · ${row.hoursPerWeek.toFixed(0)}h/wk` : "";
+  return `${row.closesPerWeek.toFixed(1)}/wk${hours}`;
+}