create-pmos 0.235.0 → 0.237.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.235.0",
+  "version": "0.237.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@a744ae0
+kernel-source: pmos@c49efbe
 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:56:46Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T11:55:57Z"}
 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:56:46Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T11:55:57Z"}
 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:56:46Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T11:55:57Z"}
 status: stable
 ---
 

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/data-freshness.md

@@ -76,6 +76,8 @@ A refresh waits for the sources it uses. The briefing waits for work assigned to
 - **Tell me**: a failed scheduled refresh adds one item to Needs you on the Briefing.
 - **Runs at once**: at most this many scheduled refreshes run together. A refresh you press is never held.
 - No scheduled refresh starts in your quiet hours; the background jobs keep to the day check's working hours.
+- **One server runs the schedules.** When several PMOS servers run on one computer (for example an npm install and a checkout), only one of them runs the schedules and starts background runs; the others serve pages only. If that server stops, another one takes over within 3 minutes. A refresh you press runs on the server where you press it.
+- **Quiet start**: a server starts no background run in its first 5 minutes, so the first pages load quickly. A missed refresh catches up after that.
 
 ### The refresh log
 

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/schedule-owner.js

@@ -0,0 +1,86 @@
+'use strict';
+/* schedule-owner.js — ONE PMOS SERVER PER COMPUTER RUNS THE BACKGROUND SCHEDULES (initiative background-runs-one-server).
+ *
+ *   create({ file, pid, port, staleMs, quietMs, bootAt, alive })
+ *     .claim(now)   → true when this server owns the schedules now (it writes or refreshes the lock), false when another
+ *                     live server owns them
+ *     .mayRun(now)  → claim(now) and the quiet start is over: the tick may start background work
+ *     .release()    → drop the lock if this server holds it (on shutdown)
+ *   lockFile(env)   → where the lock lives
+ *
+ * Every server ticks its schedules (core documents, the initiative driver, the scan, the finder, the data refresh, …),
+ * and each of those can start headless Claude runs. Several servers on one computer (an npm install, a checkout, a
+ * baseline) each started their own, for the same repositories. The lock makes one of them the owner; the others serve
+ * pages only. The owner refreshes the lock on every tick. Another server takes over when the owner's process is gone
+ * or its lock is older than staleMs.
+ *
+ * WHERE: one file per tmux socket, in the temp folder. Every real server on a computer shares the `pmos` socket, so
+ * they share the lock; a test suite has a private socket (test-run.js), so its servers never wait on the PM's.
+ * PMOS_SCHEDULE_LOCK names the file explicitly.
+ *
+ * QUIET START: a server that has just started starts no background work for quietMs (5 minutes; PMOS_QUIET_START_MS),
+ * so the first page loads have the computer to themselves. Under PMOS_TICK_MS (the suites' fast clock) it is 0.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const STALE_MS = 3 * 60 * 1000;
+const QUIET_MS = 5 * 60 * 1000;
+
+function lockFile(env = process.env) {
+  if (env.PMOS_SCHEDULE_LOCK) return path.resolve(env.PMOS_SCHEDULE_LOCK);
+  const sock = String(env.PMOS_TMUX_SOCK || 'pmos').replace(/[^A-Za-z0-9._-]/g, '_');
+  return path.join(os.tmpdir(), `pmos-schedules-${sock}.lock`);
+}
+
+function quietMs(env = process.env) {
+  const n = Number(env.PMOS_QUIET_START_MS);
+  if (env.PMOS_QUIET_START_MS != null && env.PMOS_QUIET_START_MS !== '' && Number.isFinite(n) && n >= 0) return n;
+  return env.PMOS_TICK_MS ? 0 : QUIET_MS;
+}
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return !!(e && e.code === 'EPERM'); }
+}
+
+function create(o = {}) {
+  const file = o.file || lockFile();
+  const pid = o.pid || process.pid;
+  const port = o.port || null;
+  const staleMs = o.staleMs == null ? STALE_MS : o.staleMs;
+  const quiet = o.quietMs == null ? quietMs() : o.quietMs;
+  const bootAt = o.bootAt == null ? Date.now() : o.bootAt;
+  const alive = o.alive || pidAlive;
+
+  const read = () => { try { const x = JSON.parse(fs.readFileSync(file, 'utf8')); return x && typeof x === 'object' ? x : null; } catch { return null; } };
+  const write = (now) => {
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      const tmp = `${file}.${pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify({ pid, port, at: now }));
+      fs.renameSync(tmp, file);
+    } catch { /* an unwritable temp folder: claim() then answers from what it reads back */ }
+  };
+
+  function claim(now = Date.now()) {
+    const cur = read();
+    const free = !cur || cur.pid === pid || !alive(cur.pid) || !(typeof cur.at === 'number' && now - cur.at < staleMs);
+    if (!free) return false;
+    write(now);
+    const back = read();
+    // two servers that both found it free: the last rename wins, and the other sees that here
+    return !back || back.pid === pid;
+  }
+
+  return {
+    file,
+    claim,
+    mayRun(now = Date.now()) { return claim(now) && now - bootAt >= quiet; },
+    owner() { return read(); },
+    release() { const cur = read(); if (cur && cur.pid === pid) { try { fs.unlinkSync(file); } catch { /* gone */ } } },
+  };
+}
+
+module.exports = { create, lockFile, quietMs, pidAlive, STALE_MS, QUIET_MS };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.235.0",
+  "version": "0.237.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/server.js

@@ -2688,7 +2688,11 @@ refreshRun = refreshRunLib.create({
   warn: (what, e) => warnWriteFail(what, e),
 });
 const gated = (id, fn) => () => { let g = { ok: true }; try { g = refreshRun.jobGate(id); } catch { g = { ok: true }; } if (g.ok) fn(); };
-try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } try { refreshRun.tick(); } catch (e) { warnWriteFail('refresh tick', e); } gated('sync', () => autoSync.tick().catch(() => {}))(); dashboardScheduleTick(); gated('driver', driverTick)(); gated('scan', scanTick)(); gated('finder', reportFinderTick)(); gated('coredocs', coreDocsTick)(); reportDesignTick(); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
+// background-runs-one-server: one server per computer runs the schedules (lib/schedule-owner.js), and none in its first 5 minutes.
+// data-refresh-settings: the seed schedules move to Settings › Data refresh (refreshRun.settings(), once) BEFORE checkDueSchedules reads
+// schedules.json, so a schedule that is moving never fires once more from the old list on the first tick after an upgrade.
+const scheduleOwner = require('./lib/schedule-owner.js').create({ port: PORT });
+try { const _tick = setInterval(() => { try { if (!scheduleOwner.mayRun()) return; } catch { /* no lock: run as before */ } try { refreshRun.settings(); } catch { /* the refresh tick tries again */ } checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } try { refreshRun.tick(); } catch (e) { warnWriteFail('refresh tick', e); } gated('sync', () => autoSync.tick().catch(() => {}))(); dashboardScheduleTick(); gated('driver', driverTick)(); gated('scan', scanTick)(); gated('finder', reportFinderTick)(); gated('coredocs', coreDocsTick)(); reportDesignTick(); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
 
 // ── Sessions: real PTYs, owned by the server, with disk-backed scrollback + metadata. ──
 /** @type {Map<string, {id,ws,name,agent,cwd,state,note,created,pty,buf,cols,rows,clients:Set}>} */
@@ -9546,6 +9550,7 @@ if (require.main === module) {
     for (const l of listeners) { try { l.close(); } catch {} }
     try { tunnel.stop(); } catch {}   // workspace-online-mode: the tunnel is this server's child and ends with it
     try { fs.unlinkSync(PID_FILE); } catch {}   // stop being discoverable the moment we stop serving
+    try { scheduleOwner.release(); } catch {}   // another server can run the schedules at once
     process.exit(0);
   };
   process.on('SIGTERM', shutdown);

package/workspace/test-lists/background-runs-one-server.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Initiative background-runs-one-server: one PMOS server per computer runs the background schedules (a lock per tmux socket), and a server starts no background work in its first 5 minutes.",
+  "modules": ["schedule-owner.test.js"],
+  "seconds": { "schedule-owner.test.js": 25 }
+}

package/workspace/test-lists/today-alone.json

@@ -0,0 +1,4 @@
+{
+  "_comment": "today.test.js times `pmos today` cold against a 1 s budget (0b). Beside three other suites on a CI runner it measured 1.0 to 1.2 s while it takes about 0.45 s alone, so it runs alone, after the shared suites.",
+  "exclusive": ["today.test.js"]
+}