create-pmos 0.113.0 → 0.115.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.113.0",
+  "version": "0.115.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@6d04787
+kernel-source: pmos@9fd15f4
 assembled: 2026-10-08
 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-08T05:19:33Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:01:13Z"}
 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-08T05:19:33Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:01:13Z"}
 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-08T05:19:33Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:01:13Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -28,7 +28,7 @@ The Notes view shows one meeting, top to bottom. A bar at the top shows whether
 4. Press **Stop** to end. The summary shows at the top of your notes. To carry on, press **Listen again**: the clock carries on from where it stopped, and the time between does not count. Line times and the kept audio use the same clock.
 5. If the workspace does not take a part of the audio, the page sends it again two times. If it still fails, a red message tells you how many seconds were not saved. Listening goes on. That part of the recording has a gap.
 
-To avoid an echo, listen to the meeting through headphones. When the meeting plays from a speaker, your microphone hears it a second time, and the replay has two copies of each voice.
+To avoid an echo, listen to the meeting through headphones. When the meeting plays from a speaker, your microphone hears it a second time. After **Stop**, the workspace removes most of that echo from the replay (see **Replay the meeting**).
 
 The meeting can only be heard when local transcription is set up. Until then, **Listen** hears your microphone only, through the browser's own recognition on this device.
 
@@ -130,8 +130,20 @@ When a meeting was heard with local transcription, its audio is kept on this mac
 2. While it plays, the transcript line, its item and the line of your notes that you wrote at that moment are highlighted. Your notes cannot be edited while it plays: pause to edit them.
 3. Press a time in the transcript to play from there.
 
+When you listened to both your microphone and the meeting, the workspace removes the meeting's echo from your microphone after you press **Stop**. A speaker plays the meeting, your microphone hears it a second time, and this second copy is the echo. The workspace uses the meeting's own recording as the guide. This takes a few minutes for each hour of meeting. It runs in the background, and the replay changes when it is done. Your own voice stays, because it is not in the meeting's recording. A part of the meeting where the clean-up would not help stays as it was recorded. The transcript does not change, because it is made from each source on its own. Headphones are still the best fix, because they stop the echo at its source.
+
 The replay is your microphone and the meeting added together. When both are loud at the same moment, the workspace lowers the peaks softly, so the sound does not distort. A quiet voice is not changed. The transcript is made from each source on its own, so this does not change what is written.
 
+### Clean up the replay sound
+
+The replay can play a cleaned copy of the sound. The copy has less rumble and hiss, and an even loudness. It needs **ffmpeg** on your machine. To install it, run `brew install ffmpeg` in a terminal.
+
+1. Open the settings. Select **Clean up the replay sound**. It is off until you select it. The setting is for this machine.
+2. After **Stop**, the workspace makes the cleaned copy when the echo is out of the replay. It makes the copy of a new note by itself.
+3. For a note you already have, open the note's settings and press **Clean up this note's sound**. The replay changes when the copy is ready.
+
+The workspace makes the copy from the replay only. It does not change the transcript. If ffmpeg is not on your machine, the replay plays as it is, and the settings say that ffmpeg was not found. When you clear the setting, the replay plays the plain sound again, and the cleaned copy stays on your machine until you delete the note's audio.
+
 To stop keeping audio, clear **Keep the audio for replay** in the settings. To delete one note's audio, press **Delete this note's audio** in the settings; the notes and the transcript stay. The browser's own recognition keeps no audio, so a meeting heard that way cannot be replayed.
 
 ## Capture highlights during the meeting
@@ -193,7 +205,7 @@ To take notes for a calendar event, open the event's detail on the Agenda and pr
 
 ## What stays on your machine
 
-- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes that file at once. For replay, the workspace keeps one recording of each note in `notes/recordings/` in the state folder, until you delete the audio, the note, or mark the note private. The browser's own recognition is used only on the device, never in the cloud.
+- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes that file at once. For replay, the workspace keeps one recording of each note in `notes/recordings/` in the state folder, with a cleaned copy beside it when you use **Clean up the replay sound**, until you delete the audio, the note, or mark the note private. The cleaned copy is made by ffmpeg on this machine, and nothing is sent anywhere. The browser's own recognition is used only on the device, never in the cloud.
 - Notes are files in the workspace's own folder on this machine (`notes/` in the state folder). They are never written into a repository.
 - Only Jev, with the switches on, and your agent session (the final notes, **Summary by agent**, and the Wispr Flow search) receive any text from a note. The Wispr Flow search receives the meeting's time and title only.
 - The final pass runs Qwen3-ASR, Parakeet, Whisper and the speaker models on this machine, from temporary files that it deletes when it is done.

package/workspace/lib/notes-audio.js

@@ -33,22 +33,32 @@ const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
 const dirOf = (runtimeDir) => path.join(runtimeDir, 'notes', 'recordings');
 const fileOf = (runtimeDir, id) => path.join(dirOf(runtimeDir), id + '.pcm');
 const SOURCES = ['mic', 'meeting'];
+const cleanFileOf = (runtimeDir, id) => path.join(dirOf(runtimeDir), id + '.clean.pcm');
 const sourceFileOf = (runtimeDir, id, source) => path.join(dirOf(runtimeDir), id + '.' + source + '.pcm');
 const settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'audio-settings.json');
 const next = new Map();                     // `${file}|${source}` → the byte offset where that source's last chunk ended
 
-function getKeep(runtimeDir) {
-  try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s.keep !== false; } catch { return true; }
-}
-function setKeep(runtimeDir, keep) {
-  if (typeof keep !== 'boolean') return { ok: false, error: 'say keep: true or keep: false' };
+function readSettings(runtimeDir) { try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s && typeof s === 'object' ? s : {}; } catch { return {}; } }
+function writeSettings(runtimeDir, patch) {
   const f = settingsFile(runtimeDir);
   fs.mkdirSync(path.dirname(f), { recursive: true });
   const tmp = f + '.' + process.pid + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify({ keep }), { mode: 0o600 });
+  fs.writeFileSync(tmp, JSON.stringify({ ...readSettings(runtimeDir), ...patch }), { mode: 0o600 });
   fs.renameSync(tmp, f);
+}
+function getKeep(runtimeDir) { return readSettings(runtimeDir).keep !== false; }
+function setKeep(runtimeDir, keep) {
+  if (typeof keep !== 'boolean') return { ok: false, error: 'say keep: true or keep: false' };
+  writeSettings(runtimeDir, { keep });
   return { ok: true, keep };
 }
+/** "Clean up the replay sound" (notes-audio-quality Run 3): off until the PM turns it on, for this machine. */
+function getClean(runtimeDir) { return readSettings(runtimeDir).clean === true; }
+function setClean(runtimeDir, clean) {
+  if (typeof clean !== 'boolean') return { ok: false, error: 'say clean: true or clean: false' };
+  writeSettings(runtimeDir, { clean });
+  return { ok: true, clean };
+}
 
 // The mixed file passes every sample through this soft knee (notes-audio-quality R1, R2). Below KNEE the sample is unchanged, so one
 // source alone is not made quieter. Above it the sample bends towards CEILING and never reaches full scale, so two loud sources
@@ -107,6 +117,7 @@ function remove(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return false;
   for (const k of [...next.keys()]) if (k.startsWith(fileOf(runtimeDir, id) + '|')) next.delete(k);
   for (const src of SOURCES) { try { fs.unlinkSync(sourceFileOf(runtimeDir, id, src)); } catch { /* none */ } }
+  for (const extra of ['.echo.json', '.pcm.echo.tmp', '.clean.pcm', '.clean.pcm.tmp']) { try { fs.unlinkSync(path.join(dirOf(runtimeDir), id + extra)); } catch { /* none */ } }
   try { fs.unlinkSync(fileOf(runtimeDir, id)); return true; } catch { return false; }
 }
 /** The note's audio, one file per source: [{ source, file, bytes, ms }], the sources that were heard. */
@@ -120,6 +131,22 @@ function sources(runtimeDir, id) {
   return out;
 }
 
+/** The file the replay plays: the cleaned copy when the PM switched cleaning on and the copy is as long as the mix (a copy made
+ * before listening went on is shorter, so it is stale and the plain mix plays); otherwise the mix. { file, bytes, cleaned } | null. */
+function replayOf(runtimeDir, id) {
+  const inf = info(runtimeDir, id);
+  if (!inf) return null;
+  if (getClean(runtimeDir)) {
+    try { const st = fs.statSync(cleanFileOf(runtimeDir, id)); if (st.size === inf.bytes) return { file: cleanFileOf(runtimeDir, id), bytes: st.size, cleaned: true }; } catch { /* none */ }
+  }
+  return { file: fileOf(runtimeDir, id), bytes: inf.bytes, cleaned: false };
+}
+/** True when a cleaned copy exists and is as long as the mix. */
+function hasClean(runtimeDir, id) {
+  const inf = info(runtimeDir, id);
+  try { return !!inf && fs.statSync(cleanFileOf(runtimeDir, id)).size === inf.bytes; } catch { return false; }
+}
+
 function wavHeader(dataBytes) {
   const h = Buffer.alloc(44);
   h.write('RIFF', 0); h.writeUInt32LE(36 + dataBytes, 4); h.write('WAVE', 8);
@@ -130,7 +157,7 @@ function wavHeader(dataBytes) {
 }
 /** The audio as audio/wav. A `Range: bytes=a-b` request gets 206 with that part, which is how the page seeks. */
 function serve(req, res, runtimeDir, id) {
-  const inf = info(runtimeDir, id);
+  const inf = replayOf(runtimeDir, id);
   if (!inf) { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: 'this note has no audio' })); return; }
   const header = wavHeader(inf.bytes);
   const total = header.length + inf.bytes;
@@ -148,7 +175,7 @@ function serve(req, res, runtimeDir, id) {
   if (start < header.length) res.write(header.subarray(start, Math.min(header.length, end + 1)));
   const from = Math.max(0, start - header.length); const to = end - header.length;
   if (to < from) { res.end(); return; }
-  fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
+  fs.createReadStream(inf.file, { start: from, end: to }).on('error', () => res.end()).pipe(res);
 }
 
-module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, softLimit, RATE, BYTES_PER_MS, MAX_BYTES };
+module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, getClean, setClean, hasClean, replayOf, wavHeader, softLimit, replayFile: fileOf, cleanFile: cleanFileOf, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/lib/notes-echo-worker.js

@@ -0,0 +1,6 @@
+'use strict';
+/* notes-echo-worker.js — runs notes-echo.cleanReplay on a worker thread (notes-audio-quality Run 2) and posts its result. */
+const { parentPort, workerData } = require('worker_threads');
+const echo = require('./notes-echo');
+
+parentPort.postMessage(echo.cleanReplay(workerData.runtimeDir, workerData.id));

package/workspace/lib/notes-echo.js

@@ -0,0 +1,341 @@
+'use strict';
+/* notes-echo.js — take the meeting's echo out of the microphone in a note's replay (notes-audio-quality Run 2). Local only.
+ *
+ *   cleanStream({ n, readFar, readMic, onChunk })   the canceller, over any two tracks of n samples → a report
+ *   cleanReplay(runtimeDir, id)                      rebuild the note's replay file from its two source files → { ok, ... }
+ *   cleanReplayInWorker(runtimeDir, id)              the same, on a worker thread, so the server stays awake → Promise
+ *   report(runtimeDir, id)                           what the last clean-up did, or null
+ *
+ * THE PROBLEM. The microphone hears the meeting through the speakers, so each voice is recorded twice, the second copy late.
+ * lib/notes-audio.js keeps the meeting on its own (<id>.meeting.pcm), which is exactly the signal that leaked into the microphone.
+ *
+ * THE METHOD. For a window of 30 s, find the echo path from the meeting to the microphone by least squares: the cross-correlation
+ * of the two tracks (summed over the whole window, so no frame edge biases it) gives a Toeplitz system, solved by conjugate
+ * gradient with FFTs alone. Your own voice is not correlated with the meeting, so it averages out of the fit and survives. The
+ * predicted echo is subtracted from the microphone. The path is 512 ms long, so a delay of up to about 300 ms and a room tail fit.
+ *
+ * THE TWO GUARDS (R7b). (1) A window whose parts disagree — some kept little of their energy, some a lot, because the path changed,
+ * for example the volume went down — is cut in two and each half is fitted again, down to about 7 s. (2) In every 10 s stretch,
+ * on the frames where the meeting speaks, the result must keep less than 70% of the microphone's energy (1.5 dB gained). If it
+ * does not, that stretch keeps the microphone as it was. The clean-up can lose a little echo; it cannot make a stretch louder.
+ *
+ * WHAT IT NEVER TOUCHES. The two source files (what the transcription reads) are only read. Only the mixed replay file is
+ * rewritten, through a temporary file and a rename, and only if the sources did not grow while it ran. It opens no network module.
+ */
+const fs = require('fs');
+const path = require('path');
+const { Worker } = require('worker_threads');
+const notesAudio = require('./notes-audio');
+
+const FS = notesAudio.RATE;          // 16000
+const L = 8192;                      // the echo path kept: 512 ms
+const FB = 32768;                    // FFT size for the correlations and the prediction
+const BLK = FB - L;
+const FRAME = 320;                   // 20 ms
+const ACTIVE = 1e-5;                 // mean square (full scale = 1) above which the meeting is speaking: -50 dB
+const WINDOW = 30 * FS;
+const MIN_PIECE = 6 * FS;
+const CHECK = 10 * FS;               // the stretch R7b is held over
+const PART = Math.round(2.5 * FS);   // the part of a window looked at for a bad fit
+const MARGIN = 2000;                 // samples of data either side of a window the fit may also use
+const SPLIT_RATIO = 0.35;            // a part that kept more than this share of its energy is a bad fit …
+const SPLIT_SPREAD = 0.25;           // … when another part of the window kept this much less: the parts disagree, so the path changed
+const KEEP_RATIO = 0.7;              // a stretch must keep less than this share (1.5 dB gained), or it is left as it was
+const MIN_ACTIVE_FRAMES = 25;        // half a second of meeting speech before a part is judged
+const ITERATIONS = 150;
+const LOADING = 1e-3;
+const RAMP = 800;                    // samples over which subtraction fades in or out between stretches
+const TIMEOUT_MS = 30 * 60 * 1000;
+
+/* ── FFT ──────────────────────────────────────────────────────────────────────────────────────── */
+const twiddles = new Map();
+function table(n) {
+  let t = twiddles.get(n);
+  if (!t) {
+    t = { cos: new Float64Array(n / 2), sin: new Float64Array(n / 2) };
+    for (let i = 0; i < n / 2; i++) { t.cos[i] = Math.cos(2 * Math.PI * i / n); t.sin[i] = Math.sin(2 * Math.PI * i / n); }
+    twiddles.set(n, t);
+  }
+  return t;
+}
+/** In-place radix-2 FFT of (re, im). `inv` runs the inverse and divides by n. */
+function fft(re, im, inv) {
+  const n = re.length; const t = table(n);
+  for (let i = 1, j = 0; i < n; i++) {
+    let bit = n >> 1;
+    for (; j & bit; bit >>= 1) j ^= bit;
+    j ^= bit;
+    if (i < j) { const a = re[i]; re[i] = re[j]; re[j] = a; const b = im[i]; im[i] = im[j]; im[j] = b; }
+  }
+  for (let len = 2; len <= n; len <<= 1) {
+    const step = n / len; const half = len >> 1;
+    for (let i = 0; i < n; i += len) {
+      for (let k = 0; k < half; k++) {
+        const wr = t.cos[k * step]; const wi = inv ? t.sin[k * step] : -t.sin[k * step];
+        const a = i + k; const b = a + half;
+        const tr = re[b] * wr - im[b] * wi; const ti = re[b] * wi + im[b] * wr;
+        re[b] = re[a] - tr; im[b] = im[a] - ti; re[a] += tr; im[a] += ti;
+      }
+    }
+  }
+  if (inv) for (let i = 0; i < n; i++) { re[i] /= n; im[i] /= n; }
+}
+
+/* ── the fit ──────────────────────────────────────────────────────────────────────────────────── */
+/** r[t] = sum x[u] x[u-t] and c[t] = sum m[u] x[u-t], for t < L and u in [from, to). Samples before 0 count as silence. */
+function correlations(x, m, from, to) {
+  const r = new Float64Array(L); const c = new Float64Array(L);
+  const xb = new Float64Array(FB), xi = new Float64Array(FB), cur = new Float64Array(FB), ci = new Float64Array(FB), mc = new Float64Array(FB), mi = new Float64Array(FB);
+  const ar = new Float64Array(FB), ai = new Float64Array(FB), br = new Float64Array(FB), bi = new Float64Array(FB);
+  for (let s = from; s < to; s += BLK) {
+    const len = Math.min(BLK, to - s);
+    xb.fill(0); xi.fill(0); cur.fill(0); ci.fill(0); mc.fill(0); mi.fill(0);
+    let e = 0;
+    for (let j = 0; j < L + len; j++) { const t = s - L + j; if (t >= 0 && t < x.length) xb[j] = x[t]; }
+    for (let j = 0; j < len; j++) { cur[L + j] = x[s + j]; mc[L + j] = m[s + j]; e += x[s + j] * x[s + j]; }
+    if (e / len < 1e-8) continue;                                  // the meeting is silent here: nothing to learn
+    fft(xb, xi, false); fft(cur, ci, false); fft(mc, mi, false);
+    for (let k = 0; k < FB; k++) {                                 // CUR * conj(XB) and MC * conj(XB)
+      ar[k] = cur[k] * xb[k] + ci[k] * xi[k]; ai[k] = ci[k] * xb[k] - cur[k] * xi[k];
+      br[k] = mc[k] * xb[k] + mi[k] * xi[k]; bi[k] = mi[k] * xb[k] - mc[k] * xi[k];
+    }
+    fft(ar, ai, true); fft(br, bi, true);
+    for (let t = 0; t < L; t++) { r[t] += ar[t]; c[t] += br[t]; }
+  }
+  return { r, c };
+}
+/** R v for the symmetric Toeplitz matrix R whose first column is held, as the FFT of its circulant embedding. */
+function toeplitzMul(col, v) {
+  const n = 2 * L; const re = new Float64Array(n); const im = new Float64Array(n);
+  re.set(v); fft(re, im, false);
+  for (let k = 0; k < n; k++) { const a = re[k] * col.re[k] - im[k] * col.im[k]; im[k] = re[k] * col.im[k] + im[k] * col.re[k]; re[k] = a; }
+  fft(re, im, true);
+  return re.subarray(0, L);
+}
+/** The impulse response from the meeting to the microphone over [from, to), or null when the meeting said nothing. */
+function estimatePath(x, m, from, to) {
+  const { r, c } = correlations(x, m, from, to);
+  if (!(r[0] > 0)) return null;
+  const n = 2 * L; const re = new Float64Array(n); const im = new Float64Array(n);
+  for (let t = 0; t < L; t++) re[t] = r[t];
+  for (let t = 1; t < L; t++) re[n - t] = r[t];
+  fft(re, im, false);
+  const col = { re, im };
+  const lam = LOADING * r[0];
+  const h = new Float64Array(L); const res = Float64Array.from(c); const p = Float64Array.from(res);
+  let rs = 0; for (let i = 0; i < L; i++) rs += res[i] * res[i];
+  const rs0 = rs;
+  for (let it = 0; it < ITERATIONS && rs > 1e-10 * rs0; it++) {
+    const Ap = toeplitzMul(col, p); let pAp = 0;
+    for (let i = 0; i < L; i++) { Ap[i] += lam * p[i]; pAp += p[i] * Ap[i]; }
+    if (!(pAp > 0)) break;
+    const alpha = rs / pAp; let rn = 0;
+    for (let i = 0; i < L; i++) { h[i] += alpha * p[i]; res[i] -= alpha * Ap[i]; rn += res[i] * res[i]; }
+    const beta = rn / rs; rs = rn;
+    for (let i = 0; i < L; i++) p[i] = res[i] + beta * p[i];
+  }
+  return { h };
+}
+/** The first tap that reaches a quarter of the biggest: when the meeting's sound first arrives at the microphone. */
+function arrival(h) {
+  let mx = 0; for (let i = 0; i < h.length; i++) mx = Math.max(mx, Math.abs(h[i]));
+  for (let i = 0; i < h.length; i++) if (Math.abs(h[i]) >= 0.25 * mx) return i;
+  return 0;
+}
+/** The echo that h predicts at samples [from, to): conv(x, h) by overlap-save. */
+function predict(x, h, from, to) {
+  const out = new Float64Array(to - from);
+  const Hr = new Float64Array(FB); const Hi = new Float64Array(FB);
+  Hr.set(h); fft(Hr, Hi, false);
+  const re = new Float64Array(FB); const im = new Float64Array(FB);
+  for (let s = from; s < to; s += BLK) {
+    const len = Math.min(BLK, to - s);
+    re.fill(0); im.fill(0);
+    for (let j = 0; j < L + len; j++) { const t = s - L + j; if (t >= 0 && t < x.length) re[j] = x[t]; }
+    fft(re, im, false);
+    for (let k = 0; k < FB; k++) { const a = re[k] * Hr[k] - im[k] * Hi[k]; im[k] = re[k] * Hi[k] + im[k] * Hr[k]; re[k] = a; }
+    fft(re, im, true);
+    for (let j = 0; j < len; j++) out[s - from + j] = re[L + j];
+  }
+  return out;
+}
+
+/* ── where the meeting speaks, and what a stretch kept ───────────────────────────────────────── */
+/** Energy of mic and of out over the 20 ms frames of [a, b) in which the meeting speaks: { eIn, eOut, frames }. */
+function kept(far, mic, out, a, b, base) {
+  let eIn = 0; let eOut = 0; let frames = 0;
+  for (let f = a; f + FRAME <= b; f += FRAME) {
+    let ex = 0;
+    for (let i = 0; i < FRAME; i++) ex += far[f + i] * far[f + i];
+    if (ex / FRAME <= ACTIVE) continue;
+    frames++;
+    for (let i = 0; i < FRAME; i++) { eIn += mic[f + i] * mic[f + i]; eOut += out[f - base + i] * out[f - base + i]; }
+  }
+  return { eIn, eOut, frames };
+}
+const speaks = (far, a, b) => { let n = 0; for (let f = a; f + FRAME <= b; f += FRAME) { let ex = 0; for (let i = 0; i < FRAME; i++) ex += far[f + i] * far[f + i]; if (ex / FRAME > ACTIVE) n++; } return n; };
+
+/** Smooth a 0/1 gain so subtraction fades over RAMP samples instead of switching. */
+function smooth(gain) {
+  const n = gain.length; const out = new Float64Array(n); const w = 2 * RAMP + 1;
+  let acc = 0;
+  for (let i = -RAMP; i <= RAMP; i++) acc += gain[Math.min(n - 1, Math.max(0, i))];
+  for (let i = 0; i < n; i++) {
+    out[i] = acc / w;
+    acc += gain[Math.min(n - 1, i + RAMP + 1)] - gain[Math.max(0, i - RAMP)];
+  }
+  return out;
+}
+
+/** The microphone over [from, to) with the echo of `far` taken out. far and mic are Float64 arrays of one span, full scale = 1.
+ * state collects { leaves: [{ delay }], skipped, eIn, eOut }. */
+function cleanSpan(far, mic, from, to, state) {
+  const len = to - from;
+  const plain = () => Float64Array.from(mic.subarray(from, to));
+  if (speaks(far, from, to) < MIN_ACTIVE_FRAMES) return plain();
+  const p = estimatePath(far, mic, Math.max(0, from - MARGIN), Math.min(far.length, to + MARGIN));
+  if (!p) return plain();
+  const echo = predict(far, p.h, from, to);
+  const trial = new Float64Array(len);
+  for (let i = 0; i < len; i++) trial[i] = mic[from + i] - echo[i];
+  // guard 1: parts of one window that disagree — some kept little of their energy, some kept a lot — mean the path changed
+  // inside it: cut the window in two. Parts that all keep about the same (no echo at all, or one steady poor fit) do not.
+  if (len >= 2 * MIN_PIECE) {
+    let lo = Infinity; let hi = -Infinity;
+    for (let q = from; q < to; q += PART) {
+      const k = kept(far, mic, trial, q, Math.min(to, q + PART), from);
+      if (k.frames < MIN_ACTIVE_FRAMES || !(k.eIn > 0)) continue;
+      const r = k.eOut / k.eIn; lo = Math.min(lo, r); hi = Math.max(hi, r);
+    }
+    if (hi > SPLIT_RATIO && hi - lo > SPLIT_SPREAD) {
+      const mid = from + Math.floor(len / 2 / FRAME) * FRAME;
+      const left = cleanSpan(far, mic, from, mid, state); const right = cleanSpan(far, mic, mid, to, state);
+      const joined = new Float64Array(len); joined.set(left, 0); joined.set(right, mid - from);
+      return joined;
+    }
+  }
+  // guard 2 (R7b): in every 10 s stretch the result keeps less energy than the microphone, or the stretch is left as it was
+  const gain = new Float64Array(len).fill(1);
+  const chunks = [];
+  for (let q = from; q < to; q += CHECK) chunks.push([q, Math.min(to, q + CHECK)]);
+  let off = false;
+  for (const [a, b] of chunks) {
+    const k = kept(far, mic, trial, a, b, from);
+    if (k.frames && k.eOut > KEEP_RATIO * k.eIn) { gain.fill(0, a - from, b - from); off = true; state.skipped++; }
+  }
+  const g = off ? smooth(gain) : gain;
+  const out = new Float64Array(len);
+  for (let i = 0; i < len; i++) out[i] = mic[from + i] - g[i] * echo[i];
+  if (off) {   // the ramps can let a little echo back in at an edge: a stretch that still got louder is cut hard
+    for (const [a, b] of chunks) {
+      const k = kept(far, mic, out, a, b, from);
+      if (k.frames && k.eOut > k.eIn) for (let i = a - from; i < b - from; i++) out[i] = mic[from + i];
+    }
+  }
+  for (const [a, b] of chunks) { const k = kept(far, mic, out, a, b, from); state.eIn += k.eIn; state.eOut += k.eOut; }
+  state.leaves.push({ delay: arrival(p.h) });
+  return out;
+}
+
+/** The canceller over two tracks of n samples. readFar(from, count) and readMic(from, count) give Float64Array of that many
+ * samples (full scale = 1; zeros past the end); onChunk(at, Float64Array) receives each cleaned stretch in order. Returns
+ * { windows, skipped, reduction_db, delay_ms }. */
+function cleanStream({ n, readFar, readMic, onChunk }) {
+  const state = { leaves: [], skipped: 0, eIn: 0, eOut: 0 };
+  let windows = 0;
+  for (let a = 0; a < n; a += WINDOW) {
+    const b = Math.min(n, a + WINDOW);
+    const c0 = Math.max(0, Math.floor((a - (L + MARGIN)) / FRAME) * FRAME); const c1 = Math.min(n, b + MARGIN);
+    const far = readFar(c0, c1 - c0); const mic = readMic(c0, c1 - c0);
+    onChunk(a, cleanSpan(far, mic, a - c0, b - c0, state), b - a);
+    windows++;
+  }
+  const delays = state.leaves.map((l) => l.delay).sort((x, y) => x - y);
+  return {
+    windows, fits: state.leaves.length, skipped: state.skipped,
+    reduction_db: state.eOut > 0 && state.eIn > 0 ? Math.round(10 * Math.log10(state.eIn / state.eOut) * 10) / 10 : 0,
+    delay_ms: delays.length ? Math.round(delays[delays.length >> 1] * 1000 / FS) : null,
+  };
+}
+
+/* ── the replay file ──────────────────────────────────────────────────────────────────────────── */
+const reportFile = (runtimeDir, id) => notesAudio.replayFile(runtimeDir, id).replace(/\.pcm$/, '.echo.json');
+function report(runtimeDir, id) { try { return JSON.parse(fs.readFileSync(reportFile(runtimeDir, id), 'utf8')); } catch { return null; } }
+
+function readSamples(fd, size, from, count) {
+  const out = new Float64Array(count);
+  if (fd === null) return out;
+  const bytes = Math.max(0, Math.min(count * 2, size - from * 2));
+  if (bytes <= 0) return out;
+  const buf = Buffer.alloc(bytes);
+  fs.readSync(fd, buf, 0, bytes, from * 2);
+  for (let i = 0; i < bytes / 2; i++) out[i] = buf.readInt16LE(i * 2) / 32768;
+  return out;
+}
+
+/** Rebuild the replay file of a note from its two source files, with the echo taken out of the microphone. Only when the note
+ * kept its audio and heard both sources. The replay is replaced by a rename, and only if the sources did not grow meanwhile.
+ * `beforeCommit` is called just before that check; it is for the suites. */
+function cleanReplay(runtimeDir, id, { beforeCommit } = {}) {
+  const began = Date.now();
+  if (!notesAudio.getKeep(runtimeDir)) return { ok: true, skipped: 'the audio is not kept for replay' };
+  const srcs = notesAudio.sources(runtimeDir, id);
+  const mic = srcs.find((s) => s.source === 'mic'); const meet = srcs.find((s) => s.source === 'meeting');
+  if (!mic || !meet) return { ok: true, skipped: 'only one source was heard, so there is no echo to take out' };
+  if (!notesAudio.info(runtimeDir, id)) return { ok: true, skipped: 'the note has no replay file' };
+  const out = notesAudio.replayFile(runtimeDir, id); const tmp = out + '.echo.tmp';
+  let fdM = null; let fdX = null; let fdO = null;
+  try {
+    fdM = fs.openSync(mic.file, 'r'); fdX = fs.openSync(meet.file, 'r'); fdO = fs.openSync(tmp, 'w', 0o600);
+    const n = Math.floor(Math.max(mic.bytes, meet.bytes) / 2);
+    const rep = cleanStream({
+      n,
+      readFar: (from, count) => readSamples(fdX, meet.bytes, from, count),
+      readMic: (from, count) => readSamples(fdM, mic.bytes, from, count),
+      onChunk: (at, cleaned, count) => {
+        const m = readSamples(fdX, meet.bytes, at, count);
+        const buf = Buffer.alloc(count * 2);
+        for (let i = 0; i < count; i++) {
+          const a = Math.max(-32768, Math.min(32767, Math.round(cleaned[i] * 32768)));
+          buf.writeInt16LE(notesAudio.softLimit(a + Math.round(m[i] * 32768)), i * 2);
+        }
+        fs.writeSync(fdO, buf, 0, buf.length, at * 2);
+      },
+    });
+    fs.closeSync(fdO); fdO = null;
+    if (beforeCommit) beforeCommit();          // the suites use this to make listening go on at the last moment
+    // the sources must be as they were: if listening went on meanwhile, the plain replay is the truth and this one is dropped
+    const now = notesAudio.sources(runtimeDir, id);
+    const same = now.length === srcs.length && now.every((s) => { const o = srcs.find((x) => x.source === s.source); return o && o.bytes === s.bytes; });
+    if (!same) { try { fs.unlinkSync(tmp); } catch { /* gone */ } return { ok: false, error: 'listening went on while the echo was taken out' }; }
+    fs.renameSync(tmp, out);
+    const result = { ok: true, at: new Date().toISOString(), ...rep, took_ms: Date.now() - began };
+    fs.writeFileSync(reportFile(runtimeDir, id), JSON.stringify(result), { mode: 0o600 });
+    return result;
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* none */ }
+    return { ok: false, error: String((e && e.message) || e).slice(0, 300) };
+  } finally {
+    for (const fd of [fdM, fdX, fdO]) if (fd !== null) { try { fs.closeSync(fd); } catch { /* closed */ } }
+  }
+}
+
+const running = new Map();     // `${dir}|${id}` → the promise of a clean-up that is under way
+/** cleanReplay on a worker thread. A second call for the same note while one runs gets the same promise. Never rejects. */
+function cleanReplayInWorker(runtimeDir, id) {
+  const key = runtimeDir + '|' + id;
+  if (running.has(key)) return running.get(key);
+  const p = new Promise((resolve) => {
+    let done = false;
+    const w = new Worker(path.join(__dirname, 'notes-echo-worker.js'), { workerData: { runtimeDir, id } });
+    const finish = (r) => { if (done) return; done = true; clearTimeout(timer); resolve(r); };
+    const timer = setTimeout(() => { w.terminate(); try { fs.unlinkSync(notesAudio.replayFile(runtimeDir, id) + '.echo.tmp'); } catch { /* none */ } finish({ ok: false, error: 'it took too long' }); }, TIMEOUT_MS);
+    w.once('message', finish);
+    w.once('error', (e) => finish({ ok: false, error: String((e && e.message) || e).slice(0, 300) }));
+    w.once('exit', () => finish({ ok: false, error: 'the worker ended without a result' }));
+  }).finally(() => running.delete(key));
+  running.set(key, p);
+  return p;
+}
+
+module.exports = { cleanStream, cleanReplay, cleanReplayInWorker, report, reportFile, fft, WINDOW, FS };

package/workspace/lib/notes-polish.js

@@ -0,0 +1,76 @@
+'use strict';
+/* notes-polish.js — an optional cleaned copy of a note's replay (notes-audio-quality Run 3). Local only.
+ *
+ *   detect({ env? }) → { bin } | null      the ffmpeg the PM installed
+ *   build(runtimeDir, id, { run?, bin?, force? }) → Promise<{ ok, ... }>   make <id>.clean.pcm from the replay mix
+ *                                           (`bin: null` means no ffmpeg; leave bin out to look for one)
+ *
+ * WHAT IT DOES. When the PM turned "Clean up the replay sound" on and has ffmpeg, the server runs ffmpeg on the note's replay mix:
+ * a high-pass filter at 80 Hz (rumble and desk thumps), light noise reduction, and loudness normalization to -16 LUFS with
+ * a true peak of -1.5 dB. The result is a second file next to the mix. The replay plays it while the setting is on and the copy is
+ * as long as the mix; with the setting off, or with no copy, it plays the plain mix.
+ *
+ * WHAT IT NEVER DOES. It reads only the replay mix, never the two source files, so the transcription input is not touched. It runs
+ * a program the PM installed (as whisper-cli is run), downloads nothing, installs nothing, and opens no network module. With ffmpeg
+ * missing it does nothing and says so. The copy is deleted with the note's audio.
+ */
+const fs = require('fs');
+const path = require('path');
+const notesAudio = require('./notes-audio');
+const { runProgram } = require('./notes-final');
+
+const RATE = notesAudio.RATE;
+const FILTER = 'highpass=f=80,afftdn=nr=10:nf=-45,loudnorm=I=-16:TP=-1.5:LRA=11';
+const TIMEOUT_MS = 20 * 60 * 1000;
+const LENGTH_SLACK = 0.02;          // the copy may differ from the mix by this share of its length, no more
+
+const isExec = (p) => { try { fs.accessSync(p, fs.constants.X_OK); return fs.statSync(p).isFile(); } catch { return false; } };
+
+/** The ffmpeg on this machine: PMOS_NOTES_FFMPEG_BIN, else the PATH, else where Homebrew puts it. */
+function detect({ env = process.env, fallbacks = ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin'] } = {}) {
+  const named = env.PMOS_NOTES_FFMPEG_BIN;
+  if (named) return isExec(named) ? { bin: named } : null;
+  const dirs = String(env.PATH || '').split(path.delimiter).concat(fallbacks);
+  for (const d of dirs) { if (!d) continue; const f = path.join(d, 'ffmpeg'); if (isExec(f)) return { bin: f }; }
+  return null;
+}
+
+const running = new Map();
+/** Make the cleaned copy of a note's replay. Resolves with { ok: true, ... } or { ok: false, error } or { ok: true, skipped }. Never rejects. */
+function build(runtimeDir, id, opts = {}) {
+  const { run = runProgram, force = false } = opts;
+  const key = runtimeDir + '|' + id;
+  if (running.has(key)) return running.get(key);
+  const p = (async () => {
+    if (!force && !notesAudio.getClean(runtimeDir)) return { ok: true, skipped: 'cleaning the replay sound is off' };
+    const found = 'bin' in opts ? (opts.bin ? { bin: opts.bin } : null) : detect();
+    if (!found) return { ok: true, skipped: 'ffmpeg was not found on this machine' };
+    const inf = notesAudio.info(runtimeDir, id);
+    if (!inf) return { ok: true, skipped: 'the note has no replay file' };
+    const input = notesAudio.replayFile(runtimeDir, id); const out = notesAudio.cleanFile(runtimeDir, id); const tmp = out + '.tmp';
+    const began = Date.now();
+    try {
+      const r = await run(found.bin, ['-nostdin', '-hide_banner', '-loglevel', 'error', '-y', '-f', 's16le', '-ar', String(RATE), '-ac', '1', '-i', input,
+        '-af', FILTER, '-f', 's16le', '-ar', String(RATE), '-ac', '1', tmp], { timeout: TIMEOUT_MS });
+      if (!r.ok) { try { fs.unlinkSync(tmp); } catch { /* none */ } return { ok: false, error: r.error || 'ffmpeg failed' }; }
+      const size = fs.statSync(tmp).size;
+      const now = notesAudio.info(runtimeDir, id);
+      if (!now || now.bytes !== inf.bytes) { fs.unlinkSync(tmp); return { ok: false, error: 'listening went on while the sound was cleaned up' }; }
+      if (Math.abs(size - inf.bytes) > LENGTH_SLACK * inf.bytes) { fs.unlinkSync(tmp); return { ok: false, error: 'the cleaned copy came out a different length' }; }
+      // the copy has the mix's length to the byte, so the replay can seek in it with the same times
+      if (size !== inf.bytes) {
+        const fd = fs.openSync(tmp, 'r+');
+        try { if (size > inf.bytes) fs.ftruncateSync(fd, inf.bytes); else fs.writeSync(fd, Buffer.alloc(inf.bytes - size), 0, inf.bytes - size, size); } finally { fs.closeSync(fd); }
+      }
+      fs.renameSync(tmp, out);
+      return { ok: true, bytes: inf.bytes, took_ms: Date.now() - began };
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch { /* none */ }
+      return { ok: false, error: String((e && e.message) || e).slice(0, 300) };
+    }
+  })().finally(() => running.delete(key));
+  running.set(key, p);
+  return p;
+}
+
+module.exports = { detect, build, FILTER };

package/workspace/lib/routes-notes.js

@@ -25,6 +25,7 @@
  *   POST /api/notes/line       { id, index, cat?, summary?, tags?, people?, text? } → { ok, segment, summary }   the PM's correction (Run 3)
  *   GET  /api/notes/recording?id=…          → audio/wav, with byte ranges    the note's kept audio (Run 3, D92)
  *   POST /api/notes/recording-delete { id } → { ok }    deletes the note's audio and keeps the rest
+ *   POST /api/notes/clean-audio { id }      → { ok, started }    makes the cleaned copy of the replay now (Run 3 of notes-audio-quality; needs ffmpeg)
  *   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?, accuracy?, keep_audio? } → { ok, whisper } the language, the model, the decoding
@@ -66,6 +67,8 @@ const notes = require('./notes.js');
 const whisper = require('./notes-whisper.js');
 const notesRepo = require('./notes-repo.js');
 const notesAudio = require('./notes-audio.js');
+const notesEcho = require('./notes-echo.js');
+const notesPolish = require('./notes-polish.js');
 const notesFinal = require('./notes-final.js');
 const notesQwen = require('./notes-qwen.js');
 const notesLinks = require('./notes-links.js');
@@ -81,7 +84,7 @@ const VOCAB_TTL_MS = 60 * 1000;
 const prefixes = ['/api/notes'];
 const POSTS = new Set(['/api/notes/new', '/api/notes/save', '/api/notes/dictate', '/api/notes/record', '/api/notes/transcript',
   '/api/notes/private', '/api/notes/pause', '/api/notes/summarize', '/api/notes/summarize-agent', '/api/notes/delete', '/api/notes/audio', '/api/notes/label',
-  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch']);
+  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/clean-audio', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
 const chains = new Map();      // note id → the promise of its work so far (minute batches, imports, labels, checks)
@@ -354,7 +357,7 @@ function engineInfo(ctx, w) {
   const out = { ready: live.ready, live: live.ready ? live.engine : null, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size,
     language: whisper.getLanguage(ctx.runtimeDir), languages: whisper.LANGUAGES.map(([value, label]) => ({ value, label })),
     model: whisper.getModel(ctx.runtimeDir), models: whisper.MODELS.map((m) => ({ value: m.id, label: m.label })),
-    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir),
+    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir), clean_audio: notesAudio.getClean(ctx.runtimeDir), ffmpeg: !!notesPolish.detect(),
     final: finalInfo(ctx), wispr: wisprOn(ctx) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
@@ -376,6 +379,7 @@ function engineInfo(ctx, w) {
  * while it is not ready, it is asked again every WISPR_RETRY_MS, up to WISPR_DEADLINE_MS after Stop. The workspace itself
  * makes no request: the agent session does, with the connector the PM signed in to. On by default ("Fetch Wispr Flow
  * notes" in the settings); PMOS_NOTES_WISPR (or ctx.notesWispr) 'off' turns it off on this machine. Never for a private note. */
+const echoOff = (ctx) => String(ctx.notesEcho !== undefined ? ctx.notesEcho : process.env.PMOS_NOTES_ECHO || '') === 'off';
 const finalOff = (ctx) => String(ctx.notesFinal !== undefined ? ctx.notesFinal : process.env.PMOS_NOTES_FINAL || '') === 'off';
 let finalRunner = null; let finalDir = null;
 function finalFor(ctx) {
@@ -391,6 +395,9 @@ function finalFor(ctx) {
       const dir = ctx.runtimeDir;
       const r = notes.setFinal(dir, { id, final });
       if (!notesAudio.getKeep(dir)) notesAudio.removeSources(dir, id);
+      else {   // best effort, off the main thread: on any failure the replay keeps its plain mix. The echo comes out first, then the sound is cleaned up
+        (echoOff(ctx) ? Promise.resolve() : notesEcho.cleanReplayInWorker(dir, id)).then(() => notesPolish.build(dir, id)).catch(() => {});
+      }
       if (!r.ok) return;
       const cur = notes.read(dir, id);
       const w = cur.ok && cur.note.ws ? ctx.getWs(cur.note.ws) : null;
@@ -541,7 +548,7 @@ async function handle(req, res, url, ctx) {
     // the page is open: the agent that wrote the notes before Wispr Flow's arrived writes them again, merged
     if (r.ok && mergeWispr(ctx, nid)) 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);
+      r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid); if (r.recording) r.recording = { ...r.recording, cleaned: notesAudio.hasClean(dir, nid) };
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
       r.bullets_state = bulletsState(ctx, r.note);
     }
@@ -677,22 +684,33 @@ async function handle(req, res, url, ctx) {
     if (!r.ok) return done(r);
     return done({ ok: true, deleted: notesAudio.remove(dir, id) });
   }
+  if (p === '/api/notes/clean-audio') {
+    // the PM asks for the cleaned copy of one note now; the work goes on in the background and the replay changes when it ends
+    const r = notes.read(dir, id);
+    if (!r.ok) return done(r);
+    if (!notesAudio.getClean(dir)) return done({ ok: false, status: 409, error: 'Clean up the replay sound is switched off in Settings' });
+    if (!notesPolish.detect()) return done({ ok: false, status: 409, error: 'ffmpeg was not found on this machine' });
+    if (!notesAudio.info(dir, id)) return done({ ok: false, status: 404, error: 'this note has no audio' });
+    notesPolish.build(dir, id);
+    return done({ ok: true, started: true });
+  }
   if (p === '/api/notes/switch') {
     const o = wsOf();
     // the spoken language belongs to this machine, not to a repository
     if (body.wispr !== undefined) {
       if (typeof body.wispr !== 'boolean') { ctx.json(res, { ok: false, error: 'say wispr: true or wispr: false' }, 400); return true; }
       setWisprOn(dir, body.wispr);
-      if (body.language === undefined && body.model === undefined && body.accuracy === undefined && body.keep_audio === undefined && body.jev === undefined && body.check === undefined) {
+      if (body.language === undefined && body.model === undefined && body.accuracy === undefined && body.keep_audio === undefined && body.clean_audio === undefined && body.jev === undefined && body.check === undefined) {
         ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true;
       }
     }
-    if (body.language !== undefined || body.model !== undefined || body.accuracy !== undefined || body.keep_audio !== undefined) {
+    if (body.language !== undefined || body.model !== undefined || body.accuracy !== undefined || body.keep_audio !== undefined || body.clean_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 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; }
+      const c = r.ok && m.ok && a.ok && k.ok && body.clean_audio !== undefined ? notesAudio.setClean(dir, body.clean_audio) : { ok: true };
+      if (!r.ok || !m.ok || !a.ok || !k.ok || !c.ok) { ctx.json(res, { ok: false, error: r.error || m.error || a.error || k.error || c.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; }

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.113.0",
+  "version": "0.115.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.113.0",
+      "version": "0.115.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

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

@@ -214,7 +214,7 @@ async function loadList(ctx) {
   if (!currentId && list.notes.length) currentId = list.notes[0].id;
   ctx.setState({});
 }
-const sig = (n) => JSON.stringify([n.final_state, n.final && n.final.at, n.final && n.final.names, n.final_notes && n.final_notes.at, n.wispr && [n.wispr.state, n.wispr.tries, n.wispr.reason], n.transcript, n.bullets, n.bullets_state && n.bullets_state.agent, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title, (n.versions || []).length, n.__recording && n.__recording.bytes, n.meeting, n.initiative]);
+const sig = (n) => JSON.stringify([n.final_state, n.final && n.final.at, n.final && n.final.names, n.final_notes && n.final_notes.at, n.wispr && [n.wispr.state, n.wispr.tries, n.wispr.reason], n.transcript, n.bullets, n.bullets_state && n.bullets_state.agent, n.summary && n.summary.at, n.agent && n.agent.markdown, n.private, n.speakers, n.title, (n.versions || []).length, n.__recording && [n.__recording.bytes, n.__recording.cleaned], n.meeting, n.initiative]);
 async function loadNote(ctx, id) {
   const r = await pmGet('/api/notes/one?id=' + encodeURIComponent(id));
   if (r && r.ok) {
@@ -516,10 +516,10 @@ function dropPlayer() { if (player) { try { player.el.pause(); } catch { /* gone
 function playerFor(ctx, n) {
   const rec = n.__recording;
   if (!rec || n.private) { if (player && player.id === n.id) dropPlayer(); return null; }
-  if (player && (player.id !== n.id || (player.bytes !== rec.bytes && !player.playing))) dropPlayer();
+  if (player && (player.id !== n.id || ((player.bytes !== rec.bytes || player.cleaned !== !!rec.cleaned) && !player.playing))) dropPlayer();
   if (player) return player;
-  const a = el('audio', { controls: true, preload: 'metadata', class: 'nt-audio', 'data-nt-audio': '', src: '/api/notes/recording?id=' + encodeURIComponent(n.id) + '&b=' + rec.bytes });
-  const p = { id: n.id, bytes: rec.bytes, el: a, playing: false };
+  const a = el('audio', { controls: true, preload: 'metadata', class: 'nt-audio', 'data-nt-audio': '', src: '/api/notes/recording?id=' + encodeURIComponent(n.id) + '&b=' + rec.bytes + (rec.cleaned ? '&c=1' : '') });
+  const p = { id: n.id, bytes: rec.bytes, cleaned: !!rec.cleaned, el: a, playing: false };
   a.addEventListener('play', () => { p.playing = true; ctx.setState({}); });
   a.addEventListener('pause', () => { p.playing = false; ctx.setState({}); });
   a.addEventListener('ended', () => { p.playing = false; ctx.setState({}); });
@@ -561,6 +561,21 @@ async function deleteAudio(ctx, n) {
   ctx.setState({});
 }
 
+/** Ask for the cleaned copy of one note's replay, then read the note until the copy is there. */
+async function cleanNow(ctx, n) {
+  const r = await pmPost('/api/notes/clean-audio', { id: n.id });
+  if (!r || !r.ok) { banner = { tone: 'bad', text: (r && r.error) || 'the sound was not cleaned up' }; ctx.setState({}); return; }
+  banner = { tone: 'ok', text: 'Cleaning up the sound. The replay changes when this is done; it takes a minute or two for a long meeting.' };
+  ctx.setState({});
+  for (let i = 0; i < 60; i++) {
+    await new Promise((res) => setTimeout(res, 3000));
+    const o = await loadNote(ctx, n.id);
+    if (o && o.ok && o.recording && o.recording.cleaned) { banner = { tone: 'ok', text: 'The replay now plays the cleaned sound.' }; ctx.setState({}); return; }
+  }
+  banner = { tone: 'bad', text: 'The cleaned sound is not ready yet. Open Settings and try again later.' };
+  ctx.setState({});
+}
+
 /* ── listening with local Whisper ─────────────────────────────────────────────────────────────── */
 async function openSource(kind) {
   const md = navigator.mediaDevices;
@@ -892,7 +907,7 @@ async function chooseSources(ctx, n) {
 }
 async function setSwitch(ctx, patch) {
   const ws = wsOf(ctx);
-  if (!ws && patch.language === undefined && patch.model === undefined && patch.keep_audio === undefined) return;
+  if (!ws && patch.language === undefined && patch.model === undefined && patch.keep_audio === undefined && patch.clean_audio === undefined) return;
   const r = await pmPost('/api/notes/switch', ws ? { ws, ...patch } : patch);
   if (r && r.ok) engine = { ws, whisper: r.whisper, jev: r.jev, at: Date.now() };
   ctx.setState({});
@@ -926,7 +941,13 @@ function openSettings(ctx, n) {
         onCommit: (v) => setSwitch(ctx, { keep_audio: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-keep-audio': '' } }) : null,
       w ? el('p', { class: 'nt-hint', 'data-nt-keep-hint': '' }, w.keep_audio !== false
         ? 'The meeting audio is kept on this machine, outside every repository, until you delete it. It is never sent anywhere. Browser recognition keeps no audio.'
-        : 'No audio is kept: each clip is deleted once it is transcribed, and a meeting cannot be replayed.') : null));
+        : 'No audio is kept: each clip is deleted once it is transcribed, and a meeting cannot be replayed.') : null,
+      w && w.keep_audio !== false ? field({ label: 'Clean up the replay sound', kind: 'check', value: w.clean_audio === true,
+        onCommit: (v) => setSwitch(ctx, { clean_audio: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-clean-audio': '' } }) : null,
+      w && w.keep_audio !== false ? el('p', { class: 'nt-hint', 'data-nt-clean-hint': w.ffmpeg ? 'ready' : 'missing' }, w.ffmpeg
+        ? (w.clean_audio === true ? 'After Stop, the replay gets a cleaned copy: less rumble and hiss, and an even loudness. The transcript is not changed.'
+          : 'Off. When on, the replay gets a cleaned copy after Stop: less rumble and hiss, and an even loudness.')
+        : 'This needs ffmpeg, which was not found on this machine. Install it with brew install ffmpeg, then open Settings again.') : null));
     const fp = w && w.final;
     if (fp) {
       const have = [fp.transcriber === 'qwen' ? 'Qwen3-ASR' : fp.transcriber === 'parakeet' ? 'Parakeet' : fp.transcriber === 'whisper' ? 'Whisper with beam search' : null,
@@ -958,6 +979,7 @@ function openSettings(ctx, n) {
         button({ label: n.private ? 'Mark not private' : 'Mark private', onClick: () => { h.close(); setPrivate(ctx, n, !n.private); }, attrs: { [n.private ? 'data-nt-unprivate' : 'data-nt-mark-private']: '' } }),
         button({ label: busy === 'agent' ? 'Starting …' : 'Summary by agent', disabled: n.private || busy === 'agent', onClick: () => { h.close(); summarizeAgent(ctx, n); }, attrs: { 'data-nt-summarize-agent': '' } }),
         n.__recording || (n.final_state && n.final_state.state === 'failed') ? button({ label: 'Transcribe again', disabled: n.private || finalPending(n), onClick: () => { h.close(); runFinal(ctx, n); }, attrs: { 'data-nt-final-again': '' } }) : null,
+        n.__recording && w && w.clean_audio === true && w.ffmpeg && !n.__recording.cleaned ? button({ label: 'Clean up this note\'s sound', disabled: n.private || listening(n), onClick: () => { h.close(); cleanNow(ctx, n); }, attrs: { 'data-nt-clean-now': '' } }) : null,
         n.__recording ? button({ label: 'Delete this note\'s audio', variant: 'ghost', onClick: () => { h.close(); deleteAudio(ctx, n); }, attrs: { 'data-nt-delete-audio': '' } }) : null,
         button({ label: 'Delete', variant: 'ghost', onClick: () => { h.close(); deleteNote(ctx, n); }, attrs: { 'data-nt-delete': '' } }))));
     return parts;

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

@@ -1,10 +1,12 @@
 {
-  "_comment": "meeting-notes Runs 1 to 10: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), the final pass after Stop and the Wispr Flow fetch (notes-final.test.js), Qwen3-ASR kept loaded (notes-qwen.test.js), and the Notes view in a browser (pm-notes-test.js), plus the note pop-up patched in place while it listens (pm-note-dock-test.js).",
+  "_comment": "meeting-notes Runs 1 to 10: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), the final pass after Stop and the Wispr Flow fetch (notes-final.test.js), Qwen3-ASR kept loaded (notes-qwen.test.js), and the Notes view in a browser (pm-notes-test.js), the echo canceller for the replay (notes-echo.test.js, notes-audio-quality Run 2) and the optional cleaned copy of the replay (notes-polish.test.js, Run 3), plus the note pop-up patched in place while it listens (pm-note-dock-test.js).",
   "modules": [
     "notes.test.js",
     "notes-listen.test.js",
     "notes-final.test.js",
-    "notes-qwen.test.js"
+    "notes-qwen.test.js",
+    "notes-echo.test.js",
+    "notes-polish.test.js"
   ],
   "panels": [
     "pm-notes-test.js",
@@ -16,6 +18,8 @@
     "notes-listen.test.js": 10,
     "notes-final.test.js": 6,
     "notes-qwen.test.js": 4,
-    "pm-note-dock-test.js": 20
+    "pm-note-dock-test.js": 20,
+    "notes-echo.test.js": 25,
+    "notes-polish.test.js": 3
   }
 }