create-pmos 0.178.0 → 0.179.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.178.0",
+  "version": "0.179.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@066089d
+kernel-source: pmos@21b31ef
 assembled: 2026-10-13
 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-13T01:59:58Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T02:06:03Z"}
 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-13T01:59:58Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T02:06:03Z"}
 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-13T01:59:58Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T02:06:03Z"}
 status: stable
 ---
 

package/workspace/guide/console-calendar.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: the Calendar tab of the console page"
 description: "The Calendar tab of the console page (/): Calendar and Notes, the five zooms, the highlights, the layer chips, the markers, the context of a meeting, free time, the tidy-up suggestions and the empty states."
-timestamp: 2026-10-12
+timestamp: 2026-10-13
 ---
 
 # Guide: the Calendar tab of the console page
@@ -13,7 +13,22 @@ The Calendar tab of the console page (`/`) shows time. It shows what happens and
 
 The switch at the start of the bar has two parts. **Calendar** shows the grid. **Notes** shows your notes.
 
-In **Notes**, the list is at the left, under the heading **Notes**. The notes are in groups by what they are about: **Portfolio** first, then one group for each board, in the order of the portfolio. **Not linked** is the last group. A note linked to an initiative from an earlier version, with no board, is in **Initiatives**. In each group, the newest meeting is first. A note with no meeting is placed by when its recording started, or else by when it was made. The number shows how many notes the list shows. Type in **Search notes** to keep only the notes whose title, board, initiative or summary has the words. A row shows when the note was made and its length. In a board group, a row shows its initiative, or **board** when the note is about the whole board. A row also shows **recording** or **paused** while the note is held, **no meeting** when the note has no meeting, and a warning mark when a statement differs from a file.
+In **Notes**, the list is at the left, under the heading **Notes**. The notes are in groups by what they are about: **Portfolio** first, then one group for each board, in the order of the portfolio. **Not linked** is the last group. A note linked to an initiative from an earlier version, with no board, is in **Initiatives**. In each group, the newest meeting is first. A note with no meeting is placed by when its recording started, or else by when it was made. The number shows how many notes the list shows. Type in **Search notes** to keep only the notes that have every word. The search reads the title, the board, the initiative, the summary, the decisions, the next steps and what was said. A private note is found by its title only. A row shows when the note was made and its length. In a board group, a row shows its initiative, or **board** when the note is about the whole board. A row also shows **recording** or **paused** while the note is held, **no meeting** when the note has no meeting, and a warning mark when a statement differs from a file.
+
+Notes of one regular meeting are a **series**: the same calendar series, or the same title. A series is one row. The row shows how many meetings it has, and how many next steps are still open. Press the arrow on the row to show its last three meetings. Press the row to open the series at the right. Notes older than 30 days fold into **Older than 30 days** at the end of each group. Press it to show them. A recorder left on after the meeting shows its length up to the last line heard, not up to when it stopped.
+
+The series page shows what carries from one meeting to the next:
+
+- **Next one** shows the next meeting of the series and what to bring up: the next steps still open after several meetings, the questions asked in several meetings, and your own lines. Type in **Add something to bring up** and press `Enter` to add a line. Press the cross to remove it.
+- **Still open** shows each next step not yet done, its owner, the number of meetings it was raised in, and when it was last heard. Press **Done** when it is done. It stops carrying over. **Open again** puts it back.
+- **Decided so far** shows each decision of the series, newest first, with why.
+- **Keeps coming up** shows the topics heard in several meetings.
+- **Still unanswered** shows the open questions. Press **Answered** when a question has its answer.
+- **Every meeting** shows each note of the series with its gist. Press one to open it.
+
+A private note adds its title and date to the series, and nothing else.
+
+A note in a series shows the series and its place, for example `IDPF - DSU · 21 of 21`. Press it to open the series. The arrows open the meeting before and the meeting after. **After** shows **Since the last one** first: each next step of the meeting before, as **Done**, **Raised again** or **Not mentioned**, then the new next steps. Press **Not part of this series** to take a note out of its series. Press **Add to a series** to put it in one.
 
 Press a row to open the note at the right. The note has three stages. Press **Before**, **During** or **After** to change the stage.
 

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/routes-notes.js

@@ -63,6 +63,13 @@
  *   POST /api/notes/wispr-fetch { id }    → { ok, wispr }   the PM asks for Wispr Flow's notes now, after the automatic fetch failed or
  *                                                   found nothing; the agent session is asked at once and again every two minutes for up to 20 minutes
  *   POST /api/notes/final-edit { id, sec: 'overview'|'decision'|'action'|'question', i?, text, field?: 'owner'|'due'|'why' } → { ok, final_notes }   the PM's correction
+ *   GET /api/notes also answers `series_open`: { <series key>: { open, carried } }, the actions each meeting series carries open.
+ *   GET  /api/notes/series?key=     → { ok, series }   one regular meeting's notes together (lib/notes-series.js thread)
+ *   GET  /api/notes/search?q=       → { ok, ids }      the notes whose title, notes or transcript hold every word (a private note: its title)
+ *   POST /api/notes/series-done { key, text, kind: 'action'|'question', done? } → { ok }   the PM marks a carried action done, a question answered
+ *   POST /api/notes/series-bring { key, text } → { ok, line } · POST /api/notes/series-unbring { key, id } → { ok }   lines to bring up next time
+ *   POST /api/notes/series-member { id, key: '<series key>'|'off'|null } → { ok, series }   put a note in a series, take it out, or back to automatic
+ *   GET /api/notes/one also answers `place`: the note's series, its position, the meeting before and after, and Since the last one.
  *
  * Notes are the PM's own and live in the per-user runtime directory (ctx.runtimeDir), never in a repository, so no route here
  * writes into a registered workspace. Every POST goes through pm-guard `requirePagePress` (a body that is not an object or carries
@@ -81,6 +88,7 @@
  */
 const guard = require('./pm-guard.js');
 const notes = require('./notes.js');
+const notesSeries = require('./notes-series.js');
 const whisper = require('./notes-whisper.js');
 const notesCapture = require('./notes-capture.js');
 const notesRepo = require('./notes-repo.js');
@@ -103,7 +111,7 @@ const VOCAB_TTL_MS = 60 * 1000;
 const prefixes = ['/api/notes'];
 const POSTS = new Set(['/api/notes/new', '/api/notes/save', '/api/notes/dictate', '/api/notes/record', '/api/notes/transcript',
   '/api/notes/private', '/api/notes/pause', '/api/notes/stop', '/api/notes/summarize', '/api/notes/summarize-agent', '/api/notes/delete', '/api/notes/audio', '/api/notes/label',
-  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/screen', '/api/notes/screen-delete', '/api/notes/clean-audio', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch']);
+  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/screen', '/api/notes/screen-delete', '/api/notes/clean-audio', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch', '/api/notes/series-done', '/api/notes/series-bring', '/api/notes/series-unbring', '/api/notes/series-member']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
 const chains = new Map();      // note id → the promise of its work so far (minute batches, imports, labels, checks)
@@ -673,7 +681,11 @@ async function handle(req, res, url, ctx) {
   if (resumedFor !== dir) { try { resumeStuck(ctx); } catch { /* a note that cannot be picked up stays as it was */ } }
   if (p === '/api/notes' || p === '/api/notes/one') {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
-    if (p === '/api/notes') { const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) }); if (l.ok) sweepExpired(ctx, l.notes); send(ctx, res, l); return true; }
+    if (p === '/api/notes') {
+      const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) });
+      if (l.ok) { sweepExpired(ctx, l.notes); try { l.series_open = notesSeries.openCounts(dir, l.notes); } catch { l.series_open = {}; } }
+      send(ctx, res, l); return true;
+    }
     const nid = url.searchParams.get('id');
     // the bullets the agent wrote since the last read; Jev labels and checks them after the note's earlier work
     const imp = notes.importBullets(dir, { id: nid });
@@ -688,10 +700,18 @@ async function handle(req, res, url, ctx) {
       r.screen = { frames: r.note.private ? [] : notesScreen.list(dir, nid) };
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
       r.bullets_state = bulletsState(ctx, r.note);
+      // where the note sits in its meeting series, and what changed since the meeting before (c3-notes-series)
+      try { r.place = notesSeries.placeOf(dir, nid); } catch { r.place = null; }
     }
     send(ctx, res, r);
     return true;
   }
+  if (p === '/api/notes/series' || p === '/api/notes/search') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    if (p === '/api/notes/search') { send(ctx, res, notesSeries.search(dir, url.searchParams.get('q') || '')); return true; }
+    send(ctx, res, notesSeries.thread(dir, url.searchParams.get('key') || ''));
+    return true;
+  }
   if (p === '/api/notes/screen' && (req.method === 'GET' || req.method === 'HEAD')) {
     const nid = url.searchParams.get('id');
     const r = notes.read(dir, nid);
@@ -748,6 +768,11 @@ async function handle(req, res, url, ctx) {
     if (r.ok) r.reused = false;
     return done(r);
   }
+  // the meeting series (c3-notes-series): the PM's marks and lines per series, and which series a note is in
+  if (p === '/api/notes/series-done') return done(notesSeries.markDone(dir, { key: body.key, text: body.text, kind: body.kind, done: body.done !== false }));
+  if (p === '/api/notes/series-bring') return done(notesSeries.bring(dir, { key: body.key, text: body.text }));
+  if (p === '/api/notes/series-unbring') return done(notesSeries.unbring(dir, { key: body.key, id: body.id }));
+  if (p === '/api/notes/series-member') return done(notes.setSeries(dir, { id, key: body.key }));
   // from_event: the initiative is the calendar event's own, and never replaces the PM's choice
   if (p === '/api/notes/link') return done(notes.link(dir, { id, meeting: body.meeting, initiative: body.initiative, board: body.board, portfolio: typeof body.portfolio === 'boolean' ? body.portfolio : undefined, by: body.from_event === true ? 'event' : 'pm' }));
   if (p === '/api/notes/dictate') return done(notes.dictation(body.text));

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.178.0",
+  "version": "0.179.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-notes.js

@@ -64,14 +64,15 @@ const transcriptOf = (n) => (n.final && n.final.segments && n.final.segments.len
 
 /** The notes state on the calendar instance r. */
 function stateOf(r) {
-  if (!r.notes) r.notes = { box: el('div', { class: 'cal3-notes', 'data-cal3': 'notes' }), rows: null, err: null, open: null, note: null, phase: null, q: '', seq: 0, live: null, unsub: null };
+  if (!r.notes) r.notes = { box: el('div', { class: 'cal3-notes', 'data-cal3': 'notes' }), rows: null, err: null, open: null, note: null, phase: null, q: '', seq: 0, live: null, unsub: null,
+    ser: null, thread: null, place: null, expand: new Set(), older: new Set(), found: null, every: false, open_by: {} };
   return r.notes;
 }
 
 /** The note the Calendar shows next: from the Record chip (phase During) or a meeting's detail (its default stage). */
 export function openNote(r, id, phase) {
   const s = stateOf(r);
-  s.open = id; s.note = null; s.phase = phase || null;
+  s.open = id; s.note = null; s.phase = phase || null; s.ser = null; s.thread = null;
   r.page = r.page || null;
   if (r.page) r.page.mode = 'notes';
   else r.pendingMode = 'notes';
@@ -92,18 +93,25 @@ export function notesView(ui) {
   s.ui = ui;
   if (!s.unsub) s.unsub = onNotes(() => { if (s.box.isConnected) read(s); });
   if (!s.boards) loadBoards(s);
-  if (!s.rows || (s.open && (!s.note || s.note.id !== s.open))) read(s);
+  if (!s.rows || (s.open && (!s.note || s.note.id !== s.open)) || (s.ser && (!s.thread || s.thread.key !== s.ser))) read(s);
   draw(s);
   return s.box;
 }
 
 async function read(s) {
   const seq = ++s.seq;
-  const [l, one] = await Promise.all([pmGet('/api/notes'), s.open ? pmGet('/api/notes/one?id=' + encodeURIComponent(s.open)) : null]);
+  const ser = s.ser;
+  const [l, one, th] = await Promise.all([pmGet('/api/notes'), !ser && s.open ? pmGet('/api/notes/one?id=' + encodeURIComponent(s.open)) : null,
+    ser ? pmGet('/api/notes/series?key=' + encodeURIComponent(ser)) : null]);
   if (seq !== s.seq) return;
-  if (l && l.ok) { s.rows = l.notes || []; s.err = null; } else { s.rows = s.rows || []; s.err = (l && l.error) || 'The notes could not be read.'; }
+  if (l && l.ok) { s.rows = l.notes || []; s.open_by = l.series_open || {}; s.err = null; } else { s.rows = s.rows || []; s.err = (l && l.error) || 'The notes could not be read.'; }
+  if (ser) {
+    if (th && th.ok && th.series) s.thread = th.series;
+    else { s.ser = null; s.thread = null; toast('That meeting series could not be read' + (th && th.error ? ': ' + th.error : '.')); }
+    draw(s); return;
+  }
   if (!s.open && s.rows.length) { s.open = s.rows[0].id; return read(s); }
-  if (one && one.ok && one.note && one.note.id === s.open) { s.note = one.note; s.shots = (one.screen && one.screen.frames) || []; s.rec = one.recording || null; }
+  if (one && one.ok && one.note && one.note.id === s.open) { s.note = one.note; s.shots = (one.screen && one.screen.frames) || []; s.rec = one.recording || null; s.place = one.place || null; }
   draw(s);
 }
 
@@ -114,9 +122,15 @@ async function loadBoards(s) {
   if (r && r.ok && Array.isArray(r.boards)) { s.boards = r.boards.filter((b) => b && b.id && !b.error); if (s.box.isConnected) draw(s); }
 }
 
-function choose(s, id) {
-  if (s.open === id) return;
-  s.open = id; s.note = null; s.phase = null; s.shots = []; s.rec = null;
+function choose(s, id, phase) {
+  if (s.open === id && !s.ser) return;
+  s.open = id; s.note = null; s.phase = phase || null; s.shots = []; s.rec = null; s.place = null; s.ser = null; s.thread = null;
+  draw(s); read(s);
+}
+/* open a meeting series on the right (the series page) */
+function chooseSeries(s, key) {
+  if (s.ser === key) return;
+  s.ser = key; s.thread = null; s.every = false; s.note = null; s.open = null; s.place = null;
   draw(s); read(s);
 }
 
@@ -127,61 +141,135 @@ function draw(s) {
   if (active && s.box.contains(active) && active.matches('textarea, [contenteditable="true"]') && !active.closest('[data-nt-part="live"]')) return;
   const q = s.box.querySelector('[data-cal3-notes="search"]');
   const typing = !!q && active === q; const caret = typing ? q.selectionStart : null;
-  s.box.replaceChildren(el('div', { class: 'cal3-nwrap' }, listCard(s), noteCol(s)));
+  s.box.replaceChildren(el('div', { class: 'cal3-nwrap' }, listCard(s), s.ser ? seriesCol(s) : noteCol(s)));
   s.drawn = true;
   if (typing) { const nq = s.box.querySelector('[data-cal3-notes="search"]'); if (nq) { nq.focus(); nq.setSelectionRange(caret, caret); } }
 }
 
 /* ── the list ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
 
+const OLD_DAYS = 30;
+const SEARCH_MIN = 2;
+const seriesKeyOf = (r) => (r && r.series ? r.series.key : null);
+
 function listCard(s) {
   const qtext = s.q.trim().toLowerCase();
+  const found = s.found && s.found.q === qtext ? s.found.ids : null;
   const shown = (s.rows || []).filter((r) => !qtext || String(r.title || '').toLowerCase().includes(qtext) || pathOf(r).some((x) => String(x).toLowerCase().includes(qtext))
-    || (r.summary_lines || []).some((x) => String(x).toLowerCase().includes(qtext)));
-  const search = el('input', { type: 'text', class: 'cal3-nsearch', placeholder: 'Search notes', 'aria-label': 'Search notes', value: s.q, 'data-cal3-notes': 'search' });
-  search.addEventListener('input', () => { s.q = search.value; draw(s); });
+    || (r.summary_lines || []).some((x) => String(x).toLowerCase().includes(qtext)) || (found && found.has(r.id)));
+  const search = el('input', { type: 'text', class: 'cal3-nsearch', placeholder: 'Search notes, decisions, what was said', 'aria-label': 'Search notes', value: s.q, 'data-cal3-notes': 'search' });
+  search.addEventListener('input', () => { s.q = search.value; draw(s); findLater(s); });
   let body;
   if (!s.rows) body = fold('clock', 'Reading the notes', { role: 'status' });
   else if (!s.rows.length) body = fold('mic', s.err || 'No notes yet. Press Record at the top right to start one.', { 'data-cal3-notes': 'none' });
-  else if (!shown.length) body = fold('search', 'No note matches “' + s.q.trim() + '”.', { 'data-cal3-notes': 'no-match' });
-  else body = scopeGroups(s, shown).map((g) => el('div', { class: 'cal3-ctx', 'data-cal3-notes-group': g.label }, el('h4', null, g.label),
-    el('ul', { class: 'list', role: 'list' }, g.rows.map((r) => noteRow(s, r)))));
+  else if (!shown.length) body = fold('search', qtext.length >= SEARCH_MIN && !found ? 'Searching the notes' : 'No note matches “' + s.q.trim() + '”.', { 'data-cal3-notes': 'no-match' });
+  else body = scopeGroups(s, shown).map((g) => {
+    const old = qtext ? [] : g.entries.filter((e) => isOld(e));
+    const recent = qtext ? g.entries : g.entries.filter((e) => !isOld(e));
+    const open = s.older.has(g.key);
+    const olderN = old.reduce((t, e) => t + e.rows.length, 0);
+    const rows = [...recent.flatMap((e) => entryRows(s, e, !!qtext)), ...(open ? old.flatMap((e) => entryRows(s, e, false)) : [])];
+    if (old.length) rows.push(el('li', { class: 'nrow cal3-nmore' }, btn('chip2 lk', { 'data-cal3-notes': 'older', 'aria-expanded': String(open) },
+      open ? 'Hide the older notes' : [c3ic('clock', 'sm'), 'Older than ' + OLD_DAYS + ' days · ' + olderN + (olderN === 1 ? ' note' : ' notes')],
+      () => { if (open) s.older.delete(g.key); else s.older.add(g.key); draw(s); })));
+    return el('div', { class: 'cal3-ctx', 'data-cal3-notes-group': g.label }, el('h4', null, g.label), el('ul', { class: 'list', role: 'list' }, rows));
+  });
   return el('section', { class: 'card sect', 'data-cal3-notes': 'list', 'aria-label': 'Notes' },
     el('div', { class: 'sh2' }, el('h2', null, c3ic('notes', 'sm'), 'Notes ', el('span', { class: 'bdg g', 'data-cal3-notes': 'count' }, String(shown.length)))),
     el('div', { class: 'cal3-nsearchw' }, search), body);
 }
+const isOld = (e) => { const t = Date.parse(startOf(e.rows[0])); return Number.isFinite(t) && Date.now() - t > OLD_DAYS * 86400000 && !e.rows.some((r) => held(r.id) || r.state === 'recording' || r.state === 'paused'); };
+
+/* search the notes' text on the server (GET /api/notes/search), a moment after the last key */
+function findLater(s) {
+  clearTimeout(s.findT);
+  const q = s.q.trim().toLowerCase();
+  if (q.length < SEARCH_MIN) { s.found = null; return; }
+  s.findT = setTimeout(async () => {
+    const r = await pmGet('/api/notes/search?q=' + encodeURIComponent(q));
+    if (s.q.trim().toLowerCase() !== q) return;
+    s.found = { q, ids: new Set(r && r.ok && Array.isArray(r.ids) ? r.ids : []) };
+    if (s.box.isConnected) draw(s);
+  }, 220);
+}
 
 /* the list's groups: Portfolio, each board in the portfolio's order (a board it does not list goes after them by name), an
- * initiative linked before boards were (no board on the note) under "Initiatives", then "Not linked"; in a group, the newest
- * meeting (or recording) first */
+ * initiative linked before boards were (no board on the note) under "Initiatives", then "Not linked". The notes of one meeting
+ * series (lib/notes-series.js, two or more notes with one key) are one entry, in the group of their newest note. In a group,
+ * the newest meeting (or recording) first. → [{ key, label, entries: [{ key, rows (newest first) }] }] */
 function scopeGroups(s, rows) {
   const order = new Map((s.boards || []).map((b, i) => [boardKey(b), i]));
   const known = new Map((s.boards || []).map((b) => [boardKey(b), b.name || b.id]));
-  const g = new Map();
+  const t = (r) => Date.parse(startOf(r)) || 0;
+  const all = (s.rows || []);
+  const size = new Map();
+  for (const r of all) { const k = seriesKeyOf(r); if (k) size.set(k, (size.get(k) || 0) + 1); }
+  const entries = new Map();
   for (const r of rows) {
+    const k = seriesKeyOf(r);
+    const ek = k && size.get(k) >= 2 ? 'S' + k : 'N' + r.id;
+    if (!entries.has(ek)) entries.set(ek, { key: ek, series: ek[0] === 'S' ? k : null, rows: [], size: k ? size.get(k) : 1 });
+    entries.get(ek).rows.push(r);
+  }
+  const g = new Map();
+  for (const e of entries.values()) {
+    e.rows.sort((a, b) => t(b) - t(a));
+    const r = e.rows[0];
     const k = r.portfolio ? '@portfolio' : r.board ? boardKey(r.board) : r.initiative ? '@initiative' : '';
-    if (!g.has(k)) g.set(k, { key: k, label: k === '@portfolio' ? 'Portfolio' : k === '@initiative' ? 'Initiatives' : !k ? 'Not linked' : known.get(k) || boardName(r.board), rows: [] });
-    g.get(k).rows.push(r);
+    if (!g.has(k)) g.set(k, { key: k, label: k === '@portfolio' ? 'Portfolio' : k === '@initiative' ? 'Initiatives' : !k ? 'Not linked' : known.get(k) || boardName(r.board), entries: [] });
+    g.get(k).entries.push(e);
   }
   // the server lists notes by when they were last edited; a group reads newest meeting first
-  for (const x of g.values()) x.rows.sort((a, b) => (Date.parse(startOf(b)) || 0) - (Date.parse(startOf(a)) || 0));
+  for (const x of g.values()) x.entries.sort((a, b) => t(b.rows[0]) - t(a.rows[0]));
   const rank = (x) => (x.key === '@portfolio' ? [0, 0] : x.key === '@initiative' ? [3, 0] : !x.key ? [4, 0] : order.has(x.key) ? [1, order.get(x.key)] : [2, 0]);
   return [...g.values()].sort((a, b) => { const p = rank(a); const q = rank(b); return p[0] - q[0] || p[1] - q[1] || a.label.localeCompare(b.label); });
 }
 
-function noteRow(s, r) {
+/* the rows an entry draws: a note's row, or a series row with its newest meetings under it when open (or matching a search) */
+function entryRows(s, e, searching) {
+  if (!e.series) return [noteRow(s, e.rows[0])];
+  const open = s.expand.has(e.series) || searching;
+  const out = [seriesRow(s, e, open)];
+  if (!open) return out;
+  const shown = e.rows.slice(0, 3);
+  out.push(...shown.map((r) => noteRow(s, r, true)));
+  const more = (searching ? e.rows.length : e.size) - shown.length;
+  if (more > 0) out.push(el('li', { class: 'nrow cal3-nsub cal3-nmore' }, btn('chip2 lk', { 'data-cal3-notes': 'series-all' },
+    searching ? more + ' more matching in the series' : 'All ' + e.size + ' meetings in the series', () => chooseSeries(s, e.series))));
+  return out;
+}
+
+function seriesRow(s, e, open) {
+  const r = e.rows[0];
+  const on = s.ser === e.series;
+  const o = s.open_by[e.series];
+  const title = (r.meeting && r.meeting.kind === 'event' && r.meeting.title) || r.title || 'Untitled meeting';
+  return el('li', { class: 'nrow cal3-nrow cal3-nser' + (on ? ' on' : ''), 'data-cal3-series': e.series },
+    el('span', { class: 'ki' }, c3ic('notes')),
+    btn('cal3-nopen', { title: 'Open the series ' + title, 'aria-current': on ? 'true' : 'false' }, [
+      el('span', { class: 'tt' }, title),
+      el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, whenShort(startOf(r)) + ' · ' + e.size + ' meetings'),
+        el('span', { class: 'tag', title: 'A regular meeting: its notes are kept together' }, 'series'),
+        o ? el('span', { class: 'st ' + (o.carried ? 'warn' : 'unt'), title: o.open + (o.open === 1 ? ' action is' : ' actions are') + ' carried from meeting to meeting', 'data-cal3-notes': 'series-open' }, c3ic(o.carried ? 'alert' : 'todo', 'sm'), o.open + ' open') : null)],
+    () => chooseSeries(s, e.series)),
+    btn('ib sm', { 'data-cal3-notes': 'series-x', 'aria-expanded': String(open), title: open ? 'Hide its recent meetings' : 'Show its recent meetings', 'aria-label': open ? 'Hide recent meetings' : 'Show recent meetings' },
+      c3ic(open ? 'fold' : 'next', 'sm'), () => { if (s.expand.has(e.series)) s.expand.delete(e.series); else s.expand.add(e.series); draw(s); }));
+}
+
+function noteRow(s, r, sub) {
   const mode = held(r.id) || (r.state === 'recording' || r.state === 'paused' ? r.state : null);
-  const on = s.open === r.id;
+  const on = s.open === r.id && !s.ser;
   const len = mins(r.meeting_ms || 0);
-  return el('li', { class: 'nrow cal3-nrow' + (on ? ' on' : ''), 'data-cal3-note-row': r.id },
+  const gist = sub ? (r.summary_lines || [])[0] : null;
+  return el('li', { class: 'nrow cal3-nrow' + (on ? ' on' : '') + (sub ? ' cal3-nsub' : ''), 'data-cal3-note-row': r.id },
     el('span', { class: 'ki' + (mode ? ' hot' : '') }, c3ic(mode ? 'mic' : 'doc')),
     btn('cal3-nopen', { title: 'Open ' + (r.title || 'Untitled note'), 'aria-current': on ? 'true' : 'false' }, [
-      el('span', { class: 'tt' }, r.title || 'Untitled note'),
-      el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, [mode ? 'now' : whenShort(startOf(r)), len].filter(Boolean).join(' · ')),
+      el('span', { class: 'tt' }, gist || r.title || 'Untitled note'),
+      el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, [mode ? 'now' : sub ? dayOf(startOf(r)) : whenShort(startOf(r)), len].filter(Boolean).join(' · ')),
         mode ? el('span', { class: 'tag', 'data-cal3-notes': 'live' }, mode === 'paused' ? 'paused' : 'recording')
-          : r.initiative ? el('span', { class: 'chip2', title: 'Initiative', 'data-cal3-notes': 'row-initiative' }, c3ic('init', 'sm'), iniName(r.initiative))
+          : sub ? null : r.initiative ? el('span', { class: 'chip2', title: 'Initiative', 'data-cal3-notes': 'row-initiative' }, c3ic('init', 'sm'), iniName(r.initiative))
             : r.board ? el('span', { class: 'tag', title: 'Linked to the board, not to one initiative', 'data-cal3-notes': 'row-board' }, 'board') : null,
-        !linked(r) && !mode ? el('span', { class: 'tag', title: 'Not linked to a meeting', 'data-cal3-notes': 'no-meeting' }, 'no meeting') : null,
+        !linked(r) && !mode && !sub ? el('span', { class: 'tag', title: 'Not linked to a meeting', 'data-cal3-notes': 'no-meeting' }, 'no meeting') : null,
         r.conflicts ? el('span', { class: 'st warn', title: r.conflicts + (r.conflicts === 1 ? ' statement differs' : ' statements differ') + ' from a file' }, c3ic('alert', 'sm'), String(r.conflicts)) : null)],
     () => choose(s, r.id)),
     el('span'));
@@ -206,8 +294,8 @@ function noteCol(s) {
       [dayOf(startOf(n)), len].filter(Boolean).join(' · '),
       btn('ib sm', { title: 'Copy as Markdown (with the meeting context)', 'aria-label': 'Copy as Markdown', 'data-cal3-notes': 'copy' }, c3ic('clip'), () => copy(n)),
       btn('ib sm', { title: 'Delete this note', 'aria-label': 'Delete note', 'data-cal3-notes': 'delete' }, c3ic('trash'), () => remove(s, n))),
-    links(s, n, ev));
-  const body = ph === 'before' ? before(s, n) : ph === 'during' ? during(s, n, mode) : after(s, n, mode);
+    links(s, n, ev), seriesLine(s, n));
+  const body = ph === 'before' ? before(s, n) : ph === 'during' ? during(s, n, mode) : [sinceCard(s, n), after(s, n, mode)].filter(Boolean);
   return el('div', { class: 'cal3-ncol', 'data-cal3-notes': 'note', 'data-cal3-note': n.id, 'data-cal3-stage': ph }, head, ...[].concat(body));
 }
 
@@ -309,12 +397,13 @@ function before(s, n) {
   const ev = n.meeting && n.meeting.kind === 'event' ? n.meeting : null;
   const h3 = el('h3', null, c3ic('spark'), 'Before the meeting');
   if (!ev) {
-    return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3,
+    return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3, ...carriedIn(s.place),
       fold('info', n.meeting && n.meeting.kind === 'adhoc' ? 'A meeting that is not on the calendar, so nothing was prepared for it.' : 'Not linked to a meeting, so nothing was prepared. Link it to a meeting to bring in its people and agenda.', { 'data-cal3-notes': 'no-meeting-before' }),
       linkButtons(s, n));
   }
   const c = ev.context || null;
   const lines = transcriptOf(n).map((x) => ({ t: x.t, text: x.text }));
+  const pl = s.place && s.place.key ? s.place : null;
   const heard = c ? agendaHeard(c, lines) : [];
   const rows = [];
   const isHeard = (i) => heard[i] !== null && heard[i] !== undefined;
@@ -331,7 +420,7 @@ function before(s, n) {
   rows.push(prepRow('cal', 'Meeting', [ev.title, when, c && c.where ? 'where: ' + c.where : null, c && c.organizer ? 'organizer: ' + c.organizer : null,
     c && c.series ? 'series: ' + c.series : null, c && c.role ? 'your role: ' + c.role : null, c && c.external ? 'with people outside the company' : null,
     c && c.attendees && names.length ? c.attendees + ' attendees' : null].filter(Boolean).join(' · ')));
-  return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3, ...rows,
+  return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3, ...carriedIn(pl), ...rows,
     c ? null : el('p', { class: 'dim cal3-sm' }, 'The calendar gave no more about this meeting.'));
 }
 
@@ -392,7 +481,7 @@ function after(s, n, mode) {
   if (p.actions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'actions' }, el('thead', null, el('tr', null, el('th', null, 'Next step'), el('th', null, 'Owner'), el('th', null, 'Due'), el('th'))),
     el('tbody', null, p.actions.map((a) => el('tr', { 'data-cal3-notes': 'action' }, cell(a, 'text', 'Next step'),
       cell(a, 'owner', 'Owner', 'No owner'), cell(a, 'due', 'Due', 'No date'),
-      el('td', { class: 'cal3-tdr' }, btn('chip2 lk', { 'data-cal3-notes': 'make-task', title: n.initiative ? 'Add this step to ' + iniName(n.initiative) + ' as a plan item' : 'Link the note to an initiative first' },
+      el('td', { class: 'cal3-tdr' }, carriedTag(s, a), btn('chip2 lk', { 'data-cal3-notes': 'make-task', title: n.initiative ? 'Add this step to ' + iniName(n.initiative) + ' as a plan item' : 'Link the note to an initiative first' },
         [c3ic('plus', 'sm'), 'Make task'], (e) => makeTask(n, a, { btn: e.currentTarget }))))))));
   if (p.questions.length) kids.push(el('div', { class: 'cal3-ctx', 'data-cal3-notes': 'questions' }, el('h4', null, 'Open questions'),
     el('ul', { class: 'cal3-cl', role: 'list' }, p.questions.map((x) => el('li', { class: 'cal3-ci' }, el('span', { class: 'tag' }, 'Question'), el('span', { class: 'cal3-ct' }, x.text))))));
@@ -465,6 +554,182 @@ async function remove(s, n) {
   read(s);
 }
 
+/* ── a meeting series (initiative c3-notes-series) ────────────────────────────────────────────────────────────────── */
+
+/* the words of an item, as lib/notes-series.js norm() matches them */
+const normItem = (t) => String(t || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+const plural = (n, one, many) => n + ' ' + (n === 1 ? one : many || one + 's');
+const sect = (name, ic, title, count, kids) => el('section', { class: 'card sect', 'data-cal3-series-card': name },
+  el('div', { class: 'sh2' }, el('h2', null, c3ic(ic, 'sm'), title, count !== null && count !== undefined ? el('span', { class: 'bdg g' }, String(count)) : null)), kids);
+
+/* "carried · meeting N": the step was raised in N meetings of the series up to this one */
+function carriedTag(s, a) {
+  const k = s.place && s.place.carried ? s.place.carried[normItem(a.text)] : 0;
+  return k ? el('span', { class: 'st ' + (k >= 3 ? 'warn' : 'unt'), title: 'Raised in ' + k + ' meetings of this series', 'data-cal3-notes': 'carried' }, 'carried · meeting ' + k) : null;
+}
+
+/* Before: what was still open coming in from the meeting before */
+function carriedIn(pl) {
+  if (!pl || !pl.prev) return [];
+  return [prepRow('notes', 'Carried in from ' + dayOf(pl.prev.at), pl.prev.overview || 'The meeting before in this series.'),
+    ...(pl.carried_in || []).map((x) => prepRow('todo', x.text, x.owner || 'No owner'))];
+}
+
+/* the head's series line: the meeting before, "IDPF - DSU · 4 of 21" (opens the series), the meeting after, and Take out;
+ * a note in no series offers Add to a series, and one taken out offers to go back */
+function seriesLine(s, n) {
+  const pl = s.place;
+  if (pl && pl.key) {
+    const go = (x, ic, label) => { const b = btn('ib sm', { 'data-cal3-notes': 'series-' + label, title: x ? 'The meeting ' + (label === 'prev' ? 'before' : 'after') + ', ' + dayOf(x.at) : 'None ' + (label === 'prev' ? 'before' : 'after'), 'aria-label': label === 'prev' ? 'The meeting before' : 'The meeting after' }, c3ic(ic, 'sm'), () => { if (x) choose(s, x.id, s.phase); }); if (!x) b.disabled = true; return b; };
+    return el('div', { class: 'chips2 cal3-sm cal3-nserl', 'data-cal3-notes': 'series-line' }, go(pl.prev, 'prev', 'prev'),
+      btn('chip2 lk', { 'data-cal3-notes': 'series-open-page', title: 'Open the series: what is still open, decided and coming up' }, [c3ic('notes', 'sm'), pl.title + ' · ' + pl.pos + ' of ' + pl.count], () => chooseSeries(s, pl.key)),
+      go(pl.next, 'next', 'next'),
+      btn('chip2 lk', { 'data-cal3-notes': 'series-out', title: 'This note is not a meeting of this series' }, 'Not part of this series', () => member(s, n, 'off')));
+  }
+  if (n.series_pm === 'off') return el('div', { class: 'chips2 cal3-sm cal3-nserl', 'data-cal3-notes': 'series-line' }, c3ic('notes', 'sm'), el('span', { class: 'dim' }, 'Taken out of its series'),
+    btn('chip2 lk', { 'data-cal3-notes': 'series-back' }, 'Put it back', () => member(s, n, null)));
+  const size = new Map();
+  for (const r of s.rows || []) { const k = seriesKeyOf(r); if (k) size.set(k, (size.get(k) || [])); if (k) size.get(k).push(r); }
+  const series = [...size.entries()].filter(([, rs]) => rs.length >= 2 && !rs.some((r) => r.id === n.id));
+  if (!series.length || n.private) return null;
+  const b = btn('chip2 lk', { 'data-cal3-notes': 'series-add', title: 'Keep this note with the notes of a regular meeting' }, [c3ic('notes', 'sm'), 'Add to a series'], () => {
+    menu({ anchor: b, ariaLabel: 'Add to a series', items: series.map(([k, rs]) => {
+      const r = rs.slice().sort((x, y) => (Date.parse(startOf(y)) || 0) - (Date.parse(startOf(x)) || 0))[0];
+      const title = (r.meeting && r.meeting.kind === 'event' && r.meeting.title) || r.title || 'Untitled meeting';
+      return { label: title, detail: plural(rs.length, 'meeting'), iconNode: icon('notes'), attrs: { 'data-cal3-series-pick': k }, onSelect: () => member(s, n, k) };
+    }) });
+  });
+  return el('div', { class: 'chips2 cal3-sm cal3-nserl', 'data-cal3-notes': 'series-line' }, b);
+}
+async function member(s, n, key) {
+  const r = await pmPost('/api/notes/series-member', { id: n.id, key });
+  if (!r || !r.ok) { toast('Not saved' + ((r && r.error) ? ': ' + r.error : '')); return; }
+  toast(key === 'off' ? 'Taken out of the series.' : key ? 'Added to the series.' : 'Back in its series.');
+  n.series_pm = key || undefined;
+  refreshNotes();
+  read(s);
+}
+
+/* After: Since the last one. Each next step of the meeting before: Done (you marked it), Raised again (this note has it) or
+ * Not mentioned; then this note's new steps. */
+function sinceCard(s, n) {
+  const pl = s.place;
+  if (!pl || !pl.since || n.private) return null;
+  const st = { done: ['ok', 'Done', 'check'], again: ['warn', 'Raised again', 'todo'], quiet: ['unt', 'Not mentioned', 'todo'] };
+  const rows = [
+    ...pl.since.items.map((x) => el('li', { class: 'nrow', 'data-cal3-since': x.state }, el('span', { class: 'ki' }, c3ic(st[x.state][2])),
+      el('div', { class: 'nb' }, el('span', { class: 'tt' }, x.text), el('div', { class: 'chips' }, el('span', { class: 'st ' + st[x.state][0] }, st[x.state][1]), x.owner ? el('span', { class: 'dim cal3-xs' }, x.owner) : null)), el('span'))),
+    ...pl.since.fresh.map((x) => el('li', { class: 'nrow', 'data-cal3-since': 'new' }, el('span', { class: 'ki' }, c3ic('plus')),
+      el('div', { class: 'nb' }, el('span', { class: 'tt' }, x.text), el('div', { class: 'chips' }, el('span', { class: 'tag' }, 'New'), x.owner ? el('span', { class: 'dim cal3-xs' }, x.owner) : null)), el('span'))),
+  ];
+  return el('section', { class: 'card sect', 'data-cal3-notes': 'since' },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('notes', 'sm'), 'Since the last one, ' + dayOf(pl.since.at))),
+    rows.length ? el('ul', { class: 'list', role: 'list' }, rows) : fold('info', 'The meeting before had no next steps, and this one has none.'));
+}
+
+/* The series page: the head, Next one, Still open and Decided so far, Keeps coming up and Still unanswered, Every meeting.
+ * Every line comes from the series' notes (GET /api/notes/series) or from the PM's own marks and lines. */
+function seriesCol(s) {
+  const T = s.thread;
+  if (!T) return el('div', { 'data-cal3-notes': 'series' }, el('section', { class: 'card' }, fold('clock', 'Reading the series', { role: 'status' })));
+  const a = T.about || {};
+  const about = a.initiative ? [boardName(a.board), iniName(a.initiative)].filter(Boolean).join(' › ') : a.board ? boardName(a.board) : a.portfolio ? 'Portfolio' : null;
+  const joined = (T.joined.calendar ? 'From the calendar series' : 'Notes with the same title')
+    + (T.joined.calendar && T.joined.title ? ', plus ' + plural(T.joined.title, 'note') + ' with the same title' : '') + (T.joined.pm ? ', ' + T.joined.pm + ' added by you' : '') + '.';
+  const head = el('section', { class: 'card', 'data-cv': 'stage-head', 'data-cal3-notes': 'series-head' },
+    el('div', { class: 'cal3-nhead' }, el('span', { class: 'chips2' }, el('b', { 'data-cal3-notes': 'title' }, T.title), el('span', { class: 'tag' }, 'series')),
+      btn('ib sm', { title: 'Copy the series as Markdown', 'aria-label': 'Copy as Markdown', 'data-cal3-notes': 'copy' }, c3ic('clip'), () => copySeries(T))),
+    el('div', { class: 'chips2 dim cal3-sm' }, plural(T.count, 'meeting') + ' since ' + dayOf(T.since)),
+    el('div', { class: 'chips2 cal3-sm' }, about ? el('span', { class: 'chip2' }, c3ic(a.portfolio && !a.board ? 'org' : 'init', 'sm'), about) : null, el('span', { class: 'dim', 'data-cal3-notes': 'series-joined' }, joined)));
+  return el('div', { class: 'cal3-ncol', 'data-cal3-notes': 'series', 'data-cal3-series': T.key }, head, nextCard(s, T),
+    el('div', { class: 'cal3-two' }, openCard(s, T), decidedCard(s, T)),
+    el('div', { class: 'cal3-two' }, topicsCard(T), questionsCard(s, T)), everyCard(s, T));
+}
+
+function nextCard(s, T) {
+  const x = T.next || {};
+  const rows = [
+    ...(x.bring || []).map((b) => el('div', { class: 'chips2 cal3-prep', 'data-cal3-bring': b.id }, el('span', { class: 'ki' }, c3ic('spark')),
+      el('div', { class: 'cal3-prepb' }, el('b', null, b.text), el('div', { class: 'dim' }, 'Added by you, ' + dayOf(b.at))),
+      btn('ib sm', { title: 'Remove this line', 'aria-label': 'Remove', 'data-cal3-notes': 'bring-remove' }, c3ic('x', 'sm'), () => seriesPost(s, '/api/notes/series-unbring', { key: T.key, id: b.id }, 'Removed.')))),
+    ...(x.derived || []).map((d) => (d.kind === 'carried' ? prepRow('alert', d.text, 'Still open after ' + d.seen + ' meetings' + (d.owner ? ' · ' + d.owner : ''))
+      : prepRow('info', d.text, 'Unanswered in ' + d.seen + ' meetings'))),
+  ];
+  const add = el('input', { type: 'text', class: 'cal3-nsearch', placeholder: 'Add something to bring up', 'aria-label': 'Add something to bring up', 'data-cal3-notes': 'bring-input', maxlength: '300' });
+  add.addEventListener('keydown', (e) => { if (e.key === 'Enter' && add.value.trim()) { e.preventDefault(); seriesPost(s, '/api/notes/series-bring', { key: T.key, text: add.value.trim() }, 'Added. It shows here until you remove it.'); } });
+  const when = x.at ? dayOf(x.at) + ' ' + hm(x.at) : null;
+  return el('section', { class: 'card sect', 'data-cal3-series-card': 'next' },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('spark', 'sm'), when ? 'Next one, ' + when : 'Next one'), when ? null : el('span', { class: 'dim cal3-sm' }, 'not on the calendar yet')),
+    rows.length ? rows : fold('info', 'Nothing to bring up yet.', { 'data-cal3-notes': 'bring-none' }),
+    el('div', { class: 'chips2 cal3-nadd' }, add,
+      x.id ? btn('chip2 lk', { 'data-cal3-notes': 'series-meeting', title: 'Show the next meeting in the calendar' }, [c3ic('cal', 'sm'), 'Open the meeting'], () => showMeeting(s, { start: x.at, event_id: x.id })) : null));
+}
+
+function openCard(s, T) {
+  const rows = T.open.map((o) => el('li', { class: 'nrow', 'data-cal3-open': o.key }, el('span', { class: 'ki' }, c3ic('todo')),
+    el('div', { class: 'nb' }, el('span', { class: 'tt' }, o.text),
+      el('div', { class: 'chips' }, o.owner ? el('span', { class: 'chip2' }, c3ic('user', 'sm'), o.owner) : null, el('span', { class: 'dim mono cal3-xs' }, 'since ' + dayOf(o.first)),
+        el('span', { class: 'st ' + (o.seen >= 3 ? 'warn' : 'unt'), title: 'Raised in each of these meetings', 'data-cal3-notes': 'seen' }, o.seen >= 3 ? c3ic('alert', 'sm') : null, 'in ' + plural(o.seen, 'meeting'))),
+      el('div', { class: 'dim cal3-sm' }, o.last.quote ? 'Last said: “' + o.last.quote + '” ' + dayOf(o.last.at) : 'Last raised ' + dayOf(o.last.at))),
+    btn('chip2 lk', { 'data-cal3-notes': 'series-done', title: 'Mark it done: it stops carrying over' }, [c3ic('check', 'sm'), 'Done'], () => seriesPost(s, '/api/notes/series-done', { key: T.key, text: o.text, kind: 'action' }, 'Done. It stops carrying over.'))));
+  const closed = T.closed.length ? el('details', { class: 'cal3-ctx', 'data-cal3-notes': 'closed' }, el('summary', null, el('b', null, 'Closed in the last two weeks'), el('span', { class: 'dim' }, ' · ' + T.closed.length)),
+    el('ul', { class: 'list', role: 'list' }, T.closed.map((c) => el('li', { class: 'nrow' }, el('span', { class: 'ki' }, c3ic('check')),
+      el('div', { class: 'nb' }, el('span', { class: 'tt' }, c.text), el('div', { class: 'chips' }, el('span', { class: 'dim cal3-xs' }, 'marked done ' + dayOf(c.at)))),
+      btn('chip2 lk', { 'data-cal3-notes': 'series-undone', title: 'Open it again' }, 'Open again', () => seriesPost(s, '/api/notes/series-done', { key: T.key, text: c.text, kind: 'action', done: false }, 'Open again.')))))) : null;
+  return sect('open', 'todo', 'Still open', T.open.length, [rows.length ? el('ul', { class: 'list', role: 'list' }, rows) : fold('info', 'Nothing is carried over.'), closed]);
+}
+
+function decidedCard(s, T) {
+  return sect('decisions', 'scale', 'Decided so far', T.decisions.length, T.decisions.length ? el('ul', { class: 'list', role: 'list' }, T.decisions.map((d) => el('li', { class: 'nrow cal3-nrow' },
+    el('span', { class: 'ki' }, c3ic('scale')),
+    btn('cal3-nopen', { title: 'Open the note of ' + dayOf(d.at) }, [el('span', { class: 'tt' }, d.text), el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, dayOf(d.at)), d.why ? el('span', { class: 'dim cal3-xs' }, d.why) : null)], () => choose(s, d.note)),
+    el('span')))) : fold('info', 'No decisions yet.'));
+}
+
+function topicsCard(T) {
+  if (!T.topics.length) return null;
+  return sect('topics', 'spark', 'Keeps coming up', null, el('ul', { class: 'list', role: 'list' }, T.topics.map((t) => el('li', { class: 'nrow' }, el('span', { class: 'ki' }, c3ic('spark')),
+    el('div', { class: 'nb' }, el('span', { class: 'tt' }, t.name), el('div', { class: 'chips' },
+      el('span', { class: 'cal3-dots', title: 'The last ' + t.hits.length + ' meetings, newest on the left' }, t.hits.map((h) => el('i', { class: h ? 'cal3-dot on' : 'cal3-dot' }))),
+      el('span', { class: 'dim mono cal3-xs' }, t.count + ' of last ' + t.hits.length), t.kind === 'agenda' ? el('span', { class: 'tag' }, 'agenda') : null)), el('span')))));
+}
+
+function questionsCard(s, T) {
+  if (!T.questions.length) return null;
+  return sect('questions', 'info', 'Still unanswered', T.questions.length, el('ul', { class: 'list', role: 'list' }, T.questions.map((q) => el('li', { class: 'nrow' }, el('span', { class: 'ki' }, c3ic('info')),
+    el('div', { class: 'nb' }, el('span', { class: 'tt' }, q.text), el('div', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, 'asked ' + dayOf(q.first)),
+      el('span', { class: 'st unt' }, q.seen > 1 ? 'asked in ' + q.seen + ' meetings' : 'not answered yet'))),
+    btn('chip2 lk', { 'data-cal3-notes': 'series-answered', title: 'Mark it answered' }, [c3ic('check', 'sm'), 'Answered'], () => seriesPost(s, '/api/notes/series-done', { key: T.key, text: q.text, kind: 'question' }, 'Marked answered.'))))));
+}
+
+function everyCard(s, T) {
+  const show = s.every ? T.meetings : T.meetings.slice(0, 6);
+  const rows = show.map((m) => el('li', { class: 'nrow cal3-nrow', 'data-cal3-meeting': m.id }, el('span', { class: 'ki' }, c3ic(m.private ? 'lock' : 'doc')),
+    btn('cal3-nopen', { title: 'Open the note of ' + dayOf(m.at) }, [el('span', { class: 'tt' }, m.private ? 'Private note' : m.overview || m.title),
+      el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, [dayOf(m.at), mins(m.ms)].filter(Boolean).join(' · ')),
+        m.decisions ? el('span', { class: 'tag' }, '+' + m.decisions + ' decided') : null, m.new_actions ? el('span', { class: 'tag' }, '+' + plural(m.new_actions, 'new step')) : null,
+        m.by === 'title' ? el('span', { class: 'tag', title: 'In the series because the title matches' }, 'by title') : m.by === 'pm' ? el('span', { class: 'tag' }, 'added by you') : null)],
+    () => choose(s, m.id)), el('span')));
+  const more = T.meetings.length - show.length;
+  return sect('every', 'notes', 'Every meeting', T.meetings.length, [el('ul', { class: 'list', role: 'list' }, rows),
+    more > 0 ? el('div', { class: 'cal3-nadd' }, btn('chip2 lk', { 'data-cal3-notes': 'series-every' }, 'Show ' + plural(more, 'earlier meeting'), () => { s.every = true; draw(s); })) : null]);
+}
+
+async function seriesPost(s, url, body, said) {
+  const r = await pmPost(url, body);
+  if (!r || !r.ok) { toast('Not saved' + ((r && r.error) ? ': ' + r.error : '')); return; }
+  toast(said);
+  read(s);
+}
+async function copySeries(T) {
+  const md = ['# ' + T.title, '', plural(T.count, 'meeting') + ' since ' + dayOf(T.since) + '.', ''];
+  if (T.open.length) md.push('## Still open', ...T.open.map((o) => '- ' + o.text + (o.owner ? ' (' + o.owner + ')' : '') + ', in ' + plural(o.seen, 'meeting')), '');
+  if (T.decisions.length) md.push('## Decided so far', ...T.decisions.map((d) => '- ' + dayOf(d.at) + ': ' + d.text), '');
+  if (T.questions.length) md.push('## Still unanswered', ...T.questions.map((q) => '- ' + q.text), '');
+  md.push('## Every meeting', ...T.meetings.map((m) => '- ' + dayOf(m.at) + ': ' + (m.private ? 'Private note' : m.overview || m.title)));
+  try { await navigator.clipboard.writeText(md.join('\n')); toast('The series is on the clipboard as Markdown.'); } catch { toast('The clipboard was not available.'); }
+}
+
 /* "Show in the calendar": the Calendar switch back to the grid, on the meeting's day, with the meeting selected */
 function showMeeting(s, ev) {
   const ui = s.ui; if (!ui) return;

package/workspace/public/pm/console3.css

@@ -521,6 +521,19 @@
 .c3 .cal3-xs{font-size:var(--fs-1)}
 .c3 .cal3-prep{align-items:flex-start;padding:6px 0;border-bottom:1px solid var(--border)}
 .c3 .cal3-prep .ki{flex:none}
+/* Calendar › Notes meeting series (c3-notes-series): a series' recent meetings indented under it, the quiet "more" lines,
+   the head's series line, the topic dots (last 10 meetings) and two cards side by side when there is room */
+.c3 .cal3-nrow.cal3-nsub{padding-left:var(--sp-5)}
+.c3 .cal3-nrow.cal3-nsub .tt{font-weight:400;font-size:var(--fs-2)}
+.c3 .nrow.cal3-nmore{display:flex;padding-top:2px;padding-bottom:2px}
+.c3 .cal3-nserl{gap:4px;flex-wrap:wrap}
+.c3 .cal3-nadd{padding-top:var(--sp-2);flex-wrap:wrap}
+.c3 .cal3-nadd .cal3-nsearch{flex:1 1 220px;width:auto}
+.c3 .cal3-dots{display:inline-flex;gap:3px;align-items:center}
+.c3 .cal3-dots .cal3-dot{width:7px;height:7px;border-radius:50%;background:var(--border)}
+.c3 .cal3-dots .cal3-dot.on{background:var(--acc)}
+.c3 .cal3-two{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(300px,100%),1fr));gap:var(--sp-3);align-items:start}
+.c3 .cal3-two:empty{display:none}
 .c3 .cal3-prepb{flex:1;min-width:0;font-size:var(--fs-3)}
 .c3 .cal3-agi{display:inline-flex;align-items:center;gap:2px}
 .c3 .cal3-agi[data-cal3-heard="true"] svg{color:var(--acc)}

package/workspace/run-tests.js

@@ -2,7 +2,7 @@
 'use strict';
 /* run-tests.js — run the workspace suites side by side.
  *
- *   node run-tests.js <group> [--jobs=N] [--shard=I/N] [--changed[=REF]] [--timings-out=FILE] [--list] [--verbose]
+ *   node run-tests.js <group> [--jobs=N] [--shard=I/N] [--changed[=REF]] [--retry-browser] [--timings-out=FILE] [--list] [--verbose]
  *   node run-tests.js --check
  *   node run-tests.js --merge-timings=DIR
  *
@@ -28,6 +28,13 @@
  * the suites that failed and the suites its new commits reach, not the whole group again. A suite it skips is written
  * to --passed-out too, so a pass carries forward to the run after. An empty or unknown SHA skips nothing.
  *
+ * --retry-browser runs a failed browser suite once more, alone, after the others finish (ci-flaky-retry, PM
+ * 2026-10-13). On 2026-10-12 most red Workspace CI runs went green on "Re-run failed jobs" with no change: 27 of 38
+ * re-runs. A suite that passes on the retry counts as passed and is printed as FLAKY, with a ::warning:: on CI and a
+ * line in the job summary, so the flaky suites stay visible and get fixed. A suite that fails twice fails the run. A
+ * suite that timed out is not retried: a second 10-minute wait costs more than the re-run it saves. Unit and module
+ * suites are never retried. Workspace CI passes it; a local run does not.
+ *
  * Output: a suite's own output is buffered and printed whole when it finishes, so lines from two
  * suites never interleave. A passing suite prints its last lines; --verbose prints all of it.
  *
@@ -307,12 +314,29 @@ async function main() {
   await Promise.all(Array.from({ length: Math.min(jobs, shared.length) }, worker));
   for (const f of list.filter((x) => exclusive.has(x))) results.push(await runOne(f, verbose));
 
+  // --retry-browser: one more run of each failed browser suite, alone, so the load of the first pass is gone (see the header)
+  const flaky = [];
+  if (flag('retry-browser')) {
+    const isBrowser = (f) => FILES.panels.includes(f) || FILES.ui.includes(f);
+    for (const r of results.filter((x) => !x.ok && isBrowser(x.file) && !/timed out/.test(x.why))) {
+      console.log(`\nrun-tests: ${r.file} failed (${r.why}). Running it once more, alone.`);
+      const again = await runOne(r.file, verbose);
+      if (again.ok) { flaky.push(r); r.ok = true; r.flaky = true; }
+    }
+  }
   const failed = results.filter((r) => !r.ok);
   const slowest = [...results].sort((a, b) => b.secs - a.secs).slice(0, 5).map((r) => `${r.file} ${r.secs}s`).join(', ');
   const timingsOut = flag('timings-out');
   writePassed(results);
   if (timingsOut && timingsOut !== true) fs.writeFileSync(timingsOut, JSON.stringify(Object.fromEntries(results.map((r) => [r.file, r.secs])), null, 2));
   console.log(`\nrun-tests: ${results.length - failed.length}/${results.length} suites passed in ${((Date.now() - t0) / 1000).toFixed(1)}s wall. Slowest: ${slowest}.`);
+  if (flaky.length) {
+    console.log(`FLAKY: ${flaky.map((r) => `${r.file} (first run: ${r.why})`).join(', ')}. Each passed when run again alone.`);
+    if (process.env.GITHUB_ACTIONS) for (const r of flaky) console.log(`::warning title=Flaky suite::${r.file} failed (${r.why}) and passed when run again alone. Fix it: it cost this run a retry.`);
+    if (process.env.GITHUB_STEP_SUMMARY) {
+      try { fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, `### Flaky suites (passed on the retry)\n\n${flaky.map((r) => `- \`${r.file}\` (first run: ${r.why})`).join('\n')}\n`); } catch { /* the summary is a convenience */ }
+    }
+  }
   // exitCode, never process.exit(): stdout to a pipe is asynchronous, and exiting here cut the CI log
   // off mid-suite, before the summary that names what failed.
   if (failed.length) { console.log(`FAILED: ${failed.map((r) => `${r.file} (${r.why})`).join(', ')}`); process.exitCode = 1; }

package/workspace/test-files.json

@@ -61,6 +61,7 @@
     "notes-highlight.test.js",
     "notes-page.test.js",
     "notes-conflicts.test.js",
+    "notes-series.test.js",
     "notes-resume.test.js",
     "proactive-prepare.test.js",
     "learn.test.js",
@@ -208,6 +209,7 @@
     "notes-highlight.test.js": 1,
     "notes-page.test.js": 1,
     "notes-conflicts.test.js": 1,
+    "notes-series.test.js": 1,
     "notes-resume.test.js": 8,
     "proactive-prepare.test.js": 9,
     "learn.test.js": 3,

package/workspace/test-lists/c3-notes-series.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Initiative c3-notes-series: meeting series in Calendar › Notes (one row per series, the series page, a note's place in its series, older notes folded, search in the transcript).",
+  "panels": ["pm-c3-notes-series-test.js"],
+  "seconds": { "pm-c3-notes-series-test.js": 40 }
+}