create-pmos 0.162.0 → 0.164.0

package/workspace/lib/routes-meeting-focus.js

@@ -0,0 +1,291 @@
+'use strict';
+/* routes-meeting-focus.js — the Meeting focus page's server side (initiative c3-meeting-focus; lib/route-modules.js).
+ *
+ *   GET  /api/meeting-focus?event=<id>&date=YYYY-MM-DD[&ws=]
+ *        → { ok, now_ms, event, brief, note, topics, current, runs, tail, captured, gist, chips, notes, asks, companion }
+ *        The meeting (the calendar read for that day), its brief (lib/calendar-layers.js briefOf), the note linked to it, the last
+ *        minutes of that note's transcript with who said them, the decisions, actions and questions so far, and the companion's state.
+ *        An unknown meeting is a 404. The read also starts the companion when lib/meeting-focus.js shouldRun says it may: the note
+ *        records, new lines arrived, 40 s passed, no run is under way, PMOS_FOCUS_AGENT is not off. The run is fire and forget.
+ *   POST /api/meeting-focus/topic { event | note, date?, action: 'set'|'add'|'park', topic }   page press; the PM's correction, appended to the state
+ *   POST /api/meeting-focus/ask   { event, note?, date?, question }                            page press; one headless read-only run with the PM's question
+ *   GET  /api/meeting-focus/ask?id=  → { ok, id, state: working | answered | failed, error? }   the answer itself comes back as a note in GET /api/meeting-focus
+ *
+ * The companion runs as origin `focus-companion:<key>` (lib/headless.js 'ask': Read, Glob and Grep only). It sends nothing to anyone and
+ * writes nothing: its answer is parsed here and appended to <runtimeDir>/focus/<note id or event id>.jsonl. Handlers are pure over
+ * (req, body, ctx): ctx = { runtimeDir, spawnSession, w, readEvents?, briefFor?, env?, now? }, so a test needs no server.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const guard = require('./pm-guard.js');
+const headless = require('./headless.js');
+const notes = require('./notes.js');
+const F = require('./meeting-focus.js');
+
+const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'focus');
+const KEY_BAD = /[^A-Za-z0-9_@.-]/g;
+const keyOf = (id) => String(id == null ? '' : id).replace(KEY_BAD, '_').slice(0, 80);
+const baseId = (id) => String(id || '').split('@')[0];
+const pad = (n) => String(n).padStart(2, '0');
+const localDay = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+function readLines(file) {
+  let raw; try { raw = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const l of raw.split('\n')) { if (!l.trim()) continue; try { out.push(JSON.parse(l)); } catch { /* a torn line */ } }
+  return out;
+}
+function append(runtimeDir, name, row) {
+  fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
+  fs.appendFileSync(path.join(dirOf(runtimeDir), name), JSON.stringify(row) + '\n');
+}
+/** The state of a meeting: the lines of its note's file and of its event's file (a topic set before the note existed), in order. */
+function linesOf(runtimeDir, keys) {
+  const all = [];
+  for (const k of [...new Set(keys.filter(Boolean))]) all.push(...readLines(path.join(dirOf(runtimeDir), k + '.jsonl')));
+  return all.map((l, i) => [l, i]).sort((a, b) => (Number(a[0].at) || 0) - (Number(b[0].at) || 0) || a[1] - b[1]).map((x) => x[0]);
+}
+
+/* ── the meeting, its note and its brief ──────────────────────────────────────────────────────────────────────────── */
+
+function findEvent(events, id, date, by) {
+  if (!id && by && by.at) {   // a meeting without a stored id: its start and title name it
+    const hit = (events || []).filter((e) => e && e.id && e.at === String(by.at) && (!by.title || e.title === String(by.title)));
+    return hit[0] || null;
+  }
+  const rows = (events || []).filter((e) => e && e.id && (String(e.id) === id || baseId(e.id) === baseId(id)));
+  const onDay = rows.filter((e) => !date || String(e.at || '').slice(0, 10) === date);
+  return onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+}
+function noteFor(runtimeDir, ev, noteId) {
+  if (noteId) { const r = notes.read(runtimeDir, String(noteId)); return r.ok ? r.note : null; }
+  const hit = notes.findByEvent(runtimeDir, { event_id: String(ev.id), start: ev.at, title: ev.title }) || notes.findByEvent(runtimeDir, { event_id: baseId(ev.id), start: ev.at, title: ev.title });
+  if (!hit) return null;
+  const r = notes.read(runtimeDir, hit.id);
+  return r.ok ? r.note : null;
+}
+
+const briefCache = new Map();   // runtimeDir|event|date → { at, brief }
+const BRIEF_MS = 60000;
+/** The brief of one meeting, as the Calendar card reads it (briefOf). Kept for a minute: the page asks every few seconds. */
+async function realBrief(ctx, ev, date) {
+  const key = ctx.runtimeDir + '|' + ev.id + '|' + date;
+  const hit = briefCache.get(key);
+  if (hit && Date.now() - hit.at < BRIEF_MS) return hit.brief;
+  let brief = null;
+  try {
+    const root = ctx.w && ctx.w.root ? path.resolve(ctx.w.root) : null;
+    const layers = require('./calendar-layers.js');
+    const views = require('./routes-calendar-views.js');
+    let inis = [];
+    if (root) { try { const facts = await require('./facts-async.js').readFactsAsync(root); inis = ((facts && facts.inis) || []).filter((i) => i && i.id).map((i) => ({ id: i.id, title: i.title || i.id, status: null })); } catch { inis = []; } }
+    const src = root ? views.readers(root, ctx.runtimeDir).readContextSources() : { notes: [], planItems: [], ownItems: [] };
+    const mine = (src.notes || []).filter((n) => n.meeting && (n.meeting.event_id === ev.id || n.meeting.event_id === baseId(ev.id)));
+    let links = null; try { links = require('./calendar-links.js').read(ctx.runtimeDir); } catch { links = null; }
+    let boards = null; try { boards = require('./routes-boards.js').meetingBoards(ctx); } catch { boards = null; }
+    brief = layers.briefOf(ev, mine, src, { today: localDay(Date.now()), inis, links, boards }).brief || null;
+  } catch { brief = null; }
+  briefCache.set(key, { at: Date.now(), brief });
+  return brief;
+}
+
+const kindOk = () => headless.kindFor({ agent: 'claude', origin: 'focus-companion:x' }) === 'ask';
+const spawnable = (ctx) => typeof ctx.spawnSession === 'function' && kindOk();
+
+/* ── the companion run ────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function settleRun(ctx, key, done, now) {
+  const at = typeof now === 'function' ? now() : Date.now();
+  const res = done && done.result;
+  if (done && done.stopped) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The run was stopped before it answered.' });
+  if (done && done.timedOut) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion took too long and was stopped.' });
+  if (!res || !res.ok || res.isError) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion did not answer (' + ((done && done.note) || 'no result') + ').' });
+  const parsed = F.parseCompanion(res.text);
+  // a malformed answer is dropped, not shown
+  if (!parsed) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion answered in a form PMOS could not read, so nothing was shown.' });
+  return append(ctx.runtimeDir, key + '.jsonl', F.outLine(parsed, at));
+}
+
+function inputFor(ctx, ev, brief, note, state, topics, question) {
+  const now = ctx.nowMs;
+  const names = new Map(state.topics.map((t) => [t.id, t.text]));
+  return { event: ev, brief: brief || {}, topics: state.topics.length ? state.topics : topics, current: state.current ? names.get(state.current) : null,
+    tail: note ? F.tailOf(note, { now }) : [], earlier: state.notes, question: question || null, now };
+}
+
+function startRun(ctx, key, ev, brief, note, state, topics, now) {
+  const origin = 'focus-companion:' + key;
+  const lines = note ? (note.transcript || []).length : 0;
+  append(ctx.runtimeDir, key + '.jsonl', { k: 'run', at: now, lines });
+  const prompt = F.companionPrompt(inputFor({ ...ctx, nowMs: now }, ev, brief, note, state, topics, null));
+  let s = null;
+  try {
+    s = ctx.spawnSession({ name: 'focus: companion', agent: 'claude', ws: ctx.w ? ctx.w.id : undefined, origin, initialInput: prompt,
+      onDone: (done) => settleRun(ctx, key, done, ctx.now) });
+  } catch (e) { s = null; }
+  if (!s || s.state === 'exited') append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at: now, error: 'The companion could not start: ' + ((s && s.note) || 'no session') + '.' });
+}
+
+/* ── GET /api/meeting-focus ───────────────────────────────────────────────────────────────────────────────────────── */
+
+async function read(q, ctx) {
+  const id = String((q && q.event) || '');
+  const by = q && q.at ? { at: String(q.at).slice(0, 40), title: String(q.title || '').slice(0, 200) } : null;
+  if ((!id && !by) || id.length > 120) return fail(400, 'event is required');
+  const date = q && q.date ? String(q.date) : '';
+  if (date && !DAY.test(date)) return fail(400, 'date must be YYYY-MM-DD');
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir, { now: nowMs }); } catch { events = []; }
+  const ev = findEvent(events, id, date, by);
+  if (!ev) return fail(404, 'no such meeting on the calendar');
+  const day = date || String(ev.at || '').slice(0, 10);
+  const brief = typeof ctx.briefFor === 'function' ? await ctx.briefFor(ev, day) : await realBrief(ctx, ev, day);
+  const note = noteFor(ctx.runtimeDir, ev, q && q.note);
+  const startMs = Date.parse(ev.at);
+  const topics = F.topicsFrom(ev, brief);
+  const keys = [keyOf(ev.id), note ? keyOf(note.id) : null];
+  const key = note ? keyOf(note.id) : keyOf(ev.id);
+  const state = F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs });
+  const env = ctx.env || process.env;
+  const call = F.shouldRun(nowMs, state, note ? { state: note.state, lines: (note.transcript || []).length } : null, { env, timeoutMs: headless.timeoutMs(env) });
+  let started = false;
+  if (call.run && spawnable(ctx)) { startRun(ctx, key, ev, brief, note, state, topics, nowMs); started = true; }
+  const fresh = started ? F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs }) : state;
+  const links = [];
+  const seen = new Set();
+  for (const l of [...(Array.isArray(ev.links) ? ev.links : []), ...((brief && brief.links) || []), ...(((brief && brief.refs) || []).filter((r) => r.link).map((r) => ({ label: r.label, url: r.link })))]) {
+    const url = l && typeof l.url === 'string' && /^https?:\/\//i.test(l.url) ? l.url : ''; if (!url || seen.has(url)) continue;
+    seen.add(url); links.push({ label: F.str(l.label, 120) || url, url });
+  }
+  const sessions = note && Array.isArray(note.sessions) && note.sessions.length ? note.sessions : [];
+  return { status: 200, body: {
+    ok: true, now_ms: nowMs, date: day,
+    event: { id: ev.id, title: ev.title, at: ev.at, end: ev.end, attendees: [].concat(ev.attendees || ev.people || []).map((p) => (p && typeof p === 'object' ? p.name || p.id : p)).filter(Boolean).map(String),
+      initiative: ev.initiative || null, purpose: ev.purpose || (brief && brief.purpose) || null, links },
+    brief: brief || null,
+    note: note ? { id: note.id, title: note.title || ev.title, state: note.state, recorded_from: note.recorded_from || null, lines: (note.transcript || []).length, sessions } : null,
+    topics: fresh.topics, current: fresh.current, runs: fresh.runs,
+    tail: note ? F.tailOf(note, { now: nowMs }) : [], captured: F.capturedFrom(note),
+    gist: fresh.gist, chips: fresh.chips, notes: fresh.notes, asks: fresh.asks,
+    companion: { on: !F.off(env) && kindOk() && typeof ctx.spawnSession === 'function', running: !!fresh.pending, started, reason: call.reason, last_run_at: fresh.last_run_at || null, error: fresh.error },
+  } };
+}
+
+/* ── POST /api/meeting-focus/topic ────────────────────────────────────────────────────────────────────────────────── */
+
+async function topic(req, body, ctx) {
+  const g = guard.requirePagePress(req, body); if (!g.ok) return fail(g.status, g.error);
+  const action = String(body.action || '');
+  if (!['set', 'add', 'park'].includes(action)) return fail(400, 'action must be set, add or park');
+  const text = F.str(body.topic, 120);
+  if (!text) return fail(400, 'Name the topic.');
+  const key = await keyFromBody(body, ctx); if (key.error) return key.error;
+  const now = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  append(ctx.runtimeDir, key.key + '.jsonl', F.moveLine(action, text, now));
+  return { status: 200, body: { ok: true, key: key.key } };
+}
+/** The state file a body names: its note, else its event. */
+async function keyFromBody(body, ctx) {
+  if (body.note) {
+    const r = notes.read(ctx.runtimeDir, String(body.note));
+    if (!r.ok) return { error: fail(404, 'no such note') };
+    return { key: keyOf(r.note.id), note: r.note };
+  }
+  if (!body.event) return { error: fail(400, 'event or note is required') };
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir); } catch { events = []; }
+  const ev = findEvent(events, String(body.event), body.date && DAY.test(String(body.date)) ? String(body.date) : '');
+  if (!ev) return { error: fail(404, 'no such meeting on the calendar') };
+  const note = noteFor(ctx.runtimeDir, ev, null);
+  return { key: note ? keyOf(note.id) : keyOf(ev.id), note, ev };
+}
+
+/* ── Ask PMOS quietly ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const asksFile = 'asks.jsonl';
+const asksOf = (runtimeDir) => { const by = new Map(); for (const e of readLines(path.join(dirOf(runtimeDir), asksFile))) by.set(e.id, { ...(by.get(e.id) || {}), ...e }); return by; };
+
+/** What a private question's run answered → a note on the stream, or a failure the page shows. Exported so a test can settle without a process. */
+function settleAsk(ctx, a, done, nowFn) {
+  const at = typeof nowFn === 'function' ? nowFn() : Date.now();
+  const end = (row) => { append(ctx.runtimeDir, asksFile, { id: a.id, at, ...row }); return row; };
+  const bad = (error) => { append(ctx.runtimeDir, a.key + '.jsonl', { k: 'fail', id: a.id, at, error }); return end({ event: 'failed', state: 'failed', error }); };
+  if (done && done.stopped) return bad('The run was stopped before it answered.');
+  if (done && done.timedOut) return bad('The agent took too long and was stopped. Ask again with a shorter question.');
+  const res = done && done.result;
+  if (!res || !res.ok || res.isError) return bad('The agent did not answer (' + ((done && done.note) || 'no result') + ').');
+  let list = (F.parseCompanion(res.text) || { notes: [] }).notes;
+  // a plain-text answer is one Answer note; an answer that looks like broken JSON is dropped
+  if (!list.length && !/[{}]/.test(String(res.text || '')) && String(res.text || '').trim()) list = [{ cat: 'Answer', heard: '', body: F.str(res.text, 700), why: '', src: 'PMOS', show: 'now' }];
+  if (!list.length) return bad('The agent answered in a form PMOS could not read, so nothing was shown.');
+  const out = list.map((n) => ({ ...n, show: 'now', heard: n.heard || a.question }));
+  append(ctx.runtimeDir, a.key + '.jsonl', { k: 'answer', id: a.id, at, notes: out });
+  return end({ event: 'answered', state: 'answered' });
+}
+
+async function ask(req, body, ctx) {
+  const g = guard.requirePagePress(req, body); if (!g.ok) return fail(g.status, g.error);
+  const question = F.str(body.question, 1000);
+  if (!question) return fail(400, 'Type your question.');
+  if (typeof ctx.spawnSession !== 'function') return fail(409, 'this workspace cannot start sessions');
+  if (!kindOk()) return fail(409, 'Background runs are switched off here (PMOS_HEADLESS=off), so PMOS cannot answer from this page.');
+  const k = await keyFromBody({ ...body, note: body.note }, ctx); if (k.error) return k.error;
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let ev = k.ev;
+  if (!ev) {
+    let events = [];
+    try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir); } catch { events = []; }
+    ev = body.event ? findEvent(events, String(body.event), '') : null;
+    if (!ev && k.note && k.note.meeting) ev = { id: k.note.meeting.event_id || k.note.id, title: k.note.meeting.title || k.note.title, at: k.note.meeting.start, end: k.note.meeting.end };
+  }
+  if (!ev) return fail(404, 'no such meeting on the calendar');
+  const day = String(ev.at || '').slice(0, 10);
+  const brief = typeof ctx.briefFor === 'function' ? await ctx.briefFor(ev, day) : await realBrief(ctx, ev, day);
+  const topics = F.topicsFrom(ev, brief);
+  const keys = [keyOf(ev.id), k.note ? keyOf(k.note.id) : null];
+  const startMs = Date.parse(ev.at);
+  const state = F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs });
+  const a = { id: 'fa-' + crypto.randomBytes(6).toString('hex'), key: k.key, question };
+  const origin = 'focus-companion:' + k.key;
+  const prompt = F.companionPrompt(inputFor({ ...ctx, nowMs }, ev, brief, k.note, state, topics, question));
+  const s = ctx.spawnSession({ name: 'focus: ask', agent: 'claude', ws: ctx.w ? ctx.w.id : undefined, origin, initialInput: prompt, onDone: (done) => settleAsk(ctx, a, done, ctx.now) });
+  if (!s || s.state === 'exited') return fail(409, 'The agent could not start: ' + ((s && s.note) || 'no session'));
+  append(ctx.runtimeDir, k.key + '.jsonl', { k: 'ask', id: a.id, at: nowMs, question });
+  append(ctx.runtimeDir, asksFile, { event: 'asked', id: a.id, key: k.key, question, state: 'working', session: s.id, at: nowMs });
+  return { status: 200, body: { ok: true, id: a.id, state: 'working', session: s.id } };
+}
+
+function askState(q, ctx, now = typeof ctx.now === 'function' ? ctx.now() : Date.now()) {
+  const a = asksOf(ctx.runtimeDir).get(String((q && q.id) || ''));
+  if (!a) return fail(404, 'no such question');
+  const out = { ok: true, id: a.id, state: a.state, session: a.session || null };
+  if (a.state === 'failed') out.error = a.error;
+  if (a.state === 'working' && now - Number(a.at || 0) > headless.timeoutMs() + 120000) { out.state = 'failed'; out.error = 'The run ended without an answer. Ask again.'; }
+  return { status: 200, body: out };
+}
+
+const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true; };
+
+module.exports = {
+  prefixes: ['/api/meeting-focus'],
+  read, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf,
+  handle: async (req, res, url, ctx) => {
+    const p = url.pathname;
+    const wsId = url.searchParams.get('ws');
+    const w = ctx.getWs ? ctx.getWs(wsId) : null;
+    const base = { runtimeDir: ctx.runtimeDir, spawnSession: ctx.spawnSession, w, getWs: ctx.getWs, json: ctx.json };
+    if (req.method === 'GET' && p === '/api/meeting-focus') return respond(ctx, res, await read(Object.fromEntries(url.searchParams), base));
+    if (req.method === 'GET' && p === '/api/meeting-focus/ask') return respond(ctx, res, askState(Object.fromEntries(url.searchParams), base));
+    const fn = req.method === 'POST' && { '/api/meeting-focus/topic': topic, '/api/meeting-focus/ask': ask }[p];
+    if (!fn) return false;
+    const got = await ctx.readJson(req);
+    if (!got.ok) return respond(ctx, res, fail(400, 'invalid JSON body'));
+    const body = got.body || {};
+    const bw = body.ws && ctx.getWs ? ctx.getWs(body.ws) : w;
+    return respond(ctx, res, await fn(req, body, { ...base, w: bw }));
+  },
+};

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.162.0",
+  "version": "0.164.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-calendar.js

@@ -568,6 +568,11 @@ function detail(ui) {
     el('p', { class: 'dim cal3-note' }, 'Select a meeting to see what came out of it or what to prepare. Select a dated marker to see its date and open its home.')]);
 }
 
+/** The Meeting focus page (initiative c3-meeting-focus): one calm full-screen page for a meeting that is today. It loads when pressed. */
+const focusBtn = (e, date) => button({ label: [c3ic('target', 'sm'), 'Focus'], variant: 'primary', size: 'sm',
+  attrs: { 'data-cal3': 'focus', title: 'Open the meeting focus page: the clock, the topics, the material and PMOS beside the conversation' },
+  onClick: () => { import('./c3-focus.js').then((m) => m.openFocus({ event: e, date })).catch(() => toast({ text: 'The focus page could not load.', tone: 'error' })); } });
+
 function meetingDetail(ui, hit) {
   const { M, h } = ui; const e = hit.e;
   const s = h.timeOf(e.at); const f = s === null ? null : h.endH(e);
@@ -595,7 +600,8 @@ function meetingDetail(ui, hit) {
   const iniStatus = b && b.initiative && b.initiative.id === iniId ? b.initiative.status : (((ui.d.gantt || []).find((g) => g.id === iniId) || {}).status || null);
   const sources = b && b.sources && b.sources.length ? 'Put together from ' + listWords(b.sources) + '. Each line opens its source. ' : '';
   return [
-    el('div', { class: 'cal3-dt' }, el('h3', null, c3ic('cal'), 'Meeting'), el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'), closeBtn(ui)),
+    el('div', { class: 'cal3-dt' }, el('h3', null, c3ic('cal'), 'Meeting'), el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'),
+      !past && s !== null && hit.date === ui.d.today ? focusBtn(e, hit.date) : null, closeBtn(ui)),
     el('b', { class: 'cal3-title' }, e.title || e.id),
     el('div', { class: 'dim mono cal3-when' }, h.dayLabel(hit.date) + (s === null ? ', all day' : ' · ' + h.hhmm(s) + ' to ' + h.hhmm(f))),
     el('div', { class: 'chips2', 'data-cal3': 'meeting-chips' }, homeChip('Calendar'), ...peopleOf(e).map((n) => el('span', { class: 'tag', 'data-cal3': 'person' }, n)),

package/workspace/public/pm/c3-demo-focus.js

@@ -0,0 +1,133 @@
+/* pm/c3-demo-focus.js — DEMO answers for the Meeting focus page (initiative c3-meeting-focus) on /c3.html?demo=1.
+ * c3-demo.js passes GET /api/meeting-focus, GET /api/meeting-focus/ask and the two POSTs (topic, ask) here. The content is the approved
+ * mockup's (version 7): the Partner API rate-limit review at 18:24 in, with its six topics (one added from the talk), the gist and its four
+ * context chips, the room's last lines, three PMOS notes and two it is holding, the captured items and a Google Slides deck.
+ * Whatever meeting the page asks for, the demo answers with this one. A correction (set, add, park) and a question change the answer
+ * for the rest of the page's life; nothing is saved and nothing reaches the server. Real mode never loads this file. */
+
+const DAY = '2026-10-08';
+const at = (hm) => Date.parse(DAY + 'T' + hm + ':00');
+const START = at('11:00');
+const NOW = at('11:18') + 24000;
+const min = (ms) => Math.round(((ms - START) / 60000) * 10) / 10;
+
+const EVENT = {
+  id: 'e2@' + DAY, title: 'Partner API rate-limit review', at: DAY + 'T11:00:00', end: DAY + 'T12:00:00',
+  attendees: ['Ana Putri', 'Chen Wei', 'Lina Kusuma', 'You'], initiative: 'IDPF-07',
+  purpose: 'Choose how the Partner API protects itself from bursts: soft or hard limits.',
+  links: [
+    { label: 'Rate limits for the Partner API', url: 'docs.google.com/presentation/d/1RateLimitsPartnerApiDemo/edit' },
+    { label: 'Partner API rate limits: options paper', url: 'pmos-demo.atlassian.net/wiki/spaces/IDPF/pages/7/Partner+API+rate+limits+options+paper' },
+  ],
+};
+const BRIEF = {
+  initiative: { id: 'IDPF-07', title: 'Partner API rate limits', status: 'on track' },
+  gist: ['For Partner API rate limits, which is on track.', 'The decision to choose the rate-limit approach is due today.'],
+  matters: [{ tone: 'bad', tag: 'Due today', text: 'Choose the rate-limit approach before the 11:00 review', meta: 'Partner API working group', ref: { type: 'decision', id: 'd2' } }],
+  last: { id: 'n-demo-last', title: 'Partner API rate-limit review', at: '2026-10-08T11:00:00', private: false, overview: 'On 8 Oct Chen promised the p99 numbers per partner.',
+    decisions: [], actions: [{ text: 'Send per-partner numbers to Lina', owner: 'Chen Wei', due: 'Tue 13 Oct' }] },
+  earlier: 1, purpose: EVENT.purpose, prep: 'Your one-pager is still open.', links: EVENT.links, refs: [], sources: ['the calendar', 'the IDPF-07 plan'],
+};
+
+/* the topics, in the order the page shows them: id, text, where it came from, when it came up and who raised it */
+const BASE = [
+  { id: 'context-and-goal', text: 'Context and goal', src: 'steps' },
+  { id: 'options-soft-vs-hard-limits', text: 'Options: soft vs hard limits', src: 'steps' },
+  { id: 'a-temporary-higher-tier-during-the-grace-window', text: 'A temporary higher tier during the grace window', src: 'added', at: at('11:15'), by: 'Lina' },
+  { id: 'partner-impact-top-20-traffic', text: 'Partner impact: top 20 traffic', src: 'steps' },
+  { id: 'partner-comms-and-timing', text: 'Partner comms and timing', src: 'steps' },
+  { id: 'decide-and-next-steps', text: 'Decide and next steps', src: 'steps' },
+];
+const ids = BASE.map((t) => t.id);
+/* the stretches of talk: topic id, from, to (null while open), in epoch ms */
+const fresh = () => ({
+  topics: BASE.map((t) => ({ ...t })), parked: new Set(), current: ids[1],
+  runs: [[ids[0], at('11:00'), at('11:07')], [ids[1], at('11:07'), at('11:15')], [ids[2], at('11:15'), at('11:17')], [ids[1], at('11:17'), null]],
+  asks: [], extra: [], seq: 0,
+});
+let S = fresh();
+
+const NOTES = [
+  { id: 'n0', at: at('11:15'), cat: 'Topics', heard: '"Could they buy a higher tier just for the grace window?" Lina, 11:15', body: 'Added to Topics: A temporary higher tier during the grace window. The room came back to your options at 11:17.',
+    why: 'A new thread came up. I added it to Topics so it is not lost.', src: 'what was said since 11:15', show: 'now' },
+  { id: 'n1', at: at('11:16'), cat: 'Fact check', heard: '"Are we even allowed to throttle them?" Ana, 11:16', body: 'Yes. The partner agreement v3, section 4.2, allows throttling with 30 days written notice.',
+    why: 'You answered from memory. This is the clause, in case anyone asks for it.', src: 'Partner agreement v3 (Drive)', show: 'now',
+    acts: [{ label: 'Open section 4.2', url: 'drive.google.com/file/d/1PartnerAgreementV3Demo/view' }] },
+  { id: 'n2', at: at('11:18'), cat: 'Answer', heard: '"How many partners would hit a hard limit today?" Lina, 11:17', body: '3 of the top 20 partners went over 1,000 req/s last week: Tokopay (2,400 peak), Kirimin (1,600) and Bayarku (1,100).',
+    why: 'Lina asked the room and nobody had the number. You will want it before you reply.', src: "Chen's traffic analysis, page 3", show: 'now',
+    acts: [{ label: 'Open the analysis', ref: { type: 'report', id: 'p6' } }] },
+  { id: 'n3', at: at('11:18'), cat: 'Decision', heard: '', body: 'Ana and Chen lean to soft limits now, then hard limits after 30 days. That is your recommendation on slide 7.',
+    why: '', src: 'what was said since 11:12', show: 'hold', when: 'when the room gets to the decision' },
+  { id: 'n4', at: at('11:18'), cat: 'Time', heard: '', body: "41 min left and 3 topics have not come up: partner impact, partner comms, and the decision. Lina's question already pulled in Chen's numbers, so partner impact can be short.",
+    why: '', src: 'the topics and the time left', show: 'hold', when: 'if 2 topics are left with under 15 min' },
+];
+const CHIPS = [
+  { label: 'Tokopay, Kirimin, Bayarku', sub: 'partners over the limit',
+    detail: 'Tokopay peaked at 2,400 req/s (Standard plan, account owner Lina Kusuma). Kirimin peaked at 1,600 req/s (Standard, Lina Kusuma). Bayarku peaked at 1,100 req/s (Plus, Eko Prasetyo).', from: "Chen's traffic analysis, page 3, and the partner list in the CRM" },
+  { label: 'Partner agreement 4.2', sub: 'allows throttling with notice',
+    detail: '4.2 Fair use. The Provider may limit request rates that exceed the published tier, after giving the Partner at least thirty (30) days written notice.', from: 'Drive: Legal / Partners / Partner agreement v3.pdf, page 6' },
+  { label: 'Option B', sub: 'slide 5 of your deck', url: 'docs.google.com/presentation/d/1RateLimitsPartnerApiDemo/edit#slide=id.p5' },
+  { label: 'Rate-limit decision', sub: 'due today', ref: { type: 'decision', id: 'd2' } },
+];
+const TAIL = [
+  ['You', '11:14', 'So Option B: hard limits, with a 30 day grace window.'], ['Lina', '11:15', 'Could they buy a higher tier just for the grace window?'],
+  ['Ana', '11:16', 'Are we even allowed to throttle them?'], ['You', '11:16', 'Yes, with notice. That is the grace window on this slide.'],
+  ['Lina', '11:17', 'How many partners would hit a hard limit today?'], ['Chen', '11:18', 'Three, I think. I can pull the exact numbers.'],
+].map(([who, hm, text]) => ({ who, at: DAY + 'T' + hm + ':00', t: at(hm) - START, text, source: who === 'You' ? 'mic' : 'meeting' }));
+
+function view() {
+  const spent = (id) => S.runs.filter((r) => r[0] === id).reduce((s, r) => s + ((r[2] == null ? NOW : r[2]) - r[1]), 0) / 60000;
+  const topics = S.topics.map((t) => ({ id: t.id, text: t.text, src: t.src, ...(t.at ? { at: t.at } : {}), ...(t.by ? { by: t.by } : {}),
+    state: S.current === t.id ? 'now' : S.parked.has(t.id) ? 'parked' : spent(t.id) > 0 ? 'discussed' : 'notyet', minutes: Math.round(spent(t.id)) }));
+  const notes = NOTES.map((n) => ({ ...n })).concat(S.extra);
+  return {
+    ok: true, now_ms: NOW, date: DAY, event: EVENT, brief: BRIEF,
+    note: { id: 'n-demo-focus', title: EVENT.title, state: 'recording', recorded_from: DAY + 'T11:00:00', lines: 42, sessions: [{ from: DAY + 'T11:00:00', to: null }] },
+    topics, current: S.current, runs: S.runs.map((r) => ({ topic: r[0], from_min: min(r[1]), to_min: r[2] == null ? null : min(r[2]) })),
+    tail: TAIL, captured: { decisions: [], actions: [{ text: 'Send per-partner numbers to Lina', owner: 'Chen Wei', due: 'Tue 13 Oct' }], questions: ['Can a partner buy a temporary higher tier during the grace window?'].map((text) => ({ text })) },
+    gist: 'The room is weighing hard limits against the 3 partners who would break today. Ana and Chen lean to soft limits first; Lina worries about telling partners.',
+    chips: CHIPS, notes, asks: S.asks.map((a) => ({ ...a })),
+    companion: { on: true, running: false, started: false, reason: 'too soon', last_run_at: NOW - 20000, error: null },
+  };
+}
+
+/** GET /api/meeting-focus and GET /api/meeting-focus/ask?id= */
+export function focusGet(path, url) {
+  if (path === '/api/meeting-focus/ask') {
+    const q = new URL(url, location.origin).searchParams;
+    const a = S.asks.find((x) => x.id === q.get('id'));
+    return a ? { ok: true, id: a.id, state: 'answered' } : { ok: false, status: 404, error: 'no such question' };
+  }
+  return view();
+}
+
+/** POST /api/meeting-focus/topic and POST /api/meeting-focus/ask: they change the demo's answer and nothing else. */
+export function focusPost(path, body) {
+  let b = {};
+  try { b = body ? JSON.parse(body) : {}; } catch { b = {}; }
+  const text = String(b.topic || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+  if (path === '/api/meeting-focus/ask') {
+    const q = String(b.question || '').replace(/\s+/g, ' ').trim().slice(0, 1000);
+    if (!q) return { ok: false, error: 'Type your question.' };
+    const id = 'fa-demo' + (++S.seq);
+    S.asks.push({ id, at: NOW, question: q, state: 'answered' });
+    S.extra.push({ id: 'na' + S.seq, at: NOW, cat: 'Answer', heard: q, body: 'IDPF-07 has 3 open risks. The newest is partner comms, flagged by Lina on Thu 8 Oct.', why: 'You asked.', src: 'IDPF-07 risks', show: 'now', ask: id });
+    return { ok: true, id, state: 'working' };
+  }
+  if (path !== '/api/meeting-focus/topic') return { ok: true };
+  if (!text) return { ok: false, error: 'Name the topic.' };
+  const key = text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 60);
+  let row = S.topics.find((t) => t.id === key || t.text.toLowerCase() === text.toLowerCase());
+  if (!row) { row = { id: key, text, src: 'pm', at: NOW, by: 'you' }; S.topics.push(row); }
+  const closeOpen = () => { const r = S.runs.find((x) => x[2] == null); if (r) r[2] = NOW; };
+  if (b.action === 'set') { closeOpen(); S.parked.delete(row.id); S.current = row.id; S.runs.push([row.id, NOW, null]); }
+  else if (b.action === 'park') {
+    S.parked.add(row.id);
+    if (S.current === row.id) {
+      closeOpen(); S.current = null;
+      const next = S.topics.find((t) => t.id !== row.id && !S.parked.has(t.id) && !S.runs.some((r) => r[0] === t.id));
+      if (next) { S.current = next.id; S.runs.push([next.id, NOW, null]); }
+    }
+  }
+  return { ok: true };
+}

package/workspace/public/pm/c3-demo.js

@@ -11,6 +11,7 @@
 import { el } from './dom.js';
 import * as D from './c3-demo-data.js';
 import { installInit } from './c3-demo-init.js';
+import { focusGet, focusPost } from './c3-demo-focus.js';   // Meeting focus: the mockup's Partner API review (GET /api/meeting-focus, its ask poll, and the topic and ask POSTs)
 import { installBoards } from './c3-demo-boards.js';   // Initiatives boards: answers every /api/boards GET and POST (installed outermost, in installDemo)
 import './c3-demo-cal-ix.js';   // Calendar and the ribbon: sets window.__c3calix (calendar-views.js reads it in demo only)
 import './c3-demo-cal3.js';   // Calendar Quarter and Year: answers GET /api/c3-strategy (chained under this file's fetch wrapper)
@@ -51,6 +52,7 @@ function getRoute(path, url) {
   switch (path) {
     case '/api/briefing': return D.briefing(url);
     case '/api/calendar-views': return withCalendarPage(D.calendarViews(url));
+    case '/api/meeting-focus': case '/api/meeting-focus/ask': return focusGet(path, url);
     case '/api/pm-items': return D.pmItems();
     case '/api/runs': return D.runs();
     case '/api/releases': return D.releases();
@@ -74,6 +76,7 @@ function getRoute(path, url) {
 function postRoute(path, body) {
   let b = {};
   try { b = body ? JSON.parse(body) : {}; } catch { b = {}; }
+  if (path.startsWith('/api/meeting-focus/')) return focusPost(path, body);
   if (path === '/api/pm-items/add') return { ok: true, item: { id: 'item-demo-new' + (++added), title: String(b.line || '').trim() || 'New item', due: null, priority: null, waiting_on: null, job: null, steps: [], created_at: D.NOW_ISO + 'Z' } };
   if (path === '/api/pm-items/remove') return { ok: true, undo_ms: 8000 };
   if (path === '/api/calendar-links') return (window.__c3links = (window.__c3links || []).concat([b])), { ok: true, link: b.kind === 'none' ? null : { kind: b.kind, ws: b.ws || null, board: b.board || null, initiative: b.initiative || null, title: b.title || null, by: 'pm:wawan' } };   // nothing is saved