create-pmos 0.132.0 → 0.134.0

package/workspace/lib/notes-whisper.js

@@ -25,9 +25,14 @@
  * The cuts are long (a pause of 1 s, at least 4 s) so that a cut holds a whole sentence more often than a fragment;
  * lib/notes.js joins a cut that still ends mid-sentence to the one before it.
  *
- * VOCABULARY AND CONTEXT. Each run gets `--prompt` with the names and terms of the repository (the `vocab` callback, or the
- * `prompt` string) and the last line heard from the same source, at most PROMPT_MAX characters. Whisper then spells the
- * repository's people and product terms as the repository does, and reads the cut as the continuation of the line before.
+ * VOCABULARY. Each run gets `--prompt` with the names and terms of the repository (the `vocab` callback, or the `prompt`
+ * string), at most PROMPT_MAX characters, so Whisper spells the repository's people and product terms as the repository does.
+ * The line before is no longer passed (notes-recording-reliability): it made Whisper repeat it, and a line in another language
+ * pulled the next cut into that language. promptFor still takes a previous line for the final pass.
+ *
+ * GUARDS (notes-recording-reliability, lib/notes-live-guard.js). A cut that repeats the line before it is dropped, a sentence
+ * repeated back to back is kept once, the meeting's words are taken out of the microphone's line (the echo through the PM's
+ * speakers), and with English chosen a cut that comes back in another language is run again in English.
  *
  * INVENTED LINES. whisper.cpp's no-speech threshold (`-nth`) drops segments it thinks are silence. A cut that is mostly
  * quiet and comes back as only "Thank you." or "you" is a known invention and is dropped (cleanText). A program too old
@@ -38,6 +43,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const { execFile } = require('child_process');
+const liveGuard = require('./notes-live-guard.js');
 
 const RATE = 16000;
 const FRAME_MS = 100;
@@ -53,6 +59,9 @@ const LEAD_MS = 300;                 // speech that starts a cut keeps this much
 const MIN_RMS = 180;                 // in 16-bit units; below this a frame is quiet whatever the room
 const MAX_QUEUE = 24;
 const RUN_TIMEOUT_MS = 120000;
+const HOLD_MS = 12000;               // a microphone line waits at most this long for the meeting's line of the same time
+const MEETING_LIVE_MS = 30000;       // meeting audio this recent means the meeting is being captured
+const ECHO_KEEP_MS = 60000;          // the lines kept for the echo check
 const MODEL_BASE = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/';
 // The faster model is the same one quantized to 5 bits: a third of the size, so it loads and runs faster on an M1, and it
 // makes a few more mistakes. Every cut starts the program again, so the time to load the model is paid on every line.
@@ -253,9 +262,10 @@ function runWhisper({ bin, model, file, lang = DEFAULT_LANGUAGE, accuracy = DEFA
  * @param {Function} [a.run]     runWhisper, replaceable in the suites
  * @param {Function} [a.detect]  detect, replaceable in the suites
  */
-function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWhisper, detect: det = () => detect(runtimeDir), vocab = null, prompt = '' }) {
+function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = () => {}, run = runWhisper, detect: det = () => detect(runtimeDir), vocab = null, prompt = '',
+  echo = true, holdMs = HOLD_MS, recent = null, lastLine = null }) {
   const bufs = new Map();     // `${id}|${source}` → { id, source, chunks, ms, voicedMs, quietMs, t, noise }
-  const lastText = new Map(); // `${id}|${source}` → the last words heard there, the context of the next cut
+  const lastText = new Map(); // `${id}|${source}` → { text, t }: the last line heard there, for the repetition guard
   const vocabOf = (job) => { if (typeof vocab !== 'function') return prompt || ''; try { return String(vocab({ id: job.id, source: job.source }) || ''); } catch { return prompt || ''; } };
   const noiseOf = new Map();  // source → the quiet level last measured, so a new cut starts from it
   let queue = Promise.resolve();
@@ -264,13 +274,98 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
   // a cut left by a process that ended while the program ran is deleted when the next transcriber starts
   try { for (const f of fs.readdirSync(tmpDir)) if (/^cut-[0-9a-f]+\.wav$/.test(f)) fs.unlinkSync(path.join(tmpDir, f)); } catch { /* no folder yet */ }
 
+  /* LIVE ECHO (notes-recording-reliability). A microphone line is held until the meeting source has nothing left to say about the
+   * same time: no meeting cut queued that starts before the line ends, and no meeting speech buffered from before then. Then
+   * the meeting's words are taken out of it (lib/notes-live-guard.js stripEcho), and what is left, if anything, is the PM's.
+   * A line is never held longer than holdMs. A note with no meeting audio holds nothing. */
+  const heard = new Map();    // note id → [{ source, t, end, text }] the lines of the last ECHO_KEEP_MS, for the echo check
+  const meetingAt = new Map();// note id → when meeting audio last arrived (Date.now())
+  const inQueue = [];         // { id, source, t } of the cuts queued and not yet emitted
+  const held = [];            // { job, text, until }
+  let holdTimer = null;
+  const remember = (job, text) => {
+    const xs = (heard.get(job.id) || []).filter((x) => x.end >= job.t - ECHO_KEEP_MS);
+    xs.push({ source: job.source, t: job.t, end: job.t + job.ms, text });
+    heard.set(job.id, xs);
+  };
+  const meetingBusyBefore = (id, end) => {
+    if (inQueue.some((q) => q.id === id && q.source === 'meeting' && q.t < end)) return true;
+    const b = bufs.get(id + '|meeting');
+    return !!(b && b.voicedMs >= MIN_VOICED_MS && b.t < end);
+  };
+  const emit = async (job, text, extra) => {
+    const key = job.id + '|' + job.source;
+    let prev = lastText.get(key);
+    if (!prev && typeof lastLine === 'function') { try { prev = lastLine(job.id, job.source) || null; } catch { prev = null; } }
+    if (liveGuard.repeats(text, prev, job.t)) return;
+    lastText.set(key, { text, t: job.t });
+    remember(job, text);
+    await onText({ ...job, text, ...(extra || {}) });
+  };
+  // the meeting lines heard here, and the note's own meeting lines (`recent`), so a restart still knows what the meeting said
+  const meetingLines = (id) => {
+    let stored = [];
+    try { stored = typeof recent === 'function' ? (recent(id) || []) : []; } catch { stored = []; }
+    return stored.concat((heard.get(id) || []).filter((x) => x.source === 'meeting'));
+  };
+  const ownWords = (job, text) => liveGuard.stripEcho({ t: job.t, end: job.t + job.ms, text }, meetingLines(job.id));
+  function release(force = false) {
+    const now = Date.now();
+    for (let i = 0; i < held.length;) {
+      const h = held[i];
+      if (force || now >= h.until || !meetingBusyBefore(h.job.id, h.job.t + h.job.ms)) {
+        held.splice(i, 1);
+        queue = queue.then(async () => { const own = ownWords(h.job, h.text); if (own) await emit(h.job, own, h.extra); }).catch(() => {});
+      } else i++;
+    }
+    if (holdTimer) { clearTimeout(holdTimer); holdTimer = null; }
+    if (held.length) { holdTimer = setTimeout(() => release(), 250); if (holdTimer.unref) holdTimer.unref(); }
+  }
+  async function deliver(job, text, extra) {
+    // only cuts placed by their capture's own clock (`exact`) are compared: a time taken from arrival says nothing about overlap
+    const meetingLive = echo && job.exact && job.source === 'mic' && Date.now() - (meetingAt.get(job.id) || 0) < MEETING_LIVE_MS;
+    if (!meetingLive) { await emit(job, text, extra); return; }
+    const own = ownWords(job, text);
+    if (!own) return;
+    if (!meetingBusyBefore(job.id, job.t + job.ms)) { await emit(job, own, extra); return; }
+    held.push({ job, text: own, extra, until: Date.now() + holdMs });
+    release();
+  }
+
+  /* LANGUAGE (decision 8: accented English is always English). With English (or detect) chosen, a cut that comes back in
+   * another language is run again forced to English, with the vocabulary alone as its prompt. The English text is kept and the
+   * first text goes with it as `heard_as`. When the run in English still is not English, the first text is kept. */
+  async function transcribe(d, job, file, voicedRatio) {
+    const lang = getLanguage(runtimeDir);
+    const args = { engine: d.engine || 'whisper', bin: d.bin, model: d.model, file, accuracy: getAccuracy(runtimeDir), prompt: promptFor(vocabOf(job), '') };
+    const r = await run({ ...args, lang });
+    if (!r.ok) return r;
+    const text = liveGuard.onceEach(cleanText(r.text, { voicedRatio }));
+    if (!text || !(lang === 'en' || lang === 'auto') || !liveGuard.looksForeign(text, r.language)) return { ok: true, text };
+    const again = await run({ ...args, lang: 'en' });
+    const en = again.ok ? liveGuard.onceEach(cleanText(again.text, { voicedRatio })) : '';
+    if (!en || liveGuard.looksForeign(en, again.language)) return { ok: true, text };
+    return { ok: true, text: en, extra: { heard_as: { text, language: r.language || '' } } };
+  }
+
+  const cutEnd = new Map();   // `${id}|${source}` → where the last cut of that source ended (ms)
   function cut(b) {
     bufs.delete(b.id + '|' + b.source);
-    if (b.voicedMs < MIN_VOICED_MS || !b.chunks.length) return false;
+    cutEnd.set(b.id + '|' + b.source, Math.max(cutEnd.get(b.id + '|' + b.source) || 0, b.t + b.ms));
+    // the caller learns how far this source is transcribed once the cut is done, in order, so a restart redoes a cut it lost
+    // A microphone line still held for the echo check is not written yet, so the progress stops at its start: a restart then
+    // transcribes it again rather than losing it (and the repetition guard drops the lines after it that were written).
+    const done = () => {
+      const waitFor = held.filter((h) => h.job.id === b.id && h.job.source === b.source).map((h) => h.job.t);
+      try { onCut({ id: b.id, source: b.source, until: Math.min(b.t + b.ms, ...waitFor) }); } catch { /* the caller's bookkeeping */ }
+    };
+    if (b.voicedMs < MIN_VOICED_MS || !b.chunks.length) { queue = queue.then(done).catch(() => {}); if (held.length) release(); return false; }
     if (waiting >= MAX_QUEUE) { onError({ id: b.id, source: b.source, error: 'transcription is falling behind, so a few seconds were skipped' }); return false; }
     const pcm = Buffer.concat(b.chunks);
-    const job = { id: b.id, source: b.source, t: b.t, ms: b.ms };
+    const job = { id: b.id, source: b.source, t: b.t, ms: b.ms, ...(b.ts ? { exact: true } : {}) };
     const voicedRatio = b.ms > 0 ? b.voicedMs / b.ms : 1;
+    const q = { id: job.id, source: job.source, t: job.t };
+    inQueue.push(q);
     waiting++;
     queue = queue.then(async () => {
       const d = det();
@@ -279,15 +374,13 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
       const file = path.join(tmpDir, 'cut-' + crypto.randomBytes(6).toString('hex') + '.wav');
       try {
         fs.writeFileSync(file, wav(pcm), { mode: 0o600 });
-        const key = job.id + '|' + job.source;
         // `engine` is 'qwen' when the caller's detect chose Qwen3-ASR (lib/notes-qwen.js); `run` then sends the cut there
-        const r = await run({ engine: d.engine || 'whisper', bin: d.bin, model: d.model, file, lang: getLanguage(runtimeDir), accuracy: getAccuracy(runtimeDir), prompt: promptFor(vocabOf(job), lastText.get(key)) });
+        const r = await transcribe(d, job, file, voicedRatio);
         if (!r.ok) { onError({ ...job, error: r.error }); return; }
-        const text = cleanText(r.text, { voicedRatio });
-        if (text) { lastText.set(key, text); await onText({ ...job, text }); }
+        if (r.text) await deliver(job, r.text, r.extra);
       } catch (e) { onError({ ...job, error: String((e && e.message) || e) }); }
       finally { try { fs.unlinkSync(file); } catch { /* already gone */ } }
-    }).catch(() => {}).finally(() => { waiting--; });
+    }).catch(() => {}).finally(() => { waiting--; done(); const i = inQueue.indexOf(q); if (i >= 0) inQueue.splice(i, 1); if (held.length) release(); });
     return true;
   }
 
@@ -295,24 +388,34 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
    * One chunk from the page. `t` is the chunk's start, in ms from the note's recording start.
    * @returns {{ ok:true, cut:boolean }}
    */
-  function push({ id, source, pcm, t = 0, final = false }) {
+  function push({ id, source, pcm, t = 0, final = false, exact = false }) {
     const k = id + '|' + source;
+    if (source === 'meeting' && pcm && pcm.length) meetingAt.set(id, Date.now());
+    // a chunk that names its own place and belongs before audio already cut comes too late for the live transcript: on its own it
+    // would be a fragment of a sentence already written. Its audio is kept, and the final pass after Stop reads it.
+    if (exact && !final && t + 1 < (cutEnd.get(k) || 0)) return { ok: true, cut: false, late: true };
     let b = bufs.get(k);
     const lv = pcm && pcm.length ? levels(pcm) : [];
-    if (!b) { b = { id, source, chunks: [], ms: 0, voicedMs: 0, quietMs: 0, t, noise: noiseOf.has(source) ? noiseOf.get(source) : null }; bufs.set(k, b); }
+    if (!b) { b = { id, source, chunks: [], ts: exact ? [] : null, ms: 0, voicedMs: 0, quietMs: 0, t, noise: noiseOf.has(source) ? noiseOf.get(source) : null }; bufs.set(k, b); }
     for (const v of lv) {
       // the quiet level is learnt from quiet frames only, so speech at the very start is not taken for the room's noise
       const voiced = v > Math.max(MIN_RMS, (b.noise == null ? 0 : b.noise) * 3);
       if (voiced) { b.voicedMs += FRAME_MS; b.quietMs = 0; }
       else { b.quietMs += FRAME_MS; b.noise = b.noise == null ? v : b.noise * 0.9 + v * 0.1; }
     }
-    if (pcm && pcm.length) { b.chunks.push(pcm); b.ms += (pcm.length / 2 / RATE) * 1000; }
+    if (pcm && pcm.length) {
+      // a chunk that names its own place (`exact`) and arrives after a later one goes back where it belongs in the buffer
+      const at = exact && b.ts && t < b.t + b.ms - 1 && t >= b.t ? b.ts.findIndex((x) => x > t) : -1;
+      if (at >= 0) { b.chunks.splice(at, 0, pcm); b.ts.splice(at, 0, t); } else { b.chunks.push(pcm); if (b.ts) b.ts.push(t); }
+      b.ms += (pcm.length / 2 / RATE) * 1000;
+    }
     if (b.noise != null) noiseOf.set(source, b.noise);
     // quiet before anyone speaks is not kept: only the last LEAD_MS of it stays in front of the speech
     if (!b.voicedMs && b.ms > LEAD_MS + 1000) {
       const keepBytes = Math.round(RATE * LEAD_MS / 1000) * 2;
       const all = Buffer.concat(b.chunks);
       b.chunks = [all.subarray(Math.max(0, all.length - keepBytes))];
+      if (b.ts) b.ts = [b.t + b.ms - LEAD_MS];
       b.t += b.ms - LEAD_MS; b.ms = LEAD_MS;
     }
     let did = false;
@@ -322,12 +425,25 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
   }
   /** Cut whatever is buffered for a note (the page stopped). */
   function flush(id) { for (const b of Array.from(bufs.values())) if (b.id === id) cut(b); }
+  /** Is audio of this note and source buffered and not cut yet? */
+  const has = (id, source) => bufs.has(id + '|' + source);
   /** Drop a note's buffers without transcribing them (the note was marked private or deleted). */
   function drop(id) {
     for (const [k, b] of Array.from(bufs.entries())) if (b.id === id) bufs.delete(k);
     for (const k of Array.from(lastText.keys())) if (k.startsWith(id + '|')) lastText.delete(k);
+    for (let i = held.length - 1; i >= 0; i--) if (held[i].job.id === id) held.splice(i, 1);
+    heard.delete(id); meetingAt.delete(id);
+    for (const k of Array.from(cutEnd.keys())) if (k.startsWith(id + '|')) cutEnd.delete(k);
+  }
+  /** Settled: every queued cut is transcribed and every held line is out. */
+  async function idle() {
+    for (;;) {
+      const q = queue; await q;
+      if (held.length) { release(true); continue; }
+      if (q === queue) return;
+    }
   }
-  return { push, flush, drop, pending: () => waiting, idle: () => queue };
+  return { push, flush, drop, has, pending: () => waiting + held.length, idle };
 }
 
 module.exports = { detect, setupCommand, getLanguage, setLanguage, LANGUAGES, DEFAULT_LANGUAGE, getModel, setModel, MODELS, DEFAULT_MODEL,

package/workspace/lib/notes.js

@@ -520,7 +520,7 @@ function joinText(prev, next, names) {
   const tail = KEEP_CAP.test(next) || (names && names.has(word)) || PROPER_DAYS.test(word) ? next : next.charAt(0).toLowerCase() + next.slice(1);
   return askMark(head.replace(/[,\s]+$/, '') + ' ' + tail);
 }
-function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms = null, now = Date.now() } = {}) {
+function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms = null, heard_as = null, now = Date.now() } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
   if (note.private) return err(409, 'this note is marked private, so nothing more is recorded in it');
@@ -536,6 +536,8 @@ function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms =
   const tr = note.transcript || (note.transcript = []);
   const tEnd = Number.isFinite(ms) && ms > 0 ? t + Math.round(ms) : null;
   const open = JOINS.has(src) && endsOpen(raw);
+  // the first text of a line that came back in another language and was run again in English (notes-recording-reliability, D8)
+  const heardAs = heard_as && typeof heard_as.text === 'string' && heard_as.text ? { text: heard_as.text.slice(0, MAX_PHRASE), language: String(heard_as.language || '').slice(0, 40) } : null;
   const out = [];
   // the first sentence may finish the line before it, from the same source
   if (JOINS.has(src)) {
@@ -558,7 +560,7 @@ function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms =
   const base = tr.length;
   const added = sentences.map((s, k) => { const isOpen = open && k === sentences.length - 1;
     return { at: iso(now), t, ...(tEnd != null ? { t_end: tEnd } : {}), text: s, source: src, cat: isOpen ? null : categoryOf(s, names), cat_by: 'local',
-      ...(isOpen ? { open: true } : {}), index: base + k }; });
+      ...(isOpen ? { open: true } : {}), ...(heardAs ? { heard_as: heardAs } : {}), index: base + k }; });
   note.transcript = tr.concat(added.map(({ index, ...x }) => x));
   note.updated_at = iso(now);
   store(dir, note);

package/workspace/lib/route-modules.js

@@ -60,6 +60,7 @@ const MODULES = Object.freeze([
   'routes-c3-life',       // console3 Lifecycle lens panels: newest evaluation per initiative, corrections per run, evidence sources (read-only)
   'routes-c3-strategy',   // console3 Calendar Quarter and Year panes: outcomes, north star, signals, synergy, bets (read-only)
   'routes-c3-reports',    // console3 Reports dashboards: library, per-scope data, page-press layouts (layouts are the only write)
+  'routes-onboarding',    // onboarding-scan-and-map slice 2: first run (scan read-only, structure, import into the overlay, undo, first Briefing)
   'routes-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
   'routes-sources',       // workspace-data-freshness: how old each source is, Refresh now, the change detector switch
 ]);

package/workspace/lib/routes-notes.js

@@ -15,7 +15,7 @@
  *   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, clock_from, meeting_ms }    `ws` is the repository the note's lines are checked against;
+ *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from, clock_from, meeting_ms, capture: { token, base_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, state, paused_at, resume_until, ended_at, ended_by, sessions }
  *                                             a resumable pause (Run 13, R51): the clock stops, the meeting stays open for one hour
@@ -28,7 +28,8 @@
  *   ended. A row and a note carry state ('idle'|'recording'|'paused'|'ended'), paused_at, resume_until, ended_at, ended_by, sessions
  *   and meeting.context (the snapshot of the meeting, lib/notes.js cleanContext; R59).
  *   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/audio      { id, source, pcm, final?, cap?, seq?, off? } → { ok, cut, dup? }   16 kHz mono 16-bit samples, base64; local Whisper (D91);
+ *                                             cap/seq/off name the chunk's capture, sequence number and sample offset (lib/notes-capture.js)
  *   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)
@@ -74,6 +75,7 @@
 const guard = require('./pm-guard.js');
 const notes = require('./notes.js');
 const whisper = require('./notes-whisper.js');
+const notesCapture = require('./notes-capture.js');
 const notesRepo = require('./notes-repo.js');
 const notesAudio = require('./notes-audio.js');
 const notesEcho = require('./notes-echo.js');
@@ -381,6 +383,7 @@ function liveRun(ctx, args) {
 }
 let transcriber = null; let transcriberDir = null;
 const audioErrors = new Map();   // note id → the last thing that went wrong, for the page
+const fedHere = new Set();       // `${id}|${source}|${token}` this process has had chunks of: the first one after a restart picks up what was lost
 function transcriberFor(ctx) {
   if (transcriber && transcriberDir === ctx.runtimeDir) return transcriber;
   transcriberDir = ctx.runtimeDir;
@@ -389,11 +392,27 @@ function transcriberFor(ctx) {
     detect: () => liveDetect(ctx),
     run: (args) => liveRun(ctx, args),
     vocab: ({ id }) => vocabFor(ctx, id),
+    // the note's meeting lines of the last minute, for the live echo check
+    recent: (id) => {
+      const r = notes.read(ctx.runtimeDir, id);
+      if (!r.ok) return [];
+      const tr = r.note.transcript || []; const last = tr.length ? tr[tr.length - 1].t || 0 : 0;
+      return tr.filter((x) => x && x.source === 'meeting' && (x.t || 0) >= last - 60000).map((x) => ({ source: 'meeting', t: x.t || 0, end: Number.isFinite(x.t_end) ? x.t_end : (x.t || 0), text: x.text }));
+    },
+    // the last line of a source, for the repetition guard after a restart
+    lastLine: (id, source) => {
+      const r = notes.read(ctx.runtimeDir, id);
+      const tr = r.ok ? r.note.transcript || [] : [];
+      for (let k = tr.length - 1; k >= 0; k--) if (tr[k] && tr[k].source === source) return { text: tr[k].text, t: tr[k].t || 0 };
+      return null;
+    },
     onText: async (c) => {
-      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t, ms: c.ms });
+      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t, ms: c.ms, heard_as: c.heard_as });
       if (r.ok) { audioErrors.delete(c.id); arm(ctx, c.id); }
     },
     onError: (c) => { audioErrors.set(c.id, { at: new Date().toISOString(), error: c.error }); },
+    // how far the live transcription has cut each source, kept with the capture so a restart picks up what it had buffered
+    onCut: (c) => { try { notesCapture.setCut(ctx.runtimeDir, c.id, { source: c.source, sample: Math.round(c.until * whisper.RATE / 1000) }); } catch { /* best effort */ } },
   });
   return transcriber;
 }
@@ -669,8 +688,13 @@ async function handle(req, res, url, ctx) {
     const rm = resumeMsOf(ctx);
     // a pause that ran out ends the meeting first (final notes and all), then the record is refused
     endMeeting(ctx, id, 'timeout');
+    // one capture per note: another tab or window that is sending this note's audio keeps it (notes-recording-reliability)
+    if (notesCapture.busy(dir, id)) return done({ ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' });
     const r = notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id, resumeMs: rm });
     if (r.ok) {
+      // the page names each chunk's place from here: the capture's token, and the meeting time it starts at
+      const c = notesCapture.start(dir, id, { baseMs: r.meeting_ms });
+      if (c.ok) r.capture = { token: c.token, base_ms: c.base_ms };
       clearExpiry(id); swept.delete(id);
       // a new Listen tries the agent again when it could not start last time
       const cur = notes.read(dir, id);
@@ -685,6 +709,7 @@ async function handle(req, res, url, ctx) {
   }
   if (p === '/api/notes/pause') {
     const r = notes.pause(dir, { id, resumeMs: resumeMsOf(ctx) });
+    notesCapture.close(dir, id);
     // listening stopped: the minute timer stops, and what was said since the last minute is one more batch.
     // The meeting stays open: Wispr Flow and the final pass wait for Stop or for the hour to run out.
     if (r.ok) { disarm(id); runMinute(ctx, id, { final: true }); if (r.state === 'paused') armExpiry(ctx, id, r.resume_until); }
@@ -692,6 +717,7 @@ async function handle(req, res, url, ctx) {
   }
   if (p === '/api/notes/stop') {
     const r = notes.stop(dir, { id, resumeMs: resumeMsOf(ctx) });
+    notesCapture.close(dir, id);
     if (r.ok) { clearExpiry(id); swept.add(id); disarm(id); runMinute(ctx, id, { final: true }); scheduleWispr(ctx, id); }
     return done(r);
   }
@@ -718,15 +744,41 @@ async function handle(req, res, url, ctx) {
     if (pcm24 && pcm24.length % 2) return done({ ok: false, status: 400, error: 'the audio must be 16-bit samples' });
     if (!liveDetect(ctx).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, notes.meetingMs(note.note) - ms);
+    // A chunk that names its capture (notes-recording-reliability) is placed at the capture's start plus its offset, and a sequence
+    // number already written is answered as done and neither written nor transcribed again. A chunk with no token keeps the old
+    // placement by arrival time, unless a capture with a token is live: then it comes from a second tab and is refused.
+    let t; let sample = null; let cap = null;
+    if (body.cap !== undefined) {
+      cap = notesCapture.check(dir, id, { token: String(body.cap), source, seq: body.seq });
+      if (!cap.ok) return done(cap);
+      if (cap.dup) return done({ ok: true, cut: false, dup: true });
+      const off = Number(body.off);
+      if (!Number.isInteger(off) || off < 0) return done({ ok: false, status: 400, error: 'a chunk needs its sample offset' });
+      sample = Math.round(cap.base_ms * whisper.RATE / 1000) + off;
+      t = (sample / whisper.RATE) * 1000;
+    } else {
+      if (notesCapture.tokened(dir, id)) return done({ ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' });
+      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);
     // each source is also kept apart for the final pass after Stop, which deletes it when the PM keeps no audio (Run 9)
     // a 24 kHz chunk must cover the same time as the 16 kHz chunk (to a tenth of a second); one that does not is not kept
     const sameTime = !!pcm24 && pcm24.length > 0 && Math.abs(pcm24.length / 2 / notesAudio.HI_RATE - pcm.length / 2 / whisper.RATE) <= 0.1;
     if (pcm24 && pcm24.length && !sameTime) audioErrors.set(id, { at: new Date().toISOString(), error: 'the 24 kHz audio of one chunk did not match its 16 kHz audio, so the replay has a gap there' });
-    { try { notesAudio.write(dir, { id, source, pcm, pcm24: sameTime ? pcm24 : null, 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 }));
+    { try { notesAudio.write(dir, { id, source, pcm, pcm24: sameTime ? pcm24 : null, t, sample, mixed: notesAudio.getKeep(dir) }); } catch (e) { audioErrors.set(id, { at: new Date().toISOString(), error: 'the audio was not kept: ' + ((e && e.message) || e) }); } }
+    const tr = transcriberFor(ctx);
+    if (cap && !fedHere.has(id + '|' + source + '|' + body.cap)) {
+      fedHere.add(id + '|' + source + '|' + body.cap);
+      if (fedHere.size > 400) fedHere.delete(fedHere.values().next().value);
+      // after a restart, what this source said since its last cut was written but never transcribed: transcribe it first
+      const gap = notesCapture.untranscribed(dir, id, { source, before: sample });
+      const back = gap ? notesAudio.readSource(dir, id, source, gap.from, gap.to) : null;
+      if (back && back.pcm.length) tr.push({ id, source, pcm: back.pcm, t: (back.from / whisper.RATE) * 1000, exact: true });
+    }
+    const pushed = tr.push({ id, source, pcm, t, final: body.final === true, exact: !!cap });
+    if (cap) notesCapture.mark(dir, id, { source, seq: body.seq, end: sample + pcm.length / 2 });
+    return done(pushed);
   }
   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') {
@@ -808,7 +860,7 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/private') {
     vocabCache.delete(id);
     const r = notes.setPrivate(dir, { id, private: body.private });
-    if (r.ok && r.private) { clearExpiry(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
+    if (r.ok && r.private) { clearExpiry(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); notesCapture.remove(dir, id); }
     return done(r);
   }
   if (p === '/api/notes/summarize') {
@@ -837,7 +889,7 @@ async function handle(req, res, url, ctx) {
     }
     return done(r);
   }
-  if (p === '/api/notes/delete') { clearExpiry(id); swept.delete(id); 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); }
+  if (p === '/api/notes/delete') { clearExpiry(id); swept.delete(id); 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); notesCapture.remove(dir, id); } return done(r); }
   if (p === '/api/notes/highlight') {
     // the PM's highlight: the transcript of the window, then Jev's label and the repository check of its text
     const r = notes.addHighlight(dir, { id, from: body.from, to: body.to });