beadcyte 0.4.0

package/src/web/view-model.ts

@@ -0,0 +1,717 @@
+// view-model.ts — pure adapter: bd JSON → { rows, bars, groups }.
+//
+// Mirrors the visibility, grouping, sorting, truncation, and bar-generation
+// rules used by the CLI SVG emitter (src/cli.mjs), so the interactive Gantt
+// renders the same picture the static SVG would. All coordinates are in
+// "days from window start" — pixel math is the renderer's problem, and the
+// scheduler entries stay in the same shape scheduleGreedy() returns.
+//
+// Deliberately no DOM/DDV knowledge, no reactivity, no I/O. Consumed by the
+// Pinia store (src/web/store.ts) as a computed derivation of raw beads +
+// filter/group/window state.
+
+import type { Bead } from "./store";
+import { isShipped } from "../ship.mjs";
+import { hasOpenBlocker } from "./highlights.ts";
+
+// ── shapes ────────────────────────────────────────────────────────────────
+
+export interface ScheduleEntry {
+  id: string;
+  /** Whole span: the start of any wait before the work, to the landing. */
+  start_day: number;
+  end_day: number;
+  /** The work itself (bp-m0g). Absent on entries from an older scheduler. */
+  work_start_day?: number;
+  work_end_day?: number;
+  wait_before_days?: number;
+  wait_after_days?: number;
+  backlog?: boolean;
+  assignee?: string;
+  synthetic_assignee?: boolean;
+  unassigned?: boolean;
+  in_progress_at_start?: boolean;
+  truncated?: boolean;
+}
+
+export type Schedule = Map<string, ScheduleEntry>;
+
+export type GroupBy =
+  | "epic"
+  | "assignee"
+  | "seat"
+  | "track"
+  | "status"
+  | "priority"
+  /** One flat list. Still a group internally ("__all") so every consumer
+   *  keeps one code path; renderers drop the band. */
+  | "none";
+
+export interface Filters {
+  types?: string[] | null;
+  priorities?: number[] | null;
+  labels?: string[] | null; // ALL of these must be present on the bead
+  assignees?: string[] | null;
+  /**
+   * When set, keep only these beads — plus the children of any watched
+   * epic, since watching an epic means "this piece of work", and an epic
+   * itself is never a row. Null/absent means no watch filtering.
+   */
+  watchedIds?: string[] | null;
+  /**
+   * The statuses in view. This is the ONLY control over status.
+   *
+   * There used to be `includeDeferred` and `showClosed` booleans alongside
+   * it, applied first and unconditionally, so asking for `statuses:
+   * ["closed"]` with the toggle off returned nothing and said nothing about
+   * why (bp-67g.40). Two controls for one axis, one of them invisible in its
+   * effect, and no combination the toggles enabled that this could not
+   * express on its own.
+   *
+   * Null or empty means every status — including closed and deferred. The
+   * app pre-selects everything except those two on first load, so the
+   * default view is unchanged but its reason is visible in the panel rather
+   * than being an invisible default.
+   */
+  statuses?: string[] | null;
+  /**
+   * Keep only beads with no open `blocks` dependency (bp-egy). The check is
+   * highlights.ts's hasOpenBlocker, the same one the blocked overlay uses,
+   * so "unblocked" here and "blocked" there can never disagree.
+   */
+  unblocked?: boolean | null;
+}
+
+export interface WindowSpec {
+  from: Date | null; // null = derive from data (all history)
+  to: Date | null; // null = derive from schedule horizon
+}
+
+export interface Row {
+  index: number;
+  beadId: string;
+  title: string;
+  priority: number;
+  status: string;
+  issueType: string;
+  /** Resolved the same way groupId's "assignee" case does: the bead's own
+   *  assignee, else the scheduler's, else null for unassigned. */
+  assignee: string | null;
+  /** The scheduler inferred this assignment rather than reading it off the
+   *  bead — a guess, and never to be presented as recorded fact. */
+  syntheticAssignee: boolean;
+  groupId: string;
+}
+
+export type BarKind =
+  | "shipped"
+  | "closedNoShip"
+  | "inProgressLive" // past-portion of a bead in progress at t=0
+  | "future"
+  | "futureBacklog"
+  | "unassigned" // future from the unassigned pool
+  | "waitUnclaimed" // the wait clock: before a pool pick's work (bp-6cg)
+  | "waitReview"; // the wait clock: after the work, before it lands
+
+/** The wait clock's kinds: drawn dulled and truncated, not counted as bars. */
+export function isWaitKind(kind: BarKind): boolean {
+  return kind === "waitUnclaimed" || kind === "waitReview";
+}
+
+/**
+ * What each kind means, in the words of barsFor() below (bp-67g.48). Shown
+ * on hover in the Gantt footer and listed by the first-run walkthrough, so a
+ * kind cannot be drawn without being explained, or explained two ways.
+ */
+export const BAR_KIND_NOTES: Record<BarKind, string> = {
+  shipped: "Closed with ship evidence — a merge request or a commit on the bead. Real started_at → closed_at, with a ship marker.",
+  closedNoShip: "Closed with no ship evidence recorded: an administrative close, or work that shipped without saying so. Drawn dim.",
+  inProgressLive: "The part of an in-progress bead already spent: from its recorded start to today. What follows it, right of today, is the projection.",
+  future: "Projected: the scheduler's plan for ready work, its length the estimator's median for comparable shipped work.",
+  futureBacklog: "Projected, but backlog: not spec:ready, so scheduled after the ready work and drawn faint.",
+  unassigned: "Projected from the unassigned pool: nobody is on it, so the scheduler shows it where a free slot would take it.",
+  waitUnclaimed: "Waiting, before the work: this project's median time from filing to someone starting, added when the scheduler routes an unassigned bead. Drawn dull and cut short — its length is not to scale; the landing date is.",
+  waitReview: "Waiting, after the work: this project's median review time (or its lead-time floor where none is measured) before the bead lands. Drawn dull and cut short at the landing — not to scale; the date is.",
+};
+
+export interface Bar {
+  rowIndex: number;
+  beadId: string;
+  startDay: number; // days from window start (t0)
+  endDay: number;
+  kind: BarKind;
+  synthetic?: boolean; // model-inferred assignee
+  shipMarker?: boolean;
+}
+
+export interface Group {
+  id: string;
+  label: string;
+  rowCount: number;
+  truncatedCount: number;
+  /**
+   * How many of the rows shown carry an assignee the scheduler inferred
+   * rather than one recorded on the bead. Counted over the rows actually
+   * displayed, like rowCount, so "7 beads · 2 inferred" describes the lane
+   * the reader is looking at. A lane where this is most of rowCount is the
+   * model's plan for someone, not their commitments (bp-67g.49).
+   */
+  syntheticCount: number;
+  /**
+   * Progress across the WHOLE group population (all children, before any
+   * filter or window clipping — so hiding closed beads doesn't drop the
+   * denominator). Renderers use this for a group-header progress chip.
+   */
+  progress: {
+    closed: number;
+    total: number;
+  };
+}
+
+export interface ViewModelMeta {
+  t0: Date;
+  t1: Date;
+  totalDays: number;
+  todayDay: number;
+  visibleCount: number;
+}
+
+export interface ViewModel {
+  rows: Row[];
+  bars: Bar[];
+  groups: Group[];
+  meta: ViewModelMeta;
+}
+
+export interface AssembleOptions {
+  groupBy: GroupBy;
+  filters: Filters;
+  window: WindowSpec;
+  maxPerGroup?: number; // default 20; Infinity disables truncation
+  /**
+   * Group ids the caller has explicitly expanded. Truncation is lifted for
+   * these groups — all rows appear regardless of maxPerGroup. Empty by
+   * default so callers who don't wire an expand UI keep the old behavior.
+   */
+  expandedGroups?: Set<string>;
+}
+
+// ── main entry point ──────────────────────────────────────────────────────
+
+/**
+ * Assemble the reactive view model. Pure, O(n log n) in bead count — the log
+ * factor is the per-group sort. Runs comfortably under 50ms for ~500 beads.
+ */
+export function assembleViewModel(
+  beads: Bead[],
+  schedule: Schedule,
+  opts: AssembleOptions,
+): ViewModel {
+  const filters = opts.filters ?? {};
+  const maxPerGroup = opts.maxPerGroup ?? 20;
+
+  const today = startOfDay(new Date());
+  const { t0, t1 } = resolveWindow(opts.window, beads, schedule, today);
+  const totalDays = daysBetween(t0, t1);
+  const todayDay = daysBetween(t0, today);
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+
+  // Progress totals per group id, computed BEFORE filter/window clipping.
+  // Denominator stays honest when the user hides closed beads or narrows
+  // the window — the chip in the group header still shows the true state.
+  const progressByGroup = new Map<string, { closed: number; total: number }>();
+  const bumpProgress = (gid: string, isClosed: boolean) => {
+    let p = progressByGroup.get(gid);
+    if (!p) {
+      p = { closed: 0, total: 0 };
+      progressByGroup.set(gid, p);
+    }
+    p.total++;
+    if (isClosed) p.closed++;
+  };
+  for (const b of beads) {
+    if (b.issue_type === "epic") continue;
+    const gid = groupId(b, opts.groupBy, schedule.get(b.id));
+    bumpProgress(gid, b.status === "closed");
+  }
+
+  // 1. Visibility — same rules as cli.mjs:117-144. Epics are group headers,
+  //    not rows. Filter passes come first (cheap), then window-clipping.
+  const visible: Bead[] = [];
+  for (const b of beads) {
+    if (b.issue_type === "epic") continue;
+    if (!passesFilters(b, filters, schedule.get(b.id), byId)) continue;
+
+    if (b.status === "closed") {
+      if (!b.closed_at) continue;
+      const closedDay = daysBetween(t0, new Date(b.closed_at));
+      if (closedDay < 0 || closedDay > totalDays) continue;
+      visible.push(b);
+      continue;
+    }
+
+    const sched = schedule.get(b.id);
+    if (sched) {
+      const s = todayDay + sched.start_day;
+      const e = todayDay + sched.end_day;
+      if (e < 0 || s > totalDays) continue;
+      visible.push(b);
+      continue;
+    }
+    // No schedule entry, not closed: appears at horizon-end. Deferred beads
+    // land here whenever `deferred` is in the status selection — the
+    // scheduler skips them, so there is no schedule entry to window-check.
+    visible.push(b);
+  }
+
+  // 2. Group visible beads.
+  const groupBuckets = new Map<string, Bead[]>();
+  const groupIdFor = (b: Bead) => groupId(b, opts.groupBy, schedule.get(b.id));
+  for (const b of visible) {
+    const g = groupIdFor(b);
+    let arr = groupBuckets.get(g);
+    if (!arr) {
+      arr = [];
+      groupBuckets.set(g, arr);
+    }
+    arr.push(b);
+  }
+
+  // 3. Order groups: real IDs first (sorted), synthetic __placeholders last.
+  const groupOrder = [...groupBuckets.keys()].sort((a, b) => {
+    const aFake = a.startsWith("__");
+    const bFake = b.startsWith("__");
+    if (aFake !== bFake) return aFake ? 1 : -1;
+    return a.localeCompare(b);
+  });
+
+  // 4. Sort within group by start-day, then priority, then id (stable-ish).
+  const startDayOf = (b: Bead): number => {
+    if (b.status === "closed") {
+      const t = b.started_at ?? b.closed_at;
+      return t ? daysBetween(t0, new Date(t)) : totalDays + 999;
+    }
+    const s = schedule.get(b.id);
+    if (s) return todayDay + s.start_day;
+    return totalDays + 999;
+  };
+  for (const arr of groupBuckets.values()) {
+    arr.sort(
+      (a, b) =>
+        startDayOf(a) - startDayOf(b) ||
+        (a.priority ?? 4) - (b.priority ?? 4) ||
+        a.id.localeCompare(b.id),
+    );
+  }
+
+  // 5. Truncate: keep past-shipped + in-flight + spec:ready before backlog.
+  //    Groups the caller has explicitly expanded skip this — the user has
+  //    asked to see everything.
+  const truncatedBy = new Map<string, number>();
+  const expanded = opts.expandedGroups ?? new Set<string>();
+  if (Number.isFinite(maxPerGroup)) {
+    for (const [g, arr] of groupBuckets) {
+      if (expanded.has(g)) continue;
+      if (arr.length <= maxPerGroup) continue;
+      const rank = (b: Bead): number => {
+        if (b.status === "closed") return 0;
+        if (b.status === "in_progress" || b.status === "in_review") return 1;
+        if ((b.labels ?? []).includes("spec:ready")) return 2;
+        return 3;
+      };
+      arr.sort(
+        (a, b) => rank(a) - rank(b) || startDayOf(a) - startDayOf(b),
+      );
+      const kept = arr.slice(0, maxPerGroup);
+      truncatedBy.set(g, arr.length - maxPerGroup);
+      kept.sort(
+        (a, b) =>
+          startDayOf(a) - startDayOf(b) ||
+          (a.priority ?? 4) - (b.priority ?? 4) ||
+          a.id.localeCompare(b.id),
+      );
+      groupBuckets.set(g, kept);
+    }
+  }
+
+  // 6. Materialize rows + bars in group order.
+  const rows: Row[] = [];
+  const bars: Bar[] = [];
+  const groups: Group[] = [];
+
+  for (const gid of groupOrder) {
+    const items = groupBuckets.get(gid) ?? [];
+    let syntheticCount = 0;
+    for (const b of items) {
+      const rowIndex = rows.length;
+      const sched = schedule.get(b.id);
+      const assigned = resolveAssignee(b, sched);
+      if (assigned.synthetic) syntheticCount++;
+      rows.push({
+        index: rowIndex,
+        beadId: b.id,
+        title: b.title,
+        priority: b.priority ?? 4,
+        status: b.status,
+        issueType: b.issue_type,
+        assignee: assigned.handle,
+        syntheticAssignee: assigned.synthetic,
+        groupId: gid,
+      });
+      for (const bar of barsFor(b, sched, t0, todayDay, totalDays)) {
+        bars.push({ ...bar, rowIndex, beadId: b.id });
+      }
+    }
+    groups.push({
+      id: gid,
+      label: groupLabel(gid, opts.groupBy, byId),
+      rowCount: items.length,
+      truncatedCount: truncatedBy.get(gid) ?? 0,
+      syntheticCount,
+      progress: progressByGroup.get(gid) ?? { closed: 0, total: 0 },
+    });
+  }
+
+  return {
+    rows,
+    bars,
+    groups,
+    meta: { t0, t1, totalDays, todayDay, visibleCount: rows.length },
+  };
+}
+
+// ── window resolution ─────────────────────────────────────────────────────
+
+function resolveWindow(
+  w: WindowSpec,
+  beads: Bead[],
+  schedule: Schedule,
+  today: Date,
+): { t0: Date; t1: Date } {
+  let t0 = w.from ? startOfDay(w.from) : null;
+  let t1 = w.to ? startOfDay(w.to) : null;
+  if (t0 && t1) return { t0, t1 };
+
+  // Derive from data. Scan for min started_at / max end.
+  let minMs = today.getTime();
+  let maxMs = today.getTime();
+  for (const b of beads) {
+    if (b.started_at) minMs = Math.min(minMs, +new Date(b.started_at));
+    if (b.closed_at) maxMs = Math.max(maxMs, +new Date(b.closed_at));
+  }
+  for (const s of schedule.values()) {
+    const end = today.getTime() + s.end_day * 86_400_000;
+    maxMs = Math.max(maxMs, end);
+  }
+  if (!t0) t0 = startOfDay(new Date(minMs));
+  if (!t1) t1 = startOfDay(new Date(maxMs));
+  // Guarantee t1 > t0
+  if (t1.getTime() <= t0.getTime()) t1 = addDays(t0, 1);
+  return { t0, t1 };
+}
+
+// ── filters ───────────────────────────────────────────────────────────────
+
+function passesFilters(
+  b: Bead,
+  f: Filters,
+  sched: ScheduleEntry | undefined,
+  byId: Map<string, Bead> | null,
+): boolean {
+  if (f.unblocked && byId && hasOpenBlocker(b, byId)) return false;
+  if (f.types && f.types.length && !f.types.includes(b.issue_type))
+    return false;
+  if (
+    f.priorities &&
+    f.priorities.length &&
+    !f.priorities.includes(b.priority ?? 4)
+  )
+    return false;
+  if (f.statuses && f.statuses.length && !f.statuses.includes(b.status))
+    return false;
+  if (f.assignees && f.assignees.length) {
+    if (!f.assignees.includes(assigneeKey(b, sched))) return false;
+  }
+  if (f.watchedIds) {
+    const w = new Set(f.watchedIds);
+    if (!w.has(b.id) && !(b.parent && w.has(b.parent))) return false;
+  }
+  if (f.labels && f.labels.length) {
+    const bl = new Set(b.labels ?? []);
+    for (const l of f.labels) if (!bl.has(l)) return false;
+  }
+  return true;
+}
+
+// ── assignee resolution ───────────────────────────────────────────────────
+
+/** Group/filter key for a bead with nobody on it. */
+export const UNASSIGNED = "__unassigned";
+
+export interface ResolvedAssignee {
+  handle: string | null;
+  /** The scheduler inferred this rather than reading it off the bead. */
+  synthetic: boolean;
+}
+
+/**
+ * What a synthetic assignment is, for the marker beside one (bp-67g.47).
+ * One sentence in one place, next to the resolver that produces the flag.
+ */
+export const SYNTHETIC_ASSIGNEE_NOTE =
+  "Nobody is recorded on this bead. The scheduler gave it to this person to plan a lane for it — preferring someone whose roster affinities (labels, then areas) match, then anyone with a free slot — and marked the assignment synthetic. The model's guess, not a decision anyone made.";
+
+/**
+ * THE definition of a bead's assignee, for every consumer.
+ *
+ * Grouping, filtering, the filter's option list and the grid card chip must
+ * all agree, or the same bead lands in one person's group while the filter
+ * for that person hides it. They used to disagree: everything resolved
+ * through the scheduler except the filter, which read b.assignee alone — and
+ * since most beads carry no recorded assignee, that hid nearly all of a
+ * person's work and dumped it under "(unassigned)" instead.
+ */
+export function resolveAssignee(
+  b: Bead,
+  sched: ScheduleEntry | undefined,
+): ResolvedAssignee {
+  if (b.assignee) return { handle: b.assignee, synthetic: false };
+  if (sched?.assignee) {
+    return { handle: sched.assignee, synthetic: !!sched.synthetic_assignee };
+  }
+  return { handle: null, synthetic: false };
+}
+
+/** resolveAssignee as a group/filter key, with the unassigned placeholder. */
+export function assigneeKey(
+  b: Bead,
+  sched: ScheduleEntry | undefined,
+): string {
+  return resolveAssignee(b, sched).handle ?? UNASSIGNED;
+}
+
+// ── grouping ──────────────────────────────────────────────────────────────
+
+function groupId(
+  b: Bead,
+  mode: GroupBy,
+  sched: ScheduleEntry | undefined,
+): string {
+  switch (mode) {
+    case "epic":
+      return b.parent || "__no_epic";
+    case "assignee":
+      return assigneeKey(b, sched);
+    case "seat": {
+      const s = (b.labels ?? []).find((l) => l.startsWith("seat::"));
+      return s ?? "__no_seat";
+    }
+    case "track": {
+      const t = (b.labels ?? []).find((l) => l.startsWith("track::"));
+      return t ?? "__no_track";
+    }
+    case "status":
+      return b.status || "__unknown_status";
+    case "priority":
+      return `P${b.priority ?? 4}`;
+    case "none":
+    default:
+      return "__all";
+  }
+}
+
+function groupLabel(
+  id: string,
+  mode: GroupBy,
+  byId: Map<string, Bead>,
+): string {
+  const placeholders: Record<string, string> = {
+    __no_epic: "(no epic)",
+    __no_seat: "(no seat)",
+    __no_track: "(no track)",
+    __unassigned: "(unassigned)",
+    __unknown_status: "(unknown status)",
+    __all: "(all)",
+  };
+  if (placeholders[id]) return placeholders[id];
+  if (mode === "epic") {
+    const epic = byId.get(id);
+    return epic ? `${id} · ${truncateTitle(epic.title, 44)}` : id;
+  }
+  return id;
+}
+
+function truncateTitle(s: string, n: number): string {
+  if (!s) return "";
+  return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+
+// ── bars ──────────────────────────────────────────────────────────────────
+
+interface RawBar {
+  startDay: number;
+  endDay: number;
+  kind: BarKind;
+  synthetic?: boolean;
+  shipMarker?: boolean;
+}
+
+function barsFor(
+  b: Bead,
+  sched: ScheduleEntry | undefined,
+  t0: Date,
+  todayDay: number,
+  totalDays: number,
+): RawBar[] {
+  // Closed bars are the measured span, started_at → closed_at, in fractional
+  // days (bp-vsr). They used to be rounded to whole days with a one-day
+  // minimum, which said "a day" about work that took seventeen minutes and
+  // made a two-hour bead and a two-day bead the same width. There is no
+  // floor in the data any more: a bar's minimum WIDTH is a rendering matter
+  // (a few pixels, in BeadsGantt) and shrinks as the viewport zooms in,
+  // while the ship marker is what says "this shipped" at any zoom.
+  if (b.status === "closed") {
+    if (!b.closed_at) return [];
+    const start = b.started_at ? new Date(b.started_at) : new Date(b.closed_at);
+    const end = new Date(b.closed_at);
+    const s = fractionalDaysBetween(t0, start);
+    const e = Math.max(fractionalDaysBetween(t0, end), s);
+    const sc = clamp(s, 0, totalDays);
+    const ec = clamp(e, 0, totalDays);
+    const shipped = isShipped(b);
+    return [
+      {
+        startDay: sc,
+        endDay: ec,
+        kind: shipped ? "shipped" : "closedNoShip",
+        shipMarker: shipped,
+      },
+    ];
+  }
+
+  if (!sched) return [];
+
+  // The bar is the WORK (bp-m0g): the bright part. The waits around it set
+  // the landing date (end_day) and are their own bars (bp-6cg), drawn dulled
+  // and truncated by the Gantt so the picture is mostly cost and the landing
+  // end is still where it lands.
+  const startDay = clamp(todayDay + (sched.work_start_day ?? sched.start_day), 0, totalDays);
+  const endDay = clamp(todayDay + (sched.work_end_day ?? sched.end_day), 0, totalDays);
+  const kindFuture: BarKind = sched.unassigned
+    ? "unassigned"
+    : sched.backlog
+      ? "futureBacklog"
+      : "future";
+  const waits: RawBar[] = [];
+  if (sched.work_start_day !== undefined && sched.work_start_day - sched.start_day > 1e-6) {
+    waits.push({
+      startDay: clamp(todayDay + sched.start_day, 0, totalDays),
+      endDay: startDay,
+      kind: "waitUnclaimed",
+      synthetic: sched.synthetic_assignee,
+    });
+  }
+  if (sched.work_end_day !== undefined && sched.end_day - sched.work_end_day > 1e-6) {
+    waits.push({
+      startDay: endDay,
+      endDay: clamp(todayDay + sched.end_day, 0, totalDays),
+      kind: "waitReview",
+      synthetic: sched.synthetic_assignee,
+    });
+  }
+
+  // Projected spans are the scheduler's: whole-day starts (it simulates a
+  // day at a time, see docs/model.md) and the estimator's fractional length.
+  // No half-day floor here either, for the same reason as above.
+  if (sched.in_progress_at_start && startDay < todayDay) {
+    // Split into a live-past bar + a projected-future bar.
+    return [
+      {
+        startDay,
+        endDay: todayDay,
+        kind: "inProgressLive",
+        synthetic: sched.synthetic_assignee,
+      },
+      {
+        startDay: todayDay,
+        endDay: Math.max(endDay, todayDay),
+        kind: kindFuture,
+        synthetic: sched.synthetic_assignee,
+      },
+      ...waits,
+    ];
+  }
+  return [
+    {
+      startDay,
+      endDay: Math.max(endDay, startDay),
+      kind: kindFuture,
+      synthetic: sched.synthetic_assignee,
+    },
+    ...waits,
+  ];
+}
+
+// ── date helpers (duplicated from cli.mjs on purpose — pure module) ───────
+
+function startOfDay(d: Date): Date {
+  const x = new Date(d);
+  x.setHours(0, 0, 0, 0);
+  return x;
+}
+function addDays(d: Date, n: number): Date {
+  const x = new Date(d);
+  x.setDate(x.getDate() + n);
+  return startOfDay(x);
+}
+function daysBetween(a: Date, b: Date): number {
+  return Math.round((b.getTime() - a.getTime()) / 86_400_000);
+}
+/** The same distance unrounded: for spans that are measured, not scheduled. */
+function fractionalDaysBetween(a: Date, b: Date): number {
+  return (b.getTime() - a.getTime()) / 86_400_000;
+}
+function clamp(v: number, lo: number, hi: number): number {
+  return Math.max(lo, Math.min(hi, v));
+}
+
+// ── project-wide groups (bp-67g.36) ───────────────────────────────────────
+
+/** A group as the project-wide Progress block needs it: who, and how far. */
+export interface ProjectGroup {
+  id: string;
+  label: string;
+  progress: { closed: number; total: number };
+}
+
+/**
+ * Every group the current group-by produces, over EVERY non-epic bead, with
+ * its progress. No filter, no window.
+ *
+ * assembleViewModel counts progress before clipping too, but it only emits a
+ * group that still has a visible row — so on the incytes view a window that
+ * clipped every bead of a group made that group vanish from Progress while
+ * the counts of its neighbours stayed project-wide. Two scopes on one panel.
+ * This is the single-scope source: the incytes Progress block reads it, and
+ * filters and window do not reach it at all.
+ */
+export function projectGroups(
+  beads: readonly Bead[],
+  schedule: Schedule,
+  groupBy: GroupBy,
+): ProjectGroup[] {
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+  const out = new Map<string, ProjectGroup>();
+  for (const b of beads) {
+    if (b.issue_type === "epic") continue;
+    const gid = groupId(b, groupBy, schedule.get(b.id));
+    let g = out.get(gid);
+    if (!g) {
+      g = { id: gid, label: groupLabel(gid, groupBy, byId), progress: { closed: 0, total: 0 } };
+      out.set(gid, g);
+    }
+    g.progress.total++;
+    if (b.status === "closed") g.progress.closed++;
+  }
+  return [...out.values()];
+}