create-pmos 0.110.0 → 0.111.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.110.0",
+  "version": "0.111.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@83b40d1
+kernel-source: pmos@2e6cfaa
 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-08T04:20:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 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-08T04:20:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 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-08T04:20:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -26,6 +26,9 @@ The Notes view shows one meeting, top to bottom. A bar at the top shows whether
 2. Press **Start**. The header shows a red dot, the time, and the sources. Tell people that you are taking notes.
 3. Each line shows in the transcript a few seconds after it is said, with who said it, the time and its label. Your lines are **You**. The meeting's lines are **Meeting**: click the name to change it. The transcript cannot tell the people in the meeting apart.
 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.
 
 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.
 
@@ -123,6 +126,8 @@ 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.
 
+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.
+
 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

package/workspace/lib/notes-audio.js

@@ -50,8 +50,21 @@ function setKeep(runtimeDir, keep) {
   return { ok: true, keep };
 }
 
-/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. 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 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
+// are limited and not hard-clipped. It has no memory, so the order in which the two sources arrive does not matter.
+const KNEE = 0.7 * 32768;
+const CEILING = 0.98 * 32768;
+function softLimit(x) {
+  const a = Math.abs(x);
+  if (a <= KNEE) return x;
+  const y = KNEE + (CEILING - KNEE) * Math.tanh((a - KNEE) / (CEILING - KNEE));
+  return Math.round(x < 0 ? -y : y);
+}
+
+/** 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 }) {
   if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
   const f = fileOf(runtimeDir, id);
@@ -69,7 +82,7 @@ function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
       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(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
+      for (let i = 0; i < len; i += 2) out.writeInt16LE(softLimit(old.readInt16LE(i) + pcm.readInt16LE(i)), i);
       fs.writeSync(fd, out, 0, len, at);
     } finally { fs.closeSync(fd); }
   }
@@ -138,4 +151,4 @@ function serve(req, res, runtimeDir, id) {
   fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
 }
 
-module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };
+module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, softLimit, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.110.0",
+  "version": "0.111.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

@@ -0,0 +1,88 @@
+/* audio-capture.js — how the Notes view takes sound from the browser (notes-audio-quality Run 1, R4 and R6).
+ *
+ *   makeResampler(inRate)      a stateful low-pass resampler: push(float32 block) → Int16Array at 16 kHz, flush() → the tail
+ *   toInt16(input, inRate)     one block, whole: the same filter, run once. Pure.
+ *   openCapture(ac, src, sink, onBlock) → { mode, node }   an AudioWorklet that hands float32 blocks to onBlock;
+ *                              a ScriptProcessor does the same where the browser has no worklet
+ *
+ * WHY A FILTER. A context that cannot run at 16 kHz gives 44.1 or 48 kHz blocks. Averaging the samples under each output sample
+ * is a poor low-pass: sound above 8 kHz folds back into the speech band as a hiss. The windowed-sinc filter below cuts at 7.2 kHz and
+ * keeps its state between blocks, so a block edge leaves no click. At 16 kHz the samples pass through unchanged.
+ */
+export 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; };
+
+export 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;
+  };
+  const w = new Float64Array(2 * half + 2);
+  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));
+      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);
+    },
+  };
+}
+
+/** Float samples at `inRate` as 16 kHz 16-bit samples. Pure. */
+export function toInt16(input, inRate) {
+  const r = makeResampler(inRate);
+  const a = r.push(input); const b = r.flush();
+  const out = new Int16Array(a.length + b.length); out.set(a); out.set(b, a.length);
+  return out;
+}
+
+/** Take blocks of the first channel from `src` and give each to onBlock as a Float32Array. `sink` is a muted node that keeps the
+ * graph pulling. Returns { mode: 'worklet' | 'script', node }. */
+export async function openCapture(ac, src, sink, onBlock) {
+  if (ac.audioWorklet && typeof AudioWorkletNode === 'function') {
+    try {
+      await ac.audioWorklet.addModule(new URL('./notes-capture-worklet.js', import.meta.url).href);
+      const node = new AudioWorkletNode(ac, 'notes-capture', { numberOfInputs: 1, numberOfOutputs: 1, channelCount: 1, channelCountMode: 'explicit' });
+      node.port.onmessage = (e) => onBlock(e.data);
+      src.connect(node); node.connect(sink);
+      return { mode: 'worklet', node };
+    } catch { /* the module did not load: the older route below */ }
+  }
+  const node = ac.createScriptProcessor(4096, 1, 1);
+  node.onaudioprocess = (e) => onBlock(new Float32Array(e.inputBuffer.getChannelData(0)));
+  src.connect(node); node.connect(sink);
+  return { mode: 'script', node };
+}

package/workspace/public/pm/notes-capture-worklet.js

@@ -0,0 +1,15 @@
+/* notes-capture-worklet.js — runs on the audio thread (notes-audio-quality R4). It copies the first channel of what it hears into
+ * blocks of 2048 samples and posts each block to the page, which resamples and sends it. It makes no sound. */
+class NotesCapture extends AudioWorkletProcessor {
+  constructor() { super(); this.block = new Float32Array(2048); this.at = 0; }
+  process(inputs) {
+    const ch = inputs[0] && inputs[0][0];
+    if (!ch) return true;
+    for (let i = 0; i < ch.length; i++) {
+      this.block[this.at++] = ch[i];
+      if (this.at === this.block.length) { this.port.postMessage(this.block, [this.block.buffer]); this.block = new Float32Array(2048); this.at = 0; }
+    }
+    return true;
+  }
+}
+registerProcessor('notes-capture', NotesCapture);

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

@@ -45,12 +45,15 @@ import { pmGet, pmPost } from './http.js';
 import { mdRender } from './markdown.js';
 import { icon } from './icons.js';
 import { button, iconButton, field, row, sheet, empty, menu, toast, ensureComponentsCss } from './primitives.js';
+import { toInt16, makeResampler, openCapture } from './audio-capture.js';
 
 const SAVE_MS = 700;          // a pause this long in typing saves the note
 const POLL_MS = 1500;         // while listening, and until the last line is labelled, the note is read this often
 const AGENT_POLL_MS = 3000;
 const CHUNK_SAMPLES = 16000;  // one second at 16 kHz
 const RATE = 16000;
+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']];
 
 /* ── module state: survives the redraw every setState causes ─────────────────────────────── */
@@ -194,19 +197,8 @@ export function noteMarkdown(n) {
   if ((n.transcript || []).length) out.push('## Transcript', '', ...n.transcript.map((x) => '[' + fmtTime(x.t) + '] ' + speakerOf(n, x.source) + ': ' + x.text + tagWords(x)), '');
   return out.join('\n');
 }
-/** Float samples at `inRate` as 16 kHz 16-bit samples. Each output sample averages the input samples it covers. Pure. */
-export function toInt16(input, inRate) {
-  const ratio = inRate / RATE;
-  const n = Math.floor(input.length / ratio);
-  const out = new Int16Array(n);
-  for (let i = 0; i < n; i++) {
-    const a = Math.floor(i * ratio); const b = Math.max(a + 1, Math.floor((i + 1) * ratio));
-    let s = 0; for (let k = a; k < b && k < input.length; k++) s += input[k];
-    const v = Math.max(-1, Math.min(1, s / (b - a)));
-    out[i] = v < 0 ? v * 0x8000 : v * 0x7fff;
-  }
-  return out;
-}
+/** Float samples at `inRate` as 16 kHz 16-bit samples, through a low-pass filter (pm/audio-capture.js). Pure. */
+export { toInt16 };
 function b64(int16) {
   const u = new Uint8Array(int16.buffer, int16.byteOffset, int16.byteLength);
   let s = '';
@@ -581,7 +573,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: {}, ended: 0 };
+  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 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))) {
@@ -603,14 +595,13 @@ async function startAudio(ctx, n, want) {
   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 proc = ac.createScriptProcessor(4096, 1, 1);
-    proc.onaudioprocess = (e) => {
+    const rs = a.rs[kind] = makeResampler(ac.sampleRate);
+    await openCapture(ac, src, sink, (block) => {
       if (audio !== a) return;
-      const s = toInt16(e.inputBuffer.getChannelData(0), ac.sampleRate);
+      const s = rs.push(block);
       const b = a.buf[kind]; for (let i = 0; i < s.length; i++) b.push(s[i]);
       if (b.length >= CHUNK_SAMPLES) sendChunk(ctx, a, kind, false);
-    };
-    src.connect(proc); proc.connect(sink);
+    });
     for (const t of stream.getTracks()) t.addEventListener('ended', () => { if (audio !== a) return; a.ended++; if (a.ended >= a.streams.length) stopAudio(ctx); });
   }
   a.state = 'on';
@@ -621,9 +612,23 @@ 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 seconds = b.length / RATE;
   a.queue[kind] = a.queue[kind].then(async () => {
-    const r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, final });
-    if (r && !r.ok && (r.status === 409 || r.status === 404) && audio === a) { banner = { tone: 'bad', text: 'Listening stopped: ' + r.error + '.' }; stopAudio(ctx); }
+    let r = null;
+    for (let tries = 0; tries < SEND_TRIES; tries++) {
+      r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, 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));
+    }
+    if (r && (r.status === 409 || r.status === 404)) {
+      if (audio === a) { banner = { tone: 'bad', text: 'Listening stopped: ' + r.error + '.' }; stopAudio(ctx); }
+      return;
+    }
+    a.lost += seconds;   // not silent: the recording has a gap, and the PM is told how long
+    banner = { tone: 'bad', text: 'About ' + Math.max(1, Math.round(a.lost)) + ' s of the recording was not saved, because the workspace server did not take it'
+      + (r && r.error ? ' (' + r.error + ')' : '') + '.' + (audio === a ? ' Listening goes on.' : '') };
+    ctx.setState({});
   }).catch(() => {});
   return a.queue[kind];
 }
@@ -636,6 +641,7 @@ 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]); }
   await Promise.all(a.sources.map((k) => sendChunk(ctx, a, k, true)));
   await pmPost('/api/notes/pause', { id: a.id });
   ctx.setState({});