create-pmos 0.178.0 → 0.180.0

package/workspace/lib/notes-series.js

@@ -0,0 +1,357 @@
+'use strict';
+/* notes-series.js — the notes of one regular meeting, kept together (initiative c3-notes-series, the mockup the PM approved on
+ * 2026-10-13: https://claude.ai/artifact/Q4SSHcj6QHhpQAiVAx52x6).
+ *
+ *   assign(rows)                          the list's rows get their series: a title key joins the calendar series with the same title
+ *   thread(dir, key, { now, events })    → { ok, series }   the series page: next one, still open, decided, keeps coming up, unanswered, every meeting
+ *   placeOf(dir, id, { now })            → { key, title, pos, count, prev, next, since, carried_in, carried } | null   a note in its series
+ *   search(dir, q)                        → { ok, ids }   the notes whose title, notes or transcript hold every word of q
+ *   markDone(dir, { key, text, kind, done }) · bring(dir, { key, text }) · unbring(dir, { key, id })   the PM's marks, per series
+ *
+ * A SERIES is the notes with one key (lib/notes.js seriesOf): the calendar series ('s:<id>'), else the normalized title
+ * ('t:<title>'). A note with a title key joins the calendar series whose notes have the same normalized title, so a note taken
+ * without the calendar link still lands in its meeting. A key with fewer than two notes is not a series.
+ *
+ * SAME ITEM. Two actions (or questions) are the same when their words match after lower-casing and dropping punctuation. No model
+ * is called and nothing is sent outward. An action is open until the PM marks it done; a question until the PM marks it answered.
+ * Those marks, and the PM's lines to bring up, live in <dir>/notes-series.json, keyed by series.
+ *
+ * A PRIVATE note adds its date and title to a series, never its content (as the calendar's meeting card does). */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const notes = require('./notes.js');
+const calMem = require('./calendar-memory.js');
+
+const OPEN_WINDOW = 6;        // actions and questions come from the last six meetings
+const TOPIC_WINDOW = 10;      // topics count over the last ten meetings
+const TOPIC_MIN = 3;          // a topic comes up in three or more of them
+const CLOSED_DAYS = 14;       // closed actions shown under Still open
+const CARRY_WARN = 3;         // an action carried in this many meetings is brought up
+const MAX_BRING = 20;
+const DAY = 86400000;
+
+const norm = (s) => String(s || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+const clip = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
+const err = (status, error) => ({ ok: false, status, error });
+const startOf = (n) => (n && n.meeting && n.meeting.start) || (n && n.recorded_from) || (n && n.created_at) || null;
+const timeOf = (n) => Date.parse(startOf(n)) || 0;
+
+/* ── the list ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** Give each row its series key (rows carry `series` from notes.js seriesOf). A title key moves to the calendar series whose
+ *  notes share that title. Sets row.series = { key, by } or null; by is 'calendar', 'title' or 'pm'. Changes the rows. */
+function assign(rows) {
+  const byTitle = new Map();
+  for (const r of rows) {
+    if (!r.series || r.series.by !== 'calendar') continue;
+    const t = calMem.normTitle((r.meeting && r.meeting.title) || r.title);
+    if (t && !byTitle.has(t)) byTitle.set(t, r.series.key);
+  }
+  for (const r of rows) {
+    if (!r.series || r.series.by !== 'title') continue;
+    const k = byTitle.get(r.series.key.slice(2));
+    if (k) r.series = { key: k, by: 'title' };
+  }
+  return rows;
+}
+
+/** Every note row with its series, the same as GET /api/notes. */
+function rowsOf(dir, now) { return (notes.list(dir, { now }).notes || []); }
+
+/* ── a note's parts ───────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** What a note holds: its final notes after Stop, else its saved local summary, else a local summary made now. */
+const partsCache = new WeakMap();      // a cached note (notes.js loadCached) → its parts, made again only when the file changes
+function partsOf(n) {
+  if (n && typeof n === 'object' && partsCache.has(n)) return partsCache.get(n);
+  const p = partsNow(n);
+  if (n && typeof n === 'object') partsCache.set(n, p);
+  return p;
+}
+function partsNow(n) {
+  const empty = { overview: '', decisions: [], actions: [], questions: [] };
+  if (!n || n.private) return empty;
+  const f = n.final_notes && typeof n.final_notes === 'object' ? n.final_notes : null;
+  let sec = n.summary && n.summary.sections ? n.summary.sections : null;
+  if (!f && !sec && ((n.transcript || []).length || (n.bullets || []).length)) { try { sec = notes.summarize(n).sections; } catch { sec = null; } }
+  const pick = (a, b) => (Array.isArray(a) && a.length ? a : Array.isArray(b) ? b : []);
+  const ov = n.overview_pm || (f && (f.overview || f.purpose))
+    || (sec && Array.isArray(sec.overview) ? sec.overview.slice(0, 3).map((x) => String((x && x.text) || '')).filter(Boolean).join(' ') : '');
+  const items = (xs, extra) => xs.filter((x) => x && clip(x.text, 400)).map((x) => ({ text: clip(x.text, 400), ...extra(x) }));
+  return {
+    overview: clip(ov, 600),
+    decisions: items(pick(f && f.decisions, sec && sec.decisions), (x) => ({ why: clip(x.why, 300) || null })),
+    actions: items(pick(f && f.actions, sec && sec.actions), (x) => ({ owner: clip(x.owner, 80) || null, due: clip(x.due, 60) || null, quote: clip(x.quote, 300) || null })),
+    questions: items(pick(f && f.questions, sec && sec.questions), (x) => ({ quote: clip(x.quote, 300) || null })),
+  };
+}
+
+/** The notes of one series, oldest first, each read in full with its parts. */
+function membersOf(dir, key, rows) {
+  return rows.filter((r) => r.series && r.series.key === key)
+    .map((r) => ({ row: r, note: notes.loadCached(dir, r.id) }))
+    .filter((x) => x.note)
+    .sort((a, b) => timeOf(a.note) - timeOf(b.note))
+    .map((x) => ({ ...x, at: startOf(x.note), parts: partsOf(x.note) }));
+}
+
+/* ── the PM's marks ───────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const storeFile = (dir) => path.join(dir, 'notes-series.json');
+function readStore(dir) {
+  try { const j = JSON.parse(fs.readFileSync(storeFile(dir), 'utf8')); return j && typeof j === 'object' && !Array.isArray(j) ? j : {}; } catch { return {}; }
+}
+function writeStore(dir, s) {
+  const f = storeFile(dir);
+  const tmp = f + '.' + process.pid + '.' + crypto.randomBytes(3).toString('hex') + '.tmp';
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tmp, JSON.stringify(s, null, 1));
+  fs.renameSync(tmp, f);
+}
+const entryOf = (s, key) => { const e = s[key] && typeof s[key] === 'object' ? s[key] : {}; return { done: e.done && typeof e.done === 'object' ? e.done : {}, bring: Array.isArray(e.bring) ? e.bring : [] }; };
+const validKey = (key) => typeof key === 'string' && notes.SERIES_KEY_RE.test(key);
+
+/** Mark an action done (kind 'action') or a question answered (kind 'question'), or take the mark back (done: false). */
+function markDone(dir, { key, text, kind = 'action', done = true, now = Date.now() } = {}) {
+  if (!validKey(key)) return err(400, 'that is not a series');
+  const k = norm(text);
+  if (!k) return err(400, 'say which item');
+  if (!['action', 'question'].includes(kind)) return err(400, 'the kind must be action or question');
+  const s = readStore(dir); const e = entryOf(s, key);
+  if (done) e.done[k] = { text: clip(text, 400), kind, at: new Date(now).toISOString() }; else delete e.done[k];
+  s[key] = e; writeStore(dir, s);
+  return { ok: true };
+}
+/** Add a line to bring up at the next meeting of the series. */
+function bring(dir, { key, text, now = Date.now() } = {}) {
+  if (!validKey(key)) return err(400, 'that is not a series');
+  const t = clip(text, 300);
+  if (!t) return err(400, 'write what to bring up');
+  const s = readStore(dir); const e = entryOf(s, key);
+  if (e.bring.length >= MAX_BRING) return err(400, 'this series already has ' + MAX_BRING + ' lines to bring up');
+  const line = { id: 'b-' + Math.floor(now).toString(36) + crypto.randomBytes(2).toString('hex'), text: t, at: new Date(now).toISOString() };
+  e.bring.push(line); s[key] = e; writeStore(dir, s);
+  return { ok: true, line };
+}
+function unbring(dir, { key, id } = {}) {
+  if (!validKey(key)) return err(400, 'that is not a series');
+  const s = readStore(dir); const e = entryOf(s, key);
+  const before = e.bring.length;
+  e.bring = e.bring.filter((b) => b.id !== id);
+  if (e.bring.length === before) return err(404, 'no such line');
+  s[key] = e; writeStore(dir, s);
+  return { ok: true };
+}
+
+/* ── the thread ───────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const STOP = new Set(('the a an and or of to in on for with is are was be it this that we you i at by from as but not if so do does did will can '
+  + 'should would could has have had they he she them their our us all any some more most just also into about over than then when what who which '
+  + 'how why there here yes no ok okay get got go going need needs make made let lets one two next last week today tomorrow monday tuesday wednesday '
+  + 'thursday friday team meeting call update updates').split(' '));
+const wordsIn = (s) => norm(s).split(' ').filter((w) => w.length > 2 && !STOP.has(w) && !/^\d+$/.test(w));
+
+/** For each agenda item, whether a transcript line shares two of its words (notes-context.js agendaHeard, on the server). */
+function agendaHeard(agenda, lines) {
+  const ls = lines.map((l) => new Set(wordsIn(l.text)));
+  return agenda.map((a) => {
+    const aw = [...new Set(wordsIn(a))]; const need = Math.min(2, aw.length);
+    return need > 0 && ls.some((w) => aw.filter((x) => w.has(x)).length >= need);
+  });
+}
+
+/** The topics that keep coming up over the last TOPIC_WINDOW meetings: agenda items heard, then two-word phrases from the
+ *  notes, each in TOPIC_MIN or more meetings. → [{ name, hits: [bool, newest first], count, kind: 'agenda'|'phrase' }] */
+function topicsOf(ms, seriesTitle) {
+  const recent = ms.filter((m) => !m.note.private).slice(-TOPIC_WINDOW).reverse();
+  if (recent.length < TOPIC_MIN) return [];
+  const out = [];
+  const agenda = new Map();      // norm → { name, hits }
+  recent.forEach((m, i) => {
+    const c = m.note.meeting && m.note.meeting.context;
+    const items = c && Array.isArray(c.agenda) ? c.agenda.map((a) => clip(a, 120)).filter(Boolean) : [];
+    if (!items.length) return;
+    const heard = agendaHeard(items, notes.transcriptLines(m.note) || []);
+    items.forEach((a, j) => {
+      if (!heard[j]) return;
+      const k = norm(a); if (!agenda.has(k)) agenda.set(k, { name: a, hits: recent.map(() => false) });
+      agenda.get(k).hits[i] = true;
+    });
+  });
+  for (const t of agenda.values()) { const count = t.hits.filter(Boolean).length; if (count >= TOPIC_MIN) out.push({ name: t.name, hits: t.hits, count, kind: 'agenda' }); }
+  const skip = new Set(wordsIn(seriesTitle));
+  const phrases = new Map();     // "w1 w2" → { name, hits }
+  recent.forEach((m, i) => {
+    const p = m.parts;
+    const texts = [p.overview, ...p.decisions.map((x) => x.text), ...p.actions.map((x) => x.text), ...p.questions.map((x) => x.text)];
+    const seen = new Set();
+    for (const t of texts) {
+      const raw = String(t || '').split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+      const ws = raw.map((w) => w.toLowerCase());
+      for (let j = 0; j + 1 < ws.length; j++) {
+        const a = ws[j]; const b = ws[j + 1];
+        // a short word counts only as an acronym ("QA", "UX")
+        const short = (w, r) => w.length < 3 && !/^[A-Z]{2}$/.test(r);
+        if (short(a, raw[j]) || short(b, raw[j + 1]) || STOP.has(a) || STOP.has(b) || /^\d+$/.test(a) || /^\d+$/.test(b) || (skip.has(a) && skip.has(b))) continue;
+        const k = a + ' ' + b;
+        if (seen.has(k)) continue;
+        seen.add(k);
+        if (!phrases.has(k)) phrases.set(k, { name: raw[j] + ' ' + raw[j + 1], hits: recent.map(() => false) });
+        phrases.get(k).hits[i] = true;
+      }
+    }
+  });
+  const inAgenda = (k) => out.some((t) => k.split(' ').every((w) => norm(t.name).split(' ').includes(w)));
+  const ph = [...phrases.entries()].map(([k, t]) => ({ k, ...t, count: t.hits.filter(Boolean).length }))
+    .filter((t) => t.count >= TOPIC_MIN && !inAgenda(t.k)).sort((a, b) => b.count - a.count || a.k.localeCompare(b.k));
+  for (const t of ph) {
+    if (out.length >= 6) break;
+    // a phrase that shares a word with a stronger one already kept is the same topic
+    if (out.some((o) => o.kind === 'phrase' && o.k.split(' ').some((w) => t.k.split(' ').includes(w)))) continue;
+    out.push({ name: t.name.charAt(0).toUpperCase() + t.name.slice(1), hits: t.hits, count: t.count, kind: 'phrase', k: t.k });
+  }
+  return out.map(({ k, ...t }) => t);
+}
+
+/** The items of one kind across the meetings: each distinct item with when it was first raised, in how many meetings, and the
+ *  last time it was raised. `window` limits which meetings an item must appear in to be listed. */
+function carriedOf(ms, kind, window) {
+  const all = new Map();         // norm → { text, owner, due, first, seen, last }
+  for (const m of ms) {
+    if (m.note.private) continue;
+    const seen = new Set();
+    for (const x of m.parts[kind]) {
+      const k = norm(x.text);
+      if (!k || seen.has(k)) continue;
+      seen.add(k);
+      const e = all.get(k) || { key: k, first: m.at, seen: 0 };
+      e.seen++; e.text = x.text; e.owner = x.owner || e.owner || null; e.due = x.due || e.due || null;
+      e.last = { at: m.at, note: m.note.id, quote: x.quote || null };
+      all.set(k, e);
+    }
+  }
+  const recent = new Set(ms.filter((m) => !m.note.private).slice(-window).map((m) => m.note.id));
+  return [...all.values()].filter((e) => recent.has(e.last.note));
+}
+
+/** The next meeting of the series on the calendar, after `now`. */
+function nextOf(key, events, now) {
+  const t = key.slice(2);
+  return (events || []).filter((e) => e && e.title && Date.parse(e.at) > now)
+    .filter((e) => (key.startsWith('s:') ? (e.series && 's:' + e.series === key) : false) || calMem.normTitle(e.title) === (key.startsWith('t:') ? t : null))
+    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at))
+    .map((e) => ({ id: e.id, at: e.at, end: e.end || null, title: e.title }))[0] || null;
+}
+
+function thread(dir, key, { now = Date.now(), events = null, rows = null } = {}) {
+  if (!validKey(key)) return err(400, 'that is not a series');
+  const all = rows || rowsOf(dir, now);
+  const ms = membersOf(dir, key, all);
+  if (!ms.length) return err(404, 'no notes in this series');
+  if (events === null) { try { events = require('./calendar-events.js').readAll(dir, { now }); } catch { events = []; } }
+  // a series with a title key whose notes came from the calendar still finds its meetings by the calendar series
+  const seriesIds = [...new Set(ms.map((m) => m.note.meeting && m.note.meeting.context && m.note.meeting.context.series).filter(Boolean))];
+  const st = entryOf(readStore(dir), key);
+  const newest = ms[ms.length - 1];
+  const title = clip((newest.note.meeting && newest.note.meeting.title) || newest.note.title, 160) || 'Untitled meeting';
+  const hold = (e) => !st.done[e.key];
+  const actions = carriedOf(ms, 'actions', OPEN_WINDOW);
+  const open = actions.filter(hold).sort((a, b) => b.seen - a.seen || String(b.last.at).localeCompare(String(a.last.at)));
+  const closed = Object.entries(st.done).filter(([, v]) => v && v.kind === 'action' && now - Date.parse(v.at) <= CLOSED_DAYS * DAY)
+    .map(([k, v]) => ({ key: k, text: v.text, at: v.at })).sort((a, b) => String(b.at).localeCompare(String(a.at)));
+  const questions = carriedOf(ms, 'questions', OPEN_WINDOW).filter(hold).sort((a, b) => String(b.last.at).localeCompare(String(a.last.at)));
+  const decisions = [];
+  for (const m of ms.slice().reverse()) for (const d of m.parts.decisions) decisions.push({ text: d.text, why: d.why, at: m.at, note: m.note.id });
+  const meetings = ms.map((m, i) => {
+    const prev = i > 0 ? new Set(ms[i - 1].parts.actions.map((x) => norm(x.text))) : new Set();
+    return { id: m.note.id, title: clip(m.note.title, 160), at: m.at, ms: m.row.meeting_ms || 0, private: !!m.note.private, by: m.row.series.by,
+      overview: m.parts.overview || (m.row.summary_lines || []).join(' ').slice(0, 300), decisions: m.parts.decisions.length,
+      new_actions: m.parts.actions.filter((x) => !prev.has(norm(x.text))).length };
+  }).reverse();
+  let next = nextOf(key, events, now);
+  if (!next) for (const s of seriesIds) { next = nextOf('s:' + s, events, now); if (next) break; }
+  const derived = [
+    ...open.filter((e) => e.seen >= CARRY_WARN).slice(0, 3).map((e) => ({ kind: 'carried', text: e.text, owner: e.owner, seen: e.seen })),
+    ...questions.filter((e) => e.seen >= 2).slice(0, 2).map((e) => ({ kind: 'question', text: e.text, seen: e.seen })),
+  ];
+  const by = new Set(ms.map((m) => m.row.series.by));
+  return { ok: true, series: {
+    key, title, count: ms.length, since: ms[0].at, joined: { calendar: by.has('calendar'), title: ms.filter((m) => m.row.series.by === 'title').length, pm: ms.filter((m) => m.row.series.by === 'pm').length },
+    about: { portfolio: !!newest.note.portfolio, board: newest.note.board || null, initiative: newest.note.initiative || null },
+    next: next ? { ...next, bring: st.bring, derived } : { bring: st.bring, derived },
+    open, closed, decisions: decisions.slice(0, 60), questions, topics: topicsOf(ms, title), meetings } };
+}
+
+/** A note in its series: where it sits, the meeting before and after, and what changed since the meeting before. */
+function placeOf(dir, id, { now = Date.now(), rows = null } = {}) {
+  const all = rows || rowsOf(dir, now);
+  const r = all.find((x) => x.id === id);
+  if (!r || !r.series) return null;
+  const ms = membersOf(dir, r.series.key, all);
+  if (ms.length < 2) return null;
+  const i = ms.findIndex((m) => m.note.id === id);
+  if (i < 0) return null;
+  const st = entryOf(readStore(dir), r.series.key);
+  const me = ms[i]; const prev = i > 0 ? ms[i - 1] : null; const next = i + 1 < ms.length ? ms[i + 1] : null;
+  const mine = new Set(me.parts.actions.map((x) => norm(x.text)));
+  const before = prev && !prev.note.private ? prev.parts.actions : [];
+  const prevKeys = new Set(before.map((x) => norm(x.text)));
+  const items = before.map((x) => ({ text: x.text, owner: x.owner, state: st.done[norm(x.text)] ? 'done' : mine.has(norm(x.text)) ? 'again' : 'quiet' }));
+  const fresh = me.parts.actions.filter((x) => !prevKeys.has(norm(x.text))).map((x) => ({ text: x.text, owner: x.owner }));
+  // how many meetings up to this one raised each of its actions ("carried · meeting N")
+  const carried = {};
+  for (const x of me.parts.actions) { const k = norm(x.text); const n = ms.slice(0, i + 1).filter((m) => !m.note.private && m.parts.actions.some((y) => norm(y.text) === k)).length; if (n >= 2) carried[k] = n; }
+  const carriedIn = items.filter((x) => x.state !== 'done');
+  const title = clip((ms[ms.length - 1].note.meeting && ms[ms.length - 1].note.meeting.title) || ms[ms.length - 1].note.title, 160);
+  return { key: r.series.key, title, pos: i + 1, count: ms.length, by: r.series.by,
+    prev: prev ? { id: prev.note.id, at: prev.at, overview: prev.note.private ? '' : prev.parts.overview } : null,
+    next: next ? { id: next.note.id, at: next.at } : null,
+    since: prev ? { at: prev.at, items, fresh } : null, carried_in: carriedIn, carried };
+}
+
+/** How many actions each series carries open, for the list's "N open": { key: count }, only for keys with two or more notes. */
+function openCounts(dir, rows) {
+  const by = new Map();
+  for (const r of rows) if (r.series) by.set(r.series.key, (by.get(r.series.key) || 0) + 1);
+  const store = readStore(dir);
+  const out = {};
+  for (const [key, n] of by) {
+    if (n < 2) continue;
+    const st = entryOf(store, key);
+    const open = carriedOf(membersOf(dir, key, rows), 'actions', OPEN_WINDOW).filter((e) => !st.done[e.key]);
+    if (open.length) out[key] = { open: open.length, carried: open.filter((e) => e.seen >= CARRY_WARN).length };
+  }
+  return out;
+}
+
+/* ── search ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** The notes whose text holds every word of `q`: the title always; for a note that is not private, also its overview, final
+ *  notes, typed notes, summary and transcript. */
+function search(dir, q) {
+  const ws = norm(q).split(' ').filter(Boolean);
+  if (!ws.length || norm(q).length < 2) return { ok: true, ids: [] };
+  let names = [];
+  try { names = fs.readdirSync(notes.notesDir(dir)).filter((f) => f.endsWith('.json')); } catch { return { ok: true, ids: [] }; }
+  const ids = [];
+  for (const f of names) {
+    const n = notes.loadCached(dir, f.slice(0, -5));
+    if (!n || !n.id) continue;
+    let hay = n.title || '';
+    if (!n.private) {
+      const fin = n.final_notes || {};
+      const items = (xs) => (Array.isArray(xs) ? xs.map((x) => (x && x.text) || '').join(' ') : '');
+      const sec = (n.summary && n.summary.sections) || {};
+      hay += ' ' + [n.overview_pm, fin.overview, fin.purpose, fin.discussion, items(fin.decisions), items(fin.actions), items(fin.questions), n.body,
+        items(sec.overview), items(sec.decisions), items(sec.actions), items(sec.questions), items(n.bullets), items(n.transcript),
+        n.meeting && n.meeting.title].filter(Boolean).join(' ');
+    }
+    const h = ' ' + norm(hay) + ' ';
+    if (ws.every((w) => h.includes(w))) ids.push(n.id);
+  }
+  return { ok: true, ids };
+}
+
+module.exports = { assign, openCounts, thread, placeOf, search, markDone, bring, unbring, partsOf, topicsOf, carriedOf, nextOf, norm, storeFile,
+  OPEN_WINDOW, TOPIC_WINDOW, TOPIC_MIN, CARRY_WARN };

package/workspace/lib/notes.js

@@ -111,6 +111,19 @@ function load(dir, id) {
   if (!ID_RE.test(String(id || ''))) return null;
   try { return JSON.parse(fs.readFileSync(fileOf(dir, id), 'utf8')); } catch { return null; }
 }
+/* The list's reads (c3-notes-series): a note file is parsed again only when its modified time or size changed, so a list call
+ * with many notes reads only the notes that changed. The cached note is shared: a reader must not change it. */
+const cached = new Map();      // file → { mtimeMs, size, note }
+function loadCached(dir, id) {
+  if (!ID_RE.test(String(id || ''))) return null;
+  const f = fileOf(dir, id);
+  let st; try { st = fs.statSync(f); } catch { cached.delete(f); return null; }
+  const hit = cached.get(f);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.note;
+  const note = load(dir, id);
+  if (note) cached.set(f, { mtimeMs: st.mtimeMs, size: st.size, note }); else cached.delete(f);
+  return note;
+}
 function store(dir, note) { writeAtomic(fileOf(dir, note.id), JSON.stringify(note, null, 1)); }
 const newId = (now) => 'n-' + Math.floor(now).toString(36) + '-' + crypto.randomBytes(2).toString('hex');
 const cleanTitle = (t) => String(t == null ? '' : t).replace(/\s+/g, ' ').trim().slice(0, MAX_TITLE);
@@ -147,13 +160,48 @@ function stateFields(n, now, resumeMs) {
     ended_at: endedAt, ended_by: endedBy, sessions: sessionsOf(n) };
 }
 
+/** The meeting time a row shows: the meeting clock, except that an ended meeting whose recorder ran on for more than
+ * LEFT_ON_MS after the last line heard stops at that line ("1735 min" for a stand-up left recording). */
+const LEFT_ON_MS = 10 * 60 * 1000;
+function heardMs(n, now = Date.now()) {
+  const ms = meetingMs(n, now);
+  if (!n.ended_at && !n.paused_at) return ms;
+  const last = Math.max(0, ...(n.transcript || []).map((x) => (x && Number.isFinite(x.t_end) ? x.t_end : x && Number.isFinite(x.t) ? x.t : 0)));
+  return last > 0 && ms - last > LEFT_ON_MS ? last : ms;
+}
+/** The series a note belongs to (c3-notes-series): the PM's choice (`series_pm`: a key, or 'off' for none), else the calendar
+ * series of its meeting, else the meeting's title, else the note's own title (calendar-memory.js seriesKey and normTitle).
+ * "Untitled note" and a title with no letters belong to none. → { key, by: 'pm'|'calendar'|'title' } or null. Pure. */
+function seriesOf(n) {
+  if (!n) return null;
+  if (n.series_pm === 'off') return null;
+  if (typeof n.series_pm === 'string' && SERIES_KEY_RE.test(n.series_pm)) return { key: n.series_pm, by: 'pm' };
+  const calMem = require('./calendar-memory.js');
+  const m = n.meeting && n.meeting.kind === 'event' ? n.meeting : null;
+  if (m && m.context && m.context.series) return { key: 's:' + m.context.series, by: 'calendar' };
+  const t = calMem.normTitle((m && m.title) || n.title);
+  if (!t || t === 'untitled note' || t === 'untitled') return null;
+  return { key: 't:' + t, by: 'title' };
+}
+const SERIES_KEY_RE = /^[st]:[^\n]{1,200}$/;
+/** Take a note out of its series (key 'off'), put it in one (a key), or go back to the automatic series (null). */
+function setSeries(dir, { id, key } = {}) {
+  const note = load(dir, id);
+  if (!note) return err(404, 'no such note');
+  if (key === null || key === undefined || key === '') delete note.series_pm;
+  else if (key === 'off' || SERIES_KEY_RE.test(String(key))) note.series_pm = String(key);
+  else return err(400, 'that is not a series');
+  store(dir, note);
+  return { ok: true, id: note.id, series: seriesOf(note) };
+}
+
 /** The row a list shows. Never the body or the transcript. */
 function rowOf(n, now = Date.now(), resumeMs = RESUME_MS) {
   return { id: n.id, title: n.title || 'Untitled note', created_at: n.created_at, updated_at: n.updated_at, private: !!n.private,
     words: wordsOf(n.body), segments: (n.transcript || []).length, summary: !!(n.summary || (n.agent && n.agent.markdown)),
-    meeting: n.meeting || null, initiative: n.initiative || null, board: n.board || null, portfolio: !!n.portfolio, ws: n.ws || null,
+    meeting: n.meeting || null, initiative: n.initiative || null, board: n.board || null, portfolio: !!n.portfolio, ws: n.ws || null, series: seriesOf(n),
     // the meeting time so far (a paused note's clock) and how many statements differ from a repository file (the Notes menu)
-    meeting_ms: n.recorded_from ? meetingMs(n) : 0, conflicts: n.private ? 0 : conflictsOf(n).length,
+    meeting_ms: n.recorded_from ? heardMs(n, now) : 0, conflicts: n.private ? 0 : conflictsOf(n).length,
     // a private note shows its title on the calendar and the initiative, never its summary
     summary_lines: n.private ? [] : summaryLines(n), ...stateFields(n, now, resumeMs) };
 }
@@ -299,7 +347,8 @@ function list(dir, { now = Date.now(), resumeMs } = {}) {
   let names = [];
   try { names = fs.readdirSync(notesDir(dir)).filter((f) => f.endsWith('.json')); } catch { return { ok: true, notes: [] }; }
   const notes = [];
-  for (const f of names) { const n = load(dir, f.slice(0, -5)); if (n && n.id) notes.push(rowOf(n, now, resumeOf(resumeMs))); }
+  for (const f of names) { const n = loadCached(dir, f.slice(0, -5)); if (n && n.id) notes.push(rowOf(n, now, resumeOf(resumeMs))); }
+  require('./notes-series.js').assign(notes);
   notes.sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at)) || (a.id < b.id ? 1 : -1));
   return { ok: true, notes };
 }
@@ -1711,7 +1760,7 @@ function editFinal(dir, { id, sec, i, text, field, now = Date.now() } = {}) {
   return { ok: true, final_notes: f };
 }
 
-module.exports = { addHighlight, updateHighlight, removeHighlight, editFinal, conflictsOf, setFinal, setFinalState, renameFinalSpeaker, finalSpeaker, transcriptLines, cleanNotes, notesMarkdown, groundQuote, parseTime, NOTES_SHAPE,
+module.exports = { load, loadCached, heardMs, seriesOf, setSeries, SERIES_KEY_RE, addHighlight, updateHighlight, removeHighlight, editFinal, conflictsOf, setFinal, setFinalState, renameFinalSpeaker, finalSpeaker, transcriptLines, cleanNotes, notesMarkdown, groundQuote, parseTime, NOTES_SHAPE,
   wisprHandoff, wisprPrompt, setWispr, importWispr, notesOutOf, wisprOutOf, list, read, create, link, findByEvent, sameEvent, cleanMeeting, summaryLines, save, remove, record, pause, stop, expire, stateOf, sessionsOf, cleanContext, RESUME_MS, meetingMs, appendTranscript, updateSegment, setLabel, editLine, versionsOf, renameSpeaker, speakerOf, categoryOf, isFact, CATS, PM_CATS, VERSION_FOLD_MS, setPrivate, dictation, cleanSentences, spokenPunctuation,
   summarize, localSummary, agentHandoff, agentStarted, toMarkdown, promptFor, fmtTime, ownerOf, dueOf, ID_RE, notesDir, handoffOf, agentOutOf,
   meetsBar, checkable, vocabOf, termsIn, namesIn, SECTION_CAP, JOIN_GAP_MS,

package/workspace/lib/report-checks.js

@@ -0,0 +1,103 @@
+'use strict';
+/* report-checks.js — the three extra health checks of a report document (initiative report-workspace, PRD section 6).
+ *
+ *   reportChecks(text, { listed }) → [{ id, pass, reason }]     pure: the text and the section names the definition lists
+ *   listedOf(definitionText)       → the section names a definition's frontmatter lists
+ *   isReportPath(rel)              → true for <state>/reports/<cadence>/<slot>.md (not a definition)
+ *
+ * These ride beside the six checks of scripts/doc-health.js (routes-doc-health.js adds them for a document under reports/). Each answers
+ * { id, pass, reason } like those. The text is read; nothing is changed.
+ *   numbers-sourced   Every line with a figure carries its source: a ticket key, a link, a "[reported]"-style label, or "Source:". A date is not a figure.
+ *   dates-in-full     No "next week", "tomorrow", "yesterday" or a short date such as 22/10 or 22 Oct. A date is written as 22 October 2026.
+ *   decisions-risk    "Decisions" and "Risk watch" are present as headings when the definition lists them. Not listed: pass, and the reason says so.
+ */
+// The labels of scripts/releases.js (fact, estimate, assumption, reported), plus the ones a hand-written report uses.
+const LABELS = ['fact', 'estimate', 'assumption', 'reported', 'inferred', 'verified', 'measured', 'forecast', 'source'];
+const MONTHS = 'January|February|March|April|May|June|July|August|September|October|November|December';
+const MON3 = 'Jan|Feb|Mar|Apr|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec';
+
+const body = (text) => String(text || '').replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+const lineOf = (s) => s.trim().replace(/\s+/g, ' ');
+const short = (s) => (s.length > 60 ? s.slice(0, 57) + '...' : s);
+
+/** A line with a figure once every full date, ticket key and link address is taken out. */
+function hasFigure(line) {
+  const t = line
+    .replace(new RegExp(`\\b\\d{1,2} (?:${MONTHS}) \\d{4}\\b`, 'gi'), ' ')
+    .replace(/\b\d{4}-\d{2}-\d{2}\b/g, ' ')
+    .replace(/\b[A-Z][A-Z0-9]+-\d+\b/g, ' ')
+    .replace(/\]\([^)]*\)/g, ']')
+    .replace(/\bD\d{1,3}\b/g, ' ');
+  return /\d/.test(t);
+}
+const hasSource = (line) => /\b[A-Z][A-Z0-9]+-\d+\b/.test(line) || /\]\(https?:\/\/[^)]+\)/.test(line) || new RegExp(`[\\[(](?:${LABELS.join('|')})[\\])]`, 'i').test(line) || /\bsource:/i.test(line);
+
+function numbersSourced(text) {
+  const claims = body(text).split('\n').map(lineOf).filter((l) => l && !/^#/.test(l) && !/^\|?[\s:|-]+\|?$/.test(l) && !/^```/.test(l) && hasFigure(l));
+  if (!claims.length) return { id: 'numbers-sourced', pass: true, reason: 'no line carries a figure' };
+  const bare = claims.filter((l) => !hasSource(l));
+  return bare.length
+    ? { id: 'numbers-sourced', pass: false, reason: `${bare.length} of ${claims.length} line(s) with a figure name no source: ${bare.slice(0, 3).map((l) => `"${short(l)}"`).join(', ')}` }
+    : { id: 'numbers-sourced', pass: true, reason: `${claims.length} line(s) with a figure, all with a source` };
+}
+
+const RELATIVE = /\b(?:tomorrow|yesterday|(?:next|last|this|coming|past) (?:week|month|quarter|friday|monday|tuesday|wednesday|thursday|saturday|sunday)|in (?:a|\d+) (?:day|days|week|weeks)|end of (?:the )?(?:week|month))\b/i;
+const SHORT_DATES = [
+  /\b\d{1,2}\/\d{1,2}(?:\/\d{2})?\b/,                                              // 22/10, 10/22/26
+  new RegExp(`\\b\\d{1,2} (?:${MON3})\\b(?! \\d{4})`),                              // 22 Oct
+  new RegExp(`\\b(?:${MON3}) \\d{1,2}\\b(?!,? \\d{4})`),                            // Oct 22
+  new RegExp(`\\b\\d{1,2} (?:${MONTHS})\\b(?! \\d{4})`),                            // 22 October
+];
+function datesInFull(text) {
+  const bad = [];
+  for (const raw of body(text).split('\n')) {
+    const l = lineOf(raw);
+    if (!l || /^#/.test(l)) continue;
+    const rel = new RegExp(RELATIVE.source, 'gi');
+    for (let m = rel.exec(l); m; m = rel.exec(l)) bad.push(m[0].toLowerCase());
+    for (const re of SHORT_DATES) { const m = re.exec(l); if (m) bad.push(m[0]); }
+  }
+  return bad.length
+    ? { id: 'dates-in-full', pass: false, reason: `${bad.length} date(s) not written in full: ${[...new Set(bad)].slice(0, 4).map((x) => `"${x}"`).join(', ')}` }
+    : { id: 'dates-in-full', pass: true, reason: 'every date is written in full' };
+}
+
+/** The section names a definition lists, lower-case. Reads the frontmatter list only. */
+function listedOf(definitionText) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(String(definitionText || ''));
+  if (!fm) return [];
+  const out = []; let inList = false;
+  for (const raw of fm[1].split(/\r?\n/)) {
+    const inline = /^sections:\s*\[(.*)\]\s*$/.exec(raw);
+    if (inline) return inline[1].split(',').map((x) => x.replace(/["']/g, '').trim().toLowerCase()).filter(Boolean);
+    if (/^sections:\s*$/.test(raw)) { inList = true; continue; }
+    const item = /^\s*-\s+(.*)$/.exec(raw);
+    if (inList && item) { out.push(item[1].replace(/^["']|["']$/g, '').trim().toLowerCase()); continue; }
+    if (inList && /^[A-Za-z_]/.test(raw)) inList = false;
+  }
+  return out;
+}
+
+function decisionsRisk(text, listed) {
+  const list = Array.isArray(listed) ? listed : [];
+  const wantDecisions = list.some((s) => /decid|decision/.test(s));
+  const wantRisk = list.some((s) => /risk/.test(s));
+  if (!wantDecisions && !wantRisk) return { id: 'decisions-risk', pass: true, reason: 'the definition lists neither Decisions nor Risk watch' };
+  const heads = body(text).split('\n').filter((l) => /^#{1,6}\s/.test(l)).map((l) => l.toLowerCase());
+  const missing = [];
+  if (wantDecisions && !heads.some((h) => /decid|decision/.test(h))) missing.push('Decisions');
+  if (wantRisk && !heads.some((h) => /risk/.test(h))) missing.push('Risk watch');
+  return missing.length
+    ? { id: 'decisions-risk', pass: false, reason: `the definition lists ${missing.join(' and ')}, and the document has no such heading` }
+    : { id: 'decisions-risk', pass: true, reason: 'the listed Decisions and Risk watch sections are present' };
+}
+
+function reportChecks(text, { listed } = {}) {
+  return [numbersSourced(text), datesInFull(text), decisionsRisk(text, listed)];
+}
+
+/** <state>/reports/<cadence>/<slot>.md under pmos/state or planning; the definitions folder is not a report. */
+const isReportPath = (rel) => /(?:^|\/)reports\/(?!definitions\/)[a-z][a-z0-9-]{0,39}\/\d{4}-\d{2}-\d{2}\.md$/.test(String(rel || '').replace(/\\/g, '/'));
+const cadenceOfPath = (rel) => { const m = /reports\/([a-z][a-z0-9-]{0,39})\/\d{4}-\d{2}-\d{2}\.md$/.exec(String(rel || '').replace(/\\/g, '/')); return m ? m[1] : null; };
+
+module.exports = { reportChecks, numbersSourced, datesInFull, decisionsRisk, listedOf, isReportPath, cadenceOfPath };