beadcyte 0.4.0

package/src/web/frontier.ts

@@ -0,0 +1,208 @@
+// frontier.ts — the plan's edge for one person (bp-wfe).
+//
+// Two things, both pure:
+//
+//   - the LANE: over the next N days, which beads start for this person and
+//     which land, read straight off the two-clock schedule (the same entries
+//     the Gantt draws), with synthetic assignments marked as such;
+//   - PROPOSALS: what this person could take next, ranked with the reasons
+//     stated — the scheduler's own routing (one definition, exported from
+//     scheduler.mjs: affinityMarksFor / beadAffinityMatches), triage score,
+//     unblocking power, priority, and whether they have room today — and,
+//     where someone else is over cap, their not-yet-started beads offered
+//     across as reassignments.
+//
+// DECISION (owner, 2026-09-05): the planner may propose reassignments across
+// people, but every proposal is confirmed by the owner. So a proposal is a
+// what-if change (bp-q56), never a write: accepting it stages it, the diff
+// shows what moves, and confirm (bp-2fq) is where bd is touched.
+
+import type { Bead } from "./store";
+import type { Schedule } from "./view-model";
+import type { TriageResult } from "./triage";
+import type { WhatIfChange } from "./whatif";
+import { resolveAssignee } from "./view-model.ts";
+import { FINISHED_STATUSES, IN_FLIGHT_STATUSES, NOT_WORKABLE_STATUSES, READY_LABEL, hasOpenBlocker } from "./highlights.ts";
+import { affinityMarksFor, beadAffinityMatches } from "../scheduler.mjs";
+import { DEFAULT_CAP } from "./wip.ts";
+
+// ── the lane ──────────────────────────────────────────────────────────────
+
+export interface FrontierMarker {
+  id: string;
+  title: string;
+  /** "starts": the work begins for them; "lands": the bead is projected done. */
+  kind: "starts" | "lands";
+  /** Days from today, fractional. */
+  day: number;
+  /** The assignment is the scheduler's, not recorded on the bead. */
+  synthetic: boolean;
+}
+
+export interface FrontierLane {
+  days: number;
+  markers: FrontierMarker[];
+  starts: number;
+  lands: number;
+}
+
+const isEpic = (b: Bead) => b.issue_type === "epic";
+
+/**
+ * The next `days` days for one person. A bead already in flight has no
+ * "starts" marker (it started); a bead landing past the horizon has no
+ * "lands" marker but may still start inside it.
+ */
+export function frontierLane(handle: string, beads: readonly Bead[], schedule: Schedule | null, days: number): FrontierLane {
+  const markers: FrontierMarker[] = [];
+  if (schedule) {
+    for (const b of beads) {
+      if (isEpic(b) || FINISHED_STATUSES.includes(b.status)) continue;
+      const sched = schedule.get(b.id);
+      if (!sched) continue;
+      const who = resolveAssignee(b, sched);
+      if (who.handle !== handle) continue;
+      const start = sched.work_start_day ?? sched.start_day;
+      if (!IN_FLIGHT_STATUSES.includes(b.status) && start >= 0 && start <= days) {
+        markers.push({ id: b.id, title: b.title, kind: "starts", day: start, synthetic: who.synthetic });
+      }
+      if (sched.end_day >= 0 && sched.end_day <= days) {
+        markers.push({ id: b.id, title: b.title, kind: "lands", day: sched.end_day, synthetic: who.synthetic });
+      }
+    }
+  }
+  markers.sort((a, b) => a.day - b.day || a.id.localeCompare(b.id));
+  return {
+    days,
+    markers,
+    starts: markers.filter((m) => m.kind === "starts").length,
+    lands: markers.filter((m) => m.kind === "lands").length,
+  };
+}
+
+/** "3 start, 2 land in the next 14 days", or the honest empty sentence. */
+export function describeLane(lane: FrontierLane): string {
+  if (!lane.markers.length) return `nothing starts or lands for them in the next ${lane.days} days`;
+  return `${lane.starts} start${lane.starts === 1 ? "s" : ""}, ${lane.lands} land${lane.lands === 1 ? "s" : ""} in the next ${lane.days} days`;
+}
+
+// ── proposals ─────────────────────────────────────────────────────────────
+
+export interface RosterHumanForProposals {
+  handle: string;
+  cap?: number;
+  labels?: string[];
+  areas?: string[];
+}
+
+export interface Proposal {
+  bead: Bead;
+  score: number;
+  /** Stated, in the order they were weighed; shown beside the row. */
+  reasons: string[];
+  /** The person it would come from, when it is a reassignment. */
+  from: string | null;
+  /** Accepting = staging this in the what-if. */
+  change: WhatIfChange;
+}
+
+export interface ProposalOptions {
+  limit?: number;
+}
+
+/**
+ * Rank what `handle` could take next. Candidates are workable (not
+ * deferred/finished/in flight), unblocked, non-epic beads that are unassigned,
+ * or assigned to someone over their cap and not yet started — those are the
+ * reassignments the owner decided the planner may propose. spec:ready is a
+ * reason, not a gate, as in the scheduler's own pool pick. Weights are
+ * stated in code because they are the argument; the reasons repeat them in
+ * words.
+ */
+export function proposeNext(
+  handle: string,
+  beads: readonly Bead[],
+  humans: readonly RosterHumanForProposals[],
+  schedule: Schedule | null,
+  triage: Map<string, TriageResult> | null,
+  opts: ProposalOptions = {},
+): Proposal[] {
+  const limit = opts.limit ?? 5;
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+  const me = humans.find((h) => h.handle === handle);
+  const marks = me ? affinityMarksFor(me) : new Set<string>();
+
+  // In flight and cap per person, for room and for who is over.
+  const inFlight = new Map<string, number>();
+  for (const b of beads) {
+    if (b.assignee && IN_FLIGHT_STATUSES.includes(b.status)) inFlight.set(b.assignee, (inFlight.get(b.assignee) ?? 0) + 1);
+  }
+  const capOf = (h: string) => humans.find((x) => x.handle === h)?.cap ?? DEFAULT_CAP;
+  const overBy = (h: string) => Math.max(0, (inFlight.get(h) ?? 0) - capOf(h));
+  const room = capOf(handle) - (inFlight.get(handle) ?? 0);
+
+  // Unblocking power: open beads that name this one as a blocker.
+  const dependents = new Map<string, number>();
+  for (const b of beads) {
+    if (FINISHED_STATUSES.includes(b.status)) continue;
+    for (const d of b.dependencies ?? []) {
+      if (d.type === "blocks") dependents.set(d.depends_on_id, (dependents.get(d.depends_on_id) ?? 0) + 1);
+    }
+  }
+
+  const out: Proposal[] = [];
+  for (const b of beads) {
+    if (isEpic(b) || b.assignee === handle) continue;
+    if (FINISHED_STATUSES.includes(b.status) || NOT_WORKABLE_STATUSES.includes(b.status) || IN_FLIGHT_STATUSES.includes(b.status)) continue;
+    if (hasOpenBlocker(b, byId)) continue;
+    const from = b.assignee ?? null;
+    if (from && overBy(from) === 0) continue; // theirs, and they have room: not ours to propose
+
+    const reasons: string[] = [];
+    let score = 0;
+    const sched = schedule?.get(b.id);
+    if (sched?.synthetic_assignee && sched.assignee === handle) {
+      score += 3;
+      reasons.push("the scheduler routes it here");
+    }
+    if ((b.labels ?? []).includes(READY_LABEL)) {
+      score += 1;
+      reasons.push(READY_LABEL);
+    }
+    const hits = beadAffinityMatches(b, marks);
+    if (hits.length) {
+      score += 2;
+      reasons.push(`affinity ${hits.join(", ")}`);
+    }
+    const t = triage?.get(b.id)?.score ?? 0;
+    if (t > 0) {
+      score += 2 * t;
+      reasons.push(`triage ${(t * 100).toFixed(0)}%`);
+    }
+    const unblocks = dependents.get(b.id) ?? 0;
+    if (unblocks > 0) {
+      score += Math.min(2, unblocks * 0.5);
+      reasons.push(`unblocks ${unblocks}`);
+    }
+    const p = b.priority ?? 4;
+    score += (4 - p) * 0.25;
+    if (p <= 1) reasons.push(`P${p}`);
+    if (from) {
+      score += 0.5;
+      reasons.push(`from ${from}, ${overBy(from)} over cap`);
+    }
+    if (room > 0) reasons.push(`fits: ${room} slot${room === 1 ? "" : "s"} free`);
+    else {
+      score *= 0.5;
+      reasons.push(room === 0 ? "no room today: at cap" : `no room today: ${-room} over cap`);
+    }
+    out.push({ bead: b, score, reasons, from, change: { kind: "reassign", id: b.id, assignee: handle } });
+  }
+  out.sort((a, b) => b.score - a.score || (a.bead.priority ?? 4) - (b.bead.priority ?? 4) || a.bead.id.localeCompare(b.bead.id));
+  return out.slice(0, limit);
+}
+
+/** The reasons as one line for a row note. */
+export function describeProposal(p: Proposal): string {
+  return p.reasons.join(" · ");
+}

package/src/web/gantt-viewport.ts

@@ -0,0 +1,99 @@
+// gantt-viewport.ts — the Gantt's horizontal viewport (bp-c6q).
+//
+// The scheduling window is [t0, t1]; the viewport is the part of it on
+// screen, in days from t0. Until now the whole window was always on screen,
+// so a wide preset ("all", "history") squeezed a year into the plot column
+// at two or three pixels a day. Now the window is drawn at a readable
+// density and the rest scrolls:
+//
+//   FIT   when the window fits at MIN_PX_PER_DAY or better, the viewport is
+//         the window and nothing scrolls — the Gantt looks exactly as before.
+//   DENSE otherwise the viewport spans plotWidth / MIN_PX_PER_DAY days,
+//         centred on today when today is inside the window and on the
+//         window's end otherwise (the present is the interesting end), and
+//         the plot gains a scrollbar, drag-to-pan on the axis and wheel zoom.
+//
+// Why not DDV's usePannedAndZoomedDomain: it exists (rc.4 exports it, rc.5
+// fixes bugs in it), but its wheel handler zooms and calls preventDefault on
+// every wheel event over its target — attached to the plot it would stop the
+// page scrolling over a tall chart — its pan is unbounded, it mutates the
+// source domain object, and its adjusted domain is read-only, so a
+// scrollbar or a jump-to-today could not drive it. The scaler and the domain
+// helpers are DDV's; this file is only the bounded arithmetic, kept pure so
+// the rules are testable.
+
+export const MIN_PX_PER_DAY = 6; // a week is 42px: labels stay readable
+export const MAX_PX_PER_DAY = 240; // the zoom-in limit: an hour is 10px
+
+export interface Viewport {
+  /** Days from t0 at the left edge of the plot. */
+  startDay: number;
+  /** Days visible across the plot. */
+  spanDays: number;
+}
+
+export function fitsWithoutScroll(totalDays: number, plotWidth: number): boolean {
+  return plotWidth / Math.max(1, totalDays) >= MIN_PX_PER_DAY;
+}
+
+/** Keep the span within the zoom limits and the start within the window. */
+export function clampViewport(v: Viewport, totalDays: number, plotWidth: number): Viewport {
+  const whole = Math.max(1, totalDays);
+  const minSpan = plotWidth > 0 ? Math.min(plotWidth / MAX_PX_PER_DAY, whole) : 1;
+  const spanDays = Math.min(Math.max(v.spanDays, minSpan), whole);
+  const startDay = Math.min(Math.max(v.startDay, 0), Math.max(0, whole - spanDays));
+  return { startDay, spanDays };
+}
+
+/** What a fresh window shows: see the header. */
+export function initialViewport(totalDays: number, plotWidth: number, todayDay: number): Viewport {
+  const whole = Math.max(1, totalDays);
+  if (plotWidth <= 0 || fitsWithoutScroll(whole, plotWidth)) return { startDay: 0, spanDays: whole };
+  const spanDays = plotWidth / MIN_PX_PER_DAY;
+  const anchor = todayDay >= 0 && todayDay <= whole ? todayDay : whole;
+  return clampViewport({ startDay: anchor - spanDays / 2, spanDays }, whole, plotWidth);
+}
+
+export function pxPerDay(v: Viewport, plotWidth: number): number {
+  return plotWidth / Math.max(1e-9, v.spanDays);
+}
+
+/** Move the viewport by a pixel distance: positive reveals later days. */
+export function panViewportPx(v: Viewport, dxPx: number, totalDays: number, plotWidth: number): Viewport {
+  return clampViewport({ startDay: v.startDay + dxPx / pxPerDay(v, plotWidth), spanDays: v.spanDays }, totalDays, plotWidth);
+}
+
+/**
+ * Scale the span by `factor` (> 1 zooms out) keeping the day under
+ * `anchorFrac` of the plot width where it is, so the point under the pointer
+ * stays under the pointer.
+ */
+export function zoomViewport(v: Viewport, factor: number, anchorFrac: number, totalDays: number, plotWidth: number): Viewport {
+  const f = Math.min(1, Math.max(0, anchorFrac));
+  const anchorDay = v.startDay + f * v.spanDays;
+  const spanDays = v.spanDays * factor;
+  return clampViewport({ startDay: anchorDay - f * spanDays, spanDays }, totalDays, plotWidth);
+}
+
+export function centreViewport(v: Viewport, day: number, totalDays: number, plotWidth: number): Viewport {
+  return clampViewport({ startDay: day - v.spanDays / 2, spanDays: v.spanDays }, totalDays, plotWidth);
+}
+
+/** The native scrollbar's numbers for this viewport. */
+export function scrollMetrics(v: Viewport, totalDays: number, plotWidth: number) {
+  const p = pxPerDay(v, plotWidth);
+  return {
+    contentWidth: Math.max(1, totalDays) * p,
+    scrollLeft: v.startDay * p,
+    scrollable: v.spanDays < Math.max(1, totalDays) - 1e-6,
+  };
+}
+
+export function viewportFromScrollLeft(v: Viewport, scrollLeft: number, totalDays: number, plotWidth: number): Viewport {
+  return clampViewport({ startDay: scrollLeft / pxPerDay(v, plotWidth), spanDays: v.spanDays }, totalDays, plotWidth);
+}
+
+/** Wheel down (positive deltaY) zooms out; ~500px of wheel doubles the span. */
+export function wheelZoomFactor(deltaY: number): number {
+  return Math.exp(Math.max(-300, Math.min(300, deltaY)) * (Math.LN2 / 500));
+}

package/src/web/highlights.ts

@@ -0,0 +1,124 @@
+// highlights.ts — pure helpers for the highlight overlays.
+//
+// Three overlays — blocked (has an open blocker), ready-now (spec:ready,
+// unblocked, unassigned or unscheduled), over-cap (humans exceeding their
+// WIP cap).
+//
+// All pure, no I/O, no reactivity — consumers wrap them in Pinia getters
+// and reactively resolve dependencies through the store's state.
+
+import type { Bead, Roster } from "./store";
+
+// ── readiness core (shared) ───────────────────────────────────────────────
+//
+// One definition of "workable", read by the ready-now highlight and by the
+// MINE shortcuts (shortcuts.ts). Assignment is deliberately not part of it:
+// each caller adds its own clause, and the rule itself is written once.
+
+/** Finished or parked: no longer live work. */
+export const FINISHED_STATUSES: readonly string[] = [
+  "closed",
+  "deferred",
+  "tombstone",
+  "superseded",
+];
+
+/** Already moving: what counts as work in flight for WIP against a cap. */
+export const IN_FLIGHT_STATUSES: readonly string[] = ["in_progress", "in_review"];
+
+/** Finished, parked, or already moving: not workable right now. */
+export const NOT_WORKABLE_STATUSES: readonly string[] = [
+  ...FINISHED_STATUSES,
+  ...IN_FLIGHT_STATUSES,
+];
+
+/** The label that means the work has been approved for implementation. */
+export const READY_LABEL = "spec:ready";
+
+/**
+ * Does at least one `blocks` dependency point at a bead that is not closed?
+ * Closed deps do not count; deferred ones do (they still gate work). A dep
+ * whose bead is not in the map is ignored, as the blocked overlay always has.
+ */
+export function hasOpenBlocker(bead: Bead, byId: Map<string, Bead>): boolean {
+  for (const d of bead.dependencies ?? []) {
+    if (d.type !== "blocks") continue;
+    const dep = byId.get(d.depends_on_id);
+    if (dep && dep.status !== "closed") return true;
+  }
+  return false;
+}
+
+/**
+ * Approved, in a workable status, and unblocked. Nothing about who holds it.
+ */
+export function isReadyCore(bead: Bead, byId: Map<string, Bead>): boolean {
+  if (NOT_WORKABLE_STATUSES.includes(bead.status)) return false;
+  if (!(bead.labels ?? []).includes(READY_LABEL)) return false;
+  return !hasOpenBlocker(bead, byId);
+}
+
+// ── blocked overlay ───────────────────────────────────────────────────────
+
+/**
+ * A bead is "blocked" when at least one of its `blocks` dependencies points
+ * at another bead that isn't closed. Closed deps don't count. Deferred deps
+ * do (they still gate work).
+ */
+export function computeBlockedIds(beads: Bead[]): Set<string> {
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+  const out = new Set<string>();
+  for (const b of beads) if (hasOpenBlocker(b, byId)) out.add(b.id);
+  return out;
+}
+
+// ── ready-now overlay ─────────────────────────────────────────────────────
+
+/**
+ * A bead is "ready now" when:
+ *  - it isn't closed / deferred / superseded
+ *  - it carries the `spec:ready` label
+ *  - every `blocks` dep resolves to a closed bead
+ *  - it isn't currently in-flight (in_progress / in_review)
+ *
+ * That's the queue of things that could dispatch _right now_ but haven't.
+ */
+export function computeReadyNowIds(beads: Bead[]): Set<string> {
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+  const out = new Set<string>();
+  for (const b of beads) if (isReadyCore(b, byId)) out.add(b.id);
+  return out;
+}
+
+// ── over-cap overlay ──────────────────────────────────────────────────────
+
+const DEFAULT_WIP_CAP = 5;
+
+/**
+ * Assignees currently over their WIP cap. In-flight = in_progress + in_review.
+ * Cap comes from the roster; missing entries fall through to the roster-wide
+ * default (or DEFAULT_WIP_CAP when the roster doesn't set one either).
+ */
+export function computeOverCapAssignees(
+  beads: Bead[],
+  roster: Roster,
+): Set<string> {
+  const defaultCap = roster.cap ?? DEFAULT_WIP_CAP;
+  const capByHandle = new Map<string, number>();
+  for (const h of roster.humans ?? []) {
+    capByHandle.set(h.handle, h.cap ?? defaultCap);
+  }
+  const inFlight = new Map<string, number>();
+  for (const b of beads) {
+    if (!IN_FLIGHT_STATUSES.includes(b.status)) continue;
+    if (!b.assignee) continue;
+    inFlight.set(b.assignee, (inFlight.get(b.assignee) ?? 0) + 1);
+  }
+  const out = new Set<string>();
+  for (const [handle, count] of inFlight) {
+    const cap = capByHandle.get(handle) ?? defaultCap;
+    if (count > cap) out.add(handle);
+  }
+  return out;
+}
+

package/src/web/index.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>beadcyte</title>
+    <link rel="icon" type="image/svg+xml" href="/assets/favicon.svg" />
+    <!--
+      Applies the stored theme and style before the browser paints, so an
+      explicit light/dark choice doesn't flash the OS's preference first.
+      Plain (non-module) script: runs synchronously during parsing, whereas
+      main.ts is deferred by type="module". Mirrors useTheme.ts's keys and
+      valid values — keep both in sync. useTheme().init() still runs after
+      mount to sync Vue's reactive state; this only covers the pre-JS paint.
+    -->
+    <script>
+      (function () {
+        try {
+          var q = new URLSearchParams(location.search);
+          var t = q.get("theme") || localStorage.getItem("beadcyte:theme");
+          if (t === "light" || t === "dark")
+            document.documentElement.setAttribute("data-theme", t);
+          var fx = q.get("fx");
+          var s = fx || localStorage.getItem("beadcyte:style");
+          // Every named style except default. theme.test.mjs checks this list
+          // against STYLE_NAMES, so a style added there but not here fails a
+          // test instead of flashing the default palette before hydration.
+          var STYLES = ["high-contrast", "catppuccin", "dracula", "github", "gruvbox", "nord", "one", "solarized", "synthwave", "terminal", "tokyonight"];
+          if (STYLES.indexOf(s) >= 0)
+            document.documentElement.setAttribute("data-style", s);
+        } catch (e) {
+          /* storage blocked — falls back to prefers-color-scheme */
+        }
+      })();
+    </script>
+    <!-- Stylesheets are imported from main.ts, not linked here. A plain
+         <link> sits outside Vite's module graph, so editing tokens.css or
+         styles-alt.css never triggered HMR: component changes hot-reloaded
+         while the colour layer silently stayed at whatever first loaded,
+         which looks exactly like a change not taking effect. -->
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="./main.ts"></script>
+  </body>
+</html>

package/src/web/insights.ts

@@ -0,0 +1,107 @@
+// insights.ts — pure derivations for the project-wide summary charts.
+//
+// Small on purpose. The two charts in app-main (bp-67g.30) read data the
+// pipeline already produced: the weekly ship series comes straight off
+// computeVelocity, and group progress is a reshape of the view model's own
+// groups. Neither walks the bead list again.
+//
+// No DOM, no reactivity, no I/O.
+
+import type { Group } from "./view-model";
+
+/** What groupProgress reads: the view model's groups, or projectGroups(). */
+export type ProgressSource = Pick<Group, "id" | "label" | "progress">;
+
+export interface GroupProgressRow {
+  id: string;
+  label: string;
+  closed: number;
+  total: number;
+  /** 0..1. Zero-population groups read as 0 rather than NaN. */
+  fraction: number;
+  /**
+   * True for the view model's placeholder buckets (`__no_epic`,
+   * `__unassigned`, `__all`).
+   *
+   * These are the REMAINDER, not a group whose size means anything beside a
+   * real one, and they are usually the largest thing in the list — 305 of
+   * 556 beads on the repo this was built against. Leaving one in the bars
+   * put every real group on 13% of the width, so callers are expected to
+   * split on this and report the remainder separately.
+   */
+  synthetic: boolean;
+}
+
+/**
+ * Groups by population, largest first.
+ *
+ * Encodes `progress.total`, never `rowCount`. rowCount is what the Gantt
+ * DRAWS — clamped at maxPerGroup — so on a repo with several large epics it
+ * reports the same number for all of them and a chart of it is flat-topped
+ * by construction. `progress` is counted over the whole group before any
+ * filter or window clipping, which is also why closed-vs-open comes along
+ * for free and stays honest when the user hides closed beads.
+ *
+ * Fed by projectGroups() since bp-67g.36, so the SET of groups is project-wide
+ * as well as the counts: a window that clips every bead of a group no longer
+ * drops the group from the chart.
+ */
+export function groupProgress(groups: readonly ProgressSource[]): GroupProgressRow[] {
+  return groups
+    .map((g) => ({
+      id: g.id,
+      label: g.label,
+      closed: g.progress.closed,
+      total: g.progress.total,
+      fraction: g.progress.total > 0 ? g.progress.closed / g.progress.total : 0,
+      synthetic: g.id.startsWith("__"),
+    }))
+    .sort((a, b) => b.total - a.total || a.id.localeCompare(b.id));
+}
+
+export interface ShipWeekPoint {
+  weekStart: Date;
+  count: number;
+}
+
+export interface ShipTrend {
+  weeks: ShipWeekPoint[];
+  total: number;
+  /** Mean ships per week over the series — what the calibration band shows. */
+  perWeek: number;
+  /** The most recent complete week. */
+  last: number;
+  /**
+   * Change from the mean, as a signed fraction. Compared against the mean
+   * rather than the previous week, because week-to-week on counts this small
+   * is mostly noise and the question is "are we above or below our own
+   * normal". Null when there is no history to be normal.
+   *
+   * "No history" means fewer than two weeks that shipped anything, not
+   * merely a zero total. With a single non-zero week the mean IS that week
+   * divided by the series length, so the figure is decided by the window
+   * size rather than by the data: 15 ships in one week of an 8-week window
+   * reports +700%, and the identical beads under a 4-week window report
+   * +300%. That is an artefact with a percent sign on it.
+   */
+  vsMean: number | null;
+  /** Weeks that shipped anything. Below 2, `vsMean` is null. */
+  activeWeeks: number;
+}
+
+/** Reshape computeVelocity's weekly buckets for the trend chart. */
+export function shipTrend(weekly: readonly ShipWeekPoint[]): ShipTrend {
+  const weeks = weekly.map((w) => ({ ...w }));
+  const total = weeks.reduce((a, w) => a + w.count, 0);
+  const perWeek = weeks.length ? total / weeks.length : 0;
+  const last = weeks.length ? weeks[weeks.length - 1].count : 0;
+  const activeWeeks = weeks.filter((w) => w.count > 0).length;
+  return {
+    weeks,
+    total,
+    perWeek,
+    last,
+    activeWeeks,
+    vsMean: activeWeeks >= 2 && perWeek > 0 ? (last - perWeek) / perWeek : null,
+  };
+}