create-pmos 0.250.0 → 0.252.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.250.0",
+  "version": "0.252.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@3bddf04
-assembled: 2026-10-15
+kernel-source: pmos@c1539b2
+assembled: 2026-10-16
 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-15T10:01:22Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T04:16:43Z"}
 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-15T10:01:22Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T04:16:43Z"}
 status: stable
 ---
 

package/payload/scripts/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

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-15T10:01:22Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T04:16:43Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-15
+## 2026-10-16
 
 - Adopted OKF v0.2 (D73).

package/workspace/lib/engine/signals/facts.js

@@ -92,7 +92,7 @@ function readRepoFacts(root, opts) {
   const inis = [];
   for (const id of ws.listInitiatives(base)) {
     let w;
-    try { w = ws.computeWorkflow(id, range ? { root: base, range } : { root: base }); } catch { continue; }
+    try { w = ws.computeWorkflow(id, range ? { root: base, range, skipLastActivity: true } : { root: base, skipLastActivity: true }); } catch { continue; }
     if (!w || !w.ok) continue;
     const fm = readFrontmatter(path.join(base, w.record || `planning/initiatives/${id}.md`));
     inis.push({

package/workspace/lib/engine/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

package/workspace/lib/vendor/scripts/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/server.js

@@ -2838,7 +2838,7 @@ function stripLegacyClientScreen(buf) {
   return buf.replace(TMUX_CLIENT_SMCUP, '').replace(TMUX_CLIENT_RMCUP, '');
 }
 
-function restorePersisted() {
+function restorePersisted(opts = {}) {
   // On server start, load prior sessions' metadata + scrollback. A tmux-backed session whose
   // process is STILL ALIVE (it outlived this server via the tmux daemon) is RE-ATTACHED live —
   // the PM's `claude` keeps its in-flight state across `pmos stop`/relaunch, no respawn (R7).
@@ -2853,10 +2853,13 @@ function restorePersisted() {
     const n = Number(f.replace(/\.json$/, '').split('-')[1]);
     if (Number.isFinite(n) && n >= seq) seq = n + 1;
   }
-  for (const f of files) {
+  // One lookup for every live pane, not three per session (has-session, pane_id, pane_pid): with many sessions that was seconds
+  // of blocking subprocesses before the server could answer.
+  const live = tmuxLivePanes();
+  const restoreOne = (f) => {
     try {
       const meta = JSON.parse(fs.readFileSync(path.join(SESS_DIR, f), 'utf8'));
-      if (!meta.id || sessions.has(meta.id)) continue;
+      if (!meta.id || sessions.has(meta.id)) return;
       let buf = '';
       try { buf = stripLegacyClientScreen(fs.readFileSync(path.join(SESS_DIR, meta.id + '.scrollback'), 'utf8')); } catch {}
       // re-home the session: its workspace must exist for it to be reachable in the UI
@@ -2868,8 +2871,10 @@ function restorePersisted() {
         lastOutputAt: Date.now(),   // a restored session's idle clock starts at boot, never from a missing value
       };
       sessions.set(meta.id, s);
-      if (TMUX && meta.tmux && tmuxHasSession(meta.tmux)) {
+      if (TMUX && meta.tmux && live.has(meta.tmux)) {
         s.state = 'working'; s.note = '';
+        s.paneId = live.get(meta.tmux).paneId;   // stable for the life of the tmux session; saves the pane_id lookup on attach
+        if (live.get(meta.tmux).pid > 0) s.agentPid = live.get(meta.tmux).pid;
         // seed: this server was DOWN, so output produced in the gap never reached our ring buffer.
         // Control mode replays no history, so take tmux's — it is the superset (R7 + scrollback).
         attachPty(s, { seed: true });       // the process is alive — reconnect to it, live
@@ -2889,8 +2894,23 @@ function restorePersisted() {
       }
       const n = Number(String(meta.id).split('-')[1]); if (Number.isFinite(n) && n >= seq) seq = n + 1;
     } catch {}
+  };
+  if (!opts.progressive) {
+    for (const f of files) restoreOne(f);
+    adoptOrphanTmuxSessions();
+    return;
   }
-  adoptOrphanTmuxSessions();
+  // The running server restores in short slices AFTER it is listening, so the page is reachable at once and the sessions
+  // appear as they come back. Every id was floored above, so a session spawned meanwhile cannot take a restored id.
+  const queue = files.slice();
+  const slice = () => {
+    const t0 = Date.now();
+    while (queue.length && Date.now() - t0 < 15) restoreOne(queue.shift());
+    if (queue.length) { setImmediate(slice); return; }
+    try { adoptOrphanTmuxSessions(); } catch {}
+    try { pushSessions(); } catch {}
+  };
+  setImmediate(slice);
 }
 
 // The registered workspace a directory belongs to — the LONGEST matching root, so a repo opened
@@ -2926,7 +2946,7 @@ function adoptOrphanTmuxSessions() {
   if (!TMUX) return 0;
   const claimed = new Set([...sessions.values()].map((s) => s.tmux).filter(Boolean));
   let adopted = 0;
-  for (const t of tmuxList().sort((a, b) => a.created - b.created)) {
+  for (const t of tmuxList(claimed).sort((a, b) => a.created - b.created)) {
     if (!t.name.startsWith('pmos-') || claimed.has(t.name)) continue;
     const dir = t.dir && isDir(t.dir) ? path.resolve(t.dir) : null;
     const start = t.start && isDir(t.start) ? path.resolve(t.start) : null;
@@ -3415,11 +3435,14 @@ function tmuxField(name, fmt) {
   const r = tmuxCtl(['display-message', '-p', '-t', name, fmt]);
   return r && r.status === 0 ? String(r.stdout || '').trim() : '';
 }
-function tmuxList() {
+// `skip` names sessions the caller already owns: they are not described, so a restart with many live sessions does not
+// start five blocking tmux calls for each one of them just to throw the answer away.
+function tmuxList(skip) {
   if (!TMUX) return [];
   const r = tmuxCtl(['list-sessions', '-F', '#{session_name}']);
   if (!r || r.status !== 0) return [];
   return String(r.stdout || '').split('\n').map((line) => line.trim()).filter(Boolean)
+    .filter((name) => !(skip && skip.has(name)))
     .map((name) => ({
       name,
       dir: tmuxField(name, '#{pane_current_path}'),
@@ -3431,6 +3454,20 @@ function tmuxList() {
       cmd: tmuxField(name, '#{pane_start_command}'),
     }));
 }
+// Every live session's active pane in ONE call: name -> { paneId, pid }. The restore asks it instead of running has-session,
+// pane_id and pane_pid per session. A pipe separates the fields: tmux rewrites a tab inside a format string (see tmuxField).
+function tmuxLivePanes() {
+  const out = new Map();
+  if (!TMUX) return out;
+  const r = tmuxCtl(['list-panes', '-a', '-F', '#{session_name}|#{window_active}|#{pane_active}|#{pane_id}|#{pane_pid}']);
+  if (!r || r.status !== 0) return out;
+  for (const line of String(r.stdout || '').split('\n')) {
+    const [name, win, pane, paneId, pid] = line.trim().split('|');
+    if (!name || win !== '1' || pane !== '1' || !/^%\d+$/.test(paneId || '')) continue;
+    if (!out.has(name)) out.set(name, { paneId, pid: Number(pid) });
+  }
+  return out;
+}
 // The pane id (%0, %1, …) the control client must address for input. One cheap lookup per attach;
 // cached on the session because a pane id is stable for the life of the tmux session.
 function tmuxPaneId(s, name) {
@@ -5873,13 +5910,30 @@ const TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; ch
 const zlib = require('zlib');
 const GZIP_MIN_BYTES = 1024;
 const GZIP_TYPES = /^(?:text\/|application\/(?:json|javascript|manifest\+json)|image\/svg\+xml)/;
-const wantsGzip = (res) => { const q = res && res.req; return !!(q && q.headers && /\bgzip\b/i.test(String(q.headers['accept-encoding'] || ''))); };
+// Whether this client takes a gzip body: a `gzip` (or `*`) coding in Accept-Encoding whose q-value is not 0. `gzip;q=0` is a
+// refusal. PMOS_NO_COMPRESS=1 turns compression off, so a proxy or client that mishandles it can be ruled out in one restart.
+const NO_COMPRESS = process.env.PMOS_NO_COMPRESS === '1';
+function wantsGzip(res) {
+  if (NO_COMPRESS) return false;
+  const q = res && res.req;
+  const h = q && q.headers && q.headers['accept-encoding'];
+  if (!h) return false;
+  for (const part of String(h).split(',')) {
+    const [coding, ...params] = part.trim().toLowerCase().split(';');
+    if (coding !== 'gzip') continue;
+    const qv = params.map((x) => x.trim()).find((x) => x.startsWith('q='));
+    return !(qv && Number(qv.slice(2)) === 0);
+  }
+  return false;
+}
 const fileMemo = new Map();     // file -> { sig, buf, etag, gz }
 const FILE_MEMO_MAX = 400;
 function serveFile(res, file, type, noCache) {
   fs.stat(file, (serr, st) => {
     if (serr || !st.isFile()) { res.writeHead(404); res.end('not found'); return; }
-    const sig = `${st.size}:${st.mtimeMs}`;
+    // size, mtime, change time and inode: a package install stamps every file with one fixed mtime, so size and mtime alone
+    // would keep serving the old bytes after a same-size edit.
+    const sig = `${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.ino}`;
     const send = (m) => {
       const ctype = type || TYPES[path.extname(file)] || 'application/octet-stream';
       const headers = { 'Content-Type': ctype, 'ETag': m.etag };
@@ -5902,7 +5956,7 @@ function serveFile(res, file, type, noCache) {
     if (hit && hit.sig === sig) return send(hit);
     fs.readFile(file, (err, buf) => {
       if (err) { res.writeHead(404); res.end('not found'); return; }
-      const m = { sig, buf, etag: `W/"${st.size.toString(16)}-${Math.floor(st.mtimeMs).toString(16)}"`, gz: null };
+      const m = { sig, buf, etag: `"${require('crypto').createHash('sha1').update(buf).digest('hex').slice(0, 20)}"`, gz: null };
       const ctype = type || TYPES[path.extname(file)] || '';
       const finish = () => { if (fileMemo.size >= FILE_MEMO_MAX) fileMemo.clear(); fileMemo.set(file, m); send(m); };
       if (buf.length >= GZIP_MIN_BYTES && GZIP_TYPES.test(ctype)) zlib.gzip(buf, (e, gz) => { if (!e) m.gz = gz; finish(); });
@@ -6021,6 +6075,7 @@ function json(res, obj, code = 200) {
   if (body.length >= GZIP_MIN_BYTES && wantsGzip(res)) {
     // Async, so a 1 MB library answer costs the loop nothing beyond the stringify (workspace-event-loop-lag).
     return zlib.gzip(body, (e, gz) => {
+      if (res.headersSent || res.writableEnded || res.destroyed) return;   // the handler or the client got there first
       if (e) { res.writeHead(code, { 'Content-Type': 'application/json' }); res.end(body); return; }
       res.writeHead(code, { 'Content-Type': 'application/json', 'Content-Encoding': 'gzip', 'Vary': 'Accept-Encoding', 'Content-Length': gz.length });
       res.end(gz);
@@ -9638,7 +9693,7 @@ wss.on('connection', (ws) => {
 loadWorkspaces();
 if (HOME_ENABLED) registerWorkspace(SELF_ROOT);   // the home workspace is hosted (PMOS-self, or the repo the launcher named)
 writeTmuxConf();                   // must exist before restore may reattach or spawn creates
-restorePersisted();
+restorePersisted({ progressive: !REQUIRED_AS_LIBRARY });
 
 // A first shell so the workspace is never empty on first run (honest real PTY). Only when there
 // is a repo to open it IN: an installed copy with no home and no registered repo yet must wait

package/workspace/test-lists/workspace-session-restore.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "workspace-event-loop-lag: a restart with many live sessions asks tmux once for every live pane and restores in slices after the server is listening (session-restore).",
+  "modules": ["session-restore.test.js"],
+  "seconds": { "session-restore.test.js": 12 }
+}