create-pmos 0.22.0 → 0.24.0

package/workspace/public/pm/data.js

@@ -465,6 +465,29 @@ export function branchOfWorkspace(id) {
   return (id && wsBranch.get(id)) || null;
 }
 
+/**
+ * The same map as a plain object, for `setState`.
+ *
+ * `branchOfWorkspace` answers "what branch is THIS workspace on?", which is all the ＋ session
+ * chooser ever needed. The initiative board asks the other direction — "which initiatives does this
+ * machine have a checkout for, and which of my live sessions is on one?" — and a lookup by id
+ * cannot be enumerated.
+ *
+ * It is PUBLISHED rather than exported as a getter for the reason `productWs` is: a panel that has
+ * to import the data layer to render a row cannot render that row until the import resolves, and
+ * panel 2 is the board. Published, the fact arrives in the same patch as everything else the panel
+ * reads, and the panel needs no adapter at all.
+ *
+ * `wsBranch` stays the single source — this is a projection of it taken at publish time, not a
+ * second copy anything writes to. Nulls are kept out: a folder with no git has no branch, and a map
+ * carrying holes would make every reader re-check the same thing.
+ */
+function branchMap() {
+  const out = {};
+  for (const [id, b] of wsBranch) if (typeof b === 'string' && b) out[id] = b;
+  return out;
+}
+
 /** Group registered working trees into products: several worktrees of one repo share a `repo_key`. */
 function foldWorkspaces(rows) {
   const byRepo = new Map();
@@ -595,7 +618,11 @@ function publishBoards() {
     board[name] = p.board;
     records = { ...records, ...p.records };
   }
-  setState({ board, productWs, records: { ...records, ...(hydrated) } });
+  // `wsBranches` rides the same patch as `productWs` and for the same reason: it is a fact about
+  // every registered working tree, read once from /api/workspaces, that a panel needs in order to
+  // draw a row. panel 2 joins it against `state.sessions` to say which initiative each live agent is
+  // on — the same `initiative/<id>` join lib/four-panel.js makes per initiative on the server.
+  setState({ board, productWs, wsBranches: branchMap(), records: { ...records, ...(hydrated) } });
 }
 
 /* Hydrated (fully derived) records live apart from the light ones so that a board reload cannot

package/workspace/public/pm/panel-initiatives.js

@@ -25,6 +25,33 @@
  * overrides the data layer may publish into state — `state.board` ({repoId: group[]}) and
  * `state.records` ({slug: record}). Nothing here caches anything derivable (D33): groups, counts,
  * search hits and the selected row are computed at read time, every render.
+ *
+ * ── What the board says about YOUR work (workspace-active-visibility) ────────────────────────
+ * On 178 records the filing order is the right filing order and the wrong ATTENTION order, and the
+ * PM could not tell which initiatives they were working on or which had a live agent. Two additions,
+ * both inside the elements that were already here:
+ *
+ *   1. THE ROW'S LEADING SLOT. It held a constant `#` — the Slack channel glyph, ported for its
+ *      look, carrying nothing on every row. On an initiative with a live session it now holds that
+ *      session's glyph, in that session's colour, with every session named in the tooltip. Same
+ *      span, same node count, same geometry. The TRAILING dot is untouched: it is the ladder's, and
+ *      `lightRecord` cannot derive 178 of those without ~30s of `git log`.
+ *
+ *   2. A DERIVED GROUP ABOVE THE OBJECTIVES. Built from `groupNode`, the same element, with the same
+ *      collapse key — derived groups are not new here (`unanchored` and `no record` are both
+ *      constructed in data.js). It lists what a live session, a checked-out working tree, or an open
+ *      tab says the PM is on, ordered so the initiative WAITING on them is the first row.
+ *
+ * Three rules hold it honest. Rows are DUPLICATED, never moved — an initiative keeps its place under
+ * its own anchor, because the anchor is the truth (D59) and a shortcut that re-homes work is a second
+ * filing system. The group is ABSENT, not empty, when nothing is live. And the join is
+ * lib/working-set.js's, which is the server's own `initiative/<id>` two-hopper — so a session the
+ * join cannot reach contributes nothing rather than being bucketed somewhere plausible.
+ *
+ * Fixture mode is structurally unaffected, not conditionally suppressed: `pollSessions` returns early
+ * on FIXTURE and `foldWorkspaces` never runs, so `state.sessions` is empty and there are no branches.
+ * There is no server in fixture mode, so there are no live sessions to claim — the same rule line 45
+ * states in the other direction.
  */
 
 import { el, setChildren } from './dom.js';
@@ -103,6 +130,75 @@ function sessionsOf(slug, DATA) {
   return [...(i.sessions || []), ...((state.extraSess && state.extraSess[slug]) || [])];
 }
 
+/* ── the working set: which initiatives are yours, and which of them are live ─────────────────── */
+
+/** The shared modules, off the globals the way panel-tabs.js reads window.PMOSTreeShare. */
+const WS = () => (typeof window !== 'undefined' ? window.PMOSWorkingSet : null);
+const SS = () => (typeof window !== 'undefined' ? window.PMOSSessionState : null);
+
+/** workspace id → branch, published by the data layer alongside `board` and `productWs`. */
+const branches = () => (state.wsBranches && typeof state.wsBranches === 'object' ? state.wsBranches : {});
+
+/**
+ * Every LIVE session, keyed by the initiative its working tree is on: `{slug: [session…]}`.
+ *
+ * Fixture mode returns nothing and SAYS so rather than relying on the inputs happening to be empty.
+ * `pollSessions` does return early on FIXTURE — but a marker drawn from seed data is "the beautiful
+ * shell" in the PRD's own failure-mode list, and that is not a property to leave resting on a
+ * `return` two modules away.
+ */
+function liveSessions() {
+  if (FIXTURE) return {};
+  const ws = WS();
+  if (!ws) return {};
+  const map = branches();
+  return ws.sessionsByInitiative(state.sessions, (id) => map[id] || null);
+}
+
+/**
+ * The rows the derived group shows, in attention order.
+ *
+ * `onBoard` is what stops a tab or a working tree belonging to ANOTHER repository putting a row on
+ * this repository's board — `slugProduct()` is the same map panel 4 scopes its tabs by.
+ */
+function workingSet(live, product) {
+  if (FIXTURE) return [];
+  const ws = WS();
+  if (!ws) return [];
+  const owner = slugProduct();
+  return ws.workingSet({
+    live,
+    trees: ws.initiativesWithTree(Object.values(branches())),
+    tabs: ws.initiativesWithTab(state.tabs),
+    onBoard: (slug) => owner[slug] === product,
+  });
+}
+
+/**
+ * The row's leading slot, for one initiative: `['#', colour, title]` when nothing is live, and the
+ * session's own glyph/colour/tooltip when something is.
+ *
+ * The vocabulary is `window.PMOSSessionState`'s — the module index.html loads for exactly this
+ * reason ("ONE table, TWO consumers"). Not `FX.SDOT`, which is the design prototype's seed data,
+ * parity-locked to prototype-original.html, and which gives `working` and `needs` the same ● and
+ * separates them by hue alone. On a board the PM scans, a signal that dies in greyscale is not a
+ * signal.
+ */
+const HASH = ['#', 'var(--muted-foreground)', ''];
+
+function leadOf(slug, live) {
+  const rows = live[slug];
+  if (!rows || !rows.length) return HASH;
+  const ss = SS();
+  const ws = WS();
+  if (!ss || !ws) return HASH;
+  const st = ws.stateOf(rows);
+  // A state the table does not know is NOT drawn. Falling back to a generic dot here would put a
+  // mark on the board that no vocabulary can explain, which is the one thing worse than no mark.
+  if (!st || !ss.GLYPH[st]) return HASH;
+  return [ss.GLYPH[st], ss.COLOR[st] || 'var(--muted-foreground)', ws.sessionTitle(slug, rows)];
+}
+
 /** Which repository owns each slug (lines 1963–1965) — the tab-scoping key. */
 function slugProduct() {
   const map = {};
@@ -221,8 +317,14 @@ function groupNode(g, product) {
         onClick: () => setState({ sel: it.slug, detail: { kind: 'init' }, col2: true }),
         style: 'display:flex;align-items:center;gap:7px;width:100%;padding:5px 12px 5px 27px;min-height:32px;border-left:2px solid ' + it.bl + ';background:' + it.bg,
         hover: 'background:var(--accent)',
+        // Stated where the PM is standing, not only in a tooltip on the glyph: on a working-set row
+        // this names WHICH of the three signals put it there. The glyph summarises; this does not.
+        title: it.why || null,
       },
-        el('span', { style: 'flex:none;font-size:12px;color:var(--muted-foreground)' }, '#'),
+        // ① The slot that used to be a constant. `#` when nothing is live — byte-identical to what
+        // shipped, which is what keeps the comparator's text axis clean — and the session's own
+        // glyph when something is. One span either way: no node added, no geometry moved.
+        el('span', { style: 'flex:none;font-size:12px;color:' + it.leadC, title: it.leadT || null }, it.lead),
         el('span', { style: 'font-family:var(--mono);font-size:12.5px;color:var(--foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(it.slug)),
         el('span', { style: 'margin-left:auto;flex:none;font-size:9px;color:' + it.l2c, title: it.l2b }, '●'),
       ));
@@ -238,22 +340,44 @@ function groupNode(g, product) {
 
 /* ── "matches elsewhere" — artifacts and sessions that the group list cannot show ──────────── */
 
-function searchHits(q, DATA) {
+/**
+ * `searchHits` used to read sessions off `record.sessions` ONLY — and board records are LIGHT, with
+ * `sessions: []`, until the PM opens one. So a search for a session's name returned nothing for 177
+ * of 178 initiatives, silently, with no indication that the search had not looked. The hit was
+ * scoped to hydrated records and nothing said so.
+ *
+ * `live` closes it: the same join the row markers use, over every session the server has published,
+ * regardless of what has been hydrated. The old path is KEPT rather than replaced — it also carries
+ * `state.extraSess`, the sessions this window started, which have no server row until the next poll.
+ * `seen` is what stops one session arriving twice when both paths find it.
+ */
+function searchHits(q, DATA, live) {
   const hits = [];
   if (!q) return hits;
+  const seen = new Set();
+  const push = (slug, s) => {
+    const key = slug + '|' + (s.id || s.name);
+    if (seen.has(key)) return;
+    seen.add(key);
+    hits.push({
+      kind: 'session · ' + slug,
+      label: s.name + ' · ' + (s.label || s.shown || s.st || ''),
+      on: () => { setState({ sel: slug, detail: { kind: 'init' } }); openTerm(slug, s); },
+    });
+  };
   Object.keys(DATA).forEach((slug) => {
     (DATA[slug].arts || []).forEach((a) => {
       if (a.path.toLowerCase().includes(q)) {
         hits.push({ kind: 'artifact · ' + a.role, label: a.path, on: () => openDoc(slug, a.path, a.role) });
       }
     });
-    sessionsOf(slug, DATA).forEach((s) => {
-      if (s.name.toLowerCase().includes(q)) {
-        hits.push({
-          kind: 'session · ' + slug, label: s.name + ' · ' + s.label,
-          on: () => { setState({ sel: slug, detail: { kind: 'init' } }); openTerm(slug, s); },
-        });
-      }
+    sessionsOf(slug, DATA).forEach((s) => { if (s.name.toLowerCase().includes(q)) push(slug, s); });
+  });
+  Object.keys(live || {}).forEach((slug) => {
+    (live[slug] || []).forEach((s) => {
+      // The server's row calls the presented state `shown`; a record's row calls it `st`. `openTerm`
+      // reads `st`, so the shape is normalised HERE rather than teaching the opener a second one.
+      if (s.name && s.name.toLowerCase().includes(q)) push(slug, { ...s, st: s.shown });
     });
   });
   return hits.slice(0, 8);
@@ -398,23 +522,54 @@ export function renderInitiatives(host) {
   const DATA = records();
   const selSlug = selectedSlug();
   const detKind = (state.detail && state.detail.kind) || '';
+  // ONE join per render, shared by the row markers, the working-set group and the search. Computing
+  // it three times would be three chances to disagree about one fact.
+  const live = liveSessions();
+
+  /** One row's view model. `why` is null everywhere except in the working-set group. */
+  const rowOf = (slug, why) => {
+    const i = DATA[slug];
+    // The prototype reads `i.l2` unguarded; a real repository can hand back a slug with no
+    // record at all, and a board that throws is worse than a row that reads "no record".
+    const l2 = (i && i.l2) || ['', '', FX.C.mut];
+    const [lead, leadC, leadT] = leadOf(slug, live);
+    return {
+      slug, ...selRow(slug === selSlug && detKind === 'init'),
+      l2a: l2[0], l2b: l2[1], l2c: l2[2], lead, leadC, leadT, why: why || null,
+    };
+  };
 
   let total = 0;
   const groups = groupsFor(product).map((g) => {
-    const inits = g.slugs.filter((s) => !q || s.includes(q)).map((slug) => {
-      const i = DATA[slug];
-      // The prototype reads `i.l2` unguarded; a real repository can hand back a slug with no
-      // record at all, and a board that throws is worse than a row that reads "no record".
-      const l2 = (i && i.l2) || ['', '', FX.C.mut];
-      return { slug, ...selRow(slug === selSlug && detKind === 'init'), l2a: l2[0], l2b: l2[1], l2c: l2[2] };
-    });
+    const inits = g.slugs.filter((s) => !q || s.includes(q)).map((slug) => rowOf(slug, null));
     total += inits.length;
     return { ...g, inits, isEmpty: inits.length === 0 };
   }).filter((g) => g.inits.length > 0 || (g.dyn && !q));
 
-  const hits = searchHits(q, DATA);
+  const hits = searchHits(q, DATA, live);
 
   const kids = [header, searchBox];
+  /* THE WORKING SET, pinned above the Objectives.
+   *
+   * It is `groupNode` — the same element, the same collapse key, the same forced-open-on-search
+   * rule — and it is NOT in `groups`, deliberately: it must not be counted in `total`, because
+   * `total` decides the "nothing matches" line and a duplicate row is not a second match.
+   *
+   * `hasKr` is reused to state the derivation. That slot renders an id and a sentence under a group
+   * header, which is exactly the shape "what is this group?" needs, and reusing it is what the PM
+   * asked for ("use the existing one"). It carries no KR here and claims none.
+   *
+   * Absent when empty. Not a "0", not a placeholder: a heading over nothing is a heading the PM
+   * learns to skip. */
+  const now = workingSet(live, product).filter((e) => !q || e.slug.includes(q));
+  if (now.length) {
+    kids.push(groupNode({
+      gid: 'NOW', dyn: true, idc: FX.C.brand, gname: 'working on', gct: String(now.length),
+      hasKr: true, krid: '⑂', krname: 'live sessions · checked-out trees · open tabs',
+      inits: now.map((e) => rowOf(e.slug, WS() ? WS().reasonTitle(e) : null)),
+      isEmpty: false,
+    }, product));
+  }
   for (const g of groups) kids.push(groupNode(g, product));
   kids.push(fileNewRow);
   if (hits.length) {

package/workspace/server.js

@@ -922,71 +922,58 @@ function library(root) {
 // ("— not tracked"), never invented (D14/D40 honesty).
 const PHASE_OF = { planning: 'plan', building: 'deliver', blocked: 'deliver', delivered: 'report', accepted: 'report', unknown: 'plan' };
 
-// ── Delivery evidence (board-delivery-truth R-2/R-3). ──────────────────────────────────────────
+// ── Delivery evidence (board-delivery-truth R-2/R-3; shared reader, workflow-status-sweep R-1). ──
 // "Has this shipped?" answered from the trunk's own history rather than from anything anyone typed.
 //
-// ONE `git log` per trunk head, memoised on that sha — ~0.3s and ~800 KB on this repo's 1,214
-// commits, paid once and reused by every surface until the trunk moves. Local only: git reads the
-// object store on disk, so the suite's "no network" guarantee (K. Surfaces) is untouched.
+// THIS DERIVATION NO LONGER LIVES HERE. It was module-private to this file, which meant the GUI's
+// initiative board answered the question with attribution while the engine's ladder
+// (`scripts/workflow-state.js`) answered it without any — `buildCommits` counted every build commit
+// in a range with no idea which initiative it was answering about, and over the trunk reported the
+// same 488 commits as evidence for all 177 initiatives. Two readers, one repository, different
+// answers to "did this ship". `scripts/delivery-index.js` is now the single reader, in the same
+// shape and for the same reason as `scripts/anchor-resolve.js`; its header carries the two-signal
+// rationale that used to be written here.
 //
-// TWO signals, because one is not enough. The branch convention (`initiative/<id>`) is precise but
-// incomplete: 31% of this repo's merged PRs shipped on `claude/*` branches, which match no id. So a
-// commit that MENTIONS the id and TOUCHES a build path counts too. The build-path requirement is
-// what keeps the mention signal honest — `feat(planning): add <id> PRD` mentions the id while
-// delivering nothing, and without the path test every specified initiative would read as shipped.
-const BUILD_EXCLUDE = /^(planning|okf|prototype)\//;
-function isDeliveryPath(f) {
-  if (!f) return false;
-  if (BUILD_EXCLUDE.test(f)) return false;
-  return !/^[^/]+\.md$/.test(f);      // root governance prose (DECISIONS.md, CLAUDE.md…) is not a build
-}
-const deliveryCache = new Map();      // root -> { head, index }
-function trunkRef(root) {
-  for (const c of ['origin/main', 'main', 'origin/master', 'master']) {
-    const r = gitCap(root, ['rev-parse', '--verify', '--quiet', c]);
-    if (r.ok && r.out.trim()) return { ref: c, head: r.out.trim() };
+// Resolution follows the ANCHOR_LIB_PATHS pattern below: a repo checkout first (so a dev surface and
+// CI cannot disagree), then the copy `scripts/vendor-workspace-engine.js` vendors into the bundle.
+// The engine requires this module, so it is already inside the vendored closure — an adopter's
+// install carries it without a second packaging step to remember.
+const DELIVERY_LIB_PATHS = [
+  path.join(__dirname, '..', 'scripts', 'delivery-index.js'),
+  path.join(__dirname, 'lib', 'engine', 'delivery-index.js'),
+];
+function deliveryLib() {
+  for (const p of DELIVERY_LIB_PATHS) {
+    if (!fs.existsSync(p)) continue;
+    try { return require(p); } catch { return null; }
   }
   return null;
 }
-function gitCap(root, args) {
-  try {
-    const r = spawnSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
-    if (r.error || r.status !== 0) return { ok: false, out: '', err: (r.stderr || (r.error && r.error.message) || '').trim() };
-    return { ok: true, out: r.stdout || '' };
-  } catch (e) { return { ok: false, out: '', err: String((e && e.message) || e) }; }
+function isDeliveryPath(f) {
+  const D = deliveryLib();
+  // Absent library → no path can be CONFIRMED as a delivery path. Returning `true` here would let
+  // every commit count as delivery evidence in exactly the install where the evidence cannot be
+  // read, which is the false-green direction. `deliveryIndex` below reports the absence out loud.
+  return D ? D.isDeliveryPath(f) : false;
 }
 /**
  * → { ok, reason?, byBranch:Set<id>, byMention:Set<id> }
  * `ok:false` is a REAL answer and never degrades into "nothing was delivered" — the caller renders
  * it red and marks every initiative's delivery `unknown` (R-3). A board that cannot read the
  * history must say so; silently reporting `planning` for 110 shipped initiatives is the failure
- * this whole initiative exists to remove.
+ * this whole initiative exists to remove. A missing library is the same class of answer as an
+ * unreadable history and takes the same `ok:false` path.
  */
 function deliveryIndex(root, ids) {
-  const t = trunkRef(root);
-  if (!t) return { ok: false, reason: 'no trunk branch (main/master) is reachable from this repository — delivery cannot be derived', byBranch: new Set(), byMention: new Set() };
-  const hit = deliveryCache.get(root);
-  if (hit && hit.head === t.head) return hit.index;
-
-  // %x1e separates commits, %x1f separates the message from --name-only's file list.
-  const r = gitCap(root, ['log', '--format=%x1e%s %b%x1f', '--name-only', t.head]);
-  if (!r.ok) {
-    return { ok: false, reason: `git could not read the history at ${t.ref}${r.err ? ` — ${r.err}` : ''}`, byBranch: new Set(), byMention: new Set() };
-  }
-  const byBranch = new Set(), byMention = new Set();
-  const known = Array.isArray(ids) ? ids : [...ids];
-  for (const chunk of r.out.split('\x1e')) {
-    if (!chunk.trim()) continue;
-    const cut = chunk.indexOf('\x1f');
-    const msg = cut < 0 ? chunk : chunk.slice(0, cut);
-    const files = cut < 0 ? [] : chunk.slice(cut + 1).split('\n').map((s) => s.trim()).filter(Boolean);
-    for (const m of msg.matchAll(/initiative\/([A-Za-z0-9][\w.-]*)/g)) byBranch.add(m[1]);
-    if (!files.some(isDeliveryPath)) continue;
-    for (const id of known) if (id.length > 3 && msg.includes(id)) byMention.add(id);
-  }
-  const index = { ok: true, byBranch, byMention };
-  deliveryCache.set(root, { head: t.head, index });
-  return index;
+  const D = deliveryLib();
+  if (!D) {
+    return {
+      ok: false,
+      reason: 'the delivery reader (scripts/delivery-index.js) is not present in this install — delivery cannot be derived here',
+      byBranch: new Set(), byMention: new Set(),
+    };
+  }
+  return D.deliveryIndex(root, ids);
 }
 /**
  * The five states, in precedence order. Every one of them names the artifact it was read from, so
@@ -3256,6 +3243,10 @@ async function handleRequest(req, res) {
   if (p === '/lib/mobile-nav.js') return serveFile(res, path.join(__dirname, 'lib', 'mobile-nav.js'));
   if (p === '/lib/session-state.js') return serveFile(res, path.join(__dirname, 'lib', 'session-state.js'));
   if (p === '/lib/tree-share.js') return serveFile(res, path.join(__dirname, 'lib', 'tree-share.js'));
+  // Which initiatives the PM is working on, and which of those are live. The session→initiative join
+  // is the same two-hopper lib/four-panel.js makes per initiative on the server; the board makes it
+  // once over every session, from this module, so 178 rows cost no requests.
+  if (p === '/lib/working-set.js') return serveFile(res, path.join(__dirname, 'lib', 'working-set.js'));
   // The editor computes its live diff with the SAME module the server saves through, so what the PM
   // sees while typing and what gets written cannot disagree. NB: /lib/ is an explicit allowlist, not
   // a directory route — a <script src> for a file missing from this list 404s silently, and the