create-pmos 0.59.2 → 0.60.0

package/workspace/public/pm/initiative-sheet.js

@@ -26,7 +26,7 @@ import { state, setState } from './state.js';
 import { dayOf } from './breakdown-copy.js';
 import { COPY, shortDate } from './initiatives-copy.js';
 import { getSheet, getExport, place, placed, leaveNow, setLifecycle } from './initiatives-api.js';
-import { healthSignal, say, confirmSheet, checkBySheet, horizonLabel } from './initiatives-ui.js';
+import { healthSignal, say, confirmSheet, checkBySheet, horizonLabel, rescanRepo } from './initiatives-ui.js';
 
 /** The pre-Run-2 detail pane: the fallback, and the home of the legacy gate buttons that "Open gate" reaches. */
 export function legacyOpen(repo, slug) {
@@ -72,10 +72,12 @@ export function openSheet(repo, slug) {
   const waitingHost = el('div', { class: 'in-sheet__waiting-host' });
   const tabsHost = el('div', { class: 'in-sheet__tabs' });
   const panel = el('div', { class: 'in-sheet__panel', 'data-in-panel': '' });
+  // The Breakdown pane mounts into its own host, so the breakdown read from the spec can sit above it (scan-consistency R4).
+  const bdHost = el('div', { class: 'in-sheet__bd', 'data-in-bd': '' });
   const s = sheet({
     mode: 'auto', title: slug, sub: '', body: [crumb, stepperHost, waitingHost, tabsHost, panel],
     attrs: { class: 'in-sheet', 'data-in-sheet': 'initiative', 'data-in-id': slug },
-    onClose: () => { closed = true; unmountBreakdown(panel); unmountJira(panel); if (current === s) current = null; },
+    onClose: () => { closed = true; unmountBreakdown(bdHost); unmountJira(panel); if (current === s) current = null; },
   });
   current = s;
 
@@ -117,6 +119,7 @@ export function openSheet(repo, slug) {
     items.push({ sep: true });
     items.push({ label: COPY.sheet.copyCli, onSelect: () => copyCli() });
     items.push({ label: COPY.sheet.exportBreakdown, onSelect: () => exportBreakdown() });
+    items.push({ label: COPY.rescan, onSelect: async () => { const a = await rescanRepo(ws); if (a.ok) reload(); } });
     menu({ anchor, items, ariaLabel: COPY.sheet.menuMore(I.title) });
   }
 
@@ -182,7 +185,24 @@ export function openSheet(repo, slug) {
     const steps = data.stepper || [];
     stepperHost.replaceChildren(el('ol', { class: 'in-stepper', 'aria-label': COPY.sheet.stages, 'data-in-stepper': '' }, steps.map((st) => el('li', {
       class: 'in-stepper__step', 'data-state': st.state, 'data-step': st.id, 'aria-current': st.state === 'current' ? 'step' : null,
-    }, st.state === 'done' ? icon('check') : null, el('span', null, st.label)))));
+      title: st.state === 'skipped' && st.owed ? COPY.sheet.skippedStep(st.owed) : null,
+    }, st.state === 'done' ? icon('check') : st.state === 'skipped' ? icon('circle-alert') : null, el('span', null, st.label)))));
+  }
+
+  /** The breakdown read from the spec when nothing is planned (read-only; GET /api/initiatives/<id> `derived`). */
+  function derivedSection() {
+    const d = data.derived;
+    if (!d || !Array.isArray(d.items) || !d.items.length) return null;
+    const state = COPY.sheet.derivedStates[d.state] || d.state;
+    return el('section', { class: 'in-derived', 'data-in-derived': d.state },
+      el('h3', { class: 'in-derived__title' }, COPY.sheet.derivedTitle(d.source)),
+      el('p', { class: 'in-note' }, COPY.sheet.derivedNote(d.basis)),
+      el('div', { class: 'in-sheet__rows', role: 'list' }, d.items.map((it) => row({
+        title: (it.ref ? it.ref + ' · ' : '') + it.title, meta: [state], done: d.state === 'done',
+        openLabel: COPY.aria.open(it.title),
+        onOpen: () => { const src = String(d.source || '').split(',')[0].trim(); if (src) { s.close(); openDoc(slug, src, src.split('/').pop()); } },
+        attrs: { 'data-in-derived-item': it.id, 'data-state': d.state },
+      }))));
   }
 
   function drawWaiting() {
@@ -224,7 +244,7 @@ export function openSheet(repo, slug) {
       items: [{ id: 'breakdown', label: COPY.sheet.breakdown }, { id: 'files', label: COPY.sheet.files }, { id: 'history', label: COPY.sheet.history }, { id: 'jira', label: COPY.sheet.jira }],
       onChange: (id) => {
         if (id === tab) return;
-        if (tab === 'breakdown') unmountBreakdown(panel);
+        if (tab === 'breakdown') unmountBreakdown(bdHost);
         if (tab === 'jira') unmountJira(panel);
         tab = id;
         drawTabs(); drawPanel();
@@ -236,15 +256,27 @@ export function openSheet(repo, slug) {
 
   function drawPanel() {
     if (!data) return;
-    if (tab === 'breakdown') { mountBreakdown(panel, { id: tabId, ws, slug }, { embedded: true }); return; }
+    if (tab === 'breakdown') {
+      const derived = derivedSection();
+      panel.replaceChildren(...(derived ? [derived, bdHost] : [bdHost]));
+      mountBreakdown(bdHost, { id: tabId, ws, slug }, { embedded: true });
+      return;
+    }
     if (tab === 'jira') { mountJira(panel, { ws, slug }); return; }
     if (tab === 'files') {
       const files = data.files || [];
-      panel.replaceChildren(files.length ? el('div', { class: 'in-sheet__rows', role: 'list' }, files.map((f) => row({
-        title: f.label, meta: [f.path], openLabel: COPY.aria.open(f.label),
-        onOpen: () => { s.close(); openDoc(slug, f.path, f.label); },
-        attrs: { 'data-in-file': f.kind }, openAttrs: { 'data-in-file-open': f.kind },
-      }))) : empty({ text: COPY.sheet.noFiles }));
+      // Grouped by where the tie came from (scan-consistency R3): the record's own paths, the documents the library's
+      // index links to it, and the files git changed for it. A `note` row is a fact about the list, not a file.
+      const order = ['record', 'knowledge-graph', 'git'];
+      const groups = order.map((src) => [src, files.filter((f) => (f.source || 'record') === src)]).filter(([, list]) => list.length);
+      const fileRow = (f) => (f.kind === 'note' ? el('p', { class: 'in-note', 'data-in-file-note': '' }, f.label) : row({
+        title: f.label, meta: [f.path, f.commits ? COPY.sheet.commits(f.commits) : null, f.shared ? COPY.sheet.shared : null], openLabel: COPY.aria.open(f.label),
+        onOpen: () => { s.close(); openDoc(slug, f.path, f.label, null, f.source === 'git' ? { readonly: true } : undefined); },
+        attrs: { 'data-in-file': f.kind, 'data-in-file-source': f.source || 'record' }, openAttrs: { 'data-in-file-open': f.kind },
+      }));
+      panel.replaceChildren(files.length ? el('div', { class: 'in-files' }, groups.map(([src, list]) => el('section', { class: 'in-files__group', 'data-in-files': src },
+        el('h3', { class: 'in-files__title' }, COPY.sheet.fileSource[src] || src),
+        el('div', { class: 'in-sheet__rows', role: 'list' }, list.map(fileRow))))) : empty({ text: COPY.sheet.noFiles }));
       return;
     }
     const hist = data.history || [];

package/workspace/public/pm/initiatives-api.js

@@ -10,6 +10,7 @@
  *   GET  /api/initiatives/<id>/export?ws=            the breakdown as text
  *   POST /api/placements       { ws, events: [placed…] }       every move, reorder and check-by
  *   POST /api/initiatives      { ws, title, lane, anchor, intent?, from? }   the New-initiative form and a triage card (one body, no events)
+ *   POST /api/initiatives/rescan { ws }                     the Re-scan press: read the repository again now (nothing is written)
  *
  * Every GET of /api/initiatives answers 202 { ok: false, pending: true } until the repository's first derivation lands (2C,
  * about 260 ms a record); a read waits and asks again, so a caller sees the answer or a real error, never the 202.
@@ -47,6 +48,20 @@ export const adopt = (ws, proposal) => pmPost('/api/placements', { ws, events: [
 export const drop = (ws, proposal) => pmPost('/api/placements', { ws, events: [{ ev: 'dropped', proposal }] });
 
 /** A new initiative: from the form, or from a triaged capture (`from` is the capture's id). It lands in Later. */
+/** Read the repository again now. Answers when the new derivation has landed (the records part of the sig stops reading
+ *  `~stale`), or { ok: true, slow: true } when it is still running after about three minutes. */
+export async function rescan(ws) {
+  const a = await pmPost('/api/initiatives/rescan', { ws });
+  if (!a || !a.ok) return a || { ok: false, error: 'no answer' };
+  for (let k = 0; k < 120; k++) {
+    await sleep(1500);
+    const r = await pmGet('/api/initiatives?ws=' + enc(ws) + '&view=roadmap');
+    const rec = r && r.sig ? String(r.sig.records || '') : '';
+    if (r && r.ok && rec && !rec.endsWith('~stale')) return { ok: true };
+  }
+  return { ok: true, slow: true };
+}
+
 export const createInitiative = (ws, fields) => pmPost('/api/initiatives', { ws, ...fields });
 
 export const setLifecycle = (ws, id, state, reason) => pmPost('/api/lifecycle', { ws, initiative_id: id, state, reason: reason || '' });

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

@@ -28,6 +28,12 @@ export const COPY = {
   roadmap: 'Roadmap',
   list: 'List',
   newInitiative: 'New initiative',
+  rescan: 'Re-scan the repository',
+  rescanning: 'Re-scanning…',
+  rescanHint: 'Read stage, files and breakdown again now',
+  rescanDone: (t) => `Read again at ${t}`,
+  rescanFailed: (why) => `Could not re-scan: ${why}`,
+  rescanSlow: 'The re-scan is still running. The view updates when it ends.',
   reading: 'Reading…',
   readFailed: (why) => `Could not read the initiatives: ${why}`,
   noRepo: 'Add a repository to see its initiatives.',
@@ -127,6 +133,13 @@ export const COPY = {
     openGate: 'Open gate',
     handToAgent: 'Hand to agent',
     noFiles: 'No files yet.',
+    fileSource: { record: 'Named by the record', 'knowledge-graph': 'Linked documents', git: 'Changed for it in git' },
+    commits: (n) => (n === 1 ? '1 commit' : `${n} commits`),
+    shared: 'shared',
+    skippedStep: (noun) => `Skipped: ${noun} is still open`,
+    derivedTitle: (src) => `From the spec · ${src}`,
+    derivedNote: (basis) => `Read from the spec, because the Breakdown has no items yet. Each item shows the state of the whole initiative: ${basis}.`,
+    derivedStates: { todo: 'Todo', review: 'Built', done: 'Done' },
     noHistory: 'No history yet.',
     reading: 'Reading…',
     readFailed: (why) => `Could not read the initiative: ${why}`,

package/workspace/public/pm/initiatives-ui.js

@@ -6,12 +6,14 @@
  *   confirmSheet({…})               a sheet that asks for one press (a PM-only act): an optional choice, a reason, Cancel, Confirm
  *   checkBySheet({…})               a sheet with a date and Save or Clear
  *   say(out, ok)                    a toast for the answer of a write: the success text, or the server's refusal
+ *   rescanRepo(ws)                  read the repository again now, with a toast at the start and at the end (scan-consistency R6)
  * No native dialog is used anywhere here. Every control is a primitive (primitives.js).
  */
 
 import { el } from './dom.js';
 import { button, field, signal, sheet, tabs, toast } from './primitives.js';
 import { COPY } from './initiatives-copy.js';
+import { rescan } from './initiatives-api.js';
 
 export const horizonLabel = (h) => COPY.horizons[h] || h;
 export const progressText = (row) => (row && row.progress && row.progress.label) || '';
@@ -24,6 +26,18 @@ export function healthSignal(health) {
   return signal({ text: top.text || COPY.healthUnknown, tone, title: top.source || null, attrs: { 'data-health': health.level } });
 }
 
+/** Re-scan: read the repository again now. A toast says it started and another says how it ended. Answers the rescan
+ *  answer; the caller reloads what it shows when `ok`. */
+export async function rescanRepo(ws) {
+  toast({ text: COPY.rescanning, timeout: 4000 });
+  const a = await rescan(ws);
+  const t = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  if (!a || !a.ok) toast({ text: COPY.rescanFailed((a && a.error) || 'no answer'), tone: 'error', timeout: 8000 });
+  else toast({ text: a.slow ? COPY.rescanSlow : COPY.rescanDone(t), timeout: 6000 });
+  try { if (a && a.ok) window.dispatchEvent(new CustomEvent('pmos:initiatives-changed')); } catch { /* no window */ }
+  return a || { ok: false };
+}
+
 /** A toast for the answer of a write. A refusal shows the server's own words. */
 export function say(out, okText) {
   if (out && out.ok) { if (okText) toast({ text: okText, timeout: 4000 }); return true; }

package/workspace/public/pm/mobile.js

@@ -505,11 +505,10 @@ export function mountMobile(context) {
   if (theme) theme.addEventListener('click', toggleTheme);
   document.addEventListener('click', onChromeClick);
 
-  /* `resize` only. A visual-viewport SCROLL moves the page under the keyboard and changes no box,
-   * so there is nothing to re-fit — but it fires on every frame of a touch scroll, and each one used
-   * to become a synthetic window `resize` that every resize listener on the page answered. That was
-   * the terminal stuttering under a finger on a phone. */
-  if (window.visualViewport) window.visualViewport.addEventListener('resize', refit);
+  if (window.visualViewport) {
+    window.visualViewport.addEventListener('resize', refit);
+    window.visualViewport.addEventListener('scroll', refit);
+  }
   window.addEventListener('orientationchange', () => setTimeout(refit, 250));
 
   // Crossing the breakpoint (rotate a tablet, drag a window narrow) has to re-decide whether the

package/workspace/public/pm/registry.js

@@ -44,7 +44,7 @@ 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: 'today', label: 'Agenda', 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 }),

package/workspace/public/pm/tab-term.js

@@ -678,25 +678,7 @@ function syncSize(rec) {
   if (!rec.sessionId || rec.attachedId !== rec.sessionId) return;
   const cols = rec.term.cols, rows = rec.term.rows;
   if (!cols || !rows) return;
-  if (rec.sentCols === cols && rec.sentRows === rows) { clearTimeout(rec.sizeTimer); rec.sizeTimer = null; return; }
-  /* The FIRST statement on an attach goes out at once: until it does, the shell is drawing into the
-   * 80×24 it was spawned with. A CHANGE after that waits for the grid to settle. A phone's soft
-   * keyboard slides in over about a quarter of a second and the pane is re-fitted on every frame of
-   * it; each `resize` the PTY gets makes a full-screen agent CLI repaint everything it shows, so
-   * stating every intermediate grid buried the session under a dozen redraws of screens that were
-   * gone before they arrived. The local fit is not delayed — only what the shell is told. */
-  if (rec.sentCols == null) { sendSize(rec); return; }
-  clearTimeout(rec.sizeTimer);
-  rec.sizeTimer = setTimeout(() => { rec.sizeTimer = null; sendSize(rec); }, RESIZE_SETTLE_MS);
-}
-
-/** How long the grid must hold still before a change is stated to the PTY. See syncSize. */
-const RESIZE_SETTLE_MS = 120;
-
-function sendSize(rec) {
-  if (!rec.term || !rec.sessionId || rec.attachedId !== rec.sessionId) return;
-  const cols = rec.term.cols, rows = rec.term.rows;
-  if (!cols || !rows || (rec.sentCols === cols && rec.sentRows === rows)) return;
+  if (rec.sentCols === cols && rec.sentRows === rows) return;
   if (send({ t: 'resize', id: rec.sessionId, cols, rows })) { rec.sentCols = cols; rec.sentRows = rows; }
 }
 
@@ -712,40 +694,19 @@ function note(rec, line, force) {
  * The single entry point. Coalesced into one animation frame so the six triggers below cost one
  * measure per frame rather than six. A pane that is not in the document, or has no box yet, is
  * skipped — fitting a zero-sized element is how a terminal ends up 1×1 and stays there.
- *
- * A pane whose box has not moved since it was last fitted is NOT re-measured. Every state change
- * in the app lands here (the `subscribe` below), and a fit is a getComputedStyle round-trip on the
- * terminal's parent per pane — on a phone, that was a forced style pass on every render for a grid
- * that could not have changed. The grid depends on the box and on the cell size; the box is the key
- * here, and the one event that moves the cell size without moving the box (the web font arriving)
- * passes `force`.
  */
 let refitQueued = false;
-let refitForce = false;
 
-export function refitVisible(force) {
-  if (force === true) refitForce = true;
+export function refitVisible() {
   if (refitQueued) return;
   refitQueued = true;
   const run = () => {
     refitQueued = false;
-    const forced = refitForce;
-    refitForce = false;
     for (const rec of panes.values()) {
       if (rec.kind !== 'real' || !rec.fit || !rec.host) continue;
       if (!rec.host.isConnected) continue;
-      const w = rec.host.offsetWidth, h = rec.host.offsetHeight;
-      if (!w || !h) continue;
-      if (!forced && rec.fitW === w && rec.fitH === h) { syncSize(rec); continue; }
-      try {
-        // Measured first, so a pane whose renderer cannot measure yet is retried next time rather
-        // than remembered as fitted at a grid it never reached.
-        const dims = rec.fit.proposeDimensions();
-        if (dims && dims.cols > 0 && dims.rows > 0) {
-          if (dims.cols !== rec.term.cols || dims.rows !== rec.term.rows) rec.fit.fit();
-          rec.fitW = w; rec.fitH = h;
-        }
-      } catch { /* a terminal mid-teardown */ }
+      if (!rec.host.offsetWidth || !rec.host.offsetHeight) continue;
+      try { rec.fit.fit(); } catch { /* a terminal mid-teardown */ }
       // …and state the resulting grid to the PTY. `fit()` only fires xterm's `onResize` when the
       // grid MOVES, so a pane that was measured before it had a session would otherwise never tell
       // the shell how wide it is. See the `attached` handler.
@@ -763,8 +724,7 @@ if (typeof window !== 'undefined') {
   subscribe(() => refitVisible());
   window.addEventListener('resize', () => refitVisible());
   document.addEventListener('visibilitychange', () => { if (!document.hidden) refitVisible(); });
-  // The face changes the CELL, not the box, so this one re-measures every pane regardless.
-  if (document.fonts && document.fonts.ready) document.fonts.ready.then(() => refitVisible(true)).catch(() => {});
+  if (document.fonts && document.fonts.ready) document.fonts.ready.then(() => refitVisible()).catch(() => {});
 }
 
 /* ── fixture pane ──────────────────────────────────────────────────────────────────────────── */
@@ -971,7 +931,6 @@ export function disposeTerm(tab) {
    * pane for the id and detaches from the orphan instead. */
   if (rec.kind !== 'real') return;
   if (rec.ro) { try { rec.ro.disconnect(); } catch { /* ignore */ } }
-  if (rec.sizeTimer) { clearTimeout(rec.sizeTimer); rec.sizeTimer = null; }
   if (rec.sessionId) {
     send({ t: 'detach', id: rec.sessionId });
     SOCK.attached.delete(rec.sessionId);
@@ -1099,9 +1058,6 @@ export function termProbe() {
  */
 export function __handleForTest(m) { return handle(m); }
 
-/* `fit` is the name mobile.js asks for when the soft keyboard or a rotation moves the box. Without it
- * that module fell back to dispatching a synthetic window `resize`, which every resize listener on
- * the page answered — not only this one. */
-if (typeof window !== 'undefined') window.pmTerm = { refitVisible, fit: () => refitVisible(), termProbe, panes, requestSpawn };
+if (typeof window !== 'undefined') window.pmTerm = { refitVisible, termProbe, panes, requestSpawn };
 
 export default mountTerm;

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

@@ -0,0 +1,305 @@
+/* pm/today-agenda.js — the Agenda month in the left column of Today (initiative today-goals, PRD G25 to G27).
+ *
+ *   agendaPanel(ctx, h)      → the panel: the month on top, the agenda of the picked day or week under it; null when the
+ *                              server has no agenda route (an older workspace), so the day's calendar list shows instead
+ *   meetingDetail(ctx, id)   → the right column for a remembered meeting: what it means, before it, the last time
+ *   memoryBlock(id)          → the series part of that detail, for a meeting of today drawn from the brief
+ *   litSeries(sel)           → the series key of the selected meeting, so the month marks the days it happens
+ *   refreshAgenda() · agendaSig() · onAgenda(fn)
+ *
+ * One read feeds it: GET /api/proactive/agenda?month=YYYY-MM. The server derives every answer (how full, the key
+ * meeting, readiness, no notes); this file only draws them. A day cell is a button: it picks that day. A week number
+ * picks the week. The lens switch says which answer the cells show; the agenda under the month always shows them all.
+ * Nothing here writes: the calendar memory changes only through the morning-brief session's brief.
+ */
+
+import { el } from './dom.js';
+import { button, iconButton, badge, tabs } from './primitives.js';
+import { pmGet } from './http.js';
+import { COPY } from './today-copy.js';
+
+const A = COPY.day.ag;
+const DAY0 = 9 * 60;
+const SPAN = 9 * 60;
+
+const cache = new Map();   // month -> { data, error, old }
+const ag = { month: null, pick: null, lens: 'overview', showRoutine: false };
+let redraw = () => {};
+let inflight = new Set();
+
+export function onAgenda(fn) { redraw = fn; }
+
+const pad = (n) => String(n).padStart(2, '0');
+const ymOf = (date) => date.slice(0, 7);
+const shiftMonth = (ym, n) => { const [y, m] = ym.split('-').map(Number); const d = new Date(y, m - 1 + n, 1); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}`; };
+const dateOf = (s) => { const [y, m, d] = s.split('-').map(Number); return new Date(y, m - 1, d); };
+const label = (s, opts) => { try { return dateOf(s).toLocaleDateString(undefined, opts); } catch { return s; } };
+const dayLabel = (s) => label(s, { weekday: 'short', day: 'numeric', month: 'short' });
+/** ISO 8601 week number of a YYYY-MM-DD date. */
+function isoWeek(s) {
+  const d = dateOf(s);
+  const t = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+  const wd = t.getUTCDay() || 7;
+  t.setUTCDate(t.getUTCDate() + 4 - wd);
+  const y0 = new Date(Date.UTC(t.getUTCFullYear(), 0, 1));
+  return Math.ceil(((t - y0) / 86400000 + 1) / 7);
+}
+
+async function loadMonth(month) {
+  const key = month || 'now';
+  if (inflight.has(key)) return;
+  inflight.add(key);
+  const out = await pmGet('/api/proactive/agenda' + (month ? '?month=' + encodeURIComponent(month) : ''));
+  inflight.delete(key);
+  const m = out && out.ok ? out.month : month;
+  const prev = cache.get(m);
+  const next = out && out.ok ? { data: out, error: null, old: false }
+    : { data: prev ? prev.data : null, error: (out && out.error) || A.unread, old: !!(out && out.status === 404) };
+  if (!ag.month && out && out.ok) ag.month = out.month;
+  if (!month && !(out && out.ok)) cache.set('now', next);
+  if (m) cache.set(m, next);
+  // `now` moves every read: compare it to the minute, so a read that changes nothing draws nothing
+  if (!prev || sigOf(prev) !== sigOf(next)) redraw();
+}
+
+const sigOf = (c) => JSON.stringify({ ...c, data: c.data ? { ...c.data, now: String(c.data.now).slice(0, 16) } : null });
+
+/** Read the shown month again (the day read calls this, so the month follows the brief and the clock). */
+export function refreshAgenda() { loadMonth(ag.month); }
+
+function current() {
+  const c = (ag.month && cache.get(ag.month)) || cache.get('now') || null;
+  if (!c) { loadMonth(ag.month); return null; }
+  return c;
+}
+
+export function agendaSig() {
+  const c = ag.month ? cache.get(ag.month) : cache.get('now');
+  return JSON.stringify([ag, c ? [c.error, c.data && c.data.now ? String(c.data.now).slice(0, 16) : null, c.data && Object.keys(c.data.days || {}).length, c.data && c.data.memory] : null])
+    + (c && c.data ? JSON.stringify(c.data.days).length : 0);
+}
+
+/* ── finding a meeting across the months read ─────────────────────────────────────────────────────────────────── */
+
+function findEvent(id) {
+  for (const c of cache.values()) {
+    if (!c.data) continue;
+    for (const d of Object.values(c.data.days)) {
+      const e = d.events.find((x) => x.id === id);
+      if (e) return { e, day: d, data: c.data };
+    }
+  }
+  return null;
+}
+
+/** The series key of the selected meeting (a remembered one, or today's from the brief), or null. */
+export function litSeries(sel) {
+  if (!sel || (sel.type !== 'meeting' && sel.type !== 'event')) return null;
+  const f = findEvent(sel.id);
+  return f ? { key: f.e.key, title: f.e.title } : null;
+}
+
+/* ── the month ────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function strip(day, lens) {
+  const s = el('div', { class: 'td-ag__strip', 'aria-hidden': 'true' });
+  const put = (from, mins, cls) => {
+    const a = Math.max(0, from - DAY0); const b = Math.min(SPAN, from - DAY0 + mins);
+    if (b <= a) return;
+    const n = el('span', { class: cls });
+    n.style.setProperty('--td-ag-l', (a / SPAN * 100).toFixed(2) + '%');
+    n.style.setProperty('--td-ag-w', ((b - a) / SPAN * 100).toFixed(2) + '%');
+    s.append(n);
+  };
+  if (lens === 'free') for (const [a, b] of day.gaps) put(a, b - a, 'td-ag__blk td-ag__blk--free');
+  else for (const e of day.events) { const [h, m] = e.time.split(':').map(Number); put(h * 60 + m, e.minutes, 'td-ag__blk' + (e.imp ? ' td-ag__blk--imp' : '')); }
+  return s;
+}
+
+function readyBadge(day, withWord) {
+  if (!day.need) return null;
+  return el('span', { class: 'td-ag__ready', 'data-ag-ready': day.ready || 'ok', title: A.readyWord[day.ready || 'ok'] },
+    A.readyBadge(day.done, day.need), withWord ? ' ' + A.readyWord[day.ready || 'ok'] : null);
+}
+
+function keyLine(day) {
+  if (!day.key) return null;
+  const e = day.events.find((x) => x.id === day.key);
+  return e ? el('span', { class: 'td-ag__key' }, A.star + ' ' + e.title) : null;
+}
+
+function cell(data, d, lit) {
+  const day = data.days[d];
+  const lens = ag.lens;
+  const kids = [el('span', { class: 'td-ag__num' }, String(Number(d.slice(8))))];
+  if (day.events.length && (lens === 'overview' || lens === 'full' || lens === 'free')) kids.push(strip(day, lens));
+  if (lens === 'overview') {
+    kids.push(keyLine(day));
+    if (day.ready === 'risk' || day.ready === 'warn' || (day.ready === 'ok' && !day.past)) kids.push(readyBadge(day));
+    if (day.past && day.no_notes) kids.push(el('span', { class: 'td-ag__nonotes' }, A.noNotes(day.no_notes)));
+  } else if (lens === 'full') {
+    if (day.busy) kids.push(el('span', { class: 'td-ag__meta' }, A.busy(day.busy)));
+  } else if (lens === 'key') {
+    kids.push(keyLine(day));
+  } else if (lens === 'ready') {
+    kids.push(readyBadge(day, false));
+    if (day.past && day.no_notes) kids.push(el('span', { class: 'td-ag__nonotes' }, A.noNotes(day.no_notes)));
+  } else if (lens === 'free' && !day.weekend) {
+    kids.push(el('span', { class: 'td-ag__meta' }, day.gaps.length ? A.freeBlocks(day.gaps.length) : A.noFree));
+  }
+  const picked = ag.pick && ag.pick.type === 'day' && ag.pick.date === d;
+  return button({ label: el('span', { class: 'td-ag__in' }, ...kids.filter(Boolean)), variant: 'ghost', onClick: () => pickDay(d),
+    attrs: { class: 'td-ag__cell', 'data-ag-day': d, 'data-out': day.in_month ? null : 'true', 'data-past': day.past ? 'true' : null, 'data-today': day.today ? 'true' : null,
+      'data-weekend': day.weekend ? 'true' : null, 'data-lit': lit && lit.has(d) ? 'true' : null, 'aria-pressed': picked ? 'true' : 'false', title: A.dayHint(dayLabel(d), day.key ? (day.events.find((e) => e.id === day.key) || {}).title : null) } });
+}
+
+function pickDay(d) { ag.pick = { type: 'day', date: d }; ag.showRoutine = false; redraw(); }
+function pickWeek(i) { ag.pick = { type: 'week', i }; ag.showRoutine = false; redraw(); }
+function goMonth(n, data) {
+  ag.month = n === 0 ? ymOf(data.today) : shiftMonth(ag.month || data.month, n);
+  ag.pick = null;
+  if (!cache.has(ag.month)) loadMonth(ag.month);
+  redraw();
+}
+
+function month(data, lit) {
+  const head = el('div', { class: 'td-ag__mhead' },
+    iconButton({ icon: 'chevron-left', ariaLabel: A.prev, size: 'sm', attrs: { 'data-ag': 'prev' }, onClick: () => goMonth(-1, data) }),
+    el('b', { class: 'td-ag__mlabel', 'data-ag': 'month' }, label(data.month + '-01', { month: 'long', year: 'numeric' })),
+    iconButton({ icon: 'chevron-right', ariaLabel: A.later, size: 'sm', attrs: { 'data-ag': 'later' }, onClick: () => goMonth(1, data) }),
+    ymOf(data.today) !== data.month ? button({ label: A.thisMonth, size: 'sm', variant: 'ghost', attrs: { 'data-ag': 'this-month' }, onClick: () => goMonth(0, data) }) : null);
+  const lens = tabs({ variant: 'segmented', role: 'radiogroup', ariaLabel: A.title, value: ag.lens, attrs: { 'data-ag': 'lens', class: 'td-ag__lens' },
+    items: Object.keys(A.lens).map((k) => ({ id: k, label: A.lens[k] })), onChange: (v) => { ag.lens = v; redraw(); } });
+  const wd = el('div', { class: 'td-ag__wk td-ag__wk--head', 'aria-hidden': 'true' }, el('span', null, ''),
+    ...data.weeks[0].map((d) => el('span', { class: 'td-ag__wd' }, label(d, { weekday: 'short' }))));
+  const rows = data.weeks.map((w, i) => {
+    const n = isoWeek(w[0]);
+    const picked = ag.pick && ag.pick.type === 'week' && ag.pick.i === i;
+    return el('div', { class: 'td-ag__wk', role: 'group', 'aria-label': A.weekOf(n) },
+      button({ label: A.weekNo(n), variant: 'ghost', size: 'sm', onClick: () => pickWeek(i), attrs: { class: 'td-ag__wno', 'data-ag-week': String(n), 'aria-pressed': picked ? 'true' : 'false', title: A.weekHint(n) } }),
+      ...w.map((d) => cell(data, d, lit)));
+  });
+  return [head, lens, el('p', { class: 'td-day__note', 'data-ag': 'lens-help' }, A.lensHelp[ag.lens]),
+    el('div', { class: 'td-ag__grid', 'data-ag': 'grid', 'data-lens': ag.lens }, wd, ...rows)];
+}
+
+/* ── the agenda under the month ───────────────────────────────────────────────────────────────────────────────── */
+
+function tiles(day) {
+  const key = day.key ? day.events.find((e) => e.id === day.key) : null;
+  const t = (k, v, attrs) => el('div', { class: 'td-ag__tile', ...(attrs || {}) }, el('span', { class: 'td-ag__tk' }, A.tiles[k]), el('b', null, v));
+  return el('div', { class: 'td-ag__tiles', 'data-ag': 'tiles' },
+    t('busy', day.busy ? A.busy(day.busy) : A.noMeetings),
+    t('key', key ? key.title : A.noKey),
+    t('ready', day.need ? A.readyBadge(day.done, day.need) + ' · ' + A.readyWord[day.ready || 'ok'] : A.noPrep, day.need ? { 'data-ag-ready': day.ready || 'ok' } : null));
+}
+
+function eventRow(h, e) {
+  const type = e.src === 'brief' ? 'event' : 'meeting';
+  const chips = el('span', { class: 'td-day__chips' },
+    e.imp ? badge({ text: A.star, tone: 'outline', attrs: { title: A.means } }) : null,
+    e.prep ? el('span', { class: 'td-ag__ready', 'data-ag-ready': e.ready || 'ok' }, A.readyBadge(e.prep_done || 0, e.prep.length)) : null,
+    e.ended && !e.notes && (e.imp || e.kind === 'one') ? el('span', { class: 'td-ag__nonotes' }, A.noNotes(1)) : null);
+  return h.rowBtn(type, e.id, { lead: e.time, title: e.title, meta: A.kindWord[e.kind] + (e.attendees ? ' · ' + A.people(e.attendees) : ''), trail: chips },
+    { 'data-past': e.ended ? 'true' : null, 'data-ag-event': e.id });
+}
+
+function rowsOf(h, evs) {
+  const main = evs.filter((e) => !e.routine);
+  const rout = evs.filter((e) => e.routine);
+  return [
+    main.length ? el('ul', { class: 'td-day__rows', 'data-day-list': 'agenda' }, ...main.map((e) => eventRow(h, e))) : null,
+    rout.length ? button({ label: ag.showRoutine ? A.hideRoutine : A.routine(rout.length), variant: 'ghost', size: 'sm',
+      attrs: { 'data-ag': 'routine', 'aria-expanded': ag.showRoutine ? 'true' : 'false' }, onClick: () => { ag.showRoutine = !ag.showRoutine; redraw(); } }) : null,
+    rout.length && ag.showRoutine ? el('ul', { class: 'td-day__rows', 'data-day-list': 'routine' }, ...rout.map((e) => eventRow(h, e))) : null,
+  ];
+}
+
+function agendaOf(data, h) {
+  const pick = ag.pick || (data.days[data.today] ? { type: 'day', date: data.today } : { type: 'day', date: data.month + '-01' });
+  if (pick.type === 'week') {
+    const w = data.weeks[pick.i] || data.weeks[0];
+    const all = w.flatMap((d) => data.days[d].events);
+    const days = w.filter((d) => data.days[d].events.some((e) => !e.routine));
+    const rout = all.filter((e) => e.routine);
+    return el('div', { class: 'td-ag__agenda', 'data-ag': 'agenda', 'data-ag-pick': 'week:' + isoWeek(w[0]) },
+      el('h3', { class: 'td-ag__ah' }, A.weekOf(isoWeek(w[0])), el('span', { class: 'td-day__dim' }, ' · ' + dayLabel(w[0]) + ' – ' + dayLabel(w[6]))),
+      days.length ? days.map((d) => el('div', { class: 'td-ag__wday' }, el('h4', null, dayLabel(d), data.days[d].busy ? el('span', { class: 'td-day__dim' }, ' · ' + A.busy(data.days[d].busy)) : null, readyBadge(data.days[d])),
+        el('ul', { class: 'td-day__rows' }, ...data.days[d].events.filter((e) => !e.routine).map((e) => eventRow(h, e))))) : el('p', { class: 'td-day__note' }, A.noMeetings),
+      rout.length ? button({ label: ag.showRoutine ? A.hideRoutine : A.routine(rout.length), variant: 'ghost', size: 'sm',
+        attrs: { 'data-ag': 'routine', 'aria-expanded': ag.showRoutine ? 'true' : 'false' }, onClick: () => { ag.showRoutine = !ag.showRoutine; redraw(); } }) : null,
+      rout.length && ag.showRoutine ? el('ul', { class: 'td-day__rows', 'data-day-list': 'routine' }, ...rout.map((e) => eventRow(h, e))) : null);
+  }
+  const day = data.days[pick.date];
+  if (!day) return null;
+  // today keeps the day's calendar from the brief (the line at the current time, the goal ties, the prep chips)
+  const todayList = day.today && h.todayRows ? h.todayRows() : null;
+  return el('div', { class: 'td-ag__agenda', 'data-ag': 'agenda', 'data-ag-pick': 'day:' + pick.date },
+    el('h3', { class: 'td-ag__ah' }, day.today ? A.today + ' · ' + dayLabel(pick.date) : dayLabel(pick.date)),
+    tiles(day),
+    todayList || (day.events.length ? rowsOf(h, day.events) : el('p', { class: 'td-day__note' }, A.noMeetings)));
+}
+
+/** The panel. `h` lends the day section's helpers: { panel, rowBtn(type, id, parts, mods), todayRows(), sel }. */
+export function agendaPanel(ctx, h) {
+  const c = current();
+  if (!c) return h.panel('agenda', null, el('p', { class: 'td-day__note' }, A.loading));
+  if (!c.data) return c.old ? null : h.panel('agenda', null, el('p', { class: 'td-day__note', role: 'status' }, c.error || A.unread));
+  const data = c.data;
+  const lit = litSeries(h.sel);
+  const litDays = lit && data.series[lit.key] ? new Set(data.series[lit.key].dates) : null;
+  const empty = !data.memory || !data.memory.events;
+  return h.panel('agenda', null,
+    ...month(data, litDays),
+    litDays ? el('p', { class: 'td-day__note', 'data-ag': 'lit' }, A.lit(lit.title, [...litDays].filter((d) => data.days[d]).length)) : null,
+    empty ? el('p', { class: 'td-day__note', 'data-ag': 'empty' }, A.empty) : null,
+    agendaOf(data, h));
+}
+
+/* ── the right column ─────────────────────────────────────────────────────────────────────────────────────────── */
+
+function whyLines(e) {
+  const out = [];
+  if (e.role === 'present') out.push(A.why.present);
+  if (e.role === 'decide') out.push(A.why.decide);
+  if (e.external) out.push(A.why.external);
+  if (e.exec) out.push(A.why.exec);
+  if (e.attendees && e.attendees >= 8) out.push(A.why.many(e.attendees));
+  if (e.routine) out.push(A.why.routine);
+  return out;
+}
+
+/** The series of a meeting: how often it met, what is to come, and the last time, folded. Null when unknown. */
+export function memoryBlock(id) {
+  const f = findEvent(id);
+  if (!f) return null;
+  const s = f.data.series[f.e.key];
+  if (!s) return null;
+  const last = s.last && s.last.date !== f.day.date ? s.last : null;
+  return el('div', { class: 'td-day__notes', 'data-ag': 'memory' },
+    el('h4', null, A.means),
+    el('p', null, A.kindWord[f.e.kind] + '. ' + (s.count > 1 ? A.series(s.past, s.coming) : A.once)),
+    ...whyLines(f.e).map((t) => el('p', null, t)),
+    last ? el('details', { class: 'td-ag__last', 'data-ag': 'last' }, el('summary', null, A.lastTime(dayLabel(last.date))),
+      last.notes ? el('p', null, last.notes) : el('p', { class: 'td-day__note' }, A.noLast),
+      last.open && last.open.length ? el('ul', { class: 'td-day__chk' }, ...last.open.map((x) => el('li', null, x))) : null) : null);
+}
+
+export function meetingDetail(ctx, id, h) {
+  const f = findEvent(id);
+  if (!f) return null;
+  const e = f.e;
+  const end = (() => { const d = new Date(e.end); return `${pad(d.getHours())}:${pad(d.getMinutes())}`; })();
+  return [
+    h.dhead(A.kindWord[e.kind], e.title),
+    el('p', { class: 'td-day__dim td-day__mono' }, `${dayLabel(f.day.date)} · ${e.time}–${end}${e.attendees ? ' · ' + A.people(e.attendees) : ''}`),
+    memoryBlock(id),
+    e.prep ? el('div', { class: 'td-day__phase', 'data-ag': 'before' }, el('h4', null, A.before),
+      el('p', null, A.prepLine(e.prep_done || 0, e.prep.length)),
+      el('ul', { class: 'td-day__chk' }, ...e.prep.map((t, i) => el('li', { class: i < (e.prep_done || 0) ? 'td-day__ok' : '' }, t))),
+      el('p', { class: e.ready === 'risk' ? 'td-day__warn' : 'td-day__note', 'data-ag-ready': e.ready || 'ok' }, A.readyNote[e.ready || 'ok'])) : null,
+    e.ended ? el('div', { class: 'td-day__phase', 'data-ag': 'notes' }, el('h4', null, A.afterNotes),
+      e.notes ? el('p', null, e.notes) : el('p', { class: 'td-day__note' }, A.noNotesYet),
+      e.open && e.open.length ? [el('h4', null, A.openLines), el('ul', { class: 'td-day__chk' }, ...e.open.map((x) => el('li', null, x)))] : null) : null,
+  ];
+}