create-pmos 0.23.0 → 0.25.0

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/public/pm/state.js

@@ -37,6 +37,12 @@ function initial() {
     detail: { kind: 'init' },
     tabs: [], active: null, splitId: null,
     initLinks: {}, artLinks: {}, artSyncOpen: {}, artSyncState: {},
+    /* The sync half of panel 3, all per-window and none of it persisted. `artSyncTask` holds the
+     * task text the server composed for a direction the PM just chose; `linkGone` holds the
+     * references withdrawn since the last hydration, so a retracted row leaves the screen at the
+     * click rather than at the next read. Neither is a source of truth — what a link IS and what
+     * was synced both come back from the store on the next `/api/initiative`. */
+    artSyncTask: {}, linkGone: {},
     extraSess: {}, termHist: {}, startN: 1, docEdits: {}, docModes: {},
     /* `＋ session` into a working tree that already has sessions in it opens a CHOOSER instead of
      * spawning (workspace-session-choice): `{slug, tree, branch, peers}` while it is open, null

package/workspace/server.js

@@ -702,11 +702,21 @@ function readTextDoc(root, rel) {
 // falling back to the filename convention when an artifact declares nothing.
 // Ordered LONGEST-DISCRIMINATOR-FIRST: `-copy-brief` must be tested before `-brief`, and
 // `-eval-rubric` before any `-rubric`, because the first match wins and slices the stem.
+//
+// The qualified-brief entries (`-comms-brief`, `-launch-brief`) are here for a reason worth stating,
+// because it is the same reason `-copy-brief` was: a stem ending `-comms-brief` ALSO ends `-brief`,
+// so without its own entry it matches the shorter one and the slice leaves a `-comms` tail on the
+// stem. That tail belongs to the qualifier, not to the initiative, and it is enough to put a comms
+// brief in a different group from the PRD it was written for — which is precisely what the PM
+// reported seeing (PRD, defect 3).
 const ROLE_SUFFIXES = [
   ['-eval-rubric', 'rubric'], ['-design-brief', 'design brief'], ['-design-reference', 'design'],
-  ['-copy-brief', 'copy brief'], ['-user-stories', 'user stories'], ['-copy', 'copy'],
+  ['-copy-brief', 'copy brief'], ['-comms-brief', 'comms brief'], ['-launch-brief', 'launch brief'],
+  ['-user-stories', 'user stories'], ['-user-story', 'user stories'], ['-stories', 'user stories'],
+  ['-one-pager', 'one-pager'], ['-copy', 'copy'],
   ['-dogfood', 'dogfood'], ['-reconcile', 'reconcile'], ['-findings', 'findings'],
   ['-scoping', 'scoping'], ['-intake', 'intake'], ['-brief', 'brief'], ['-prd', 'PRD'],
+  ['-spec', 'spec'],
 ];
 const ROLE_BY_DIR = {
   prd: 'PRD', evals: 'eval', design: 'design', research: 'research', briefs: 'brief',
@@ -864,12 +874,34 @@ function initiativeIndex(root) {
   for (const m of metas) if (!m.initiative) byStem.set(m.stem, (byStem.get(m.stem) || 0) + 1);
   const groups = new Map();
   const ungrouped = [];
+  // PREFIX ATTACHMENT, and the three constraints that keep it from becoming a similarity score.
+  //
+  // The join above is stem EQUALITY, and equality is the wrong shape for how PMs name files. An
+  // initiative `ooh-zbsg-ast1` carries `ooh-zbsg-ast1-design-prd.md`, `ooh-zbsg-ast1-user-stories.md`
+  // and `ooh-zbsg-ast1-comms-brief.md`; after the role suffix is sliced those are three DIFFERENT
+  // stems, so the initiative's own PRD was attributed to no initiative and never reached panel 3.
+  // Measured on this repository one initiative ago: 148 documents attributed to nothing, 31 of them
+  // beginning with a declared id.
+  //
+  //   1. Only EXPLICITLY DECLARED ids may capture (`declared`, not `groups`). A group that exists
+  //      only because two filenames happened to share a stem was never named by anyone, and giving
+  //      it the authority to claim documents would let a naming coincidence annex a neighbourhood.
+  //   2. LONGEST WINS, so `workspace-session-choice-prd.md` cannot be captured by `workspace-session`
+  //      when both are declared. Sorted once per call, not per document.
+  //   3. It runs LAST, after equality and after the convention join, so it can only move a document
+  //      that would otherwise be `ungrouped`. It cannot take a document away from a group that has a
+  //      better claim on it, which is what makes the total document count provably unchanged.
+  //
+  // The boundary being held here is the one `lib/related-docs.js` holds for the same reason: a
+  // concrete tie, never "feels related". `x-` is a tie the PM typed. Similarity is not.
+  const capturing = [...declared].sort((a, b) => b.length - a.length);
+  const prefixOwner = (stem) => capturing.find((id) => stem.length > id.length + 1 && stem.startsWith(id + '-')) || null;
   const keyFor = (m) => {
     if (m.initiative) return m.initiative;
     if (declared.has(m.stem)) return m.stem;
     // the convention join: `jira-sync-prd.md` + `jira-sync-eval-rubric.md` are one unit
     if ((byStem.get(m.stem) || 0) > 1) return m.stem;
-    return null;
+    return prefixOwner(m.stem);
   };
   for (const m of metas) {
     const k = keyFor(m);
@@ -3243,6 +3275,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
@@ -3948,6 +3984,7 @@ async function handleRequest(req, res) {
         : null,
       artifactLinks: fourPanel.readDeclarations(stateDir, fourPanel.ARTIFACT_LINKS),
       initiativeLinks: fourPanel.readDeclarations(stateDir, fourPanel.INITIATIVE_LINKS),
+      artifactSync: fourPanel.readDeclarations(stateDir, fourPanel.ARTIFACT_SYNC),
       // Which destinations a session could look up, derived from the PM's agent profiles. The home
       // directory is passed IN rather than read inside four-panel.js for the same reason
       // readProfiles takes it as a parameter: a module that reads os.homedir() itself can only be
@@ -3982,6 +4019,36 @@ async function handleRequest(req, res) {
     // A write that failed returns 500 and says so — never a false green (the /api/gate rule).
     return json(res, { ...wrote, connectors: fourPanel.connectors(os.homedir()) }, wrote.ok ? 200 : 500);
   }
+  if (p === '/api/initiative/sync' && req.method === 'POST') {
+    // The PM chose a direction for a link they already recorded, or a session is reporting what it
+    // did about one. Both arrive here, and the difference between them is exactly the difference the
+    // store enforces: a direction the PM chose is `proposed` and claims nothing, while a session's
+    // report is `applied` and is REFUSED unless it names the profile that performed it.
+    //
+    // This route composes the task text and appends the row. It performs no sync — there is no
+    // branch here that contacts Confluence, Jira or Google, and there cannot be one: the workspace
+    // holds no credential (D53), and `no-network.test.js` asserts the absence structurally.
+    const w = getWs(url.searchParams.get('ws'));
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w2 = body.ws ? getWs(body.ws) : w;
+    const built = fourPanel.syncRow(body);
+    if (!built.ok) return json(res, { ok: false, error: built.error }, 400);
+    const task = fourPanel.syncTask({
+      direction: built.row.direction, kind: built.row.kind,
+      artifact_path: built.row.artifact_path, target: built.row.target, profile: body.profile || null,
+    });
+    const engine = consoleState.loadEngine();
+    if (!engine.ok) return json(res, { ok: false, error: engine.error }, 500);
+    const stateDir = fourPanel.storeDir(engine.engine, w2 ? w2.root : SELF_ROOT);
+    const wrote = fourPanel.appendDeclaration(stateDir, fourPanel.ARTIFACT_SYNC, built.row);
+    // A write that failed returns 500 and says so — never a false green (the /api/gate rule). The
+    // task is returned either way: a PM whose store is unwritable can still run the work by hand,
+    // and withholding the text would turn a recording failure into a capability failure.
+    return json(res, { ...wrote, task: task.ok ? task.text : null, task_error: task.ok ? null : task.error },
+      wrote.ok ? 200 : 500);
+  }
   if (p === '/api/initiative/lookup-task' && req.method === 'POST') {
     // The task a SESSION runs to resolve a reference. This endpoint composes a string and returns
     // it. It contacts nothing — that is the entire point of the design: PMOS describes the lookup,