create-pmos 0.236.0 → 0.237.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.236.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@d874247
+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-14T10:47:28Z"}
+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-14T10:47:28Z"}
+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-14T10:47:28Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T11:55:57Z"}
 status: stable
 ---
 

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/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.236.0",
+  "version": "0.237.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.236.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.236.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/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"]
+}