create-pmos 0.52.0 → 0.53.0

package/workspace/public/pm/print.css

@@ -0,0 +1,33 @@
+/* pm/print.css — a report on paper (pm-os-absorb Run 5, slice 5C). Linked with media="print" by report-view.js.
+ *
+ * printReport() draws the report into `body > .rp-print`, in the light theme. On paper every other child of the body goes,
+ * and the report takes the page. The report's own rules (.rp-doc …) are in components.css. */
+@page {
+  margin: 16mm;
+}
+@media print {
+  body > *:not(.rp-print) {
+    display: none !important;
+  }
+  html,
+  body {
+    height: auto !important;
+    overflow: visible !important;
+    background: Canvas !important;
+  }
+  body > .rp-print {
+    display: block !important;
+    padding: 0;
+    background: Canvas;
+    color: CanvasText;
+    font-family: var(--sans);
+  }
+  .rp-print .rp-doc__h2,
+  .rp-print .rp-doc__h3 {
+    break-after: avoid;
+  }
+  .rp-print .rp-doc__table,
+  .rp-print .rp-doc__note {
+    break-inside: avoid;
+  }
+}

package/workspace/public/pm/provider-cards.js

@@ -0,0 +1,136 @@
+/* pm/provider-cards.js — every needs provider's rows as Today cards (pm-os-absorb seams, Runs 2 to 5).
+ *
+ * The server folds each run's needs-you rows into /api/needs (lib/needs-providers.js): a day-one Cycle review, an
+ * unattested PM line, an item in Review, a report to issue. This module is the ONE Today source for all of them, so the
+ * nav's Today count and Today's header count each row once, whichever run made it:
+ *   - it reads /api/needs of each repository's workspace, once the first sessions poll has answered (as keep-card.js
+ *     does, so the page's startup makes no extra request), and again when that workspace's ledgers change;
+ *   - it keeps the provider rows only (derived, with a `provider`), never Run 1's own rows, which keep-card.js draws;
+ *   - it draws a row with the renderer its run registered for the row's kind (registry.js registerTodayCard), or else
+ *     a plain card from the row's `today` payload: the cause as the title, the evidence as the meta line.
+ *
+ * Loaded by registry.js loadExtensions at boot. Run 3 (slice 3B) owns this file after the base: every card carries its R12
+ * kind and its id (data-today-kind, data-today-id) so Today ranks them, the plain card has its one button and the ⋯ menu,
+ * and a provider's failure is a notice on Today, never a card. Fixture mode never loads it.
+ */
+
+import { ensureComponentsCss, toast, SEL } from './primitives.js';
+import { pmGet } from './http.js';
+import { wsOf } from './data.js';
+import { state, setState } from './state.js';
+import { registerTodaySource, todayCardFor, openInitiative } from './registry.js';
+import { todayCard, ensureFeed, onFeed } from './today-cards.js';
+import { COPY } from './today-copy.js';
+
+const cache = new Map();   // ws -> { rows, loading, stale }
+let hooked = false;
+
+/** A row that is a card: derived, from a provider, and not that provider's own failure (a failed source is a notice, not a card). */
+const isCardRow = (r) => !!r && r.derived === true && typeof r.provider === 'string' && r.kind !== 'provider-error' && r.run_id !== 'plan-items:unreadable';
+
+function load(ws) {
+  const c = cache.get(ws) || { rows: [], loading: false, stale: true };
+  cache.set(ws, c);
+  if (c.loading) { c.again = true; return; }
+  c.loading = true; c.again = false;
+  pmGet('/api/needs?ws=' + encodeURIComponent(ws)).then((out) => {
+    c.loading = false; c.stale = false;
+    const all = out && Array.isArray(out.needs) ? out.needs : [];
+    // an item Run 1's `evidence` row already names (keep-card.js draws it) is not drawn again from 4D's item-no-evidence row
+    const evidenceOf = new Set(all.filter((r) => r && r.kind === 'evidence').map((r) => String(r.run_id).replace(/^evidence:/, '')));
+    const dup = (r) => r.kind === 'item-no-evidence' && evidenceOf.has(String(r.run_id || '').replace(/^work-check-needs:no-evidence:/, ''));
+    c.rows = all.filter((r) => isCardRow(r) && !dup(r));
+    if (c.again) load(ws);
+    setState({});
+  });
+}
+
+function hook() {
+  if (hooked || typeof window === 'undefined') return;
+  hooked = true;
+  // A D86 row changes with a placement, a measurement, an issue: files the sessions poll does not watch. The shared feed
+  // (today-cards.js) watches the repository's own /api/today sig, and tells this source when it moved.
+  onFeed((ws) => { const c = cache.get(ws); if (c) { c.stale = true; load(ws); } });
+  window.addEventListener('pmos:ledgers', (e) => {
+    const changed = (e && e.detail && e.detail.changed) || [];
+    for (const ws of changed) { const c = cache.get(ws); if (c) { c.stale = true; load(ws); } }
+  });
+}
+
+/** The provider rows of the given repositories, each with its repository: [{ repo, ws, row }]. Starts a read if needed. */
+function rowsOf(repos) {
+  hook();
+  const out = [];
+  for (const repo of repos || []) {
+    const ws = wsOf(repo);
+    if (!ws) continue;
+    ensureFeed(ws);
+    const c = cache.get(ws);
+    if ((!c || (c.stale && !c.loading)) && Array.isArray(state.sessions)) load(ws);
+    for (const row of (c && c.rows) || []) out.push({ repo, ws, row });
+  }
+  return out;
+}
+
+const rowId = (ws, row) => ws + '|' + row.run_id;
+
+/** What the one button of a plain provider card does: open the initiative, else the destination that holds the record. */
+function pressOf(repo, row) {
+  return () => {
+    const t = row.today && typeof row.today === 'object' ? row.today : {};
+    if (row.initiative_id) { openInitiative(repo, row.initiative_id); return; }
+    const open = typeof window !== 'undefined' && window.pmApp && window.pmApp.open;
+    const dest = row.provider === 'report-needs' ? 'reports' : row.provider === 'initiative-needs' ? 'initiatives' : null;
+    if (dest && open) { open(dest); return; }
+    if (t.act && t.act.cli) toast({ text: COPY.commandShown(t.act.cli), timeout: 12000 }); else toast({ text: COPY.noInitiative });
+  };
+}
+
+function plainCard({ repo, ws, row }) {
+  const t = row.today && typeof row.today === 'object' ? row.today : {};
+  const slug = row.initiative_id || null;
+  const kind = Number.isInteger(t.kind) && t.kind >= 1 && t.kind <= 8 ? t.kind : 8;
+  return todayCard({
+    kind, id: rowId(ws, row), repo, ws, initiative: slug, cause: t.cause || row.question || row.kind, evidence: t.evidence || slug || '',
+    act: t.act || { label: 'Open' }, onAct: pressOf(repo, row),
+    attrs: { 'data-today-row': row.kind, 'data-provider': row.provider },
+  });
+}
+
+registerTodaySource({
+  id: 'provider-rows',
+  kind: null,        // every R12 kind: each row carries its own in row.today.kind
+  rank: 50,
+  count: (ctx) => rowsOf(ctx.repos).length,
+  cards: (ctx) => {
+    const out = rowsOf(ctx.repos).map((x) => {
+      const render = todayCardFor(x.row.kind);
+      if (render) {
+        try {
+          const node = render(x.row, { ...ctx, repo: x.repo, ws: x.ws });
+          if (node) {
+            // A run's renderer draws its own face (4D's Release card, 2D's triage and Cycle cards, 5C's report cards). That face
+            // is the Today card's body: its title is the one cause and its action the one button, and Today adds only the ⋯
+            // menu (R12), so every card ranks, counts and reads alike without a second cause or a second button.
+            const t = x.row.today && typeof x.row.today === 'object' ? x.row.today : {};
+            const kind = Number.isInteger(t.kind) && t.kind >= 1 && t.kind <= 8 ? t.kind : 8;
+            // the renderer's action: its last button that is not the card's own open button, else the open button
+            const btns = [...node.querySelectorAll('button')];
+            const actBtn = btns.filter((b) => !b.matches(SEL.cardOpen)).pop() || btns[0];
+            if (actBtn) actBtn.setAttribute('data-today-act', '');
+            const causeEl = node.querySelector('[data-today-cause]') || node.querySelector(SEL.cardTitle);
+            if (causeEl) causeEl.setAttribute('data-today-cause', '');
+            return todayCard({
+              kind, id: rowId(x.ws, x.row), repo: x.repo, ws: x.ws, initiative: x.row.initiative_id || null,
+              cause: t.cause || x.row.question || x.row.kind, act: t.act || { label: 'Open' },
+              attrs: { 'data-provider': x.row.provider, 'data-today-host': x.row.kind }, face: node,
+            });
+          }
+        } catch (e) { console.error('[pm] the Today card for ' + x.row.kind + ' failed:', e); }
+      }
+      return plainCard(x);
+    });
+    if (out.length) ensureComponentsCss();
+    return out;
+  },
+});

package/workspace/public/pm/registry.js

@@ -0,0 +1,194 @@
+/* pm/registry.js — where the planning layer's page modules plug into the shell (pm-os-absorb Runs 2 to 5).
+ *
+ * Four runs add screens at once. If each one edited app.js, panel-cockpit.js, view-today.js and panel-tabs.js, every
+ * merge would collide on the same lines. So the shell reads this registry once, in a few hook lines, and each run adds
+ * its own module files.
+ *
+ * ── DESTINATIONS: the four places of PRD R9, plus ⚙ ─────────────────────────────────────────────────────────────────
+ * Listed below before their modules exist. Run 3 (slice 3A) builds the frame that shows them as top-level places. Until
+ * that frame is the default, each one opens as a tab in panel 4 (kind 'dest', its id in the tab's `view` field), from
+ * ⌘K or from `window.pmApp.open(id)`. Wherever it is drawn, its host carries data-dest="<id>" (mountDestTab sets it; the
+ * frame mounts through mountDestTab too). A DESTINATION MODULE exports:
+ *   mountDestination(host, ctx)   called on EVERY render with the same host element. Idempotent: keep one persistent
+ *                                 root per host, rebuild only when its own data changed, never while a drag is live.
+ *   disposeDestination(host)      optional; the tab closed or the frame let go of the host.
+ * ctx = { state, setState, FIXTURE, tab, openInitiative }
+ *
+ * ── EXTENSIONS: modules that only register ──────────────────────────────────────────────────────────────────────────
+ * Loaded at boot with the destinations, so a view or a Today source is in place before its host renders.
+ *
+ * ── THE REGISTRIES (call these from your own module, at import time) ─────────────────────────────────────────────────
+ *   registerTodaySource({ id, kind, rank, cards(ctx) → Element[], count(ctx) → number })
+ *       kind is the R12 card kind (1 to 8); rank orders sources inside Today (lower first). ctx = { all, repos,
+ *       setState, open(repo, slug) }. count must equal cards().length for the same ctx: the nav badge and Today's
+ *       header add the counts, and they must agree (Run 1 finding F8).
+ *   registerTodayCard(rowKind, render(row, ctx) → Element)
+ *       how ONE needs-row kind of a server provider (lib/needs-providers.js) is drawn on Today. The rows themselves come
+ *       from /api/needs through provider-cards.js, the one Today source for every provider row, so the count is the
+ *       server's row count and a run never counts its rows twice. A kind with no renderer is drawn from its `today`
+ *       payload (cause, evidence, act). Use registerTodaySource only for a card the page computes itself.
+ *   registerCommand({ id, label, hint, cli, run(), when() })        a ⌘K row; `cli` is the same act's CLI form (R11)
+ *   registerBreakdownView(id, { label, mount(host, ctx), dispose(host) })      a Breakdown view next to Tree and Board
+ *   registerInitiativesView(id, { label, mount(host, ctx), dispose(host) })    a view in Initiatives (Roadmap, List, …)
+ *       ctx is ALWAYS initiativesViewCtx(…): { repo, ws, rows, sig, openInitiative, setState } — rows = the roadmap.json
+ *       horizons rows (fixtures/initiatives-api/roadmap.json), sig = that GET's sig. 2D builds it; 4C reads it.
+ *   setInitiativeOpener(fn)        Run 2 points openInitiative at the initiative sheet; nobody else calls it
+ *   openInitiative(repo, slug)     the one way to open an initiative from any module
+ * An id registered twice keeps the first and logs an error: two runs must not claim one id.
+ *
+ * Fixture mode (the parity boards) loads nothing and registers nothing, so the prototype renders are unchanged.
+ */
+
+import { state, setState, FIXTURE } from './state.js';
+import { pmGet } from './http.js';
+import { empty, ensureComponentsCss } from './primitives.js';
+
+export const DESTINATIONS = Object.freeze([
+  Object.freeze({ id: 'today', label: 'Today', key: 'g t', module: 'dest-today.js', run: 3 }),
+  Object.freeze({ id: 'initiatives', label: 'Initiatives', key: 'g i', module: 'dest-initiatives.js', run: 2 }),
+  Object.freeze({ id: 'board', label: 'Board', key: 'g b', module: 'dest-board.js', run: 4 }),
+  Object.freeze({ id: 'reports', label: 'Reports', key: 'g r', module: 'dest-reports.js', run: 5 }),
+  Object.freeze({ id: 'settings', label: 'Settings', key: null, module: 'dest-settings.js', run: 3 }),
+]);
+export const EXTENSIONS = Object.freeze([
+  'provider-cards.js',         // the base: every needs provider's rows as Today cards (Run 3, 3B, owns it after)
+  'bd-timeline.js',            // Run 4 (4B): Breakdown › Timeline
+  'initiatives-timeline.js',   // Run 4 (4C): Initiatives › Timeline
+]);
+
+const loaded = {};        // module file name -> the module
+const loadErrors = {};    // module file name -> why it did not load
+const todaySources = [];
+const commandList = [];
+const bdViews = [];
+const initViews = [];
+const rowCards = new Map();   // needs-row kind -> render(row, ctx)
+let opener = null;
+
+const dup = (list, id, what) => {
+  if (!list.some((x) => x.id === id)) return false;
+  console.error('[pm] ' + what + ' ' + id + ' is registered twice; the first one is kept');
+  return true;
+};
+
+export function registerTodaySource(src) {
+  if (FIXTURE || !src || typeof src.id !== 'string' || typeof src.cards !== 'function' || dup(todaySources, src.id, 'Today source')) return;
+  todaySources.push({ rank: 100, count: (ctx) => src.cards(ctx).length, ...src });
+  todaySources.sort((a, b) => a.rank - b.rank || (a.id < b.id ? -1 : 1));
+}
+export function registerTodayCard(rowKind, render) {
+  if (FIXTURE || typeof rowKind !== 'string' || typeof render !== 'function') return;
+  if (rowCards.has(rowKind)) { console.error('[pm] Today card ' + rowKind + ' is registered twice; the first one is kept'); return; }
+  rowCards.set(rowKind, render);
+}
+export function registerCommand(cmd) {
+  if (FIXTURE || !cmd || typeof cmd.id !== 'string' || typeof cmd.run !== 'function' || dup(commandList, cmd.id, 'command')) return;
+  commandList.push(cmd);
+}
+export function registerBreakdownView(id, view) {
+  if (FIXTURE || typeof id !== 'string' || !view || typeof view.mount !== 'function' || dup(bdViews, id, 'Breakdown view')) return;
+  bdViews.push({ id, ...view });
+}
+export function registerInitiativesView(id, view) {
+  if (FIXTURE || typeof id !== 'string' || !view || typeof view.mount !== 'function' || dup(initViews, id, 'Initiatives view')) return;
+  initViews.push({ id, ...view });
+}
+/** The frozen keys of an Initiatives view's mount ctx, and the one way to build it (a missing key is null). */
+export const INITIATIVES_VIEW_CTX_KEYS = Object.freeze(['repo', 'ws', 'rows', 'sig', 'openInitiative', 'setState']);
+export function initiativesViewCtx(src) {
+  const o = {};
+  for (const k of INITIATIVES_VIEW_CTX_KEYS) o[k] = src && src[k] !== undefined ? src[k] : null;
+  return Object.freeze(o);
+}
+export function setInitiativeOpener(fn) { if (typeof fn === 'function') opener = fn; }
+
+export function openInitiative(repo, slug) {
+  if (opener) return opener(repo, slug);
+  const repos = typeof window !== 'undefined' && window.pmApp && window.pmApp.mods ? window.pmApp.mods.repos : null;
+  if (repos && typeof repos.selectRepo === 'function' && repo) repos.selectRepo(repo);
+  setState({ sel: slug, detail: { kind: 'init' }, col2: true });
+}
+
+/* ── readers, for the shell's hook lines ───────────────────────────────────────────────────────────────────────────── */
+
+const safe = (what, fn, fallback) => { try { return fn(); } catch (e) { console.error('[pm] ' + what + ' failed:', e); return fallback; } };
+export const todayCards = (ctx) => (FIXTURE ? [] : todaySources.flatMap((s) => safe('Today source ' + s.id, () => s.cards(ctx) || [], [])));
+export const todayCount = (ctx) => (FIXTURE ? 0 : todaySources.reduce((n, s) => n + safe('Today source ' + s.id, () => Number(s.count(ctx)) || 0, 0), 0));
+export const commands = () => commandList.filter((c) => !c.when || safe('command ' + c.id, () => !!c.when(), false));
+/** The renderer registered for a needs-row kind, or null (provider-cards.js then draws the row's `today` payload). */
+export const todayCardFor = (rowKind) => rowCards.get(rowKind) || null;
+export const breakdownViews = () => bdViews.slice();
+export const initiativesViews = () => initViews.slice();
+/** The destinations whose module is loaded, in order. */
+export const destinations = () => DESTINATIONS.filter((d) => loaded[d.module]);
+export const extensionErrors = () => ({ ...loadErrors });
+
+/** Load every listed module that is on disk (the server says which: GET /api/pm-modules), once, at boot. */
+let loading = null;
+export function loadExtensions() {
+  if (FIXTURE) return Promise.resolve();
+  if (loading) return loading;
+  const want = [...DESTINATIONS.map((d) => d.module), ...EXTENSIONS];
+  loading = (async () => {
+    const j = await pmGet('/api/pm-modules?want=' + encodeURIComponent(want.join(',')));
+    const present = Array.isArray(j && j.present) ? j.present.filter((n) => want.includes(n)) : [];
+    await Promise.all(present.map(async (name) => {
+      try { loaded[name] = await import('./' + name); }
+      catch (e) { loadErrors[name] = String((e && e.message) || e); console.error('[pm] ' + name + ' failed to load:', e); }
+    }));
+  })();
+  return loading;
+}
+
+/* ── the home of a destination: the frame, or (outside it) a tab in panel 4 ────────────────────────────────────────── */
+
+const tabId = (id) => 'dest:' + id;
+const hosts = new Map();   // tab id -> { host, mod }
+let frameHome = null;      // set by app.js when the frame is on (Run 3, slice 3A)
+
+/** app.js (the frame): from now on a destination opens as a top-level place of the frame, not as a panel-4 tab. */
+export function setFrameHome(fn) { frameHome = typeof fn === 'function' ? fn : null; }
+
+/** Open destination `id`: in the frame, as the place on screen; outside it (fixture mode does not load this module, so
+ * this is ?layout=legacy), as a panel-4 tab, opened or focused. `params` may carry { repo, slug } for a destination that
+ * opens on one. Returns false for an id that names no destination. */
+export function openDestination(id, params) {
+  const d = DESTINATIONS.find((x) => x.id === id);
+  if (!d) return false;
+  if (frameHome) return frameHome(id, params || {}) !== false;
+  const p = params || {};
+  const tid = tabId(id);
+  setState((s) => {
+    const tabs = s.tabs || [];
+    const tab = { id: tid, kind: 'dest', view: id, title: d.label, role: d.label.toLowerCase(), repo: p.repo || null, slug: p.slug || null };
+    return { tabs: tabs.some((t) => t.id === tid) ? tabs.map((t) => (t.id === tid ? { ...t, repo: tab.repo, slug: tab.slug } : t)) : [...tabs, tab], active: tid };
+  });
+  return true;
+}
+
+/** Draw destination `tab.view` into its persistent host: the frame's host for that place (tab id 'frame:<id>'), or a
+ * 'dest' tab's pane (panel-tabs.js paneFor). The frame's tab also carries `scope`: 'repo', or 'all' when Repository ▾ is
+ * on All repositories (then `repo` is null). */
+export function mountDestTab(host, tab) {
+  const d = DESTINATIONS.find((x) => x.id === tab.view);
+  host.setAttribute('data-dest', tab.view || '');   // the one hook a test finds a destination by, in a tab or the frame
+  const mod = d ? loaded[d.module] : null;
+  if (!mod || typeof mod.mountDestination !== 'function') {
+    const text = !d ? 'This tab names no destination.'
+      : loadErrors[d.module] ? d.label + ' could not load: ' + loadErrors[d.module]
+        : d.label + ' arrives in Run ' + d.run + '.';
+    ensureComponentsCss();
+    host.replaceChildren(empty({ text, attrs: { 'data-dest-missing': tab.view || '' } }));
+    return;
+  }
+  hosts.set(tab.id, { host, mod });
+  safe('destination ' + d.id, () => mod.mountDestination(host, { state, setState, FIXTURE, tab, openInitiative }), null);
+}
+
+/** panel-tabs.js reapClosedPanes: the tab closed. */
+export function disposeDestTab(id) {
+  const h = hosts.get(id);
+  if (!h) return;
+  hosts.delete(id);
+  if (typeof h.mod.disposeDestination === 'function') safe('dispose ' + id, () => h.mod.disposeDestination(h.host), null);
+}

package/workspace/public/pm/release-card.js

@@ -0,0 +1,110 @@
+/* pm/release-card.js — the Release card, on the Board and on Today (pm-os-absorb Run 4, slice 4D; PRD R12 kind 4, D86 point 2).
+ *
+ *   releaseButton({ ws, initiative, batch, items, onDone })   the one Release button; a press posts /api/board/release
+ *   releaseCard(release, { ws, onDone })                      one ready batch as a card, for the Board
+ *   grantScopes(onReady)                                      the scopes a press can grant now, or null until they are read
+ *
+ * Importing this file registers the Today renderers for the needs-row kinds of lib/work-check-needs.js (registry.js
+ * registerTodayCard): `release`, `item-review` and `item-no-evidence`, so dest-board.js imports it and the cards exist at
+ * boot. An item row shows the item's title (the row's question) and opens the initiative that holds it. A Release is the PM's press: the page sends the press with
+ * pmPost, which carries the page's Origin (and, from Run 2, the launch nonce). The server mints ONE grant for the whole
+ * batch. Nothing here writes a record or starts a factory run, and the button never acts on its own.
+ *
+ * Until the grant writer is merged, /api/pm-modules lists no `release` scope. The button then shows disabled, with
+ * "Release arrives in Run 2." beside it, so a press is never made to fail on purpose.
+ */
+
+import { el } from './dom.js';
+import { button, card, toast, ensureComponentsCss } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
+import { FIXTURE, setState } from './state.js';
+import { registerTodayCard } from './registry.js';
+import { COPY } from './board-copy.js';
+
+let scopes = null;
+let reading = false;
+const waiting = [];
+
+/** The grant scopes a press can mint now (GET /api/pm-modules), or null until the first read ends. */
+export function grantScopes(onReady) {
+  if (scopes) return scopes;
+  if (typeof onReady === 'function') waiting.push(onReady);
+  if (!reading && !FIXTURE) {
+    reading = true;
+    pmGet('/api/pm-modules?want=').then((j) => {
+      scopes = Array.isArray(j && j.grantScopes) ? j.grantScopes : [];
+      reading = false;
+      for (const fn of waiting.splice(0)) { try { fn(scopes); } catch (e) { console.error('[release-card]', e); } }
+      setState({});
+    });
+  }
+  return scopes;
+}
+
+/** True when the page knows the release scope cannot be granted yet. Unknown (not read) counts as grantable. */
+const notYet = () => Array.isArray(scopes) && !scopes.includes('release');
+
+/** One Release button. `onDone(out)` runs after a press that was granted. */
+export function releaseButton({ ws, initiative, batch, items, onDone } = {}) {
+  const b = button({
+    label: COPY.release.press, variant: 'outline', size: 'sm',
+    attrs: { 'data-bo-release-press': `${initiative}:${batch}`, 'aria-label': COPY.release.pressLabel(initiative, batch) },
+    disabled: notYet(),
+    onClick: async () => {
+      if (b.disabled) return;
+      b.disabled = true;
+      const out = await pmPost('/api/board/release', { ws, initiative, batch });
+      if (!out || out.ok === false) {
+        toast({ text: COPY.release.failed((out && out.error) || 'the server did not answer'), tone: 'error' });
+        b.disabled = notYet();
+        return;
+      }
+      toast({ text: COPY.release.pressed(out.items || items || 0) });
+      if (onDone) onDone(out);
+    },
+  });
+  return b;
+}
+
+/** One ready batch as a card: the initiative, the batch, how many work items, and the Release button. */
+export function releaseCard(r, { ws, onDone } = {}) {
+  ensureComponentsCss();
+  const waitingForRun = notYet();
+  return el('div', { class: 'bo-rel', 'data-bo-release': `${r.initiative}:${r.batch}` },
+    el('div', { class: 'bo-rel__main' },
+      el('div', { class: 'bo-rel__title' }, COPY.release.title(r.initiativeTitle || r.initiative)),
+      el('div', { class: 'bo-rel__meta' }, [COPY.release.batch(r.batch), COPY.release.items((r.items || []).length)].join(' · ')),
+      waitingForRun ? el('div', { class: 'bo-rel__wait', 'data-bo-release-wait': '' }, COPY.release.waiting) : null),
+    releaseButton({ ws, initiative: r.initiative, batch: r.batch, items: (r.items || []).length, onDone }));
+}
+
+/* Today: a needs row of kind `release` (lib/work-check-needs.js). Its run_id is work-check-needs:release:<initiative>:<batch>. */
+function todayRelease(row, ctx) {
+  const m = /^work-check-needs:release:([^:]+):(.+)$/.exec(String(row.run_id || ''));
+  if (!m) return null;
+  const t = row.today && typeof row.today === 'object' ? row.today : {};
+  grantScopes();
+  return el('div', { class: 'bo-rel bo-rel--today', 'data-today-row': 'release', 'data-provider': row.provider || '', 'data-initiative': m[1] },
+    el('div', { class: 'bo-rel__main' },
+      el('div', { class: 'bo-rel__title', 'data-today-cause': '' }, row.question || t.cause || COPY.release.head),
+      el('div', { class: 'bo-rel__meta' }, [m[1], COPY.release.batch(m[2])].join(' · ')),
+      notYet() ? el('div', { class: 'bo-rel__wait', 'data-bo-release-wait': '' }, COPY.release.waiting) : null),
+    releaseButton({ ws: (ctx && ctx.ws) || row.ws, initiative: m[1], batch: m[2], onDone: () => setState({}) }));
+}
+registerTodayCard('release', todayRelease);
+
+/* Today: an item row (item-review, item-no-evidence). The row's question names the item; the card opens its initiative. */
+function todayItem(row, ctx) {
+  const t = row.today && typeof row.today === 'object' ? row.today : {};
+  const slug = row.initiative_id || null;
+  ensureComponentsCss();
+  return card({
+    title: row.question || t.cause || row.kind,
+    meta: [t.cause, slug, t.evidence].filter(Boolean),
+    onOpen: slug && ctx && ctx.open ? () => ctx.open(ctx.repo, slug) : undefined,
+    openLabel: slug ? COPY.aria.open(row.question || slug) : undefined,
+    attrs: { 'data-today-row': row.kind, 'data-provider': row.provider || '', 'data-initiative': slug || '' },
+  });
+}
+registerTodayCard('item-review', todayItem);
+registerTodayCard('item-no-evidence', todayItem);