create-pmos 0.129.0 → 0.131.0

package/workspace/lib/work-focus.js

@@ -0,0 +1,106 @@
+'use strict';
+/* work-focus.js — Focus on the Work page: up to three jobs PMOS suggests for today (console3 PRD R4).
+ *
+ * Rules first, no model call. Pure functions; the route layer reads and writes focus.jsonl.
+ *
+ * focusSuggestions(workToday, jobs, state, todayIso)
+ *   Groups the Today items by their job (an item with no job is its own group, key 'item:<id>'; a job group's key
+ *   is 'job:<jobId>'), scores each group, and returns the best three as { key, title, why, item_ids, job }.
+ *   Score per item: overdue 3 per day (at most 9), due today 2, flagged 2, P1 2, offline 1. A group scores the
+ *   sum of its items. A key the PM accepted or dismissed today is not suggested again.
+ *
+ * foldFocus(lines, todayIso)
+ *   The focus.jsonl events 'accepted', 'dismissed' and 'cleared' carry `day` (YYYY-MM-DD, set by the route from the
+ *   server date). Only today's events count, so Focus starts empty each day. Returns { accepted, dismissed }.
+ */
+const MAX_SUGGESTIONS = 3;
+const DAY_MS = 86400000;
+
+const dayNumber = (isoDay) => Math.floor(Date.parse(`${isoDay}T00:00:00Z`) / DAY_MS);
+
+function parts(item, todayIso) {
+  const overdueDays = item.due && item.due < todayIso ? dayNumber(todayIso) - dayNumber(item.due) : 0;
+  return {
+    overdueDays,
+    dueToday: item.due === todayIso,
+    flagged: item.flagged === true,
+    p1: item.priority === 'P1',
+    offline: item.kind === 'offline',
+  };
+}
+
+function itemScore(p) {
+  return Math.min(p.overdueDays * 3, 9) + (p.dueToday ? 2 : 0) + (p.flagged ? 2 : 0) + (p.p1 ? 2 : 0) + (p.offline ? 1 : 0);
+}
+
+// Plain words, no dashes: "2 items overdue, 1 flagged".
+function whyText(list) {
+  const n = (f) => list.filter(f).length;
+  const overdue = n((p) => p.overdueDays > 0);
+  const bits = [];
+  if (overdue) bits.push(`${overdue} ${overdue === 1 ? 'item' : 'items'} overdue`);
+  if (n((p) => p.dueToday)) bits.push(`${n((p) => p.dueToday)} due today`);
+  if (n((p) => p.flagged)) bits.push(`${n((p) => p.flagged)} flagged`);
+  if (n((p) => p.p1)) bits.push(`${n((p) => p.p1)} at P1`);
+  if (n((p) => p.offline)) bits.push(`${n((p) => p.offline)} outside PMOS`);
+  return bits.length ? bits.join(', ') : 'Planned for today';
+}
+
+function jobTitle(job) {
+  const t = job && (job.want || job.when || job.so);
+  return t ? String(t).trim() : 'A standing job';
+}
+
+function focusSuggestions(workToday, jobs, state, todayIso) {
+  const blocked = new Set([...(state && state.accepted ? state.accepted.map((a) => a.key) : []), ...(state && state.dismissed ? state.dismissed : [])]);
+  const jobById = new Map((jobs || []).map((j) => [j.id, j]));
+  const groups = new Map();
+  for (const item of workToday || []) {
+    const job = item.job && jobById.has(item.job) ? item.job : null;
+    const key = job ? `job:${job}` : `item:${item.id}`;
+    if (!groups.has(key)) groups.set(key, { key, job, members: [] });
+    const p = parts(item, todayIso);
+    groups.get(key).members.push({ item, p, score: itemScore(p) });
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    if (blocked.has(g.key)) continue;
+    g.members.sort((a, b) => b.score - a.score);
+    out.push({
+      key: g.key,
+      score: g.members.reduce((sum, m) => sum + m.score, 0),
+      earliest: g.members.map((m) => m.item.due || '9999').sort()[0],
+      suggestion: {
+        key: g.key,
+        title: g.job ? jobTitle(jobById.get(g.job)) : g.members[0].item.title,
+        why: whyText(g.members.map((m) => m.p)),
+        item_ids: g.members.map((m) => m.item.id),
+        job: g.job,
+      },
+    });
+  }
+  const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+  out.sort((a, b) => b.score - a.score || cmp(a.earliest, b.earliest) || cmp(a.key, b.key));
+  return out.slice(0, MAX_SUGGESTIONS).map((o) => o.suggestion);
+}
+
+function foldFocus(lines, todayIso) {
+  const accepted = new Map();
+  const dismissed = new Set();
+  for (const ev of lines || []) {
+    if (!ev || !ev.key || ev.day !== todayIso) continue;
+    if (ev.event === 'accepted') {
+      dismissed.delete(ev.key);
+      accepted.set(ev.key, { key: ev.key, title: ev.title, why: ev.why, item_ids: ev.item_ids || [], job: ev.job || null });
+    } else if (ev.event === 'dismissed') {
+      accepted.delete(ev.key);
+      dismissed.add(ev.key);
+    } else if (ev.event === 'cleared') {
+      accepted.delete(ev.key);
+      dismissed.delete(ev.key);
+    }
+  }
+  return { accepted: [...accepted.values()], dismissed };
+}
+
+module.exports = { MAX_SUGGESTIONS, focusSuggestions, foldFocus };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.129.0",
+  "version": "0.131.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.129.0",
+      "version": "0.131.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.129.0",
+  "version": "0.131.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/c3-brief-data.js

@@ -0,0 +1,11 @@
+/* pm/c3-brief-data.js — the one read behind the Briefing's Today agenda and the own-item rows of Needs you: GET /api/brief-page
+ * (lib/routes-brief-page.js). Both sections subscribe; one request answers both. A failed read is kept as { ok:false, error } so each
+ * section can say so; nothing here invents a row. */
+import { pmGet } from './http.js';
+
+let cache = null; const subs = new Set();
+export function onBriefPage(fn) { subs.add(fn); if (cache) fn(cache); return () => subs.delete(fn); }
+export function loadBriefPage() {
+  return pmGet('/api/brief-page').then((j) => (j && j.ok !== false ? j : { ok: false, error: (j && j.error) || 'unreadable' }), (e) => ({ ok: false, error: String((e && e.message) || e) }))
+    .then((j) => { cache = j; subs.forEach((f) => f(j)); return j; });
+}

package/workspace/public/pm/c3-brief-needs.js

@@ -0,0 +1,145 @@
+/* pm/c3-brief-needs.js — the Briefing's "Needs you" (PRD briefing-brief R3, R4, R6).
+ *   needsSection(S)   the section: own items first (overdue, most late first; then due today; then outside PMOS), then the decisions only the PM
+ *                     can make (the briefing's needs in the demo, the engine cards that carry a move or are Critical in real mode: c3-brief.js needRow).
+ *   itemRow(row, ctx) a row of an own item. It opens in place (c3-expand). Its actions write to the item's home record, through the pm-items routes:
+ *                       Done        POST /api/pm-items/done   { id, outcome? }
+ *                       Not yet     POST /api/pm-items/notyet { id, when: 'later-today' | 'tomorrow' | 'next-week' }   the item returns on that date
+ *                       Drop        POST /api/pm-items/remove { id }   (Undo: POST /api/pm-items/undo)
+ *                     An outside-PMOS item (talk to, meet, call, ask) takes an optional one-line outcome. When PMOS holds evidence ("a meeting with Ana is
+ *                     booked Tue 10:00") it asks "Looks done: ... Confirm?". It never marks the item done itself: only a press on Done or Confirm does.
+ * The own-item rows are built again only when their keys change, so a re-read does not close an open row. An open row is kept in BX.open. */
+import { el } from './dom.js';
+import { c3ic } from './pm-work-view.js';
+import { pmPost } from './http.js';
+import { makeXp, attachExpand } from './c3-expand.js';
+import { needRow, belowLine, BX, toast } from './c3-brief.js';
+import { onBriefing, loadBriefing } from './shell-ticker.js';
+import { cardView, TAG_STYLE } from './briefing-model.js';
+import { onBriefPage } from './c3-brief-data.js';
+import { button, ensureComponentsCss } from './primitives.js';
+
+const reduced = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+const post = (path, body) => pmPost(path, body).catch(() => ({ ok: false }));
+export const WHEN = [['later-today', 'Later today'], ['tomorrow', 'Tomorrow'], ['next-week', 'Next week']];
+const WHEN_TOAST = { 'later-today': 'Back later today', tomorrow: 'Back tomorrow', 'next-week': 'Back next week' };
+
+function leave(row, then) {
+  if (reduced()) { then(); return; }
+  row.classList.add('leave'); setTimeout(then, 340);
+}
+
+export function itemRow(r, ctx = {}) {
+  const key = r.key; const offline = !!r.offline;
+  const tone = r.kind === 'overdue' ? 't-bad' : offline ? 't-ink' : 't-warn';
+  ensureComponentsCss();
+  const late = r.days_late > 0 ? (r.days_late === 1 ? '1 day late' : r.days_late + ' days late') : null;
+  let row = null; let busy = false;
+  const out = el('input', { type: 'text', class: 'ioutcome', 'data-outcome': '', maxlength: '160', placeholder: offline ? 'What happened? One line, optional' : 'Note, optional', 'aria-label': 'Outcome, optional' });
+
+  const write = (call, okText, undo) => {
+    if (busy) return; busy = true;
+    call().then((res) => {
+      busy = false;
+      if (!res || res.ok === false) { toast('That did not go through' + (res && res.error ? ': ' + res.error : '.')); return; }
+      BX.open.delete(key);
+      leave(row, () => { row.remove(); if (ctx.changed) ctx.changed(); });
+      toast(okText, undo ? () => { post(undo.path, undo.body).then(() => { if (ctx.reload) ctx.reload(); }); } : undefined);
+    });
+  };
+  const done = (why) => {
+    const o = out.value.trim() || why || '';
+    write(() => post('/api/pm-items/done', { id: r.id, ...(o ? { outcome: o } : {}) }), 'Marked done', { path: '/api/pm-items/reopen', body: { id: r.id } });
+  };
+  const notYet = (when) => write(() => post('/api/pm-items/notyet', { id: r.id, when }), WHEN_TOAST[when]);
+  const drop = () => write(() => post('/api/pm-items/remove', { id: r.id }), 'Dropped', { path: '/api/pm-items/undo', body: { id: r.id } });
+
+  const btn = (label, act, fn, extra) => button({ label, onClick: (e) => { e.stopPropagation(); fn(); }, attrs: { 'data-act': act, ...(extra || {}) } });
+  const panel = el('div', { class: 'ip', 'data-item-panel': r.id },
+    r.evidence ? el('div', { class: 'looks', 'data-evidence': '', role: 'note' }, c3ic('eye', 'sm'), el('span', null, 'Looks done: ' + r.evidence.text + '. Confirm?'),
+      btn('Yes, it is done', 'confirm', () => done('Confirmed: ' + r.evidence.text))) : null,
+    out,
+    el('div', { class: 'iacts' },
+      btn('Done', 'done', () => done('')),
+      el('span', { class: 'ny', role: 'group', 'aria-label': 'Not yet: ask again' }, el('span', { class: 'dim c3s2' }, 'Not yet, ask again:'),
+        ...WHEN.map(([w, l]) => btn(l, 'notyet', () => notYet(w), { 'data-when': w }))),
+      btn('Drop', 'drop', drop)));
+  const xp = makeXp(panel);
+  const chips = [late ? el('span', { class: 'st warn', 'data-late': String(r.days_late) }, c3ic('clock', 'sm'), late) : null,
+    r.kind === 'due-today' ? el('span', { class: 'chip2' }, c3ic('clock', 'sm'), 'Due today') : null,
+    offline ? el('span', { class: 'tag', 'data-offline': '' }, 'Outside PMOS') : el('span', { class: 'tag' }, 'Yours'),
+    r.person ? el('span', { class: 'chip2' }, c3ic('user', 'sm'), r.person) : null,
+    r.priority ? el('span', { class: 'fl ' + String(r.priority).toLowerCase() }, r.priority) : null,
+    r.evidence ? el('span', { class: 'st ok', 'data-looks-done': '' }, c3ic('eye', 'sm'), 'Looks done') : null];
+  row = el('li', { class: 'nrow', 'data-row': '', 'data-id': key, 'data-needs-row': key, 'data-item-id': r.id, 'data-ref-row': r.id, 'data-kind': r.kind, 'data-a': 'expand' },
+    el('span', { class: 'ki ' + tone + (r.kind === 'overdue' ? ' hot' : ''), title: r.kind }, c3ic(r.kind === 'overdue' ? 'alert' : offline ? 'user' : 'clock')),
+    el('div', { class: 'nb' }, el('span', { class: 'tt' }, r.headline), el('div', { class: 'chips' }, ...chips.filter(Boolean)), xp));
+  attachExpand(row, xp, { key: 'item-' + key, initial: BX.open.has(key), onToggle: (on) => { if (on) BX.open.add(key); else BX.open.delete(key); } });
+  return row;
+}
+
+export function needsSection(S) {
+  const count = el('span', { class: 'bdg g' }, '0');
+  const quick = el('span', { class: 'chips2 dim mono c3s2' });
+  const own = el('ul', { class: 'list', role: 'list', 'data-needs-own': '' });
+  const ownNote = el('div');
+  const list = el('ul', { class: 'list', role: 'list' });
+  const extra = el('div');
+  const alertHost = el('div');
+  const box = el('section', { class: 'card sect', 'data-c3pg': 'needs', 'aria-label': 'Needs you' },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('inbox', 'sm'), 'Needs you ', count)), alertHost, ownNote, own, list, extra);
+  let sig = ''; let last = null; let ownSig = ''; let page = null;
+  const nothing = () => el('li', { class: 'fold' }, c3ic('check', 'sm'), 'Nothing needs you.');
+  const recount = () => {
+    const n = box.querySelectorAll('.nrow[data-needs-row]').length;
+    count.textContent = String(n);
+    const f = list.querySelector('.fold');
+    if (!n && !f) list.replaceChildren(nothing());
+    else if (n && f && list.children.length === 1 && f.textContent.startsWith('Nothing needs')) f.remove();
+  };
+  const ctx = { changed: recount };
+
+  const fillOwn = (j) => {
+    page = j;
+    if (!j || j.ok === false) { ownNote.replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status' }, 'Your own items could not be read: ' + ((j && j.error) || 'unreadable'))); return; }
+    ownNote.replaceChildren();
+    const rows = (j.needs || []).filter((r) => r.kind !== 'decision');
+    const g = JSON.stringify(rows.map((r) => [r.key, r.headline, r.days_late, !!r.evidence]));
+    if (g === ownSig) return; ownSig = g;
+    own.replaceChildren(...rows.map((r) => itemRow(r, { ...ctx, reload: () => import('./c3-brief-data.js').then((m) => m.loadBriefPage()) })));
+    recount();
+  };
+
+  const fill = (b) => {
+    last = b;
+    const inc = !!S.incident;
+    let needs = b && Array.isArray(b.needs) && b.needs.length ? b.needs.filter((n) => !BX.gone[n.key] && (!inc || n.hard)) : null;
+    const decide = ((b && b.cards) || []).filter((c) => c && (c.move || c.tag === 'Critical'));
+    const key = needs ? needs.map((n) => n.key + n.headline) : decide.map((c) => (c.key || '') + c.headline);
+    if (needs && S.pinNeed) { const at = needs.findIndex((n) => n.key === S.pinNeed); if (at > 0) needs.unshift(...needs.splice(at, 1)); }
+    const g = JSON.stringify([key, inc, !!(b && b.kept_out), S.pinNeed || '']);
+    if (g === sig) return; sig = g;
+    alertHost.replaceChildren(...(inc ? [el('div', { class: 'incident', role: 'status', 'data-c3pg': 'incident' }, c3ic('alert', 'lg'), el('div', null, el('b', null, 'Card payments failing since 07:40'), el('div', { class: 'dim c3s3' }, '12% of checkouts. Sam on call. Only deadlines shown.')))] : []));
+    if (needs) {
+      if (!quick.isConnected) box.querySelector('.sh2').append(quick);
+      quick.textContent = ''; quick.append(c3ic('bolt', 'sm'), needs.filter((n) => n.quick).length + ' under 2 min');
+      list.replaceChildren(...needs.slice(0, 5).map((n, i) => needRow(n, i, ctx)));
+      extra.replaceChildren(...(inc ? [] : belowLine(needs.slice(5), (n, i) => needRow(n, i + 5, ctx), b.kept_out)));
+      recount();
+      return;
+    }
+    const cards = decide.map(cardView);
+    quick.remove();
+    list.replaceChildren(...cards.map((v, i) => {
+      const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
+      return needRow({ key: v.key || String(i), headline: v.headline, kind: v.tag, icon: T.icon, color: T.color, time: v.deadline && v.deadline.text ? v.deadline.text : null, src: v.tag, view: v }, i, ctx);
+    }));
+    extra.replaceChildren();
+    recount();
+  };
+  S.refreshNeeds = () => { sig = ''; if (last) fill(last); };
+  S.needsFill = fill;
+  onBriefing((b) => { S.brief = b; fill(b); });
+  onBriefPage(fillOwn);
+  loadBriefing();
+  return box;
+}

package/workspace/public/pm/c3-brief-pulse.js

@@ -0,0 +1,70 @@
+/* pm/c3-brief-pulse.js — the Briefing's "Portfolio pulse" (PRD briefing-brief R5, R6).
+ * One status bar and a row per initiative (the Calendar's own gantt rows, GET /api/calendar-views quarter, c3-plan.js readQuarter; the demo's pulse rows
+ * carry their own colour and reason). A row opens in place with the case component the Needs you rows use (c3-expand + c3-case): why it is where it
+ * is, promised against forecast. A press on a row does NOT change the tab. "Open initiative" is an explicit link inside the opened row and is the only
+ * thing here that does. Rows are references (data-ref-row): nothing in them changes a record. */
+import { el } from './dom.js';
+import { c3ic } from './pm-work-view.js';
+import { makeXp, attachExpand } from './c3-expand.js';
+import { caseFile } from './c3-brief.js';
+import { readQuarter } from './c3-plan.js';
+import { row, signal, ensureComponentsCss } from './primitives.js';
+
+/* tone: ok is neutral, warn is the warning token, bad the destructive one (R28-12) */
+const PST = { 'on time': ['ok', 'On time'], 'at risk': ['warn', 'At risk'], delayed: ['bad', 'Delayed'], overdue: ['bad', 'Overdue'], 'no plan': ['', 'No plan'] };
+const RAG = { red: ['bad', 'Off track'], amber: ['warn', 'At risk'], green: ['ok', 'On track'], park: ['', 'Parked'] };
+const SIG = { bad: 'destructive', warn: 'warning' };
+const end = (o) => (o && (o.end || o.start)) || null;
+
+/** One gantt row as the pulse draws it: { id, title, cls, word, color, why, evidence }. Pure. */
+export function pulseRow(g) {
+  if (g.pulse && RAG[g.pulse.c]) {
+    const [cls, word] = RAG[g.pulse.c];
+    const ev = [];
+    if (g.promised) ev.push(['target', 'Promised ' + g.promised, 'Plan', cls === 'bad' ? 'bad' : cls === 'warn' ? 'warn' : '']);
+    return { id: g.id, title: g.title || g.id, cls, word, why: g.pulse.why, evidence: ev };
+  }
+  const k = PST[g.status] ? g.status : 'no plan'; const f = end(g.forecast); const p = g.promised || null;
+  const why = p ? 'Forecast ' + (f || 'not set') + ' vs promised ' + p : 'No promised date' + (f ? '; forecast ' + f : '');
+  const ev = [];
+  if (p) ev.push(['target', 'Promised ' + p, 'Plan']);
+  if (f) ev.push(['clock', 'Forecast ' + f, 'Plan', PST[k][0] === 'bad' ? 'bad' : PST[k][0] === 'warn' ? 'warn' : '']);
+  if (g.slip_days > 0) ev.push(['alert', 'Slipping by ' + g.slip_days + ' d', 'Plan', 'warn']);
+  return { id: g.id, title: g.title || g.id, cls: PST[k][0], word: PST[k][1] + (g.slip_days > 0 ? ' +' + g.slip_days + ' d' : ''), why, evidence: ev };
+}
+
+export function pulseCase(r) {
+  return { id: 'pulse:' + r.id, tc: r.cls === 'bad' ? 'var(--destructive)' : r.cls === 'warn' ? 'var(--warning)' : 'var(--muted-foreground)', sit: r.why, chg: r.evidence, opts: [], go: ['goinit', r.id, 'Open initiative'], cta: '' };
+}
+
+export function pulse(S) {
+  ensureComponentsCss();
+  const body = el('div', null, el('p', { class: 'dim mono c3s2' }, 'Reading the initiatives.'));
+  const box = el('section', { class: 'card pulsecard', 'data-c3pg': 'pulse' },
+    el('div', { class: 'pulsehead' },
+      el('h3', null, c3ic('init', 'sm'), 'Portfolio pulse'), el('span', { class: 'mono dim c3s2' }, 'promised vs forecast')), body);
+  const note = (t, ic) => el('div', { class: 'fold' }, c3ic(ic || 'moon', 'sm'), t);
+  const draw = (rows, err) => {
+    if (err) { body.replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status' }, 'The initiatives could not be read: ' + err)); return; }
+    if (!rows.length) { body.replaceChildren(note('No initiative has a promised date yet, so there is nothing to compare with the forecast.')); return; }
+    const noPlan = rows.filter((g) => !g.pulse && g.status === 'no plan').length;
+    rows = rows.filter((g) => g.pulse || g.status !== 'no plan');
+    if (!rows.length) { body.replaceChildren(note('No initiative has a promised date yet, so there is nothing to compare with the forecast.'), ...(noPlan ? [el('p', { class: 'dim mono c3s2' }, noPlan + ' initiatives have no plan date.')] : [])); return; }
+    const pr = rows.map(pulseRow);
+    const by = new Map(); pr.forEach((r) => { const k = r.word.replace(/ \+.*/, ''); const o = by.get(k) || { n: 0, cls: r.cls }; o.n += 1; by.set(k, o); });
+    const bar = el('div', { class: 'pbs', role: 'group', 'aria-label': 'Status of initiatives' },
+      ...[...by.entries()].map(([k, v]) => { const seg = el('span', { class: 'pb-seg pb-' + (v.cls || 'mute'), title: v.n + ' ' + k.toLowerCase(), 'aria-label': v.n + ' ' + k.toLowerCase() }); seg.style.setProperty('--fr-grow', String(v.n)); return seg; }));
+    const rowEl = (r) => {
+      const xp = makeXp(caseFile(pulseCase(r)));
+      let ex = null;
+      const head = row({ title: r.title, meta: [r.why], signals: [signal({ text: r.word, tone: SIG[r.cls] || 'muted' })], openLabel: r.title + ': ' + r.word, onOpen: () => ex.toggle(), openAttrs: { 'data-c3pg-prow': r.id } });
+      ex = attachExpand(head, xp, { key: 'pulse-' + r.id });
+      return el('div', { class: 'pwrap', 'data-ref-row': '', 'data-pulse-row': r.id }, head, xp);
+    };
+    body.replaceChildren(...[bar, el('div', null, ...pr.slice(0, 8).map(rowEl)), pr.length > 8 ? el('div', { class: 'dim mono c3s2' }, '+' + (pr.length - 8) + ' more in the Calendar tab') : null, noPlan ? el('div', { class: 'dim mono c3s2' }, noPlan + ' more have no plan date.') : null].filter(Boolean));
+  };
+  readQuarter().then((j) => {
+    if (!j || j.ok === false) draw([], (j && j.error) || 'unreadable'); else { S.today = j.today || ''; draw(j.gantt || []); }
+  }).catch((e) => draw([], String((e && e.message) || e)));
+  return box;
+}

package/workspace/public/pm/c3-brief-today.js

@@ -0,0 +1,44 @@
+/* pm/c3-brief-today.js — the Briefing's "Today": the agenda of today's meetings (PRD briefing-brief R2).
+ * One row per meeting, in time order, from GET /api/brief-page: its time and length, the people, the initiative, what PMOS holds as PREPARED
+ * (documents, notes) and what the PM must do BEFORE the meeting (own items that name it). A meeting with nothing held says "Nothing prepared
+ * yet". A meeting that is over is dimmed; the one under way is marked Now, the next one Next.
+ * Rows are REFERENCES (data-ref-row): they carry no control that changes a record. The record's actions are in Needs you and on its own page. */
+import { el } from './dom.js';
+import { c3ic } from './pm-work-view.js';
+import { onBriefPage } from './c3-brief-data.js';
+
+const p2 = (n) => String(n).padStart(2, '0');
+const hm = (iso) => { const d = new Date(iso); return p2(d.getHours()) + ':' + p2(d.getMinutes()); };
+
+export function meetingRow(m) {
+  const marks = { now: 'Now', next: 'Next' };
+  const prep = m.prepared && m.prepared.length
+    ? el('ul', { class: 'tl', role: 'list', 'aria-label': 'Prepared' }, ...m.prepared.map((x) => el('li', { 'data-prep': x.kind }, c3ic(x.kind === 'prep' ? 'spark' : 'doc', 'sm'), x.text)))
+    : el('p', { class: 'dim c3s2', 'data-prep': 'none' }, c3ic('moon', 'sm'), 'Nothing prepared yet');
+  const bef = m.before && m.before.length
+    ? el('ul', { class: 'tl', role: 'list', 'aria-label': 'Before the meeting' }, ...m.before.map((x) => el('li', { 'data-before': x.id }, c3ic('todo', 'sm'), x.title, x.due ? el('span', { class: 'mono dim' }, ' · due ' + x.due) : null)))
+    : el('p', { class: 'dim c3s2', 'data-before': 'none' }, 'Nothing to do before it.');
+  return el('li', { class: 'trow ' + m.state, 'data-ref-row': '', 'data-today-row': m.id, 'data-state': m.state },
+    el('div', { class: 'tm mono' }, hm(m.start), el('div', { class: 'dim c3s2' }, m.minutes ? m.minutes + ' min' : 'no end')),
+    el('div', { class: 'tb' },
+      el('div', { class: 'chips2' }, el('b', { class: 'tt' }, m.title), marks[m.state] ? el('span', { class: 'st ' + (m.state === 'now' ? 'ok' : ''), 'data-mark': m.state }, marks[m.state]) : null),
+      el('div', { class: 'chips2 dim c3s2' },
+        m.people && m.people.length ? el('span', { class: 'chip2', 'data-people': '' }, c3ic('user', 'sm'), m.people.join(', ')) : null,
+        m.initiative ? el('span', { class: 'chip2', 'data-init': '' }, c3ic('init', 'sm'), m.initiative) : null),
+      el('div', { class: 'tcols' }, el('div', null, el('div', { class: 'lab mono' }, 'Prepared'), prep), el('div', null, el('div', { class: 'lab mono' }, 'Before the meeting'), bef))));
+}
+
+export function todaySection() {
+  const list = el('ul', { class: 'list', role: 'list' });
+  const count = el('span', { class: 'bdg g' }, '0');
+  const box = el('section', { class: 'card sect', 'data-c3pg': 'today', 'aria-label': 'Today' },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('cal', 'sm'), 'Today ', count)), list);
+  list.replaceChildren(el('li', { class: 'fold', 'data-today-state': 'loading' }, c3ic('clock', 'sm'), 'Reading today\'s meetings.'));
+  onBriefPage((j) => {
+    if (!j || j.ok === false) { count.textContent = '0'; list.replaceChildren(el('li', { class: 'fold', role: 'status', 'data-today-state': 'error' }, c3ic('alert', 'sm'), 'Today\'s meetings could not be read: ' + ((j && j.error) || 'unreadable'))); return; }
+    const t = j.today || [];
+    count.textContent = String(t.length);
+    list.replaceChildren(...(t.length ? t.map(meetingRow) : [el('li', { class: 'fold', 'data-today-state': 'empty' }, c3ic('moon', 'sm'), 'No meetings today in the calendar PMOS holds.')]));
+  });
+  return box;
+}