create-pmos 0.115.0 → 0.116.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.115.0",
+  "version": "0.116.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@9fd15f4
+kernel-source: pmos@affb04c
 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-08T06:01:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:17:49Z"}
 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-08T06:01:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:17:49Z"}
 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-08T06:01:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T06:17:49Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -132,6 +132,8 @@ When a meeting was heard with local transcription, its audio is kept on this mac
 
 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 of a new note is kept at 24 kHz, so it keeps the high sounds of a voice that a 16 kHz file loses. The transcript is still made from 16 kHz audio, as before. A note you recorded before this change keeps its 16 kHz replay and plays as it did. The 24 kHz file is about 173 MB for each hour, and the workspace deletes it with the note's audio.
+
 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

package/workspace/lib/audio-resample.js

@@ -0,0 +1,76 @@
+'use strict';
+/* audio-resample.js — the server's copy of the low-pass resampler in public/pm/audio-capture.js (notes-audio-quality Run 4).
+ *
+ *   makeResampler(inRate, outRate) → { push(Float32Array|Float64Array) → Int16Array, flush() → Int16Array }
+ *
+ * The page cannot require() a CommonJS file and the server cannot import() a page module without a warning on every start, so the
+ * function exists twice. Its text must stay the same in both files: notes-hires.test.js compares the two and runs them on the same
+ * sound. Change one, change the other.
+ */
+const RATE = 16000;
+const CUT = 0.45;             // the filter cuts at this share of the output rate
+const CROSSINGS = 16;         // zero crossings of the sinc on each side of the centre
+
+const toS16 = (v) => { const c = v > 1 ? 1 : v < -1 ? -1 : v; return c < 0 ? c * 0x8000 : c * 0x7fff; };
+
+function makeResampler(inRate, outRate = RATE) {
+  const ratio = inRate / outRate;
+  if (ratio === 1) {
+    return { push(x) { const o = new Int16Array(x.length); for (let i = 0; i < x.length; i++) o[i] = toS16(x[i]); return o; }, flush() { return new Int16Array(0); } };
+  }
+  const fc = CUT / Math.max(1, ratio);          // cycles per input sample
+  const half = Math.ceil(CROSSINGS / (2 * fc)); // input samples either side of the centre
+  let buf = new Float64Array(0);                // input not yet used up; buf[0] is input sample `base`
+  let base = 0;
+  let centre = 0;                               // the next output sample sits at this input position
+  let seen = 0;                                 // input samples received
+  const weight = (d) => {
+    const x = 2 * fc * d;
+    const sinc = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+    const w = 0.42 + 0.5 * Math.cos(Math.PI * d / half) + 0.08 * Math.cos(2 * Math.PI * d / half);   // Blackman, centred
+    return sinc * w;
+  };
+  // The weights depend only on the fractional part of the centre, so they are made once for each fraction (3 or 160 of them for the
+  // rates in use) and kept: 48 kHz to 16 kHz, or 24 kHz to 16 kHz, would otherwise compute a sine and two cosines per tap per sample.
+  const phases = new Map();
+  const phaseOf = (frac) => {
+    const key = Math.round(frac * 1e6);
+    let ph = phases.get(key);
+    if (!ph) {
+      const c = Math.floor(frac * 1e6 + 0.5) / 1e6; const lo = Math.ceil(c - half) - 0; const hi = Math.floor(c + half);
+      const w = new Float64Array(hi - lo + 1); let norm = 0;
+      for (let i = lo; i <= hi; i++) { const k = weight(i - c); w[i - lo] = k; norm += k; }
+      for (let i = 0; i < w.length; i++) w[i] /= norm;
+      ph = { lo, w };
+      if (phases.size < 4096) phases.set(key, ph);
+    }
+    return ph;
+  };
+  function run(limit, out) {
+    while (centre < limit && Math.floor(centre) + half < base + buf.length) {
+      const fl = Math.floor(centre); const ph = phaseOf(centre - fl);
+      const first = fl + ph.lo - base; let sum = 0;
+      for (let k = 0; k < ph.w.length; k++) { const j = first + k; if (j >= 0 && j < buf.length) sum += buf[j] * ph.w[k]; }
+      out.push(toS16(sum));
+      centre += ratio;
+    }
+  }
+  function trim() {
+    const keep = Math.max(base, Math.floor(centre) - half);
+    if (keep > base) { buf = buf.slice(keep - base); base = keep; }
+  }
+  return {
+    push(x) {
+      const merged = new Float64Array(buf.length + x.length); merged.set(buf); merged.set(x, buf.length); buf = merged; seen += x.length;
+      const out = []; run(Infinity, out); trim();
+      return Int16Array.from(out);
+    },
+    flush() {
+      const pad = new Float64Array(buf.length + half + 1); pad.set(buf); buf = pad;
+      const out = []; run(seen, out); trim();
+      return Int16Array.from(out);
+    },
+  };
+}
+
+module.exports = { makeResampler, RATE };

package/workspace/lib/notes-audio.js

@@ -28,11 +28,16 @@ const RATE = 16000;
 const BYTES_PER_MS = (RATE * 2) / 1000;
 const ON_TIME_MS = 1500;                    // a chunk this close to where its source left off is placed straight after it
 const MAX_BYTES = RATE * 2 * 60 * 60 * 6;   // six hours; a longer meeting keeps its first six hours
+const HI_RATE = 24000;                      // the replay may be stored at this rate (D92 as amended 2026-10-08)
+const HI_BYTES_PER_MS = (HI_RATE * 2) / 1000;
+const HI_MAX_BYTES = HI_RATE * 2 * 60 * 60 * 6;
 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 hiFileOf = (runtimeDir, id) => path.join(dirOf(runtimeDir), id + '.hi.pcm');
+const sideFileOf = (runtimeDir, id, suffix) => path.join(dirOf(runtimeDir), id + suffix);
 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');
@@ -75,7 +80,7 @@ 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, t, mixed = true }) {
+function write(runtimeDir, { id, source, pcm, pcm24 = null, t, 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;
@@ -86,7 +91,10 @@ function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
   if (at >= MAX_BYTES) return { ok: true, kept: false };
   const len = Math.min(pcm.length, MAX_BYTES - at);
   fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
-  if (mixed) {
+  // 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 (mixed && !hiOk) {
     const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
     try {
       const old = Buffer.alloc(len);
@@ -105,9 +113,38 @@ function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
   return { ok: true, kept: true, at_ms: at / BYTES_PER_MS };
 }
 
-function info(runtimeDir, id) {
+/** 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) {
+  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 prev = next.get(key);
+  if (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);
+  try {
+    const old = Buffer.alloc(len);
+    fs.readSync(fd, old, 0, len, at);
+    const out = Buffer.alloc(len);
+    for (let i = 0; i < len; i += 2) out.writeInt16LE(softLimit(old.readInt16LE(i) + pcm24.readInt16LE(i)), i);
+    fs.writeSync(fd, out, 0, len, at);
+  } finally { fs.closeSync(fd); }
+  next.set(key, at + len);
+}
+
+/** The file the replay is made from: the 24 kHz mix when the note has one, else the 16 kHz mix. { file, bytes, rate } | null. */
+function baseOf(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return null;
-  try { const st = fs.statSync(fileOf(runtimeDir, id)); return st.size ? { bytes: st.size, ms: Math.round(st.size / BYTES_PER_MS) } : null; } catch { return null; }
+  for (const [file, rate] of [[hiFileOf(runtimeDir, id), HI_RATE], [fileOf(runtimeDir, id), RATE]]) {
+    try { const st = fs.statSync(file); if (st.size) return { file, bytes: st.size, rate }; } catch { /* none */ }
+  }
+  return null;
+}
+
+function info(runtimeDir, id) {
+  const b = baseOf(runtimeDir, id);
+  return b ? { bytes: b.bytes, ms: Math.round(b.bytes / (b.rate * 2 / 1000)), rate: b.rate } : null;
 }
 function removeSources(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return;
@@ -115,10 +152,14 @@ function removeSources(runtimeDir, id) {
 }
 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 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 */ } }
-  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; }
+  let removed = false;
+  for (const extra of ['.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;
 }
 /** The note's audio, one file per source: [{ source, file, bytes, ms }], the sources that were heard. */
 function sources(runtimeDir, id) {
@@ -131,27 +172,28 @@ 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. */
+/** The file the replay plays: the cleaned copy when the PM switched cleaning on and the copy is as long as the replay's base (a copy
+ * made before listening went on is shorter, so it is stale and the plain replay plays); otherwise the base. { file, bytes, rate,
+ * cleaned } | null. */
 function replayOf(runtimeDir, id) {
-  const inf = info(runtimeDir, id);
-  if (!inf) return null;
+  const base = baseOf(runtimeDir, id);
+  if (!base) 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 */ }
+    try { const st = fs.statSync(cleanFileOf(runtimeDir, id)); if (st.size === base.bytes) return { file: cleanFileOf(runtimeDir, id), bytes: st.size, rate: base.rate, cleaned: true }; } catch { /* none */ }
   }
-  return { file: fileOf(runtimeDir, id), bytes: inf.bytes, cleaned: false };
+  return { file: base.file, bytes: base.bytes, rate: base.rate, cleaned: false };
 }
-/** True when a cleaned copy exists and is as long as the mix. */
+/** True when a cleaned copy exists and is as long as the replay's base. */
 function hasClean(runtimeDir, id) {
-  const inf = info(runtimeDir, id);
-  try { return !!inf && fs.statSync(cleanFileOf(runtimeDir, id)).size === inf.bytes; } catch { return false; }
+  const base = baseOf(runtimeDir, id);
+  try { return !!base && fs.statSync(cleanFileOf(runtimeDir, id)).size === base.bytes; } catch { return false; }
 }
 
-function wavHeader(dataBytes) {
+function wavHeader(dataBytes, rate = RATE) {
   const h = Buffer.alloc(44);
   h.write('RIFF', 0); h.writeUInt32LE(36 + dataBytes, 4); h.write('WAVE', 8);
   h.write('fmt ', 12); h.writeUInt32LE(16, 16); h.writeUInt16LE(1, 20); h.writeUInt16LE(1, 22);
-  h.writeUInt32LE(RATE, 24); h.writeUInt32LE(RATE * 2, 28); h.writeUInt16LE(2, 32); h.writeUInt16LE(16, 34);
+  h.writeUInt32LE(rate, 24); h.writeUInt32LE(rate * 2, 28); h.writeUInt16LE(2, 32); h.writeUInt16LE(16, 34);
   h.write('data', 36); h.writeUInt32LE(dataBytes, 40);
   return h;
 }
@@ -159,7 +201,7 @@ function wavHeader(dataBytes) {
 function serve(req, res, 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 header = wavHeader(inf.bytes, inf.rate);
   const total = header.length + inf.bytes;
   let start = 0; let end = total - 1; let partial = false;
   const m = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range || '').trim());
@@ -178,4 +220,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: fileOf, cleanFile: cleanFileOf, RATE, BYTES_PER_MS, MAX_BYTES };
+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 };

package/workspace/lib/notes-echo.js

@@ -4,7 +4,7 @@
  *   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
+ *   report(runtimeDir, id)                           what the last clean-up did (or why it failed), 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.
@@ -26,6 +26,7 @@ const fs = require('fs');
 const path = require('path');
 const { Worker } = require('worker_threads');
 const notesAudio = require('./notes-audio');
+const hires = require('./notes-hires');
 
 const FS = notesAudio.RATE;          // 16000
 const L = 8192;                      // the echo path kept: 512 ms
@@ -259,7 +260,7 @@ function cleanStream({ n, readFar, readMic, onChunk }) {
 }
 
 /* ── the replay file ──────────────────────────────────────────────────────────────────────────── */
-const reportFile = (runtimeDir, id) => notesAudio.replayFile(runtimeDir, id).replace(/\.pcm$/, '.echo.json');
+const reportFile = (runtimeDir, id) => notesAudio.sideFile(runtimeDir, id, '.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) {
@@ -282,9 +283,18 @@ function cleanReplay(runtimeDir, id, { beforeCommit } = {}) {
   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';
+  const base = notesAudio.baseOf(runtimeDir, id);
+  if (!base) return { ok: true, skipped: 'the note has no replay file' };
+  // A note with a 24 kHz replay is cleaned at 16 kHz, from the source files, and the cleaned speech is then put together with the
+  // band above 8 kHz of the 24 kHz recording (lib/notes-hires.js). An older note has a 16 kHz replay and is rebuilt as it always was.
+  const hi = base.rate === notesAudio.HI_RATE;
+  const mixPath = notesAudio.mixFile(runtimeDir, id); const hiPath = notesAudio.hiFile(runtimeDir, id);
+  const out = hi ? hiPath : mixPath; const tmp = mixPath + '.echo.tmp'; const tmpHi = hiPath + '.echo.tmp';
   let fdM = null; let fdX = null; let fdO = null;
+  const fail = (error) => {
+    for (const f of [tmp, tmpHi]) { try { fs.unlinkSync(f); } catch { /* none */ } }
+    return { ok: false, error: String(error).slice(0, 300) };
+  };
   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);
@@ -303,22 +313,30 @@ function cleanReplay(runtimeDir, id, { beforeCommit } = {}) {
       },
     });
     fs.closeSync(fdO); fdO = null;
+    if (hi) {
+      const c = hires.compose({ cleanFile: tmp, hiFile: hiPath, outFile: tmpHi });
+      if (!c.ok) { const r = fail(c.error); writeReport(runtimeDir, id, r); return r; }
+    }
     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 });
+    // the sources and the replay must be as they were: if listening went on meanwhile, the replay as it is is the truth and this one is dropped
+    const now = notesAudio.sources(runtimeDir, id); const nowBase = notesAudio.baseOf(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; })
+      && (!hi || (nowBase && nowBase.bytes === base.bytes));
+    if (!same) return fail('listening went on while the echo was taken out');
+    if (hi) { fs.renameSync(tmpHi, hiPath); try { fs.unlinkSync(tmp); } catch { /* none */ } } else fs.renameSync(tmp, mixPath);
+    const result = { ok: true, at: new Date().toISOString(), rate: hi ? notesAudio.HI_RATE : notesAudio.RATE, ...rep, took_ms: Date.now() - began };
+    writeReport(runtimeDir, id, result);
     return result;
   } catch (e) {
-    try { fs.unlinkSync(tmp); } catch { /* none */ }
-    return { ok: false, error: String((e && e.message) || e).slice(0, 300) };
+    return fail((e && e.message) || e);
   } finally {
     for (const fd of [fdM, fdX, fdO]) if (fd !== null) { try { fs.closeSync(fd); } catch { /* closed */ } }
   }
 }
+/** What the last clean-up did, kept beside the audio so a failure is not silent. */
+function writeReport(runtimeDir, id, result) {
+  try { fs.writeFileSync(reportFile(runtimeDir, id), JSON.stringify({ at: new Date().toISOString(), ...result }), { mode: 0o600 }); } catch { /* best effort */ }
+}
 
 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. */
@@ -329,7 +347,7 @@ function cleanReplayInWorker(runtimeDir, id) {
     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);
+    const timer = setTimeout(() => { w.terminate(); for (const t of [notesAudio.mixFile(runtimeDir, id) + '.echo.tmp', notesAudio.hiFile(runtimeDir, id) + '.echo.tmp']) { try { fs.unlinkSync(t); } 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' }));

package/workspace/lib/notes-hires.js

@@ -0,0 +1,94 @@
+'use strict';
+/* notes-hires.js — put the cleaned speech back into the 24 kHz replay (notes-audio-quality Run 4, D92 as amended 2026-10-08).
+ *
+ *   compose({ cleanFile, hiFile, outFile }) → { ok, samples } | { ok: false, error }
+ *
+ * THE PROBLEM. The echo clean-up (lib/notes-echo.js) works at 16 kHz, on the two source files, so it cleans the band below 8 kHz.
+ * The replay the PM hears is the 24 kHz mix, which also holds the band from 8 to 12 kHz: the air and the hiss of the voices. Rebuilding
+ * the replay from the 16 kHz clean-up alone would throw that band away and bring the replay back to 16 kHz quality.
+ *
+ * THE METHOD. Split the 24 kHz mix at the filter's edge (7.2 kHz): low = the mix taken down to 16 kHz and back up to 24 kHz, high = the
+ * mix minus low. The replay is then the cleaned 16 kHz mix taken up to 24 kHz, plus high. The low band is the cleaned speech; the high
+ * band is exactly what was recorded. Running it again on its own output changes nothing, because the high band of the result is the
+ * high band of the recording, so a second final pass (Listen again) can use it.
+ *
+ * WHAT IT NEVER DOES. It reads the two files and writes the output file; the caller renames it into place. It does not touch the
+ * 16 kHz source files. It opens no network module.
+ */
+const fs = require('fs');
+const resample = require('./audio-resample');
+const { softLimit } = require('./notes-audio');
+
+const HI = 24000;
+const LO = 16000;
+const BLOCK_HI = 480000;           // 20 s of the 24 kHz mix at a time
+const BLOCK_LO = BLOCK_HI * LO / HI;
+const TOLERANCE_S = 0.5;           // the two files may differ in length by this much: more means they are not the same recording
+
+const toFloat = (i16) => { const f = new Float32Array(i16.length); for (let i = 0; i < i16.length; i++) f[i] = i16[i] / 32768; return f; };
+
+/** A queue of int16 samples that grows at the back and is eaten from the front. */
+function queue() {
+  let a = new Int16Array(0);
+  return { get length() { return a.length; }, push(x) { const m = new Int16Array(a.length + x.length); m.set(a); m.set(x, a.length); a = m; },
+    take(n) { const out = a.subarray(0, n); a = a.slice(n); return out; } };
+}
+
+function readBlock(fd, size, from, count) {
+  const bytes = Math.max(0, Math.min(count * 2, size - from * 2));
+  const out = new Int16Array(bytes / 2);
+  if (bytes <= 0) return out;
+  const buf = Buffer.alloc(bytes);
+  fs.readSync(fd, buf, 0, bytes, from * 2);
+  for (let i = 0; i < out.length; i++) out[i] = buf.readInt16LE(i * 2);
+  return out;
+}
+
+function compose({ cleanFile, hiFile, outFile }) {
+  let fdC = null; let fdH = null; let fdO = null;
+  try {
+    const sizeC = fs.statSync(cleanFile).size; const sizeH = fs.statSync(hiFile).size;
+    const nC = Math.floor(sizeC / 2); const nH = Math.floor(sizeH / 2);
+    if (!nH) return { ok: false, error: 'the 24 kHz recording is empty' };
+    if (Math.abs(nC / LO - nH / HI) > TOLERANCE_S) return { ok: false, error: 'the two recordings differ in length by more than ' + TOLERANCE_S + ' s' };
+    fdC = fs.openSync(cleanFile, 'r'); fdH = fs.openSync(hiFile, 'r'); fdO = fs.openSync(outFile, 'w', 0o600);
+    const down = resample.makeResampler(HI, LO); const up = resample.makeResampler(LO, HI); const upClean = resample.makeResampler(LO, HI);
+    const raw = queue(); const low = queue(); const clean = queue();
+    let written = 0;
+    const emit = (n) => {
+      if (n <= 0) return;
+      const r = raw.take(n); const l = low.take(n); const c = clean.take(n);
+      const buf = Buffer.alloc(n * 2);
+      for (let i = 0; i < n; i++) buf.writeInt16LE(softLimit(c[i] + (r[i] - l[i])), i * 2);
+      fs.writeSync(fdO, buf, 0, buf.length, written * 2); written += n;
+    };
+    const drain = () => emit(Math.min(raw.length, low.length, clean.length));
+    for (let a = 0, b = 0; a < nH || b < nC; a += BLOCK_HI, b += BLOCK_LO) {
+      const h = readBlock(fdH, sizeH, a, BLOCK_HI); const c = readBlock(fdC, sizeC, b, BLOCK_LO);
+      raw.push(h);
+      low.push(up.push(toFloat(down.push(toFloat(h)))));
+      clean.push(upClean.push(toFloat(c)));
+      drain();
+    }
+    low.push(up.push(toFloat(down.flush()))); low.push(up.flush());
+    clean.push(upClean.flush());
+    drain();
+    // the last few samples may lack a partner (the filters stop a hair short): the band-limited parts are then taken as silent
+    const rest = raw.length;
+    if (rest > 0) {
+      if (rest > 8) return { ok: false, error: 'the recordings did not line up to the end' };
+      const r = raw.take(rest); const l = low.take(Math.min(rest, low.length)); const c = clean.take(Math.min(rest, clean.length));
+      const buf = Buffer.alloc(rest * 2);
+      for (let i = 0; i < rest; i++) buf.writeInt16LE(softLimit((i < c.length ? c[i] : 0) + (i < l.length ? r[i] - l[i] : 0)), i * 2);
+      fs.writeSync(fdO, buf, 0, buf.length, written * 2); written += rest;
+    }
+    fs.closeSync(fdO); fdO = null;
+    return { ok: true, samples: written };
+  } catch (e) {
+    return { ok: false, error: String((e && e.message) || e).slice(0, 300) };
+  } finally {
+    for (const fd of [fdC, fdH, fdO]) if (fd !== null) { try { fs.closeSync(fd); } catch { /* closed */ } }
+  }
+}
+
+module.exports = { compose, HI, LO };

package/workspace/lib/notes-polish.js

@@ -19,7 +19,6 @@ 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
@@ -50,8 +49,8 @@ function build(runtimeDir, id, opts = {}) {
     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 });
+      const r = await run(found.bin, ['-nostdin', '-hide_banner', '-loglevel', 'error', '-y', '-f', 's16le', '-ar', String(inf.rate), '-ac', '1', '-i', input,
+        '-af', FILTER, '-f', 's16le', '-ar', String(inf.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);

package/workspace/lib/routes-notes.js

@@ -654,13 +654,21 @@ async function handle(req, res, url, ctx) {
     if (b64.length > Math.ceil(MAX_PCM_BYTES / 3) * 4) return done({ ok: false, status: 413, error: 'that audio chunk is too long' });
     const pcm = Buffer.from(b64, 'base64');
     if (pcm.length % 2) return done({ ok: false, status: 400, error: 'the audio must be 16-bit samples' });
+    // the same time at 24 kHz, for the replay (D92 as amended 2026-10-08); the transcription never reads it
+    const b24 = typeof body.pcm24 === 'string' ? body.pcm24 : '';
+    if (b24.length > Math.ceil((MAX_PCM_BYTES * 1.5) / 3) * 4) return done({ ok: false, status: 413, error: 'that audio chunk is too long' });
+    const pcm24 = b24 ? Buffer.from(b24, 'base64') : null;
+    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);
     // 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)
-    { try { notesAudio.write(dir, { id, source, pcm, t, mixed: notesAudio.getKeep(dir) }); } catch (e) { audioErrors.set(id, { at: new Date().toISOString(), error: 'the audio was not kept: ' + ((e && e.message) || e) }); } }
+    // 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 }));
   }
   if (p === '/api/notes/label') return done(notes.setLabel(dir, { id, index: Number(body.index), cat: body.cat, drop: body.drop === true }));

package/workspace/notes-test-signals.js

@@ -0,0 +1,65 @@
+'use strict';
+/* notes-test-signals.js — synthetic sound for the notes audio suites (notes-echo.test.js, notes-hires.test.js). Not a test itself.
+ *
+ *   speechLike(seed, secs, talkShare) → { x, active }    noise through three resonances, in phrases with pauses
+ *   makePath(seed, delayMs, gainDb)                       an echo path: a direct arrival and a decaying tail
+ *   conv(x, h)                                            conv by overlap-add over FFTs
+ *   scene({ secs, delayMs, gainDb, tanh, change, noiseDb, seed }) → { far, near, mic, echo, n }
+ *                                                         the meeting `far`, the PM `near`, and the microphone that hears both
+ */
+const E = require('./lib/notes-echo');
+
+const FS = 16000;
+function rng(seed) { let a = seed >>> 0; return () => { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+const gauss = (r) => Math.sqrt(-2 * Math.log(r() + 1e-12)) * Math.cos(2 * Math.PI * r());
+/** Speech-like: noise through three resonances, in phrases of 1 to 3 s with pauses. { x, active }. */
+function speechLike(seed, secs, talkShare) {
+  const r = rng(seed); const n = secs * FS; const x = new Float64Array(n); const active = new Uint8Array(n);
+  const res = [[500, 80], [1500, 120], [2600, 200]].map(([f, bw]) => { const R = Math.exp(-Math.PI * bw / FS); return { a1: 2 * R * Math.cos(2 * Math.PI * f / FS), a2: -R * R, y1: 0, y2: 0 }; });
+  let t = 0;
+  while (t < n) {
+    const talk = Math.round((1 + 2 * r()) * FS); const quiet = Math.round(talk * (1 - talkShare) / talkShare * (0.5 + r())); const syll = 3 + 3 * r();
+    for (let i = 0; i < talk && t + i < n; i++) {
+      const env = 0.55 + 0.45 * Math.sin(2 * Math.PI * syll * i / FS) ** 2; const edge = Math.min(1, i / 800, (talk - i) / 800); const e = gauss(r);
+      let y = 0; for (const q of res) { const o = e * 0.2 + q.a1 * q.y1 + q.a2 * q.y2; q.y2 = q.y1; q.y1 = o; y += o; }
+      x[t + i] = y * env * edge * 0.04; active[t + i] = 1;
+    }
+    t += talk + quiet;
+  }
+  let pk = 0; for (let i = 0; i < n; i++) pk = Math.max(pk, Math.abs(x[i]));
+  for (let i = 0; i < n; i++) x[i] = x[i] / pk * 0.4;
+  return { x, active };
+}
+/** An echo path: a direct arrival after delayMs, then a decaying tail, rolled off at the top. */
+function makePath(seed, delayMs, gainDb) {
+  const d = Math.round(delayMs * FS / 1000); const len = d + 4800; const r = rng(seed); const h = new Float64Array(len); const g = 10 ** (gainDb / 20);
+  for (let i = 0; i < len - d; i++) h[d + i] = (i === 0 ? 1 : 0.35 * gauss(r) * Math.exp(-i / FS / 0.08)) * g;
+  let y = 0; for (let i = 0; i < len; i++) { y = 0.55 * y + 0.45 * h[i]; h[i] = y; }
+  return h;
+}
+/** conv(x, h) by overlap-add over FFTs. */
+function conv(x, h) {
+  const F = 16384; const B = F - h.length; if (B <= 0) throw new Error('path too long');
+  const out = new Float64Array(x.length); const Hr = new Float64Array(F); const Hi = new Float64Array(F); Hr.set(h); E.fft(Hr, Hi, false);
+  for (let s = 0; s < x.length; s += B) {
+    const re = new Float64Array(F); const im = new Float64Array(F);
+    for (let i = 0; i < B && s + i < x.length; i++) re[i] = x[s + i];
+    E.fft(re, im, false);
+    for (let k = 0; k < F; k++) { const a = re[k] * Hr[k] - im[k] * Hi[k]; im[k] = re[k] * Hi[k] + im[k] * Hr[k]; re[k] = a; }
+    E.fft(re, im, true);
+    for (let i = 0; i < F && s + i < out.length; i++) out[s + i] += re[i];
+  }
+  return out;
+}
+/** A scene: the meeting `far`, the PM `near`, and the microphone that hears both, plus the echo alone. */
+function scene({ secs, delayMs = 120, gainDb = -9, tanh = 0, change = null, noiseDb = -50, seed = 1 }) {
+  const far = speechLike(11 + seed, secs, 0.65); const near = speechLike(29 + seed, secs, 0.45); const n = far.x.length;
+  const driven = tanh ? Float64Array.from(far.x, (v) => Math.tanh(tanh * v) / tanh) : far.x;
+  const echo = conv(driven, makePath(5, delayMs, gainDb));
+  if (change) { const second = conv(driven, makePath(6, delayMs + 20, gainDb - 6)); for (let i = Math.round(change * FS); i < n; i++) echo[i] = second[i]; }
+  const r = rng(77); const nz = 10 ** (noiseDb / 20) * 0.05; const mic = new Float64Array(n);
+  for (let i = 0; i < n; i++) mic[i] = echo[i] + near.x[i] * 0.5 + nz * gauss(r);
+  return { far, near, mic, echo, n };
+}
+
+module.exports = { FS, rng, gauss, speechLike, makePath, conv, scene };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/audio-capture.js

@@ -32,14 +32,28 @@ export function makeResampler(inRate, outRate = RATE) {
     const w = 0.42 + 0.5 * Math.cos(Math.PI * d / half) + 0.08 * Math.cos(2 * Math.PI * d / half);   // Blackman, centred
     return sinc * w;
   };
-  const w = new Float64Array(2 * half + 2);
+  // The weights depend only on the fractional part of the centre, so they are made once for each fraction (3 or 160 of them for the
+  // rates in use) and kept: 48 kHz to 16 kHz, or 24 kHz to 16 kHz, would otherwise compute a sine and two cosines per tap per sample.
+  const phases = new Map();
+  const phaseOf = (frac) => {
+    const key = Math.round(frac * 1e6);
+    let ph = phases.get(key);
+    if (!ph) {
+      const c = Math.floor(frac * 1e6 + 0.5) / 1e6; const lo = Math.ceil(c - half) - 0; const hi = Math.floor(c + half);
+      const w = new Float64Array(hi - lo + 1); let norm = 0;
+      for (let i = lo; i <= hi; i++) { const k = weight(i - c); w[i - lo] = k; norm += k; }
+      for (let i = 0; i < w.length; i++) w[i] /= norm;
+      ph = { lo, w };
+      if (phases.size < 4096) phases.set(key, ph);
+    }
+    return ph;
+  };
   function run(limit, out) {
     while (centre < limit && Math.floor(centre) + half < base + buf.length) {
-      const lo = Math.ceil(centre - half); const hi = Math.floor(centre + half);
-      let sum = 0; let norm = 0;
-      for (let i = lo; i <= hi; i++) { const k = weight(i - centre); w[i - lo] = k; norm += k; }
-      for (let i = lo; i <= hi; i++) { const j = i - base; if (j >= 0 && j < buf.length) sum += buf[j] * w[i - lo]; }
-      out.push(toS16(sum / norm));
+      const fl = Math.floor(centre); const ph = phaseOf(centre - fl);
+      const first = fl + ph.lo - base; let sum = 0;
+      for (let k = 0; k < ph.w.length; k++) { const j = first + k; if (j >= 0 && j < buf.length) sum += buf[j] * ph.w[k]; }
+      out.push(toS16(sum));
       centre += ratio;
     }
   }

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

@@ -52,6 +52,7 @@ const POLL_MS = 1500;         // while listening, and until the last line is lab
 const AGENT_POLL_MS = 3000;
 const CHUNK_SAMPLES = 16000;  // one second at 16 kHz
 const RATE = 16000;
+const HI_RATE = 24000;        // the replay is kept at this rate when the device has it (D92 as amended 2026-10-08)
 const SEND_TRIES = 3;         // a chunk that the server did not take is sent again this many times in all …
 const SEND_BACKOFF_MS = 400;  // … after 400 ms, then 1200 ms
 const SECTIONS = [['decision', 'Decisions'], ['action', 'Next steps'], ['question', 'Open questions']];
@@ -588,7 +589,7 @@ async function openSource(kind) {
   return new MediaStream(tracks);
 }
 async function startAudio(ctx, n, want) {
-  const a = { id: n.id, state: 'starting', sources: [], streams: [], ctx: null, started: Date.now(), clock: null, msg: null, queue: {}, buf: {}, rs: {}, lost: 0, ended: 0 };
+  const a = { id: n.id, state: 'starting', sources: [], streams: [], ctx: null, started: Date.now(), clock: null, msg: null, queue: {}, buf: {}, rs: {}, rs24: {}, buf24: {}, lost: 0, ended: 0 };
   const opened = [];
   // the meeting first, straight from the press: the browser lets a page share a screen only right after a click
   for (const kind of want.slice().sort((x, y) => (x === 'meeting' ? -1 : y === 'meeting' ? 1 : 0))) {
@@ -604,17 +605,22 @@ async function startAudio(ctx, n, want) {
   // the clock counts the meeting time, as the line times do: Listen again carries on from where it stopped
   a.started = Date.parse(r.clock_from || r.recorded_from) || a.started;
   let ac;
-  try { ac = new AudioContext({ sampleRate: RATE }); } catch { ac = new AudioContext(); }
+  // the device's own rate: the 16 kHz audio for transcription and the 24 kHz audio for the replay are both made from the same blocks (D92 as amended)
+  try { ac = new AudioContext(); } catch { ac = new AudioContext({ sampleRate: RATE }); }
   a.ctx = ac;
   const sink = ac.createGain(); sink.gain.value = 0; sink.connect(ac.destination);
   for (const [kind, stream] of opened) {
     a.streams.push(stream); a.sources.push(kind); a.buf[kind] = []; a.queue[kind] = Promise.resolve();
     const src = ac.createMediaStreamSource(stream);
     const rs = a.rs[kind] = makeResampler(ac.sampleRate);
+    // a device slower than 24 kHz has nothing above 12 kHz to keep, so it sends 16 kHz audio only and the replay stays 16 kHz
+    const rs24 = ac.sampleRate >= HI_RATE ? (a.rs24[kind] = makeResampler(ac.sampleRate, HI_RATE)) : null;
+    a.buf24[kind] = [];
     await openCapture(ac, src, sink, (block) => {
       if (audio !== a) return;
       const s = rs.push(block);
       const b = a.buf[kind]; for (let i = 0; i < s.length; i++) b.push(s[i]);
+      if (rs24) { const h = rs24.push(block); const b24 = a.buf24[kind]; for (let i = 0; i < h.length; i++) b24.push(h[i]); }
       if (b.length >= CHUNK_SAMPLES) sendChunk(ctx, a, kind, false);
     });
     for (const t of stream.getTracks()) t.addEventListener('ended', () => { if (audio !== a) return; a.ended++; if (a.ended >= a.streams.length) stopAudio(ctx); });
@@ -627,11 +633,13 @@ async function startAudio(ctx, n, want) {
 function sendChunk(ctx, a, kind, final) {
   const b = a.buf[kind] || []; a.buf[kind] = [];
   const pcm = b64(Int16Array.from(b));
+  const b24 = a.buf24[kind] || []; a.buf24[kind] = [];
+  const pcm24 = b24.length ? b64(Int16Array.from(b24)) : undefined;
   const seconds = b.length / RATE;
   a.queue[kind] = a.queue[kind].then(async () => {
     let r = null;
     for (let tries = 0; tries < SEND_TRIES; tries++) {
-      r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, final });
+      r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, pcm24, final });
       if (r && r.ok) return;
       if (r && (r.status === 409 || r.status === 404)) break;   // the server refused this note's audio: sending again changes nothing
       if (tries + 1 < SEND_TRIES) await new Promise((res) => setTimeout(res, SEND_BACKOFF_MS * 3 ** tries));
@@ -656,7 +664,10 @@ async function stopAudio(ctx, { discard = false } = {}) {
   try { if (a.ctx) await a.ctx.close(); } catch { /* closed */ }
   if (discard) { ctx.setState({}); return; }
   // the rest of what was said, then the summary once the last line is transcribed
-  for (const k of a.sources) { const tail = a.rs[k] ? a.rs[k].flush() : []; const b = a.buf[k]; for (let i = 0; i < tail.length; i++) b.push(tail[i]); }
+  for (const k of a.sources) {
+    const tail = a.rs[k] ? a.rs[k].flush() : []; const b = a.buf[k]; for (let i = 0; i < tail.length; i++) b.push(tail[i]);
+    const tail24 = a.rs24[k] ? a.rs24[k].flush() : []; const b24 = a.buf24[k]; for (let i = 0; i < tail24.length; i++) b24.push(tail24[i]);
+  }
   await Promise.all(a.sources.map((k) => sendChunk(ctx, a, k, true)));
   await pmPost('/api/notes/pause', { id: a.id });
   ctx.setState({});

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

@@ -1,12 +1,13 @@
 {
-  "_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).",
+  "_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) and the 24 kHz replay (notes-hires.test.js, Run 4), 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-echo.test.js",
-    "notes-polish.test.js"
+    "notes-polish.test.js",
+    "notes-hires.test.js"
   ],
   "panels": [
     "pm-notes-test.js",
@@ -20,6 +21,7 @@
     "notes-qwen.test.js": 4,
     "pm-note-dock-test.js": 20,
     "notes-echo.test.js": 25,
-    "notes-polish.test.js": 3
+    "notes-polish.test.js": 3,
+    "notes-hires.test.js": 10
   }
 }