create-pmos 0.234.0 → 0.236.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.234.0",
+  "version": "0.236.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@cda8b75
+kernel-source: pmos@d874247
 assembled: 2026-10-14
 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-14T09:51:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T10:47:28Z"}
 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-14T09:51:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T10:47:28Z"}
 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-14T09:51:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T10:47:28Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -27,6 +27,7 @@ const http = require('http');
 const net = require('net');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { spawn, spawnSync } = require('child_process');
 const D = require('../lib/server-discovery');
 const stateRoot = require('../lib/state-root');
@@ -164,6 +165,17 @@ function repoRootOf(dir) {
   return top && fs.existsSync(top) ? top : path.resolve(dir);
 }
 
+// `pmos` typed in a new terminal runs in the home folder. Registering the home folder as a workspace made PMOS start
+// its background jobs over every file the PM has. The setup's PMOS folder (PMOS_DIR, else ~/PMOS) is opened instead;
+// with no such folder, `pmos` says where to run it and registers nothing.
+function workspaceDir(dir) {
+  const home = path.resolve(os.homedir());
+  if (path.resolve(repoRootOf(dir)) !== home) return { dir };
+  const pmosDir = process.env.PMOS_DIR ? path.resolve(process.env.PMOS_DIR) : path.join(home, 'PMOS');
+  if (pmosDir !== home && fs.existsSync(pmosDir)) return { dir: pmosDir, note: `note: this is your home folder, so PMOS opens your PMOS folder, ${pmosDir}.` };
+  return { refused: 'this is your home folder. Run `pmos` inside a project folder, or `pmos <folder>`.' };
+}
+
 function openBrowser(url) {
   if (NO_OPEN) return;
   const cmd = process.platform === 'darwin' ? ['open', [url]]
@@ -283,6 +295,12 @@ async function servesTailnet(port) {
 // `remote` starts a NEW server in tailnet mode (pmos phone); a server that is already running is reused as it is.
 // `open: false` registers the repo without opening the desktop browser.
 async function up(dir, { remote = false, open = true, waited = false } = {}) {
+  if (!waited) {
+    const where = workspaceDir(dir);
+    if (where.refused) { say(`✗ ${where.refused}`); return 1; }
+    if (where.note) say(where.note);
+    dir = where.dir;
+  }
   // 1. Is a workspace already running — on ANY port it recorded, not just the one this shell guesses?
   let live = await discover();
   // A server that predates this install is running OLD code under NEW files (or the reverse). Reusing

package/workspace/c3-report-design-test.js

@@ -138,16 +138,33 @@ const DOC = 'planning/reports/rs1/2026-10-21.md';
   await page.click('[data-rd-act="mksave"]');
   ok('the marker is numbered on the preview and listed under Point and say', !!(await until(() => page.$('[data-rd-mk]'))) && (await page.$$('[data-rd-mkrow]')).length === 1 && /Make this title smaller/.test(await text('[data-rd-point]')));
   await shot(page, 'design-point-1440');
+  /* the slide and its thumbnails are not rebuilt by a paint: a frame put back in the page loads again, and that was the flicker */
+  const tagFrames = () => page.$$eval('[data-rd-preview] iframe', (fs) => fs.forEach((f) => { f.__kept = 1; }));
+  const framesKept = () => page.$$eval('[data-rd-preview] iframe', (fs) => fs.length > 2 && fs.every((f) => f.__kept === 1));
+  await tagFrames();
   await page.fill('[data-rd-in]', 'Make it dense');
   await page.click('[data-rd-act="send"]');
   const turn = await until(() => sent('/api/report-design/turn')[0]);
   ok('a turn posts the words and the markers as points', !!turn && turn.body.text === 'Make it dense' && Array.isArray(turn.body.points) && turn.body.points.length === 1 && turn.body.points[0].text === 'Make this title smaller' && turn.body.points[0].n === 1 && typeof turn.body.points[0].slide === 'string', JSON.stringify(turn && turn.body));
   ok('while the job runs the conversation shows PMOS working', !!(await until(() => page.$('[data-rd-running]'), 3000)));
-  ok('the job lands D4 as the current version, with its PMOS line', !!(await until(async () => await page.getAttribute('[data-rd-v="4"]', 'aria-pressed') === 'true', 8000)) && /D4:/.test(await text('[data-rd-chat]')));
+  await page.$eval('[data-rd-in]', (t) => { t.__kept = 1; });
+  await page.type('[data-rd-in]', 'next');
+  await sleep(3200);
+  ok('while the job runs the slide and its thumbnails stay in place: the reads of the design rebuild no frame', await framesKept());
+  ok('while the job runs the box you type in is not rebuilt and keeps your words', await page.$eval('[data-rd-in]', (t) => t.__kept === 1 && t.value === 'next'));
+  await page.fill('[data-rd-in]', '');
+  ok('the job lands D4 as the current version, with its PMOS line', !!(await until(async () => await page.getAttribute('[data-rd-v="4"]', 'aria-pressed') === 'true', 15000)) && /D4:/.test(await text('[data-rd-chat]')));
   ok('the markers are cleared after the turn', (await page.$$('[data-rd-mkrow]')).length === 0);
+  await until(() => page.$('[data-rd-sstrip] [data-rd-sgo="1"]'));
+  await tagFrames();
+  const bigBefore = await page.getAttribute('[data-rd-sbig]', 'data-rd-sbig');
+  await page.click('[data-rd-sstrip] [data-rd-sgo="1"]');
+  ok('picking a thumbnail changes the slide and keeps the thumbnails as they were', !!(await until(async () => (await page.getAttribute('[data-rd-sbig]', 'data-rd-sbig')) !== bigBefore))
+    && await page.getAttribute('[data-rd-sgo="1"]', 'aria-current') === 'true' && await page.$$eval('[data-rd-sstrip] iframe', (fs) => fs.length > 1 && fs.every((f) => f.__kept === 1)));
+  await page.click('[data-rd-sstrip] [data-rd-sgo="0"]');
   await page.fill('[data-rd-in]', 'This turn should fail');
   await page.click('[data-rd-act="send"]');
-  ok('a failed job shows an error line and makes no version', !!(await until(() => page.$('[data-rd-log="error"]'), 8000)) && (await page.$$('[data-rd-v]')).length === 4);
+  ok('a failed job shows an error line and makes no version', !!(await until(() => page.$('[data-rd-log="error"]'), 15000)) && (await page.$$('[data-rd-v]')).length === 4);
 
   /* compare (#design-compare) */
   await page.click('[data-rd-act="cmp"]');
@@ -185,7 +202,7 @@ const DOC = 'planning/reports/rs1/2026-10-21.md';
   await page.click('[data-rd-act="send"]');
   const desc = await until(() => sent('/api/report-design/describe')[0]);
   ok('the first words are posted as the description with the format, then a turn', !!desc && desc.body.id === 'rg0' && /decisions first/.test(desc.body.text) && desc.body.format === 'deck' && !!(await until(() => sent('/api/report-design/turn').some((t) => t.body.id === 'rg0'))));
-  ok('D1 arrives', !!(await until(() => page.$('[data-rd-v="1"]'), 8000)));
+  ok('D1 arrives', !!(await until(() => page.$('[data-rd-v="1"]'), 15000)));
   await closeAll(page);
 
   /* a document design (#design-doc), then This is it */

package/workspace/guide/report-design.md

@@ -23,7 +23,7 @@ Use one of these two buttons:
 1. Select **Deck** or **Document** at the top of the studio.
 2. Write what the report is for and who reads it. For example: "This goes to the progress session every other Thursday. The decisions must stand out."
 3. Press **Add a sample** to give PMOS a report that people liked. You can upload a file, paste a link, add a page from Chrome (see below), or pick a report document that PMOS has. Each sample shows what PMOS took from it. PMOS reads a link from Google Slides, Docs or Sheets, or from Confluence, through your own connectors. It saves the words and the structure (slide titles, order, sections and tables), and it changes nothing in the file. It does not get the look. To match the look, also add the file as a PDF or a screenshot. For Google Slides, choose **File**, **Download**, **PDF document (.pdf)** in Slides, then add that file. If your connectors cannot read the link, the sample says so. Any other link is kept by its address, and PMOS cannot open it. PMOS sees the pages of a PDF or an image, so it can follow their look. From a .pptx or a .docx, PMOS gets only the words.
-4. Press **Make the next version**. PMOS makes a version from your words and this cycle's data. This takes a short time. You can leave the studio. The studio shows when the version is ready.
+4. Press **Make the next version**. PMOS makes a version from your words and this cycle's data. This takes a short time. You can leave the studio. The studio shows when the version is ready. While PMOS works, the version on screen and its slides stay as they are, and you can keep reading it or write your next turn.
 5. Read the version in the preview. Write what to change and press **Make the next version** again. Each turn makes a new version: D1, D2, D3 and so on.
 
 To set the width of the studio, use **Half**, **3/4** or **Whole** at the top right. PMOS keeps your choice on this computer.

package/workspace/lib/win-command.js

@@ -0,0 +1,54 @@
+'use strict';
+/* lib/win-command.js — how to start a command such as `claude` on Windows.
+ *
+ * On Windows, Node starts a program by name only when it is an .exe or .com file. A command that npm installed
+ * (`npm install -g @anthropic-ai/claude-code`) is a `claude.cmd` file, so `spawn('claude')` fails with ENOENT
+ * (-4058), even though the same `claude` works in a terminal. Since Node 20, Node also refuses to start a .cmd
+ * file without a shell.
+ *
+ * resolve() finds the file on PATH the way a terminal does (PATHEXT) and returns what to start instead:
+ *   - an .exe or .com file: its full path;
+ *   - an npm .cmd shim: node and the script the shim points to, so no shell quoting is involved;
+ *   - any other .cmd or .bat file: cmd.exe /d /s /c with the file, as a last resort.
+ * On other platforms, and when nothing is found, the command is returned unchanged, so the caller's own
+ * "not found" handling still applies.
+ *
+ * Pure apart from the injected `exists` and `read`, so every case is testable on any platform.
+ */
+const fs = require('fs');
+const path = require('path');
+
+function resolve(cmd, {
+  platform = process.platform, env = process.env, execPath = process.execPath,
+  exists = (f) => { try { return fs.statSync(f).isFile(); } catch { return false; } },
+  read = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return null; } },
+} = {}) {
+  const same = { file: cmd, prefix: [] };
+  if (platform !== 'win32' || !cmd) return same;
+  const P = path.win32;
+  const exts = String(env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean).map((e) => e.toLowerCase());
+  const hasExt = exts.includes(P.extname(cmd).toLowerCase());
+  const names = hasExt ? [cmd] : exts.map((e) => cmd + e);
+  const dirs = /[\\/]/.test(cmd) ? [''] : String(env.PATH || env.Path || '').split(';').filter(Boolean);
+  let found = null;
+  for (const d of dirs) {
+    for (const n of names) { const f = d ? P.join(d, n) : n; if (exists(f)) { found = f; break; } }
+    if (found) break;
+  }
+  if (!found) return same;
+  const ext = P.extname(found).toLowerCase();
+  if (ext === '.exe' || ext === '.com') return { file: found, prefix: [] };
+  if (ext === '.cmd' || ext === '.bat') {
+    // npm's cmd-shim names its target relative to the shim's folder: "%dp0%\node_modules\…\cli.js" (or "%~dp0\…").
+    const text = read(found) || '';
+    const m = /"%~?dp0%?\\([^"%]+\.(js|cjs|mjs|exe))"/i.exec(text);
+    if (m) {
+      const target = P.join(P.dirname(found), m[1]);
+      if (exists(target)) return m[2].toLowerCase() === 'exe' ? { file: target, prefix: [] } : { file: execPath, prefix: [target] };
+    }
+    return { file: env.ComSpec || 'cmd.exe', prefix: ['/d', '/s', '/c', found] };
+  }
+  return same;
+}
+
+module.exports = { resolve };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/c3-demo-rd.js

@@ -7,7 +7,7 @@
  * The data is the mockup's: the MySPH & Identity Platform biweekly update (set-up rs1) has a saved deck design, versions D1 to D3 made from
  * the Wed 21 Oct draft, two samples, a conversation, two designed cycles (Wed 21 Oct differs: Usage-based billing got its own slide; Wed 7 Oct
  * matches), speaker notes carried forward from 7 Oct and four notes on the slides. The Monthly OOH x Digital review (rs3) has a document
- * design in progress (D1, D2, not saved). Any other set-up starts with no design. A turn runs 1.5 seconds and lands the next version; a turn
+ * design in progress (D1, D2, not saved). Any other set-up starts with no design. A turn runs 4 seconds and lands the next version; a turn
  * whose words say "fail" lands an error line instead. The renders follow the HTML contract (one <style>, pmos-slide or pmos-sec sections, the
  * data attributes); their colours are the slide tokens the frame links. Nothing is saved anywhere and nothing is sent. */
 
@@ -249,9 +249,9 @@ function versionHtml(id, D, v) {
   const s = ctx.setups().find((x) => x.id === id) || { name: id }; const d = curDoc(id);
   return genericHtml(v.format, s.name, sectionsOf(d ? ctx.docText(d.path) : ''), v.step || 1);
 }
-/* a job lands when its 1.5 seconds are up (read on each GET) */
+/* a job lands when its 4 seconds are up (read on each GET): the studio reads the design more than once while it runs, as with a real job */
 function settle(id) {
-  const D = DESIGNS[id]; if (!D || !D.running || performance.now() - D.running.t0 < 1500) return;
+  const D = DESIGNS[id]; if (!D || !D.running || performance.now() - D.running.t0 < 4000) return;
   const t = D.running.turn; const pts = D.running.points || []; D.running = null;
   if (/\bfail\b/i.test(t)) { D.log.push({ at: nowIso(), who: 'pmos', kind: 'error', text: 'The job ended before it made a version: the render did not pass the check (a slide had no data-slide-id). Nothing changed. Try the turn again.' }); return; }
   const base = D.versions.find((x) => x.n === D.current) || null; const n = (D.versions.length ? Math.max(...D.versions.map((x) => x.n)) : 0) + 1;

package/workspace/public/pm/c3-design-studio.js

@@ -43,6 +43,16 @@ function sampleChip(s) {
       : el('p', null, el('span', { class: 'dim' }, 'PMOS took: '), s.took || 'PMOS reads it on the next turn.')));
 }
 
+/* put() that leaves a node in place when it stays: only the nodes that go are taken out, so a kept frame does not load again */
+function keep(host, ...kids) {
+  const want = kids.flat(Infinity).filter((k) => k != null && k !== false && k !== true).map((k) => (typeof k === 'string' ? document.createTextNode(k) : k));
+  const set = new Set(want);
+  for (const c of [...host.childNodes]) if (!set.has(c)) c.remove();
+  let ref = host.firstChild;
+  for (const n of want) { if (n === ref) ref = ref.nextSibling; else host.insertBefore(n, ref); }
+  return host;
+}
+
 /* ── the studio ── */
 export function openStudio({ ws, id, name, view, onClose } = {}) {
   ensureDeckCss();
@@ -59,16 +69,21 @@ export function openStudio({ ws, id, name, view, onClose } = {}) {
     sizeBtns.forEach((b) => b.setAttribute('aria-pressed', String(b.dataset.rdSize === size)));
   }
 
-  async function load(keepView) {
+  /* follow: show the current version when it changed (a job landed). A read that changed nothing paints nothing: the poll reads the design
+   * every 1.5 seconds while a job runs, and a repaint rebuilt the conversation and the box the PM types in. */
+  async function load(keepView, follow) {
     const r = await RD.design(ws, id);
-    if (!r || r.ok === false) { S.err = (r && r.error) || 'The design could not be read.'; paint(); return; }
+    if (!r || r.ok === false) { S.err = (r && r.error) || 'The design could not be read.'; S.shown = null; paint(); return; }
+    const prev = S.D ? S.D.current : null;
     S.D = r.design; S.setup = r.setup || { id, name };
     if (!K.fmt || !S.D.versions.length) K.fmt = S.D.format || 'deck';
-    if (!keepView || K.view == null || !S.D.versions.some((v) => v.n === K.view)) K.view = S.D.current;
+    if (!keepView || K.view == null || !S.D.versions.some((v) => v.n === K.view) || (follow && S.D.current !== prev)) K.view = S.D.current;
     if (S.D.running || (S.D.samples || []).some((x) => x.fetching)) poll(); else clearTimeout(S.timer);
     if (K.view != null) await render(K.view);
     if (K.cmp) await render(cmpA());
-    paint();
+    const shown = JSON.stringify([r.design, r.setup, K.view, K.cmp, K.cmp ? cmpA() : null, Object.keys(S.cache)]);
+    if (shown === S.shown) return;
+    S.shown = shown; paint();
   }
   async function render(n) {
     if (n == null || S.cache[n]) return;
@@ -84,7 +99,11 @@ export function openStudio({ ws, id, name, view, onClose } = {}) {
   }
   S.watch = setInterval(checkNew, 4000);
   window.addEventListener('focus', checkNew);
-  function poll() { clearTimeout(S.timer); S.timer = setTimeout(async () => { if (S.closed) return; const was = S.D && S.D.current; await load(false); if (S.D && !S.D.running && S.D.current !== was) { K.markers = []; K.draft = null; scrollLog(); } }, 1500); }
+  function poll() { clearTimeout(S.timer); S.timer = setTimeout(async () => { if (S.closed) return; const was = S.D && S.D.current; await load(true, true); if (S.D && !S.D.running && S.D.current !== was) { K.markers = []; K.draft = null; scrollLog(); } }, 1500); }
+  /* The preview's frames are kept from one paint to the next: a frame that is taken out of the page and put back loads again, and every
+   * paint rebuilt the slide and its thumbnails, so they flickered on each read while a job ran and on each click. */
+  const KEPT = {};
+  const reuse = (slot, key, make) => { const k = KEPT[slot]; if (k && k.key === key) return k.node; const node = make(); KEPT[slot] = { key, node }; return node; };
   const ver = (n) => (S.D.versions || []).find((v) => v.n === n);
   const cmpA = () => { const b = S.D.current; const a = K.cmpA != null && K.cmpA !== b && ver(K.cmpA) ? K.cmpA : (S.D.versions.filter((v) => v.n < b).pop() || S.D.versions.find((v) => v.n !== b) || {}).n; return a; };
   const scrollLog = () => requestAnimationFrame(() => { const l = body.querySelector('.rd-dks-log'); if (l) l.scrollTop = l.scrollHeight; });
@@ -216,19 +235,26 @@ export function openStudio({ ws, id, name, view, onClose } = {}) {
     if (!R) return [strip(), capline, el('div', { class: 'fold', role: 'status' }, icon('clock', 'sm'), ' Reading D' + v.n + '.')];
     if (R.err) return [strip(), capline, el('div', { class: 'fold w', role: 'alert' }, icon('alert', 'sm'), ' D' + v.n + ' could not be read: ' + R.err + '.')];
     if (R.format === 'doc') {
-      const card = el('div', { class: 'rd-docf rd-dks-doc' + (K.point ? ' placing' : ''), 'data-rd-sbig': 'doc' }); const layer = el('div', { class: 'rd-doclayer' });
-      const box = (e) => { const sec = e.target.closest && e.target.closest('section.pmos-sec'); if (!sec) return null; const r = sec.getBoundingClientRect(); return { id: sec.getAttribute('data-sec-id'), x: (e.clientX - r.left) / r.width * 100, y: (e.clientY - r.top) / r.height * 100 }; };
-      card.append(frame(R.style, R.body, { title: 'D' + v.n + ', the document', cls: 'pmos-doc', focusable: true, onLoad: (doc, fr) => {
-        const fit = () => { fr.style.setProperty('--rp-h', Math.max(200, doc.documentElement.scrollHeight) + 'px'); const L = []; for (const s of R.secs) { const n = doc.querySelector('section.pmos-sec[data-sec-id="' + s.id.replace(/"/g, '') + '"]'); if (n) L.push(...markers(s.id, n.getBoundingClientRect())); } put(layer, ...L); };
-        fit(); setTimeout(fit, 120); wireFrame(doc, { ...pointHands(box), more: fit });
-      } }), layer);
+      const card = reuse('doc', v.n, () => {
+        const c = el('div', { class: 'rd-docf rd-dks-doc', 'data-rd-sbig': 'doc' }); const layer = el('div', { class: 'rd-doclayer' });
+        const box = (e) => { const sec = e.target.closest && e.target.closest('section.pmos-sec'); if (!sec) return null; const r = sec.getBoundingClientRect(); return { id: sec.getAttribute('data-sec-id'), x: (e.clientX - r.left) / r.width * 100, y: (e.clientY - r.top) / r.height * 100 }; };
+        c.append(frame(R.style, R.body, { title: 'D' + v.n + ', the document', cls: 'pmos-doc', focusable: true, onLoad: (doc, fr) => {
+          const fit = () => { if (!doc.documentElement) return; fr.style.setProperty('--rp-h', Math.max(200, doc.documentElement.scrollHeight) + 'px'); const L = []; for (const s of R.secs) { const n = doc.querySelector('section.pmos-sec[data-sec-id="' + s.id.replace(/"/g, '') + '"]'); if (n) L.push(...markers(s.id, n.getBoundingClientRect())); } put(layer, ...L); };
+          c.fit = fit; fit(); setTimeout(fit, 120); wireFrame(doc, { ...pointHands(box), more: fit });
+        } }), layer);
+        return c;
+      });
+      card.classList.toggle('placing', !!K.point); if (card.fit) card.fit();
       const key = K.draft ? K.draft.slide : (K.markers[0] || {}).slide || (R.secs[0] || {}).id || 'doc';
       return [strip(), capline, run, card, pointSect(key)];
     }
     if (!R.slides.length) return [strip(), capline, el('div', { class: 'fold w' }, icon('alert', 'sm'), ' D' + v.n + ' has no slide.')];
     K.sidx = Math.min(K.sidx, R.slides.length - 1); const s = R.slides[K.sidx];
-    const big = slideCard(R, s, { cls: 'rd-big' + (K.point ? ' placing' : ''), attrs: { 'data-rd-sbig': s.id }, focusable: true, over: markers(s.id), wire: (doc) => wireFrame(doc, pointHands((e) => ({ id: s.id, x: e.clientX / 1280 * 100, y: e.clientY / 720 * 100 }))) });
-    return [strip(), capline, run, thumbStrip(R, K.sidx, (i) => { K.sidx = i; K.draft = null; paint(); }),
+    const big = reuse('big', v.n + '/' + s.id, () => slideCard(R, s, { cls: 'rd-big', attrs: { 'data-rd-sbig': s.id }, focusable: true, wire: (doc) => wireFrame(doc, pointHands((e) => ({ id: s.id, x: e.clientX / 1280 * 100, y: e.clientY / 720 * 100 }))) }));
+    big.classList.toggle('placing', !!K.point); [...big.children].forEach((c) => { if (c.tagName !== 'IFRAME') c.remove(); }); big.append(...markers(s.id));
+    const thumbs = reuse('thumbs', v.n, () => thumbStrip(R, K.sidx, (i) => { K.sidx = i; K.draft = null; paint(); }));
+    thumbs.querySelectorAll('[data-rd-sgo]').forEach((b) => b.setAttribute('aria-current', String(Number(b.getAttribute('data-rd-sgo')) === K.sidx)));
+    return [strip(), capline, run, thumbs,
       el('div', { class: 'rd-dk-cap' }, el('b', { 'data-rd-scap': '' }, 'Slide ' + s.n + ' of ' + R.slides.length + ': ' + s.title), el('span', { class: 'dim rd-small' }, hint(s.kind))), big, pointSect(s.id)];
   }
   function thumbStrip(R, cur, pick) {
@@ -277,13 +303,15 @@ export function openStudio({ ws, id, name, view, onClose } = {}) {
     const D = S.D; const nm = (S.setup && S.setup.name) || name || 'Report';
     const sb = body.closest('.sb'); const y = sb ? sb.scrollTop : 0; const log = body.querySelector('.rd-dks-log'); const ly = log ? log.scrollTop : null;
     const focus = document.activeElement && body.contains(document.activeElement) && document.activeElement.matches('[data-rd-in],[data-rd-link]') ? document.activeElement.getAttribute('data-rd-in') != null ? '[data-rd-in]' : '[data-rd-link]' : null;
-    put(body, el('div', { class: 'rd-dk-bar' }, el('div', { class: 'chips2 rd-wrap' }, el('div', { class: 'seg', role: 'group', 'aria-label': 'Report type' },
+    S.dks = S.dks || el('div', { class: 'rd-dks' }); S.out = S.out || el('div', { class: 'rd-dks-out', 'data-rd-preview': '' });
+    keep(body, el('div', { class: 'rd-dk-bar' }, el('div', { class: 'chips2 rd-wrap' }, el('div', { class: 'seg', role: 'group', 'aria-label': 'Report type' },
       btn({ 'data-rd-fmt': 'deck', 'aria-pressed': String(K.fmt === 'deck'), onclick: () => setFmt('deck') }, icon('img', 'sm'), 'Deck'), btn({ 'data-rd-fmt': 'doc', 'aria-pressed': String(K.fmt === 'doc'), onclick: () => setFmt('doc') }, icon('doc', 'sm'), 'Document')),
     el('b', null, nm), D.saved ? el('span', { class: 'chip2 ds-good', 'data-rd-saved': String(D.saved.version) }, icon('check', 'sm'), 'Saved design: D' + D.saved.version) : el('span', { class: 'chip2', 'data-rd-saved': '' }, 'Not saved yet')),
     el('div', { class: 'chips2' }, pbtn('primary', 'This is it', 'check', { 'data-rd-act': 'accept', disabled: !D.versions.length, onclick: () => accept() }),
       D.saved ? pbtn('ghost', 'Design brief', 'doc', { 'data-rd-act': 'brief', onclick: () => openBrief({ ws, id, name: nm }) }) : null)),
     el('div', { class: 'fold' }, icon('info', 'sm'), ' No template to fill in. Describe the report, add samples, then refine until it looks right. PMOS keeps what you settle on and drafts every cycle to match it. Nothing is sent.'),
-    el('div', { class: 'rd-dks' }, chat(), el('div', { class: 'rd-dks-out', 'data-rd-preview': '' }, ...[].concat(preview()))));
+    S.dks);
+    keep(S.dks, chat(), S.out); keep(S.out, preview());
     if (sb) sb.scrollTop = y; const l2 = body.querySelector('.rd-dks-log'); if (l2) l2.scrollTop = ly == null ? l2.scrollHeight : ly;
     if (focus) { const n = body.querySelector(focus); if (n) n.focus(); }
   }

package/workspace/public/pm/c3-report-deck.js

@@ -199,21 +199,25 @@ export function createDeck(o) {
   const root = el('div', { class: 'rd-dk', 'data-rd-deck': path });
   const redraw = () => { if (S.api && S.api.redraw) S.api.redraw(); };
 
+  /* A read that changed nothing draws nothing: while the cycle is redrawn the deck is read every 2 seconds, and a redraw loads every frame
+   * again, so the slides flickered. */
   async function load() {
     const c = await RD.cycle(ws, path);
-    if (!c || c.ok === false) { S.loaded = true; S.cyc = null; S.err = (c && c.error) || ''; redraw(); return; }
-    S.cyc = c;
+    if (!c || c.ok === false) { S.loaded = true; S.cyc = null; S.err = (c && c.error) || ''; S.seen = null; redraw(); return; }
+    S.cyc = c; const seen = [c];
     if (c.designed) {
-      try { S.R = splitRender(await RD.cycleHtml(ws, path)); } catch (e) { S.err = (e && e.message) || 'the render could not be read'; S.R = null; }
-      const n = await RD.notes(ws, path); if (n && n.ok !== false) S.notes = { speaker: n.speaker || {}, suggestions: n.suggestions || {}, pins: n.pins || [] };
+      try { const h = await RD.cycleHtml(ws, path); seen.push(h); S.R = splitRender(h); } catch (e) { S.err = (e && e.message) || 'the render could not be read'; S.R = null; }
+      const n = await RD.notes(ws, path); seen.push(n); if (n && n.ok !== false) S.notes = { speaker: n.speaker || {}, suggestions: n.suggestions || {}, pins: n.pins || [] };
       if (c.previous && c.previous.path) {
-        const pc = await RD.cycle(ws, c.previous.path);
-        if (pc && pc.ok !== false && pc.designed) { S.prev = { ...pc, ...c.previous }; try { S.prevR = splitRender(await RD.cycleHtml(ws, c.previous.path)); } catch { S.prevR = null; } }
+        const pc = await RD.cycle(ws, c.previous.path); seen.push(pc);
+        if (pc && pc.ok !== false && pc.designed) { S.prev = { ...pc, ...c.previous }; try { const h = await RD.cycleHtml(ws, c.previous.path); seen.push(h); S.prevR = splitRender(h); } catch { S.prevR = null; } }
       }
     }
     S.loaded = true; S.cur = Math.min(S.cur, Math.max(0, count() - 1));
     if (c.rendering) poll();
-    redraw();
+    const sig = JSON.stringify(seen) + S.err;
+    if (sig === S.seen) return;
+    S.seen = sig; redraw();
   }
   function poll() { clearTimeout(S.timer); S.timer = setTimeout(async () => { if (!root.isConnected && !OV) return; await load(); }, 2000); }
   const count = () => (S.R ? (S.R.format === 'deck' ? S.R.slides.length : S.R.secs.length) : 0);

package/workspace/replaced-tests.json

@@ -3061,6 +3061,20 @@
       "names": [
         "hand to agent: no drop on any column started a session or called a /handoff/ route"
       ]
+    },
+    {
+      "id": "E75",
+      "group": "E",
+      "file": "workspace/pm-r12-test.js",
+      "section": "T3: the two spawn paths",
+      "change": "rewritten",
+      "slice": "one-line-setup",
+      "reason": "On Windows, Node cannot start npm's claude.cmd by name (spawn claude ENOENT, -4058). The direct-PTY spawn now starts the file lib/win-command.js resolves (unchanged on macOS and Linux). The assertion read the old line of server.js literally.",
+      "replacement": "The assertion stays under the same name; it now matches pty.spawn(run.file, [...run.prefix, ...launchArgs], …), which still passes the launch args as an argv.",
+      "pm_approval": null,
+      "names": [
+        "T3: both spawn paths take the launch args — tmux joins plain tokens, the direct PTY passes an argv"
+      ]
     }
   ]
 }

package/workspace/server.js

@@ -1957,6 +1957,7 @@ const autoSync = require('./lib/auto-sync').createAutoSync({
 // workspace starts the board and facts rebuilds when the repository changes, so nothing is re-read on a clock. The board
 // keeps its last value while it rebuilds (stale while revalidate): dropping it would show a blank Board on every change.
 const factsAsync = require('./lib/facts-async.js');
+const winCommand = require('./lib/win-command');
 factsAsync.configure({ stateDir: STATE });
 const freshness = require('./lib/freshness.js').create({
   stateDir: STATE,
@@ -3611,7 +3612,9 @@ function startHeadless(base, workdir, kind, launchArgs, env, initialInput, addDi
   let child;
   // detached: its own process group, so stopping it also stops what it started (an MCP server, a script) and no
   // grandchild keeps the output pipes open after the run is stopped.
-  try { child = spawn(base.agent, args, { cwd: workdir, env, stdio: ['pipe', 'pipe', 'pipe'], detached: true }); }
+  // Windows: `claude` installed by npm is claude.cmd, which spawn() cannot start by name (lib/win-command.js).
+  const run = winCommand.resolve(base.agent, { env });
+  try { child = spawn(run.file, [...run.prefix, ...args], { cwd: workdir, env, stdio: ['pipe', 'pipe', 'pipe'], detached: true }); }
   catch (e) {
     s.state = 'exited'; s.note = spawnFailureAdvice(e, base.agent, false);
     say(`\x1b[38;5;203m✗ ${s.note}\x1b[0m\n`); persist(s); pushSessions(); pushWorkspaces(); return s;
@@ -3862,7 +3865,7 @@ function spawnSessionInner({ name, agent, cwd, ws, origin, initialInput, profile
   let p, usedCmd = cmd;
   try {
     if (isShell) { const r = spawnPty(cmd, workdir, penv); p = r.pty; usedCmd = r.cmd; }
-    else p = pty.spawn(cmd, launchArgs, { name: 'xterm-256color', cols: 80, rows: 24, cwd: workdir, env: penv });
+    else { const run = winCommand.resolve(cmd, { env: penv }); p = pty.spawn(run.file, [...run.prefix, ...launchArgs], { name: 'xterm-256color', cols: 80, rows: 24, cwd: workdir, env: penv }); }
   } catch (e) {
     return exitedSession(base, workdir, spawnFailureAdvice(e, cmd, isShell));
   }

package/workspace/test-lists/one-line-setup.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "one-line-setup: on Windows the background server hides the console window of every command it runs (lib/win-hide.js); `pmos` waits for its own busy server instead of starting a second one (busy-server.test.js).",
-  "modules": ["win-hide.test.js", "busy-server.test.js"],
-  "seconds": { "win-hide.test.js": 1, "busy-server.test.js": 12 }
+  "_comment": "one-line-setup: on Windows the server hides command windows (win-hide), starts npm's claude.cmd (win-command), and `pmos` waits for its own busy server (busy-server) and never registers the home folder (windows-start).",
+  "modules": ["win-hide.test.js", "busy-server.test.js", "windows-start.test.js"],
+  "seconds": { "win-hide.test.js": 1, "busy-server.test.js": 12, "windows-start.test.js": 3 }
 }