create-pmos 0.177.0 → 0.179.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.177.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@9ea3e51
+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:28:03Z"}
+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:28:03Z"}
+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:28:03Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T02:06:03Z"}
 status: stable
 ---
 

package/workspace/c3-sessions-panel-test.js

@@ -30,6 +30,12 @@ const finish = async (code) => {
 process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function until(fn, ms = 8000) { const end = Date.now() + ms; while (Date.now() < end) { const v = await fn(); if (v) return v; await sleep(150); } return null; }
+/* the Sessions panel: the Sessions button opens a running last session's terminal, whose "All sessions" opens the panel */
+async function openPanel(page) {
+  await page.click('[data-c3pg="agent-button"]');
+  const got = await page.waitForSelector('[data-c3t="host"], [data-c3-all-sessions]', { timeout: 15000 }).catch(() => null);
+  if (got && await page.$('[data-c3-all-sessions]')) await page.click('[data-c3-all-sessions]');
+}
 async function waitFor(page, fn, arg, ms = 15000) { try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; } }
 const get = (p) => fetch(BASE + p).then((r) => r.json());
 // the agent CLI's home for this run: the conversation test writes a session record and a transcript here, as claude would
@@ -175,8 +181,11 @@ function startShell(name) {
   await waitFor(page, () => !document.querySelector('[data-c3-session-term]'));
 
   /* ── D: End asks first, then ends ── */
+  // Sessions opens the terminal of the session opened last while it runs (PM, 2026-10-13); its "All sessions" opens the panel
   await page.click('[data-c3pg="agent-button"]');
-  ok('D0 the panel opens again', await waitFor(page, (s) => !!document.querySelector(s), sel));
+  ok('D0 Sessions opens the terminal of the session opened last', await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id));
+  await page.click('[data-c3-all-sessions]');
+  ok('D0a All sessions in the terminal sheet opens the panel', await waitFor(page, (s) => !!document.querySelector(s), sel) && !(await page.$('[data-c3-session-term]')));
   ok('D0b it opens on the session opened last: its row is open and marked', await waitFor(page, (i) => { const li = document.querySelector(`[data-c3t="mine"] [data-run="${i}"]`); const end = document.querySelector(`[data-end-session="${i}"]`); return !!li && li.hasAttribute('data-last-open') && !!end && end.offsetParent !== null; }, id)
     && await page.evaluate((i) => localStorage.getItem('pmos.workspace.c3.last-session') === i, id));
   if (!(await page.isVisible(`[data-end-session="${id}"]`).catch(() => false))) await page.click(sel + ' .nb');
@@ -232,7 +241,7 @@ function startShell(name) {
 
   /* ── F: New session starts on console3 and opens its terminal here (c3-new-session; it went to the classic app before) ── */
   const before = new Set(((await get('/api/sessions')).sessions || []).map((s) => s.id));
-  if (!(await page.isVisible('[data-c3t="new"]').catch(() => false))) await page.click('[data-c3pg="agent-button"]');
+  if (!(await page.isVisible('[data-c3t="new"]').catch(() => false))) await openPanel(page);
   ok('F1 Started by me has a New button', await waitFor(page, () => !!document.querySelector('[data-c3t="new"]')));
   await page.click('[data-c3t="new"]');
   ok('F2 New opens the new-session sheet on this page', await waitFor(page, () => !!document.querySelector('[data-c3ns="form"]')) && page.url() === url0, page.url());
@@ -261,7 +270,7 @@ function startShell(name) {
 
   /* ── P: a past session can be removed, also one the server knows only from its record on disk ── */
   if (await page.isVisible('[data-shell="sheet"] [aria-label="Close"]').catch(() => false)) await page.click('[data-shell="sheet"] [aria-label="Close"]');
-  if (!(await page.isVisible('[data-c3t="past"]').catch(() => false))) await page.click('[data-c3pg="agent-button"]');
+  if (!(await page.isVisible('[data-c3t="past"]').catch(() => false))) await openPanel(page);
   const pastSel = '[data-c3t="past"] [data-run="sess-9901"]';
   ok('P1 the ended session is listed in Past', await waitFor(page, (s) => !!document.querySelector(s), pastSel));
   if (!(await page.isVisible('[data-end-session="sess-9901"]').catch(() => false))) await page.click(pastSel + ' .nb');

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/guide/console3-sessions.md

@@ -9,6 +9,8 @@ timestamp: 2026-10-13
 
 Press the **Sessions** button in the console3 header to open the panel. It is the bolt icon with no label. Point at it to see its name. When a session needs you, a count shows on it. It shows your sessions in four groups: **On a card**, **Started by me**, **Past (7 days)** and **Automatic**.
 
+When the session that you opened last is still running, the **Sessions** button opens its terminal directly. To see all your sessions, press **All sessions** at the top of the terminal sheet. If that session has ended, the button opens the panel.
+
 The panel opens on the session that you opened last. Its row is open, so you can read the conversation and send a message without searching for it. A session counts as opened when you open its row or its terminal.
 
 ## The dock

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,