create-pmos 0.115.0 → 0.117.0

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.117.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.115.0",
+      "version": "0.117.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.117.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/components.css

@@ -3499,6 +3499,7 @@
 .td-day__ts[data-step-state="done"] .td-day__seg { background: currentColor; }
 .td-day__ts[data-step-state="now"] .td-day__seg { background: var(--foreground); animation: td-day-pulse 1.2s infinite; }
 @media (prefers-reduced-motion: reduce) { .td-day__ts[data-step-state="now"] .td-day__seg { animation: none; } }
+.td-day__spacer { flex: 1 1 0; align-self: stretch; min-width: 0; }
 .td-day__status { flex: 1 1 0; min-width: 80px; text-align: right; font-size: 12px; color: var(--muted-foreground); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .td-day__check { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--muted-foreground); }
 .td-day__run { margin: 0; font-size: 12px; line-height: 16px; color: var(--foreground); }
@@ -3549,6 +3550,19 @@
 .td-day__group { display: grid; gap: 2px; }
 .td-day__newdot { display: inline-block; flex: none; width: 7px; height: 7px; border-radius: 50%; background: var(--warning); }
 .td-day__chip { min-width: 84px; padding: 3px 8px; font: 500 11px/1.2 var(--mono); text-align: center; background: var(--muted); color: var(--foreground); }
+/* a mention drawn as a card of its source (initiative today-goals-jobs, PRD M1): layout only, no brand colour */
+.td-day__mc { display: grid; gap: 4px; min-width: 0; text-align: left; font-weight: 400; }
+.td-day__mc > span { display: block; min-width: 0; }
+.td-day__mc-head { display: inline-flex; align-items: center; gap: 6px; font: 11px var(--mono); letter-spacing: 0.04em; color: var(--muted-foreground); }
+.td-day__mc-main { display: flex; align-items: flex-start; gap: 8px; }
+.td-day__av { display: grid; place-items: center; flex: none; width: 32px; height: 32px; background: var(--muted); color: var(--foreground); font: 600 12px var(--mono); }
+.td-day__mc-col { display: grid; gap: 2px; min-width: 0; }
+.td-day__mc-name { font-size: 14px; line-height: 20px; font-weight: 600; color: var(--foreground); }
+.td-day__mc-time { margin-left: 6px; font: 12px var(--mono); color: var(--muted-foreground); }
+.td-day__mc-text { font-size: 14px; line-height: 20px; color: var(--foreground); overflow-wrap: anywhere; }
+.td-day__mc-quote { padding: 2px 8px; border-left: 3px solid var(--border); font-size: 12px; line-height: 16px; color: var(--muted-foreground); overflow-wrap: anywhere; }
+.td-day__mc-frame { display: grid; place-items: center; flex: none; width: 64px; height: 44px; border: 1px solid var(--border); background: var(--muted); color: var(--foreground); }
+.td-day__mcbox { padding: 8px; border: 1px solid var(--border); }
 
 /* the detail */
 .td-day__dhead { display: grid; gap: 4px; }
@@ -3659,33 +3673,32 @@
 /* the Agenda month (today-agenda.js, G25 to G27): weeks of 8 columns, the week number and seven day cells */
 .td-ag__mhead { display: flex; align-items: center; gap: 6px; }
 .td-ag__mlabel { min-width: 120px; font-size: 14px; text-align: center; color: var(--foreground); }
-.td-ag__lens { flex-wrap: wrap; max-width: 100%; }
+.td-ag__bar { display: flex; align-items: center; gap: 8px; }
+.td-ag__month { display: grid; gap: 6px; width: 100%; min-width: 0; }
 .td-ag__grid { display: grid; gap: 2px; }
 .td-ag__wk { display: grid; grid-template-columns: 36px repeat(7, minmax(0, 1fr)); gap: 2px; }
 .td-ag__wk--head { font: 11px var(--mono); color: var(--muted-foreground); text-transform: uppercase; }
 .td-ag__wd { padding: 0 4px; }
-.td-day .td-ag__wno { height: auto; min-height: 64px; padding: 0; font: 11px var(--mono); letter-spacing: 0; color: var(--muted-foreground); }
+.td-day .td-ag__wno { height: auto; min-height: 44px; padding: 0; font: 11px var(--mono); letter-spacing: 0; color: var(--muted-foreground); }
 .td-day .td-ag__wno[aria-pressed="true"] { background: var(--accent); color: var(--foreground); border-color: var(--ring); }
 .td-day .td-ag__cell {
-  display: grid; align-items: start; justify-content: stretch; height: auto; min-height: 64px; padding: 4px;
+  display: grid; align-items: start; justify-content: stretch; height: auto; min-height: 44px; padding: 4px;
   border: 1px solid var(--border); background: var(--background); text-align: left; text-transform: none; letter-spacing: 0;
   font-weight: 400; white-space: normal;
 }
+.td-day .td-ag__cell[data-load="1"] { background: color-mix(in oklab, var(--background) 85%, var(--ring)); }
+.td-day .td-ag__cell[data-load="2"] { background: color-mix(in oklab, var(--background) 65%, var(--ring)); }
+.td-day .td-ag__cell[data-load="3"] { background: color-mix(in oklab, var(--background) 40%, var(--ring)); }
 .td-day .td-ag__cell[data-out="true"] { opacity: 0.45; }
 .td-day .td-ag__cell[data-weekend="true"] { background: var(--muted); }
 .td-day .td-ag__cell[data-today="true"] { border: 2px solid var(--foreground); }
 .td-day .td-ag__cell[aria-pressed="true"] { background: var(--accent); border-color: var(--ring); }
 .td-day .td-ag__cell[data-lit="true"] { box-shadow: inset 0 0 0 2px var(--warning); }
-.td-ag__in { display: grid; gap: 3px; min-width: 0; }
+.td-ag__in { display: flex; align-items: center; justify-content: space-between; gap: 3px; min-width: 0; width: 100%; }
+.td-ag__star { font-size: 12px; line-height: 16px; color: var(--foreground); }
 .td-ag__num { font: 12px var(--mono); color: var(--foreground); font-variant-numeric: tabular-nums; }
 .td-ag__cell[data-past="true"] .td-ag__num { color: var(--muted-foreground); }
-.td-ag__strip { position: relative; height: 6px; background: var(--muted); }
-.td-ag__blk { position: absolute; top: 0; bottom: 0; left: var(--td-ag-l, 0); width: var(--td-ag-w, 0); background: var(--muted-foreground); }
-.td-ag__blk--imp { background: var(--foreground); }
-.td-ag__blk--free { background: var(--ring); }
-.td-ag__key, .td-ag__meta, .td-ag__nonotes { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 11px; line-height: 14px; }
-.td-ag__key { font-weight: 600; color: var(--foreground); }
-.td-ag__meta { color: var(--muted-foreground); }
+.td-ag__nonotes { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 11px; line-height: 14px; }
 .td-ag__nonotes { color: var(--warning); }
 .td-ag__ready { justify-self: start; padding: 0 4px; font: 11px/16px var(--mono); border: 1px solid var(--border); color: var(--foreground); }
 .td-ag__ready[data-ag-ready="warn"] { border-color: var(--warning); color: var(--warning); }
@@ -3714,6 +3727,21 @@
   margin: 0;
 }
 .td-goal__prep { display: inline-flex; align-items: center; gap: 8px; }
+/* goals own jobs (initiative today-goals-jobs): the square for who acts, the YOU and AGENT tags, a goal's context and jobs */
+.td-day__sq { display: inline-block; flex: none; width: 10px; height: 10px; border: 1.5px solid var(--foreground); }
+.td-day__sq[data-who="agent"] { background: var(--foreground); }
+.td-day__marks2 { display: inline-flex; align-items: center; gap: 6px; }
+.td-day__tag { display: inline-block; margin-left: 4px; padding: 0 4px; border: 1px solid currentColor; font: 600 10px/1.4 var(--mono); letter-spacing: 0.04em; vertical-align: middle; }
+.td-day__tag[data-who="agent"] { background: color-mix(in oklab, currentColor 18%, transparent); }
+.td-day__who2 { display: flex; align-items: center; gap: 8px; margin: 0; font-size: 14px; color: var(--foreground); }
+.td-day__jobmeta { display: grid; gap: 8px; padding: 10px 12px; border: 1px solid var(--border); background: var(--background); }
+.td-day__goaladd { display: grid; gap: 6px; }
+.td-goal__jobs { gap: 6px; }
+.td-goal__donewhen { margin: 0; font-size: 14px; color: var(--foreground); }
+.td-goal__ctxfields { display: grid; gap: 6px; }
+.td-goal__ctxfold { margin-top: 6px; }
+.td-goal__nogoal { margin-top: 12px; padding-top: 8px; border-top: 1px solid var(--border); }
+.td-goal__pick { display: block; min-width: 140px; max-width: 220px; }
 .td-card {
   display: flex;
   flex-direction: column;