create-pmos 0.77.0 → 0.78.0

package/workspace/lib/routes-notes.js

@@ -60,6 +60,7 @@ const notes = require('./notes.js');
 const whisper = require('./notes-whisper.js');
 const notesRepo = require('./notes-repo.js');
 const notesAudio = require('./notes-audio.js');
+const notesFinal = require('./notes-final.js');
 const notesLinks = require('./notes-links.js');
 const jevNotes = require('./jev-notes.js');
 const tsSettings = require('./typesafe-settings.js');
@@ -73,7 +74,7 @@ const VOCAB_TTL_MS = 60 * 1000;
 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/pause', '/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/line', '/api/notes/recording-delete', '/api/notes/link', '/api/notes/bullet']);
+  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/link', '/api/notes/bullet']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
 const chains = new Map();      // note id → the promise of its work so far (minute batches, imports, labels, checks)
@@ -304,7 +305,8 @@ function engineInfo(ctx, w) {
   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 })),
-    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir) };
+    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir),
+    final: finalInfo(ctx), wispr: wisprOn(ctx) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
   const sw = jevNotes.getSwitch(ctx.runtimeDir, w.root);
@@ -312,6 +314,134 @@ function engineInfo(ctx, w) {
   return { whisper: out, jev: { ...info, paused: jevNotes.pauseStatus(w.root) } };
 }
 
+/* ── the final pass and Wispr Flow's notes (meeting-notes Run 9) ───────────────────────────────────── */
+/* AFTER STOP. The summary the page asks for after Stop (prefer: 'agent') queues the final pass (lib/notes-final.js) when an
+ * engine is set up and the note kept audio: the whole meeting is transcribed again, the speakers are told apart, and then
+ * the PM's agent session writes the notes from that transcript (startAgent). Without an engine or audio, the agent writes
+ * them from the live transcript at once, as before. Listen again drops a queued pass; the next Stop queues a new one.
+ * The audio of each source is written for the pass even when the PM keeps no audio for replay; then it is deleted when the
+ * pass ends. PMOS_NOTES_FINAL (or ctx.notesFinal) 'off' skips the pass.
+ *
+ * WISPR FLOW. When the PM uses Wispr Flow in the same meeting, its notes are fetched after Stop: WISPR_DELAY_MS later the
+ * PM's agent session is asked to find the meeting with the Wispr Flow connector and copy its summary (notes.wisprHandoff);
+ * while it is not ready, it is asked again every WISPR_RETRY_MS, up to WISPR_DEADLINE_MS after Stop. The workspace itself
+ * makes no request: the agent session does, with the connector the PM signed in to. On by default ("Fetch Wispr Flow
+ * notes" in the settings); PMOS_NOTES_WISPR (or ctx.notesWispr) 'off' turns it off on this machine. Never for a private note. */
+const finalOff = (ctx) => String(ctx.notesFinal !== undefined ? ctx.notesFinal : process.env.PMOS_NOTES_FINAL || '') === 'off';
+let finalRunner = null; let finalDir = null;
+function finalFor(ctx) {
+  if (finalRunner && finalDir === ctx.runtimeDir) return finalRunner;
+  finalDir = ctx.runtimeDir;
+  finalRunner = notesFinal.createFinal({
+    runtimeDir: ctx.runtimeDir,
+    ...(ctx.notesFinalRun ? { run: ctx.notesFinalRun } : {}),
+    ...(ctx.notesFinalDetect ? { detect: ctx.notesFinalDetect } : {}),
+    onState: (id, st) => { if (st.state !== 'done') notes.setFinalState(ctx.runtimeDir, { id, state: st }); },
+    onDone: (id, final) => {
+      const dir = ctx.runtimeDir;
+      const r = notes.setFinal(dir, { id, final });
+      if (!notesAudio.getKeep(dir)) notesAudio.removeSources(dir, id);
+      if (!r.ok) return;
+      const cur = notes.read(dir, id);
+      const w = cur.ok && cur.note.ws ? ctx.getWs(cur.note.ws) : null;
+      startAgent(ctx, dir, id, w && w.id === cur.note.ws ? w : null);
+    },
+  });
+  return finalRunner;
+}
+function finalInfo(ctx) {
+  const d = ctx.notesFinalDetect ? ctx.notesFinalDetect() : notesFinal.detect(ctx.runtimeDir);
+  return { ready: !!d.ready && !finalOff(ctx), transcriber: d.transcriber || null, vad: !!d.vad, speakers: !!d.diarize, missing: d.missing || [], setup: d.setup || '' };
+}
+/** Queue the final pass of a note when it can run. → { queued, reason } */
+function queueFinal(ctx, id) {
+  const dir = ctx.runtimeDir;
+  const cur = notes.read(dir, id);
+  if (!cur.ok || cur.note.private) return { queued: false, reason: 'this note is marked private' };
+  if (finalOff(ctx)) return { queued: false, reason: 'the final pass is switched off on this machine' };
+  const info = finalInfo(ctx);
+  if (!info.ready) return { queued: false, reason: 'local transcription is not set up' };
+  if (!notesAudio.sources(dir, id).length) return { queued: false, reason: 'no audio was kept for this note' };
+  const prompt = whisper.promptFor(vocabFor(ctx, id), '');
+  finalFor(ctx).queue(id, { prompt });
+  notes.setFinalState(dir, { id, state: { state: 'queued' } });
+  return { queued: true, reason: '' };
+}
+function cancelFinal(ctx, id) { if (finalRunner) finalRunner.cancel(id); }
+
+const WISPR_DELAY_MS = 5 * 60 * 1000;
+const WISPR_RETRY_MS = 2 * 60 * 1000;
+const WISPR_DEADLINE_MS = 20 * 60 * 1000;
+const numOf = (v, d, min = 50) => { const n = Number(v); return Number.isFinite(n) && n >= min ? n : d; };
+const wisprDelay = (ctx) => numOf(ctx.notesWisprDelayMs !== undefined ? ctx.notesWisprDelayMs : process.env.PMOS_NOTES_WISPR_DELAY_MS, WISPR_DELAY_MS);
+const wisprRetry = (ctx) => numOf(ctx.notesWisprRetryMs !== undefined ? ctx.notesWisprRetryMs : process.env.PMOS_NOTES_WISPR_RETRY_MS, WISPR_RETRY_MS);
+const wisprDeadline = (ctx) => numOf(ctx.notesWisprDeadlineMs !== undefined ? ctx.notesWisprDeadlineMs : process.env.PMOS_NOTES_WISPR_DEADLINE_MS, WISPR_DEADLINE_MS);
+const wisprSettingsFile = (dir) => path.join(dir, 'notes', 'wispr-settings.json');
+function wisprOn(ctx) {
+  const env = String(ctx.notesWispr !== undefined ? ctx.notesWispr : process.env.PMOS_NOTES_WISPR || '');
+  if (env === 'off') return false;
+  try { return JSON.parse(fs.readFileSync(wisprSettingsFile(ctx.runtimeDir), 'utf8')).fetch !== false; } catch { return true; }
+}
+function setWisprOn(dir, on) {
+  const f = wisprSettingsFile(dir);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  fs.writeFileSync(f, JSON.stringify({ fetch: !!on }), { mode: 0o600 });
+}
+const wisprTimers = new Map();     // note id → timer
+function unwatchWispr(id) { const t = wisprTimers.get(id); if (t) { clearTimeout(t); wisprTimers.delete(id); } }
+function wisprLater(ctx, id, ms, fn) {
+  unwatchWispr(id);
+  const t = setTimeout(() => { wisprTimers.delete(id); fn(); }, ms);
+  if (t.unref) t.unref();
+  wisprTimers.set(id, t);
+}
+/** Listening stopped: ask for Wispr Flow's notes WISPR_DELAY_MS from now. */
+function scheduleWispr(ctx, id) {
+  const dir = ctx.runtimeDir;
+  const cur = notes.read(dir, id);
+  if (!cur.ok || cur.note.private || !cur.note.recorded_from || !wisprOn(ctx)) return;
+  if (cur.note.wispr && cur.note.wispr.state === 'found') return;
+  if (typeof ctx.spawnSession !== 'function') { notes.setWispr(dir, { id, patch: { state: 'off', reason: 'this workspace cannot start sessions' } }); return; }
+  const stop = Date.now();
+  notes.setWispr(dir, { id, patch: { state: 'waiting', due_at: new Date(stop + wisprDelay(ctx)).toISOString(), stopped_at: new Date(stop).toISOString(), tries: 0, reason: '' } });
+  wisprLater(ctx, id, wisprDelay(ctx), () => askWispr(ctx, id));
+}
+function askWispr(ctx, id) {
+  const dir = ctx.runtimeDir;
+  const cur = notes.read(dir, id);
+  if (!cur.ok || cur.note.private || !cur.note.wispr || listening(cur.note)) return;
+  const w0 = cur.note.wispr;
+  const stopped = Date.parse(w0.stopped_at) || Date.now();
+  const h = notes.wisprHandoff(dir, { id, until: stopped });
+  if (!h.ok) return;
+  const tries = (w0.tries || 0) + 1;
+  let session = w0.session || null;
+  const again = 'Try again: the Wispr Flow notes may be ready now. Read ' + h.handoff + ' again and write ' + h.out + ' as before.';
+  const sent = session && typeof ctx.sendToSession === 'function' && ctx.sendToSession(session, again + '\r');
+  if (!sent) {
+    const ws = cur.note.ws ? ctx.getWs(cur.note.ws) : null;
+    const s = ctx.spawnSession({ name: 'notes: Wispr Flow', agent: 'claude', ws: ws && ws.id === cur.note.ws ? ws.id : undefined, origin: 'notes-wispr:' + id, initialInput: h.prompt + '\r' });
+    if (!s || s.state === 'exited') { notes.setWispr(dir, { id, patch: { state: 'failed', reason: (s && s.note) || 'could not start a claude session', tries } }); return; }
+    session = s.id;
+  }
+  notes.setWispr(dir, { id, patch: { state: 'asking', tries, session, asked_at: new Date().toISOString() } });
+  wisprLater(ctx, id, wisprRetry(ctx), () => checkWispr(ctx, id));
+}
+function checkWispr(ctx, id) {
+  const dir = ctx.runtimeDir;
+  notes.importWispr(dir, { id });
+  const cur = notes.read(dir, id);
+  if (!cur.ok || !cur.note.wispr || cur.note.private) return;
+  const w = cur.note.wispr;
+  if (['found', 'not_found', 'no_connector', 'failed', 'off'].includes(w.state)) return;
+  const stopped = Date.parse(w.stopped_at) || 0;
+  if (Date.now() - stopped >= wisprDeadline(ctx)) {
+    notes.setWispr(dir, { id, patch: { state: 'failed', reason: 'Wispr Flow had no notes for this meeting ' + Math.round(wisprDeadline(ctx) / 60000) + ' minutes after Stop' } });
+    return;
+  }
+  askWispr(ctx, id);
+}
+
 const send = (ctx, res, r) => ctx.json(res, r, r.ok ? 200 : (r.status || 400));
 
 async function handle(req, res, url, ctx) {
@@ -325,6 +455,7 @@ async function handle(req, res, url, ctx) {
     // the bullets the agent wrote since the last read; Jev labels and checks them after the note's earlier work
     const imp = notes.importBullets(dir, { id: nid });
     if (imp.added.length) enrich(ctx, nid, imp.added, 'bullets');
+    notes.importWispr(dir, { id: nid });
     const r = notes.read(dir, nid);
     if (r.ok) {
       r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid);
@@ -403,6 +534,10 @@ async function handle(req, res, url, ctx) {
       // a new Listen tries the agent again when it could not start last time
       const cur = notes.read(dir, id);
       if (cur.ok && cur.note.minutes && cur.note.minutes.agent === 'failed') notes.setMinutesAgent(dir, { id, agent: null, reason: '' });
+      // listening again: the final pass and the Wispr Flow fetch wait for the next Stop
+      cancelFinal(ctx, id); unwatchWispr(id);
+      if (cur.ok && cur.note.final_state && cur.note.final_state.state !== 'done') notes.setFinalState(dir, { id, state: null });
+      if (cur.ok && cur.note.wispr && cur.note.wispr.state !== 'found') notes.setWispr(dir, { id, patch: null });
       arm(ctx, id);
     }
     return done(r);
@@ -410,7 +545,7 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/pause') {
     const r = notes.pause(dir, { id });
     // listening stopped: the minute timer stops, and what was said since the last minute is one more batch
-    if (r.ok) { disarm(id); runMinute(ctx, id, { final: true }); }
+    if (r.ok) { disarm(id); runMinute(ctx, id, { final: true }); scheduleWispr(ctx, id); }
     return done(r);
   }
   if (p === '/api/notes/transcript') {
@@ -434,11 +569,21 @@ async function handle(req, res, url, ctx) {
     const t = Math.max(0, notes.meetingMs(note.note) - ms);
     // the audio is kept for replay unless the PM switched that off (D92); a private note never reaches this line
     arm(ctx, id);
-    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) }); } }
+    // each source is also kept apart for the final pass after Stop, which deletes it when the PM keeps no audio (Run 9)
+    { try { notesAudio.write(dir, { id, source, pcm, t, mixed: notesAudio.getKeep(dir) }); } 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/speaker') {
+    if (body.key !== undefined) return done(notes.renameFinalSpeaker(dir, { id, key: String(body.key), name: body.name }));
+    return done(notes.renameSpeaker(dir, { id, source: body.source, name: body.name }));
+  }
+  if (p === '/api/notes/final') {
+    // the PM asks for the final pass again, for example after setting up a better engine
+    if (!notes.read(dir, id).ok) return done(notes.read(dir, id));
+    const q = queueFinal(ctx, id);
+    return done(q.queued ? { ok: true, queued: true } : { ok: false, status: 409, error: q.reason });
+  }
   if (p === '/api/notes/bullet') return done(notes.editBullet(dir, { id, bid: body.bullet, cat: body.cat, drop: body.drop, text: body.text }));
   if (p === '/api/notes/line') {
     const pick = (k) => (body[k] === undefined ? undefined : body[k]);
@@ -452,6 +597,13 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/switch') {
     const o = wsOf();
     // the spoken language belongs to this machine, not to a repository
+    if (body.wispr !== undefined) {
+      if (typeof body.wispr !== 'boolean') { ctx.json(res, { ok: false, error: 'say wispr: true or wispr: false' }, 400); return true; }
+      setWisprOn(dir, body.wispr);
+      if (body.language === undefined && body.model === undefined && body.accuracy === undefined && body.keep_audio === undefined && body.jev === undefined && body.check === undefined) {
+        ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true;
+      }
+    }
     if (body.language !== undefined || body.model !== undefined || body.accuracy !== 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 };
@@ -476,10 +628,21 @@ async function handle(req, res, url, ctx) {
     ctx.json(res, { ok: true, started, session: s ? s.id : null, command, reason: started ? '' : ((s && s.note) || 'could not start a terminal') });
     return true;
   }
+  if (p === '/api/notes/final-setup') {
+    const o = wsOf();
+    if (!o.ok) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
+    const command = notesFinal.setupCommand(dir);
+    if (typeof ctx.spawnSession !== 'function') { ctx.json(res, { ok: true, started: false, command, reason: 'this workspace cannot start sessions' }); return true; }
+    // typed, not run, as the Whisper setup is (D91)
+    const s = ctx.spawnSession({ name: 'notes: set up the final pass', agent: 'shell', ws: o.w ? o.w.id : undefined, origin: 'notes-final-setup', initialInput: command });
+    const started = !!s && s.state !== 'exited';
+    ctx.json(res, { ok: true, started, session: s ? s.id : null, command, reason: started ? '' : ((s && s.note) || 'could not start a terminal') });
+    return true;
+  }
   if (p === '/api/notes/private') {
     vocabCache.delete(id);
     const r = notes.setPrivate(dir, { id, private: body.private });
-    if (r.ok && r.private) { disarm(id); unwatchLate(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
+    if (r.ok && r.private) { disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
     return done(r);
   }
   if (p === '/api/notes/summarize') {
@@ -498,6 +661,9 @@ async function handle(req, res, url, ctx) {
     r.source = 'local';
     if (body.prefer === 'agent') {
       // the agent's summary is the default when an agent can be asked; the local one is already stored as the fallback
+      // with kept audio and an engine, the final pass runs first and the agent writes the notes from it (Run 9)
+      const q = cur.ok && !cur.note.private ? queueFinal(ctx, id) : { queued: false };
+      if (q.queued) { r.final = { state: 'queued' }; r.agent = { started: false, waiting: 'final', reason: '' }; r.source = 'agent'; return done(r); }
       const ag = cur.ok && cur.note.private ? { ok: false, error: 'this note is marked private, so it is not handed to any agent or service' }
         : startAgent(ctx, dir, id, ws.ok ? ws.w : null);
       r.agent = ag.ok ? (({ ok, ...x }) => x)(ag) : { started: false, reason: ag.error || 'the agent could not be asked' };
@@ -505,7 +671,7 @@ async function handle(req, res, url, ctx) {
     }
     return done(r);
   }
-  if (p === '/api/notes/delete') { disarm(id); unwatchLate(id); if (transcriber) transcriber.drop(id); const r = notes.remove(dir, id); if (r.ok) notesAudio.remove(dir, id); return done(r); }
+  if (p === '/api/notes/delete') { disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); 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) {
@@ -532,4 +698,5 @@ function startAgent(ctx, dir, id, w) {
   return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, runMinute, bulletsState, __idle: () => Promise.all([transcriber ? transcriber.idle() : null, ...chains.values()]) };
+module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr,
+  __idle: () => Promise.all([transcriber ? transcriber.idle() : null, finalRunner ? finalRunner.idle() : null, ...chains.values()]) };

package/workspace/package-lock.json

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

package/workspace/package.json

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

@@ -6471,6 +6471,21 @@
   color: var(--foreground);
   font-weight: 500;
 }
+.nt-para {
+  margin: 0 0 8px;
+  font-size: 14px;
+  line-height: 20px;
+}
+.nt-quote {
+  display: block;
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--muted-foreground);
+}
+.nt-topic {
+  margin: 4px 0 8px;
+  font-size: 14px;
+}
 
 /* -- layouts · .lg- the legacy and fixture shells (Run 3, slice 3D) -- */
 /* The legacy and fixture cockpit's two columns: the list head (a stack) and the rail's tile column. */

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

@@ -72,6 +72,8 @@ let pendingOpen = null;       // a note another page asked to open (openNote), s
 let transcriptOpen = { inline: false, full: true };   // the transcript is folded in the pop-up and open on the full screen
 let inlineSwitch = null;      // the note the pop-up is switching to (renderInline), so a redraw does not start it twice
 let popped = null;            // the note the pop-up shows (pm/note-dock.js), which the Notes tab then does not draw
+let liveTranscript = false;   // after the final pass, the PM can look at the live transcript instead (Run 9)
+let wisprTimer = null;
 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 ''; } };
@@ -213,7 +215,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.bullets, n.bullets_state && n.bullets_state.agent, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title, (n.versions || []).length, n.__recording && n.__recording.bytes, n.meeting, n.initiative]);
+const sig = (n) => JSON.stringify([n.final_state, n.final && n.final.at, n.final && n.final.names, n.final_notes && n.final_notes.at, n.wispr && [n.wispr.state, n.wispr.tries, n.wispr.reason], n.transcript, n.bullets, n.bullets_state && n.bullets_state.agent, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title, (n.versions || []).length, n.__recording && n.__recording.bytes, n.meeting, n.initiative]);
 async function loadNote(ctx, id) {
   const r = await pmGet('/api/notes/one?id=' + encodeURIComponent(id));
   if (r && r.ok) {
@@ -343,6 +345,7 @@ async function summarize(ctx, n, quiet = false) {
   busy = '';
   if (r && r.ok) {
     n.summary = r.summary; if (r.initiative !== undefined) { n.initiative = r.initiative; const c = cache.get(n.id); if (c) c.initiative = r.initiative; } banner = null;
+    if (r.final) { n.final_state = r.final; const c = cache.get(n.id); if (c) c.final_state = r.final; pollAgent(ctx, n.id); }
     if (r.agent && r.agent.started) { n.agent = { requested_at: new Date().toISOString(), started: true, reason: '', session: r.agent.session, withheld: r.agent.withheld, markdown: null, out: r.agent.out }; pollAgent(ctx, n.id); }
   } else if (!quiet) banner = { tone: 'bad', text: (r && r.error) || 'no summary was made' };
   ctx.setState({});
@@ -367,11 +370,45 @@ function pollAgent(ctx, id) {
   agentTimer = setTimeout(async () => {
     agentTimer = null;
     const n = cache.get(id);
-    if (!n || !n.agent || n.agent.markdown || currentId !== id) return;
+    if (!n || currentId !== id || !(finalPending(n) || (n.agent && n.agent.started && !n.agent.markdown))) return;
     const r = await loadNote(ctx, id);
-    if (r && r.ok && !(r.note.agent && r.note.agent.markdown)) pollAgent(ctx, id);
+    if (r && r.ok && (finalPending(r.note) || (r.note.agent && r.note.agent.started && !r.note.agent.markdown))) pollAgent(ctx, id);
   }, AGENT_POLL_MS);
 }
+const finalPending = (n) => !!(n && n.final_state && (n.final_state.state === 'queued' || n.final_state.state === 'running'));
+const wisprPending = (n) => !!(n && n.wispr && (n.wispr.state === 'waiting' || n.wispr.state === 'asking'));
+/** Wispr Flow's notes come minutes after Stop: the note is read again every 20 seconds while they are awaited. */
+function pollWispr(ctx, id) {
+  if (wisprTimer) return;
+  wisprTimer = setTimeout(async () => {
+    wisprTimer = null;
+    const n = cache.get(id);
+    if (!n || currentId !== id || !wisprPending(n)) return;
+    const r = await loadNote(ctx, id);
+    if (r && r.ok && wisprPending(r.note)) pollWispr(ctx, id);
+  }, 20000);
+}
+async function runFinal(ctx, n) {
+  const r = await pmPost('/api/notes/final', { id: n.id });
+  if (r && r.ok) { n.final_state = { state: 'queued' }; pollAgent(ctx, n.id); } else banner = { tone: 'bad', text: (r && r.error) || 'the final pass did not start' };
+  ctx.setState({});
+}
+async function finalSetup(ctx) {
+  const ws = wsOf(ctx);
+  const r = await pmPost('/api/notes/final-setup', ws ? { ws } : {});
+  banner = r && r.ok && r.started
+    ? { tone: 'ok', text: 'A terminal opened with the setup commands typed in. Read them and press Enter there. The downloads are about 3 GB. Then open Settings again.' }
+    : { tone: 'bad', text: 'No terminal opened' + (r && r.reason ? ': ' + r.reason : '') + '. Run this in a terminal: ' + ((r && r.command) || '') };
+  ctx.setState({});
+}
+async function renameFinalSpeaker(ctx, n, key, now) {
+  const name = await askText({ title: 'Name this speaker', label: 'Name', value: now, placeholder: now, confirmLabel: 'Save' });
+  if (name == null) return;
+  const r = await pmPost('/api/notes/speaker', { id: n.id, key, name });
+  // the note may have been read again since this button was drawn, so read it once more rather than change a stale copy
+  if (r && r.ok) { await loadNote(ctx, n.id); } else banner = { tone: 'bad', text: (r && r.error) || 'not renamed' };
+  ctx.setState({});
+}
 async function copyMarkdown(ctx, n) {
   const text = noteMarkdown({ ...n, title: editor ? editor.title.value : n.title, body: editor ? editor.body.value : n.body });
   try { await navigator.clipboard.writeText(text); banner = { tone: 'ok', text: 'The note is on the clipboard as Markdown.' }; }
@@ -758,6 +795,22 @@ function openSettings(ctx, n) {
       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));
+    const fp = w && w.final;
+    if (fp) {
+      const have = [fp.transcriber === 'parakeet' ? 'Parakeet' : fp.transcriber === 'whisper' ? 'Whisper with beam search' : null,
+        fp.vad ? 'speech detection' : null, fp.speakers ? 'speaker separation' : null].filter(Boolean);
+      parts.push(el('div', { class: 'nt-set', 'data-nt-final-set': fp.ready ? 'ready' : 'missing' },
+        el('div', { class: 'nt-set__head' }, 'Final notes after Stop'),
+        el('p', { class: 'nt-hint' }, fp.ready
+          ? 'After Stop, the whole meeting is transcribed again on this machine (' + have.join(', ') + '), and your agent session writes the notes from it.'
+          : 'Set up local transcription first. After Stop, the whole meeting is then transcribed again on this machine, and your agent session writes the notes from it.'),
+        fp.missing.length ? el('p', { class: 'nt-hint', 'data-nt-final-missing': '' }, 'For better notes, set up ' + fp.missing.map((m) => (m === 'parakeet' ? 'Parakeet (more accurate in English)' : m === 'vad' ? 'speech detection' : 'speaker separation')).join(', ')
+          + '. The setup installs them into the workspace\'s own folder; the downloads are about 3 GB.') : null,
+        fp.missing.length ? button({ label: 'Set up in a terminal', onClick: () => { h.close(); finalSetup(ctx); }, attrs: { 'data-nt-final-setup': '' } }) : null,
+        field({ label: 'Fetch Wispr Flow notes after the meeting', kind: 'check', value: w.wispr !== false,
+          onCommit: (v) => setSwitch(ctx, { wispr: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-wispr-switch': '' } }),
+        el('p', { class: 'nt-hint' }, 'Five minutes after Stop, your agent session looks for the same meeting in Wispr Flow and copies its notes into this note. It needs the Wispr Flow connector in Claude Code.')));
+    }
     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': '' } });
@@ -772,6 +825,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 || (n.final_state && n.final_state.state === 'failed') ? button({ label: 'Transcribe again', disabled: n.private || finalPending(n), onClick: () => { h.close(); runFinal(ctx, n); }, attrs: { 'data-nt-final-again': '' } }) : null,
         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;
@@ -1035,6 +1089,75 @@ function itemRow(ctx, n, key, title, x) {
       : key === 'fact' || key === 'tagged' || key === 'point' ? null
         : iconButton({ icon: 'x', ariaLabel: 'Remove from ' + title, onClick: () => unpick(ctx, n, x), size: 'sm', attrs: { 'data-nt-unpick': String(x.index) } }));
 }
+/* ── the final notes, the final transcript and Wispr Flow's notes (Run 9) ────────────────────────────── */
+function finalSpeakerOf(n, key) {
+  const nm = n.final && n.final.names && n.final.names[key];
+  if (nm) return nm;
+  if (key === 'mic' || key === 'meeting') return speakerOf(n, key);
+  const m = /^(?:mic|meeting)-(\d+)$/.exec(String(key || ''));
+  return m ? 'Speaker ' + m[1] : 'Speaker';
+}
+function timeOf(ctx, n, t, k) {
+  if (typeof t !== 'number') return el('span', { class: 'nt-at' }, '');
+  return n.__recording && !listening(n)
+    ? button({ label: fmtTime(t), variant: 'ghost', size: 'sm', onClick: () => seek(ctx, n, t), attrs: { 'data-nt-seek-item': k, title: 'Play from here' } })
+    : el('span', { class: 'nt-at' }, fmtTime(t));
+}
+function finalItem(ctx, n, sec, x, i) {
+  const extra = [x.owner ? ' · ' + x.owner : '', x.due ? ' · ' + x.due : ''].join('');
+  return el('li', { class: 'nt-item', 'data-nt-final-item': sec + '-' + i }, timeOf(ctx, n, x.t, sec + '-' + i),
+    el('span', { class: 'nt-item__text' }, x.text, extra ? el('span', { class: 'nt-who' }, extra) : null, el('span', { class: 'nt-quote', 'data-nt-quote': '' }, 'Said: ' + x.quote)));
+}
+function finalNotesSections(ctx, n) {
+  const f = n.final_notes;
+  const from = f.from === 'final' ? ' · by your agent session, from the whole recording' : ' · by your agent session';
+  const out = [el('section', { class: 'nt-sec', 'data-nt-summary': 'final' }, el('h3', { class: 'nt-sec__h' }, 'Overview', el('span', { class: 'nt-src' }, from)),
+    f.purpose ? el('p', { class: 'nt-para', 'data-nt-purpose': '' }, f.purpose) : null, f.overview ? el('p', { class: 'nt-para' }, f.overview) : null)];
+  const list = (key, title, items) => el('section', { class: 'nt-sec', 'data-nt-sec': key }, el('h3', { class: 'nt-sec__h' }, title),
+    items.length ? el('ul', { class: 'nt-items' }, items.map((x, i) => finalItem(ctx, n, key, x, i))) : el('p', { class: 'nt-hint' }, 'None.'));
+  out.push(list('decision', 'Decisions', f.decisions || []), list('action', 'Next steps', f.actions || []), list('question', 'Open questions', f.questions || []));
+  if ((f.topics || []).length) {
+    out.push(el('details', { class: 'nt-sec', 'data-nt-topics': '' }, el('summary', { class: 'nt-sec__h nt-fold' }, 'Topics', el('span', { class: 'nt-src' }, ' · ' + f.topics.length)),
+      f.topics.map((tp) => el('div', { class: 'nt-topic' }, el('b', null, tp.title), el('ul', { class: 'nt-items' }, tp.points.map((p) => el('li', { class: 'nt-item nt-item--plain' }, el('span', { class: 'nt-item__text' }, p))))))));
+  }
+  if (f.dropped) out.push(el('p', { class: 'nt-hint', 'data-nt-dropped': '' }, f.dropped + (f.dropped === 1 ? ' item was' : ' items were') + ' left out: no quote from the transcript supports ' + (f.dropped === 1 ? 'it.' : 'them.')));
+  return out;
+}
+function finalStateHint(ctx, n) {
+  const st = n.final_state;
+  if (!st || listening(n)) return null;
+  if (st.state === 'queued' || st.state === 'running') {
+    return el('p', { class: 'nt-hint', 'data-nt-final-wait': st.state, role: 'status' }, 'Writing the final notes: ' + (st.step || 'waiting to transcribe the meeting again') + '. Until then, these are the notes taken live.');
+  }
+  if (st.state === 'failed') return el('p', { class: 'nt-hint nt-hint--bad', 'data-nt-final-failed': '' }, 'The final notes were not written: ' + (st.reason || 'no reason given') + '. These are the notes taken live.');
+  if (st.state === 'done' && n.agent && n.agent.started && !n.agent.markdown) return el('p', { class: 'nt-hint', 'data-nt-agent-wait': '' }, 'The meeting is transcribed again. Your agent session is writing the notes.');
+  return null;
+}
+const WISPR_WORDS = {
+  waiting: 'PMOS asks Wispr Flow for its notes of this meeting five minutes after Stop.',
+  asking: 'Your agent session is looking for this meeting in Wispr Flow.',
+  not_ready: 'Wispr Flow has no notes for this meeting yet. PMOS asks again.',
+  not_found: 'Wispr Flow has no meeting at this time.',
+  no_connector: 'Your agent session has no Wispr Flow connector. Add it in Claude Code to fetch Wispr Flow notes.',
+};
+function wisprSection(ctx, n) {
+  const w = n.wispr;
+  if (!w || w.state === 'off' || n.private) return null;
+  if (wisprPending(n)) pollWispr(ctx, n.id);
+  const body = [];
+  if (w.state === 'found') {
+    if (w.meeting && w.meeting.title) body.push(el('p', { class: 'nt-hint' }, w.meeting.title + (w.meeting.start ? ' · ' + dayOf(w.meeting.start) + ' ' + nowClock(w.meeting.start) : '')));
+    let blocks = [];
+    try { blocks = mdRender(w.summary || '').blocks || []; } catch { blocks = [el('div', { class: 'nt-pre' }, w.summary || '')]; }
+    body.push(el('div', { class: 'nt-md', 'data-nt-wispr-summary': '' }, blocks));
+    if (w.meeting && w.meeting.share_link) {
+      const link = w.meeting.share_link;
+      body.push(button({ label: 'Open in Wispr Flow', variant: 'ghost', size: 'sm', onClick: () => { try { window.open(link, '_blank', 'noopener'); } catch { /* blocked */ } }, attrs: { 'data-nt-wispr-open': '' } }));
+    }
+  } else body.push(el('p', { class: 'nt-hint', 'data-nt-wispr-state': w.state }, WISPR_WORDS[w.state] || ('Wispr Flow notes were not fetched: ' + (w.reason || 'no reason given') + '.')));
+  return el('details', { class: 'nt-sec', 'data-nt-part': 'wispr', open: w.state === 'found' ? null : '' },
+    el('summary', { class: 'nt-sec__h nt-fold' }, 'Wispr Flow notes', el('span', { class: 'nt-src' }, w.state === 'found' ? ' · fetched by your agent session' : '')), body);
+}
 function sectionOf(ctx, n, key, title, items, extra) {
   if (!items.length && !extra) return null;
   return el('section', { class: 'nt-sec', 'data-nt-sec': key },
@@ -1106,7 +1229,12 @@ function noteColumn(ctx, n, ed) {
   const bs = n.bullets_state;
   const parts = [];
   if (n.__audio && n.__audio.error && live) parts.push(el('p', { class: 'nt-hint nt-hint--bad', 'data-nt-audio-error': '' }, n.__audio.error));
-  if (live) parts.push(myNotes(ctx, n, ed)); else parts.push(summarySection(ctx, n));
+  if (!live && n.final_notes) {
+    // the notes written after Stop replace the live draft (Run 9)
+    parts.push(...finalNotesSections(ctx, n), myNotes(ctx, n, ed), wisprSection(ctx, n));
+    return el('section', { class: 'nt-notecol', 'data-nt-part': 'notes' }, parts.filter(Boolean));
+  }
+  if (live) parts.push(myNotes(ctx, n, ed)); else parts.push(finalStateHint(ctx, n), summarySection(ctx, n));
   const each = bs && bs.agent === 'on' ? el('span', { class: 'nt-src', 'data-nt-each-minute': '' }, ' · each minute') : null;
   const secs = [sectionOf(ctx, n, 'point', 'Key points', c.point, c.point.length || each ? each : null)];
   for (const [k, t] of SECTIONS) secs.push(sectionOf(ctx, n, k, t, c[k]));
@@ -1117,12 +1245,35 @@ function noteColumn(ctx, n, ed) {
   else parts.push(el('p', { class: 'nt-hint', 'data-nt-caught-hint': '' }, live ? 'Listening … Key points, decisions, next steps and questions appear here as they are said.' : (n.transcript || []).length ? 'Nothing was caught as a decision, next step or question.'
     : 'Decisions, actions and questions appear here as they are said, each checked against this repository.'));
   if (bs && bs.agent === 'failed' && bs.reason) parts.push(el('p', { class: 'nt-hint', 'data-nt-bullets-failed': '' }, 'Key points are not written each minute: ' + bs.reason + '. Lines are labelled on this machine.'));
-  if (!live) parts.push(myNotes(ctx, n, ed));
+  if (!live) parts.push(myNotes(ctx, n, ed), wisprSection(ctx, n));
   return el('section', { class: 'nt-notecol', 'data-nt-part': 'notes' }, parts.filter(Boolean));
 }
+function finalTranscript(ctx, n, opts) {
+  const segs = n.final.segments;
+  const typed = (n.transcript || []).filter((x) => x.source === 'typed' && !x.dropped).map((x) => ({ t: x.t, text: x.text, typed: true }));
+  const rows = [...segs.map((g, i) => ({ ...g, i })), ...typed].sort((a, b) => (a.t || 0) - (b.t || 0));
+  const lines = rows.map((x) => {
+    const who = x.typed ? 'You, typed' : finalSpeakerOf(n, x.spk);
+    const spk = x.typed ? el('span', { class: 'nt-spk nt-spk--typed', 'data-nt-spk': 'typed' }, who)
+      : button({ label: who, variant: 'ghost', size: 'sm', onClick: () => renameFinalSpeaker(ctx, n, x.spk, who), attrs: { 'data-nt-final-spk': x.spk, title: 'Name this speaker' } });
+    const at = n.__recording && typeof x.t === 'number'
+      ? button({ label: fmtTime(x.t), variant: 'ghost', size: 'sm', onClick: () => seek(ctx, n, x.t), attrs: { 'data-nt-seek-final': String(x.i), title: 'Play from here' } })
+      : el('span', { class: 'nt-at' }, fmtTime(x.t));
+    return el('div', { class: 'nt-ln', 'data-nt-final-seg': x.typed ? null : String(x.i) }, el('div', { class: 'nt-ln__meta' }, at, spk), el('div', null, x.text));
+  });
+  const box = el('div', { class: 'nt-lines', 'data-nt-transcript': 'final' }, lines);
+  const where = opts.inline ? 'inline' : 'full';
+  const how = [n.final.engine === 'parakeet' ? 'Parakeet' : 'Whisper', n.final.diarized ? 'speakers told apart' : null].filter(Boolean).join(', ');
+  const d = el('details', { class: 'nt-trans', 'data-nt-part': 'transcript', open: transcriptOpen[where] },
+    el('summary', { class: 'nt-sec__h nt-fold' }, 'Transcript', el('span', { class: 'nt-src' }, ' · from the whole recording (' + how + '), ' + rows.length + (rows.length === 1 ? ' line' : ' lines'))),
+    button({ label: 'Show the live transcript', variant: 'ghost', size: 'sm', onClick: () => { liveTranscript = true; ctx.setState({}); }, attrs: { 'data-nt-live-transcript': '' } }), box);
+  d.addEventListener('toggle', () => { transcriptOpen[where] = d.open; });
+  return d;
+}
 function transcriptColumn(ctx, n, opts = {}) {
   const tr = n.transcript || [];
   const live = listening(n);
+  if (!live && !liveTranscript && n.final && (n.final.segments || []).length) return finalTranscript(ctx, n, opts);
   const lines = tr.map((x, i) => {
     if (x.source === 'typed' && x.dropped) return null;      // a note line the PM removed
     const lab = x.cat && x.cat !== 'small talk' ? el('span', { class: 'nt-lab', 'data-nt-cat': x.cat }, x.cat) : null;
@@ -1148,7 +1299,8 @@ function transcriptColumn(ctx, n, opts = {}) {
   const shownN = tr.filter((x) => !(x.source === 'typed' && x.dropped)).length;
   const where = opts.inline ? 'inline' : 'full';
   const d = el('details', { class: 'nt-trans', 'data-nt-part': 'transcript', open: transcriptOpen[where] },
-    el('summary', { class: 'nt-sec__h nt-fold' }, 'Transcript', el('span', { class: 'nt-src' }, ' · ' + shownN + (shownN === 1 ? ' line' : ' lines') + (live ? ' so far' : ''))), box);
+    el('summary', { class: 'nt-sec__h nt-fold' }, 'Transcript', el('span', { class: 'nt-src' }, ' · ' + shownN + (shownN === 1 ? ' line' : ' lines') + (live ? ' so far' : ''))),
+    !live && n.final && (n.final.segments || []).length ? button({ label: 'Show the final transcript', variant: 'ghost', size: 'sm', onClick: () => { liveTranscript = false; ctx.setState({}); }, attrs: { 'data-nt-final-transcript': '' } }) : null, box);
   d.addEventListener('toggle', () => { transcriptOpen[where] = d.open; if (d.open) box.scrollTop = box.scrollHeight; });
   if (live && transcriptOpen[where]) requestAnimationFrame(() => { box.scrollTop = box.scrollHeight; });
   return d;
@@ -1190,7 +1342,7 @@ export function renderBoard(inner, ctx) {
       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);
+    if (((n.agent && n.agent.started && !n.agent.markdown) || finalPending(n)) && !agentTimer) pollAgent(ctx, n.id);
   }
   inner.appendChild(wrap);
   keep();

package/workspace/test-lists/meeting-notes.json

@@ -1,8 +1,9 @@
 {
-  "_comment": "meeting-notes Runs 1 and 2: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), and the Notes view in a browser (pm-notes-test.js).",
+  "_comment": "meeting-notes Runs 1 to 9: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), the final pass after Stop and the Wispr Flow fetch (notes-final.test.js), and the Notes view in a browser (pm-notes-test.js).",
   "modules": [
     "notes.test.js",
-    "notes-listen.test.js"
+    "notes-listen.test.js",
+    "notes-final.test.js"
   ],
   "panels": [
     "pm-notes-test.js"
@@ -10,6 +11,7 @@
   "seconds": {
     "notes.test.js": 12,
     "pm-notes-test.js": 40,
-    "notes-listen.test.js": 10
+    "notes-listen.test.js": 10,
+    "notes-final.test.js": 6
   }
 }

package/workspace/test-timings.json

@@ -51,6 +51,7 @@
     "measurements.test.js": 1,
     "next-step-actions.test.js": 11,
     "no-network.test.js": 1,
+    "notes-final.test.js": 2,
     "notes-listen.test.js": 2,
     "notes.test.js": 5,
     "online-mode.test.js": 1,