create-pmos 0.63.2 → 0.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.63.2",
+  "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@586dc2f
-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:17:22Z"}
+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:17:22Z"}
+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:17:22Z"}
+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/guide/people.md

@@ -12,20 +12,26 @@ People lists the people you work with in the current repository. For each person
 
 ## How people get into People
 
-The workspace does not read your mail, chat, calendar or Jira. Agent sessions that already read them with your own connectors record the people they see:
+People adds every person it finds. It reads the names the workspace already holds for the repository each time you open People:
 
-- **Gather requirements** records the author of each item it gathers.
-- **Live notes** records each named speaker.
+- **Plan items.** The owner of each item, when the owner is a person.
+- **Live notes.** Each named speaker. A session marked private is skipped.
+- **Meeting notes.** The speakers you renamed and the action owners the summary finds, in your notes for this repository. A note marked private is skipped.
+- **Calendar.** The attendees this machine remembers, but only when **Keep attendee names from the calendar** is on (see Settings below).
+
+The workspace does not read your mail, chat or Jira. Agent sessions that already read them with your own connectors record the people they see:
+
+- **Gather requirements** records the author of each item it gathers and the people an item names.
+- **Live notes** records each named speaker and each named action owner.
 - **Jira sync** records assignees and reporters by their Jira name.
-- **Morning brief** records meeting attendees, but only when **Keep attendee names from the calendar** is on (see Settings below).
+- **Morning brief** records meeting attendees, but only when calendar names are on.
 
-Each record is a sighting: a name, a handle (a mail address, a chat or Jira name, a transcript speaker, or only a name), and at most one interaction line in the agent's words with a pointer to where it came from. No message body is kept. Private, personal, confidential and HR material is skipped.
+Each record is a sighting: a name, a handle (a mail address, a chat or Jira name, a speaker, or only a name), and at most one interaction line with a pointer to where it came from. No message body is kept. Private, personal, confidential and HR material is skipped. A numbered speaker such as "Speaker 2" is not a person.
 
-A sighting does not make a person. New people wait for you in **Waiting for you** at the top of People.
+A sighting of a new handle adds the person. A sighting with the full name of a person in People joins that person. A first name alone, from a speaker or a name, joins the one person with that first name. When two people have that first name, it joins neither of them.
 
 ## Waiting for you
 
-- **A new person.** Press **Add to People** to add them, or **Ignore** to hide them. Later sightings of an ignored handle stay hidden.
 - **A possible duplicate.** When a session thinks two handles are one person, it says why. Press **Merge** to join the handle to that person, or **Keep separate** to close the question.
 - **Tones to confirm.** The count of people whose tone you have not confirmed. Open the person to confirm it.
 
@@ -39,7 +45,8 @@ Type in **Find a person** to search names, handles and initiatives. **All**, **T
 - **Tone.** The mix of tones (warm, neutral, cautious, tense) and a proposed overall tone: the most frequent tone of the latest 10 interactions. When two tones are tied, the latest one wins. Press **Confirm** to keep the proposal, **Set another** to choose a different tone, or **Change** to clear your choice. Tone describes the exchanges, not the person.
 - **Shared work.** The initiatives your interactions name, the plan items the person owns (with **Blocked** when the item is blocked), and the coming meetings that name them when calendar names are on. Nothing here is typed by hand.
 - **Notes.** Type a note and press **Add note**. Press **Remove** to remove one. Only you can add or remove a note. No command writes one.
-- **Identity and sources.** The person's handles, how many interactions each source gave, and the file the person lives in.
+- **Identity and sources.** The person's handles, how many interactions each source gave, where People found them, and the file the person lives in.
+- **Remove from People.** Takes the person out. Later sightings of their handles stay out.
 
 ## Ways in from other places
 
@@ -65,6 +72,8 @@ People keeps one append-only file, `people.jsonl`, in the repository's state dir
 - `pmos people settings` prints `calendar names: on` or `calendar names: off`. The morning brief reads it before it records attendees.
 - `pmos people help` prints the commands.
 
-The sightings file holds `{ "sightings": [...], "merges": [...] }`. A sighting is `{ "source": "gather" | "calendar" | "live" | "jira", "handle": { "kind": "mail" | "slack" | "jira" | "confluence" | "speaker" | "name", "value": "…" }, "name": "…", "role"?, "org"?, "external"?: true, "interaction"?: { "date": "YYYY-MM-DD", "kind": "Mail", "text": "one line, at most 200 characters", "pointer": "where it came from, at most 200 characters", "tone"?: "warm", "initiative"?: "<id>" } }`. A merge is `{ "a": <handle>, "b": <handle>, "why": "one line" }`.
+The sightings file holds `{ "sightings": [...], "merges": [...] }`. A sighting is `{ "source": "gather" | "calendar" | "live" | "jira" | "plan" | "notes", "handle": { "kind": "mail" | "slack" | "jira" | "confluence" | "speaker" | "name", "value": "…" }, "name": "…", "role"?, "org"?, "external"?: true, "interaction"?: { "date": "YYYY-MM-DD", "kind": "Mail", "text": "one line, at most 200 characters", "pointer": "where it came from, at most 200 characters", "tone"?: "warm", "initiative"?: "<id>" } }`. A merge is `{ "a": <handle>, "b": <handle>, "why": "one line" }`.
+
+`pmos people list` and `pmos people show` first add the plan item owners and Live notes speakers, as People does.
 
-No command adds a person, ignores or merges a handle, sets a tone or writes a note. Do those in People.
+No command removes a person, merges a handle, sets a tone or writes a note. Do those in People.

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/people-cli.js

@@ -8,7 +8,9 @@
  *   pmos people settings [--json]                     whether calendar attendee names are kept
  *
  * The same module the People place reads (lib/people-store.js), so a terminal line and the page cannot disagree.
- * No command adds a person, merges, sets a tone or writes a note: those are the PM's presses in People (D90).
+ * `list` and `show` first record the names this repository's records hold (plan item owners, Live notes speakers), as
+ * the People place does. No command removes a person, merges, sets a tone or writes a note: those are the PM's presses
+ * in People (D90).
  * `record` must name who recorded: the session's PMOS_SESSION token, or `--by <profile>` outside the workspace.
  *
  * Exit codes: 0 done, 1 refused, 2 usage.
@@ -25,7 +27,7 @@ const USAGE = [
   '  pmos people show <person> [--json]          one person: interactions, tone, shared work, notes and handles',
   '  pmos people record --file <sightings.json>  (agent session) record the people a session saw',
   '  pmos people settings [--json]               whether calendar attendee names are kept (calendar names: on|off)',
-  'Nothing here adds a person, merges, sets a tone or writes a note. Do that in People.',
+  'Nothing here removes a person, merges, sets a tone or writes a note. Do that in People.',
 ];
 const BOOL = new Set(['json', 'help']);
 
@@ -64,20 +66,17 @@ async function run(argv, { say = console.log, cwd = process.cwd(), env = process
   const root = flags.root ? path.resolve(cwd, flags.root) : repoRoot(cwd);
   const fail = (error, code = 1) => { if (json) say(JSON.stringify({ ok: false, error })); else say(`✗ ${error}`); return code; };
 
+  if (sub === 'list' || sub === 'show') store.scan(root, { now });
   if (sub === 'list') {
     const v = store.view(root, { now });
     if (!v.ok) return fail(v.error);
     if (json) { say(JSON.stringify({ ok: true, people: v.people, review: v.review, settings: v.settings, counts: v.counts })); return 0; }
     const r = v.review;
-    say(`People · ${v.people.length} ${v.people.length === 1 ? 'person' : 'people'} · ${r.new.length} new · ${r.merges.length} possible duplicate${r.merges.length === 1 ? '' : 's'} · ${r.tones.length} tone${r.tones.length === 1 ? '' : 's'} to confirm`);
-    if (!v.people.length && !r.new.length) { say('Nobody yet. Agent sessions record the people they see; you add them in People.'); return 0; }
+    say(`People · ${v.people.length} ${v.people.length === 1 ? 'person' : 'people'} · ${r.merges.length} possible duplicate${r.merges.length === 1 ? '' : 's'} · ${r.tones.length} tone${r.tones.length === 1 ? '' : 's'} to confirm`);
+    if (!v.people.length) { say('Nobody yet. People adds the owners of plan items, Live notes speakers, and the people agent sessions record.'); return 0; }
     for (const p of v.people) {
       say(`${p.name}  (${p.id})  ${[p.role, p.org].filter(Boolean).join(' · ') || p.group}  · ${p.count} interaction${p.count === 1 ? '' : 's'}${p.last ? ' · last ' + p.last : ''} · ${toneWord(p.tone)}`);
     }
-    if (r.new.length) {
-      say('New, waiting for you in People:');
-      for (const f of r.new) say(`  ${f.name}  ${handleText(f.handle)}  · ${f.count} sighting${f.count === 1 ? '' : 's'} from ${f.sources.join(', ')}`);
-    }
     return 0;
   }