create-pmos 0.64.0 → 0.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.64.0",
+  "version": "0.65.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@2196dd0
-assembled: 2026-10-06
+kernel-source: pmos@bcf4a86
+assembled: 2026-10-07
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:08:29Z"}
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:08:29Z"}
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:08:29Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-06
+## 2026-10-07
 
 - Adopted OKF v0.2 (D73).

package/workspace/guide/notes.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Guide: notes"
-description: "How to take notes in a meeting: listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, and get a summary."
+description: "How to take notes in a meeting: listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, correct and tag lines, see what changed in your notes, replay the meeting, and get a summary."
 timestamp: 2026-10-06
 ---
 
@@ -28,9 +28,9 @@ The meeting can only be heard when local transcription is set up. Until then, **
 
 ## What is caught
 
-Each line gets a label: decision, action, question, topic, statement or small talk. Decisions, actions and questions go into their sections as they are said. After **Stop**, statements with a number go under **Facts mentioned**.
+Each line gets a label: decision, action, question, fact, topic, statement or small talk. Decisions, actions and questions go into their sections as they are said. After **Stop**, facts and statements with a number go under **Facts mentioned**.
 
-- To remove an item that does not belong, press the **x** beside it.
+- To remove an item that does not belong, press the **x** beside it. To take a line out of the summary, press the **x** beside it in the summary.
 - When a caught line is about something in the repository, the closest file shows beside it: **see** the file, a check mark when Jev finds that the file says the same, or **≠** the file when Jev finds that the line says something different. Point at the mark to see the file and the line.
 
 ## Set up local transcription
@@ -57,6 +57,35 @@ Without Jev, the workspace labels each line with its own rules and finds the clo
 
 With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Audio, speaker names and private notes never go. A line that looks like a secret is not sent.
 
+## Correct and tag a line
+
+1. In the transcript, press the **…** button on a line.
+2. Change what you need:
+   - **Words**: correct what was heard. The words that were heard are kept, the line shows **edited**, and **Use what was heard** puts them back.
+   - **Label**: decision, action, question, fact, topic, statement or small talk.
+   - **Summary**: **As picked**, **Always in the summary** or **Never in the summary**.
+   - **Tags**: words such as `#pricing #launch`.
+   - **People**: names, separated by commas. Press a name below the field to add a person from this repository.
+3. Press **Save**. The tags and people show on the line, on its item in your notes and under **Tagged**. **Copy as Markdown** includes them.
+
+## See what changed in your notes
+
+Each change to your notes keeps the text from before it. Changes within two minutes count as one. The first text you typed is always kept.
+
+1. When your notes have changed, the header shows **Edited**. Press it.
+2. **History** shows each version, newest first: the lines that were added and removed, and the original at the end.
+3. To go back, press **Use this version**. The text before it stays in **History**.
+
+## Replay the meeting
+
+When a meeting was heard with local transcription, its audio is kept on this machine.
+
+1. Open the note. **Replay** is above your notes. Press play.
+2. While it plays, the transcript line, its item and the line of your notes that you wrote at that moment are highlighted. Your notes cannot be edited while it plays: pause to edit them.
+3. Press a time in the transcript to play from there.
+
+To stop keeping audio, clear **Keep the audio for replay** in the settings. To delete one note's audio, press **Delete this note's audio** in the settings; the notes and the transcript stay. The browser's own recognition keeps no audio, so a meeting heard that way cannot be replayed.
+
 ## Dictate into your notes
 
 1. Put the cursor where the text must go, then press **Dictate** and speak.
@@ -66,13 +95,13 @@ With the switches on, each line goes to TypeSafe for its label. For a caught lin
 ## Copy, private and delete
 
 - **Copy as Markdown** puts the title, the summary, your notes, the caught items and the transcript on the clipboard.
-- In the settings, **Mark private** stops listening at once. A private note is not recorded again, and nothing from it goes to Jev or to an agent. **Mark not private** undoes it.
+- In the settings, **Mark private** stops listening at once and deletes the note's audio. A private note is not recorded again, and nothing from it goes to Jev or to an agent. **Mark not private** undoes it.
 - **Summary by agent** starts an agent session in the selected repository that writes a summary into the note. Lines that look like a secret are removed first.
-- **Delete** removes the note, its transcript and its summaries from this machine after you confirm. You cannot undo it.
+- **Delete** removes the note, its transcript, its summaries and its audio from this machine after you confirm. You cannot undo it.
 
 ## What stays on your machine
 
-- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes the file at once. The browser's own recognition is used only on the device, never in the cloud.
+- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes that file at once. For replay, the workspace keeps one recording of each note in `notes/recordings/` in the state folder, until you delete the audio, the note, or mark the note private. The browser's own recognition is used only on the device, never in the cloud.
 - Notes are files in the workspace's own folder on this machine (`notes/` in the state folder). They are never written into a repository.
 - Only Jev, with the switches on, and **Summary by agent**, when you press it, receive any text from a note.
 

package/workspace/lib/notes-audio.js

@@ -0,0 +1,111 @@
+'use strict';
+/* notes-audio.js — the meeting audio a note keeps for replay (meeting-notes Run 3, D92). Local only.
+ *
+ *   write(runtimeDir, { id, source, pcm, t })   add one chunk of 16 kHz mono 16-bit samples at meeting time t (ms)
+ *   info(runtimeDir, id) → { bytes, ms } | null
+ *   remove(runtimeDir, id)                      delete the note's audio
+ *   serve(req, res, runtimeDir, id)             the audio as a WAV file, with byte ranges so the page can seek
+ *   getKeep(runtimeDir) · setKeep(runtimeDir, bool)   "Keep the audio for replay", on by default, for this machine
+ *
+ * WHAT IT KEEPS. One file per note, `<runtime>/notes/recordings/<id>.pcm`: raw samples with no header, sample k at
+ * k / 16000 seconds after the note's first Listen. The microphone and the meeting are added into the same samples, so the
+ * file is the meeting as the PM heard it. A chunk is placed straight after the previous chunk of its source when it
+ * arrives on time or early, so the small jitter of the page's timer leaves no clicks; a chunk that arrives much later (Listen again)
+ * is placed at its own time, and the gap stays silent.
+ *
+ * WHAT IT NEVER DOES. It sends nothing and opens no network module. The routes (lib/routes-notes.js) write nothing for a
+ * private note, delete the file when a note is made private or deleted, and write nothing when the PM switches keeping off.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const RATE = 16000;
+const BYTES_PER_MS = (RATE * 2) / 1000;
+const ON_TIME_MS = 1500;                    // a chunk this close to where its source left off is placed straight after it
+const MAX_BYTES = RATE * 2 * 60 * 60 * 6;   // six hours; a longer meeting keeps its first six hours
+const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
+
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'notes', 'recordings');
+const fileOf = (runtimeDir, id) => path.join(dirOf(runtimeDir), id + '.pcm');
+const settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'audio-settings.json');
+const next = new Map();                     // `${file}|${source}` → the byte offset where that source's last chunk ended
+
+function getKeep(runtimeDir) {
+  try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s.keep !== false; } catch { return true; }
+}
+function setKeep(runtimeDir, keep) {
+  if (typeof keep !== 'boolean') return { ok: false, error: 'say keep: true or keep: false' };
+  const f = settingsFile(runtimeDir);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify({ keep }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+  return { ok: true, keep };
+}
+
+/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. */
+function write(runtimeDir, { id, source, pcm, t }) {
+  if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
+  const f = fileOf(runtimeDir, id);
+  const key = f + '|' + source;
+  let at = Math.max(0, Math.round((Number(t) || 0) * BYTES_PER_MS / 2) * 2);
+  const prev = next.get(key);
+  // a source never overlaps itself: a chunk that would start before its source left off, or just after, goes straight after it
+  if (prev !== undefined && at <= prev + ON_TIME_MS * BYTES_PER_MS) at = prev;
+  if (at >= MAX_BYTES) return { ok: true, kept: false };
+  const len = Math.min(pcm.length, MAX_BYTES - at);
+  fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
+  const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
+  try {
+    const old = Buffer.alloc(len);
+    fs.readSync(fd, old, 0, len, at);
+    const out = Buffer.alloc(len);
+    for (let i = 0; i < len; i += 2) out.writeInt16LE(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
+    fs.writeSync(fd, out, 0, len, at);
+  } finally { fs.closeSync(fd); }
+  next.set(key, at + len);
+  return { ok: true, kept: true, at_ms: at / BYTES_PER_MS };
+}
+
+function info(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return null;
+  try { const st = fs.statSync(fileOf(runtimeDir, id)); return st.size ? { bytes: st.size, ms: Math.round(st.size / BYTES_PER_MS) } : null; } catch { return null; }
+}
+function remove(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return false;
+  for (const k of [...next.keys()]) if (k.startsWith(fileOf(runtimeDir, id) + '|')) next.delete(k);
+  try { fs.unlinkSync(fileOf(runtimeDir, id)); return true; } catch { return false; }
+}
+
+function wavHeader(dataBytes) {
+  const h = Buffer.alloc(44);
+  h.write('RIFF', 0); h.writeUInt32LE(36 + dataBytes, 4); h.write('WAVE', 8);
+  h.write('fmt ', 12); h.writeUInt32LE(16, 16); h.writeUInt16LE(1, 20); h.writeUInt16LE(1, 22);
+  h.writeUInt32LE(RATE, 24); h.writeUInt32LE(RATE * 2, 28); h.writeUInt16LE(2, 32); h.writeUInt16LE(16, 34);
+  h.write('data', 36); h.writeUInt32LE(dataBytes, 40);
+  return h;
+}
+/** The audio as audio/wav. A `Range: bytes=a-b` request gets 206 with that part, which is how the page seeks. */
+function serve(req, res, runtimeDir, id) {
+  const inf = info(runtimeDir, id);
+  if (!inf) { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: 'this note has no audio' })); return; }
+  const header = wavHeader(inf.bytes);
+  const total = header.length + inf.bytes;
+  let start = 0; let end = total - 1; let partial = false;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range || '').trim());
+  if (m && (m[1] || m[2])) {
+    if (m[1]) { start = Number(m[1]); if (m[2]) end = Math.min(total - 1, Number(m[2])); }
+    else { start = Math.max(0, total - Number(m[2])); }
+    if (start > end || start >= total) { res.writeHead(416, { 'Content-Range': 'bytes */' + total }); res.end(); return; }
+    partial = true;
+  }
+  res.writeHead(partial ? 206 : 200, { 'Content-Type': 'audio/wav', 'Accept-Ranges': 'bytes', 'Content-Length': end - start + 1, 'Cache-Control': 'no-store',
+    ...(partial ? { 'Content-Range': 'bytes ' + start + '-' + end + '/' + total } : {}) });
+  if (req.method === 'HEAD') { res.end(); return; }
+  if (start < header.length) res.write(header.subarray(start, Math.min(header.length, end + 1)));
+  const from = Math.max(0, start - header.length); const to = end - header.length;
+  if (to < from) { res.end(); return; }
+  fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
+}
+
+module.exports = { write, info, remove, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/lib/notes.js

@@ -1,10 +1,12 @@
 'use strict';
-/* notes.js — the PM's notes: typed notes, dictation, meeting transcripts and their summaries (meeting-notes, Runs 1 and 2).
+/* notes.js — the PM's notes: typed notes, dictation, meeting transcripts and their summaries (meeting-notes, Runs 1 to 3).
  *
  *   list(dir) · read(dir, id) · create(dir, { title }) · save(dir, { id, title, body }) · remove(dir, id)
  *   record(dir, { id, ws }) · appendTranscript(dir, { id, text, source, t }) · setPrivate(dir, { id, private })
  *   categoryOf(text, names) → 'decision'|'action'|'question'|'topic'|'statement'|'small talk'   the local label (Run 2)
  *   updateSegment(dir, { id, index, text, patch }) · setLabel(dir, { id, index, cat }) · renameSpeaker(dir, { id, source, name })
+ *   editLine(dir, { id, index, cat?, summary?, tags?, people?, text? })   the PM's corrections to one line (Run 3, D92)
+ *   versionsOf(note) → [{ at, title, body, original }]    every kept version of the notes, oldest first (Run 3, D92)
  *   dictation(text) → { ops }            the cleaned phrase as insert operations, spoken commands resolved
  *   cleanSentences(text) → [sentence]    a recognised phrase, cleaned and split into sentences
  *   summarize(note) → { markdown, sections, counts }    the local summary: no model, the same for the same input
@@ -15,6 +17,13 @@
  * never leaves half a note. A transcript holds other people's words, which is why it stays in the per-user directory, as
  * the Live notes transcript does (D85). Deleting a note deletes its file and its agent handoff files.
  *
+ * CORRECTIONS AND VERSIONS (Run 3, D92). The PM can correct a line: its label (the six, or fact), whether it is in the
+ * summary, its tags, the people it names and its text. A corrected text keeps the first text the transcript recorded as
+ * `orig_text`, and its repository check is dropped because it was about the old words. Every save of the notes keeps the
+ * state before it in `versions`; a save within VERSION_FOLD_MS of the last kept version keeps nothing new, so a burst of
+ * typing is one version, and the first version is never replaced. While a note has been recorded, each new line of the
+ * notes gets the meeting time it was first saved at (`line_times`), so a replay can show what was typed when.
+ *
  * SPEECH. This file never sees audio. Words reach it from local Whisper (lib/notes-whisper.js, D91) or from the browser's
  * on-device recognition (processLocally, no cloud fallback, D85). A transcript line carries its source: `mic` and
  * `meeting` from Whisper, `speech` from the browser. The note names each source ("You", "Meeting"); the PM can rename it.
@@ -43,6 +52,10 @@ const MAX_BODY = 400 * 1024;
 const MAX_PHRASE = 4000;
 const MAX_SEGMENTS = 20000;
 const MAX_AGENT_SUMMARY = 64 * 1024;
+const VERSION_FOLD_MS = 2 * 60 * 1000;
+const MAX_VERSIONS = 200;
+const MAX_TAGS = 12;
+const MAX_LINE_TIMES = 2000;
 const notesDir = (dir) => path.join(dir, 'notes');
 const handoffDir = (dir) => path.join(notesDir(dir), 'handoff');
 const fileOf = (dir, id) => path.join(notesDir(dir), id + '.json');
@@ -97,15 +110,51 @@ function read(dir, id) {
 function save(dir, { id, title, body, now = Date.now() } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
-  if (title !== undefined) note.title = cleanTitle(title);
+  const nextTitle = title !== undefined ? cleanTitle(title) : note.title;
+  let nextBody = note.body;
   if (body !== undefined) {
-    const b = String(body == null ? '' : body);
-    if (Buffer.byteLength(b) > MAX_BODY) return err(413, 'the note is too long to save: keep it under 400 KB');
-    note.body = b;
+    nextBody = String(body == null ? '' : body);
+    if (Buffer.byteLength(nextBody) > MAX_BODY) return err(413, 'the note is too long to save: keep it under 400 KB');
+  }
+  if (nextTitle !== note.title || nextBody !== (note.body || '')) {
+    keepVersion(note, now);
+    if (nextBody !== (note.body || '')) stampLines(note, nextBody, now);
   }
+  note.title = nextTitle; note.body = nextBody;
   note.updated_at = iso(now);
   store(dir, note);
-  return { ok: true, updated_at: note.updated_at };
+  return { ok: true, updated_at: note.updated_at, versions: (note.versions || []).length };
+}
+/** Keep the note's text before this save, unless the last kept version is younger than VERSION_FOLD_MS. Notes with no
+ * text yet are not a version. The first version is never dropped, so the original stays. */
+function keepVersion(note, now) {
+  if (!String(note.body || '').trim()) return;
+  const vs = note.versions || (note.versions = []);
+  const last = vs[vs.length - 1];
+  if (last && now - Date.parse(last.kept_at) < VERSION_FOLD_MS) return;
+  vs.push({ at: note.body_at || note.updated_at, kept_at: iso(now), title: note.title || '', body: note.body || '' });
+  if (vs.length > MAX_VERSIONS) vs.splice(1, 1);
+  note.body_at = iso(now);
+}
+/** Each line of the notes that is new in this save gets the meeting time it appeared at. */
+function stampLines(note, body, now) {
+  if (!note.recorded_from) return;
+  const t = now - Date.parse(note.recorded_from);
+  if (!(t >= 0)) return;
+  const prev = note.line_times || {};
+  const next = {};
+  for (const raw of String(body).split(/\r?\n/)) {
+    const l = raw.trim();
+    if (!l || next[l] !== undefined) continue;
+    next[l] = prev[l] !== undefined ? prev[l] : Math.round(t);
+    if (Object.keys(next).length >= MAX_LINE_TIMES) break;
+  }
+  note.line_times = next;
+}
+/** Every kept version, oldest first, then the current text. The first is the original. */
+function versionsOf(note) {
+  const vs = (note.versions || []).map((v, i) => ({ at: v.at, title: v.title, body: v.body, original: i === 0 }));
+  return vs;
 }
 function remove(dir, id) {
   if (!load(dir, id)) return err(404, 'no such note');
@@ -176,11 +225,47 @@ function setLabel(dir, { id, index, cat, drop = false, now = Date.now() } = {})
   if (!note) return err(404, 'no such note');
   const seg = (note.transcript || [])[index];
   if (!seg) return err(404, 'no such line');
-  if (!CATS.includes(cat)) return err(400, 'the label must be one of: ' + CATS.join(', '));
+  if (!PM_CATS.includes(cat)) return err(400, 'the label must be one of: ' + PM_CATS.join(', '));
   seg.cat = cat; seg.cat_by = 'pm'; if (drop) seg.dropped = true; else delete seg.dropped; note.updated_at = iso(now);
   store(dir, note);
   return { ok: true, segment: seg };
 }
+const cleanTag = (t) => String(t == null ? '' : t).replace(/^[#\s]+/, '').replace(/\s+/g, '-').replace(/[^\p{L}\p{N}_-]/gu, '').slice(0, 40);
+const cleanPerson = (p) => String(p == null ? '' : p).replace(/^[@\s]+/, '').replace(/\s+/g, ' ').trim().slice(0, 60);
+const uniq = (xs) => { const seen = new Set(); return xs.filter((x) => { const k = x.toLowerCase(); if (!x || seen.has(k)) return false; seen.add(k); return true; }); };
+/** The PM's corrections to one line. Each field is optional; what is not given is kept. */
+function editLine(dir, { id, index, cat, summary, tags, people, text, now = Date.now() } = {}) {
+  const note = load(dir, id);
+  if (!note) return err(404, 'no such note');
+  const seg = (note.transcript || [])[index];
+  if (!seg) return err(404, 'no such line');
+  if (cat !== undefined && !PM_CATS.includes(cat)) return err(400, 'the label must be one of: ' + PM_CATS.join(', '));
+  if (summary !== undefined && summary !== null && typeof summary !== 'boolean') return err(400, 'summary must be true, false or null');
+  if (tags !== undefined && !Array.isArray(tags)) return err(400, 'tags must be a list');
+  if (people !== undefined && !Array.isArray(people)) return err(400, 'people must be a list');
+  let resummarize = false;
+  if (text !== undefined) {
+    const t = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+    if (!t) return err(400, 'a line cannot be empty: remove it from its section instead');
+    if (t.length > MAX_PHRASE) return err(413, 'that line is too long');
+    if (t !== seg.text) {
+      if (seg.orig_text === undefined) seg.orig_text = seg.text;
+      if (t === seg.orig_text) { delete seg.orig_text; delete seg.edited_at; } else seg.edited_at = iso(now);
+      seg.text = t; delete seg.check; resummarize = true;
+    }
+  }
+  if (cat !== undefined) { seg.cat = cat; seg.cat_by = 'pm'; delete seg.dropped; resummarize = true; }
+  if (summary !== undefined) { if (summary === null) delete seg.in_summary; else seg.in_summary = summary; resummarize = true; }
+  if (tags !== undefined) { const v = uniq(tags.map(cleanTag)).slice(0, MAX_TAGS); if (v.length) seg.tags = v; else delete seg.tags; }
+  if (people !== undefined) { const v = uniq(people.map(cleanPerson)).slice(0, MAX_TAGS); if (v.length) seg.people = v; else delete seg.people; }
+  if (resummarize && note.summary && note.summary.source === 'local') {
+    const sm = summarize(note);
+    note.summary = { source: 'local', at: iso(now), markdown: sm.markdown, sections: sm.sections };
+  }
+  note.updated_at = iso(now);
+  store(dir, note);
+  return { ok: true, segment: seg, summary: note.summary || null };
+}
 function renameSpeaker(dir, { id, source, name, now = Date.now() } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
@@ -325,6 +410,8 @@ function isQuestion(s) {
 }
 /* ── the local label (Run 2) ───────────────────────────────────────────────────────────────────── */
 const CATS = ['decision', 'action', 'question', 'topic', 'statement', 'small talk'];
+// the labels the PM may set: the six a rule or Jev may give, and fact, which only the PM gives
+const PM_CATS = ['decision', 'action', 'question', 'fact', 'topic', 'statement', 'small talk'];
 const SMALL_TALK = /^(?:(?:ok(?:ay)?|so|and|well|um|uh)[, ]+)*(?:hi|hello|hey|morning|good (?:morning|afternoon|evening)|thanks?(?: you)?|thank you|bye|see you|cheers|can you (?:hear|see) me|you(?:'re| are) (?:on )?mute|one sec(?:ond)?|sorry|ok(?:ay)?|yeah|yes|no|right|cool|great|perfect|sounds good|let me share my screen|is everyone here|let's (?:start|begin|get started))\b/i;
 const TOPIC = /\b(?:let's (?:talk about|move on|discuss|look at|go through|turn to)|(?:the )?main (?:thing|topic|item|point)|agenda|next (?:topic|item)|moving on|today we(?:'re| are| will)|the (?:goal|point|idea|context|background|reason) (?:is|here)|what (?:this|that) means is|to give (?:you )?some context)\b/i;
 /** The local label of one line. Decisions, actions and questions use the summary's own rules, so both agree. */
@@ -340,7 +427,7 @@ function categoryOf(text, names) {
   return 'statement';
 }
 /** A statement worth listing under "Facts mentioned": it has a number, or the repository check found its passage. */
-const isFact = (x) => !x.dropped && x.cat === 'statement' && (/\d|\b(?:percent|half|double|twice)\b/i.test(x.text) || !!(x.check && x.check.doc));
+const isFact = (x) => !x.dropped && (x.cat === 'fact' || (x.cat === 'statement' && (/\d|\b(?:percent|half|double|twice)\b/i.test(x.text) || !!(x.check && x.check.doc))));
 const fmtTime = (ms) => {
   if (ms == null || !Number.isFinite(ms)) return null;
   const s = Math.floor(ms / 1000); const h = Math.floor(s / 3600); const m = Math.floor((s % 3600) / 60); const r = s % 60;
@@ -362,7 +449,8 @@ function bodySentences(body) {
 function summarize(note) {
   const tr = ((note && note.transcript) || []).filter((x) => x && x.text);
   const typed = bodySentences(note && note.body);
-  const items = tr.map((x, i) => ({ i, text: x.text, t: Number.isFinite(x.t) ? x.t : null, src: 'transcript', cat: x.cat || null, check: x.check || null, dropped: !!x.dropped }));
+  const items = tr.map((x, i) => ({ i, index: (note.transcript || []).indexOf(x), text: x.text, t: Number.isFinite(x.t) ? x.t : null, src: 'transcript', cat: x.cat || null, check: x.check || null, dropped: !!x.dropped,
+    in_summary: x.in_summary === true ? true : x.in_summary === false ? false : null }));
   for (const s of typed) items.push({ i: items.length, text: s, t: null, src: 'notes' });
   const terms = items.map((x) => [...new Set(termsOf(x.text))]);
   const names = namesIn(items.map((x) => x.text));
@@ -396,8 +484,11 @@ function summarize(note) {
   const k = Math.max(3, Math.min(7, Math.round(pool.length / 12)));
   const chosen = [];
   const jac = (a, b) => { const A = new Set(a); const B = new Set(b); let i = 0; for (const w of A) if (B.has(w)) i++; return i / ((A.size + B.size - i) || 1); };
+  // the PM's choice wins: a line put in the summary is in it, a line taken out never is
+  for (const x of pool) if (x.in_summary === true) chosen.push(x);
   for (const x of pool.slice().sort((a, b) => score[b.i] - score[a.i] || a.i - b.i)) {
     if (chosen.length >= k || score[x.i] <= 0) break;
+    if (x.in_summary === false || chosen.includes(x)) continue;
     if (chosen.some((c) => jac(terms[c.i], terms[x.i]) > 0.5)) continue;
     chosen.push(x);
   }
@@ -410,7 +501,7 @@ function summarize(note) {
   const questions = items.filter((x) => kindOf(x, 'question')).filter(once);
   const facts = items.filter((x) => x.src === 'transcript' && isFact(x)).filter(once);
   const sections = {
-    overview: chosen.map((x) => ({ text: x.text, at: cite(x) })),
+    overview: chosen.map((x) => (x.src === 'transcript' ? { text: x.text, at: cite(x), index: x.index } : { text: x.text, at: cite(x) })),
     decisions: decisions.map((x) => ({ text: x.text, at: cite(x) })),
     actions: actions.map((x) => ({ text: x.text, at: cite(x), owner: x.owner, due: x.due })),
     questions: questions.map((x) => ({ text: x.text, at: cite(x) })),
@@ -459,9 +550,11 @@ function toMarkdown(note, { redact = false, summary = true } = {}) {
   if (String(note.body || '').trim()) out.push('## Notes', '', ...String(note.body).split(/\r?\n/).map(line), '');
   const sum = note.agent && note.agent.markdown ? note.agent.markdown : note.summary && note.summary.markdown;
   if (summary && sum) out.push('## Summary', '', ...sum.split(/\r?\n/).map(line), '');
-  if ((note.transcript || []).length) out.push('## Transcript', '', ...note.transcript.map((x) => line('[' + fmtTime(x.t) + '] ' + (x.source && x.source !== 'speech' ? speakerOf(note, x.source) + ': ' : '') + x.text)), '');
+  if ((note.transcript || []).length) out.push('## Transcript', '', ...note.transcript.map((x) => line('[' + fmtTime(x.t) + '] ' + (x.source && x.source !== 'speech' ? speakerOf(note, x.source) + ': ' : '') + x.text + tagWords(x))), '');
   return { markdown: out.join('\n'), withheld };
 }
+/** " #tag @Person" for a line, or "". */
+const tagWords = (x) => [...(x.tags || []).map((t) => '#' + t), ...(x.people || []).map((p) => '@' + p)].map((w) => ' ' + w).join('');
 function promptFor(handoff, out) {
   return 'Summarize a meeting note for me. Read the file ' + handoff + ' (a PMOS meeting note: my typed notes and a transcript recognised on my machine). '
     + 'Write the summary in Markdown to the file ' + out + ' with these sections: ### Overview (three to six bullets on what the meeting was about and concluded), '
@@ -507,5 +600,5 @@ function importAgent(dir, note) {
   return true;
 }
 
-module.exports = { list, read, create, save, remove, record, appendTranscript, updateSegment, setLabel, renameSpeaker, speakerOf, categoryOf, isFact, CATS, setPrivate, dictation, cleanSentences, spokenPunctuation,
+module.exports = { list, read, create, save, remove, record, 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 };

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.64.0",
+  "version": "0.65.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.64.0",
+  "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;

package/workspace/public/pm/view-notes.js

@@ -1,4 +1,4 @@
-/* pm/view-notes.js — the Notes view tab: one meeting on one screen (meeting-notes, Runs 1 and 2).
+/* pm/view-notes.js — the Notes view tab: one meeting on one screen (meeting-notes, Runs 1 to 3).
  *
  * The screen follows the simplified mockup the PM reviewed (prototype/meeting-notes):
  *   header      the title and the date, and one action: Listen; while listening a red dot, the time, the sources and Stop;
@@ -17,10 +17,17 @@
  * LABELS AND CHECKS. The server labels each line locally; behind the D91 gates Jev labels it and compares a captured line
  * with the closest repository passage. The page shows the result in words and reads it by polling the note.
  *
+ * CORRECT, TRACK AND REPLAY (Run 3, D92). The ellipsis on a transcript line opens its editor: the words (the words that
+ * were heard stay kept and the line shows "edited"), the label, whether it is in the summary, tags and people. Tags and
+ * people show on the line, on its item and under Tagged. Each save of the notes keeps the text before it, and History
+ * shows every version as a line diff, the original first. When the note kept its audio, Replay plays it; while it plays,
+ * the transcript line, its item and the note line written at that moment are highlighted, and a time in the transcript
+ * jumps there. Your notes are shown read-only while the meeting plays, so their lines can be highlighted.
+ *
  * Reads and writes (lib/routes-notes.js). Notes live in the per-user runtime directory, never in a repository:
- *   GET  /api/notes · /api/notes/one?id=… · /api/notes/engine?ws=…
+ *   GET  /api/notes · /api/notes/one?id=… · /api/notes/engine?ws=… · /api/notes/recording?id=… · /api/people?ws=…
  *   POST /api/notes/new · save · dictate · record · transcript · audio · label · speaker · switch · whisper-setup · private
- *        · summarize · summarize-agent · delete
+ *        · summarize · summarize-agent · delete · line · recording-delete
  */
 import { el } from './dom.js';
 import { askConfirm, askText } from './dialogs.js';
@@ -49,6 +56,9 @@ let engine = null;            // { ws, whisper, jev, at }
 let showList = false;
 let pollTimer = null; let agentTimer = null;
 let busy = '';
+let player = null;            // the replay: { id, bytes, el, playing }, kept across redraws so playback goes on
+let people = null;            // { ws, names } — the repository's people, offered in the line editor
+const LABELS = [['decision', 'Decision'], ['action', 'Action'], ['question', 'Question'], ['fact', 'Fact'], ['topic', 'Topic'], ['statement', 'Statement'], ['small talk', 'Small talk']];
 
 const nowClock = (iso) => { try { return new Date(iso).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); } catch { return ''; } };
 const dayOf = (iso) => { try { return new Date(iso).toLocaleDateString([], { weekday: 'short', day: 'numeric', month: 'short' }); } catch { return ''; } };
@@ -107,6 +117,42 @@ export function caught(n) {
   return out;
 }
 const checkWords = (c) => (!c ? '' : c.verdict === 'differs' ? 'differs from ' + c.doc : c.verdict === 'agrees' ? 'consistent with ' + c.doc : 'see ' + c.doc);
+/** " #tag @Person" for a line, or ''. Pure. */
+export const tagWords = (x) => [...((x && x.tags) || []).map((t) => ' #' + t), ...((x && x.people) || []).map((p) => ' @' + p)].join('');
+/** The lines with tags or people that are not already a caught item, in the order they were said. Pure. */
+export function tagged(n) {
+  const c = caught(n);
+  const inItems = new Set(Object.values(c).flat().map((x) => x.index));
+  return (n.transcript || []).map((x, index) => ({ ...x, index }))
+    .filter((x) => x && x.text && !x.dropped && !inItems.has(x.index) && ((x.tags && x.tags.length) || (x.people && x.people.length)));
+}
+/** The index of the last item whose time is at or before `ms`, or -1. `times` is in meeting order. Pure. */
+export function nowIndex(times, ms) {
+  let best = -1;
+  for (let i = 0; i < times.length; i++) if (typeof times[i] === 'number' && times[i] <= ms && (best < 0 || times[i] >= times[best])) best = i;
+  return best;
+}
+/** The note line written at meeting time `ms`: of the lines that have a time at or before it, the latest. Pure. */
+export function noteLineAt(body, lineTimes, ms) {
+  const lines = String(body || '').split(/\r?\n/);
+  return nowIndex(lines.map((l) => (l.trim() && lineTimes ? lineTimes[l.trim()] : undefined)), ms);
+}
+/** A line diff from `a` to `b`: [{ op: 'same'|'del'|'add', text }]. Longest common subsequence of lines. Pure. */
+export function lineDiff(a, b) {
+  const x = String(a || '').split(/\r?\n/); const y = String(b || '').split(/\r?\n/);
+  if (x.length * y.length > 250000) return [...x.map((t) => ({ op: 'del', text: t })), ...y.map((t) => ({ op: 'add', text: t }))];
+  const L = Array.from({ length: x.length + 1 }, () => new Array(y.length + 1).fill(0));
+  for (let i = x.length - 1; i >= 0; i--) for (let j = y.length - 1; j >= 0; j--) L[i][j] = x[i] === y[j] ? L[i + 1][j + 1] + 1 : Math.max(L[i + 1][j], L[i][j + 1]);
+  const out = []; let i = 0; let j = 0;
+  while (i < x.length && j < y.length) {
+    if (x[i] === y[j]) { out.push({ op: 'same', text: x[i] }); i++; j++; }
+    else if (L[i + 1][j] >= L[i][j + 1]) out.push({ op: 'del', text: x[i++] });
+    else out.push({ op: 'add', text: y[j++] });
+  }
+  while (i < x.length) out.push({ op: 'del', text: x[i++] });
+  while (j < y.length) out.push({ op: 'add', text: y[j++] });
+  return out;
+}
 /** The whole note as Markdown, for "Copy as Markdown". Pure, for the suite. */
 export function noteMarkdown(n) {
   const out = ['# ' + (n.title || 'Untitled note'), ''];
@@ -118,9 +164,11 @@ export function noteMarkdown(n) {
   for (const [k, title] of [...SECTIONS, ['fact', 'Facts mentioned']]) {
     if (!c[k].length) continue;
     out.push('## ' + title, '', ...c[k].map((x) => '- ' + (k === 'action' && x.source && x.source !== 'speech' ? speakerOf(n, x.source) + ': ' : '') + x.text
-      + (x.check && x.check.verdict !== 'related' ? ' (' + checkWords(x.check) + ')' : '') + ' [' + fmtTime(x.t) + ']'), '');
+      + tagWords(x) + (x.check && x.check.verdict !== 'related' ? ' (' + checkWords(x.check) + ')' : '') + ' [' + fmtTime(x.t) + ']'), '');
   }
-  if ((n.transcript || []).length) out.push('## Transcript', '', ...n.transcript.map((x) => '[' + fmtTime(x.t) + '] ' + speakerOf(n, x.source) + ': ' + x.text), '');
+  const tg = tagged(n);
+  if (tg.length) out.push('## Tagged', '', ...tg.map((x) => '- ' + x.text + tagWords(x) + ' [' + fmtTime(x.t) + ']'), '');
+  if ((n.transcript || []).length) out.push('## Transcript', '', ...n.transcript.map((x) => '[' + fmtTime(x.t) + '] ' + speakerOf(n, x.source) + ': ' + x.text + tagWords(x)), '');
   return out.join('\n');
 }
 /** Float samples at `inRate` as 16 kHz 16-bit samples. Each output sample averages the input samples it covers. Pure. */
@@ -151,7 +199,7 @@ async function loadList(ctx) {
   if (!currentId && list.notes.length) currentId = list.notes[0].id;
   ctx.setState({});
 }
-const sig = (n) => JSON.stringify([n.transcript, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title]);
+const sig = (n) => JSON.stringify([n.transcript, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title, (n.versions || []).length, n.__recording && n.__recording.bytes]);
 async function loadNote(ctx, id) {
   const r = await pmGet('/api/notes/one?id=' + encodeURIComponent(id));
   if (r && r.ok) {
@@ -159,6 +207,7 @@ async function loadNote(ctx, id) {
     // what the PM is typing wins over what the server last saved
     if (editor && editor.id === id && dirty) { r.note.title = editor.title.value; r.note.body = editor.body.value; }
     r.note.__audio = r.audio || null;
+    r.note.__recording = r.recording || null;
     cache.set(id, r.note);
     if (!had || sig(had) !== sig(r.note)) ctx.setState({});
   } else if (r && r.status === 404) { cache.delete(id); if (currentId === id) currentId = null; loadList(ctx); }
@@ -210,6 +259,8 @@ async function flushSave(ctx) {
   if (r && r.ok) {
     savedAt = r.updated_at; saveError = null;
     const n = cache.get(id); if (n) { n.title = title; n.body = body; n.updated_at = r.updated_at; touchRow(n); }
+    // a new version was kept: read it, so History shows it
+    if (n && typeof r.versions === 'number' && r.versions !== (n.versions || []).length) loadNote(ctx, id);
   } else { dirty = true; saveError = (r && r.error) || 'not saved'; }
   if (dirty && !saveError) scheduleSave(ctx);     // typed while the save was in flight
   paintSaveState();
@@ -237,14 +288,14 @@ async function selectNote(ctx, id) {
   showList = false;
   if (id === currentId) { ctx.setState({}); return; }
   await stopAll(ctx); await flushSave(ctx);
-  currentId = id; editor = null; savedAt = null; saveError = null; banner = null;
+  currentId = id; editor = null; savedAt = null; saveError = null; banner = null; dropPlayer();
   ctx.setState({});
   loadNote(ctx, id);
 }
 async function deleteNote(ctx, n) {
   const sure = await askConfirm({ title: 'Delete this note?', body: '"' + (n.title || 'Untitled note') + '" and its transcript and summaries are deleted from this machine. This cannot be undone.', confirmLabel: 'Delete note', danger: true });
   if (!sure) return;
-  await stopAll(ctx, { discard: true }); clearTimeout(saveTimer); dirty = false;
+  await stopAll(ctx, { discard: true }); clearTimeout(saveTimer); dirty = false; dropPlayer();
   const r = await pmPost('/api/notes/delete', { id: n.id });
   if (r && r.ok) { cache.delete(n.id); currentId = null; editor = null; if (list) list.notes = (list.notes || []).filter((x) => x.id !== n.id); if (list && list.notes.length) currentId = list.notes[0].id; banner = { tone: 'ok', text: 'The note was deleted.' }; }
   else banner = { tone: 'bad', text: (r && r.error) || 'the note was not deleted' };
@@ -254,7 +305,7 @@ async function setPrivate(ctx, n, priv) {
   // a private press drops what is still buffered: nothing more is sent, transcribed or summarized
   if (priv) await stopAll(ctx, { discard: true });
   const r = await pmPost('/api/notes/private', { id: n.id, private: priv });
-  if (r && r.ok) { n.private = r.private; touchRow(n); banner = priv ? { tone: 'ok', text: 'Marked private. Listening stopped, and nothing from this note goes to Jev or to any agent.' } : null; }
+  if (r && r.ok) { n.private = r.private; if (priv) { n.__recording = null; dropPlayer(); } touchRow(n); banner = priv ? { tone: 'ok', text: 'Marked private. Listening stopped, its audio was deleted, and nothing from this note goes to Jev or to any agent.' } : null; }
   else banner = { tone: 'bad', text: (r && r.error) || 'not changed' };
   ctx.setState({});
 }
@@ -310,6 +361,133 @@ async function renameSpeaker(ctx, n, source) {
   ctx.setState({});
 }
 
+/* ── corrections, history and replay (Run 3, D92) ─────────────────────────────────────────────────── */
+async function peopleNames(ctx) {
+  const ws = wsOf(ctx);
+  if (people && people.ws === ws) return people.names;
+  const r = await pmGet('/api/people' + (ws ? '?ws=' + encodeURIComponent(ws) : ''));
+  const names = r && r.ok && Array.isArray(r.people) ? [...new Set(r.people.map((x) => x && x.name).filter(Boolean))].slice(0, 24) : [];
+  people = { ws, names };
+  return names;
+}
+const splitTags = (v) => String(v || '').split(/[\s,]+/).map((t) => t.replace(/^#+/, '')).filter(Boolean);
+const splitPeople = (v) => String(v || '').split(',').map((t) => t.replace(/^\s*@/, '').trim()).filter(Boolean);
+/** The editor for one transcript line: its words, label, place in the summary, tags and people. */
+async function editLine(ctx, n, index) {
+  const x = (n.transcript || [])[index];
+  if (!x) return;
+  const text = field({ label: 'Words', kind: 'textarea', value: x.text, attrs: { 'data-nt-ed-text': '' } });
+  const cat = field({ label: 'Label', kind: 'select', value: LABELS.some(([v]) => v === x.cat) ? x.cat : 'statement', options: LABELS.map(([value, label]) => ({ value, label })), attrs: { 'data-nt-ed-cat': '' } });
+  const sumv = x.in_summary === true ? 'in' : x.in_summary === false ? 'out' : 'auto';
+  const sum = field({ label: 'Summary', kind: 'select', value: sumv, options: [{ value: 'auto', label: 'As picked' }, { value: 'in', label: 'Always in the summary' }, { value: 'out', label: 'Never in the summary' }], attrs: { 'data-nt-ed-summary': '' } });
+  const tags = field({ label: 'Tags', value: (x.tags || []).map((t) => '#' + t).join(' '), placeholder: '#pricing #trial', attrs: { 'data-nt-ed-tags': '' } });
+  const ppl = field({ label: 'People', value: (x.people || []).join(', '), placeholder: 'Names, separated by commas', attrs: { 'data-nt-ed-people': '' } });
+  const sugg = el('div', { class: 'nt-row', 'data-nt-ed-suggest': '' });
+  const addPerson = (name) => {
+    const have = splitPeople(ppl.control.value);
+    if (!have.some((h) => h.toLowerCase() === name.toLowerCase())) ppl.control.value = [...have, name].join(', ');
+  };
+  const heard = x.orig_text !== undefined
+    ? el('div', { class: 'nt-heard', 'data-nt-ed-orig': '' }, el('p', { class: 'nt-hint' }, 'Heard as: ' + x.orig_text),
+      button({ label: 'Use what was heard', variant: 'ghost', size: 'sm', icon: 'undo-2', onClick: () => { text.control.value = x.orig_text; }, attrs: { 'data-nt-ed-restore': '' } }))
+    : null;
+  let h = null;
+  const save = async () => {
+    const patch = { id: n.id, index, tags: splitTags(tags.control.value), people: splitPeople(ppl.control.value) };
+    const t = text.control.value.replace(/\s+/g, ' ').trim();
+    if (t !== x.text) patch.text = t;
+    if (cat.control.value !== x.cat) patch.cat = cat.control.value;
+    if (sum.control.value !== sumv) patch.summary = sum.control.value === 'in' ? true : sum.control.value === 'out' ? false : null;
+    const r = await pmPost('/api/notes/line', patch);
+    if (r && r.ok) { n.transcript[index] = r.segment; if (r.summary) n.summary = r.summary; banner = null; h.close(); }
+    else banner = { tone: 'bad', text: (r && r.error) || 'the line was not changed' };
+    ctx.setState({});
+  };
+  h = sheet({ title: 'Correct this line', sub: speakerOf(n, x.source) + ', ' + fmtTime(x.t), body: [text, heard, cat, sum, tags, ppl, sugg], attrs: { 'data-nt-line-sheet': '' },
+    actions: [button({ label: 'Cancel', variant: 'ghost', onClick: () => h.close() }), button({ label: 'Save', variant: 'primary', onClick: save, attrs: { 'data-nt-ed-save': '' } })] });
+  const names = await peopleNames(ctx);
+  if (h.open && names.length) sugg.replaceChildren(...names.map((name) => button({ label: name, icon: 'plus', variant: 'ghost', size: 'sm', onClick: () => addPerson(name), attrs: { 'data-nt-ed-person': name } })));
+}
+async function unsummarize(ctx, n, index) {
+  const r = await pmPost('/api/notes/line', { id: n.id, index, summary: false });
+  if (r && r.ok) { n.transcript[index] = r.segment; if (r.summary) n.summary = r.summary; } else banner = { tone: 'bad', text: (r && r.error) || 'not changed' };
+  ctx.setState({});
+}
+/** Every kept version of the notes, newest first, each as the lines it changed from the one before. */
+function openHistory(ctx, n) {
+  const vs = n.versions || [];
+  const now = { at: n.updated_at, title: editor && editor.id === n.id ? editor.title.value : n.title, body: editor && editor.id === n.id ? editor.body.value : n.body, current: true };
+  const all = [...vs, now];
+  const when = (iso) => dayOf(iso) + ', ' + nowClock(iso);
+  let h = null;
+  const restore = (v) => {
+    h.close();
+    if (!editor || editor.id !== n.id) return;
+    editor.title.value = v.title || ''; editor.body.value = v.body || '';
+    banner = { tone: 'ok', text: 'The version from ' + when(v.at) + ' is back in your notes. The text before it is kept in History.' };
+    scheduleSave(ctx); ctx.setState({});
+  };
+  const items = all.map((v, i) => {
+    const diff = i === 0 ? String(v.body || '').split(/\r?\n/).map((t) => ({ op: 'same', text: t })) : lineDiff(all[i - 1].body, v.body);
+    const head = v.current ? 'Now' : i === 0 ? 'Original, ' + when(v.at) : 'Version ' + (i + 1) + ', ' + when(v.at);
+    return el('div', { class: 'nt-ver', 'data-nt-version': v.current ? 'now' : String(i) },
+      el('div', { class: 'nt-set__head' }, head, i > 0 && all[i - 1].title !== v.title ? el('span', { class: 'nt-hint' }, ' · title: ' + (v.title || 'Untitled')) : null),
+      el('div', { class: 'nt-diff' }, diff.map((d) => el('div', { class: 'nt-diff__ln nt-diff__ln--' + d.op, 'data-nt-diff': d.op },
+        el('span', { class: 'nt-sr' }, d.op === 'add' ? 'added: ' : d.op === 'del' ? 'removed: ' : ''), d.text || ' '))),
+      v.current ? null : button({ label: 'Use this version', variant: 'ghost', size: 'sm', icon: 'undo-2', onClick: () => restore(v), attrs: { 'data-nt-restore': String(i) } }));
+  }).reverse();
+  h = sheet({ title: 'History of your notes', sub: vs.length + ' earlier version' + (vs.length === 1 ? '' : 's') + '. The original is kept.', body: items, attrs: { 'data-nt-history-sheet': '' } });
+}
+function dropPlayer() { if (player) { try { player.el.pause(); } catch { /* gone */ } player = null; } }
+/** The replay of the note's kept audio. One <audio> per note, kept across redraws so playback goes on. */
+function playerFor(ctx, n) {
+  const rec = n.__recording;
+  if (!rec || n.private) { if (player && player.id === n.id) dropPlayer(); return null; }
+  if (player && (player.id !== n.id || (player.bytes !== rec.bytes && !player.playing))) dropPlayer();
+  if (player) return player;
+  const a = el('audio', { controls: true, preload: 'metadata', class: 'nt-audio', 'data-nt-audio': '', src: '/api/notes/recording?id=' + encodeURIComponent(n.id) + '&b=' + rec.bytes });
+  const p = { id: n.id, bytes: rec.bytes, el: a, playing: false };
+  a.addEventListener('play', () => { p.playing = true; ctx.setState({}); });
+  a.addEventListener('pause', () => { p.playing = false; ctx.setState({}); });
+  a.addEventListener('ended', () => { p.playing = false; ctx.setState({}); });
+  a.addEventListener('timeupdate', paintNow);
+  a.addEventListener('seeked', paintNow);
+  player = p;
+  return p;
+}
+function seek(ctx, n, ms) {
+  const p = playerFor(ctx, n);
+  if (!p) return;
+  try { p.el.currentTime = Math.max(0, ms / 1000); p.el.play().catch(() => {}); } catch { /* not loaded yet */ }
+  paintNow();
+}
+/** Highlight the transcript line, its item and the note line at the replay's time. Classes only: no redraw. */
+function paintNow() {
+  if (typeof document === 'undefined') return;
+  for (const x of document.querySelectorAll('.nt-now')) x.classList.remove('nt-now');
+  const n = currentId ? cache.get(currentId) : null;
+  if (!player || !n || player.id !== n.id) return;
+  const ms = player.el.currentTime * 1000;
+  if (!player.playing && !(ms > 0)) return;
+  const i = nowIndex((n.transcript || []).map((x) => x.t), ms);
+  if (i >= 0) {
+    for (const x of document.querySelectorAll('[data-nt-seg="' + i + '"], [data-nt-item="' + i + '"], [data-nt-ov="' + i + '"]')) x.classList.add('nt-now');
+    const ln = document.querySelector('[data-nt-seg="' + i + '"]');
+    if (ln && player.playing && ln.scrollIntoView) ln.scrollIntoView({ block: 'nearest' });
+  }
+  const k = noteLineAt(editor && editor.id === n.id ? editor.body.value : n.body, n.line_times, ms);
+  if (k >= 0) { const nl = document.querySelector('[data-nt-noteline="' + k + '"]'); if (nl) nl.classList.add('nt-now'); }
+}
+async function deleteAudio(ctx, n) {
+  const sure = await askConfirm({ title: 'Delete this note\'s audio?', body: 'The recording of "' + (n.title || 'Untitled note') + '" is deleted from this machine. The notes and the transcript stay. This cannot be undone.', confirmLabel: 'Delete audio', danger: true });
+  if (!sure) return;
+  if (player && player.id === n.id) dropPlayer();
+  const r = await pmPost('/api/notes/recording-delete', { id: n.id });
+  if (r && r.ok) { n.__recording = null; banner = { tone: 'ok', text: 'The audio was deleted. The notes and the transcript are kept.' }; }
+  else banner = { tone: 'bad', text: (r && r.error) || 'the audio was not deleted' };
+  ctx.setState({});
+}
+
 /* ── listening with local Whisper ─────────────────────────────────────────────────────────────── */
 async function openSource(kind) {
   const md = navigator.mediaDevices;
@@ -491,7 +669,9 @@ async function chooseSources(ctx, n) {
   const meet = field({ label: 'The meeting', kind: 'check', value: local, attrs: { 'data-nt-src-meeting': '', disabled: !local } });
   const body = [mic, meet,
     el('p', { class: 'nt-hint' }, local ? 'Pick the meeting\'s tab or window next, and tick "Share tab audio".' : 'The meeting can be heard once local transcription is set up in Settings. Until then the microphone is recognised by the browser on this device.'),
-    el('p', { class: 'nt-consent', 'data-nt-consent': '' }, 'Speech is transcribed on this ' + (local ? 'machine' : 'device') + '. Let people know you\'re taking notes.')];
+    el('p', { class: 'nt-consent', 'data-nt-consent': '' }, local
+      ? 'Speech is transcribed on this machine' + (eng.whisper.keep_audio === false ? ', and no audio is kept' : ', and the audio is kept on this machine so you can replay the meeting') + '. Let people know you\'re taking notes.'
+      : 'Speech is recognised by the browser on this device, and no audio is kept. Let people know you\'re taking notes.')];
   let h = null;
   const go = () => {
     const want = [mic.control.checked && 'mic', local && meet.control.checked && 'meeting'].filter(Boolean);
@@ -504,7 +684,7 @@ async function chooseSources(ctx, n) {
 }
 async function setSwitch(ctx, patch) {
   const ws = wsOf(ctx);
-  if (!ws && patch.language === undefined && patch.model === undefined) return;
+  if (!ws && patch.language === undefined && patch.model === undefined && patch.keep_audio === undefined) return;
   const r = await pmPost('/api/notes/switch', ws ? { ws, ...patch } : patch);
   if (r && r.ok) engine = { ws, whisper: r.whisper, jev: r.jev, at: Date.now() };
   ctx.setState({});
@@ -531,7 +711,12 @@ function openSettings(ctx, n) {
         onCommit: (v) => setSwitch(ctx, { model: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-model': '' } }) : null,
       w && !w.ready ? button({ label: 'Set up in a terminal', onClick: () => { h.close(); whisperSetup(ctx); }, attrs: { 'data-nt-whisper-setup': '' } }) : null,
       w && w.ready && w.languages ? field({ label: 'Language spoken in the meeting', kind: 'select', value: w.language, options: w.languages,
-        onCommit: (v) => setSwitch(ctx, { language: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-language': '' } }) : null));
+        onCommit: (v) => setSwitch(ctx, { language: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-language': '' } }) : null,
+      w ? field({ label: 'Keep the audio for replay', kind: 'check', value: w.keep_audio !== false,
+        onCommit: (v) => setSwitch(ctx, { keep_audio: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-keep-audio': '' } }) : null,
+      w ? el('p', { class: 'nt-hint', 'data-nt-keep-hint': '' }, w.keep_audio !== false
+        ? 'The meeting audio is kept on this machine, outside every repository, until you delete it. It is never sent anywhere. Browser recognition keeps no audio.'
+        : 'No audio is kept: each clip is deleted once it is transcribed, and a meeting cannot be replayed.') : null));
     if (!wsOf(ctx)) parts.push(el('p', { class: 'nt-hint' }, 'Choose a repository to check notes against it.'));
     else {
       const jsw = field({ label: 'Label lines with Jev', kind: 'check', value: !!(j && j.jev), onCommit: (v) => setSwitch(ctx, { jev: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-sw-jev': '' } });
@@ -546,6 +731,7 @@ function openSettings(ctx, n) {
       el('div', { class: 'nt-row' },
         button({ label: n.private ? 'Mark not private' : 'Mark private', onClick: () => { h.close(); setPrivate(ctx, n, !n.private); }, attrs: { [n.private ? 'data-nt-unprivate' : 'data-nt-mark-private']: '' } }),
         button({ label: busy === 'agent' ? 'Starting …' : 'Summary by agent', disabled: n.private || busy === 'agent', onClick: () => { h.close(); summarizeAgent(ctx, n); }, attrs: { 'data-nt-summarize-agent': '' } }),
+        n.__recording ? button({ label: 'Delete this note\'s audio', variant: 'ghost', onClick: () => { h.close(); deleteAudio(ctx, n); }, attrs: { 'data-nt-delete-audio': '' } }) : null,
         button({ label: 'Delete', variant: 'ghost', onClick: () => { h.close(); deleteNote(ctx, n); }, attrs: { 'data-nt-delete': '' } }))));
     return parts;
   };
@@ -584,7 +770,9 @@ function listening(n) {
 function header(ctx, n, ed) {
   const live = listening(n);
   const when = el('span', { class: 'nt-when' }, dayOf(n.created_at) + ', ' + nowClock(n.created_at));
-  const left = el('div', { class: 'nt-headl' }, ed.titleWrap, when, el('span', { class: 'nt-saved', 'data-nt-saved': '' }, saveWords()));
+  const nv = (n.versions || []).length;
+  const left = el('div', { class: 'nt-headl' }, ed.titleWrap, when, el('span', { class: 'nt-saved', 'data-nt-saved': '' }, saveWords()),
+    nv ? button({ label: 'Edited', icon: 'history', variant: 'ghost', size: 'sm', onClick: () => openHistory(ctx, n), attrs: { 'data-nt-history': String(nv), title: nv + ' earlier version' + (nv === 1 ? '' : 's') + ' kept' } }) : null);
   const acts = [];
   if (live) {
     acts.push(el('span', { class: 'nt-live', 'data-nt-listening': live.kind, role: 'status' },
@@ -622,6 +810,11 @@ function checkMark(x) {
   if (c.verdict === 'agrees') return el('span', { class: 'nt-ok', 'data-nt-check': 'agrees', title: 'Jev rates it ' + (c.words || 'likely') + ' that ' + where + ' already says this', role: 'img', 'aria-label': 'consistent with ' + baseName(c.doc) }, icon('check'));
   return el('span', { class: 'nt-rel', 'data-nt-check': 'related', title: 'The closest passage in this repository: ' + where }, 'see ' + baseName(c.doc));
 }
+function chips(x) {
+  return [...(x.tags || []).map((t) => el('span', { class: 'nt-tag', 'data-nt-tag': t }, '#' + t)),
+    ...(x.people || []).map((p) => el('span', { class: 'nt-tag nt-tag--person', 'data-nt-person': p }, '@' + p))];
+}
+const editedMark = (x) => (x.orig_text !== undefined ? el('span', { class: 'nt-edited', 'data-nt-edited': '', title: 'Heard as: ' + x.orig_text }, 'edited') : null);
 function sectionOf(ctx, n, key, title, items) {
   if (!items.length) return null;
   return el('section', { class: 'nt-sec', 'data-nt-sec': key },
@@ -629,9 +822,9 @@ function sectionOf(ctx, n, key, title, items) {
     el('ul', { class: 'nt-items' }, items.map((x) => el('li', { class: 'nt-item', 'data-nt-item': String(x.index) },
       el('span', { class: 'nt-item__text' },
         key === 'action' && x.source && x.source !== 'speech' ? el('span', { class: 'nt-who' }, speakerOf(n, x.source) + ': ') : null,
-        x.text, ' ', checkMark(x)),
+        x.text, ' ', checkMark(x), ' ', editedMark(x), chips(x)),
       el('span', { class: 'nt-at' }, fmtTime(x.t)),
-      key === 'fact' ? null : iconButton({ icon: 'x', ariaLabel: 'Remove from ' + title, onClick: () => unpick(ctx, n, x), size: 'sm', attrs: { 'data-nt-unpick': String(x.index) } })))));
+      key === 'fact' || key === 'tagged' ? null : iconButton({ icon: 'x', ariaLabel: 'Remove from ' + title, onClick: () => unpick(ctx, n, x), size: 'sm', attrs: { 'data-nt-unpick': String(x.index) } })))));
 }
 function summarySection(ctx, n) {
   const a = n.agent;
@@ -646,13 +839,19 @@ function summarySection(ctx, n) {
   else if (a && a.started === false && a.reason) out.push(el('p', { class: 'nt-hint', 'data-nt-agent-failed': '' }, 'No agent session started: ' + a.reason + '.'));
   if (!ov || !ov.length) return out.length ? el('section', { class: 'nt-sec' }, out) : null;
   return el('section', { class: 'nt-sec', 'data-nt-summary': 'local' }, el('h3', { class: 'nt-sec__h' }, 'Summary'),
-    el('ul', { class: 'nt-items' }, ov.map((x) => el('li', { class: 'nt-item nt-item--plain' }, el('span', { class: 'nt-item__text' }, x.text)))),
+    el('ul', { class: 'nt-items' }, ov.map((x) => el('li', { class: 'nt-item nt-item--plain', 'data-nt-ov': x.index === undefined ? null : String(x.index) }, el('span', { class: 'nt-item__text' }, x.text),
+      x.index === undefined ? null : iconButton({ icon: 'x', ariaLabel: 'Take out of the summary', onClick: () => unsummarize(ctx, n, x.index), size: 'sm', attrs: { 'data-nt-unsum': String(x.index) } })))),
     el('p', { class: 'nt-hint' }, 'Picked from what was said, on this machine.'), ...out);
 }
 function noteColumn(ctx, n, ed) {
   const live = listening(n);
   const c = caught(n);
-  const parts = [summarySection(ctx, n), ed.bodyWrap];
+  const replaying = player && player.id === n.id && player.playing;
+  const notes = replaying
+    ? el('div', { class: 'nt-notelines', 'data-nt-notelines': '' }, String(ed.body.value || '').split(/\r?\n/).map((l, k) => el('div', { class: 'nt-noteline', 'data-nt-noteline': String(k) }, l || ' ')),
+      el('p', { class: 'nt-hint' }, 'Your notes, as the meeting plays. Pause to edit them.'))
+    : ed.bodyWrap;
+  const parts = [summarySection(ctx, n), notes];
   const sp = speech && speech.id === n.id ? speech : null;
   const bar = [];
   if (sp && sp.mode === 'dictate' && sp.state === 'on') bar.push(el('span', { class: 'nt-hint', 'data-nt-listening': 'dictate', role: 'status' }, 'Dictating into your notes.'), button({ label: 'Stop dictating', variant: 'ghost', onClick: () => { stopSpeech(); ctx.setState({}); }, attrs: { 'data-nt-stop-dictate': '' } }));
@@ -663,6 +862,7 @@ function noteColumn(ctx, n, ed) {
   if (n.__audio && n.__audio.error && live) parts.push(el('p', { class: 'nt-hint nt-hint--bad', 'data-nt-audio-error': '' }, n.__audio.error));
   const secs = SECTIONS.map(([k, t]) => sectionOf(ctx, n, k, t, c[k])).filter(Boolean);
   if (!live && (n.transcript || []).length) { const f = sectionOf(ctx, n, 'fact', 'Facts mentioned', c.fact); if (f) secs.push(f); }
+  const tg = sectionOf(ctx, n, 'tagged', 'Tagged', tagged(n)); if (tg) secs.push(tg);
   if (secs.length) parts.push(...secs);
   else parts.push(el('p', { class: 'nt-hint', 'data-nt-caught-hint': '' }, live ? 'Listening …' : (n.transcript || []).length ? 'Nothing was caught as a decision, action or question.'
     : 'Decisions, actions and questions appear here as they are said, each checked against this repository.'));
@@ -677,8 +877,13 @@ function transcriptColumn(ctx, n) {
     const spk = x.source === 'meeting'
       ? button({ label: who, variant: 'ghost', size: 'sm', onClick: () => renameSpeaker(ctx, n, 'meeting'), attrs: { 'data-nt-spk': 'meeting', title: 'Name this speaker' } })
       : el('span', { class: 'nt-spk', 'data-nt-spk': x.source || 'speech' }, who);
-    return el('div', { class: 'nt-ln' + (['decision', 'action', 'question'].includes(x.cat) ? ' nt-ln--picked' : ''), 'data-nt-seg': String(i) },
-      el('div', { class: 'nt-ln__meta' }, spk, el('span', { class: 'nt-at' }, fmtTime(x.t)), lab), el('div', null, x.text));
+    const at = n.__recording && !live && typeof x.t === 'number'
+      ? button({ label: fmtTime(x.t), variant: 'ghost', size: 'sm', onClick: () => seek(ctx, n, x.t), attrs: { 'data-nt-seek': String(i), title: 'Play from here' } })
+      : el('span', { class: 'nt-at' }, fmtTime(x.t));
+    return el('div', { class: 'nt-ln' + (['decision', 'action', 'question', 'fact'].includes(x.cat) ? ' nt-ln--picked' : ''), 'data-nt-seg': String(i) },
+      el('div', { class: 'nt-ln__meta' }, spk, at, lab, editedMark(x),
+        iconButton({ icon: 'ellipsis', ariaLabel: 'Correct this line', onClick: () => editLine(ctx, n, i), size: 'sm', attrs: { 'data-nt-edit': String(i) } })),
+      el('div', null, x.text), x.tags || x.people ? el('div', { class: 'nt-tags' }, chips(x)) : null);
   });
   const sp = speech && speech.id === n.id && speech.mode === 'record' && speech.state === 'on' ? speech : null;
   if (sp) lines.push(el('div', { class: 'nt-ln nt-ln--interim', 'data-nt-interim': '', 'aria-live': 'polite' }, sp.interim || ''));
@@ -716,7 +921,11 @@ export function renderBoard(inner, ctx) {
     wrap.appendChild(header(ctx, n, ed));
     if (showList) wrap.appendChild(listPane(ctx));
     if (n.private) wrap.appendChild(el('p', { class: 'nt-hint', 'data-nt-private': '' }, 'This note is private: it is not recorded, and nothing from it goes to Jev or to any agent.'));
+    const pl = !listening(n) ? playerFor(ctx, n) : null;
+    if (pl) wrap.appendChild(el('div', { class: 'nt-replay', 'data-nt-part': 'replay' }, el('span', { class: 'nt-sec__h' }, 'Replay'), pl.el,
+      el('span', { class: 'nt-hint' }, 'Kept on this machine. Press a time in the transcript to play from there.')));
     wrap.appendChild(el('div', { class: 'nt-body2' }, noteColumn(ctx, n, ed), transcriptColumn(ctx, n)));
+    if (pl) queueMicrotask(paintNow);
     if (n.agent && n.agent.started && !n.agent.markdown && !agentTimer) pollAgent(ctx, n.id);
     requestAnimationFrame(fitBody);
   }