create-pmos 0.25.0 → 0.27.0

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

@@ -45,8 +45,21 @@
  * 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.
+ * lib/working-set.js's — so a session the join cannot reach never lands on a row it does not belong
+ * to.
+ *
+ * ── What that first cut got wrong (workspace-session-attribution) ────────────────────────────
+ * It joined on the `initiative/<id>` branch convention ALONE, which holds in one of four ordinary
+ * situations — and the proof was this file's own history: the initiative that shipped this group was
+ * built on a `claude/*` branch, so the group could not see the session that wrote it. A session now
+ * RECORDS what it is for, and `attributeSessions` resolves recorded → branch → unattributed, saying
+ * which path answered.
+ *
+ * The other half was worse than a narrow join. A session the board could not place was DROPPED, so a
+ * running agent was invisible on the surface whose job is to say what is running. Refusing to guess
+ * and refusing to mention are different things, and only the first is honesty — hence `orphanRows`,
+ * which lists them under the group, claims no initiative for them, and offers the bind that turns
+ * the PM's knowledge into a recorded declaration.
  *
  * 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.
@@ -148,11 +161,26 @@ const branches = () => (state.wsBranches && typeof state.wsBranches === 'object'
  * `return` two modules away.
  */
 function liveSessions() {
-  if (FIXTURE) return {};
+  return attribution().byInitiative;
+}
+
+/**
+ * The full attribution — `{byInitiative, via, unattributed}` — computed ONCE per render and shared
+ * by the row markers, the working-set group, the unattributed row and the search. Deriving it three
+ * times would be three chances to disagree about one fact.
+ *
+ * The join now prefers what a session RECORDED over what its branch is called; `via` says which
+ * answered, and `unattributed` is every live session neither path could place. That last list is
+ * why this returns the whole shape rather than just the map: a running agent PMOS cannot attribute
+ * still has to be visible somewhere, and dropping it was half the defect this fixes.
+ */
+function attribution() {
+  const empty = { byInitiative: {}, via: {}, unattributed: [] };
+  if (FIXTURE) return empty;
   const ws = WS();
-  if (!ws) return {};
+  if (!ws || typeof ws.attributeSessions !== 'function') return empty;
   const map = branches();
-  return ws.sessionsByInitiative(state.sessions, (id) => map[id] || null);
+  return ws.attributeSessions(state.sessions, (id) => map[id] || null);
 }
 
 /**
@@ -161,13 +189,14 @@ function liveSessions() {
  * `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) {
+function workingSet(attr, product) {
   if (FIXTURE) return [];
   const ws = WS();
   if (!ws) return [];
   const owner = slugProduct();
   return ws.workingSet({
-    live,
+    live: attr.byInitiative,
+    via: attr.via,
     trees: ws.initiativesWithTree(Object.values(branches())),
     tabs: ws.initiativesWithTab(state.tabs),
     onBoard: (slug) => owner[slug] === product,
@@ -224,9 +253,25 @@ export function openTab(tab) {
 }
 
 export function openTerm(slug, sess) {
+  /* THE TAB ID, and why a session with no initiative gets a different one.
+   *
+   * `term:<slug>:<name>` is the id every initiative-opened terminal has always had, and it is what
+   * makes `openTab` focus an already-open tab instead of duplicating it. A session PMOS cannot place
+   * on an initiative has no slug — and interpolating one anyway produced `term:null:agent 1`, where
+   * every unattributed session with the same name would collide on one tab. Keying those by the
+   * SERVER's own session id instead is both collision-free and more honest: the tab is a view of
+   * that process, not of an initiative it does not belong to. */
+  const key = slug ? 'term:' + slug + ':' + sess.name : 'term:sess:' + ((sess && sess.id) || sess.name);
   openTab({
-    id: 'term:' + slug + ':' + sess.name, kind: 'term', title: sess.name, slug,
-    repo: slugProduct()[slug], sess: sess.name, state: sess.st, profile: sess.profile || 'claude-work',
+    id: key, kind: 'term', title: sess.name, slug: slug || null,
+    /* `profile` is the session's OWN, or null — never the literal 'claude-work'. It used to default
+     * to that string, which was a claim about a descriptor this client had never read: nothing in
+     * data.js reads /api/profiles, so the name was invented here and then filed on the session. It
+     * also became load-bearing the moment the tab's profile started travelling to the server on a
+     * spawn, because `resolveProfileForSpawn` REFUSES a profile it cannot find — a fabricated
+     * default would have turned "no profile chosen" into "session refused". Every display reader
+     * (fixture.js:853, modes.js:658/808) already supplies its own fallback for null. */
+    repo: slug ? slugProduct()[slug] : null, sess: sess.name, state: sess.st, profile: sess.profile || null,
     /* The SERVER's session id, when the row that was clicked carries one. This is the exact join:
      * with it, the terminal attaches to precisely the PTY the PM pointed at, and a reload attaches
      * to the same one again. Without it the tab falls back to matching by NAME, and names repeat
@@ -333,11 +378,67 @@ function groupNode(g, product) {
       body.push(el('div', { style: 'padding:5px 12px 6px 27px;font-size:11px;color:var(--muted-foreground);font-style:italic' },
         'nothing filed yet — a successful read of nothing'));
     }
+    // Rows this group carries that are NOT initiatives — today, the live sessions PMOS cannot place.
+    // Appended by the caller so `groupNode` stays the one renderer and does not learn a second model.
+    if (g.after) body.push(g.after);
   }
 
   return el('div', { style: 'margin-top:4px' }, groupHeader, body);
 }
 
+/* ── the live sessions PMOS cannot place ──────────────────────────────────────────────────────
+ *
+ * One row per unattributable live session, under the working-set group, in the same row shape the
+ * initiatives use so the eye reads one list. It deliberately does NOT look like an initiative row:
+ * the id slot carries the session's own name and its glyph is the session state, because this row
+ * stands for a process, not for a record.
+ *
+ * Clicking it opens that session's terminal — the same `openTerm` join every other session click
+ * uses, by the server's id, with no `spawn`. `＋ bind` is the second control: it turns the PM's
+ * knowledge of what the session is for into a recorded declaration, which is the only way a session
+ * started before this field existed can ever join an initiative.
+ */
+function orphanRows(rows) {
+  const ss = SS();
+  const ws = WS();
+  const head = el('div', {
+    style: 'display:flex;align-items:baseline;gap:6px;padding:6px 12px 3px 27px',
+    title: ws ? ws.unattributedTitle(rows) : null,
+  },
+    el('span', { style: 'flex:none;font-family:var(--mono);font-size:10px;color:var(--warning)' }, iv('⌁')),
+    el('span', { style: 'font-size:10.5px;color:var(--muted-foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' },
+      iv('not on an initiative — ' + rows.length + ' live session' + (rows.length === 1 ? '' : 's'))),
+  );
+
+  const body = rows.map((s) => {
+    const st = ss && ss.GLYPH[s.shown] ? s.shown : null;
+    return el('button', {
+      onClick: () => openTerm(null, { name: s.name, st: s.shown, label: s.label, id: s.id, profile: s.profile_id }),
+      style: 'display:flex;align-items:center;gap:7px;width:100%;padding:5px 12px 5px 27px;min-height:32px;border-left:2px solid transparent;background:transparent',
+      hover: 'background:var(--accent)',
+      title: (s.name || s.id) + ' — ' + (s.label || s.shown || '')
+        + '\nPMOS was never told what this session is for. ＋ bind records it.',
+    },
+      el('span', { style: 'flex:none;font-size:12px;color:' + (st && ss ? ss.COLOR[st] : 'var(--muted-foreground)') },
+        st && ss ? ss.GLYPH[st] : '·'),
+      el('span', { style: 'font-family:var(--mono);font-size:12.5px;color:var(--foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' },
+        iv(s.name || s.id)),
+      el('span', { style: 'margin-left:auto;flex:none;font-size:9px;color:var(--muted-foreground)' }, iv(s.label || s.shown || '')),
+    );
+  });
+
+  const bind = el('button', {
+    onClick: () => setState({ bindSess: rows.length === 1 ? rows[0].id : null, bindResult: null, detail: { kind: 'bind' }, col2: true }),
+    style: 'display:flex;align-items:center;gap:7px;width:100%;padding:6px 12px 6px 27px;color:var(--muted-foreground)',
+    hover: 'color:var(--foreground);background:var(--accent)',
+  },
+    el('span', { style: 'flex:none;width:9px;text-align:center;font-size:14px' }, '＋'),
+    el('span', { style: 'font-size:11px' }, 'bind a session to an initiative'),
+  );
+
+  return el('div', null, head, body, bind);
+}
+
 /* ── "matches elsewhere" — artifacts and sessions that the group list cannot show ──────────── */
 
 /**
@@ -522,9 +623,10 @@ 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 attribution per render, shared by the row markers, the working-set group, the unattributed
+  // row and the search. Computing it four times would be four chances to disagree about one fact.
+  const attr = attribution();
+  const live = attr.byInitiative;
 
   /** One row's view model. `why` is null everywhere except in the working-set group. */
   const rowOf = (slug, why) => {
@@ -561,13 +663,26 @@ export function renderInitiatives(host) {
    *
    * 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) {
+  const now = workingSet(attr, product).filter((e) => !q || e.slug.includes(q));
+  /* EVERY LIVE SESSION PMOS CANNOT PLACE (workspace-session-attribution R5).
+   *
+   * The board shipped joining on the `initiative/<id>` branch alone, so a session on `main`, on a
+   * `claude/*` branch, or in a repo with no git simply vanished from it. Refusing to guess which
+   * initiative it belongs to is right; refusing to MENTION it is not, and only the first is honesty.
+   *
+   * It is rendered as a row inside the same group rather than as a group of its own, because it is
+   * not an initiative and must not sit in a list keyed by one. `＋ bind` opens the chooser that
+   * turns it into the PM's own declaration. */
+  const orphans = q ? [] : (attr.unattributed || []);
+  if (now.length || orphans.length) {
+    const rows = now.map((e) => rowOf(e.slug, WS() ? WS().reasonTitle(e) : null));
     kids.push(groupNode({
-      gid: 'NOW', dyn: true, idc: FX.C.brand, gname: 'working on', gct: String(now.length),
+      gid: 'NOW', dyn: true, idc: FX.C.brand, gname: 'working on',
+      gct: String(now.length + orphans.length),
       hasKr: true, krid: '⑂', krname: 'live sessions · checked-out trees · open tabs',
-      inits: now.map((e) => rowOf(e.slug, WS() ? WS().reasonTitle(e) : null)),
+      inits: rows,
       isEmpty: false,
+      after: orphans.length ? orphanRows(orphans) : null,
     }, product));
   }
   for (const g of groups) kids.push(groupNode(g, product));