create-pmos 0.51.0 → 0.53.0

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

@@ -0,0 +1,244 @@
+/* pm/today-cards.js — the card every Today source draws, the one feed they read, and the ranking (pm-os-absorb Run 3,
+ * slice 3B, PRD R12).
+ *
+ * Today lists eight kinds of card and no other. A card has a CAUSE, its EVIDENCE, ONE button and the ⋯ menu. It never has
+ * a dismiss: it leaves when its cause is gone.
+ *
+ *   todayCard({ kind, id, repo, ws, initiative, cause, evidence, act, onAct, menuExtra, attrs, panel })  → the card
+ *   rankNodes(nodes)        the cards in Today's order: the kind (data-today-kind), then the id (data-today-id)
+ *   scopeCtx(st)            { all, repos, repo }: the repositories Today (and the nav badge) count, from the scope
+ *   ensureFeed(ws)          starts reading GET /api/today?ws= for a repository: once, then on every change of its sig
+ *   feedOf(ws)              the last answer for that repository, or null
+ *   onFeed(cb(ws))          cb runs when a repository's list changed (the sources that read /api/needs read it again)
+ *   refreshFeed(ws)         read it now (after a press that changed a record)
+ *   feedErrorOf(ws)         why the last read of that repository's list failed, or null (a list that cannot be read is said)
+ *   bannerOf(repos)         the sources that could not be read: [{ repo, source, error }], and a list that could not be read
+ *
+ * The server owns the list (lib/today.js). The page draws what the server sent and what the registered sources add, and
+ * counts the same rows once: the nav badge and the header read todayCount() from the registry, which adds the sources.
+ */
+
+import { el } from './dom.js';
+import { button, iconButton, menu, needsDot, tabs, field, toast, ensureComponentsCss } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
+import { watchSig } from './sig-watch.js';
+import { wsOf } from './data.js';
+import { state, setState, FIXTURE } from './state.js';
+import { openInitiative } from './registry.js';
+import { COPY } from './today-copy.js';
+
+/* ── the feed ────────────────────────────────────────────────────────────────────────────── */
+
+const feeds = new Map();          // ws -> { data, sig, error, stop }
+const listeners = new Set();
+let hooked = false;
+
+const notify = (ws) => { for (const cb of [...listeners]) { try { cb(ws); } catch (e) { console.error('[pm] a Today listener failed:', e); } } };
+
+async function read(ws) {
+  const f = feeds.get(ws);
+  const out = await pmGet('/api/today?ws=' + encodeURIComponent(ws));
+  if (!f) return null;
+  if (!out || out.ok === false || !Array.isArray(out.cards)) {
+    // an answer that is not a list is said (R12): the page never reads "Reading what needs you." for ever, and never reads as empty
+    const had = f.error;
+    f.error = (out && out.error ? String(out.error) : COPY.health.noAnswer).slice(0, 240);
+    if (f.error !== had) notify(ws);
+    return null;
+  }
+  const changed = !f.data || !!f.error;
+  f.data = out; f.sig = out.sig || null; f.error = null;
+  if (changed) notify(ws);
+  return f.sig;
+}
+
+function hook() {
+  if (hooked || typeof window === 'undefined') return;
+  hooked = true;
+  window.addEventListener('pmos:ledgers', (e) => {
+    for (const ws of (e && e.detail && e.detail.changed) || []) if (feeds.has(ws)) refreshFeed(ws);
+  });
+}
+
+/** Start reading a repository's list, once the first sessions poll has answered (the page's startup makes no extra request). */
+export function ensureFeed(ws) {
+  if (FIXTURE || !ws) return null;
+  if (feeds.has(ws)) return feeds.get(ws);
+  if (!Array.isArray(state.sessions)) return null;
+  hook();
+  const f = { data: null, sig: null, error: null, stop: null };
+  feeds.set(ws, f);
+  f.stop = watchSig(() => read(ws), () => notify(ws), { everyMs: 10000 });
+  return f;
+}
+export const feedOf = (ws) => { const f = feeds.get(ws); return f && f.data ? f.data : null; };
+export const feedErrorOf = (ws) => { const f = feeds.get(ws); return f && f.error ? f.error : null; };
+export function onFeed(cb) { listeners.add(cb); return () => listeners.delete(cb); }
+export async function refreshFeed(ws) {
+  const f = feeds.get(ws);
+  if (!f) return;
+  const before = f.sig;
+  await read(ws);
+  if (f.sig !== before) notify(ws);
+}
+
+/** The sources that could not be read, over the given repositories: never an empty list that reads as "nothing needs you". */
+export function bannerOf(repos) {
+  const out = [];
+  for (const repo of repos || []) {
+    const ws = wsOf(repo);
+    const d = feedOf(ws);
+    const err = feedErrorOf(ws);
+    if (err) out.push({ repo, source: COPY.health.todaySource, error: err });
+    for (const b of (d && d.banner) || []) out.push({ repo, source: String(b.source || ''), error: String(b.error || '') });
+  }
+  return out;
+}
+
+/** The repositories Today counts: the one the person chose, or every one. The nav badge reads the same scope. */
+export function scopeCtx(st, tuples, current) {
+  const all = (st || state).todayScope === 'all';
+  const names = (tuples || []).map((t) => t[0]);
+  return { all, repos: all ? names : [current].filter(Boolean), repo: current || null };
+}
+
+/* ── ranking ─────────────────────────────────────────────────────────────────────────────── */
+
+const kindOf = (n) => { const k = Number(n.getAttribute('data-today-kind')); return Number.isInteger(k) && k >= 1 && k <= 8 ? k : 9; };
+/** The cards in Today's order (lib/today.js rank): the kind, then the id. Returns a new array; the nodes are not moved. */
+export function rankNodes(nodes) {
+  const idOf = (n) => n.getAttribute('data-today-id') || '';
+  // the same comparison as lib/today.js rank (code-unit order), so the page and GET /api/today list a kind the same way
+  return nodes.slice().sort((a, b) => kindOf(a) - kindOf(b) || (idOf(a) < idOf(b) ? -1 : idOf(a) > idOf(b) ? 1 : 0));
+}
+
+/* ── the card ────────────────────────────────────────────────────────────────────────────── */
+
+function copyCommand(cli) {
+  if (!cli) { toast({ text: COPY.noCommand }); return; }
+  const done = () => toast({ text: COPY.commandCopied(cli) });
+  const shown = () => toast({ text: COPY.commandShown(cli), timeout: 12000 });
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) navigator.clipboard.writeText(cli).then(done, shown);
+    else shown();
+  } catch { shown(); }
+}
+
+/**
+ * todayCard({ kind 1–8, id, repo, ws, initiative, cause, evidence, act: { label, cli? }, onAct(event), menuExtra: [{ label,
+ *   onSelect }], attrs, panel: Node|null })
+ * `id` is the card's stable id (`<ws>|<run id>`): the ranking sorts by it and a test finds the card by it.
+ */
+/** The ⋯ of a Today card: the card's own entries, then Open initiative, Copy command and Why. provider-cards.js gives it
+ * to a card a run's renderer drew without one, so every card on Today has its ⋯. */
+export function moreButton({ kind, repo, initiative, cause, act, menuExtra } = {}) {
+  const label = (act && act.label) || 'Open';
+  const more = iconButton({
+    icon: 'ellipsis', ariaLabel: COPY.aria.more(cause || label), attrs: { 'data-today-more': '' },
+    onClick: () => menu({
+      anchor: more, ariaLabel: COPY.aria.more(cause || label),
+      items: [
+        ...(menuExtra || []),
+        { label: COPY.menu.open, onSelect: () => { if (initiative) openInitiative(repo, initiative); else toast({ text: COPY.noInitiative }); } },
+        { label: COPY.menu.command, onSelect: () => copyCommand(act && act.cli) },
+        { label: COPY.menu.why, onSelect: () => toast({ text: COPY.why[kind] || COPY.why[8] }) },
+      ],
+    }),
+  });
+  return more;
+}
+
+/**
+ * `face`: a run's renderer card (registerTodayCard). The face IS the card's body: it shows the one cause and the one
+ * action, so the Today card adds only the ⋯ menu beside it, never a second cause or a second button. The face's cause
+ * element carries data-today-cause and its action data-today-act, as a plain card's do.
+ */
+export function todayCard({ kind, id, repo, ws, initiative, cause, evidence, act, onAct, menuExtra, attrs, actAttrs, panel, face } = {}) {
+  ensureComponentsCss();
+  const label = (act && act.label) || 'Open';
+  const more = moreButton({ kind, repo, initiative, cause, act, menuExtra });
+  const box = {
+    class: face ? 'td-card td-card--host' : 'td-card', 'data-today': 'card', 'data-today-kind': String(kind), 'data-today-id': id || null,
+    'data-initiative': initiative || null, 'data-repo': repo || null, 'data-ws': ws || null, ...(attrs || {}),
+  };
+  if (face) return el('div', box, el('div', { class: 'td-card__host' }, el('div', { class: 'td-card__face' }, face), more));
+  return el('div', box,
+  el('div', { class: 'td-card__top' },
+    el('div', { class: 'td-card__text' },
+      el('div', { class: 'td-card__cause', 'data-today-cause': '' }, needsDot(), el('span', null, cause || '')),
+      evidence ? el('div', { class: 'td-card__evidence' }, evidence) : null),
+    el('div', { class: 'td-card__acts' },
+      button({ label, variant: 'outline', size: 'sm', attrs: { 'data-today-act': '', ...(actAttrs || {}) }, onClick: (e) => { if (onAct) onAct(e); } }),
+      more)),
+  panel || null);
+}
+
+/* ── the Acceptance Gate card (D12): Review › Right or Wrong › note › Accept ──────────────────────────────── */
+
+const ui = new Map();   // card id -> { open, right, noting, note, busy, error }
+const uiOf = (id) => { if (!ui.has(id)) ui.set(id, { open: false, right: null, noting: false, note: '', busy: false, error: '' }); return ui.get(id); };
+const verdictLabel = (v) => (/^pass/i.test(String(v || '')) ? 'pass' : /^fail/i.test(String(v || '')) ? 'fail' : null);
+
+/**
+ * The card of an open acceptance. The PM's answer to "Was the evaluator right?" is written as `pm_label`: the evaluator's own
+ * verdict when the answer is Right, the other one when it is Wrong. Nothing is written until Accept or Return is pressed,
+ * and the write is one POST to the guarded gate (pmPost carries the nonce).
+ */
+export function acceptCard(c, { repo, rerender }) {
+  const u = uiOf(c.id);
+  const verdict = c.detail && c.detail.verdict ? c.detail.verdict : null;
+  const score = c.detail && c.detail.score !== undefined ? c.detail.score : null;
+  const lbl = verdictLabel(verdict);
+  const need = lbl !== null;   // with no verdict there is nothing to rate, and the buttons need no answer
+  const ready = !need || u.right !== null;
+
+  const send = async (action) => {
+    if (u.busy || !ready) return;
+    u.busy = true; u.error = ''; rerender();
+    const note = noteField && noteField.control ? String(noteField.control.value || '').trim() : u.note;
+    const pm_label = need ? ((u.right === true) === (lbl === 'pass') ? 'pass' : 'fail') : undefined;
+    const out = await pmPost('/api/gate', {
+      ws: c.ws, action, run_id: c.run_id, ...(c.initiative_id ? { initiative_id: c.initiative_id } : {}), ...(pm_label ? { pm_label } : {}), note,
+    });
+    u.busy = false;
+    if (out && out.ok !== false) {
+      ui.delete(c.id);
+      toast({ text: action === 'accept' ? COPY.accept.accepted(c.run_id) : COPY.accept.returned(c.run_id) });
+      await refreshFeed(c.ws);
+    } else {
+      u.error = out && out.error ? COPY.accept.refused(String(out.error)) : COPY.accept.unreached;
+    }
+    rerender();
+  };
+
+  let noteField = null;
+  let panel = null;
+  if (u.open) {
+    noteField = u.noting ? field({
+      label: COPY.accept.note, hideLabel: true, kind: 'text', value: u.note, placeholder: COPY.accept.noteHint,
+      attrs: { 'data-today-note': '' }, onCommit: (v) => { u.note = String(v || ''); },
+    }) : null;
+    if (noteField) noteField.control.addEventListener('input', (e) => { u.note = e.target.value; });
+    panel = el('div', { class: 'td-accept', 'data-today-panel': c.id },
+      el('p', { class: 'td-accept__line' }, verdict ? COPY.accept.verdict(verdict, score) : COPY.accept.noVerdict),
+      need ? el('div', { class: 'td-accept__ask' },
+        el('span', { class: 'td-accept__q' }, COPY.accept.question),
+        tabs({
+          variant: 'segmented', role: 'radiogroup', ariaLabel: COPY.accept.question, value: u.right === null ? null : (u.right ? 'right' : 'wrong'),
+          items: [{ id: 'right', label: COPY.accept.right }, { id: 'wrong', label: COPY.accept.wrong }],
+          onChange: (id) => { u.right = id === 'right'; rerender(); },
+          attrs: { 'data-today-verdict': '' },
+        })) : null,
+      noteField || button({ label: COPY.accept.note, variant: 'ghost', size: 'sm', attrs: { 'data-today-add-note': '' }, onClick: () => { u.noting = true; rerender(); } }),
+      el('div', { class: 'td-accept__acts' },
+        button({ label: COPY.accept.accept, variant: 'outline', disabled: u.busy || !ready, attrs: { 'data-today-accept': '' }, onClick: () => send('accept') }),
+        button({ label: COPY.accept.return, variant: 'ghost', disabled: u.busy || !ready, attrs: { 'data-today-return': '' }, onClick: () => send('return') })),
+      u.error ? el('p', { class: 'td-accept__error', role: 'alert', 'data-today-error': '' }, u.error) : null);
+  }
+  return todayCard({
+    kind: 1, id: c.id, repo, ws: c.ws, initiative: c.initiative_id, cause: c.cause, evidence: c.evidence,
+    act: { label: COPY.accept.review, cli: c.act && c.act.cli }, panel,
+    attrs: { 'data-today-row': 'accept', 'data-run': c.run_id, 'data-open': u.open ? 'true' : 'false' },
+    onAct: () => { u.open = !u.open; rerender(); },
+  });
+}

package/workspace/public/pm/today-copy.js

@@ -0,0 +1,97 @@
+/* pm/today-copy.js — every word Today shows (pm-os-absorb Run 3, slice 3B, PRD R12).
+ *
+ * Pure data and pure functions. No DOM and no import, so `glossary.test.js` can load this file in Node and check every
+ * string against the glossary rules. A sentence a person reads on Today, in a Today card or its menu, or in a toast
+ * raised from a Today card, is written here and nowhere else. The cause and the evidence of a card come from the server
+ * (lib/today.js, or the needs provider that made the row); they are not written here.
+ *
+ * Instructional register (PMOS-STE): one idea per sentence, active voice, the verb first on a button.
+ */
+
+export const COPY = {
+  title: 'Today',
+  /** "3 need you", "1 needs you". */
+  count: (n) => `${n} ${n === 1 ? 'needs' : 'need'} you`,
+  countIn: (n, repo) => `${n} ${n === 1 ? 'needs' : 'need'} you in ${repo || 'this repository'}`,
+  countAcross: (n, repos) => `${n} ${n === 1 ? 'needs' : 'need'} you across ${repos} ${repos === 1 ? 'repository' : 'repositories'}`,
+  scope: { label: 'Show', repo: 'Repository', all: 'All repositories' },
+  /** The empty state of R12. `next` is the label of the next scheduled draft, or null when none is known. */
+  empty: (next) => (next ? `Nothing needs you. Next: ${next}.` : 'Nothing needs you.'),
+  reading: 'Reading what needs you.',
+  more: (n) => `Show ${n} more`,
+  fewer: 'Show fewer',
+  /** The state-health notice: sources that could not be read are said here, never shown as an empty list. */
+  health: {
+    title: (n) => (n === 1 ? 'One source could not be read.' : `${n} sources could not be read.`),
+    line: (source, error) => `${source}: ${error}`,
+    todaySource: 'Today',
+    noAnswer: 'The list could not be read. The workspace did not answer.',
+  },
+  aria: {
+    list: 'What needs you',
+    more: (what) => `More actions for ${what}`,
+    badge: (n) => `${n} ${n === 1 ? 'needs' : 'need'} you`,
+  },
+  /** The ⋯ menu of a card. */
+  menu: {
+    open: 'Open the initiative',
+    command: 'Copy the command',
+    why: 'Why is this here?',
+  },
+  /** One sentence per kind: why a card of that kind is on Today. The kinds are the eight of R12. */
+  why: {
+    1: 'A gate is owed. Only you can close it.',
+    2: 'A session is waiting for you.',
+    3: 'You sent a step back. It is still open.',
+    4: 'Work is ready for you to check.',
+    5: 'An agent proposed items. They count in no progress until you keep them.',
+    6: 'A capture was triaged. Add it or dismiss it.',
+    7: 'A cycle review is due. Confirm what is in Now, or move it.',
+    8: 'A record needs repair. Today shows it until it is fixed.',
+  },
+  noCommand: 'This card has no command.',
+  withdrawAll: 'Withdraw all',
+  keepHint: 'Keep them, or withdraw all from the menu.',
+  commandCopied: (cmd) => `Copied: ${cmd}`,
+  commandShown: (cmd) => `Run this in a terminal: ${cmd}`,
+  noInitiative: 'This card names no initiative.',
+  sessionGone: 'That session has ended.',
+  /** The Acceptance Gate card (D12): the PM's own act on a run. */
+  accept: {
+    review: 'Review',
+    question: 'Was the evaluator right?',
+    verdict: (v, score) => `The evaluator says ${v}${score !== null && score !== undefined ? ` (${score})` : ''}.`,
+    noVerdict: 'The evaluator gave no verdict.',
+    right: 'Right',
+    wrong: 'Wrong',
+    note: 'Add a note',
+    noteHint: 'Optional. One line on why.',
+    accept: 'Accept',
+    return: 'Return',
+    accepted: (run) => `Recorded the acceptance of ${run}.`,
+    returned: (run) => `Returned ${run}.`,
+    refused: (why) => `Nothing was recorded. ${why}`,
+    unreached: 'Nothing was recorded. The server did not answer.',
+  },
+};
+
+/**
+ * The glossary's `accept` and `next` rules are lifted and put back with one allowance each, so a later misuse in Today's
+ * copy ("Accept the proposal", "Next step") still fails glossary.test.js (contract C12):
+ *   accept  the Acceptance Gate card's button, `Accept` (D12), alone or as a bold button label in the guide
+ *   next    the empty state of R12, "Nothing needs you. Next: <draft>."
+ * Each extra rule reads: from the start of the text, skip anything that is not the allowed wording, then find the word.
+ */
+export const GLOSSARY = {
+  exempt: {
+    accept: 'Re-imposed below by accept-today, except the Acceptance Gate card\'s own button (D12).',
+    next: 'Re-imposed below by next-today, except the empty state of R12.',
+  },
+  extra: [
+    { id: 'accept-today', re: /^(?!Accept$)(?:(?!\*\*Accept\*\*)[^])*?\bAccept(?:s|ed|ing)?\b/,
+      why: 'A proposal is kept, not accepted. Only the Acceptance Gate card\'s button reads Accept (D12).' },
+    { id: 'next-today', re: /^(?:(?!Nothing needs you\. Next:)[^])*?(?:\bnext(?:\s*:|\s+steps?\b|\s+up\b)|\bup next\b)/i,
+      why: 'Next is the horizon. Only the empty state says "Nothing needs you. Next: <draft>." (R12).' },
+  ],
+  guide: 'today.md',
+};

package/workspace/public/pm/tokens.css

@@ -9,6 +9,12 @@
  * secondary text, status badges and warnings reach about 4.5:1 on the light surfaces. The dark theme, which the parity board
  * compares, is untouched.
  *
+ * Second exception, pm-os-absorb Run 3 (PRD R27): `--primary` is the foreground on the background, so a primary control is
+ * neutral in both themes. The brand colour has one meaning, the Today dot and count, and lives in `--brand-mark`, which only
+ * .pmc-needs-dot and .pmc-needs-count read (the gate's R28-8). `--brand` is a retired alias of the foreground: the old
+ * surfaces that still name it read neutral until each is swept, so the brand colour cannot leak back through them. The
+ * tab strip and the bottom bar follow the theme like the rest of the chrome: only the terminal itself (--term-bg) stays dark.
+ *
  * The faces are VENDORED (D62: the workspace is a local companion app that must render correctly
  * with no network at all). The prototype linked Google Fonts; a CDN font is network egress and is
  * forbidden here, so the same three IBM Plex Mono weights and the Space Grotesk variable face are
@@ -52,41 +58,33 @@
   --muted:oklch(0.275 0.011 216.9);--muted-foreground:oklch(0.723 0.014 214.4);
   --accent:oklch(0.275 0.011 216.9);--border:oklch(1 0 0 / 10%);--input:oklch(1 0 0 / 15%);
   --ring:oklch(0.56 0.021 213.5);--sidebar:oklch(0.218 0.008 223.9);
-  --brand:oklch(0.623 0.214 259.815);--brand-wash:color-mix(in oklab, oklch(0.623 0.214 259.815) 12%, transparent);
+  --primary:var(--foreground);--primary-foreground:var(--background);
+  --brand-mark:oklch(0.623 0.214 259.815);
+  --brand:var(--foreground);--brand-wash:color-mix(in oklab, var(--foreground) 8%, transparent);
   --success:oklch(0.76 0.17 152);--warning:oklch(0.82 0.15 82);--info:oklch(0.79 0.11 195);
   --purple:oklch(0.72 0.15 300);--destructive:oklch(0.704 0.191 22.216);
   --term-bg:oklch(0.148 0.004 228.8);
   --mono:"IBM Plex Mono",ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
   --sans:"Space Grotesk",ui-sans-serif,system-ui,sans-serif;
 }
-[data-pm-theme="light"]{
+[data-pm-theme="light"],html[data-pm-page-theme="light"]{
   --background:oklch(1 0 0);--foreground:oklch(0.148 0.004 228.8);
   --card:oklch(1 0 0);--secondary:oklch(0.967 0.001 286.375);
   --muted:oklch(0.963 0.002 197.1);--muted-foreground:oklch(0.48 0.021 213.5);
   --accent:oklch(0.963 0.002 197.1);--border:oklch(0.925 0.005 214.3);--input:oklch(0.925 0.005 214.3);
   --ring:oklch(0.723 0.014 214.4);--sidebar:oklch(0.987 0.002 197.1);
-  --brand:oklch(0.488 0.243 264.376);--brand-wash:color-mix(in oklab, oklch(0.488 0.243 264.376) 7%, transparent);
+  --primary:var(--foreground);--primary-foreground:var(--background);
+  --brand-mark:oklch(0.488 0.243 264.376);
+  --brand:var(--foreground);--brand-wash:color-mix(in oklab, var(--foreground) 8%, transparent);
   --success:oklch(0.46 0.13 152);--warning:oklch(0.48 0.11 72);--info:oklch(0.47 0.09 195);
   --purple:oklch(0.5 0.2 300);--destructive:oklch(0.5 0.21 27.325);
   --term-bg:oklch(0.148 0.004 228.8);
 }
-/* The tab strip and the bottom bar of the tabs panel sit on --term-bg, dark in BOTH themes (D41). In the light theme they take the
-   dark theme's tokens, so their text and controls stay readable. Copied from the :root block above; keep the two in step. */
-[data-pm-theme="light"] [data-term-chrome]{
-  --background:oklch(0.148 0.004 228.8);--foreground:oklch(0.987 0.002 197.1);
-  --card:oklch(0.218 0.008 223.9);--secondary:oklch(0.274 0.006 286.033);
-  --muted:oklch(0.275 0.011 216.9);--muted-foreground:oklch(0.723 0.014 214.4);
-  --accent:oklch(0.275 0.011 216.9);--border:oklch(1 0 0 / 10%);--input:oklch(1 0 0 / 15%);
-  --ring:oklch(0.56 0.021 213.5);--sidebar:oklch(0.218 0.008 223.9);
-  --brand:oklch(0.623 0.214 259.815);--brand-wash:color-mix(in oklab, oklch(0.623 0.214 259.815) 12%, transparent);
-  --success:oklch(0.76 0.17 152);--warning:oklch(0.82 0.15 82);--info:oklch(0.79 0.11 195);
-  --purple:oklch(0.72 0.15 300);--destructive:oklch(0.704 0.191 22.216);
-  color:var(--foreground);
-}
 @keyframes pmblink{0%,49%{opacity:1}50%,100%{opacity:0}}
 *{box-sizing:border-box}
-body{margin:0;background:oklch(0.148 0.004 228.8);-webkit-font-smoothing:antialiased}
-a{color:oklch(0.623 0.214 259.815)}a:hover{color:oklch(0.72 0.19 259.8)}
+body{margin:0;background:var(--background);-webkit-font-smoothing:antialiased}
+a{color:var(--foreground);text-decoration:underline;text-underline-offset:2px}
+@media (hover:hover){a:hover{color:var(--muted-foreground)}}
 button{font:inherit;color:inherit;background:none;border:0;cursor:pointer;text-align:left;padding:0}
 input,textarea{font:inherit;color:inherit;background:none;border:0;outline:none;padding:0;resize:none}
 /* overhaul-r1 R4: a collapsed-rail glyph draws its initials and kind badge from data attributes, so

package/workspace/public/pm/topbar.js

@@ -0,0 +1,102 @@
+/* pm/topbar.js — the frame's one top bar (pm-os-absorb Run 3, slice 3A; PRD R9, R10).
+ *
+ *   Repository ▾ · Today Initiatives Board Reports · ⌘K · Sync (only when unsynced) · Settings
+ *
+ * The bar is built once and updated on every render: app.js calls `bar.update(model)` and the bar changes only what
+ * the model changed, so a focused control keeps its focus across a repaint. It holds no state of its own except the
+ * last sync reading of each repository, which it reads from local git through data.js (no network: GET /api/sync/status
+ * runs `git status` against the remote-tracking ref the last fetch left).
+ *
+ *   createTopbar({ go, openPalette, repoMenu, sync }) → { node, update(model) }
+ *     go(id)              open destination id (today, initiatives, board, reports, settings)
+ *     openPalette()       open ⌘K
+ *     repoMenu(anchor)    open the Repository menu under `anchor`
+ *     sync(repo)          run Sync for `repo`; resolves to the server's answer
+ *   model = { dest, repoLabel, needs, unsynced, syncing }
+ *
+ * Hooks the suites find things by: [data-fr="bar"], [data-fr="repo"], [data-fr-dest="<id>"] (aria-current="page" on
+ * the open one), [data-today-badge] (the Today count, seams §2.6), [data-fr="search"], [data-fr="sync"].
+ */
+
+import { el, setChildren } from './dom.js';
+import { button, needsDot, needsCount } from './primitives.js';
+import { COPY } from './frame-copy.js';
+
+/** The destinations the bar names, in order. Settings sits at the end of the bar, after Sync. */
+export const BAR_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports']);
+
+/** Is this sync reading "not in sync"? Behind, ahead or records not yet recorded. An unreadable status is not shown. */
+export function unsyncedOf(st) {
+  return !!st && st.ok !== false && ((st.behind | 0) > 0 || (st.ahead | 0) > 0 || (st.dirty_records | 0) > 0);
+}
+
+export function createTopbar({ go, openPalette, repoMenu, sync } = {}) {
+  const node = el('header', { class: 'fr-bar', 'data-shell': 'top', 'data-fr': 'bar' });
+
+  let repoBtn = null;
+  let repoLabel = null;
+  const repoSlot = el('div', { class: 'fr-bar__repo' });
+
+  const count = needsCount('0', { 'data-today-badge': '' });
+  const dot = needsDot();
+  const links = {};
+  for (const id of [...BAR_DESTS, 'settings']) {
+    links[id] = button({
+      label: COPY.nav[id], variant: 'ghost', icon: id === 'settings' ? 'settings' : undefined,
+      attrs: { class: 'fr-link', 'data-fr-dest': id, 'aria-current': 'false' },
+      onClick: () => go && go(id),
+    });
+  }
+  const todayMark = el('span', { class: 'fr-mark' }, dot, count);
+  links.today.appendChild(todayMark);
+  const nav = el('nav', { class: 'fr-nav', 'aria-label': COPY.nav.label }, BAR_DESTS.map((id) => links[id]));
+
+  const search = button({
+    label: COPY.search, variant: 'outline', icon: 'search',
+    attrs: { class: 'fr-search', 'data-fr': 'search', 'aria-keyshortcuts': 'Meta+K Control+K' },
+    onClick: () => openPalette && openPalette(),
+  });
+  search.appendChild(el('kbd', { class: 'fr-kbd' }, COPY.searchKey));
+
+  let syncBtn = null;
+  let syncLabel = null;
+
+  function repoButton(label) {
+    const b = button({
+      label, variant: 'ghost', iconEnd: 'chevron-down',
+      attrs: { class: 'fr-repo', 'data-fr': 'repo', 'aria-haspopup': 'menu', 'aria-label': COPY.repo.open(label) },
+      onClick: () => repoMenu && repoMenu(b),
+    });
+    return b;
+  }
+  function syncButton(label, busy) {
+    return button({
+      label, variant: 'outline', size: 'sm', disabled: busy,
+      attrs: { class: 'fr-sync', 'data-fr': 'sync', title: COPY.sync.title },
+      onClick: () => sync && sync(),
+    });
+  }
+
+  function update(m) {
+    const model = m || {};
+    if (model.repoLabel !== repoLabel) {
+      repoLabel = model.repoLabel;
+      repoBtn = repoButton(repoLabel || COPY.repo.none);
+      setChildren(repoSlot, [repoBtn]);
+    }
+    for (const id of Object.keys(links)) links[id].setAttribute('aria-current', id === model.dest ? 'page' : 'false');
+    const n = Math.max(0, Number(model.needs) || 0);
+    if (count.textContent !== String(n)) count.textContent = String(n);
+    todayMark.hidden = n === 0;
+    count.setAttribute('aria-label', COPY.needs(n));
+    const want = model.unsynced || model.syncing ? (model.syncing ? COPY.sync.busy : COPY.sync.label) : null;
+    if (want !== syncLabel) {
+      syncLabel = want;
+      syncBtn = want ? syncButton(want, !!model.syncing) : null;
+    }
+    setChildren(node, [repoSlot, nav, search, syncBtn, links.settings]);
+  }
+
+  update({});
+  return { node, update, links };
+}

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

@@ -0,0 +1,60 @@
+/* pm/triage-card.js — the triage card of Today, kind 6 (pm-os-absorb Run 2, slice 2D; PRD R12, R17).
+ *
+ * "Proposed: <title> · <lane> · <anchor> · Add". A capture was triaged by an agent; one press of Add writes the
+ * initiative (`pmos initiative new --from <capture>`), and it starts in Later. The row's run id ends with the capture's id.
+ *
+ * The writer takes a title, a lane and an anchor and no more, so the card reads them back from the row's own line. When the
+ * line says "no anchor yet", the writer would refuse the initiative: the card opens the New-initiative form with the title
+ * and the lane filled in, and the PM chooses the anchor.
+ */
+
+import { button, card, toast, ensureComponentsCss } from './primitives.js';
+import { registerTodayCard } from './registry.js';
+import { COPY } from './initiatives-copy.js';
+import { createInitiative } from './initiatives-api.js';
+import { changed } from './initiative-sheet.js';
+import { openNewInitiative } from './new-initiative-sheet.js';
+
+const captureOf = (row) => String(row.run_id || '').replace(/^initiative-needs:triage:/, '');
+const titleOf = (q) => String(q || '').replace(/^Proposed:\s*/, '').split(' · ')[0];
+
+/** "Proposed: <title> · <lane label> · <anchor>" → { title, lane, anchor }, or null. The anchor is null for "no anchor yet". */
+export function proposalOf(question) {
+  const parts = String(question || '').replace(/^Proposed:\s*/, '').split(' · ');
+  if (parts.length < 3) return null;
+  const anchor = parts.pop().trim();
+  const lane = parts.pop().trim().replace(/\s+/g, '-');
+  const title = parts.join(' · ').trim();
+  return title && lane ? { title, lane, anchor: /^no anchor yet$/i.test(anchor) ? null : anchor } : null;
+}
+
+export function renderTriageCard(row, ctx) {
+  ensureComponentsCss();
+  let busy = false;
+  const add = button({
+    label: (row.today && row.today.act && row.today.act.label) || COPY.triage.add, variant: 'primary', attrs: { 'data-in-triage-add': '' },
+    onClick: async () => {
+      if (busy) return;
+      const p = proposalOf(row.question);
+      if (!p) { toast({ text: COPY.triage.addFailed(COPY.triage.unreadable), tone: 'error', timeout: 8000 }); return; }
+      if (!p.anchor) {
+        openNewInitiative({ repo: ctx.repo, ws: ctx.ws, anchors: [], prefill: { title: p.title, lane: p.lane, from: captureOf(row) }, onAdded: () => { changed(); try { window.dispatchEvent(new CustomEvent('pmos:ledgers', { detail: { changed: [ctx.ws] } })); } catch { /* no window */ } } });
+        return;
+      }
+      busy = true; add.disabled = true;
+      const out = await createInitiative(ctx.ws, { title: p.title, lane: p.lane, anchor: p.anchor, from: captureOf(row) });
+      busy = false; add.disabled = false;
+      if (out && out.ok) {
+        toast({ text: COPY.triage.added(titleOf(row.question)), timeout: 4000 });
+        changed();
+        try { window.dispatchEvent(new CustomEvent('pmos:ledgers', { detail: { changed: [ctx.ws] } })); } catch { /* no window */ }
+      } else toast({ text: COPY.triage.addFailed((out && out.error) || 'The server did not answer.'), tone: 'error', timeout: 8000 });
+    },
+  });
+  return card({
+    title: row.question, meta: [row.today && row.today.cause, row.today && row.today.evidence], trail: [add],
+    attrs: { class: 'in-today-card', 'data-today-row': 'triage', 'data-provider': row.provider || null, 'data-capture': captureOf(row) },
+  });
+}
+
+registerTodayCard('triage', renderTriageCard);