create-pmos 0.63.0 → 0.63.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.63.0",
+  "version": "0.63.2",
   "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@586dc2f
 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-06T23:17:22Z"}
 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-06T23:17:22Z"}
 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-06T23:17:22Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -119,6 +119,8 @@ Every row has a visible ⋯ button. Every control is at least 44 pixels high. No
 
 You can have the same session open on your phone and your computer. A session has one size, so the screen you type in or tap last sets it. The other screen keeps showing the session and takes the size back as soon as you type in it.
 
+On an iPhone or an iPad, the terminal gets smaller when the keyboard opens, so the agent's prompt stays above the keyboard. Tapping the terminal does not zoom the page, and dragging at its top or bottom does not pull or reload the page. A swipe from the left edge of the screen is Safari's Back gesture and leaves the workspace. To avoid that, add the workspace to your Home Screen and open it from there.
+
 ## The older layout
 
 The address options `?layout=legacy` and `?fixture=cockpit` keep the older layouts. The rest of this page describes them. In the cockpit, the workspace has four columns: the repository rail, the list, the detail and the tabs. With `?layout=legacy` it has three columns: navigation, detail and tabs.

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.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

package/workspace/public/pm/mobile.css

@@ -43,6 +43,7 @@
     border-left: 1px solid var(--border);
     border-right: 1px solid var(--border);
   }
+  html.pm-vv body { height: var(--fr-vvh, 100vh); }
 
   /* Explicit placement, never auto-placement: app.js appends its root LAST, so source order would
    * put the screen underneath the bottom nav. */
@@ -363,3 +364,19 @@
 .mob[hidden], .mobmenu[hidden], .mob-back[hidden], .mob-brand[hidden] { display: none !important; }
 .mob-repo[hidden], .mob-set[hidden], .mob-sync[hidden], .mob-theme[hidden], .mobnav-n[hidden] { display: none !important; }
 .mob-deck[hidden], .mob-pager[hidden], .mob-deck__views[hidden] { display: none !important; }
+
+/* ── a touch screen: the visible height, no page bounce, no zoom on focus ─────────────────────
+ * pm/mobile.js sets `pm-vv` and `--fr-vvh` (the visual viewport's height) on a touch screen. The
+ * page is that tall, so the soft keyboard sits under the terminal and does not cover it. Above the
+ * breakpoint (an iPad) that is app.js's root; at the breakpoint and below it is <body>, in the phone rules above.
+ * A drag at the top or bottom of the terminal does not pull the page or reload it. Every rule here
+ * needs `pm-vv`, so a desktop with a mouse is untouched. */
+html.pm-vv, html.pm-vv body { overscroll-behavior: none; }
+html.pm-vv { -webkit-text-size-adjust: 100%; text-size-adjust: 100%; }
+@media (min-width: 761px) {
+  html.pm-vv body > [data-pm-theme] { height: var(--fr-vvh, 100vh) !important; }
+}
+/* xterm types through a hidden textarea and gives it the terminal's 12.5px font. iOS zooms the
+ * page in on a focused field under 16px, which pushes the terminal off the side of the screen. The
+ * textarea is invisible, so its size changes nothing else. */
+html.pm-vv .xterm .xterm-helper-textarea { font-size: 16px !important; }

package/workspace/public/pm/mobile.js

@@ -475,13 +475,42 @@ function onChromeClick(e) {
 
 /* The terminal has to re-measure when the soft keyboard shows or hides and after a rotation, or
  * xterm keeps the row count it had and the bottom of the session is clipped. The fit itself belongs
- * to the terminal panel; this only tells it that the box changed. */
+ * to the terminal panel; this only tells it that the box changed. It calls the terminal's refit
+ * directly: a synthetic window `resize` also re-lays the card deck and the report slides. */
 function refit() {
   const t = window.pmTerm;
-  if (t && typeof t.fit === 'function') { try { t.fit(); return; } catch { /* fall through */ } }
+  if (t && typeof t.refitVisible === 'function') { try { t.refitVisible(); return; } catch { /* fall through */ } }
   window.dispatchEvent(new Event('resize'));
 }
 
+/* ── the visible height, on a touch screen ───────────────────────────────────────────────────
+ * iOS does not shrink the page when the soft keyboard opens. `100vh` stays the full screen, the
+ * keyboard covers its bottom, and that bottom is where the agent's prompt and the control keys
+ * are. Safari then scrolls the page to show the focused field, so the screen jumps. And with
+ * Safari's toolbar shown, `100vh` is already taller than what is visible.
+ *
+ * So on a touch screen the page height is the VISUAL viewport's: `--fr-vvh` on <html>, read by
+ * pm/mobile.css, with the page held at the top. A pinch zoom also changes the visual viewport, and
+ * that is not the page getting smaller, so the height is in layout pixels (height × scale). */
+const TOUCH = window.matchMedia('(hover: none) and (pointer: coarse)');
+let vvh = 0;
+
+function fitViewport() {
+  const vv = window.visualViewport;
+  const root = document.documentElement;
+  if (!vv || !TOUCH.matches) {
+    if (root.classList.contains('pm-vv')) { root.classList.remove('pm-vv'); vvh = 0; refit(); }
+    return;
+  }
+  root.classList.add('pm-vv');
+  if (window.scrollY || window.scrollX) window.scrollTo(0, 0);
+  const h = Math.round(vv.height * (vv.scale || 1));
+  if (!h || h === vvh) return;
+  vvh = h;
+  root.style.setProperty('--fr-vvh', h + 'px');
+  refit();
+}
+
 /* ── mount ──────────────────────────────────────────────────────────────────────────────────── */
 
 /**
@@ -515,10 +544,12 @@ export function mountMobile(context) {
   document.addEventListener('click', onChromeClick);
 
   if (window.visualViewport) {
-    window.visualViewport.addEventListener('resize', refit);
-    window.visualViewport.addEventListener('scroll', refit);
+    window.visualViewport.addEventListener('resize', fitViewport);
+    window.visualViewport.addEventListener('scroll', fitViewport);
   }
-  window.addEventListener('orientationchange', () => setTimeout(refit, 250));
+  if (TOUCH.addEventListener) TOUCH.addEventListener('change', fitViewport);
+  window.addEventListener('orientationchange', () => setTimeout(() => { fitViewport(); refit(); }, 250));
+  fitViewport();
 
   // Crossing the breakpoint (rotate a tablet, drag a window narrow) has to re-decide whether the
   // phone shell exists at all AND repaint the panels — a shell left mounted above 760px is a second

package/workspace/public/pm/tab-term.js

@@ -699,6 +699,18 @@ function syncSize(rec, claim) {
   if (send({ t: 'resize', id: rec.sessionId, cols, rows })) { rec.sentCols = cols; rec.sentRows = rows; }
 }
 
+/**
+ * State a grid that a refit changed, once the box stops moving. A phone's soft keyboard and a
+ * rotation move the box several times in a few hundred milliseconds, and every grid the PTY hears
+ * makes the agent redraw its whole frame. Typing still sends at once: `onData` calls syncSize
+ * before the keystroke, which states the latest grid and makes the queued call a no-op.
+ */
+const SIZE_SETTLE_MS = 120;
+function queueSize(rec) {
+  clearTimeout(rec.sizeTimer);
+  rec.sizeTimer = setTimeout(() => { rec.sizeTimer = null; syncSize(rec, true); }, SIZE_SETTLE_MS);
+}
+
 /** Write a status line into the terminal itself — once per distinct message, dimmed. */
 function note(rec, line, force) {
   if (!rec.term) return;
@@ -726,8 +738,9 @@ export function refitVisible() {
       try { rec.fit.fit(); } catch { /* a terminal mid-teardown */ }
       // …and state the resulting grid to the PTY. `fit()` only fires xterm's `onResize` when the
       // grid MOVES, so a pane that was measured before it had a session would otherwise never tell
-      // the shell how wide it is. See the `attached` handler.
-      syncSize(rec);
+      // the shell how wide it is. See the `attached` handler. A grid change the fit just queued
+      // (see queueSize) goes out when the box settles, not here.
+      if (!rec.sizeTimer) syncSize(rec);
     }
   };
   if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);
@@ -891,12 +904,12 @@ function buildReal(tab) {
   term.attachCustomKeyEventHandler((e) => !((e.metaKey || e.ctrlKey) && (e.key === 'k' || e.key === 'K')));
 
   const rec = {
-    kind: 'real', tab, host, term, fit, sessionId: null, attachedId: null, noted: null, ro: null,
+    kind: 'real', tab, host, term, fit, sessionId: null, attachedId: null, noted: null, ro: null, sizeTimer: null,
   };
   // Typing, focusing or re-sizing THIS pane takes the session's grid back from another screen, and
   // the grid goes out before the keystroke so the agent answers it at this pane's size.
   term.onData((d) => { if (rec.sessionId) { syncSize(rec, true); send({ t: 'input', id: rec.sessionId, data: d }); } });
-  term.onResize(() => syncSize(rec, true));
+  term.onResize(() => queueSize(rec));
   host.addEventListener('focusin', () => syncSize(rec, true));
   if (typeof ResizeObserver === 'function') {
     rec.ro = new ResizeObserver(() => refitVisible());
@@ -951,6 +964,7 @@ export function disposeTerm(tab) {
    * pane for the id and detaches from the orphan instead. */
   if (rec.kind !== 'real') return;
   if (rec.ro) { try { rec.ro.disconnect(); } catch { /* ignore */ } }
+  clearTimeout(rec.sizeTimer);
   if (rec.sessionId) {
     send({ t: 'detach', id: rec.sessionId });
     SOCK.attached.delete(rec.sessionId);

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': '' } });