create-pmos 0.241.0 → 0.242.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.241.0",
+  "version": "0.242.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@05129df
+kernel-source: pmos@f07c531
 assembled: 2026-10-14
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-14T14:33:36Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T15:23:59Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-14T14:33:36Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T15:23:59Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-14T14:33:36Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T15:23:59Z"}
 status: stable
 ---
 

package/workspace/guide/console-calendar.md

@@ -156,6 +156,20 @@ To fix the topic, press **Topics**. Press **Not this topic** and pick the topic
 
 The companion starts only while the meeting is recorded. It reads the new lines of the transcript at most every 40 seconds. It writes the sentence, the chips, the topic and the notes. If the answer is not usable, PMOS drops it and shows nothing. To stop the companion, set `PMOS_FOCUS_AGENT` to `off`. The page then shows the transcript and a quiet line, and it adds no notes. In the last 5 minutes, and after the meeting, the page shows the captured items under the material. You confirm them in the note after the meeting. Nothing goes to other people.
 
+### Meeting material
+
+Link the documents, reports and decks that you want to show or present in a meeting. The card of a meeting that has not ended has a **Material** part. It lists each linked item with its kind, the topic it is for, where it came from (the invite, the morning brief, or you), and whether it is for this meeting or for every meeting in the series. Each item has **Present** or **Open**, and a remove button (x). Items from the invite and the morning brief have no remove button. PMOS keeps your items in its own record (`meeting-material.jsonl` in the runtime folder). It does not change your calendar invite. Removing an item does not change the document.
+
+Press **Add material** to open the sheet:
+
+- **Suggested for this meeting**: the documents of the level of the meeting (the initiative it is about) and the newest reports and decks, with the reason for each.
+- **Find in PMOS**: type two letters or more to search the titles of documents and report decks.
+- **Or paste a link**: a Google Slides, Google Docs or Confluence link, or any https address. A web page opens in a new tab. PMOS does not read it.
+
+After you pick an item, choose **For** (this meeting, or every meeting in the series), **Topic** (one of the topics of the meeting, or the whole meeting) and **You** (**Present it** or **Only read it**, for a PMOS deck or a Google Slides link).
+
+In **Focus**, the material shows next to the links of the invite. An item for a topic comes up on the stage when the room is on that topic. When the room moves to another topic, the stage goes back to the first link. Press an item in the **Material** switch to keep it on the stage. A PMOS deck or report opens in PMOS. A PMOS deck has **Present**, which opens the presenter view with your speaker notes, and **Audience view**, which shows the slides only, full screen. Press it before you share your screen in the call. When nothing is linked, the Material part of Focus has **Add material**.
+
 ### Meeting focus over Google Meet
 
 The PMOS Chrome extension shows a small panel over a Google Meet call, so you do not need to switch to the PMOS tab. The panel is the Meeting focus page in a compact form. It has a head with the topic the room is on (or "Starts in" before the start) and the time left, the **What's being said** line, the conversation with PMOS, and **Ask PMOS quietly**. Only you see it. It is not part of the screen you share. The extension reads the address and the title of the Meet tab only. It does not read the call's audio or captions, and it talks only to the PMOS on your computer.

package/workspace/guide/notes.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: notes"
 description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, decisions with their why and who, next steps with an open question, a discussion paragraph, and Wispr Flow's notes merged in and fetched by hand when the fetch fails; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository for conflicts, capture highlights during the meeting, create tasks from next steps, correct and tag lines, see what changed in your notes, replay the meeting, see screenshots of the shared screen beside the transcript, link a note to its meeting and its initiative, and get a summary."
-timestamp: 2026-10-12
+timestamp: 2026-10-14
 ---
 
 # Guide: notes
@@ -201,6 +201,18 @@ The replay of a new note is kept at 24 kHz, so it keeps the high sounds of a voi
 
 The replay is your microphone and the meeting added together. When both are loud at the same moment, the workspace lowers the peaks softly, so the sound does not distort. A quiet voice is not changed. The transcript is made from each source on its own, so this does not change what is written.
 
+### The meeting replay page
+
+Press **Replay** beside the player (in Calendar › Notes, or on the meeting's card once the meeting has ended) to open the meeting replay: the whole meeting on one full-screen page, as Focus showed it, played back. Press **Stop and open the replay** in Focus to end the meeting and open it at once.
+
+- The **topic track** is the bar to scrub. Each stretch of talk is a numbered stretch of the bar. A mark above it is a decision, a question or a next step. A mark is amber when it needs you: a next step with no owner, a question still open. A small dot below it is a note PMOS made for you during the meeting.
+- **Play** or **Pause**, **Back 10 s**, and **1×**, **1.5×** or **2×** set how it plays. A press on a stretch, a mark, a key point, a topic, a screen shot or a line plays from there.
+- The **stage** shows the screen shot that was on screen at the playing time. Press it to see it large. A shot that looked like another app was set aside: it is not in the replay, and **N set aside** opens them so you can keep or delete each one.
+- **Key points** lists the decisions, next steps and questions with the time each was said. A key point whose line is not found has no time and no play button. **Confirm all** makes a task of each next step on the note's initiative.
+- **Topics** shows the minutes each topic took and the first time it came up. **Conversation** shows the lines and PMOS's notes in time order. The line being played is marked and kept in view. Choose **All**, **Key points** or **PMOS**, or search for a word.
+
+The page reads only records on this machine: the note, the file Focus kept for the meeting, and the screen shots.
+
 ### Clean up the replay sound
 
 The replay can play a cleaned copy of the sound. The copy has less rumble and hiss, and an even loudness. It needs **ffmpeg** on your machine. To install it, run `brew install ffmpeg` in a terminal.
@@ -226,6 +238,15 @@ When you share the meeting's screen, the workspace also keeps screenshots of it,
 - In the transcript, a line said while a new screenshot came up has a small picture beside it. Press it to see the screenshot.
 - When **tesseract** is on this machine, the workspace reads the text on each screenshot, on this machine, and shows it under the large picture. To install it, run `brew install tesseract` in a terminal.
 
+### Shots of the meeting only
+
+When you press **Listen**, a sheet asks **Where is the meeting?** The choice is remembered for the next time.
+
+- **Zoom app** or **Another app**: the browser asks twice. The first share is **Entire screen** with system audio; PMOS uses its sound only, never its picture. Then a second sheet asks you to **Pick the meeting window**; the shots come from that window only, and it stays captured while you work in other apps. Press **Sound only, no shots** to skip the second share.
+- **Google Meet in Chrome**: one share of the Meet tab, with its sound, gives the sound and the shots.
+- **Pause shots**: the chip next to **REC** in Focus, and the eye icon on the recording chip in the top bar, stop the pictures and keep the sound. Press it again to take shots again.
+- **Set aside.** If the picture is the whole screen and tesseract is on this machine, PMOS reads each shot. A shot whose text looks like another app (Slack or a mailbox, for example) and not like the call is set aside: it is not in the note, the replay or anything the agent reads. The note shows **N set aside**. Press it to **Keep it**, **Delete** or **Delete all**. Set-aside shots are deleted on their own after 7 days. Without tesseract, every shot is kept.
+
 To stop taking screenshots, clear **Capture the shared screen** in the settings. The sound of the shared screen is still used. To stop sharing only the picture during a meeting, stop the share in the browser's sharing bar; the screenshots stop. To delete one note's screenshots, press **Delete this note's screenshots** in the settings, or **Delete screenshots** in the note's **More** menu. The notes, the transcript and the audio stay. Deleting a note, or marking it private, deletes its screenshots.
 
 ## Capture highlights during the meeting

package/workspace/lib/meeting-material.js

@@ -0,0 +1,151 @@
+'use strict';
+/* lib/meeting-material.js — the material the PM linked to a meeting (initiative meeting-material-replay, part 1).
+ *
+ *   keyOf(event)                          → 's:<series>' or 't:<normalized title>' (calendar-memory.js seriesKey), as lib/calendar-links.js
+ *   append(runtimeDir, body, by)          → { ok, items } | { ok: false, error }   op 'add' (the default) or 'remove'
+ *   forMeeting(runtimeDir, event)         → [item]   the series items of the meeting and the items for this one meeting, in the order they were added
+ *   read(runtimeDir)                      → Map<identity, row>   the rows that hold now (a removed item is gone)
+ *   check(body)                           → null | the reason the body is refused
+ *   classifyUrl(url)                      → { kind: slides|gdoc|conf|link, url } | null
+ *
+ * The calendar is read-only (PMOS never edits an invite), so the material lives beside it: <runtime>/meeting-material.jsonl, append-only.
+ * A row: { at, by, key, series, event?, scope: 'meeting'|'series', item: { kind, ref?, title, url?, ws? }, topic?, present, removed? }.
+ * An item is named by its key, its event ("this meeting"; empty for the series) and its kind and ref or url. The last row of a name wins,
+ * and a row with removed: true takes the item off. Nothing is ever rewritten.
+ *
+ * Kinds. PMOS items name a file of the repository by ref: pmos-doc (a document), pmos-deck (a report cycle that is a slide deck), report
+ * (any other report cycle). Links name an address: slides, gdoc, conf, link. The server decides a link's kind from its address. */
+const fs = require('fs');
+const path = require('path');
+const calMem = require('./calendar-memory.js');
+
+const FILE = 'meeting-material.jsonl';
+const PMOS_KINDS = ['pmos-deck', 'pmos-doc', 'report'];
+const LINK_KINDS = ['slides', 'gdoc', 'conf', 'link'];
+const KINDS = [...PMOS_KINDS, ...LINK_KINDS];
+const SCOPES = ['meeting', 'series'];
+const OPS = ['add', 'remove'];
+const MAX_ITEMS = 60;
+const str = (v) => (typeof v === 'string' ? v.trim() : '');
+
+const keyOf = (e) => calMem.seriesKey({ series: e && e.series ? String(e.series) : null, title: e && e.title });
+const fileOf = (runtimeDir) => path.join(runtimeDir, FILE);
+
+/** What an address is. Only https addresses are kept; the server and the page agree on the kind. */
+function classifyUrl(raw) {
+  const s = str(raw);
+  if (!s || s.length > 1000 || /\s/.test(s)) return null;
+  let u; try { u = new URL(/^[a-z][a-z0-9+.-]*:/i.test(s) ? s : 'https://' + s); } catch { return null; }
+  if (u.protocol !== 'https:' || !u.hostname.includes('.')) return null;
+  if (u.hostname === 'docs.google.com' && /^\/presentation\/d\//.test(u.pathname)) return { kind: 'slides', url: u.href };
+  if (u.hostname === 'docs.google.com' && /^\/document\/d\//.test(u.pathname)) return { kind: 'gdoc', url: u.href };
+  if (/\.atlassian\.net$/.test(u.hostname) && u.pathname.startsWith('/wiki')) return { kind: 'conf', url: u.href };
+  return { kind: 'link', url: u.href };
+}
+
+/** A repository-relative file path: no leading slash, no "..", no backslash, no control character. */
+const refOk = (r) => typeof r === 'string' && r.length > 0 && r.length <= 300 && !r.startsWith('/') && !r.includes('\\') && !/(^|\/)\.\.(\/|$)/.test(r) && !/[\u0000-\u001f]/.test(r);
+
+/** The name of an item inside one meeting or series. */
+const idOf = (item) => item.kind + '|' + (PMOS_KINDS.includes(item.kind) ? item.ref : item.url);
+const identity = (row) => [row.key, row.scope === 'series' ? '' : row.event || '', idOf(row.item)].join('\u0000');
+
+/** The reason a POST body is refused, or null.
+ *  body: { op?: 'add'|'remove', event: { id?, title, series? }, scope: 'meeting'|'series', item: { kind, ref | url, title?, ws? }, topic?, present? } */
+function check(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return 'the body must be a JSON object';
+  if (body.op != null && !OPS.includes(body.op)) return 'op is one of ' + OPS.join(', ');
+  const e = body.event;
+  if (!e || typeof e !== 'object' || !str(e.title) || str(e.title).length > 300) return 'event.title is required (one line, at most 300 characters)';
+  if (e.series != null && (typeof e.series !== 'string' || e.series.length > 300)) return 'event.series must be text';
+  if (e.id != null && (typeof e.id !== 'string' || e.id.length > 120)) return 'event.id must be text';
+  const scope = body.scope == null ? 'meeting' : body.scope;
+  if (!SCOPES.includes(scope)) return 'scope is one of ' + SCOPES.join(', ');
+  if (scope === 'meeting' && !str(e.id)) return 'a link for one meeting needs event.id';
+  const it = body.item;
+  if (!it || typeof it !== 'object') return 'item is required';
+  if (PMOS_KINDS.includes(it.kind)) { if (!refOk(it.ref)) return 'a PMOS item needs ref, the path of the file in the repository'; }
+  else if (it.kind == null || LINK_KINDS.includes(it.kind)) { if (!classifyUrl(it.url)) return 'a link must be an https address'; }
+  else return 'item.kind is one of ' + KINDS.join(', ');
+  if (it.title != null && (typeof it.title !== 'string' || it.title.length > 300 || /[\r\n]/.test(it.title))) return 'item.title is one line of at most 300 characters';
+  if (it.ws != null && (typeof it.ws !== 'string' || it.ws.length > 120)) return 'item.ws must be text';
+  if (body.topic != null && (typeof body.topic !== 'string' || body.topic.length > 160 || /[\r\n]/.test(body.topic))) return 'topic is one line of at most 160 characters';
+  if (body.present != null && typeof body.present !== 'boolean') return 'present must be true or false';
+  return null;
+}
+
+/** The item as it is kept: the kind a link has, its address in full, a title. */
+function cleanItem(it) {
+  if (PMOS_KINDS.includes(it.kind)) return { kind: it.kind, ref: it.ref, title: str(it.title) || it.ref, ...(str(it.ws) ? { ws: str(it.ws) } : {}) };
+  const c = classifyUrl(it.url);
+  return { kind: c.kind, url: c.url, title: str(it.title) || c.url };
+}
+
+function lines(runtimeDir) {
+  if (!runtimeDir) return [];
+  let text = '';
+  try { text = fs.readFileSync(fileOf(runtimeDir), 'utf8'); } catch { return []; }
+  const out = [];
+  for (const l of text.split('\n')) {
+    if (!l.trim()) continue;
+    let x; try { x = JSON.parse(l); } catch { continue; }
+    if (!x || typeof x.key !== 'string' || !SCOPES.includes(x.scope) || !x.item || !KINDS.includes(x.item.kind)) continue;
+    if (PMOS_KINDS.includes(x.item.kind) ? !refOk(x.item.ref) : !x.item.url) continue;
+    out.push(x);
+  }
+  return out;
+}
+
+/** The rows that hold now, in the order their items were first added (a changed item keeps its place). */
+function read(runtimeDir) {
+  const out = new Map();
+  for (const row of lines(runtimeDir)) {
+    const id = identity(row);
+    if (row.removed) { out.delete(id); continue; }
+    out.set(id, out.has(id) ? { ...row, firstAt: out.get(id).firstAt } : { ...row, firstAt: row.at || null });
+  }
+  return out;
+}
+
+const view = (row) => ({
+  id: crypto16(identity(row)), kind: row.item.kind, ref: row.item.ref || null, url: row.item.url || null, title: row.item.title || row.item.ref || row.item.url,
+  ws: row.item.ws || null, topic: row.topic || null, present: row.present === true, scope: row.scope, from: 'you', by: row.by || null, at: row.at || null,
+});
+/** A short stable id for a row, so the page can name an item without sending its path back and forth. */
+function crypto16(s) { return require('crypto').createHash('sha1').update(s).digest('hex').slice(0, 12); }
+
+/** The material of one meeting: its series items and its own, in the order they were added. event: { id?, title, series? } */
+function forMeeting(runtimeDir, event) {
+  if (!event || !str(event.title)) return [];
+  const key = keyOf(event);
+  const id = str(event.id);
+  const mine = [];
+  for (const row of read(runtimeDir).values()) {
+    if (row.key !== key) continue;
+    if (row.scope === 'meeting' && !(id && row.event === id)) continue;
+    mine.push(row);
+  }
+  return mine.sort((a, b) => String(a.firstAt).localeCompare(String(b.firstAt))).map(view);
+}
+
+function append(runtimeDir, body, by) {
+  const bad = check(body);
+  if (bad) return { ok: false, error: bad };
+  if (!runtimeDir) return { ok: false, error: 'this server has no runtime folder, so the material cannot be saved' };
+  const op = body.op || 'add';
+  const scope = body.scope || 'meeting';
+  const item = cleanItem(body.item);
+  const line = { at: new Date().toISOString(), by: by || null, key: keyOf(body.event), series: body.event.series ? String(body.event.series) : null, event_title: str(body.event.title), scope, item };
+  if (scope === 'meeting') line.event = str(body.event.id);
+  if (op === 'remove') line.removed = true;
+  else {
+    if (str(body.topic)) line.topic = str(body.topic);
+    line.present = body.present === true && ['pmos-deck', 'slides', 'report'].includes(item.kind);
+    if (forMeeting(runtimeDir, body.event).length >= MAX_ITEMS && !read(runtimeDir).has(identity(line))) return { ok: false, error: 'a meeting holds at most ' + MAX_ITEMS + ' items' };
+  }
+  fs.mkdirSync(runtimeDir, { recursive: true });
+  fs.appendFileSync(fileOf(runtimeDir), JSON.stringify(line) + '\n');
+  return { ok: true, items: forMeeting(runtimeDir, body.event) };
+}
+
+module.exports = { keyOf, read, forMeeting, append, check, classifyUrl, KINDS, PMOS_KINDS, LINK_KINDS, FILE };

package/workspace/lib/meeting-replay.js

@@ -0,0 +1,170 @@
+'use strict';
+/* meeting-replay.js — the pure join behind the meeting replay page (initiative meeting-material-replay, part 2).
+ *
+ *   build({ note, event?, stateLines?, frames?, audio?, topics?, now? }) → the replay
+ *
+ * The replay is Focus played back, so it joins three records PMOS already keeps and invents nothing:
+ *   the note       transcript lines (with who said them), decisions, next steps and questions, the audio's length
+ *   the Focus file <runtime>/focus/<note or event id>.jsonl, folded by lib/meeting-focus.js: topics, the stretches of talk, PMOS's notes
+ *   the shots      lib/notes-screen.js frames; a frame with `aside` truthy was set aside (it looked like another app) and is NEVER in the replay
+ *
+ * Every time is MEETING time in ms: 0 is where the recording starts, the same clock the audio, the transcript and the shots use
+ * (the audio's currentTime * 1000). `start_ms` is the wall clock (epoch ms) of meeting time 0, so the page can show 11:18.
+ *
+ * A KEY POINT'S TIME is the time of the transcript line it was caught from: the item's own `t` (the final notes and the minute
+ * bullets keep it), else the line its quote (or, failing that, its text) is found in. When none is known `t` is null and the page
+ * shows no play button. Nothing here reads a file or starts a process; lib/routes-meeting-replay.js reads and calls build().
+ *
+ * Output:
+ *   { ok, note: { id, title, state, initiative, ws }, meeting: { title, at, end, attendees },
+ *     audio: { url, ms } | null, start_ms, length_ms,
+ *     lines:  [{ i, t, who, text, source, key: { k, id } | null }]            by t
+ *     keys:   [{ id, k: 'decision'|'action'|'question', text, t, owner, due, by, state: 'draft'|'owner'|'open'|'answered', warn }]
+ *     topics: [{ id, text, src, state, minutes, n, first_t, stretches, parked, by }]   visited ones first, in the order they came up
+ *     runs:   [{ topic, n, from_ms, to_ms }]
+ *     notes:  [{ id, t, cat, body, heard, why, src }]                          PMOS's notes with the time they were made
+ *     shots:  [{ t, w, h, why?, text? }]                                       kept shots only
+ *     aside_count }
+ */
+const N = require('./notes.js');
+const F = require('./meeting-focus.js');
+
+const SHOT_TEXT_MAX = 400;
+const NEAR_LINE_MS = 3000;       // a key point whose time is not exactly a line's belongs to the line this close
+const ANSWER_OVERLAP = 0.6;
+
+const str = (v, n) => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim().slice(0, n) : '');
+const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+const words = (t) => String(t == null ? '' : t).toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '').match(/[\p{L}\p{N}]+/gu) || [];
+const share = (a, b) => {
+  const wa = words(a); const hb = new Set(words(b));
+  return wa.length ? wa.filter((w) => hb.has(w)).length / wa.length : 0;
+};
+
+/** The wall clock (epoch ms) of meeting time 0: a transcript line's `at` minus its `t`, else when recording began, else the meeting's start. */
+function startOf(note, event) {
+  for (const x of (note && note.transcript) || []) {
+    const at = Date.parse(x && x.at);
+    if (x && finite(x.t) && Number.isFinite(at)) return at - x.t;
+  }
+  const rec = Date.parse(note && note.recorded_from);
+  if (Number.isFinite(rec)) return rec;
+  const ev = Date.parse(event && event.at);
+  return Number.isFinite(ev) ? ev : null;
+}
+
+/** The lines of the talk with a time: the final pass's segments when there are some, else the live lines; by t. */
+function linesOf(note) {
+  let raw = [];
+  try { raw = N.transcriptLines(note); } catch { raw = []; }
+  return raw.filter((x) => x && finite(x.t) && typeof x.text === 'string' && x.text.trim())
+    .map((x) => ({ t: Math.round(x.t), who: str(x.who, 60), text: str(x.text, 600), source: x.source || 'speech' }))
+    .sort((a, b) => a.t - b.t)
+    .map((x, i) => ({ i, ...x, key: null }));
+}
+
+/** The decisions, next steps and questions of the note, as the Notes page shows them: the final notes when written, else the minute
+ *  bullets, else the local summary. → { decision: [item], action: [item], question: [item] }, item = { text, quote?, t?, owner?, due?, by? } */
+function caughtOf(note) {
+  const out = { decision: [], action: [], question: [] };
+  const f = note && note.final_notes;
+  const fromList = (kind, list) => {
+    for (const x of Array.isArray(list) ? list : []) {
+      const text = str(x && x.text, 300);
+      if (text) out[kind].push({ text, quote: str(x.quote, 400), t: finite(x.t) ? x.t : null, owner: str(x.owner, 60) || null, due: str(x.due, 40) || null, by: str(x.by, 120) || null });
+    }
+  };
+  if (f && ((f.decisions || []).length || (f.actions || []).length || (f.questions || []).length)) {
+    fromList('decision', f.decisions); fromList('action', f.actions); fromList('question', f.questions);
+    return out;
+  }
+  const bl = ((note && note.bullets) || []).filter((b) => b && b.text && !b.dropped && !b.open);
+  if (bl.length) {
+    for (const b of bl) if (out[b.cat]) out[b.cat].push({ text: str(b.text, 300), quote: '', t: finite(b.t) ? b.t : null, owner: str(b.owner, 60) || null, due: str(b.due, 40) || null, by: null });
+    if (out.decision.length || out.action.length || out.question.length) return out;
+  }
+  const sec = (note && note.summary && note.summary.sections) || {};
+  const at = (x) => { const m = /^\s*\[?(\d+:\d{2}(?::\d{2})?)\]?\s*$/.exec(String((x && x.at) || '')); return m ? N.parseTime(m[1]) : null; };
+  const fromSec = (kind, list) => { for (const x of Array.isArray(list) ? list : []) { const text = str(x && x.text, 300); if (text) out[kind].push({ text, quote: '', t: at(x), owner: str(x.owner, 60) || null, due: str(x.due, 40) || null, by: null }); } };
+  fromSec('decision', sec.decisions); fromSec('action', sec.actions); fromSec('question', sec.questions);
+  return out;
+}
+
+/** The time of the line a key point was caught from: its own t, else the line its quote (or its text) is in; null when unknown. */
+function timeOfKey(item, lines) {
+  if (finite(item.t)) return Math.max(0, Math.round(item.t));
+  const timed = lines.map((l) => ({ t: l.t, text: l.text }));
+  for (const probe of [item.quote, item.text]) {
+    if (!probe) continue;
+    let at = null;
+    try { at = N.groundQuote(timed, probe, null); } catch { at = null; }
+    if (finite(at)) return Math.max(0, Math.round(at));
+  }
+  return null;
+}
+
+/** Join the three records. */
+function build({ note, event = null, stateLines = [], frames = [], audio = null, topics = [], now = Date.now() } = {}) {
+  const n = note || {};
+  const lines = linesOf(n);
+  const start = startOf(n, event);
+  const shots = (frames || []).filter((f) => f && finite(f.t) && !f.aside).sort((a, b) => a.t - b.t)
+    .map((f) => ({ t: f.t, w: f.w || 0, h: f.h || 0, ...(f.why ? { why: f.why } : {}), ...(f.text ? { text: str(f.text, SHOT_TEXT_MAX) } : {}) }));
+  const asideCount = (frames || []).filter((f) => f && f.aside).length;
+
+  // Focus's state: topics, stretches, PMOS's notes. Stretches are measured from meeting time 0.
+  const fold = F.foldState(stateLines || [], { topics, startMs: start, nowMs: start == null ? now : start + 0 });
+  const pmos = start == null ? [] : fold.notes.filter((x) => x && x.body && finite(x.at)).map((x) => ({ id: x.id, t: Math.max(0, Math.round(x.at - start)), cat: str(x.cat, 30), body: str(x.body, 700), heard: str(x.heard, 300), why: str(x.why, 300), src: str(x.src, 80) }))
+    .sort((a, b) => a.t - b.t);
+
+  // length: the audio, the clock of the note, else the last thing that has a time
+  let heard = 0;
+  if (n.ended_at || n.paused_at) { try { heard = N.heardMs(n, now) || 0; } catch { heard = 0; } }   // a note still recording has no end to trust
+  const caught = caughtOf(n);
+  const keys = [];
+  for (const [kind, list] of [['decision', caught.decision], ['action', caught.action], ['question', caught.question]]) {
+    list.forEach((it, i) => {
+      const t = timeOfKey(it, lines);
+      const answered = kind === 'question' && t != null && pmos.some((p) => p.cat === 'Answer' && p.t >= t && share(it.text, p.heard || p.body) >= ANSWER_OVERLAP);
+      const state = kind === 'action' ? (it.owner ? 'draft' : 'owner') : kind === 'question' ? (answered ? 'answered' : 'open') : 'draft';
+      keys.push({ id: kind[0] + (i + 1), k: kind, text: it.text, t, owner: it.owner, due: it.due, by: it.by, state, warn: state === 'owner' || state === 'open' });
+    });
+  }
+  keys.sort((a, b) => (a.t == null) - (b.t == null) || (a.t || 0) - (b.t || 0));
+  // the line a key point was caught from carries its mark
+  for (const k of keys) {
+    if (k.t == null || !lines.length) continue;
+    let best = null;
+    for (const l of lines) if (!l.key && (best === null || Math.abs(l.t - k.t) < Math.abs(best.t - k.t))) best = l;
+    if (best && Math.abs(best.t - k.t) <= NEAR_LINE_MS) best.key = { k: k.k, id: k.id };
+  }
+
+  const lastT = (xs) => xs.reduce((m, x) => (finite(x.t) && x.t > m ? x.t : m), 0);
+  const length = Math.max(finite(audio && audio.ms) ? audio.ms : 0, heard, lastT(lines), lastT(shots), lastT(keys), lastT(pmos));
+
+  // stretches, in ms; a stretch still open runs to the end
+  const runs = fold.runs.map((r) => ({ topic: r.topic, from_ms: Math.round(r.from_min * 60000), to_ms: r.to_min == null ? length : Math.round(r.to_min * 60000) }))
+    .filter((r) => r.to_ms > r.from_ms || r.to_ms === length);
+  const firstOf = new Map();
+  for (const r of runs) if (!firstOf.has(r.topic)) firstOf.set(r.topic, r.from_ms);
+  const visited = fold.topics.filter((t) => firstOf.has(t.id)).sort((a, b) => firstOf.get(a.id) - firstOf.get(b.id));
+  const numOf = new Map(visited.map((t, i) => [t.id, i + 1]));
+  const stretches = (id) => runs.filter((r) => r.topic === id).length;
+  const minutesOf = (id) => Math.round(runs.filter((r) => r.topic === id).reduce((s, r) => s + (r.to_ms - r.from_ms), 0) / 60000);
+  const topicRows = [...visited, ...fold.topics.filter((t) => !firstOf.has(t.id))].map((t) => ({
+    id: t.id, text: t.text, src: t.src, state: t.state, minutes: minutesOf(t.id), n: numOf.get(t.id) || null, first_t: firstOf.has(t.id) ? firstOf.get(t.id) : null,
+    stretches: stretches(t.id), parked: t.state === 'parked', by: t.by || null }));
+  const ev = event || {};
+  const m = n.meeting || {};
+  return {
+    ok: true,
+    note: { id: n.id, title: n.title || m.title || ev.title || 'Untitled note', state: n.state || null, initiative: n.initiative || null, ws: n.ws || (n.initiative && n.initiative.ws) || null },
+    meeting: { title: ev.title || m.title || n.title || 'Untitled note', at: ev.at || m.start || n.recorded_from || n.created_at || null, end: ev.end || m.end || null,
+      attendees: [].concat(ev.attendees || ev.people || []).map((p) => (p && typeof p === 'object' ? p.name || p.id : p)).filter(Boolean).map(String) },
+    audio: audio && audio.url ? { url: audio.url, ms: finite(audio.ms) ? audio.ms : null } : null,
+    start_ms: start, length_ms: length,
+    lines, keys, topics: topicRows, runs: runs.map((r) => ({ ...r, n: numOf.get(r.topic) || null })), notes: pmos, shots, aside_count: asideCount,
+  };
+}
+
+module.exports = { build, caughtOf, timeOfKey, linesOf, startOf };