create-pmos 0.23.0 → 0.24.0

package/README.md

@@ -333,6 +333,34 @@ Refreshes the skills, concepts, and scripts only. Your records — `state/`, `pl
 `okf/product/` — are yours, and an update never touches them. `pmos/KIT-VERSION` always says
 exactly what you're running.
 
+## What's new in 0.24.0
+
+**The initiative board says which work is yours, and which of it has an agent running.** Run
+`npx create-pmos@latest workspace`; the version bump means an existing install auto-upgrades.
+
+- **A `NOW · working on` group is pinned at the top of the board.** With a few dozen initiatives
+  filed by objective, the list is in the right *filing* order and the wrong *attention* order — the
+  one you have an agent running on sits wherever its KR happens to fall. This group collects what
+  you are actually on, ordered so whatever is **waiting on you** is the first row on the screen.
+- **Three signals, ranked and told apart.** An initiative is in the group because a session is live
+  on its `initiative/<id>` branch, or a working tree is checked out on that branch with nothing
+  running in it, or you have a tab open on it in this window. They are never merged into one vague
+  "active" badge — each row's tooltip says which one put it there, and the two weaker ones say
+  plainly that nothing is running.
+- **A live session shows on its own row.** The `#` beside an initiative becomes that session's own
+  glyph — `◆ needs you`, `● working`, `◇ maybe blocked`, `◼ quiet` — in the same vocabulary the
+  session sidebar uses. Hovering names **every** session on that initiative with its state, rather
+  than counting them: the status bar already says how many and never which. Several sessions fold to
+  the one that most wants you, and `maybe blocked` outranks `working`.
+- **The glyphs differ in shape, not just colour**, so the board still reads in greyscale and for a
+  colour-blind reader.
+- **Nothing is re-homed and nothing is invented.** An initiative still appears under its own
+  objective and KR — the group is a shortcut, not a second filing system — and it disappears
+  entirely when there is nothing to say. A session PMOS cannot place on an initiative is not placed
+  on one.
+- **Searching for a session name now finds it.** It only ever matched initiatives you had already
+  opened in that window, and returned nothing for the rest without saying it had not looked.
+
 ## What's new in 0.21.0
 
 **The workspace terminal's lines are no longer double-spaced.** Run

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Scaffold the PMOS portable kit \u2014 run the PMOS product-management workflow (initiative \u2192 lane-fit spec \u2192 contract \u2192 build \u2192 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@76ed2d3
+kernel-source: pmos@ac2ee81
 assembled: 2026-07-31
 mode: vendor

package/workspace/README.md

@@ -67,6 +67,16 @@ bar and a 26px status bar, on the oklch token layer, in both themes:
 2. **Initiatives** — a channel list. Collapsible objective/KR groups over `#slug` rows, one search
    box that forces the groups open and reports matches elsewhere, and an add form. Unanchored
    initiatives are filed honestly and shown **rejected** under D59, never hidden.
+   A **`NOW · working on`** group is pinned above the objectives when — and only when — there is
+   something to say: every initiative with a live session on its `initiative/<id>` branch, a
+   registered working tree on that branch, or a tab open in this window, ordered so whatever is
+   **waiting on you** is the first row on the board. The three signals are ranked, never merged, and
+   each row's tooltip names which one put it there. On a row with a live session the leading `#`
+   becomes that session's own glyph — `◆ needs you`, `● working`, `◇ maybe blocked`, `◼ quiet` —
+   in the vocabulary `lib/session-state.js` uses everywhere else, with every session named
+   individually on hover. The glyphs differ in **shape**, so the signal survives greyscale.
+   The join is the branch convention and nothing else: a session PMOS cannot place on an initiative
+   is not placed on one.
 3. **Initiative detail** — the record's header and pills (type / anchor / flow / branch), the derived
    footer, **task phases** (collapsible; a phase's status is derived from its tasks, and the tasks
    are derived from the workflow ladder unless the record authors them), a **links** section for

package/workspace/lib/session-state.js

@@ -66,8 +66,62 @@
 
   // Filled = corroborated by both sources, hollow = suspected from one. `needs` takes ◆, which has
   // sat declared-but-dead in the client's GLYPH map since the harness tower; this makes it live.
+  //
+  // THE SHAPES CARRY THE SIGNAL, AND COLOUR ONLY REINFORCES IT. Every pair in this map is
+  // distinguishable in greyscale, which is the property `fixture.js`'s SDOT does not have (it gives
+  // `working` and `needs` the same ● and separates them by hue alone). That map is the design
+  // prototype's seed data, parity-locked to prototype-original.html; this one is the shipped
+  // vocabulary. When a surface has to draw a session, it draws from here.
   const GLYPH = { working: '●', quiet: '◼', exited: '○', needs: '◆', blocked: '◇' };
 
+  // The colour that goes with the glyph, as a SEMANTIC TOKEN NAME — never a hex, never an oklch.
+  // The workspace's own token layer (pm/tokens.css, D38) resolves it, and workspace-ci's
+  // token-hygiene step fails on raw hex in a component rule.
+  //
+  // It lives HERE, beside WORD and GLYPH, for the reason the module's header gives: a second copy of
+  // one table is free to drift. The initiative board needed a colour per presented state and there
+  // was none anywhere in the repo — adding one inside the panel would have started exactly the
+  // second table this file exists to prevent.
+  //
+  // `blocked` takes --warning and not --destructive on purpose. Its own WORD names its uncertainty
+  // ("maybe blocked") because its evidence cannot separate a permission prompt from a hung tool from
+  // a corpse; a destructive colour would launder that into a confident claim of failure.
+  // `quiet` is muted: nothing is happening and nothing is wrong, and any louder colour would make an
+  // idle session read as a problem on a board of 178 rows.
+  const COLOR = {
+    working: 'var(--success)',
+    quiet: 'var(--muted-foreground)',
+    exited: 'var(--muted-foreground)',
+    needs: 'var(--brand)',
+    blocked: 'var(--warning)',
+  };
+
+  /**
+   * How loudly a presented state asks for the PM, highest first. Used where several sessions have to
+   * collapse into ONE mark — a board row standing for every session on an initiative.
+   *
+   * `blocked` outranks `working` deliberately. A working session is doing what it was asked to; a
+   * "maybe blocked" one may be sitting on a permission prompt, which is the PM's to clear. Ranking
+   * it below the running states would bury the only two states that can want a human.
+   *
+   * `exited` is 0: a corpse is not a claim on anyone's attention. A caller filtering live sessions
+   * drops it before it gets here; the entry exists so the map is total over PRESENTED.
+   */
+  const ATTENTION = { needs: 4, blocked: 3, working: 2, quiet: 1, exited: 0 };
+
+  /**
+   * The presented state that should stand for a whole GROUP of sessions — the loudest one.
+   * Returns null for an empty list, so a caller cannot draw a mark for nothing.
+   */
+  function loudest(states) {
+    let best = null;
+    for (const s of states || []) {
+      if (!(s in ATTENTION)) continue;          // an unknown word is never promoted into a claim
+      if (best === null || ATTENTION[s] > ATTENTION[best]) best = s;
+    }
+    return best;
+  }
+
   // Which presented states may carry the open call's verb + age. Unchanged for `working` (shipped
   // behaviour); extended to `blocked`, where the age is the most informative part of a weak claim —
   // "a call has been open 6m and nothing is moving" is the whole signal.
@@ -134,6 +188,6 @@
     return w;
   }
 
-  return { CADENCE, TURN, PRESENTED, WORD, GLYPH, CARRIES_CALL_AGE,
-    presented, presentedStates, isNeedsClaim, label };
+  return { CADENCE, TURN, PRESENTED, WORD, GLYPH, COLOR, ATTENTION, CARRIES_CALL_AGE,
+    presented, presentedStates, isNeedsClaim, loudest, label };
 });

package/workspace/lib/working-set.js

@@ -0,0 +1,224 @@
+'use strict';
+// working-set — which initiatives is the PM actually working on, and which of those are live.
+//
+// Two questions the initiative board could not answer, asked by the PM about their own board of 178
+// records: *which of these am I currently working on*, and *which one has an active session*. Both
+// were computable from state the browser already held, and nothing put them together.
+//
+// ── THE JOIN, AND WHY IT IS ONLY EVER TWO HOPS ───────────────────────────────────────────────
+// A session carries NO initiative id. It never has. The only thing tying a PTY to an initiative is
+// the branch convention — a working tree on `initiative/<id>` — and that is exactly the join
+// lib/four-panel.js `sessionsFor()` already makes on the server, per initiative, inside
+// /api/initiative:
+//
+//     session ──s.ws──▶ workspace ──w.branch──▶ "initiative/<id>" ──▶ the initiative
+//
+// This module is that same join, made once over ALL sessions instead of once per initiative, so the
+// board can colour 178 rows without 178 requests. It is deliberately NOT a second opinion: it takes
+// the branch strings the server derived (`git rev-parse --abbrev-ref`, published on /api/workspaces)
+// and the session rows the server published, and it runs no git and guesses at nothing.
+//
+// ── WHAT IT REFUSES TO DO ────────────────────────────────────────────────────────────────────
+// Every input that does not resolve contributes NOTHING. A session whose workspace is unknown, a
+// workspace with no branch, a branch that is not `initiative/…`, a branch that is the literal
+// `initiative/` with no id — each is dropped in silence rather than bucketed somewhere plausible.
+// A marker on the wrong initiative is worse than no marker: the PM would stop trusting the column,
+// and an untrusted signal costs more than an absent one.
+//
+// `exited` is not live. A session that has ended is a corpse, not a claim on anyone's attention, and
+// it is filtered before the loudest-state fold rather than ranked at the bottom of it.
+//
+// ── THREE SIGNALS, KEPT APART ────────────────────────────────────────────────────────────────
+// "Working on" is not one fact. It is three, with different strengths and different lifetimes:
+//
+//   session  a live PTY is on initiative/<id>            — strongest; ends when the process does
+//   tree     a registered working tree is on that branch — nothing is running in it
+//   open     this window has a tab open on it            — intent, not machine state; persisted
+//
+// They are ranked, never merged. `reason` survives all the way to the row's tooltip so the surface
+// can say which one it is: a single undifferentiated "active" badge would assert something none of
+// the three supports on its own.
+//
+// Pure functions over plain rows, like lib/tree-share.js and for the same reason — the rules are the
+// part worth walking exhaustively in node, without a browser and without a server.
+//
+// ── ONE module, TWO consumers ────────────────────────────────────────────────────────────────
+// A UMD, so the SERVER can hold the same rules the BROWSER draws from. Today the drawing consumer is
+// pm/panel-initiatives.js; test.js is the other, and it walks the whole input domain.
+(function (root, factory) {
+  const api = factory(
+    typeof require === 'function' && typeof module !== 'undefined' && module.exports
+      ? require('./session-state')
+      : (root && root.PMOSSessionState),
+  );
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  else root.PMOSWorkingSet = api;
+})(typeof self !== 'undefined' ? self : this, function (SS) {
+
+  const PREFIX = 'initiative/';
+
+  /** The three reasons an initiative is in the working set, loudest first. */
+  const REASONS = ['session', 'tree', 'open'];
+  const REASON_RANK = { session: 2, tree: 1, open: 0 };
+
+  /**
+   * The initiative id a branch name names, or null.
+   *
+   * Strict on purpose. `initiative/` with nothing after it is not an initiative, and neither is
+   * `feature/initiative/x` — the convention is a PREFIX, and matching it loosely is how a marker
+   * lands on a row that has nothing to do with the session.
+   */
+  function initiativeOfBranch(branch) {
+    const b = typeof branch === 'string' ? branch : '';
+    if (!b.startsWith(PREFIX)) return null;
+    const id = b.slice(PREFIX.length);
+    return id ? id : null;
+  }
+
+  /** Is this session row one the board should draw? A corpse is not. */
+  function isLive(s) {
+    return !!s && s.shown !== 'exited';
+  }
+
+  /**
+   * Every LIVE session, grouped by the initiative its working tree is on.
+   *
+   *   sessions   the rows /api/sessions publishes (id, ws, name, shown, label, …)
+   *   branchOf   ws id → branch string, or null. The caller supplies it because the browser holds
+   *              it as a Map built by foldWorkspaces and the server holds it as a workspace list;
+   *              taking a function rather than either shape keeps this module ignorant of both.
+   *
+   * Returns `{ <id>: [session, …] }` — insertion-ordered, never containing an empty array, and
+   * never containing an initiative the join could not actually reach.
+   */
+  function sessionsByInitiative(sessions, branchOf) {
+    const out = Object.create(null);
+    if (typeof branchOf !== 'function') return out;
+    for (const s of Array.isArray(sessions) ? sessions : []) {
+      if (!isLive(s) || !s.ws) continue;
+      let id = null;
+      // A branch lookup that THROWS must not take the board down with it. The map is the data
+      // layer's and this module does not own its failure modes.
+      try { id = initiativeOfBranch(branchOf(s.ws)); } catch { id = null; }
+      if (!id) continue;
+      (out[id] || (out[id] = [])).push(s);
+    }
+    return out;
+  }
+
+  /**
+   * The one presented state that stands for a whole initiative's sessions — the loudest, via
+   * session-state's own ATTENTION order. Null when there is nothing live, so a caller cannot draw
+   * a mark for nothing.
+   */
+  function stateOf(sessions) {
+    if (!SS || typeof SS.loudest !== 'function') return null;
+    return SS.loudest((sessions || []).map((s) => s && s.shown));
+  }
+
+  /**
+   * Every initiative a registered working tree is checked out on.
+   *
+   * `branches` is a flat list of branch strings — the caller enumerates its own registry. A tree on
+   * initiative/<id> means the PM has a checkout dedicated to that initiative, whether or not
+   * anything is running in it; that is a weaker claim than a live session and a real one.
+   */
+  function initiativesWithTree(branches) {
+    const out = new Set();
+    for (const b of Array.isArray(branches) ? branches : []) {
+      const id = initiativeOfBranch(b);
+      if (id) out.add(id);
+    }
+    return out;
+  }
+
+  /**
+   * Every initiative this window has a tab open on.
+   *
+   * The weakest of the three signals and the only one that reflects INTENT rather than machine
+   * state. It is also durable: pm/state.js persists `tabs`, so it survives a reload — which is the
+   * whole reason it is worth reading. It can be stale (a tab left open for a week reads like one
+   * opened a minute ago), which is why it ranks last and why its reason is carried, not hidden.
+   */
+  function initiativesWithTab(tabs) {
+    const out = new Set();
+    for (const t of Array.isArray(tabs) ? tabs : []) {
+      if (t && typeof t.slug === 'string' && t.slug) out.add(t.slug);
+    }
+    return out;
+  }
+
+  /**
+   * THE WORKING SET — the rows the board pins above the Objectives.
+   *
+   *   live      {id: [session…]}  from sessionsByInitiative
+   *   trees     Set<id>           from initiativesWithTree
+   *   tabs      Set<id>           from initiativesWithTab
+   *   onBoard   (id) => boolean   is this slug on the repository currently showing? REQUIRED, and
+   *                               the reason a tab or a tree belonging to another repository cannot
+   *                               leak a row onto the wrong board.
+   *
+   * Ordered by attention: needs → blocked → working → quiet → tree → open, alphabetical within a
+   * band. So the initiative waiting on the PM is the first row on the screen.
+   *
+   * Each entry is `{slug, reason, state, sessions}`. `reason` is one of REASONS and is never
+   * collapsed away — the surface says which of the three it is.
+   */
+  function workingSet({ live, trees, tabs, onBoard } = {}) {
+    const L = live && typeof live === 'object' ? live : {};
+    const T = trees instanceof Set ? trees : new Set();
+    const B = tabs instanceof Set ? tabs : new Set();
+    const keep = typeof onBoard === 'function' ? onBoard : () => false;
+
+    const seen = new Map();
+    const add = (slug, reason, sessions) => {
+      if (!slug || seen.has(slug) || !keep(slug)) return;
+      seen.set(slug, { slug, reason, state: reason === 'session' ? stateOf(sessions) : null, sessions: sessions || [] });
+    };
+    for (const slug of Object.keys(L)) add(slug, 'session', L[slug]);
+    for (const slug of T) add(slug, 'tree', null);
+    for (const slug of B) add(slug, 'open', null);
+
+    const attention = (e) => (e.state && SS && SS.ATTENTION ? (SS.ATTENTION[e.state] || 0) : 0);
+    return [...seen.values()].sort((a, b) => {
+      if (REASON_RANK[a.reason] !== REASON_RANK[b.reason]) return REASON_RANK[b.reason] - REASON_RANK[a.reason];
+      if (attention(a) !== attention(b)) return attention(b) - attention(a);
+      return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
+    });
+  }
+
+  /**
+   * What the PM reads when they hover a row's session mark: every live session named INDIVIDUALLY,
+   * with the SERVER's own word for its state.
+   *
+   * The glyph summarises and the tooltip does not — a count would reproduce the status bar's
+   * "3 sessions running", which is the thing that says how many and never which. `s.label` is
+   * server-rendered (session-state's `label`, one clock, one sentence), so this cannot word a
+   * session differently from the pane it belongs to. A row with no label falls back to `shown`
+   * rather than inventing a sentence.
+   */
+  function sessionTitle(slug, sessions) {
+    const rows = (sessions || []).filter(isLive);
+    if (!rows.length) return '';
+    const lines = rows.map((s) => '· ' + (s.name || s.id || 'session') + ' — ' + (s.label || s.shown || 'unknown'));
+    const n = rows.length;
+    return [
+      n + ' live session' + (n === 1 ? '' : 's') + ' on ' + PREFIX + slug,
+      ...lines,
+    ].join('\n');
+  }
+
+  /** One line naming why an initiative is in the working set. Stated, never implied. */
+  function reasonTitle(entry) {
+    if (!entry) return '';
+    if (entry.reason === 'session') return sessionTitle(entry.slug, entry.sessions);
+    if (entry.reason === 'tree') return 'a registered working tree is on ' + PREFIX + entry.slug + ' — nothing is running in it';
+    return 'you have a tab open on this initiative in this window';
+  }
+
+  return {
+    PREFIX, REASONS, REASON_RANK,
+    initiativeOfBranch, isLive, sessionsByInitiative, stateOf,
+    initiativesWithTree, initiativesWithTab, workingSet, sessionTitle, reasonTitle,
+  };
+});

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/index.html

@@ -35,6 +35,13 @@
      Both read this file, so the sentence in the terminal and the sentence in the chooser cannot
      drift apart. Classic script (a UMD setting window.PMOSTreeShare), like the two above. -->
 <script src="/lib/tree-share.js"></script>
+<!-- The session→initiative join, made once over every session instead of once per initiative
+     (workspace-active-visibility). The SERVER makes the same two-hopper per initiative inside
+     /api/initiative (lib/four-panel.js sessionsFor); the BOARD needs it for 178 rows at once and
+     cannot spend 178 requests on it. Loaded here rather than imported so it stays walkable in node
+     — test.js requires it and walks its whole input domain. It reads window.PMOSSessionState for
+     the attention order, so it must come AFTER that script. -->
+<script src="/lib/working-set.js"></script>
 <!-- The phone's navigation reducer. DOM-free, loaded as a classic script (it is a UMD that sets
      window.PMOSMobileNav) and required by test.js, so the whole screen domain is walkable in node
      rather than only in a browser. pm/mobile.js reads it from the global; the module graph does not

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

@@ -3243,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