create-pmos 0.132.0 → 0.134.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.132.0",
+  "version": "0.134.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@b177828
+kernel-source: pmos@d509552
 assembled: 2026-10-11
 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-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 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-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 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-11T04:03:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T08:10:43Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -188,6 +188,7 @@ function ensureInstalled() {
 // Register the target directory and open the browser ON IT. The `focus` broadcast matters:
 // the OS may refocus an already-open tab instead of opening our URL, and without it the PM
 // would be looking at the previously-opened repo — the defect this replaces.
+let FORCE_WELCOME = false; // `pmos welcome [path]`
 async function openWorkspace(dir, port, { open = true } = {}) {
   const root = repoRootOf(dir);
   const reg = await api(port, 'POST', '/api/workspaces', { root, name: path.basename(root) });
@@ -199,7 +200,17 @@ async function openWorkspace(dir, port, { open = true } = {}) {
   const w = reg.workspace;
   say(`✓ workspace “${w.name}” — ${urlOf(port)}?ws=${w.id}`);
   say(`  ${root}`);
-  if (open) openBrowser(`${urlOf(port)}?ws=${w.id}`);
+  // First run (onboarding-scan-and-map): a plain folder PMOS has never imported opens on Welcome (the route's first_run);
+  // `pmos welcome` opens it on purpose. Any failure keeps the old URL.
+  let first = FORCE_WELCOME;
+  if (!first) {
+    try {
+      const st = await api(port, 'GET', `/api/onboarding/status?ws=${encodeURIComponent(w.id)}`);
+      first = !!(st && st.ok && st.first_run);
+    } catch { first = false; }
+  }
+  if (first) say(FORCE_WELCOME ? '✓ opening Welcome' : '✓ first run — opening Welcome');
+  if (open) openBrowser(first ? `${urlOf(port)}/welcome?ws=${w.id}` : `${urlOf(port)}?ws=${w.id}`);
   return 0;
 }
 
@@ -511,9 +522,10 @@ function doctor() {
     if (r.error) { say('✗ could not run ' + npx + ' — ' + r.error.message); code = 1; }
     else code = r.status === null ? 1 : r.status;
   } else if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
-    say('usage: pmos [<path>|status|ls|stop|doctor|phone|upgrade|schedule|skill|proactive|kg|item|' + require('../lib/pmos-verbs.js').names().join('|') + ']');
+    say('usage: pmos [<path>|welcome|status|ls|stop|doctor|phone|upgrade|schedule|skill|proactive|kg|item|' + require('../lib/pmos-verbs.js').names().join('|') + ']');
     say('  pmos          open the current repo as a workspace (starts the server if needed)');
     say('  pmos <path>   open another repo as a workspace');
+    say('  pmos welcome [<path>]  scan a folder and bring its products and initiatives into PMOS (undoable)');
     say('  pmos phone    turn on phone access over Tailscale and show the QR code to scan');
     say('  pmos schedule …  create, edit and run scheduled tasks (pmos schedule --help)');
     say('  pmos skill …     list, read, create and edit skills');
@@ -523,6 +535,10 @@ function doctor() {
     for (const line of require('../lib/pmos-verbs.js').helpLines()) say(line);
     say('  pmos upgrade  reinstall the workspace app from the latest published create-pmos');
     code = 0;
+  } else if (cmd === 'welcome') {
+    // the first-run page on purpose: scan this folder, import it, or undo an import (onboarding-scan-and-map)
+    FORCE_WELCOME = true;
+    code = await up(process.argv[3] && !process.argv[3].startsWith('-') ? path.resolve(process.argv[3]) : process.cwd());
   } else if (cmd === 'up' || cmd === 'start' || cmd === 'open') {
     // `pmos open ../other-repo` — the path is the argument AFTER the verb
     code = await up(process.argv[3] && !process.argv[3].startsWith('-') ? path.resolve(process.argv[3]) : process.cwd());

package/workspace/guide/index.md

@@ -39,6 +39,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 
 ## Where to read next
 
+- [Welcome (first run)](welcome.md): scan a new folder, review the proposed portfolio, import it and undo it.
 - [The Briefing](briefing.md): the console's first page: Today's meetings, Needs you (Done, Not yet, Drop) and the Portfolio pulse.
 - [Start the workspace without a terminal](launcher.md): the PMOS app, the login item and `pmos launcher`.
 - [Jira tickets](jira.md): Jira tickets drafted from the PRD, pushed when you select them, and their status.

package/workspace/guide/notes.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: notes"
 description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, decisions with their why and who, next steps with an open question, a discussion paragraph, and Wispr Flow's notes merged in and fetched by hand when the fetch fails; 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 for conflicts, capture highlights during the meeting, create tasks from next steps, correct and tag lines, see what changed in your notes, replay the meeting, link a note to its meeting and its initiative, and get a summary."
-timestamp: 2026-10-08
+timestamp: 2026-10-11
 ---
 
 # Guide: notes
@@ -20,6 +20,24 @@ The Record control is at the right of the top bar. It has two groups, always in
 
 Starting a note, from the Record control or from **Take notes** on a calendar event, shows the Notes page with that note.
 
+### The Record control in the console
+
+The console (the page at `/c3.html`) has the same Record control in its top bar, beside the Sessions button. It is always there, also when nothing is recording. **Record** (the microphone) starts an untitled note and listens at once. The arrow lists the meetings of today that have not started. Press one to start a note linked to that calendar event. While a meeting records, the red group shows its name and clock, **Highlight**, **Pause** and **Stop**. While it is paused, the group shows **Resume** and **Stop**. **Stop** asks first and offers **Pause instead**. A red dot shows on the Calendar tab while a meeting is held. The console has no Notes page, so the name in the red group opens the note in the main app.
+
+When Whisper or Qwen3-ASR transcribes the meeting, the red group also names the engine and the language, for example **Whisper · English**. Check it when lines come out in the wrong language: the language is set in the Notes settings.
+
+One meeting records in one tab at a time. If another tab or window already records the meeting, **Record** there says so and starts nothing.
+
+
+## What the live transcript leaves out
+
+The live transcript keeps each sentence once:
+
+- When the meeting plays on your speakers, your microphone hears the other people too. PMOS takes their words out of your microphone's line, and keeps the line from the meeting. Your own words stay.
+- A line that only repeats the line before it is left out. A sentence said twice in a row in one line is kept once.
+- If the meeting language is English (the default), a line that comes back in another language, for example Hindi, Indonesian or Chinese, is transcribed again in English. The first text stays with the line.
+- If the workspace restarts during a meeting, the recording continues where it was. Nothing is written twice.
+
 ## Pause, resume and stop
 
 **Pause** keeps the meeting open. PMOS stops listening and the clock stops. It does not ask, and it does not write the final notes yet. You can resume for one hour. The top bar shows the minutes left. After an hour the meeting ends by itself, and PMOS writes its final notes.

package/workspace/guide/welcome.md

@@ -0,0 +1,38 @@
+---
+type: Guide
+title: "Guide: Welcome (first run)"
+timestamp: 2026-10-11
+---
+
+# Welcome (first run)
+
+The Welcome page is the first screen of a new folder. It reads your folder, shows what it found, and sets up your portfolio from it. You do not need to answer questions first.
+
+## How you get there
+
+Run `pmos` in a plain folder that PMOS has not imported. The terminal says "first run — opening Welcome" and the browser opens `/welcome`. A folder that already has its own PMOS state folder opens the console as before. After an import, `pmos` opens the console.
+
+Run `pmos welcome` to open the page on purpose, for example to scan a folder again or to undo an import. `pmos welcome <path>` opens it for another folder.
+
+Choose **Not now** on the first screen to go to the console. Welcome then stops opening on its own for that folder. `pmos welcome` still opens it.
+
+## The promise
+
+The page says it before the scan: PMOS reads only, writes nothing in your folder, and nothing leaves this computer. The scan runs on your machine and uses no model. The import is stored in the PMOS state folder, never in your folder.
+
+## The steps
+
+1. **Welcome.** The page shows the folder name and path. Choose **Add another folder** to open the system folder chooser and add a second folder. Choose **Scan** to start. A spinner shows while the scan runs. A large folder can take a minute or two, and the rest of PMOS keeps working.
+2. **First look.** One sentence gives the counts: initiatives, documents, deadlines, stale documents, duplicates, people and risks. Up to ten findings follow. Each finding shows the file and line it comes from. Choose **Continue**.
+3. **Your portfolio.** PMOS proposes one board for each product folder (`products/<name>/`). If there is no product folder, it proposes one board for the whole folder. Each board lists its initiatives. Each row has a checkbox, a title you can edit, a lane, an anchor, a stage and a document count. Choose the document count to see the documents. Use the board list on a row to move it to another board. Each board shows how many documents PMOS could not place. High and medium confidence rows start checked. The button reads **Import N initiatives into M boards**. The numbers change as you check, uncheck and move rows.
+4. **Questions.** This step appears only when the scan could not decide something. There are three questions at most. Each question shows its default already chosen. Choose **Import** to accept what is chosen. Choose **Skip** to leave a question open: for the anchor question, the proposed anchors then stay marked for you to confirm later.
+5. **First Briefing.** After the import, the page lists up to five things that need you first. An item that belongs to an imported initiative names the initiative and its board. Choose **Continue**. Choose **Undo this import** to take the import back and return to your portfolio.
+6. **More sources.** This step is optional. It offers Calendar (your meetings today and for the next 14 days) and Jira (the issues assigned to you). PMOS reads nothing from them until you choose **Bring in**. Bring in starts the source's read-only skill as an agent session in the workspace, with your own connection. The skill writes nothing to the tool. Choose **Skip** to leave a source out. You can bring it in later from Settings. Inbox and Slack have no import yet. Choose **Open PMOS** to go to the console.
+
+## Undo
+
+**Undo this import** retracts the import. Nothing is deleted: the import and its undo stay in the record. You can then change the portfolio and import again. When you open Welcome after an import, the page shows the first Briefing with the Undo link.
+
+## What the page does not do
+
+The page does not change your folder. It does not open the files that the exclusion list names, such as `.git`, `node_modules` and files that look like secrets. It does not read Calendar or Jira until you choose **Bring in** on More sources, and the PMOS server itself calls nothing outside this computer. It does not import from Drive, Inbox, Slack or other tools.

package/workspace/lib/import-overlay.js

@@ -0,0 +1,32 @@
+'use strict';
+/* import-overlay.js: where a workspace's first-run import lives, and the fold of it (slice 2 of onboarding-scan-and-map).
+ *   overlayDir(stateRoot, wsId) = <stateRoot>/imports/<wsId>      overlayDirFor is the same function
+ *   importedFor(stateRoot, wsId) -> { boards, initiatives, imports } from scripts/onboarding/apply.js; empty shapes when nothing is there.
+ * Initiative rows carry import_id and source: 'import'; board rows too. Never throws on a missing folder or file. */
+const fs = require('fs');
+const path = require('path');
+
+/** Where scripts/onboarding/ is: the checkout's own, else the copy an installed package vendors under lib/vendor/
+ * (scripts/vendor-workspace-engine.js vendorTree). Null when neither is there. */
+function onboardingDir() {
+  for (const d of [path.join(__dirname, '..', '..', 'scripts', 'onboarding'), path.join(__dirname, 'vendor', 'scripts', 'onboarding')]) {
+    if (fs.existsSync(path.join(d, 'scan.js'))) return d;
+  }
+  return null;
+}
+
+const WS_ID = /^[A-Za-z0-9_-]{1,64}$/; // one safe path segment (server ids are 10 hex characters)
+const empty = () => ({ boards: [], initiatives: [], imports: [] });
+
+function overlayDir(stateRoot, wsId) {
+  if (!WS_ID.test(String(wsId))) throw new Error('bad workspace id');
+  return path.join(stateRoot, 'imports', String(wsId));
+}
+
+function importedFor(stateRoot, wsId) {
+  let apply;
+  try { apply = require(path.join(onboardingDir(), 'apply.js')); } catch { return empty(); }
+  try { return apply.importedFor(overlayDir(stateRoot, wsId)); } catch { return empty(); }
+}
+
+module.exports = { overlayDir, overlayDirFor: overlayDir, importedFor, onboardingDir };

package/workspace/lib/notes-audio.js

@@ -18,6 +18,9 @@
  * place and with nothing added, so the final pass after Stop (lib/notes-final.js) can tell the PM's microphone from the
  * meeting. remove deletes all three.
  *
+ * A chunk from a page that names its place (`sample`, from lib/notes-capture.js) is written exactly there, so a chunk that arrives
+ * late, or after a restart, lands where it belongs (notes-recording-reliability).
+ *
  * 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.
  */
@@ -80,20 +83,23 @@ 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, pcm24 = null, t, mixed = true }) {
+function write(runtimeDir, { id, source, pcm, pcm24 = null, t, sample = null, 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;
-  let at = Math.max(0, Math.round((Number(t) || 0) * BYTES_PER_MS / 2) * 2);
+  // `sample` (notes-recording-reliability): the chunk's own place, from the capture's start and its offset, so it is written there
+  // and nowhere else, whenever it arrives. Without it the chunk is placed by its arrival time, as before.
+  const exact = Number.isInteger(sample) && sample >= 0;
+  let at = exact ? sample * 2 : 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 (!exact && 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 });
   // 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 (hiOk) writeHi(runtimeDir, id, source, pcm24, t, exact ? Math.round(sample * HI_RATE / RATE) : null);
   if (mixed && !hiOk) {
     const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
     try {
@@ -114,12 +120,13 @@ function write(runtimeDir, { id, source, pcm, pcm24 = null, t, mixed = true }) {
 }
 
 /** 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) {
+function writeHi(runtimeDir, id, source, pcm24, t, sample = null) {
   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 exact = Number.isInteger(sample) && sample >= 0;
+  let at = exact ? sample * 2 : 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 (!exact && 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);
@@ -155,12 +162,24 @@ function remove(runtimeDir, id) {
   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 */ } }
   let removed = false;
-  for (const extra of ['.echo.json', '.pcm.echo.tmp', '.hi.pcm.echo.tmp', '.hi.pcm', '.clean.pcm', '.clean.pcm.tmp']) {
+  for (const extra of ['.capture.json', '.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;
 }
+/** Samples [from, to) (16 kHz) of one source's own file, or null. At most a minute. */
+function readSource(runtimeDir, id, source, from, to) {
+  if (!ID_RE.test(String(id || '')) || !SOURCES.includes(source)) return null;
+  const a = Math.max(0, from, to - RATE * 60); const n = (to - a) * 2;
+  if (n <= 0) return null;
+  let fd;
+  try {
+    fd = fs.openSync(sourceFileOf(runtimeDir, id, source), 'r');
+    const b = Buffer.alloc(n); const got = fs.readSync(fd, b, 0, n, a * 2);
+    return got > 0 ? { pcm: b.subarray(0, got - (got % 2)), from: a } : null;
+  } catch { return null; } finally { if (fd !== undefined) fs.closeSync(fd); }
+}
 /** The note's audio, one file per source: [{ source, file, bytes, ms }], the sources that were heard. */
 function sources(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return [];
@@ -220,4 +239,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: (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 };
+module.exports = { write, readSource, 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-capture.js

@@ -0,0 +1,128 @@
+'use strict';
+/* notes-capture.js — which page is capturing a note, and which chunks of it are already written (notes-recording-reliability). Local only.
+ *
+ *   start(runtimeDir, id, { baseMs, now }) → { ok, token, base_ms } | { ok: false, status: 409, error }
+ *   check(runtimeDir, id, { token, source, seq, now }) → { ok, dup, base_ms } | { ok: false, status: 409, error }
+ *   mark(runtimeDir, id, { source, seq, now })   the chunk is written: a second copy of it is a duplicate
+ *   setCut(runtimeDir, id, { source, sample }) · untranscribed(runtimeDir, id, { source, before }) → { from, to } | null
+ *                                                the live transcription's progress, so a restart transcribes what it had buffered
+ *   close(runtimeDir, id)                        Pause or Stop: the capture ends, and the next Listen starts a new one
+ *   tokened(runtimeDir, id) → true when the live capture has sent a chunk with its token
+ *   remove(runtimeDir, id)
+ *
+ * WHY. The page sends each source in one-second chunks and sends a chunk again when its answer does not come back. Before this
+ * module, the server placed each chunk at its arrival time and remembered in memory where each source ended. So a chunk written
+ * twice was kept twice, a restart lost the memory and the next chunk was added onto audio already written, a late chunk moved
+ * the rest of its source, and two tabs could capture one note into the same file (measured by notes-duplication.test.js).
+ *
+ * WHAT IT KEEPS. Listen hands the page a token and the meeting time the capture starts at (base_ms). Each chunk carries the
+ * token, a sequence number per source and its sample offset in the capture, so the route places it at base_ms + offset, and
+ * the sequence numbers already written are kept as ranges. All of it is in `<runtime>/notes/recordings/<id>.capture.json`,
+ * next to the audio, so a restart keeps it.
+ *
+ * ONE CAPTURE PER NOTE. Listen is refused while another capture is live: one that sent a chunk (or started) in the last
+ * LIVE_MS. A chunk with a token that is not the note's capture is refused, and the page stops listening on that answer.
+ *
+ * WHAT IT NEVER DOES. It sends nothing and opens no network module.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const LIVE_MS = 5000;
+const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
+const fileOf = (runtimeDir, id) => path.join(runtimeDir, 'notes', 'recordings', id + '.capture.json');
+const cache = new Map();   // file → state, written through to the file
+
+function load(runtimeDir, id) {
+  const f = fileOf(runtimeDir, id);
+  if (cache.has(f)) return cache.get(f);
+  let s = null;
+  try { s = JSON.parse(fs.readFileSync(f, 'utf8')); } catch { s = null; }
+  if (!s || typeof s !== 'object') s = null;
+  cache.set(f, s);
+  return s;
+}
+function save(runtimeDir, id, s) {
+  const f = fileOf(runtimeDir, id);
+  cache.set(f, s);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(s), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+const liveAt = (s) => Math.max(Date.parse(s.started_at) || 0, Date.parse(s.last_at) || 0);
+const isLive = (s, now) => !!(s && s.token && !s.closed && now - liveAt(s) < LIVE_MS);
+
+/** A new capture, unless another one is live. */
+function start(runtimeDir, id, { baseMs = 0, now = Date.now() } = {}) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const s = load(runtimeDir, id);
+  if (isLive(s, now)) return { ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' };
+  const token = crypto.randomBytes(9).toString('hex');
+  const base = Math.max(0, Math.round(Number(baseMs) || 0));
+  save(runtimeDir, id, { token, base_ms: base, started_at: new Date(now).toISOString(), last_at: null, closed: false, tokened: false, seqs: {} });
+  return { ok: true, token, base_ms: base };
+}
+/** Refuse true when another check would refuse the next Listen: used before the note's own record step changes anything. */
+function busy(runtimeDir, id, { now = Date.now() } = {}) { return isLive(load(runtimeDir, id), now); }
+
+const has = (ranges, n) => (ranges || []).some(([a, b]) => n >= a && n <= b);
+function add(ranges, n) {
+  const r = (ranges || []).concat([[n, n]]).sort((x, y) => x[0] - y[0]);
+  const out = [];
+  for (const [a, b] of r) { const last = out[out.length - 1]; if (last && a <= last[1] + 1) last[1] = Math.max(last[1], b); else out.push([a, b]); }
+  return out;
+}
+
+/** May this chunk be written? `dup` when its sequence number is already written. */
+function check(runtimeDir, id, { token, source, seq } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || !s.token || s.closed || s.token !== token) return { ok: false, status: 409, error: 'this meeting is being recorded in another tab or window, or listening stopped' };
+  const n = Number(seq);
+  if (!Number.isInteger(n) || n < 0) return { ok: false, status: 400, error: 'a chunk needs a sequence number' };
+  return { ok: true, dup: has((s.seqs || {})[source], n), base_ms: s.base_ms };
+}
+function mark(runtimeDir, id, { source, seq, end = null, now = Date.now() } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s) return;
+  s.seqs = s.seqs || {};
+  s.seqs[source] = add(s.seqs[source], Number(seq));
+  if (Number.isInteger(end)) { s.fed = s.fed || {}; s.fed[source] = Math.max(s.fed[source] || 0, end); }
+  s.last_at = new Date(now).toISOString(); s.tokened = true;
+  save(runtimeDir, id, s);
+}
+/** The live transcription cut this source up to `sample` (16 kHz). */
+function setCut(runtimeDir, id, { token, source, sample } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed || (token && s.token !== token) || !Number.isInteger(sample)) return;
+  s.cut = s.cut || {};
+  if (sample <= (s.cut[source] || 0)) return;
+  s.cut[source] = sample;
+  save(runtimeDir, id, s);
+}
+/** After a restart the live transcription lost what it had buffered: the stretch [from, to) of a source that was written but not
+ * transcribed, ending where the incoming chunk starts. null when there is none. */
+function untranscribed(runtimeDir, id, { source, before } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed) return null;
+  const base = Math.round((s.base_ms || 0) * 16);
+  const from = Math.max(base, (s.cut || {})[source] || 0);
+  const to = Math.min(before, (s.fed || {})[source] || 0);
+  return to > from ? { from, to } : null;
+}
+function tokened(runtimeDir, id, { now = Date.now() } = {}) { const s = load(runtimeDir, id); return isLive(s, now) && !!s.tokened; }
+function close(runtimeDir, id) {
+  const s = load(runtimeDir, id);
+  if (!s || s.closed) return;
+  s.closed = true;
+  save(runtimeDir, id, s);
+}
+function remove(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return;
+  const f = fileOf(runtimeDir, id);
+  cache.delete(f);
+  try { fs.unlinkSync(f); } catch { /* none */ }
+}
+
+module.exports = { start, busy, check, mark, setCut, untranscribed, close, tokened, remove, LIVE_MS };

package/workspace/lib/notes-live-guard.js

@@ -0,0 +1,117 @@
+'use strict';
+/* notes-live-guard.js — what the live transcript must not keep (notes-recording-reliability). Pure functions, no I/O.
+ *
+ *   stripEcho(mic, meetingLines) → the microphone line's text without the meeting's words, or '' when nothing of its own is left
+ *   repeats(text, previous) → true when a cut only says again what the line before it said
+ *   onceEach(text) → the text with a sentence repeated back to back kept once
+ *   looksForeign(text, reported) → true when a cut that should be English came back in another language
+ *
+ * ECHO. On speakers the remote voice also reaches the microphone, so the microphone's cut holds the meeting's words a second
+ * time. lib/notes-final.js drops such lines after Stop (dropEcho); this is the same rule, live: a run of ECHO_RUN or more words
+ * that a meeting line overlapping in time also holds (and that is at least half of that line) is taken out of the microphone line, and what is left is dropped when it
+ * still overlaps the meeting line by ECHO_OVERLAP of its length with ECHO_WORDS of its words the same (dropEcho's numbers).
+ * The PM's own words on the microphone stay.
+ *
+ * REPETITION. Whisper repeats itself, more so when the previous line is in its prompt (no longer passed). A cut whose words are
+ * the previous line's words, or end it, adds nothing. A short reply ("Yes.") said again later is kept: a short line counts
+ * as a repeat only within REPEAT_MS.
+ *
+ * LANGUAGE (decision 8 of the console3 feedback plan: accented English is always English). A cut is foreign when the engine
+ * says another language, when most of its letters are not Latin, or when most of its words are Indonesian function words.
+ */
+const ECHO_OVERLAP = 0.5;
+const ECHO_WORDS = 0.5;
+const ECHO_RUN = 4;
+const ECHO_SLACK_MS = 1500;
+const REPEAT_MS = 15000;
+
+const norm = (w) => String(w || '').toLowerCase().replace(/[^\p{L}\p{N}']/gu, '');
+const tokens = (text) => String(text || '').split(/\s+/).filter(Boolean);
+const wordsOf = (t) => new Set(String(t || '').toLowerCase().match(/[\p{L}\p{N}']{3,}/gu) || []);
+function sameWords(a, b) {
+  const x = wordsOf(a); const y = wordsOf(b);
+  if (!x.size || !y.size) return 0;
+  let both = 0; for (const w of x) if (y.has(w)) both++;
+  return both / Math.min(x.size, y.size);
+}
+/** The longest run of words the two token lists share, as { at, len } in `a`. */
+function longestRun(a, b) {
+  let best = { at: 0, len: 0 };
+  for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b.length; j++) {
+      let k = 0;
+      while (i + k < a.length && j + k < b.length && a[i + k] && a[i + k] === b[j + k]) k++;
+      if (k > best.len) best = { at: i, len: k };
+    }
+  }
+  return best;
+}
+const overlapMs = (a, b) => Math.min(a.end, b.end) - Math.max(a.t, b.t);
+
+/** `mic` and each meeting line: { t, end, text }. → the microphone text that is the PM's own. */
+function stripEcho(mic, meetingLines) {
+  const near = (meetingLines || []).filter((g) => overlapMs({ t: mic.t - ECHO_SLACK_MS, end: mic.end + ECHO_SLACK_MS }, g) > 0);
+  if (!near.length) return String(mic.text || '').trim();
+  let toks = tokens(mic.text);
+  for (const g of near) {
+    const theirs = tokens(g.text).map(norm);
+    const need = theirs.filter(Boolean).length * ECHO_WORDS;
+    // the runs of ECHO_RUN words or more this meeting line shares with the microphone line; they are echo together when they
+    // cover at least half of the meeting line: an echo repeats most of what the remote speaker said, a PM quoting a phrase does not.
+    // A microphone line that is wholly the meeting's words goes, however short.
+    let work = toks.slice(); const cuts = []; let covered = 0;
+    for (;;) {
+      const mine = work.map(norm);
+      const r = longestRun(mine, theirs);
+      const whole = r.len && r.len >= mine.filter(Boolean).length && !cuts.length;
+      if (!r.len || (!whole && r.len < ECHO_RUN)) break;
+      covered += r.len; cuts.push(r);
+      work = work.slice(0, r.at).concat(new Array(r.len).fill('')).concat(work.slice(r.at + r.len));
+      if (whole) { covered = Infinity; break; }
+    }
+    if (cuts.length && covered >= need) toks = work.filter(Boolean);
+    if (!toks.length) return '';
+  }
+  const left = toks.join(' ').replace(/^[\s,.;:!?…-]+/, '').trim();
+  if (!/[\p{L}\p{N}]/u.test(left)) return '';
+  const len = Math.max(1, mic.end - mic.t);
+  if (near.some((g) => overlapMs(mic, g) / len >= ECHO_OVERLAP && sameWords(left, g.text) >= ECHO_WORDS)) return '';
+  return left;
+}
+
+/** Does `text` only repeat `previous` ({ text, t }) of the same source? `t` is the new cut's time. */
+function repeats(text, previous, t = 0) {
+  if (!previous || !previous.text) return false;
+  const a = tokens(text).map(norm).filter(Boolean); const b = tokens(previous.text).map(norm).filter(Boolean);
+  if (!a.length || a.length > b.length) return false;
+  const tail = b.slice(b.length - a.length);
+  if (a.join(' ') !== tail.join(' ')) return false;
+  return a.length >= 3 || Math.abs(t - (previous.t || 0)) <= REPEAT_MS;
+}
+
+/** A sentence said twice or more back to back inside one cut is kept once. */
+function onceEach(text) {
+  const parts = String(text || '').match(/[^.!?…]+[.!?…]*\s*/g);
+  if (!parts || parts.length < 2) return String(text || '').trim();
+  const out = [];
+  for (const p of parts) { const k = tokens(p).map(norm).join(' '); if (out.length && k && k === tokens(out[out.length - 1]).map(norm).join(' ')) continue; out.push(p); }
+  return out.join('').trim();
+}
+
+const ID_WORDS = new Set(['yang', 'dan', 'di', 'ini', 'itu', 'tidak', 'dengan', 'untuk', 'ada', 'saya', 'kita', 'kami', 'akan', 'sudah', 'belum', 'juga',
+  'dari', 'ke', 'karena', 'jadi', 'bisa', 'apa', 'kalau', 'tapi', 'atau', 'nya', 'lagi', 'harus', 'sama', 'mau', 'gak', 'nggak', 'ya', 'kamu', 'mereka', 'dia', 'pada', 'dalam', 'seperti', 'lebih', 'masih', 'aja', 'saja']);
+/** Did a cut that should be English come back in another language? `reported` is the engine's language name, when it says one. */
+function looksForeign(text, reported) {
+  const t = String(text || '');
+  if (reported && !/^(en|english)$/i.test(String(reported).trim())) return true;
+  const letters = t.match(/\p{L}/gu) || [];
+  if (letters.length) {
+    const latin = letters.filter((c) => /\p{Script=Latin}/u.test(c)).length;
+    if (latin / letters.length < 0.7) return true;
+  }
+  const ws = (t.toLowerCase().match(/[a-z]+/g) || []);
+  if (ws.length >= 4 && ws.filter((w) => ID_WORDS.has(w)).length / ws.length >= 0.3) return true;
+  return false;
+}
+
+module.exports = { stripEcho, repeats, onceEach, looksForeign, sameWords, ECHO_OVERLAP, ECHO_WORDS, ECHO_RUN, REPEAT_MS };