create-pmos 0.63.2 → 0.65.0

package/workspace/lib/people-store.js

@@ -8,8 +8,16 @@
  *   record(root, { by, sightings, merges, now }) → { ok, recorded, duplicates, refused[], error? }
  *   decide(root, { actor, body, now })       → { ok, row } | { ok:false, error }   one PM page press
  *   settings(root)                           → { ok, calendar_names, file }
+ *   scan(root, { now, calendar, notesDir, ws }) → { ok, recorded, found }   the names the workspace's own records hold
  *
  * Every write is an append through people.js's validators, so a refused row is never on disk. No network, no process.
+ *
+ * SCAN (the PM, 2026-10-06: "If you detect a person's name, add it to the people directory"). People no longer waits for
+ * an agent session alone. `scan` reads the names the workspace already holds and records each as a sighting by
+ * `workspace:scan`, which adds the person (people.js): plan item owners (`person:<name>`), the speakers of this
+ * repository's Live notes sessions, the renamed speakers and action owners of the PM's meeting notes for this repository,
+ * and, only while calendar names are on, the attendees this machine remembers from the calendar. A private Live notes
+ * session or a private note is skipped. A sighting already on disk is not written again, so a scan writes only what is new.
  */
 const crypto = require('crypto');
 const P = require('./people');
@@ -17,6 +25,8 @@ const fourPanel = require('./four-panel');
 const consoleState = require('./console-state');
 
 const MAX_PER_RECORD = 500;
+const fs = require('fs');
+const path = require('path');
 
 function stateDir(root) {
   const e = consoleState.loadEngine();
@@ -120,4 +130,103 @@ function decide(root, { actor, body, now = Date.now() } = {}) {
   return { ok: true, row: w.recorded, person };
 }
 
-module.exports = { view, record, decide, settings, stateDir, readRows };
+/* ── scan: the names the workspace's own records hold ─────────────────────────────────────────────────────────────── */
+// Not names: the notes' default speakers, the action owners that are not a person, and numbered speakers.
+const NOT_A_NAME = /^(you|me|meeting|mic|speech|unknown|someone|everyone|the speaker|the team|team|we|speaker\s*\d*|participant\s*\d*|guest\s*\d*)$/i;
+function personName(v) {
+  const n = String(v == null ? '' : v).replace(/\s+/g, ' ').trim().replace(/^@/, '');
+  if (n.length < 2 || n.length > 80 || !/\p{L}/u.test(n) || NOT_A_NAME.test(n)) return null;
+  return n;
+}
+const day = (v) => (typeof v === 'string' && /^\d{4}-\d{2}-\d{2}/.test(v) ? v.slice(0, 10) : null);
+const lines = (file) => { try { return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return []; } };
+/** "Ana Lee, Bo Chen and kim@x.io" → ["Ana Lee", "Bo Chen", "kim@x.io"]. */
+const splitNames = (w) => String(w || '').split(/\s*(?:,|;|&|\band\b|\/)\s*/i).map((x) => x.replace(/\(.*?\)/g, '').trim()).filter(Boolean);
+
+/** The sightings the workspace's records hold for this repository. Pure apart from reading files. */
+function sightingsFrom(root, { items = [], calendar = [], calendarOn = false, notesDir = null, ws = null } = {}) {
+  const out = [];
+  const push = (source, kind, value, name, interaction) => {
+    const n = personName(name);
+    if (!n) return;
+    const s = { source, handle: { kind, value: String(value).slice(0, 120) }, name: n };
+    if (interaction && interaction.date) s.interaction = { ...interaction, text: interaction.text.slice(0, 200), pointer: interaction.pointer.slice(0, 200) };
+    out.push(s);
+  };
+  // plan item owners: the person's shared work already lists the items, so the sighting carries no interaction
+  for (const it of items || []) {
+    if (!it || it.state === 'withdrawn' || typeof it.owner !== 'string' || !it.owner.startsWith('person:')) continue;
+    const n = personName(it.owner.slice(7));
+    if (n) push('plan', 'name', n, n, null);
+  }
+  // Live notes sessions in this repository: one interaction per speaker per session
+  const lnDir = path.join(fs.existsSync(path.join(root, 'pmos', 'state')) ? path.join(root, 'pmos', 'state') : path.join(root, 'planning'), 'live-notes');
+  let files = []; try { files = fs.readdirSync(lnDir).filter((f) => f.endsWith('.jsonl')).sort(); } catch { /* no sessions */ }
+  for (const f of files) {
+    const rows = lines(path.join(lnDir, f));
+    if (rows.some((r) => r.row === 'private')) continue;
+    const session = f.replace(/\.jsonl$/, '');
+    const start = day((rows.find((r) => r.row === 'session') || {}).at) || day((rows[0] || {}).at);
+    const said = new Set();
+    for (const r of rows) {
+      const sp = r && r.pointer && personName(r.pointer.speaker);
+      if (!sp || said.has(sp.toLowerCase())) continue;
+      said.add(sp.toLowerCase());
+      push('live', 'speaker', sp, sp, { date: start || day(r.at), kind: 'Meeting', text: 'Spoke in a Live notes session', pointer: `live notes ${session}` });
+    }
+  }
+  // the PM's meeting notes for this repository: renamed speakers and the action owners the local summary reads
+  if (notesDir && ws) {
+    let nf = []; try { nf = fs.readdirSync(path.join(notesDir, 'notes')).filter((f) => f.endsWith('.json')); } catch { /* no notes */ }
+    let notesLib = null; try { notesLib = require('./notes'); } catch { /* notes unavailable */ }
+    for (const f of nf) {
+      let note = null; try { note = JSON.parse(fs.readFileSync(path.join(notesDir, 'notes', f), 'utf8')); } catch { continue; }
+      if (!note || note.private || note.ws !== ws || !note.id) continue;
+      const date = day(note.recorded_from) || day(note.created_at);
+      if (!date) continue;
+      const pointer = `note ${note.id}`;
+      for (const sp of Object.values(note.speakers || {})) push('notes', 'speaker', sp, sp, { date, kind: 'Meeting', text: 'Spoke in a meeting note', pointer });
+      if (notesLib) {
+        let actions = []; try { actions = (notesLib.summarize(note).sections || {}).actions || []; } catch { /* unreadable note */ }
+        const owners = new Set();
+        for (const a of actions) for (const o of String(a.owner || '').split(/\s+and\s+/)) { const n = personName(o); if (n) owners.add(n); }
+        for (const n of owners) push('notes', 'name', n, n, { date, kind: 'Meeting', text: 'Has an action in a meeting note', pointer });
+      }
+    }
+  }
+  // the calendar this machine remembers, only while calendar names are on (R3)
+  if (calendarOn) {
+    for (const e of calendar || []) {
+      const date = e && day(e.start);
+      if (!date || !e.with) continue;
+      for (const w of splitNames(e.with)) {
+        const mail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(w);
+        push('calendar', mail ? 'mail' : 'name', mail ? w.toLowerCase() : w, mail ? w.split('@')[0] : w,
+          { date, kind: 'Meeting', text: e.title ? `Meeting: ${e.title}` : 'Meeting', pointer: 'calendar' });
+      }
+    }
+  }
+  return out;
+}
+
+/** Record the names the workspace's records hold. Writes only sightings not already on disk. */
+function scan(root, { now = Date.now(), calendar = [], notesDir = null, ws = null } = {}) {
+  const r = readRows(root);
+  if (!r.ok) return r;
+  const calendarOn = P.fold(r.rows).settings.calendar_names;
+  const found = sightingsFrom(root, { items: planItems(root), calendar, calendarOn, notesDir, ws });
+  const seen = new Set(r.rows.filter((x) => x && x.kind === 'sighting').map(sightKey));
+  let recorded = 0;
+  for (const s of found) {
+    const c = P.checkSighting(s);
+    if (!c.ok) continue;
+    const k = sightKey(c.row);
+    if (seen.has(k)) continue;
+    const w = fourPanel.appendDeclaration(r.dir, P.LEDGER, stamp(c.row, 'workspace:scan', now));
+    if (!w.ok) return { ok: false, error: w.error, recorded, found: found.length };
+    seen.add(k); recorded++;
+  }
+  return { ok: true, recorded, found: found.length };
+}
+
+module.exports = { view, record, decide, settings, scan, sightingsFrom, stateDir, readRows };

package/workspace/lib/people.js

@@ -4,8 +4,9 @@
  *
  *   checkSighting(s)                 → { ok, row } | { ok:false, error }   one sighting an agent session records
  *   checkMergeProposal(m)            → { ok, row } | { ok:false, error }
- *   checkDecision(body)              → { ok, row } | { ok:false, error }   one PM press (add, ignore, merge, keep-separate,
- *                                                                           edit, tone, note, note-remove, setting)
+ *   checkDecision(body)              → { ok, row } | { ok:false, error }   one PM press (add, ignore, remove, merge,
+ *                                                                           keep-separate, edit, tone, note, note-remove,
+ *                                                                           setting)
  *   fold(rows, { now, items, meetings }) → { people, review, settings, counts }
  *   handleKey(h) · slugOf(name) · toneProposal(interactions) · matchPeople(people, text)
  *   SOURCES · HANDLE_KINDS · INTERACTION_KINDS · TONES · ACTS · LEDGER
@@ -13,21 +14,24 @@
  * Pure: no file, no clock unless given, no network. lib/people-store.js reads and appends; the route, the CLI and the
  * People place all answer from fold(), so the terminal and the page cannot hold two opinions about a person.
  *
- * WHO DECIDES (D90). A sighting row is anyone's: an agent session records it through `pmos people record`. Every
- * decision row (a person added, a handle ignored or merged, a tone, a note, the calendar setting) counts only when its
- * `by` is the PM (`pm:<slug>`), which only a page press writes. A decision row with any other `by` is skipped and
- * counted in counts.skipped, so a hand-appended line cannot make an agent's choice the PM's.
+ * WHO DECIDES (D90, as amended 2026-10-06). A sighting row is anyone's: an agent session records it through
+ * `pmos people record`, and the workspace records the names its own records hold (people-store.js scan). A sighting of
+ * a handle nobody holds ADDS that person: the PM asked for every detected name to be in People, not to wait in a list.
+ * A sighting whose name is a person's full name joins that person. Every decision row (a person added or removed, a
+ * handle ignored or merged, a tone, a note, the calendar setting) counts only when its `by` is the PM (`pm:<slug>`),
+ * which only a page press writes. A decision row with any other `by` is skipped and counted in counts.skipped, so a
+ * hand-appended line cannot make an agent's choice the PM's. Remove and Ignore keep a person's handles out for good.
  *
  * CALENDAR NAMES (R3). The setting is off until the PM turns it on. While it is off, the store refuses a calendar
  * sighting, and this fold also drops the calendar sightings recorded while it was on.
  */
 
 const LEDGER = 'people.jsonl';
-const SOURCES = Object.freeze(['gather', 'calendar', 'live', 'jira']);
+const SOURCES = Object.freeze(['gather', 'calendar', 'live', 'jira', 'plan', 'notes']);
 const HANDLE_KINDS = Object.freeze(['mail', 'slack', 'jira', 'confluence', 'speaker', 'name']);
 const INTERACTION_KINDS = Object.freeze(['Mail', 'Chat', 'Meeting', '1:1', 'Jira', 'Doc', 'Call', 'Mention']);
 const TONES = Object.freeze(['warm', 'neutral', 'cautious', 'tense']);
-const ACTS = Object.freeze(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+const ACTS = Object.freeze(['add', 'ignore', 'remove', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const ID_RE = /^[a-z0-9][a-z0-9-]{0,59}$/;
 const NOTE_ID_RE = /^n-[0-9a-z]{4,16}$/;
@@ -148,6 +152,7 @@ function checkDecision(body) {
     return { ok: true, row: { kind: 'keep-separate', a: a.value, b: b.value } };
   }
   if (!person()) return { ok: false, error: 'say which person' };
+  if (act === 'remove') return { ok: true, row: { kind: 'remove', person: person() } };
   if (act === 'edit') {
     const row = { kind: 'edit', person: person() };
     for (const [k, max] of [['name', 80], ['role', 120], ['org', 80]]) {
@@ -217,7 +222,7 @@ function matchPeople(people, hay) {
 const sightKey = (r) => [handleKey(r.handle), r.interaction ? r.interaction.date : '', r.interaction ? r.interaction.pointer : '', r.interaction ? r.interaction.text : ''].join('\u0000');
 const pairKey = (a, b) => [handleKey(a), handleKey(b)].sort().join('\u0000');
 const isPm = (r) => typeof r.by === 'string' && PM_BY_RE.test(r.by);
-const DECISION_KINDS = new Set(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+const DECISION_KINDS = new Set(['add', 'ignore', 'remove', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
 
 /**
  * The one fold. `rows` are the ledger's rows in file order (torn lines already dropped). `items` are plan items (the
@@ -233,7 +238,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
   const sightings = [];
   const proposals = [];
 
-  // 1 · decisions, in file order; the calendar setting first so the sightings below read the final value
+  // 1 · the calendar setting first, so every sighting below reads its final value
   for (const r of rows || []) {
     if (!isObj(r)) continue;
     counts.rows++;
@@ -249,11 +254,44 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     const p = people.get(id);
     if (!p.handles.some((x) => handleKey(x) === k)) p.handles.push({ kind: h.kind, value: h.value });
   };
+  const create = (name, h, at) => {
+    let id = slugOf(name);
+    for (let n = 2; people.has(id); n++) id = `${slugOf(name).slice(0, 56)}-${n}`;
+    people.set(id, { id, name, role: null, org: null, external: null, handles: [], tone: null, notes: new Map(), addedAt: at || null, edited: {} });
+    attach(id, h);
+    return id;
+  };
+  // A sighting whose name is a person's full name is that person: "Ana Lee" from Jira and "Ana Lee" from a meeting. A
+  // bare first name from a weak handle (a name or a speaker, never a mail or chat handle) joins the one person with that
+  // first name; when two people share it, it joins nobody.
+  const byName = (name, kind) => {
+    const n = str(name).toLowerCase();
+    const live = [...people.values()].filter((p) => p.handles.length);
+    const full = live.find((p) => str(p.name).toLowerCase() === n);
+    if (full) return full.id;
+    if ((kind !== 'name' && kind !== 'speaker') || n.includes(' ')) return null;
+    const firsts = live.filter((p) => str(p.name).toLowerCase().split(' ')[0] === n);
+    return firsts.length === 1 ? firsts[0].id : null;
+  };
+  // One pass in file order, so a person exists before the PM's later presses about them.
+  const seen = new Set();
   for (const r of rows || []) {
     if (!isObj(r)) continue;
     if (r.kind === 'sighting') {
       const c = checkSighting(r);
-      if (c.ok) sightings.push({ ...c.row, at: r.at || null });
+      if (!c.ok) continue;
+      const s = { ...c.row, at: r.at || null };
+      const key = sightKey(s);
+      if (seen.has(key)) { counts.duplicates++; continue; }
+      seen.add(key);
+      if (s.source === 'calendar' && !settings.calendar_names) { counts.hiddenCalendar++; continue; }
+      const k = handleKey(s.handle);
+      if (ignored.has(k)) continue;
+      if (!owner.has(k) || !people.has(owner.get(k))) {
+        const id = byName(s.name, s.handle.kind);
+        if (id) attach(id, s.handle); else create(s.name, s.handle, s.at);
+      }
+      sightings.push(s);
       continue;
     }
     if (r.kind === 'merge-proposal') {
@@ -268,20 +306,23 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     if (d.kind === 'add') {
       const k = handleKey(d.handle);
       if (owner.has(k) && people.has(owner.get(k))) continue;
-      let id = slugOf(d.name);
-      for (let n = 2; people.has(id); n++) id = `${slugOf(d.name).slice(0, 56)}-${n}`;
-      people.set(id, { id, name: d.name, role: null, org: null, external: null, handles: [], tone: null, notes: new Map(), addedAt: r.at || null, edited: {} });
-      attach(id, d.handle);
+      create(d.name, d.handle, r.at);
     } else if (d.kind === 'ignore') {
       const k = handleKey(d.handle);
-      if (!owner.has(k)) ignored.add(k);
+      const o = owner.get(k);
+      if (o && people.has(o)) { const pp = people.get(o); pp.handles = pp.handles.filter((x) => handleKey(x) !== k); }
+      owner.delete(k);
+      ignored.add(k);
     } else if (d.kind === 'merge') {
       if (people.has(d.person)) attach(d.person, d.handle);
     } else if (d.kind === 'keep-separate') {
       closed.add(pairKey(d.a, d.b));
     } else if (people.has(d.person)) {
       const p = people.get(d.person);
-      if (d.kind === 'edit') {
+      if (d.kind === 'remove') {
+        for (const h of p.handles) { owner.delete(handleKey(h)); ignored.add(handleKey(h)); }
+        p.handles = [];
+      } else if (d.kind === 'edit') {
         for (const k of ['name', 'role', 'org', 'external']) if (d[k] !== undefined) { p[k] = d[k]; p.edited[k] = true; }
       } else if (d.kind === 'tone') p.tone = d.tone;
       else if (d.kind === 'note') p.notes.set(d.id, { id: d.id, text: d.text, at: r.at || null });
@@ -289,38 +330,21 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     }
   }
 
-  // 2 · sightings: dedup, drop calendar ones while the setting is off, then hand each to its person or the review list
-  const seen = new Set();
-  const fresh = new Map();   // handle key -> { handle, name, role, org, external, count, sources, last }
+  // 2 · each sighting's details go to the person who holds its handle at the end
   const interactions = new Map();   // person id -> []
+  const sourcesOf = new Map();      // person id -> Set of sources
   for (const s of sightings) {
-    const key = sightKey(s);
-    if (seen.has(key)) { counts.duplicates++; continue; }
-    seen.add(key);
-    if (s.source === 'calendar' && !settings.calendar_names) { counts.hiddenCalendar++; continue; }
-    const k = handleKey(s.handle);
-    const id = owner.get(k);
-    if (id && people.has(id)) {
-      const p = people.get(id);
-      for (const f of ['role', 'org']) if (s[f] && !p.edited[f]) p[f] = s[f];
-      if (s.external === true && !p.edited.external) p.external = true;
-      if (s.interaction) {
-        if (!interactions.has(id)) interactions.set(id, []);
-        interactions.get(id).push({ ...s.interaction, source: s.source, handle: s.handle, at: s.at });
-      }
-      continue;
+    const id = owner.get(handleKey(s.handle));
+    if (!id || !people.has(id)) continue;
+    const p = people.get(id);
+    if (!sourcesOf.has(id)) sourcesOf.set(id, new Set());
+    sourcesOf.get(id).add(s.source);
+    for (const f of ['role', 'org']) if (s[f] && !p.edited[f]) p[f] = s[f];
+    if (s.external === true && !p.edited.external) p.external = true;
+    if (s.interaction) {
+      if (!interactions.has(id)) interactions.set(id, []);
+      interactions.get(id).push({ ...s.interaction, source: s.source, handle: s.handle, at: s.at });
     }
-    if (ignored.has(k)) continue;
-    const f = fresh.get(k) || { handle: s.handle, name: s.name, role: null, org: null, external: false, count: 0, sources: [], last: null };
-    f.name = s.name;
-    if (s.role) f.role = s.role;
-    if (s.org) f.org = s.org;
-    if (s.external) f.external = true;
-    f.count++;
-    if (!f.sources.includes(s.source)) f.sources.push(s.source);
-    const d = s.interaction ? s.interaction.date : (s.at || '').slice(0, 10);
-    if (d && (!f.last || d > f.last)) f.last = d;
-    fresh.set(k, f);
   }
 
   // 3 · each person's page
@@ -340,6 +364,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
       id: p.id, name: p.name, role: p.role || null, org: p.org || null, external: p.external === true,
       group: p.external === true ? 'External' : 'Team',
       handles: p.handles.slice(),
+      sources: [...(sourcesOf.get(p.id) || [])],
       interactions: ints,
       tone: { proposed, confirmed: p.tone || null, mix, pending: !!proposed && !p.tone },
       notes: [...p.notes.values()],
@@ -367,7 +392,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
   }
   list.sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || a.name.localeCompare(b.name));
 
-  // 5 · the review list: new handles, open merge proposals, tones the PM has not confirmed
+  // 5 · the review list: open merge proposals and tones the PM has not confirmed (a new person is added, not listed)
   const merges = [];
   const shown = new Set();
   for (const m of proposals) {
@@ -375,7 +400,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     if (closed.has(pk) || shown.has(pk)) continue;
     const oa = owner.get(handleKey(m.a)); const ob = owner.get(handleKey(m.b));
     if (oa && ob && oa === ob) continue;
-    // Merge needs a person to join: the one holding a (or else b). Two handles nobody holds wait in "new" instead.
+    // Merge needs a person to join: the one holding a (or else b).
     const into = oa && people.has(oa) ? oa : ob && people.has(ob) ? ob : null;
     if (!into) continue;
     const other = into === oa ? m.b : m.a;
@@ -383,11 +408,10 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     shown.add(pk);
     merges.push({ a: m.a, b: m.b, why: m.why, person: into, personName: people.get(into).name, handle: other });
   }
-  const freshList = [...fresh.values()].sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || b.count - a.count);
   const tones = list.filter((p) => p.tone.pending).map((p) => p.id);
   return {
     people: list,
-    review: { new: freshList, merges, tones, count: freshList.length + merges.length + (tones.length ? 1 : 0) },
+    review: { merges, tones, count: merges.length + (tones.length ? 1 : 0) },
     settings,
     counts,
   };

package/workspace/lib/routes-notes.js

@@ -1,5 +1,5 @@
 'use strict';
-/* routes-notes.js — the Notes view's routes (meeting-notes, Runs 1 and 2; lib/route-modules.js).
+/* routes-notes.js — the Notes view's routes (meeting-notes, Runs 1 to 3; lib/route-modules.js).
  *
  *   GET  /api/notes                         → { ok, notes: [row] }            newest first; a row never carries the body
  *   GET  /api/notes/one?id=…                → { ok, note }                    imports an agent summary written since the request
@@ -11,9 +11,12 @@
  *   POST /api/notes/audio      { id, source, pcm, final? } → { ok, cut }   16 kHz mono 16-bit samples, base64; local Whisper (D91)
  *   POST /api/notes/label      { id, index, cat }           → { ok, segment }   the PM's own label for a line
  *   POST /api/notes/speaker    { id, source, name }         → { ok, speakers }
+ *   POST /api/notes/line       { id, index, cat?, summary?, tags?, people?, text? } → { ok, segment, summary }   the PM's correction (Run 3)
+ *   GET  /api/notes/recording?id=…          → audio/wav, with byte ranges    the note's kept audio (Run 3, D92)
+ *   POST /api/notes/recording-delete { id } → { ok }    deletes the note's audio and keeps the rest
  *   GET  /api/notes/engine?ws=…             → { ok, whisper, jev }   is Whisper set up; which Jev gates hold (booleans only)
  *   POST /api/notes/switch     { ws, jev?, check? }         → { ok, jev }   the two D91 switches, default off
- *                              { language?, model? }        → { ok, whisper } the spoken language and the model, for this machine
+ *                              { language?, model?, keep_audio? } → { ok, whisper } the language, the model and keeping audio, for this machine
  *   POST /api/notes/whisper-setup { ws? }   → { ok, started, session, command }   a terminal with the setup typed in, not run
  *   POST /api/notes/private    { id, private }            → { ok, private }
  *   POST /api/notes/summarize  { id }       → { ok, summary }   the local summary
@@ -34,6 +37,7 @@ const guard = require('./pm-guard.js');
 const notes = require('./notes.js');
 const whisper = require('./notes-whisper.js');
 const notesRepo = require('./notes-repo.js');
+const notesAudio = require('./notes-audio.js');
 const jevNotes = require('./jev-notes.js');
 const tsSettings = require('./typesafe-settings.js');
 
@@ -43,7 +47,7 @@ const CHECKED = new Set(['decision', 'action', 'statement']);
 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/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/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/line', '/api/notes/recording-delete']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
 const chains = new Map();      // note id → the promise of its enrichment so far
@@ -109,7 +113,7 @@ function engineInfo(ctx, w) {
   const d = whisper.detect(ctx.runtimeDir);
   const out = { ready: d.ready, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size,
     language: whisper.getLanguage(ctx.runtimeDir), languages: whisper.LANGUAGES.map(([value, label]) => ({ value, label })),
-    model: whisper.getModel(ctx.runtimeDir), models: whisper.MODELS.map((m) => ({ value: m.id, label: m.label })) };
+    model: whisper.getModel(ctx.runtimeDir), models: whisper.MODELS.map((m) => ({ value: m.id, label: m.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
   const sw = jevNotes.getSwitch(ctx.runtimeDir, w.root);
@@ -128,10 +132,18 @@ async function handle(req, res, url, ctx) {
     if (p === '/api/notes') { send(ctx, res, notes.list(dir)); return true; }
     const nid = url.searchParams.get('id');
     const r = notes.read(dir, nid);
-    if (r.ok) r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null };
+    if (r.ok) { r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid); }
     send(ctx, res, r);
     return true;
   }
+  if (p === '/api/notes/recording' && (req.method === 'GET' || req.method === 'HEAD')) {
+    const nid = url.searchParams.get('id');
+    const r = notes.read(dir, nid);
+    if (!r.ok) { send(ctx, res, r); return true; }
+    if (r.note.private) { ctx.json(res, { ok: false, error: 'this note is private and keeps no audio' }, 404); return true; }
+    notesAudio.serve(req, res, dir, nid);
+    return true;
+  }
   if (p === '/api/notes/engine') {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
     const wsId = url.searchParams.get('ws');
@@ -180,17 +192,29 @@ async function handle(req, res, url, ctx) {
     if (!whisper.detect(dir).ready) return done({ ok: false, status: 409, error: 'local transcription is not set up' });
     const ms = (pcm.length / 2 / whisper.RATE) * 1000;
     const t = Math.max(0, Date.now() - Date.parse(note.note.recorded_from) - ms);
+    // the audio is kept for replay unless the PM switched that off (D92); a private note never reaches this line
+    if (notesAudio.getKeep(dir)) { try { notesAudio.write(dir, { id, source, pcm, t }); } catch (e) { audioErrors.set(id, { at: new Date().toISOString(), error: 'the audio was not kept: ' + ((e && e.message) || e) }); } }
     return done(transcriberFor(ctx).push({ id, source, pcm, t, final: body.final === true }));
   }
   if (p === '/api/notes/label') return done(notes.setLabel(dir, { id, index: Number(body.index), cat: body.cat, drop: body.drop === true }));
   if (p === '/api/notes/speaker') return done(notes.renameSpeaker(dir, { id, source: body.source, name: body.name }));
+  if (p === '/api/notes/line') {
+    const pick = (k) => (body[k] === undefined ? undefined : body[k]);
+    return done(notes.editLine(dir, { id, index: Number(body.index), cat: pick('cat'), summary: pick('summary'), tags: pick('tags'), people: pick('people'), text: pick('text') }));
+  }
+  if (p === '/api/notes/recording-delete') {
+    const r = notes.read(dir, id);
+    if (!r.ok) return done(r);
+    return done({ ok: true, deleted: notesAudio.remove(dir, id) });
+  }
   if (p === '/api/notes/switch') {
     const o = wsOf();
     // the spoken language belongs to this machine, not to a repository
-    if (body.language !== undefined || body.model !== undefined) {
+    if (body.language !== undefined || body.model !== undefined || body.keep_audio !== undefined) {
       const r = body.language !== undefined ? whisper.setLanguage(dir, String(body.language)) : { ok: true };
       const m = r.ok && body.model !== undefined ? whisper.setModel(dir, String(body.model)) : { ok: true };
-      if (!r.ok || !m.ok) { ctx.json(res, { ok: false, error: r.error || m.error }, 400); return true; }
+      const k = r.ok && m.ok && body.keep_audio !== undefined ? notesAudio.setKeep(dir, body.keep_audio) : { ok: true };
+      if (!r.ok || !m.ok || !k.ok) { ctx.json(res, { ok: false, error: r.error || m.error || k.error }, 400); return true; }
       if (body.jev === undefined && body.check === undefined) { ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true; }
     }
     if (!o.ok || !o.w) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
@@ -211,11 +235,11 @@ async function handle(req, res, url, ctx) {
   }
   if (p === '/api/notes/private') {
     const r = notes.setPrivate(dir, { id, private: body.private });
-    if (r.ok && r.private && transcriber) transcriber.drop(id);
+    if (r.ok && r.private) { if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
     return done(r);
   }
   if (p === '/api/notes/summarize') return done(notes.localSummary(dir, { id }));
-  if (p === '/api/notes/delete') { if (transcriber) transcriber.drop(id); return done(notes.remove(dir, id)); }
+  if (p === '/api/notes/delete') { if (transcriber) transcriber.drop(id); const r = notes.remove(dir, id); if (r.ok) notesAudio.remove(dir, id); return done(r); }
   // summarize-agent: the handoff file first (refused for a private note), then the PM's own agent session
   let w = null;
   if (body.ws != null) {

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.63.2",
+  "version": "0.65.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.63.2",
+  "version": "0.65.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/components.css

@@ -4929,6 +4929,88 @@
   white-space: pre-wrap;
   font-size: 14px;
 }
+.nt-now {
+  background: var(--accent);
+}
+.nt-ln.nt-now {
+  color: var(--foreground);
+}
+.nt-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 4px;
+}
+.nt-tag {
+  margin-left: 4px;
+  padding: 0 4px;
+  border: 1px solid var(--border);
+  font-size: 11px;
+  color: var(--muted-foreground);
+}
+.nt-tags .nt-tag {
+  margin-left: 0;
+}
+.nt-edited {
+  font-size: 11px;
+  font-style: italic;
+  color: var(--muted-foreground);
+}
+.nt-heard {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
+}
+.nt-ver {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 8px;
+  padding: 12px 0;
+  border-bottom: 1px solid var(--border);
+}
+.nt-diff {
+  align-self: stretch;
+  font-family: var(--mono);
+  font-size: 12px;
+  line-height: 18px;
+  white-space: pre-wrap;
+}
+.nt-diff__ln--same {
+  color: var(--muted-foreground);
+}
+.nt-diff__ln--add {
+  color: var(--foreground);
+  background: var(--accent);
+}
+.nt-diff__ln--del {
+  color: var(--muted-foreground);
+  text-decoration: line-through;
+}
+.nt-replay {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 12px;
+  padding-bottom: 12px;
+  border-bottom: 1px solid var(--border);
+}
+.nt-audio {
+  flex: 1 1 320px;
+  min-width: 0;
+  height: 32px;
+}
+.nt-notelines {
+  display: flex;
+  flex-direction: column;
+  min-height: 96px;
+  font-size: 14px;
+  line-height: 22px;
+}
+.nt-noteline {
+  white-space: pre-wrap;
+}
 @media (max-width: 760px) {
   .nt-body2 {
     grid-template-columns: 1fr;