create-pmos 0.133.0 → 0.134.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.133.0",
+  "version": "0.134.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@c3d0fb4
+kernel-source: pmos@d509552
 assembled: 2026-10-11
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: notes"
 description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, decisions with their why and who, next steps with an open question, a discussion paragraph, and Wispr Flow's notes merged in and fetched by hand when the fetch fails; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository for conflicts, capture highlights during the meeting, create tasks from next steps, correct and tag lines, see what changed in your notes, replay the meeting, link a note to its meeting and its initiative, and get a summary."
-timestamp: 2026-10-08
+timestamp: 2026-10-11
 ---
 
 # Guide: notes
@@ -20,6 +20,24 @@ The Record control is at the right of the top bar. It has two groups, always in
 
 Starting a note, from the Record control or from **Take notes** on a calendar event, shows the Notes page with that note.
 
+### The Record control in the console
+
+The console (the page at `/c3.html`) has the same Record control in its top bar, beside the Sessions button. It is always there, also when nothing is recording. **Record** (the microphone) starts an untitled note and listens at once. The arrow lists the meetings of today that have not started. Press one to start a note linked to that calendar event. While a meeting records, the red group shows its name and clock, **Highlight**, **Pause** and **Stop**. While it is paused, the group shows **Resume** and **Stop**. **Stop** asks first and offers **Pause instead**. A red dot shows on the Calendar tab while a meeting is held. The console has no Notes page, so the name in the red group opens the note in the main app.
+
+When Whisper or Qwen3-ASR transcribes the meeting, the red group also names the engine and the language, for example **Whisper · English**. Check it when lines come out in the wrong language: the language is set in the Notes settings.
+
+One meeting records in one tab at a time. If another tab or window already records the meeting, **Record** there says so and starts nothing.
+
+
+## What the live transcript leaves out
+
+The live transcript keeps each sentence once:
+
+- When the meeting plays on your speakers, your microphone hears the other people too. PMOS takes their words out of your microphone's line, and keeps the line from the meeting. Your own words stay.
+- A line that only repeats the line before it is left out. A sentence said twice in a row in one line is kept once.
+- If the meeting language is English (the default), a line that comes back in another language, for example Hindi, Indonesian or Chinese, is transcribed again in English. The first text stays with the line.
+- If the workspace restarts during a meeting, the recording continues where it was. Nothing is written twice.
+
 ## Pause, resume and stop
 
 **Pause** keeps the meeting open. PMOS stops listening and the clock stops. It does not ask, and it does not write the final notes yet. You can resume for one hour. The top bar shows the minutes left. After an hour the meeting ends by itself, and PMOS writes its final notes.

package/workspace/lib/notes-audio.js

@@ -18,6 +18,9 @@
  * place and with nothing added, so the final pass after Stop (lib/notes-final.js) can tell the PM's microphone from the
  * meeting. remove deletes all three.
  *
+ * A chunk from a page that names its place (`sample`, from lib/notes-capture.js) is written exactly there, so a chunk that arrives
+ * late, or after a restart, lands where it belongs (notes-recording-reliability).
+ *
  * WHAT IT NEVER DOES. It sends nothing and opens no network module. The routes (lib/routes-notes.js) write nothing for a
  * private note, delete the file when a note is made private or deleted, and write nothing when the PM switches keeping off.
  */
@@ -80,20 +83,23 @@ function softLimit(x) {
 /** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, then limited by softLimit. With
  * `mixed: false` only the source's own file is written: the PM keeps no audio for replay, and the final pass deletes it when done.
  * The per-source files are never limited: they are what the transcription reads. */
-function write(runtimeDir, { id, source, pcm, pcm24 = null, t, mixed = true }) {
+function write(runtimeDir, { id, source, pcm, pcm24 = null, t, sample = null, mixed = true }) {
   if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
   const f = fileOf(runtimeDir, id);
   const key = f + '|' + source;
-  let at = Math.max(0, Math.round((Number(t) || 0) * BYTES_PER_MS / 2) * 2);
+  // `sample` (notes-recording-reliability): the chunk's own place, from the capture's start and its offset, so it is written there
+  // and nowhere else, whenever it arrives. Without it the chunk is placed by its arrival time, as before.
+  const exact = Number.isInteger(sample) && sample >= 0;
+  let at = exact ? sample * 2 : Math.max(0, Math.round((Number(t) || 0) * BYTES_PER_MS / 2) * 2);
   const prev = next.get(key);
   // a source never overlaps itself: a chunk that would start before its source left off, or just after, goes straight after it
-  if (prev !== undefined && at <= prev + ON_TIME_MS * BYTES_PER_MS) at = prev;
+  if (!exact && prev !== undefined && at <= prev + ON_TIME_MS * BYTES_PER_MS) at = prev;
   if (at >= MAX_BYTES) return { ok: true, kept: false };
   const len = Math.min(pcm.length, MAX_BYTES - at);
   fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
   // With 24 kHz audio the replay is the 24 kHz mix and no 16 kHz mix is written; the 16 kHz source files are written either way
   const hiOk = mixed && pcm24 && pcm24.length && pcm24.length % 2 === 0;
-  if (hiOk) writeHi(runtimeDir, id, source, pcm24, t);
+  if (hiOk) writeHi(runtimeDir, id, source, pcm24, t, exact ? Math.round(sample * HI_RATE / RATE) : null);
   if (mixed && !hiOk) {
     const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
     try {
@@ -114,12 +120,13 @@ function write(runtimeDir, { id, source, pcm, pcm24 = null, t, mixed = true }) {
 }
 
 /** Add one chunk of 24 kHz audio to the note's 24 kHz mix at meeting time `t`, placed as write() places the 16 kHz audio. */
-function writeHi(runtimeDir, id, source, pcm24, t) {
+function writeHi(runtimeDir, id, source, pcm24, t, sample = null) {
   const f = hiFileOf(runtimeDir, id);
   const key = f + '|' + source;
-  let at = Math.max(0, Math.round((Number(t) || 0) * HI_BYTES_PER_MS / 2) * 2);
+  const exact = Number.isInteger(sample) && sample >= 0;
+  let at = exact ? sample * 2 : Math.max(0, Math.round((Number(t) || 0) * HI_BYTES_PER_MS / 2) * 2);
   const prev = next.get(key);
-  if (prev !== undefined && at <= prev + ON_TIME_MS * HI_BYTES_PER_MS) at = prev;
+  if (!exact && prev !== undefined && at <= prev + ON_TIME_MS * HI_BYTES_PER_MS) at = prev;
   if (at >= HI_MAX_BYTES) return;
   const len = Math.min(pcm24.length, HI_MAX_BYTES - at);
   const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
@@ -155,12 +162,24 @@ function remove(runtimeDir, id) {
   for (const k of [...next.keys()]) if (k.startsWith(fileOf(runtimeDir, id) + '|') || k.startsWith(hiFileOf(runtimeDir, id) + '|')) next.delete(k);
   for (const src of SOURCES) { try { fs.unlinkSync(sourceFileOf(runtimeDir, id, src)); } catch { /* none */ } }
   let removed = false;
-  for (const extra of ['.echo.json', '.pcm.echo.tmp', '.hi.pcm.echo.tmp', '.hi.pcm', '.clean.pcm', '.clean.pcm.tmp']) {
+  for (const extra of ['.capture.json', '.echo.json', '.pcm.echo.tmp', '.hi.pcm.echo.tmp', '.hi.pcm', '.clean.pcm', '.clean.pcm.tmp']) {
     try { fs.unlinkSync(path.join(dirOf(runtimeDir), id + extra)); if (extra === '.hi.pcm') removed = true; } catch { /* none */ }
   }
   try { fs.unlinkSync(fileOf(runtimeDir, id)); removed = true; } catch { /* none */ }
   return removed;
 }
+/** Samples [from, to) (16 kHz) of one source's own file, or null. At most a minute. */
+function readSource(runtimeDir, id, source, from, to) {
+  if (!ID_RE.test(String(id || '')) || !SOURCES.includes(source)) return null;
+  const a = Math.max(0, from, to - RATE * 60); const n = (to - a) * 2;
+  if (n <= 0) return null;
+  let fd;
+  try {
+    fd = fs.openSync(sourceFileOf(runtimeDir, id, source), 'r');
+    const b = Buffer.alloc(n); const got = fs.readSync(fd, b, 0, n, a * 2);
+    return got > 0 ? { pcm: b.subarray(0, got - (got % 2)), from: a } : null;
+  } catch { return null; } finally { if (fd !== undefined) fs.closeSync(fd); }
+}
 /** The note's audio, one file per source: [{ source, file, bytes, ms }], the sources that were heard. */
 function sources(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return [];
@@ -220,4 +239,4 @@ function serve(req, res, runtimeDir, id) {
   fs.createReadStream(inf.file, { start: from, end: to }).on('error', () => res.end()).pipe(res);
 }
 
-module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, getClean, setClean, hasClean, replayOf, wavHeader, softLimit, replayFile: (dir, id) => (baseOf(dir, id) || { file: fileOf(dir, id) }).file, mixFile: fileOf, hiFile: hiFileOf, sideFile: sideFileOf, baseOf, cleanFile: cleanFileOf, HI_RATE, RATE, BYTES_PER_MS, MAX_BYTES };
+module.exports = { write, readSource, info, remove, removeSources, sources, serve, getKeep, setKeep, getClean, setClean, hasClean, replayOf, wavHeader, softLimit, replayFile: (dir, id) => (baseOf(dir, id) || { file: fileOf(dir, id) }).file, mixFile: fileOf, hiFile: hiFileOf, sideFile: sideFileOf, baseOf, cleanFile: cleanFileOf, HI_RATE, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/lib/notes-capture.js

@@ -0,0 +1,128 @@
+'use strict';
+/* notes-capture.js — which page is capturing a note, and which chunks of it are already written (notes-recording-reliability). Local only.
+ *
+ *   start(runtimeDir, id, { baseMs, now }) → { ok, token, base_ms } | { ok: false, status: 409, error }
+ *   check(runtimeDir, id, { token, source, seq, now }) → { ok, dup, base_ms } | { ok: false, status: 409, error }
+ *   mark(runtimeDir, id, { source, seq, now })   the chunk is written: a second copy of it is a duplicate
+ *   setCut(runtimeDir, id, { source, sample }) · untranscribed(runtimeDir, id, { source, before }) → { from, to } | null
+ *                                                the live transcription's progress, so a restart transcribes what it had buffered
+ *   close(runtimeDir, id)                        Pause or Stop: the capture ends, and the next Listen starts a new one
+ *   tokened(runtimeDir, id) → true when the live capture has sent a chunk with its token
+ *   remove(runtimeDir, id)
+ *
+ * WHY. The page sends each source in one-second chunks and sends a chunk again when its answer does not come back. Before this
+ * module, the server placed each chunk at its arrival time and remembered in memory where each source ended. So a chunk written
+ * twice was kept twice, a restart lost the memory and the next chunk was added onto audio already written, a late chunk moved
+ * the rest of its source, and two tabs could capture one note into the same file (measured by notes-duplication.test.js).
+ *
+ * WHAT IT KEEPS. Listen hands the page a token and the meeting time the capture starts at (base_ms). Each chunk carries the
+ * token, a sequence number per source and its sample offset in the capture, so the route places it at base_ms + offset, and
+ * the sequence numbers already written are kept as ranges. All of it is in `<runtime>/notes/recordings/<id>.capture.json`,
+ * next to the audio, so a restart keeps it.
+ *
+ * ONE CAPTURE PER NOTE. Listen is refused while another capture is live: one that sent a chunk (or started) in the last
+ * LIVE_MS. A chunk with a token that is not the note's capture is refused, and the page stops listening on that answer.
+ *
+ * WHAT IT NEVER DOES. It sends nothing and opens no network module.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const LIVE_MS = 5000;
+const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
+const fileOf = (runtimeDir, id) => path.join(runtimeDir, 'notes', 'recordings', id + '.capture.json');
+const cache = new Map();   // file → state, written through to the file
+
+function load(runtimeDir, id) {
+  const f = fileOf(runtimeDir, id);
+  if (cache.has(f)) return cache.get(f);
+  let s = null;
+  try { s = JSON.parse(fs.readFileSync(f, 'utf8')); } catch { s = null; }
+  if (!s || typeof s !== 'object') s = null;
+  cache.set(f, s);
+  return s;
+}
+function save(runtimeDir, id, s) {
+  const f = fileOf(runtimeDir, id);
+  cache.set(f, s);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(s), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+const liveAt = (s) => Math.max(Date.parse(s.started_at) || 0, Date.parse(s.last_at) || 0);
+const isLive = (s, now) => !!(s && s.token && !s.closed && now - liveAt(s) < LIVE_MS);
+
+/** A new capture, unless another one is live. */
+function start(runtimeDir, id, { baseMs = 0, now = Date.now() } = {}) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const s = load(runtimeDir, id);
+  if (isLive(s, now)) return { ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' };
+  const token = crypto.randomBytes(9).toString('hex');
+  const base = Math.max(0, Math.round(Number(baseMs) || 0));
+  save(runtimeDir, id, { token, base_ms: base, started_at: new Date(now).toISOString(), last_at: null, closed: false, tokened: false, seqs: {} });
+  return { ok: true, token, base_ms: base };
+}
+/** Refuse true when another check would refuse the next Listen: used before the note's own record step changes anything. */
+function busy(runtimeDir, id, { now = Date.now() } = {}) { return isLive(load(runtimeDir, id), now); }
+
+const has = (ranges, n) => (ranges || []).some(([a, b]) => n >= a && n <= b);
+function add(ranges, n) {
+  const r = (ranges || []).concat([[n, n]]).sort((x, y) => x[0] - y[0]);
+  const out = [];
+  for (const [a, b] of r) { const last = out[out.length - 1]; if (last && a <= last[1] + 1) last[1] = Math.max(last[1], b); else out.push([a, b]); }
+  return out;
+}
+
+/** May this chunk be written? `dup` when its sequence number is already written. */
+function check(runtimeDir, id, { token, source, seq } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || !s.token || s.closed || s.token !== token) return { ok: false, status: 409, error: 'this meeting is being recorded in another tab or window, or listening stopped' };
+  const n = Number(seq);
+  if (!Number.isInteger(n) || n < 0) return { ok: false, status: 400, error: 'a chunk needs a sequence number' };
+  return { ok: true, dup: has((s.seqs || {})[source], n), base_ms: s.base_ms };
+}
+function mark(runtimeDir, id, { source, seq, end = null, now = Date.now() } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s) return;
+  s.seqs = s.seqs || {};
+  s.seqs[source] = add(s.seqs[source], Number(seq));
+  if (Number.isInteger(end)) { s.fed = s.fed || {}; s.fed[source] = Math.max(s.fed[source] || 0, end); }
+  s.last_at = new Date(now).toISOString(); s.tokened = true;
+  save(runtimeDir, id, s);
+}
+/** The live transcription cut this source up to `sample` (16 kHz). */
+function setCut(runtimeDir, id, { token, source, sample } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed || (token && s.token !== token) || !Number.isInteger(sample)) return;
+  s.cut = s.cut || {};
+  if (sample <= (s.cut[source] || 0)) return;
+  s.cut[source] = sample;
+  save(runtimeDir, id, s);
+}
+/** After a restart the live transcription lost what it had buffered: the stretch [from, to) of a source that was written but not
+ * transcribed, ending where the incoming chunk starts. null when there is none. */
+function untranscribed(runtimeDir, id, { source, before } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed) return null;
+  const base = Math.round((s.base_ms || 0) * 16);
+  const from = Math.max(base, (s.cut || {})[source] || 0);
+  const to = Math.min(before, (s.fed || {})[source] || 0);
+  return to > from ? { from, to } : null;
+}
+function tokened(runtimeDir, id, { now = Date.now() } = {}) { const s = load(runtimeDir, id); return isLive(s, now) && !!s.tokened; }
+function close(runtimeDir, id) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed) return;
+  s.closed = true;
+  save(runtimeDir, id, s);
+}
+function remove(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return;
+  const f = fileOf(runtimeDir, id);
+  cache.delete(f);
+  try { fs.unlinkSync(f); } catch { /* none */ }
+}
+
+module.exports = { start, busy, check, mark, setCut, untranscribed, close, tokened, remove, LIVE_MS };

package/workspace/lib/notes-live-guard.js

@@ -0,0 +1,117 @@
+'use strict';
+/* notes-live-guard.js — what the live transcript must not keep (notes-recording-reliability). Pure functions, no I/O.
+ *
+ *   stripEcho(mic, meetingLines) → the microphone line's text without the meeting's words, or '' when nothing of its own is left
+ *   repeats(text, previous) → true when a cut only says again what the line before it said
+ *   onceEach(text) → the text with a sentence repeated back to back kept once
+ *   looksForeign(text, reported) → true when a cut that should be English came back in another language
+ *
+ * ECHO. On speakers the remote voice also reaches the microphone, so the microphone's cut holds the meeting's words a second
+ * time. lib/notes-final.js drops such lines after Stop (dropEcho); this is the same rule, live: a run of ECHO_RUN or more words
+ * that a meeting line overlapping in time also holds (and that is at least half of that line) is taken out of the microphone line, and what is left is dropped when it
+ * still overlaps the meeting line by ECHO_OVERLAP of its length with ECHO_WORDS of its words the same (dropEcho's numbers).
+ * The PM's own words on the microphone stay.
+ *
+ * REPETITION. Whisper repeats itself, more so when the previous line is in its prompt (no longer passed). A cut whose words are
+ * the previous line's words, or end it, adds nothing. A short reply ("Yes.") said again later is kept: a short line counts
+ * as a repeat only within REPEAT_MS.
+ *
+ * LANGUAGE (decision 8 of the console3 feedback plan: accented English is always English). A cut is foreign when the engine
+ * says another language, when most of its letters are not Latin, or when most of its words are Indonesian function words.
+ */
+const ECHO_OVERLAP = 0.5;
+const ECHO_WORDS = 0.5;
+const ECHO_RUN = 4;
+const ECHO_SLACK_MS = 1500;
+const REPEAT_MS = 15000;
+
+const norm = (w) => String(w || '').toLowerCase().replace(/[^\p{L}\p{N}']/gu, '');
+const tokens = (text) => String(text || '').split(/\s+/).filter(Boolean);
+const wordsOf = (t) => new Set(String(t || '').toLowerCase().match(/[\p{L}\p{N}']{3,}/gu) || []);
+function sameWords(a, b) {
+  const x = wordsOf(a); const y = wordsOf(b);
+  if (!x.size || !y.size) return 0;
+  let both = 0; for (const w of x) if (y.has(w)) both++;
+  return both / Math.min(x.size, y.size);
+}
+/** The longest run of words the two token lists share, as { at, len } in `a`. */
+function longestRun(a, b) {
+  let best = { at: 0, len: 0 };
+  for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b.length; j++) {
+      let k = 0;
+      while (i + k < a.length && j + k < b.length && a[i + k] && a[i + k] === b[j + k]) k++;
+      if (k > best.len) best = { at: i, len: k };
+    }
+  }
+  return best;
+}
+const overlapMs = (a, b) => Math.min(a.end, b.end) - Math.max(a.t, b.t);
+
+/** `mic` and each meeting line: { t, end, text }. → the microphone text that is the PM's own. */
+function stripEcho(mic, meetingLines) {
+  const near = (meetingLines || []).filter((g) => overlapMs({ t: mic.t - ECHO_SLACK_MS, end: mic.end + ECHO_SLACK_MS }, g) > 0);
+  if (!near.length) return String(mic.text || '').trim();
+  let toks = tokens(mic.text);
+  for (const g of near) {
+    const theirs = tokens(g.text).map(norm);
+    const need = theirs.filter(Boolean).length * ECHO_WORDS;
+    // the runs of ECHO_RUN words or more this meeting line shares with the microphone line; they are echo together when they
+    // cover at least half of the meeting line: an echo repeats most of what the remote speaker said, a PM quoting a phrase does not.
+    // A microphone line that is wholly the meeting's words goes, however short.
+    let work = toks.slice(); const cuts = []; let covered = 0;
+    for (;;) {
+      const mine = work.map(norm);
+      const r = longestRun(mine, theirs);
+      const whole = r.len && r.len >= mine.filter(Boolean).length && !cuts.length;
+      if (!r.len || (!whole && r.len < ECHO_RUN)) break;
+      covered += r.len; cuts.push(r);
+      work = work.slice(0, r.at).concat(new Array(r.len).fill('')).concat(work.slice(r.at + r.len));
+      if (whole) { covered = Infinity; break; }
+    }
+    if (cuts.length && covered >= need) toks = work.filter(Boolean);
+    if (!toks.length) return '';
+  }
+  const left = toks.join(' ').replace(/^[\s,.;:!?…-]+/, '').trim();
+  if (!/[\p{L}\p{N}]/u.test(left)) return '';
+  const len = Math.max(1, mic.end - mic.t);
+  if (near.some((g) => overlapMs(mic, g) / len >= ECHO_OVERLAP && sameWords(left, g.text) >= ECHO_WORDS)) return '';
+  return left;
+}
+
+/** Does `text` only repeat `previous` ({ text, t }) of the same source? `t` is the new cut's time. */
+function repeats(text, previous, t = 0) {
+  if (!previous || !previous.text) return false;
+  const a = tokens(text).map(norm).filter(Boolean); const b = tokens(previous.text).map(norm).filter(Boolean);
+  if (!a.length || a.length > b.length) return false;
+  const tail = b.slice(b.length - a.length);
+  if (a.join(' ') !== tail.join(' ')) return false;
+  return a.length >= 3 || Math.abs(t - (previous.t || 0)) <= REPEAT_MS;
+}
+
+/** A sentence said twice or more back to back inside one cut is kept once. */
+function onceEach(text) {
+  const parts = String(text || '').match(/[^.!?…]+[.!?…]*\s*/g);
+  if (!parts || parts.length < 2) return String(text || '').trim();
+  const out = [];
+  for (const p of parts) { const k = tokens(p).map(norm).join(' '); if (out.length && k && k === tokens(out[out.length - 1]).map(norm).join(' ')) continue; out.push(p); }
+  return out.join('').trim();
+}
+
+const ID_WORDS = new Set(['yang', 'dan', 'di', 'ini', 'itu', 'tidak', 'dengan', 'untuk', 'ada', 'saya', 'kita', 'kami', 'akan', 'sudah', 'belum', 'juga',
+  'dari', 'ke', 'karena', 'jadi', 'bisa', 'apa', 'kalau', 'tapi', 'atau', 'nya', 'lagi', 'harus', 'sama', 'mau', 'gak', 'nggak', 'ya', 'kamu', 'mereka', 'dia', 'pada', 'dalam', 'seperti', 'lebih', 'masih', 'aja', 'saja']);
+/** Did a cut that should be English come back in another language? `reported` is the engine's language name, when it says one. */
+function looksForeign(text, reported) {
+  const t = String(text || '');
+  if (reported && !/^(en|english)$/i.test(String(reported).trim())) return true;
+  const letters = t.match(/\p{L}/gu) || [];
+  if (letters.length) {
+    const latin = letters.filter((c) => /\p{Script=Latin}/u.test(c)).length;
+    if (latin / letters.length < 0.7) return true;
+  }
+  const ws = (t.toLowerCase().match(/[a-z]+/g) || []);
+  if (ws.length >= 4 && ws.filter((w) => ID_WORDS.has(w)).length / ws.length >= 0.3) return true;
+  return false;
+}
+
+module.exports = { stripEcho, repeats, onceEach, looksForeign, sameWords, ECHO_OVERLAP, ECHO_WORDS, ECHO_RUN, REPEAT_MS };