create-pmos 0.75.0 → 0.76.0

package/workspace/lib/routes-notes.js

@@ -2,14 +2,22 @@
 /* routes-notes.js — the Notes view's routes (meeting-notes, Runs 1 to 4; 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
+ *   GET  /api/notes/one?id=…                → { ok, note, bullets_state, audio, recording }   imports an agent summary and the agent's
+ *                                                   minute bullets written since the last read (Run 8). note.bullets:
+ *                                                   [{ id, t, minute, text, owner, cat, cat_by, by: 'agent', open?, check?, dropped? }];
+ *                                                   an open bullet has cat null. bullets_state: { agent: 'on'|'off'|'failed',
+ *                                                   reason, session, next_at_ms, minute_ms, minutes }
+ *   POST /api/notes/bullet     { id, bullet, cat?, drop?, text? } → { ok, bullet, summary }   the PM's correction to one bullet (Run 8)
  *   POST /api/notes/new        { title?, meeting?, initiative? } → { ok, note, reused }   a calendar event that already has a note
  *                                                   gets that note back (reused: true), so one meeting keeps one note (Run 4)
  *   POST /api/notes/link       { id, meeting?, initiative?, from_event? } → { ok, note, kept? }   the PM's link; null unlinks (Run 4)
  *   GET  /api/notes/initiatives?id=…&ws=…  → { ok, open: [{ id, title }], pick }   the repository's open initiatives, and the local suggestion
- *   POST /api/notes/save       { id, title?, body? }      → { ok, updated_at }
+ *   POST /api/notes/save       { id, title?, body? }      → { ok, updated_at, versions, added }   each new line of the notes is also
+ *                                                   a transcript line, source 'typed' (`added`, Run 8)
  *   POST /api/notes/dictate    { text }     → { ok, ops }  one dictated phrase as insert operations (lib/notes.js dictation)
- *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from }    `ws` is the repository the note's lines are checked against
+ *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from, clock_from, meeting_ms }    `ws` is the repository the note's lines are checked against;
+ *                                             clock_from is the first Listen moved on by the time listening was stopped
+ *   POST /api/notes/pause      { id }       → { ok, meeting_ms }      listening stopped: the meeting clock stops until the next Listen
  *   POST /api/notes/transcript { id, text, source? } → { ok, added: [{ at, t, text, source, cat, index }] }
  *   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
@@ -19,11 +27,16 @@
  *   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?, keep_audio? } → { ok, whisper } the language, the model and keeping audio, for this machine
+ *                              { language?, model?, accuracy?, keep_audio? } → { ok, whisper } the language, the model, the decoding
+ *                                                   ('fast' | 'accurate') 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, ws? }  → { ok, summary, initiative }   the local summary; with ws and no initiative yet,
- *                                                   the local suggestion is linked (by: 'local')
+ *   POST /api/notes/summarize  { id, ws?, prefer? }  → { ok, summary, initiative, source, agent? }   the local summary; with ws and
+ *                                                   no initiative yet, the local suggestion is linked (by: 'local'). With
+ *                                                   prefer: 'agent' the PM's agent session is also started, as summarize-agent
+ *                                                   does: source is 'agent' when it started (its file is imported by
+ *                                                   GET /api/notes/one), else 'local'; `agent` is summarize-agent's answer
+ *                                                   without `ok`, or { started: false, reason } when no agent was asked
  *   POST /api/notes/summarize-agent { id, ws? }           → { ok, started, session, handoff, out, withheld, reason }
  *   POST /api/notes/delete     { id }       → { ok }
  *
@@ -33,9 +46,14 @@
  * agent summary starts the PM's own agent session in the repository (ctx.spawnSession), as the skill draft does; Whisper runs
  * on this machine (lib/notes-whisper.js); a label or a check goes to Jev only through lib/jev-notes.js, behind the D91 gates.
  *
- * AFTER A LINE IS ADDED (Run 2). Each new line already has its local label. Then, one note at a time and in order: Jev's label
- * when the label gates hold; for a decision, action or statement, the closest repository passage (local, lib/notes-repo.js),
- * and Jev's comparison when the check gates hold too. The page reads the results with GET /api/notes/one.
+ * AFTER A LINE IS ADDED (Run 2, batched by Run 8). Each new line already has its local label (none while it is open: cut
+ * mid-sentence). Nothing goes to Jev per line: once a minute of meeting time the new lines are one batch (see "minute batches"
+ * below). With the PM's agent, the batch becomes bullets, and Jev labels and checks each closed bullet; without one, Jev labels
+ * the batch's lines and checks the checkable ones. One note at a time and in order: Jev's label when the label gates hold;
+ * for a decision, action, question or fact, the closest repository passage (local, lib/notes-repo.js), and Jev's comparison
+ * when the check gates hold too. The page reads the results with GET /api/notes/one.
+ * The minute is PMOS_NOTES_MINUTE_MS (or ctx.notesMinuteMs), default 60000; the bullets agent is PMOS_NOTES_BULLETS_AGENT
+ * (or ctx.notesBulletsAgent), default 'claude', and 'off' uses none.
  */
 const guard = require('./pm-guard.js');
 const notes = require('./notes.js');
@@ -46,23 +64,31 @@ const notesLinks = require('./notes-links.js');
 const jevNotes = require('./jev-notes.js');
 const tsSettings = require('./typesafe-settings.js');
 
+const fs = require('fs');
+const path = require('path');
+
 const MAX_PCM_BYTES = 16000 * 2 * 15;       // 15 s of 16 kHz 16-bit audio in one request
-const CHECKED = new Set(['decision', 'action', 'statement']);
+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/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/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']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
-const chains = new Map();      // note id → the promise of its enrichment so far
-function enrich(ctx, id, added) {
-  if (!added || !added.length) return Promise.resolve();
-  const next = (chains.get(id) || Promise.resolve()).then(() => enrichNow(ctx, id, added)).catch(() => {});
+const chains = new Map();      // note id → the promise of its work so far (minute batches, imports, labels, checks)
+/** Run `fn` after the note's earlier work, so one note's labels and checks happen one at a time and in order. */
+function chain(id, fn) {
+  const next = (chains.get(id) || Promise.resolve()).then(fn).catch(() => {});
   chains.set(id, next);
   next.then(() => { if (chains.get(id) === next) chains.delete(id); });
   return next;
 }
+/** Label and check `added` (transcript lines, or bullets with kind 'bullets') after the note's earlier work. */
+function enrich(ctx, id, added, kind = 'lines') {
+  if (!added || !added.length) return Promise.resolve();
+  return chain(id, () => enrichNow(ctx, id, added, kind));
+}
 function gatesFor(ctx, root) {
   const dir = ctx.runtimeDir;
   if (!root) return { root: null, exclude: [], ask: null, check: false, key: null, askOpts: {} };
@@ -73,29 +99,187 @@ function gatesFor(ctx, root) {
   return { root, exclude: repo.exclude, ask: snd.ask, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
 }
 const stillOpen = (dir, id) => { const r = notes.read(dir, id); return r.ok && !r.note.private ? r.note : null; };
-async function enrichNow(ctx, id, added) {
+/** Jev's label (when the label gates hold), then for a checkable item the closest repository passage and Jev's comparison
+ * (when the check gates hold too). `kind` 'lines': `items` are transcript lines ({ index, text, cat, cat_by }); 'bullets':
+ * they are the agent's bullets ({ id, text, cat, cat_by }). */
+async function enrichNow(ctx, id, items, kind = 'lines') {
   const dir = ctx.runtimeDir;
   const note = stillOpen(dir, id);
   if (!note) return;
   const w = note.ws ? ctx.getWs(note.ws) : null;
   const g = gatesFor(ctx, w ? w.root : null);
-  for (const seg of added) {
-    let cat = seg.cat;
+  const put = (x, patch) => (kind === 'bullets'
+    ? notes.updateBullet(dir, { id, bid: x.id, text: x.text, patch })
+    : notes.updateSegment(dir, { id, index: x.index, text: x.text, patch }));
+  for (const x of items) {
+    let cat = x.cat;
+    let catBy = x.cat_by;
     if (g.ask && stillOpen(dir, id)) {
-      const l = await jevNotes.label({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: seg.text, root: g.root });
-      if (l.cat) { const u = notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { cat: l.cat, cat_by: 'jev' } }); if (u.ok) cat = u.segment.cat; }
-      else if (l.reason === 'failed' || l.reason === 'paused') notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { jev: l.reason } });
+      const l = await jevNotes.label({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: x.text, root: g.root });
+      // a label below the bar (a fragment called a decision, a backchannel called a question) keeps the local label
+      if (l.cat && notes.meetsBar(l.cat, x.text)) { const u = put(x, { cat: l.cat, cat_by: 'jev' }); if (u.ok) { const v = u.segment || u.bullet; cat = v.cat; catBy = v.cat_by; } }
+      else if (l.reason === 'failed' || l.reason === 'paused') put(x, { jev: l.reason });
     }
-    if (!g.root || !CHECKED.has(cat)) continue;
-    const pass = notesRepo.closest(g.root, seg.text, { exclude: g.exclude });
+    // only an item that survives as a decision, action, question or fact, with 5 words or more, is checked
+    if (!g.root || !notes.checkable({ text: x.text, cat, cat_by: catBy })) continue;
+    const pass = notesRepo.closest(g.root, x.text, { exclude: g.exclude });
     if (!pass) continue;
     let check = { doc: pass.path, line: pass.line, verdict: 'related', by: 'local' };
     if (g.ask && g.check && stillOpen(dir, id)) {
-      const c = await jevNotes.compare({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: seg.text, passage: pass, root: g.root });
+      const c = await jevNotes.compare({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: x.text, passage: pass, root: g.root });
       if (c.verdict) check = { doc: pass.path, line: pass.line, verdict: c.verdict, words: c.words || null, by: 'jev' };
     }
-    notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { check } });
+    put(x, { check });
+  }
+}
+
+/* ── minute batches and the agent's bullets (Run 8) ─────────────────────────────────────────────── */
+/* While a note listens, every MINUTE_MS of meeting time (and once more when listening stops, and on a summary after Stop)
+ * the lines added since the last batch become one batch. With an agent: the batch is a minute file, and the note's one
+ * bullets session is told to write its bullets (the first batch starts the session with the whole job; a later batch is
+ * typed into the same session; a session that is gone is started again). The bullets are imported on each read of the note
+ * and on each tick, then Jev labels each one and the checkable ones are checked against the repository. Without an agent
+ * (switched off, no sessions, or it could not start): Jev labels the batch's lines and checks the checkable ones, as each
+ * line was before, but once a minute. A private note is never batched or handed off. A note that is not receiving audio
+ * after a restart does not tick: the timer starts on Listen, and again on the next audio or transcript line. */
+const MINUTE_MS = 60 * 1000;
+const minuteMsOf = (ctx) => { const v = Number(ctx.notesMinuteMs || process.env.PMOS_NOTES_MINUTE_MS); return Number.isFinite(v) && v >= 100 ? v : MINUTE_MS; };
+// the bullets agent's command: 'claude' unless ctx.notesBulletsAgent or PMOS_NOTES_BULLETS_AGENT names another; 'off' uses none
+const bulletsAgentOf = (ctx) => { const v = ctx.notesBulletsAgent !== undefined ? ctx.notesBulletsAgent : process.env.PMOS_NOTES_BULLETS_AGENT; return v ? String(v) : 'claude'; };
+const timers = new Map();      // note id → { timer, next_at_ms }
+const listening = (n) => !!(n && !n.private && n.recorded_from && !n.paused_at);
+/** Start the note's minute timer, when it listens and has none. */
+function arm(ctx, id) {
+  if (timers.has(id)) return;
+  const r = notes.read(ctx.runtimeDir, id);
+  if (!r.ok || !listening(r.note)) return;
+  const ms = minuteMsOf(ctx);
+  const t = { timer: null, next_at_ms: Math.round(notes.meetingMs(r.note)) + ms };
+  t.timer = setTimeout(() => { if (timers.get(id) === t) timers.delete(id); runMinute(ctx, id).then(() => arm(ctx, id)); }, ms);
+  if (t.timer.unref) t.timer.unref();
+  timers.set(id, t);
+}
+function disarm(id) { const t = timers.get(id); if (t) { clearTimeout(t.timer); timers.delete(id); } }
+/** One minute's work for a note, after its earlier work: import what the agent wrote, then the next batch. */
+function runMinute(ctx, id, { final = false } = {}) { return chain(id, () => minuteNow(ctx, id, { final })); }
+async function importNow(ctx, id) {
+  const r = notes.importBullets(ctx.runtimeDir, { id });
+  if (r.added.length) await enrichNow(ctx, id, r.added, 'bullets');
+}
+/** The late minutes (handed to the agent, no bullets by their deadline) go through the line fallback. Then the next
+ * deadline gets a timer, so a minute handed off at Stop is caught even though the minute timer has stopped. */
+const lateTimers = new Map();   // note id → timer
+async function lateNow(ctx, id) {
+  const dir = ctx.runtimeDir;
+  if (!stillOpen(dir, id)) return;
+  await importNow(ctx, id);
+  const r = notes.lateMinutes(dir, { id, minuteMs: minuteMsOf(ctx) });
+  for (const x of r.late) {
+    notes.markFallback(dir, { id, minute: x.minute });
+    await enrichNow(ctx, id, x.lines.filter((l) => l.cat && notes.meetsBar(l.cat, l.text)), 'lines');
+  }
+  watchLate(ctx, id, r.next_at);
+}
+function watchLate(ctx, id, at) {
+  const old = lateTimers.get(id); if (old) { clearTimeout(old); lateTimers.delete(id); }
+  if (at == null) return;
+  const t = setTimeout(() => { lateTimers.delete(id); chain(id, () => lateNow(ctx, id)); }, Math.max(20, at - Date.now() + 20));
+  if (t.unref) t.unref();
+  lateTimers.set(id, t);
+}
+function unwatchLate(id) { const t = lateTimers.get(id); if (t) { clearTimeout(t); lateTimers.delete(id); } }
+async function minuteNow(ctx, id, { final }) {
+  const dir = ctx.runtimeDir;
+  if (!stillOpen(dir, id)) return;
+  await lateNow(ctx, id);
+  const b = notes.takeBatch(dir, { id, final });
+  if (!b.ok || !b.minute) return;
+  const note = stillOpen(dir, id);
+  if (!note) return;
+  if (handToAgent(ctx, id, note, b)) {
+    notes.minuteHanded(dir, { id, minute: b.minute, lines: b.lines, final: b.final });
+    const r = notes.lateMinutes(dir, { id, minuteMs: minuteMsOf(ctx) });
+    watchLate(ctx, id, r.next_at);
+    return;
+  }
+  // no agent: Jev labels the lines that meet the bar for their local label, and the checkable ones are checked. A batch
+  // never holds an open line (takeBatch leaves it for later; pause closes it), so a line cut mid-sentence is never sent.
+  await enrichNow(ctx, id, b.lines.filter((x) => !x.open && x.cat && notes.meetsBar(x.cat, x.text)), 'lines');
+  // the meeting ended and no agent will close the points still open: they are closed here, then labelled and checked
+  if (b.final) { const c = notes.closeOpenBullets(dir, { id }); if (c.closed.length) await enrichNow(ctx, id, c.closed, 'bullets'); }
+}
+/** The batch to the note's bullets session. → true when an agent has it; false when the fallback must run. */
+function handToAgent(ctx, id, note, b) {
+  const dir = ctx.runtimeDir;
+  const m = note.minutes || {};
+  const cmd = bulletsAgentOf(ctx);
+  if (cmd === 'off') { notes.setMinutesAgent(dir, { id, agent: 'off', reason: 'the bullets agent is switched off on this machine' }); return false; }
+  if (typeof ctx.spawnSession !== 'function') { notes.setMinutesAgent(dir, { id, agent: 'off', reason: 'this workspace cannot start sessions' }); return false; }
+  if (m.agent === 'failed') return false;
+  const h = notes.minuteHandoff(dir, { id, minute: b.minute, lines: b.lines, context: b.context, final: b.final, terms: repoTermsFor(ctx, note) });
+  if (!h.ok) return false;
+  if (m.agent === 'on' && m.session && typeof ctx.sendToSession === 'function' && ctx.sendToSession(m.session, notes.bulletsFollowUp(h))) return true;
+  const w = note.ws ? ctx.getWs(note.ws) : null;
+  const s = ctx.spawnSession({ name: 'notes: bullets', agent: cmd, ws: w ? w.id : undefined, origin: 'notes-bullets:' + id, initialInput: notes.bulletsPrompt(h) + '\r' });
+  const started = !!s && s.state !== 'exited';
+  if (!started) {
+    try { fs.unlinkSync(h.md); } catch { /* gone */ }
+    notes.setMinutesAgent(dir, { id, agent: 'failed', reason: (s && s.note) || 'could not start a ' + cmd + ' session', session: null });
+    return false;
+  }
+  notes.setMinutesAgent(dir, { id, agent: 'on', reason: '', session: s.id });
+  return true;
+}
+/** What the page shows about the bullets: who makes them, why not, the session, and when the next minute is taken. */
+function bulletsState(ctx, note) {
+  const m = note.minutes || {};
+  const t = timers.get(note.id);
+  const cannot = note.private ? 'this note is marked private' : bulletsAgentOf(ctx) === 'off' ? 'the bullets agent is switched off on this machine'
+    : typeof ctx.spawnSession !== 'function' ? 'this workspace cannot start sessions' : '';
+  const agent = cannot ? 'off' : (m.agent || 'on');
+  const imported = new Set((m.imported || []).map(Number));
+  const waiting = Object.keys(m.handed || {}).map(Number).filter((n) => !imported.has(n) && !(m.fallback || []).includes(n)).length;
+  return { agent, reason: cannot || m.reason || '', session: agent === 'on' ? m.session || null : null, next_at_ms: t ? t.next_at_ms : null, minute_ms: minuteMsOf(ctx), minutes: Number(m.n) || 0,
+    late: (m.fallback || []).length, waiting };
+}
+
+/* ── the names and terms of a note and its repository, cached ───────────────────────────────────── */
+// A repository glossary, when it has one: bold terms, "- Term:" items and small headings. Read at most 64 KB.
+const GLOSSARY_FILES = ['GLOSSARY.md', 'glossary.md', 'planning/glossary.md', 'docs/glossary.md', 'okf/glossary.md'];
+const glossaryCache = new Map();   // root → { at, terms }
+function glossaryOf(root) {
+  const c = glossaryCache.get(root);
+  if (c && Date.now() - c.at < VOCAB_TTL_MS) return c.terms;
+  const terms = [];
+  for (const rel of GLOSSARY_FILES) {
+    let text = '';
+    try { const fd = fs.openSync(path.join(root, rel), 'r'); try { const b = Buffer.alloc(64 * 1024); text = b.subarray(0, fs.readSync(fd, b, 0, b.length, 0)).toString('utf8'); } finally { fs.closeSync(fd); } } catch { continue; }
+    for (const m of text.matchAll(/^\s*(?:[-*]\s+)?\*\*([^*\n]{2,40}?)\*\*/gm)) terms.push(m[1]);
+    for (const m of text.matchAll(/^\s*[-*]\s+([A-Za-z][\w .&/-]{1,38}?)\s*[:—–]\s/gm)) terms.push(m[1]);
+    for (const m of text.matchAll(/^#{2,4}\s+([^\n#]{2,40})$/gm)) terms.push(m[1]);
+    break;
   }
+  const out = terms.map((t) => t.replace(/\s*[—–(].*$/, '').trim()).filter(Boolean).slice(0, 40);
+  glossaryCache.set(root, { at: Date.now(), terms: out });
+  return out;
+}
+/** The repository's terms for a note: its initiative's title, the glossary, and the product terms in the open initiatives' titles. */
+function repoTermsFor(ctx, note) {
+  const w = note && note.ws && typeof ctx.getWs === 'function' ? ctx.getWs(note.ws) : null;
+  const linked = note && note.initiative && note.initiative.title ? [note.initiative.title] : [];
+  if (!w || !w.root) return linked;
+  const open = notesLinks.initiativesOf(w.root);
+  return [...linked, ...glossaryOf(w.root), ...notes.termsIn(open.map((i) => i.title))];
+}
+const vocabCache = new Map();      // note id → { at, text }
+function vocabFor(ctx, id) {
+  const c = vocabCache.get(id);
+  if (c && Date.now() - c.at < VOCAB_TTL_MS) return c.text;
+  const r = notes.read(ctx.runtimeDir, id);
+  const text = r.ok && !r.note.private ? notes.vocabOf(r.note, { terms: repoTermsFor(ctx, r.note) }).text : '';
+  vocabCache.set(id, { at: Date.now(), text });
+  if (vocabCache.size > 200) vocabCache.delete(vocabCache.keys().next().value);
+  return text;
 }
 
 /* ── local Whisper: one transcriber for the process ───────────────────────────────────────────── */
@@ -106,9 +290,10 @@ function transcriberFor(ctx) {
   transcriberDir = ctx.runtimeDir;
   transcriber = whisper.createTranscriber({
     runtimeDir: ctx.runtimeDir,
+    vocab: ({ id }) => vocabFor(ctx, id),
     onText: async (c) => {
-      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t });
-      if (r.ok) { audioErrors.delete(c.id); await enrich(ctx, c.id, r.added).catch(() => {}); }
+      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t, ms: c.ms });
+      if (r.ok) { audioErrors.delete(c.id); arm(ctx, c.id); }
     },
     onError: (c) => { audioErrors.set(c.id, { at: new Date().toISOString(), error: c.error }); },
   });
@@ -118,7 +303,8 @@ 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 })), keep_audio: notesAudio.getKeep(ctx.runtimeDir) };
+    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) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
   const sw = jevNotes.getSwitch(ctx.runtimeDir, w.root);
@@ -136,8 +322,15 @@ async function handle(req, res, url, ctx) {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
     if (p === '/api/notes') { send(ctx, res, notes.list(dir)); return true; }
     const nid = url.searchParams.get('id');
+    // 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');
     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); }
+    if (r.ok) {
+      r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid);
+      if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
+      r.bullets_state = bulletsState(ctx, r.note);
+    }
     send(ctx, res, r);
     return true;
   }
@@ -192,7 +385,11 @@ async function handle(req, res, url, ctx) {
   // from_event: the initiative is the calendar event's own, and never replaces the PM's choice
   if (p === '/api/notes/link') return done(notes.link(dir, { id, meeting: body.meeting, initiative: body.initiative, by: body.from_event === true ? 'event' : 'pm' }));
   if (p === '/api/notes/dictate') return done(notes.dictation(body.text));
-  if (p === '/api/notes/save') return done(notes.save(dir, { id, title: body.title, body: body.body }));
+  if (p === '/api/notes/save') {
+    const r = notes.save(dir, { id, title: body.title, body: body.body });
+    if (r.ok && r.added && r.added.length) arm(ctx, id);
+    return done(r);
+  }
   const wsOf = () => {
     if (body.ws == null) return { ok: true, w: null };
     const w = typeof body.ws === 'string' ? ctx.getWs(body.ws) : null;
@@ -201,11 +398,24 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/record') {
     const o = wsOf();
     if (!o.ok) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
-    return done(notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id }));
+    const r = notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id });
+    if (r.ok) {
+      // 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: '' });
+      arm(ctx, id);
+    }
+    return done(r);
+  }
+  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 }); }
+    return done(r);
   }
   if (p === '/api/notes/transcript') {
     const r = notes.appendTranscript(dir, { id, text: body.text, source: 'speech' });
-    if (r.ok) enrich(ctx, id, r.added);
+    if (r.ok) arm(ctx, id);
     return done(r);
   }
   if (p === '/api/notes/audio') {
@@ -221,13 +431,15 @@ async function handle(req, res, url, ctx) {
     if (pcm.length % 2) return done({ ok: false, status: 400, error: 'the audio must be 16-bit samples' });
     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);
+    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) }); } }
     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/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]);
     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') }));
@@ -240,11 +452,12 @@ 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.language !== undefined || body.model !== undefined || body.keep_audio !== undefined) {
+    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 };
-      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; }
+      const a = r.ok && m.ok && body.accuracy !== undefined ? whisper.setAccuracy(dir, String(body.accuracy)) : { ok: true };
+      const k = r.ok && m.ok && a.ok && body.keep_audio !== undefined ? notesAudio.setKeep(dir, body.keep_audio) : { ok: true };
+      if (!r.ok || !m.ok || !a.ok || !k.ok) { ctx.json(res, { ok: false, error: r.error || m.error || a.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; }
@@ -264,11 +477,15 @@ async function handle(req, res, url, ctx) {
     return true;
   }
   if (p === '/api/notes/private') {
+    vocabCache.delete(id);
     const r = notes.setPrivate(dir, { id, private: body.private });
-    if (r.ok && r.private) { if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
+    if (r.ok && r.private) { disarm(id); unwatchLate(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
     return done(r);
   }
   if (p === '/api/notes/summarize') {
+    // after Stop, what was said since the last minute is one more batch (nothing when the pause already took it)
+    // a note that was never recorded (typed lines only) gets its batch here too
+    { const cur0 = notes.read(dir, id); if (cur0.ok && !cur0.note.private && !listening(cur0.note)) runMinute(ctx, id, { final: true }); }
     const r = notes.localSummary(dir, { id });
     if (!r.ok) return done(r);
     const ws = wsOf();
@@ -278,28 +495,41 @@ async function handle(req, res, url, ctx) {
       if (s.pick) { const l = notes.link(dir, { id, initiative: { id: s.pick.id, ws: ws.w.id, title: s.pick.title, shared: s.pick.shared }, by: 'local' }); if (l.ok) r.initiative = l.note.initiative; }
     }
     if (r.initiative === undefined) r.initiative = cur.ok ? cur.note.initiative || null : null;
+    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
+      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' };
+      if (r.agent.started) r.source = 'agent';
+    }
     return done(r);
   }
-  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); }
+  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); }
   // 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) {
     w = typeof body.ws === 'string' ? ctx.getWs(body.ws) : null;
     if (!w || w.id !== body.ws) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
   }
-  const h = notes.agentHandoff(dir, { id });
-  if (!h.ok) return done(h);
+  return done(startAgent(ctx, dir, id, w));
+}
+
+/** The handoff file (refused for a private note), then the PM's own agent session in the repository `w`, or none.
+ * → { ok, started, session, reason, handoff, out, withheld } or an error. */
+function startAgent(ctx, dir, id, w) {
+  const cur = notes.read(dir, id);
+  const h = notes.agentHandoff(dir, { id, terms: cur.ok ? repoTermsFor(ctx, w ? { ...cur.note, ws: w.id } : cur.note) : [] });
+  if (!h.ok) return h;
   if (typeof ctx.spawnSession !== 'function') {
     notes.agentStarted(dir, { id, started: false, reason: 'this workspace cannot start sessions' });
-    ctx.json(res, { ok: true, started: false, reason: 'this workspace cannot start sessions', handoff: h.handoff, out: h.out, withheld: h.withheld });
-    return true;
+    return { ok: true, started: false, session: null, reason: 'this workspace cannot start sessions', handoff: h.handoff, out: h.out, withheld: h.withheld };
   }
   const s = ctx.spawnSession({ name: 'notes: summary', agent: 'claude', ws: w ? w.id : undefined, origin: 'notes-summary:' + id, initialInput: h.prompt + '\r' });
   const started = !!s && s.state !== 'exited';
   const reason = started ? '' : ((s && s.note) || 'could not start a claude session');
   notes.agentStarted(dir, { id, session: s ? s.id : null, started, reason });
-  ctx.json(res, { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld });
-  return true;
+  return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, __idle: () => Promise.all([transcriber ? transcriber.idle() : null, ...chains.values()]) };
+module.exports = { prefixes, handle, enrich, runMinute, bulletsState, __idle: () => Promise.all([transcriber ? transcriber.idle() : null, ...chains.values()]) };

package/workspace/package-lock.json

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

package/workspace/package.json

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