create-pmos 0.247.0 → 0.249.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.247.0",
+  "version": "0.249.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@47bc3dc
+kernel-source: pmos@381bd87
 assembled: 2026-10-15
 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-15T07:42:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-15T09:38:27Z"}
 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-15T07:42:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-15T09:38:27Z"}
 status: stable
 ---
 

package/payload/scripts/delivery-index.js

@@ -78,12 +78,43 @@ function gitCap(root, args) {
   } catch (e) { return { ok: false, out: '', err: String((e && e.message) || e) }; }
 }
 
+// `trunkRef` runs on every call, and each probe is a `git` subprocess started with spawnSync, which holds the whole
+// event loop of a long-lived server (the workspace calls this on every Initiatives and Library request). The answer
+// only changes when a ref the probe reads changes, so it is kept per root against those refs' own content: the loose
+// ref files and the stat of packed-refs. A key that cannot be read falls back to asking git, exactly as before.
+const TRUNK_CANDIDATES = ['origin/main', 'main', 'origin/master', 'master'];
+const trunkMemo = new Map();          // root -> { key, value }
+function trunkKey(root) {
+  const fs = require('fs');
+  const path = require('path');
+  const dotgit = path.join(root, '.git');
+  let common = dotgit;
+  if (!fs.statSync(dotgit).isDirectory()) {
+    const m = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(dotgit, 'utf8'));
+    if (!m) throw new Error('no gitdir');
+    const dir = path.resolve(root, m[1].trim());
+    common = dir;
+    try { common = path.resolve(dir, fs.readFileSync(path.join(dir, 'commondir'), 'utf8').trim()); } catch { /* not a linked worktree */ }
+  }
+  const loose = (rel) => { try { return fs.readFileSync(path.join(common, rel), 'utf8').trim(); } catch { return '-'; } };
+  let packed = '-';
+  try { const st = fs.statSync(path.join(common, 'packed-refs')); packed = `${st.size}:${st.mtimeMs}:${st.ino}`; } catch { /* no packed refs */ }
+  const parts = TRUNK_CANDIDATES.map((c) => loose(c.startsWith('origin/') ? `refs/remotes/${c}` : `refs/heads/${c}`));
+  return [packed, ...parts].join('|');
+}
+
 function trunkRef(root) {
-  for (const c of ['origin/main', 'main', 'origin/master', 'master']) {
+  let key = null;
+  try { key = trunkKey(root); } catch { key = null; }
+  const hit = trunkMemo.get(root);
+  if (key && hit && hit.key === key) return hit.value;
+  let value = null;
+  for (const c of TRUNK_CANDIDATES) {
     const r = gitCap(root, ['rev-parse', '--verify', '--quiet', c]);
-    if (r.ok && r.out.trim()) return { ref: c, head: r.out.trim() };
+    if (r.ok && r.out.trim()) { value = { ref: c, head: r.out.trim() }; break; }
   }
-  return null;
+  if (key) trunkMemo.set(root, { key, value });
+  return value;
 }
 
 // ONE `git log` per trunk head, memoised on that sha — ~0.3 s and ~800 KB on this repository's

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-15T07:42:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-15T09:38:27Z"}
 status: stable
 ---
 

package/workspace/lib/engine/delivery-index.js

@@ -78,12 +78,43 @@ function gitCap(root, args) {
   } catch (e) { return { ok: false, out: '', err: String((e && e.message) || e) }; }
 }
 
+// `trunkRef` runs on every call, and each probe is a `git` subprocess started with spawnSync, which holds the whole
+// event loop of a long-lived server (the workspace calls this on every Initiatives and Library request). The answer
+// only changes when a ref the probe reads changes, so it is kept per root against those refs' own content: the loose
+// ref files and the stat of packed-refs. A key that cannot be read falls back to asking git, exactly as before.
+const TRUNK_CANDIDATES = ['origin/main', 'main', 'origin/master', 'master'];
+const trunkMemo = new Map();          // root -> { key, value }
+function trunkKey(root) {
+  const fs = require('fs');
+  const path = require('path');
+  const dotgit = path.join(root, '.git');
+  let common = dotgit;
+  if (!fs.statSync(dotgit).isDirectory()) {
+    const m = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(dotgit, 'utf8'));
+    if (!m) throw new Error('no gitdir');
+    const dir = path.resolve(root, m[1].trim());
+    common = dir;
+    try { common = path.resolve(dir, fs.readFileSync(path.join(dir, 'commondir'), 'utf8').trim()); } catch { /* not a linked worktree */ }
+  }
+  const loose = (rel) => { try { return fs.readFileSync(path.join(common, rel), 'utf8').trim(); } catch { return '-'; } };
+  let packed = '-';
+  try { const st = fs.statSync(path.join(common, 'packed-refs')); packed = `${st.size}:${st.mtimeMs}:${st.ino}`; } catch { /* no packed refs */ }
+  const parts = TRUNK_CANDIDATES.map((c) => loose(c.startsWith('origin/') ? `refs/remotes/${c}` : `refs/heads/${c}`));
+  return [packed, ...parts].join('|');
+}
+
 function trunkRef(root) {
-  for (const c of ['origin/main', 'main', 'origin/master', 'master']) {
+  let key = null;
+  try { key = trunkKey(root); } catch { key = null; }
+  const hit = trunkMemo.get(root);
+  if (key && hit && hit.key === key) return hit.value;
+  let value = null;
+  for (const c of TRUNK_CANDIDATES) {
     const r = gitCap(root, ['rev-parse', '--verify', '--quiet', c]);
-    if (r.ok && r.out.trim()) return { ref: c, head: r.out.trim() };
+    if (r.ok && r.out.trim()) { value = { ref: c, head: r.out.trim() }; break; }
   }
-  return null;
+  if (key) trunkMemo.set(root, { key, value });
+  return value;
 }
 
 // ONE `git log` per trunk head, memoised on that sha — ~0.3 s and ~800 KB on this repository's

package/workspace/lib/find-browser.js

@@ -26,13 +26,21 @@ const path = require('path');
 // matching (which is the same skip-looks-like-pass failure, arriving later).
 function playwrightCandidates() {
   const roots = [process.env.PLAYWRIGHT_BROWSERS_PATH, '/opt/pw-browsers',
-    path.join(process.env.HOME || '', '.cache', 'ms-playwright')].filter(Boolean);
+    path.join(process.env.HOME || '', '.cache', 'ms-playwright'),
+    path.join(process.env.HOME || '', 'Library', 'Caches', 'ms-playwright')].filter(Boolean);
   const out = [];
   for (const root of roots) {
     let entries = [];
     try { entries = fs.readdirSync(root); } catch { continue; }
     for (const dir of entries.sort().reverse()) {          // newest version first
       if (!/^chromium/.test(dir)) continue;
+      // On a Mac or Windows PC a full Chromium shows in the Dock or taskbar, so a headless shell goes first there. Linux
+      // keeps its order: CI runs the browser suites on the browser it always picked.
+      if (process.platform !== 'linux') out.push(
+        path.join(root, dir, 'chrome-headless-shell-mac-arm64', 'chrome-headless-shell'),
+        path.join(root, dir, 'chrome-headless-shell-mac-x64', 'chrome-headless-shell'),
+        path.join(root, dir, 'chrome-headless-shell-win64', 'chrome-headless-shell.exe'),
+      );
       out.push(
         path.join(root, dir, 'chrome-linux', 'chrome'),
         path.join(root, dir, 'chrome-linux', 'headless_shell'),
@@ -44,15 +52,22 @@ function playwrightCandidates() {
   return out;
 }
 
+/* THE PM'S OWN CHROME IS NOT A TEST BROWSER. A suite that launches /Applications/Google Chrome.app opens a second Chrome
+ * that shows in the Dock and the taskbar for a few seconds, so a parallel run makes Chrome icons flicker on the PM's screen
+ * (and they cannot be opened). Only a headless browser is picked unless PMOS_CHROME / PMOS_CHROMIUM names one, or
+ * PMOS_ALLOW_SYSTEM_CHROME=1 says the visible app is fine (initiative chrome-dock-flicker). */
 function findBrowser() {
+  const visible = process.env.PMOS_ALLOW_SYSTEM_CHROME === '1' ? [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+  ] : [];
   const cands = [
     process.env.PMOS_CHROME,
     process.env.PMOS_CHROMIUM,
     ...playwrightCandidates(),
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-    '/Applications/Chromium.app/Contents/MacOS/Chromium',
     '/usr/bin/google-chrome', '/usr/bin/chromium', '/usr/bin/chromium-browser',
-    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    ...visible,
   ].filter(Boolean);
   return cands.find((c) => { try { fs.accessSync(c, fs.constants.X_OK); return true; } catch { return false; } });
 }

package/workspace/lib/vendor/scripts/delivery-index.js

@@ -78,12 +78,43 @@ function gitCap(root, args) {
   } catch (e) { return { ok: false, out: '', err: String((e && e.message) || e) }; }
 }
 
+// `trunkRef` runs on every call, and each probe is a `git` subprocess started with spawnSync, which holds the whole
+// event loop of a long-lived server (the workspace calls this on every Initiatives and Library request). The answer
+// only changes when a ref the probe reads changes, so it is kept per root against those refs' own content: the loose
+// ref files and the stat of packed-refs. A key that cannot be read falls back to asking git, exactly as before.
+const TRUNK_CANDIDATES = ['origin/main', 'main', 'origin/master', 'master'];
+const trunkMemo = new Map();          // root -> { key, value }
+function trunkKey(root) {
+  const fs = require('fs');
+  const path = require('path');
+  const dotgit = path.join(root, '.git');
+  let common = dotgit;
+  if (!fs.statSync(dotgit).isDirectory()) {
+    const m = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(dotgit, 'utf8'));
+    if (!m) throw new Error('no gitdir');
+    const dir = path.resolve(root, m[1].trim());
+    common = dir;
+    try { common = path.resolve(dir, fs.readFileSync(path.join(dir, 'commondir'), 'utf8').trim()); } catch { /* not a linked worktree */ }
+  }
+  const loose = (rel) => { try { return fs.readFileSync(path.join(common, rel), 'utf8').trim(); } catch { return '-'; } };
+  let packed = '-';
+  try { const st = fs.statSync(path.join(common, 'packed-refs')); packed = `${st.size}:${st.mtimeMs}:${st.ino}`; } catch { /* no packed refs */ }
+  const parts = TRUNK_CANDIDATES.map((c) => loose(c.startsWith('origin/') ? `refs/remotes/${c}` : `refs/heads/${c}`));
+  return [packed, ...parts].join('|');
+}
+
 function trunkRef(root) {
-  for (const c of ['origin/main', 'main', 'origin/master', 'master']) {
+  let key = null;
+  try { key = trunkKey(root); } catch { key = null; }
+  const hit = trunkMemo.get(root);
+  if (key && hit && hit.key === key) return hit.value;
+  let value = null;
+  for (const c of TRUNK_CANDIDATES) {
     const r = gitCap(root, ['rev-parse', '--verify', '--quiet', c]);
-    if (r.ok && r.out.trim()) return { ref: c, head: r.out.trim() };
+    if (r.ok && r.out.trim()) { value = { ref: c, head: r.out.trim() }; break; }
   }
-  return null;
+  if (key) trunkMemo.set(root, { key, value });
+  return value;
 }
 
 // ONE `git log` per trunk head, memoised on that sha — ~0.3 s and ~800 KB on this repository's

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/server.js

@@ -5864,19 +5864,48 @@ function fsList(dir) {
 const TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8',
   '.css': 'text/css; charset=utf-8', '.json': 'application/json', '.map': 'application/json',
   '.svg': 'image/svg+xml', '.woff2': 'font/woff2' };
+// Compression and validators (workspace-event-loop-lag). The app shell is 5.7 MB of script and style and a library answer
+// is about 1 MB of JSON, and none of it was compressed, so a phone or an Online-address visit paid for every byte on every
+// load. A response is gzipped only when the client asks for it and the body is text over the threshold. Gzip runs on the
+// thread pool and never blocks the loop; a served file's gzip is made once per mtime and kept.
+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'] || ''))); };
+const fileMemo = new Map();     // file -> { sig, buf, etag, gz }
+const FILE_MEMO_MAX = 400;
 function serveFile(res, file, type, noCache) {
-  fs.readFile(file, (err, buf) => {
-    if (err) { res.writeHead(404); res.end('not found'); return; }
-    const headers = { 'Content-Type': type || TYPES[path.extname(file)] || 'application/octet-stream' };
-    // The app SHELL (index.html + the /pm/ module graph) must revalidate every load: without this a tab left open
-    // across a `git merge` + server restart keeps running the pre-merge JS, so a fix that IS being
-    // served never reaches the screen. `no-cache` = "always revalidate", not "never store".
-    // Every script and stylesheet revalidates too, not only /pm/: a /lib/ module served with no header was kept by the
-    // browser's heuristic cache, and at the Online address by Cloudflare's edge, so an updated workspace still drew
-    // the old labels (workspace-kit-update). Images and fonts keep the default.
-    if (noCache || /\.(js|mjs|css)$/.test(file)) headers['Cache-Control'] = 'no-cache';
-    res.writeHead(200, headers);
-    res.end(buf);
+  fs.stat(file, (serr, st) => {
+    if (serr || !st.isFile()) { res.writeHead(404); res.end('not found'); return; }
+    const sig = `${st.size}:${st.mtimeMs}`;
+    const send = (m) => {
+      const ctype = type || TYPES[path.extname(file)] || 'application/octet-stream';
+      const headers = { 'Content-Type': ctype, 'ETag': m.etag };
+      // The app SHELL (index.html + the /pm/ module graph) must revalidate every load: without this a tab left open
+      // across a `git merge` + server restart keeps running the pre-merge JS, so a fix that IS being
+      // served never reaches the screen. `no-cache` = "always revalidate", not "never store".
+      // Every script and stylesheet revalidates too, not only /pm/: a /lib/ module served with no header was kept by the
+      // browser's heuristic cache, and at the Online address by Cloudflare's edge, so an updated workspace still drew
+      // the old labels (workspace-kit-update). Images and fonts keep the default.
+      // The ETag keeps that rule cheap: the revalidation of an unchanged file is a 304 with no body.
+      if (noCache || /\.(js|mjs|css)$/.test(file)) headers['Cache-Control'] = 'no-cache';
+      if (GZIP_TYPES.test(ctype)) headers['Vary'] = 'Accept-Encoding';
+      const inm = res.req && res.req.headers && res.req.headers['if-none-match'];
+      if (inm && String(inm).split(',').some((t) => t.trim() === m.etag)) { res.writeHead(304, headers); res.end(); return; }
+      if (m.gz && wantsGzip(res)) { headers['Content-Encoding'] = 'gzip'; headers['Content-Length'] = m.gz.length; res.writeHead(200, headers); res.end(m.gz); return; }
+      res.writeHead(200, headers);
+      res.end(m.buf);
+    };
+    const hit = fileMemo.get(file);
+    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 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(); });
+      else finish();
+    });
   });
 }
 // claims-ledger — the claims ledger and its local checks. Local only: no key, no network. The ledger is file-mode
@@ -5986,8 +6015,17 @@ function readBody(req) {
   return new Promise((resolve) => { let b = ''; req.on('data', (c) => (b += c)); req.on('end', () => resolve(b)); });
 }
 function json(res, obj, code = 200) {
+  const body = JSON.stringify(obj);
+  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 (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);
+    });
+  }
   res.writeHead(code, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(obj));
+  res.end(body);
 }
 
 async function handleRequest(req, res) {

package/workspace/test-files.json

@@ -8,6 +8,7 @@
     "test.js"
   ],
   "modules": [
+    "find-browser.test.js",
     "own-profile.test.js",
     "stage-tools.test.js",
     "report-template-cadence.test.js",

package/workspace/test-lists/workspace-event-loop-lag.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "workspace-event-loop-lag: the server gzips text responses on request, sends an ETag with every served file, and reads the delivery trunk once per ref state (http-compression).",
+  "modules": ["http-compression.test.js"],
+  "seconds": { "http-compression.test.js": 8 }
+}