create-pmos 0.64.0 → 0.65.1

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.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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