create-pmos 0.64.0 → 0.65.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.64.0",
+  "version": "0.65.1",
   "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@2196dd0
-assembled: 2026-10-06
+kernel-source: pmos@5f54d4e
+assembled: 2026-10-07
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:49:12Z"}
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:49:12Z"}
 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-06T23:35:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T00:49:12Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-06
+## 2026-10-07
 
 - Adopted OKF v0.2 (D73).

package/workspace/guide/docs.md

@@ -1,6 +1,6 @@
 ---
 type: Guide
-title: "Docs: is each document the same as its Google Docs and Confluence copy, and which version to use"
+title: "Docs: every repository file by category, the files each one links to, and whether each copy in Google Docs or Confluence is the same"
 timestamp: 2026-10-06
 ---
 
@@ -8,15 +8,65 @@ timestamp: 2026-10-06
 
 Open Docs from the top bar, from ⌘K (**Docs**), or press `g d`.
 
-Docs lists every document in the repository that has a copy in Google Docs or Confluence. For each copy, it shows whether the repository version (PMOS) or the copy is newer. You can then use one version over the other, one copy at a time.
+Docs lists every markdown file in the repository by category. For each file, it shows the files that it links to and the files that link to it. For each document that has a copy in Google Docs or Confluence, it shows whether the repository version (PMOS) or the copy is newer. You can then use one version over the other, one copy at a time.
 
 Nothing syncs by itself. A copy changes only when you press a button for that copy.
 
 ## The list
 
-The copies are grouped by initiative. Copies of files that no initiative owns are under **Other**.
+Docs has three views:
 
-**Needs you** shows the copies that are not the same. **All** shows every copy.
+- **Needs you** shows the copies that are not the same.
+- **With a copy** shows every copy.
+- **All files** shows every markdown file in the repository.
+
+The copies are grouped by category.
+
+## Categories
+
+The category of a file comes from its folder, then from its frontmatter `type`. You do not tag a file.
+
+| Category | Files |
+|---|---|
+| Specs | `planning/prd/`, or `type: PRD` |
+| Initiatives | `planning/initiatives/` |
+| Decisions | the ADR folder, `DECISIONS.md`, `pm-decisions.md` |
+| Research & plans | the other `planning/` folders |
+| Explainers | `planning/explainers/` |
+| Evals | `planning/evals/`, or `type: Rubric` |
+| Knowledge | the other `okf/` folders |
+| Guides & rules | all other files |
+| Prototypes | `prototype/` |
+
+## All files
+
+**All files** opens with one line for each category: its name, its number of files, and "N need you" when a copy in it is not the same. Press a category to open it. It shows its first 20 files: the files with a copy first, then the newest. Press **Show all** to see the rest.
+
+A file with no copy is one line: its title, the short name of its initiative (or its path when no initiative owns it), and the date of its last edit. **Add copy** shows when you point at the line, and always on a touch screen.
+
+## The links of a file
+
+Press a file in **All files** to see its links:
+
+- on the left, the files that link to it;
+- in the middle, the file;
+- on the right, the files that it links to.
+
+Each side shows at most 7 files. A dashed line is a decision that the file cites. Press a file in the graph to put it in the middle. Press **Back** to go back. **Open file** opens the file in the reader.
+
+**List all N links** lists every link in both directions, grouped by kind.
+
+A link counts only when a file writes it:
+
+- a markdown link to another file;
+- a path in the frontmatter, such as `prd_path`;
+- the `initiative_id` of the file;
+- the anchor (`parent_kr`);
+- a decision number, such as D65.
+
+PMOS does not guess a link from similar words. `pmos kg neighbors <path>` shows the same links in the terminal.
+
+On a phone the graph is not shown. The list is shown.
 
 Each copy is one line:
 
@@ -49,7 +99,8 @@ Click a line to see its details:
 - the copy: its address and its last edit;
 - a **Use … version** button for each side;
 - the first difference that the compare found, when it found one;
-- **Compare again** and **Stop tracking this copy**.
+- **Compare again** and **Stop tracking this copy**;
+- the links of the file, as in **All files**.
 
 **Stop tracking this copy** removes the link. The copy is not deleted. Press **Undo** in the message to link it again.
 
@@ -72,7 +123,9 @@ A compare runs only when you press it. There is no schedule. An edit to a reposi
 
 ## Add a copy
 
-Type in **Find a document**. The search finds every markdown file in the repository by its title or path, also files that have no copy. A file with no copy shows **No copy** and **Add copy**.
+Type in the search box. The search finds every markdown file in the repository by its title, its path or the name of its initiative, also files that have no copy. The results are grouped by category, and the match is marked. Press Esc to clear the search.
+
+Press **Add copy** on a file with no copy.
 
 Press **Add copy**, paste the address of the Google Doc or Confluence page, and press Enter. A document can have one Google Doc and one Confluence page.
 

package/workspace/guide/initiatives-screen.md

@@ -76,6 +76,14 @@ The Files tab lists every file that belongs to the initiative, in three groups:
 - **Linked documents.** The documents the library joins to the initiative: a document that declares its `initiative_id`, a document the record names, a file name that starts with the id.
 - **Changed for it in git.** The files that the commits for this initiative changed and that still exist. These are its own branch, trunk commits that name the id, and merged changes that carried its documents. The file opens read-only.
 
+**List · Graph** at the top of the tab changes the view. **List** shows the groups above. **Graph** shows the files of the initiative as a network:
+
+- a filled dot is a markdown file of the initiative: a file that the record names, or a linked document. Its label is its role, such as PRD, Rubric or Explainer;
+- a hollow dot is a file outside the initiative that one of its files links to, or that links to one of its files. A decision shows its number, such as D65;
+- a line is a link that a file writes. A dashed line is a decision that a file cites.
+
+The graph shows at most 14 outside files, the most-linked first. The legend says how many are left out. Press a dot to mark its lines and to see its title, its path and **Open file**. The same files and links always give the same picture. On a phone the list is shown.
+
 ### A breakdown read from the spec
 
 When nobody has planned items for an initiative, the Breakdown tab shows the items of its spec above the empty Breakdown: the user stories, or the entries of the Requirements section of the PRD that the record names. Each item shows the state of the whole initiative: **Done** after you accept it, **Built** when its build is on the trunk, and **Todo** before that. These items are read-only and nothing is written. To track an item, add it to the Breakdown. The card and the row show the same count, for example "0 of 8 · from board-delivery-truth-prd.md".

package/workspace/guide/notes.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Guide: notes"
-description: "How to take notes in a meeting: listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, and get a summary."
+description: "How to take notes in a meeting: listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, correct and tag lines, see what changed in your notes, replay the meeting, and get a summary."
 timestamp: 2026-10-06
 ---
 
@@ -28,9 +28,9 @@ The meeting can only be heard when local transcription is set up. Until then, **
 
 ## What is caught
 
-Each line gets a label: decision, action, question, topic, statement or small talk. Decisions, actions and questions go into their sections as they are said. After **Stop**, statements with a number go under **Facts mentioned**.
+Each line gets a label: decision, action, question, fact, topic, statement or small talk. Decisions, actions and questions go into their sections as they are said. After **Stop**, facts and statements with a number go under **Facts mentioned**.
 
-- To remove an item that does not belong, press the **x** beside it.
+- To remove an item that does not belong, press the **x** beside it. To take a line out of the summary, press the **x** beside it in the summary.
 - When a caught line is about something in the repository, the closest file shows beside it: **see** the file, a check mark when Jev finds that the file says the same, or **≠** the file when Jev finds that the line says something different. Point at the mark to see the file and the line.
 
 ## Set up local transcription
@@ -57,6 +57,35 @@ Without Jev, the workspace labels each line with its own rules and finds the clo
 
 With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Audio, speaker names and private notes never go. A line that looks like a secret is not sent.
 
+## Correct and tag a line
+
+1. In the transcript, press the **…** button on a line.
+2. Change what you need:
+   - **Words**: correct what was heard. The words that were heard are kept, the line shows **edited**, and **Use what was heard** puts them back.
+   - **Label**: decision, action, question, fact, topic, statement or small talk.
+   - **Summary**: **As picked**, **Always in the summary** or **Never in the summary**.
+   - **Tags**: words such as `#pricing #launch`.
+   - **People**: names, separated by commas. Press a name below the field to add a person from this repository.
+3. Press **Save**. The tags and people show on the line, on its item in your notes and under **Tagged**. **Copy as Markdown** includes them.
+
+## See what changed in your notes
+
+Each change to your notes keeps the text from before it. Changes within two minutes count as one. The first text you typed is always kept.
+
+1. When your notes have changed, the header shows **Edited**. Press it.
+2. **History** shows each version, newest first: the lines that were added and removed, and the original at the end.
+3. To go back, press **Use this version**. The text before it stays in **History**.
+
+## Replay the meeting
+
+When a meeting was heard with local transcription, its audio is kept on this machine.
+
+1. Open the note. **Replay** is above your notes. Press play.
+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.
+
+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.
+
 ## Dictate into your notes
 
 1. Put the cursor where the text must go, then press **Dictate** and speak.
@@ -66,13 +95,13 @@ With the switches on, each line goes to TypeSafe for its label. For a caught lin
 ## Copy, private and delete
 
 - **Copy as Markdown** puts the title, the summary, your notes, the caught items and the transcript on the clipboard.
-- In the settings, **Mark private** stops listening at once. A private note is not recorded again, and nothing from it goes to Jev or to an agent. **Mark not private** undoes it.
+- In the settings, **Mark private** stops listening at once and deletes the note's audio. A private note is not recorded again, and nothing from it goes to Jev or to an agent. **Mark not private** undoes it.
 - **Summary by agent** starts an agent session in the selected repository that writes a summary into the note. Lines that look like a secret are removed first.
-- **Delete** removes the note, its transcript and its summaries from this machine after you confirm. You cannot undo it.
+- **Delete** removes the note, its transcript, its summaries and its audio from this machine after you confirm. You cannot undo it.
 
 ## What stays on your machine
 
-- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes the file at once. The browser's own recognition is used only on the device, never in the cloud.
+- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes that file at once. For replay, the workspace keeps one recording of each note in `notes/recordings/` in the state folder, until you delete the audio, the note, or mark the note private. The browser's own recognition is used only on the device, never in the cloud.
 - Notes are files in the workspace's own folder on this machine (`notes/` in the state folder). They are never written into a repository.
 - Only Jev, with the switches on, and **Summary by agent**, when you press it, receive any text from a note.
 

package/workspace/lib/doc-library.js

@@ -0,0 +1,131 @@
+'use strict';
+/* doc-library.js — every tracked markdown file of a workspace, by category, with its initiative and the links between the
+ * files (initiative docs-library-graph, PRD R-L1 to R-L5).
+ *
+ * The links are the knowledge graph's (lib/kg.js through kg-cli `graphFor`): a markdown link, a path in the header, the
+ * initiative, the anchor, a decision number. Nothing is inferred from wording. A category is derived from where a file
+ * lives, then from its frontmatter type; it is never written into a file. The result is kept in memory per repository
+ * state (git HEAD plus the uncommitted markdown files), and the kg cache stays in the runtime state directory. Nothing
+ * here writes into the repository or reads the network.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const kgCli = require('./kg-cli');
+
+/* [key, name] in display order */
+const CATEGORIES = [
+  ['spec', 'Specs'], ['ini', 'Initiatives'], ['dec', 'Decisions'], ['res', 'Research & plans'], ['exp', 'Explainers'],
+  ['eval', 'Evals'], ['know', 'Knowledge'], ['guide', 'Guides & rules'], ['proto', 'Prototypes'],
+];
+/* the link kinds, in the order the client numbers them */
+const KINDS = ['link', 'header', 'initiative', 'anchor', 'cites'];
+
+const BY_TYPE = { prd: 'spec', initiative: 'ini', adr: 'dec', decision: 'dec', rubric: 'eval', eval: 'eval', verdict: 'eval', explainer: 'exp' };
+
+/** The category of one file: where it lives first, then its frontmatter type, then Guides & rules. */
+function categoryOf(rel, type) {
+  const p = String(rel || '');
+  if (/^prototype\//.test(p)) return 'proto';
+  if (/(^|\/)planning\/initiatives\//.test(p)) return 'ini';
+  if (/(^|\/)planning\/prd\//.test(p)) return 'spec';
+  if (/(^|\/)planning\/evals\//.test(p)) return 'eval';
+  if (/(^|\/)planning\/explainers\//.test(p)) return 'exp';
+  if (/^okf\/products\/[^/]+\/adr\//.test(p) || /^(DECISIONS|pm-decisions)\.md$/.test(p) || /(^|\/)planning\/decisions-/.test(p)) return 'dec';
+  if (/(^|\/)planning\//.test(p)) return 'res';
+  if (/^okf\//.test(p)) return 'know';
+  const t = String(type || '').trim().toLowerCase();
+  return BY_TYPE[t] || 'guide';
+}
+
+/** A short name for an initiative title: no "PRD:" prefix, the part before the first dash or colon, at most 44 characters. */
+function shortTitle(title) {
+  let t = String(title || '').trim();
+  t = t.replace(/^(PRD|Initiative|Chore|Spike|Prototype Brief|Discovery|Incident|Content brief|Feature)\s*(?:[:—–]|\s-\s)\s*/i, '');
+  t = t.split(/\s[—–]\s|:\s|\.\s/)[0].trim();
+  if (t.length > 44) { const cut = t.slice(0, 43); t = (cut.includes(' ') ? cut.replace(/\s+\S*$/, '') : cut) + '…'; }
+  return t ? t[0].toUpperCase() + t.slice(1) : '';
+}
+
+/** The kind of one kg edge, or null for a kind the library does not show. */
+function kindOf(e) {
+  if (e.type === 'link') return 'link';
+  if (e.type === 'initiative') return 'initiative';
+  if (e.type === 'anchor') return 'anchor';
+  if (e.type === 'cites') return e.typed ? 'header' : 'cites';
+  if (e.type === 'frontmatter' || e.type === 'supersedes' || e.type === 'amended_by') return 'header';
+  return null;
+}
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+
+/** path → YYYY-MM-DD of its last commit (one git log; merge commits are skipped, their changes are in their parents). */
+function commitDates(root) {
+  const out = new Map();
+  let text = '';
+  try { text = git(root, ['log', '--format=%x01%cs', '--name-only', '--', '*.md']); } catch { return out; }
+  let day = null;
+  for (const line of text.split('\n')) {
+    if (line.startsWith('\x01')) { day = line.slice(1); continue; }
+    if (line && day && !out.has(line)) out.set(line, day);
+  }
+  return out;
+}
+
+/** The uncommitted markdown files: their date is the file's own. */
+function dirtyPaths(root) {
+  try {
+    return new Set(git(root, ['status', '--porcelain', '-z', '--untracked-files=no']).split('\0').filter(Boolean)
+      .map((l) => l.slice(3)).filter((p) => /\.md$/.test(p)));
+  } catch { return new Set(); }
+}
+
+const cache = new Map();   // root -> { key, value }
+
+/**
+ * The library of one repository.
+ *   owners: () => Map path → { id, title } — the library's own attribution (server.js initiativeIndex), real initiatives
+ *   only. It is called only when the repository state changed, because the index reads every planning file.
+ * Returns { ok, files: [{path,title,category,date,initiative}], initiatives: {id: {title, short}}, kinds, edges: [[from, to, kind]], categories }.
+ * `from` and `to` index `files`; `kind` indexes `kinds`.
+ */
+function library(root, { stateDir, owners = () => new Map() } = {}) {
+  let key;
+  try { key = kgCli.cacheKey(root); } catch (e) { return { ok: false, error: 'this workspace is not a git repository, so there are no tracked files to list' }; }
+  const hit = cache.get(root);
+  if (hit && hit.key === key) return hit.value;
+  const { graph, unreadable } = kgCli.graphFor(root, stateDir ? { stateDir } : {});
+  let own = new Map();
+  try { own = owners() || new Map(); } catch { /* no attribution: every file has no initiative */ }
+  const dates = commitDates(root);
+  const dirty = dirtyPaths(root);
+  const dayOf = (rel) => {
+    if (!dirty.has(rel) && dates.has(rel)) return dates.get(rel);
+    try { return fs.statSync(path.join(root, rel)).mtime.toISOString().slice(0, 10); } catch { return dates.get(rel) || null; }
+  };
+  // An initiative is named by its record's title (planning/initiatives/<id>.md), else by the index's title for it.
+  const titleOf = new Map(graph.nodes.map((n) => [n.id, n.title]));
+  const named = (o) => String(titleOf.get(`planning/initiatives/${o.id}.md`) || o.title || o.id);
+  const initiatives = {};
+  const files = graph.nodes.map((n) => {
+    const o = own.get(n.id) || null;
+    if (o && !initiatives[o.id]) initiatives[o.id] = { title: named(o), short: shortTitle(named(o)) };
+    return { path: n.id, title: String(n.title || n.id), category: categoryOf(n.id, n.type), date: dayOf(n.id), initiative: o ? o.id : null };
+  });
+  const index = new Map(files.map((f, i) => [f.path, i]));
+  const seen = new Set();
+  const edges = [];
+  for (const e of graph.edges) {
+    const k = kindOf(e);
+    if (!k || e.from === e.to || !index.has(e.from) || !index.has(e.to)) continue;
+    const a = index.get(e.from); const b = index.get(e.to); const ki = KINDS.indexOf(k);
+    const id = a + '|' + b + '|' + ki;
+    if (seen.has(id)) continue;
+    seen.add(id); edges.push([a, b, ki]);
+  }
+  const value = { ok: true, key, files, initiatives, kinds: KINDS, edges, categories: CATEGORIES.map(([k, name]) => ({ key: k, name })), unreadable: unreadable || [] };
+  cache.set(root, { key, value });
+  return value;
+}
+
+module.exports = { CATEGORIES, KINDS, categoryOf, shortTitle, kindOf, library, commitDates };

package/workspace/lib/notes-audio.js

@@ -0,0 +1,111 @@
+'use strict';
+/* notes-audio.js — the meeting audio a note keeps for replay (meeting-notes Run 3, D92). Local only.
+ *
+ *   write(runtimeDir, { id, source, pcm, t })   add one chunk of 16 kHz mono 16-bit samples at meeting time t (ms)
+ *   info(runtimeDir, id) → { bytes, ms } | null
+ *   remove(runtimeDir, id)                      delete the note's audio
+ *   serve(req, res, runtimeDir, id)             the audio as a WAV file, with byte ranges so the page can seek
+ *   getKeep(runtimeDir) · setKeep(runtimeDir, bool)   "Keep the audio for replay", on by default, for this machine
+ *
+ * WHAT IT KEEPS. One file per note, `<runtime>/notes/recordings/<id>.pcm`: raw samples with no header, sample k at
+ * k / 16000 seconds after the note's first Listen. The microphone and the meeting are added into the same samples, so the
+ * file is the meeting as the PM heard it. A chunk is placed straight after the previous chunk of its source when it
+ * arrives on time or early, so the small jitter of the page's timer leaves no clicks; a chunk that arrives much later (Listen again)
+ * is placed at its own time, and the gap stays silent.
+ *
+ * WHAT IT NEVER DOES. It sends nothing and opens no network module. The routes (lib/routes-notes.js) write nothing for a
+ * private note, delete the file when a note is made private or deleted, and write nothing when the PM switches keeping off.
+ */
+const fs = require('fs');
+const path = require('path');
+
+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 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 settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'audio-settings.json');
+const next = new Map();                     // `${file}|${source}` → the byte offset where that source's last chunk ended
+
+function getKeep(runtimeDir) {
+  try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s.keep !== false; } catch { return true; }
+}
+function setKeep(runtimeDir, keep) {
+  if (typeof keep !== 'boolean') return { ok: false, error: 'say keep: true or keep: false' };
+  const f = settingsFile(runtimeDir);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify({ keep }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+  return { ok: true, keep };
+}
+
+/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. */
+function write(runtimeDir, { id, source, pcm, t }) {
+  if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
+  const f = fileOf(runtimeDir, id);
+  const key = f + '|' + source;
+  let at = Math.max(0, Math.round((Number(t) || 0) * BYTES_PER_MS / 2) * 2);
+  const prev = next.get(key);
+  // a source never overlaps itself: a chunk that would start before its source left off, or just after, goes straight after it
+  if (prev !== undefined && at <= prev + ON_TIME_MS * BYTES_PER_MS) at = prev;
+  if (at >= MAX_BYTES) return { ok: true, kept: false };
+  const len = Math.min(pcm.length, MAX_BYTES - at);
+  fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
+  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(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
+    fs.writeSync(fd, out, 0, len, at);
+  } finally { fs.closeSync(fd); }
+  next.set(key, at + len);
+  return { ok: true, kept: true, at_ms: at / BYTES_PER_MS };
+}
+
+function info(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; }
+}
+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);
+  try { fs.unlinkSync(fileOf(runtimeDir, id)); return true; } catch { return false; }
+}
+
+function wavHeader(dataBytes) {
+  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.write('data', 36); h.writeUInt32LE(dataBytes, 40);
+  return h;
+}
+/** The audio as audio/wav. A `Range: bytes=a-b` request gets 206 with that part, which is how the page seeks. */
+function serve(req, res, runtimeDir, id) {
+  const inf = info(runtimeDir, id);
+  if (!inf) { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: 'this note has no audio' })); return; }
+  const header = wavHeader(inf.bytes);
+  const total = header.length + inf.bytes;
+  let start = 0; let end = total - 1; let partial = false;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range || '').trim());
+  if (m && (m[1] || m[2])) {
+    if (m[1]) { start = Number(m[1]); if (m[2]) end = Math.min(total - 1, Number(m[2])); }
+    else { start = Math.max(0, total - Number(m[2])); }
+    if (start > end || start >= total) { res.writeHead(416, { 'Content-Range': 'bytes */' + total }); res.end(); return; }
+    partial = true;
+  }
+  res.writeHead(partial ? 206 : 200, { 'Content-Type': 'audio/wav', 'Accept-Ranges': 'bytes', 'Content-Length': end - start + 1, 'Cache-Control': 'no-store',
+    ...(partial ? { 'Content-Range': 'bytes ' + start + '-' + end + '/' + total } : {}) });
+  if (req.method === 'HEAD') { res.end(); return; }
+  if (start < header.length) res.write(header.subarray(start, Math.min(header.length, end + 1)));
+  const from = Math.max(0, start - header.length); const to = end - header.length;
+  if (to < from) { res.end(); return; }
+  fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
+}
+
+module.exports = { write, info, remove, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };