create-pmos 0.63.0 → 0.63.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.63.0",
+  "version": "0.63.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@8370b9c
+kernel-source: pmos@4cf3dc9
 assembled: 2026-10-06
 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-06T17:30:54Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
 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-06T17:30:54Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
 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-06T17:30:54Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -39,7 +39,14 @@ Local transcription uses whisper.cpp, a free program that runs on your machine.
 
 1. Open the settings and press **Set up in a terminal**. A terminal opens with the setup commands typed in. They install whisper.cpp with Homebrew and download the model into the workspace's own folder.
 2. Read the commands and press Enter in the terminal. The workspace does not run them for you.
-3. When the download is done, open the settings again. It says **Whisper is set up**.
+3. Homebrew then says that whisper.cpp needs a model file. That is expected: the next command downloads it. Keep the terminal open until it says **Whisper is set up**.
+4. Open the settings again. It says **Whisper is set up**.
+
+If lines come slowly, choose **Faster (about 550 MB)** under **Model** in the settings, press **Set up in a terminal** and press Enter to download it. It is the same model in a smaller form: it starts and runs faster on an M1 and makes a few more mistakes. **Most accurate (1.6 GB)** is the default.
+
+Whisper writes in the language you choose in the settings under **Language spoken in the meeting**: English unless you change it, or Indonesian. **Detect for each line** lets Whisper guess for each few seconds of speech; it can guess wrong and write a line in another language, so choose the language when you know it.
+
+If the download stops, press **Set up in a terminal** again and press Enter. The download continues where it stopped, and a part-downloaded model is never used.
 
 ## Use Jev for labels and checks
 

package/workspace/lib/notes-whisper.js

@@ -5,6 +5,8 @@
  *   setupCommand(runtimeDir)     → the shell commands the PM runs once: install whisper.cpp and download its model
  *   createTranscriber({ runtimeDir, onText, run?, detect? }) → { push, flush, pending, stopAll }
  *   wav(pcm, rate) · levels(pcm, rate) · cleanText(text)
+ *   getLanguage(runtimeDir) · setLanguage(runtimeDir, code)   the spoken language Whisper writes in (LANGUAGES)
+ *   getModel(runtimeDir) · setModel(runtimeDir, id)             the model: accurate (1.6 GB) or faster (about 550 MB) (MODELS)
  *
  * WHAT IT IS. The page captures the microphone and, when the PM picks it, a meeting tab's audio. It sends each source as
  * 16 kHz mono 16-bit samples to the server on the loopback address. This module keeps a buffer per note and source, cuts it
@@ -36,8 +38,16 @@ const LEAD_MS = 300;                 // speech that starts a cut keeps this much
 const MIN_RMS = 180;                 // in 16-bit units; below this a frame is quiet whatever the room
 const MAX_QUEUE = 24;
 const RUN_TIMEOUT_MS = 120000;
-const MODEL_FILE = 'ggml-large-v3-turbo.bin';
-const MODEL_URL = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/' + MODEL_FILE;
+const MODEL_BASE = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/';
+// The faster model is the same one quantized to 5 bits: a third of the size, so it loads and runs faster on an M1, and it
+// makes a few more mistakes. Every cut starts the program again, so the time to load the model is paid on every line.
+const MODELS = Object.freeze([
+  Object.freeze({ id: 'accurate', file: 'ggml-large-v3-turbo.bin', size: '1.6 GB', label: 'Most accurate (1.6 GB)' }),
+  Object.freeze({ id: 'fast', file: 'ggml-large-v3-turbo-q5_0.bin', size: 'about 550 MB', label: 'Faster (about 550 MB)' }),
+]);
+const DEFAULT_MODEL = 'accurate';
+const MODEL_FILE = MODELS[0].file;
+const MODEL_URL = MODEL_BASE + MODEL_FILE;
 const BIN_NAMES = ['whisper-cli', 'whisper-cpp'];
 const BIN_DIRS = ['/opt/homebrew/bin', '/usr/local/bin'];
 
@@ -55,16 +65,31 @@ function findBin(env) {
 function findModel(runtimeDir, env) {
   if (env.PMOS_WHISPER_MODEL) return isFile(env.PMOS_WHISPER_MODEL) ? env.PMOS_WHISPER_MODEL : null;
   const dir = modelDir(runtimeDir);
-  if (isFile(path.join(dir, MODEL_FILE))) return path.join(dir, MODEL_FILE);
+  const chosen = modelOf(runtimeDir);
+  if (isFile(path.join(dir, chosen.file))) return path.join(dir, chosen.file);
+  // a model the PM chose and has not downloaded yet is missing, so the setup downloads it; with no choice made, any
+  // whole model in the folder will do
+  if (readSettings(runtimeDir).model) return null;
   let names = [];
   try { names = fs.readdirSync(dir).filter((f) => /^ggml-.+\.bin$/.test(f)).sort(); } catch { /* none */ }
   return names.length ? path.join(dir, names[names.length - 1]) : null;
 }
 
-/** The commands the PM runs once, in their own terminal. The server never runs them. */
+/** The commands the PM runs once, in their own terminal. The server never runs them.
+ *
+ * Homebrew's own note after the install says that no model is downloaded; the next command is that download. It goes to a
+ * `.part` file that is renamed only when it is complete, so a stopped download never reads as ready, and `-C -` continues
+ * a stopped download when the PM runs the commands again. A program already installed is not installed again. */
 function setupCommand(runtimeDir) {
   const dir = modelDir(runtimeDir);
-  return 'brew install whisper-cpp && mkdir -p ' + shq(dir) + ' && curl -L --fail -o ' + shq(path.join(dir, MODEL_FILE)) + ' ' + MODEL_URL;
+  const m = modelOf(runtimeDir);
+  const file = path.join(dir, m.file);
+  return '{ command -v whisper-cli >/dev/null 2>&1 || brew install whisper-cpp; }'
+    + ' && mkdir -p ' + shq(dir)
+    + ' && echo ' + shq('Downloading the Whisper model (' + m.size + '). Keep this terminal open.')
+    + ' && curl -L --fail -C - -# -o ' + shq(file + '.part') + ' ' + MODEL_BASE + m.file
+    + ' && mv ' + shq(file + '.part') + ' ' + shq(file)
+    + ' && echo ' + shq('Whisper is set up. Open the Notes settings again.');
 }
 
 /** Is local transcription ready? `missing` names what is not there: 'program', 'model'. */
@@ -74,7 +99,7 @@ function detect(runtimeDir, { env = process.env } = {}) {
   const missing = [];
   if (!bin) missing.push('program');
   if (!model) missing.push('model');
-  return { ready: missing.length === 0, bin, model, missing, setup: setupCommand(runtimeDir), model_dir: modelDir(runtimeDir), model_size: '1.6 GB' };
+  return { ready: missing.length === 0, bin, model, missing, setup: setupCommand(runtimeDir), model_dir: modelDir(runtimeDir), model_size: modelOf(runtimeDir).size };
 }
 
 /** A mono 16-bit PCM buffer as a WAV file. */
@@ -109,11 +134,48 @@ function cleanText(text) {
   return t;
 }
 
+/* THE SPOKEN LANGUAGE. Whisper writes in the language it is told. With 'auto' it guesses the language of each cut, and on a
+ * few seconds of accented speech it can guess wrong and write the line in that language, which reads as a translation. So
+ * the PM picks the language of the meeting once (English by default) and every cut uses it. PMOS_WHISPER_LANG wins. */
+const LANGUAGES = Object.freeze([['en', 'English'], ['id', 'Indonesian'], ['auto', 'Detect for each line']]);
+const DEFAULT_LANGUAGE = 'en';
+const settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'whisper-settings.json');
+function readSettings(runtimeDir) {
+  try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s && typeof s === 'object' ? s : {}; } catch { return {}; }
+}
+function writeSettings(runtimeDir, patch) {
+  const f = settingsFile(runtimeDir);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify({ ...readSettings(runtimeDir), ...patch }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+function getLanguage(runtimeDir, { env = process.env } = {}) {
+  if (env.PMOS_WHISPER_LANG) return env.PMOS_WHISPER_LANG;
+  const c = readSettings(runtimeDir).language;
+  return LANGUAGES.some(([k]) => k === c) ? c : DEFAULT_LANGUAGE;
+}
+function setLanguage(runtimeDir, code) {
+  if (!LANGUAGES.some(([k]) => k === code)) return { ok: false, error: 'the language must be one of ' + LANGUAGES.map(([k]) => k).join(', ') };
+  writeSettings(runtimeDir, { language: code });
+  return { ok: true, language: code };
+}
+function modelOf(runtimeDir) { const id = readSettings(runtimeDir).model; return MODELS.find((m) => m.id === id) || MODELS.find((m) => m.id === DEFAULT_MODEL); }
+function getModel(runtimeDir) { return modelOf(runtimeDir).id; }
+function setModel(runtimeDir, id) {
+  if (!MODELS.some((m) => m.id === id)) return { ok: false, error: 'the model must be one of ' + MODELS.map((m) => m.id).join(', ') };
+  writeSettings(runtimeDir, { model: id });
+  return { ok: true, model: id };
+}
+
 /** Run the program on one WAV file. Resolves { ok, text } or { ok: false, error }. */
-function runWhisper({ bin, model, file, lang = process.env.PMOS_WHISPER_LANG || 'auto' }) {
-  const threads = String(Math.max(2, Math.min(8, (os.cpus() || []).length || 4)));
+function runWhisper({ bin, model, file, lang = DEFAULT_LANGUAGE }) {
+  // The GPU does most of the work on Apple silicon, so four threads are enough; more only compete with the browser.
+  // Greedy decoding (-bs 1 -bo 1) instead of the program's default five-way beam search makes each line several times
+  // faster for a small loss on hard words.
+  const threads = String(Math.max(2, Math.min(4, (os.cpus() || []).length || 4)));
   return new Promise((resolve) => {
-    execFile(bin, ['-m', model, '-f', file, '-nt', '-np', '-l', lang, '-t', threads], { timeout: RUN_TIMEOUT_MS, maxBuffer: 1 << 20 }, (e, stdout, stderr) => {
+    execFile(bin, ['-m', model, '-f', file, '-nt', '-np', '-l', lang, '-t', threads, '-bs', '1', '-bo', '1'], { timeout: RUN_TIMEOUT_MS, maxBuffer: 1 << 20 }, (e, stdout, stderr) => {
       if (e) resolve({ ok: false, error: e.killed ? 'the transcription took too long' : String((stderr || e.message || 'the program failed')).trim().split('\n').pop().slice(0, 200) });
       else resolve({ ok: true, text: String(stdout || '') });
     });
@@ -152,7 +214,7 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
       const file = path.join(tmpDir, 'cut-' + crypto.randomBytes(6).toString('hex') + '.wav');
       try {
         fs.writeFileSync(file, wav(pcm), { mode: 0o600 });
-        const r = await run({ bin: d.bin, model: d.model, file });
+        const r = await run({ bin: d.bin, model: d.model, file, lang: getLanguage(runtimeDir) });
         if (!r.ok) { onError({ ...job, error: r.error }); return; }
         const text = cleanText(r.text);
         if (text) await onText({ ...job, text });
@@ -197,4 +259,4 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
   return { push, flush, drop, pending: () => waiting, idle: () => queue };
 }
 
-module.exports = { detect, setupCommand, createTranscriber, runWhisper, wav, levels, cleanText, modelDir, RATE, MODEL_FILE, MODEL_URL, MIN_CUT_MS, MAX_CUT_MS, PAUSE_MS };
+module.exports = { detect, setupCommand, getLanguage, setLanguage, LANGUAGES, DEFAULT_LANGUAGE, getModel, setModel, MODELS, DEFAULT_MODEL, createTranscriber, runWhisper, wav, levels, cleanText, modelDir, RATE, MODEL_FILE, MODEL_URL, MIN_CUT_MS, MAX_CUT_MS, PAUSE_MS };

package/workspace/lib/routes-notes.js

@@ -13,6 +13,7 @@
  *   POST /api/notes/speaker    { id, source, name }         → { ok, speakers }
  *   GET  /api/notes/engine?ws=…             → { ok, whisper, jev }   is Whisper set up; which Jev gates hold (booleans only)
  *   POST /api/notes/switch     { ws, jev?, check? }         → { ok, jev }   the two D91 switches, default off
+ *                              { language?, model? }        → { ok, whisper } the spoken language and the model, for this machine
  *   POST /api/notes/whisper-setup { ws? }   → { ok, started, session, command }   a terminal with the setup typed in, not run
  *   POST /api/notes/private    { id, private }            → { ok, private }
  *   POST /api/notes/summarize  { id }       → { ok, summary }   the local summary
@@ -106,7 +107,9 @@ function transcriberFor(ctx) {
 }
 function engineInfo(ctx, w) {
   const d = whisper.detect(ctx.runtimeDir);
-  const out = { ready: d.ready, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size };
+  const out = { ready: d.ready, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size,
+    language: whisper.getLanguage(ctx.runtimeDir), languages: whisper.LANGUAGES.map(([value, label]) => ({ value, label })),
+    model: whisper.getModel(ctx.runtimeDir), models: whisper.MODELS.map((m) => ({ value: m.id, label: m.label })) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
   const sw = jevNotes.getSwitch(ctx.runtimeDir, w.root);
@@ -183,6 +186,13 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/speaker') return done(notes.renameSpeaker(dir, { id, source: body.source, name: body.name }));
   if (p === '/api/notes/switch') {
     const o = wsOf();
+    // the spoken language belongs to this machine, not to a repository
+    if (body.language !== undefined || body.model !== undefined) {
+      const r = body.language !== undefined ? whisper.setLanguage(dir, String(body.language)) : { ok: true };
+      const m = r.ok && body.model !== undefined ? whisper.setModel(dir, String(body.model)) : { ok: true };
+      if (!r.ok || !m.ok) { ctx.json(res, { ok: false, error: r.error || m.error }, 400); return true; }
+      if (body.jev === undefined && body.check === undefined) { ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true; }
+    }
     if (!o.ok || !o.w) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
     jevNotes.setSwitch(dir, o.w.root, { jev: typeof body.jev === 'boolean' ? body.jev : undefined, check: typeof body.check === 'boolean' ? body.check : undefined });
     ctx.json(res, { ok: true, ...engineInfo(ctx, o.w) });

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.63.0",
+  "version": "0.63.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

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

@@ -504,8 +504,8 @@ async function chooseSources(ctx, n) {
 }
 async function setSwitch(ctx, patch) {
   const ws = wsOf(ctx);
-  if (!ws) return;
-  const r = await pmPost('/api/notes/switch', { ws, ...patch });
+  if (!ws && patch.language === undefined && patch.model === undefined) return;
+  const r = await pmPost('/api/notes/switch', ws ? { ws, ...patch } : patch);
   if (r && r.ok) engine = { ws, whisper: r.whisper, jev: r.jev, at: Date.now() };
   ctx.setState({});
   return r;
@@ -527,7 +527,11 @@ function openSettings(ctx, n) {
       el('div', { class: 'nt-set__head' }, 'Local transcription'),
       el('p', { class: 'nt-hint' }, !w ? 'Reading …' : w.ready ? 'Whisper is set up. The microphone and the meeting are transcribed on this machine.'
         : 'Whisper is not set up (' + w.missing.map((m) => (m === 'program' ? 'the program' : 'the model, ' + w.model_size)).join(' and ') + ' missing). The setup installs whisper.cpp with Homebrew and downloads the model.'),
-      w && !w.ready ? button({ label: 'Set up in a terminal', onClick: () => { h.close(); whisperSetup(ctx); }, attrs: { 'data-nt-whisper-setup': '' } }) : null));
+      w && w.models ? field({ label: 'Model', kind: 'select', value: w.model, options: w.models,
+        onCommit: (v) => setSwitch(ctx, { model: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-model': '' } }) : null,
+      w && !w.ready ? button({ label: 'Set up in a terminal', onClick: () => { h.close(); whisperSetup(ctx); }, attrs: { 'data-nt-whisper-setup': '' } }) : null,
+      w && w.ready && w.languages ? field({ label: 'Language spoken in the meeting', kind: 'select', value: w.language, options: w.languages,
+        onCommit: (v) => setSwitch(ctx, { language: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-language': '' } }) : null));
     if (!wsOf(ctx)) parts.push(el('p', { class: 'nt-hint' }, 'Choose a repository to check notes against it.'));
     else {
       const jsw = field({ label: 'Label lines with Jev', kind: 'check', value: !!(j && j.jev), onCommit: (v) => setSwitch(ctx, { jev: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-sw-jev': '' } });