create-pmos 0.253.0 → 0.254.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.253.0",
+  "version": "0.254.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@86e280d
+kernel-source: pmos@be12de7
 assembled: 2026-10-17
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-17T04:34:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-17T14:34:03Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-17T04:34:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-17T14:34:03Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-17T04:34:20Z"}
+generated: {by: process:create-pmos, at: "2026-10-17T14:34:03Z"}
 status: stable
 ---
 

package/workspace/briefing-premium-products-test.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+/* briefing-premium-products-test.js — the premium Briefing across products (initiative briefing-premium-products; planning/prd/briefing-premium-products-prd.md P1 to P13).
+ * The real server with two product repositories registered beside the home one (the PMOS checkout the server runs from). Both products hold a
+ * kill condition KC9 that has passed its date, so each has a "decide" row with the SAME id: the page must keep them apart.
+ *   P1  by default the home workspace is not read, and the header says so
+ *   P2  the picker lists every workspace, the home one included, and says how many are on
+ *   P3  a tick is saved through /api/settings and survives a reload; Back to the default returns to P1
+ *   P4  an unticked product's rows leave the list
+ *   P6  each row carries its product
+ *   P9  deciding a row writes into the owning product's journal and no other
+ *   P10 a question about a merged row starts the read-only agent
+ *   P13 floors: the picker and its menu are 44 px high, reachable by keyboard, no sideways scroll at 390 px, both themes
+ * Every wait polls the page; no fixed sleep stands in for a state. */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'briefing-premium-products' });
+
+const BASE = T.BASE;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const until = async (fn, ms = 15000, step = 150) => { const t0 = Date.now(); for (;;) { let v = null; try { v = await fn(); } catch { v = null; } if (v) return v; if (Date.now() - t0 > ms) return v; await sleep(step); } };
+const results = [];
+const ok = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + String(extra).slice(0, 300) : ''}`); };
+let srv = null; let browser = null;
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pmos-bpp-'));
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* left for the OS */ }
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} briefing-premium-products assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+const sh = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
+const product = (name, cond) => {
+  const root = path.join(tmp, name);
+  fs.mkdirSync(path.join(root, 'planning', 'okrs'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'AGENTS.md'), '# a\n');
+  fs.writeFileSync(path.join(root, 'pm-decisions.md'), '# decisions\n');
+  fs.writeFileSync(path.join(root, 'planning', 'okrs', 'kill-conditions.md'), `| KC9 | ${cond} | stalls by **2020-01-01** | monthly | pauses merges |\n`);
+  sh(root, ['init', '-q', '-b', 'main']); sh(root, ['config', 'user.email', 't@t']); sh(root, ['config', 'user.name', 't']); sh(root, ['add', '-A']); sh(root, ['commit', '-q', '-m', 'initial']);
+  return root;
+};
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the briefing-premium-products suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the briefing-premium-products suite cannot run'); return finish(1); }
+  const fakeBin = path.join(tmp, 'bin'); fs.mkdirSync(fakeBin);
+  fs.writeFileSync(path.join(fakeBin, 'claude'), '#!/bin/sh\nsleep 30\n', { mode: 0o755 });
+  const rootA = product('idpf-repo', 'IDPF condition'), rootB = product('micro-repo', 'Microsites condition');
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT), PATH: fakeBin + path.delimiter + process.env.PATH }) });
+  await T.waitForServer(BASE);
+  const json = async (m, p, b, h) => { const res = await fetch(BASE + p, { method: m, headers: { 'content-type': 'application/json', ...(h || {}) }, body: b ? JSON.stringify(b) : undefined }); let j = null; try { j = await res.json(); } catch { /* not json */ } return { status: res.status, body: j }; };
+  const wA = (await json('POST', '/api/workspaces', { root: rootA, name: 'IDPF', focus: false })).body.workspace;
+  const wB = (await json('POST', '/api/workspaces', { root: rootB, name: 'microsites', focus: false })).body.workspace;
+  const all = (await json('GET', '/api/workspaces')).body.workspaces;
+  const home = all.find((w) => w.home);
+  ok('P0 the server has a home workspace and the two products', !!home && !!wA && !!wB, JSON.stringify(all.map((w) => [w.name, w.home])));
+  const model = async () => { const r = await json('GET', '/api/briefing-premium'); return r.status === 200 && r.body.model && !r.body.model.pending ? r.body : null; };
+  const m0 = await until(model, 90000);
+  ok('P1 by default only the two products are read: two decide rows, none from the home workspace', m0 && m0.model.list.rows.length === 2 && m0.model.list.rows.every((r) => r.kind === 'decision' && ['IDPF', 'microsites'].includes(r.product)) && m0.model.products.available.find((a) => a.home).on === false, JSON.stringify(m0 && m0.model.list.rows.map((r) => [r.key, r.product])));
+  ok('P1 the two rows share an id and differ in workspace', m0 && new Set(m0.model.list.rows.map((r) => r.key)).size === 2 && m0.model.list.rows.every((r) => /^decision:KC9:/.test(r.key)));
+
+  browser = await chromium.launch({ executablePath: exe });
+  const open = async ({ w = 1280, h = 900, theme = 'light', q = '' } = {}) => {
+    const ctx = await browser.newContext({ viewport: { width: w, height: h } });
+    await ctx.addInitScript((t) => { try { localStorage.setItem('pmos.premium.theme', t); } catch { /* none */ } }, theme);
+    const page = await ctx.newPage(); const errors = [];
+    page.on('pageerror', (e) => errors.push(String(e.message || e)));
+    await page.goto(BASE + '/premium.html' + q, { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#rank .rr, #calm:not([hidden]), #pkw:not([hidden])', { timeout: 30000 });
+    return { ctx, page, errors };
+  };
+  const rowsOf = (page) => page.$$eval('#rank .rr', (els) => els.map((e) => ({ key: e.dataset.key, tag: (e.querySelector('.pn') || {}).textContent || '', title: e.querySelector('.rt').textContent })));
+
+  {
+    const { ctx, page, errors } = await open();
+    await until(async () => (await rowsOf(page)).length === 2, 20000);
+    const rows = await rowsOf(page);
+    ok('P6 each row carries its product', rows.length === 2 && rows.map((r) => r.tag).sort().join() === 'IDPF,microsites', JSON.stringify(rows));
+    const snap = await page.textContent('#snap');
+    ok('P1 the header names what is read and what is not', /IDPF and microsites/.test(snap) && /not included/.test(snap) && /\b[Pp][Mm][Oo][Ss]\b|pmos/i.test(snap), snap);
+    ok('P2 the picker says how many of the workspaces are on', (await page.textContent('#pick')).replace(/\s+/g, '') === 'Products2of3', await page.textContent('#pick'));
+    await page.click('#pick');
+    const items = await page.$$eval('#pickMenu [role="menuitemcheckbox"]', (els) => els.map((e) => ({ name: e.textContent.trim(), on: e.getAttribute('aria-checked'), h: Math.round(e.getBoundingClientRect().height) })));
+    ok('P2 the menu lists every workspace, the home one included, unticked', items.length === 3 && items.filter((i) => i.on === 'true').length === 2 && items.some((i) => i.on === 'false' && /home/.test(i.name)), JSON.stringify(items));
+    const pickH = await page.$eval('#pick', (e) => Math.round(e.getBoundingClientRect().height));
+    ok('P13 the picker and its items are at least 42 px high (the crumb menu\'s own height)', pickH >= 42 && items.every((i) => i.h >= 42), pickH + ' ' + JSON.stringify(items.map((i) => i.h)));
+    // untick microsites: its row leaves, the setting is saved
+    await page.click(`#pickMenu [data-ws="${wB.id}"]`);
+    ok('P4 an unticked product\'s row leaves the list', await until(async () => { const r = await rowsOf(page); return r.length === 1 && r[0].tag === 'IDPF'; }, 20000));
+    const saved = (await json('GET', '/api/settings')).body.settings.find((s) => s.key === 'ws.briefing.include');
+    ok('P3 the choice is saved as a list of workspace ids', saved && JSON.stringify(saved.value) === JSON.stringify([wA.id]), JSON.stringify(saved));
+    ok('P2 the count in the picker follows', (await page.textContent('#pick')).replace(/\s+/g, '') === 'Products1of3');
+    ok('P13 keyboard: the menu stays open on the ticked item and Escape closes it', await page.evaluate((id) => document.activeElement && document.activeElement.dataset.ws === id, wB.id) && (await page.keyboard.press('Escape'), await until(async () => await page.$eval('#pickMenu', (e) => e.hidden), 3000)));
+    ok('P3 the choice survives a reload', await (async () => { await page.reload({ waitUntil: 'domcontentloaded' }); return until(async () => { const r = await rowsOf(page); return r.length === 1 && r[0].tag === 'IDPF' ? 1 : 0; }, 20000); })());
+    // tick the home workspace
+    await page.click('#pick'); await page.click(`#pickMenu [data-ws="${home.id}"]`);
+    ok('P3 ticking the home workspace reads it', await until(async () => (await page.getAttribute(`#pickMenu [data-ws="${home.id}"]`, 'aria-checked')) === 'true' && new RegExp(home.name + ' and IDPF|IDPF and ' + home.name, 'i').test(await page.textContent('#snap')), 20000), await page.textContent('#snap'));
+    // back to the default
+    await page.click('#pickMenu [data-reset]');
+    ok('P3 Back to the default reads every product but the home one again', await until(async () => (await rowsOf(page)).length === 2, 20000) && (await page.textContent('#pick')).replace(/\s+/g, '') === 'Products2of3');
+    ok('P3 and the saved choice is gone', (await json('GET', '/api/settings')).body.settings.find((s) => s.key === 'ws.briefing.include').changed === false);
+    ok('no page error', errors.length === 0, errors.join(' | '));
+    await ctx.close();
+  }
+
+  {
+    // P9 decide a row of IDPF, from the page
+    const { ctx, page } = await open();
+    await until(async () => (await rowsOf(page)).length === 2, 20000);
+    const key = (await rowsOf(page)).find((r) => r.tag === 'IDPF').key;
+    await page.click(`#rank .rr[data-key="${key}"] .rhd`);
+    await page.waitForSelector('#dBody [data-op]');
+    await page.click('#dBody [data-op="extend"]');
+    await page.fill('#why', 'IDPF moves the date.');
+    await page.click('#recBtn');
+    ok('P9 the press is recorded and the IDPF row leaves, the microsites row stays', await until(async () => { const r = await rowsOf(page); return r.length === 1 && r[0].tag === 'microsites' ? 1 : 0; }, 20000), JSON.stringify(await rowsOf(page)));
+    const dA = fs.readFileSync(path.join(rootA, 'pm-decisions.md'), 'utf8'), dB = fs.readFileSync(path.join(rootB, 'pm-decisions.md'), 'utf8');
+    ok('P9 the decision is in IDPF\'s journal and not in the other product\'s or the home one\'s', /KC9/.test(dA) && /IDPF moves the date/.test(dA) && !/KC9/.test(dB) && !/IDPF moves the date/.test(fs.readFileSync(path.join(home.root, 'pm-decisions.md'), 'utf8')));
+    await ctx.close();
+  }
+
+  {
+    // P9/P10 refusals and the agent, over the real routes
+    const html = await (await fetch(BASE + '/')).text();
+    const nonce = (/<meta name="pmos-nonce" content="([^"]*)"/.exec(html) || [])[1] || '';
+    const press = { Origin: BASE, ...(nonce ? { 'x-pmos-nonce': nonce } : {}) };
+    const homeKey = 'decision:KC9:' + home.id;
+    const r1 = await json('POST', '/api/briefing-premium/decide', { key: homeKey, choice: 'extend', why: 'Not included.' }, press);
+    ok('P9 a row of a workspace that is not included is refused', r1.status === 400 && /not included/.test(r1.body.error), JSON.stringify(r1));
+    const r2 = await json('POST', '/api/briefing-premium/decide', { key: 'decision:KC9:w-nope', choice: 'extend', why: 'Unknown.' }, press);
+    ok('P9 a row of a workspace that is not registered is refused', r2.status === 400 && /not registered/.test(r2.body.error), JSON.stringify(r2));
+    const r3 = await json('POST', '/api/briefing-premium/ask', { key: 'decision:KC9:' + wB.id, text: 'Why is this on my list?' }, press);
+    ok('P10 a question about a merged row starts the read-only agent in that product', r3.status === 200 && r3.body.ok && r3.body.state === 'working', JSON.stringify(r3));
+    const r4 = await json('POST', '/api/briefing-premium/ask', { key: 'decision:KC9:' + wA.id, text: 'Why?' }, press);
+    ok('P10 a row that is no longer on the page is refused', r4.status === 404, JSON.stringify(r4));
+  }
+
+  for (const [w, th] of [[390, 'light'], [390, 'dark'], [1280, 'dark']]) {
+    const { ctx, page } = await open({ w, h: 800, theme: th });
+    await until(async () => (await rowsOf(page)).length >= 1, 20000);
+    await page.click('#pick');
+    const o = await page.evaluate(() => ({ sw: document.documentElement.scrollWidth, cw: document.documentElement.clientWidth, menu: (() => { const r = document.querySelector('#pickMenu').getBoundingClientRect(); return { l: Math.round(r.left), r: Math.round(r.right) }; })() }));
+    ok(`P13 at ${w} px, ${th}: no sideways scroll with the menu open, and the menu stays on screen`, o.sw <= o.cw && o.menu.l >= 0 && o.menu.r <= o.cw, JSON.stringify(o));
+    await ctx.close();
+  }
+
+  {
+    // the narrowed view (P12): the one-workspace page, with a way back
+    const { ctx, page } = await open({ q: '?ws=' + encodeURIComponent(wB.id) });
+    ok('P12 ?ws= shows that one workspace and a link back to the picked products', await until(async () => (await page.$('#pickAll')) !== null, 20000) && (await page.getAttribute('#pickAll', 'href')) === '/premium.html');
+    await ctx.close();
+  }
+  return finish();
+})().catch((e) => { console.error(e); finish(1); });

package/workspace/guide/briefing-premium.md

@@ -7,10 +7,24 @@ timestamp: 2026-10-16
 
 # The premium Briefing
 
-The premium Briefing is a page of its own at `/premium.html`. The console at `/` stays the default page. This page reads the repository. It writes only when you press a button that says it records (see "What the buttons record"), plus one derived copy of its last answer, described below.
+The premium Briefing is a page of its own at `/premium.html`. The console at `/` stays the default page. This page reads the repositories of the products you pick (see "Products"). It writes only when you press a button that says it records (see "What the buttons record"), plus one derived copy of its last answer, described below.
 
 A rail on the left names four places: Briefing, My work, Board and Insights. Briefing is on this page. The other three open the matching tab of the console.
 
+## Products
+
+You work across products, and a conversation in email, the calendar or Confluence cannot be tied to one product. So the Briefing reads more than one workspace and merges what needs you into one list.
+
+- **By default** it reads every registered workspace except the home one (PMOS itself). PMOS is the tool, not a product you manage, so it is left out until you ask.
+- **The Products button** in the header lists every registered workspace, the home one included, each with a box. Tick a box to read that workspace, clear it to stop. The button says how many are on, for example "2 of 3". "Back to the default" returns to every workspace except the home one.
+- **Your choice is saved** as the setting `ws.briefing.include` (a list of workspace ids) in this computer's state folder, so it stays when you reload or restart.
+- **A workspace that is not ticked is not read at all.** Its decisions, blocked work, merges and runs do not count in the hero, the list or the dock.
+- **Each row says which product it belongs to**, in a small tag before its line. Two products can hold an initiative or a kill condition of the same name. They stay separate rows, and a press is written into the journal of the product the row names.
+- **The order** is the same across products: blocked work first, then decisions only you can make, then what has waited longest. A failed-review row is made for each product, so a count is never added across products.
+- **The header** names what is read and what is not, for example "IDPF and microsites · pmos not included". A product that is still being read or could not be read is named there too, and the others still show.
+- **`/premium.html?ws=<id>`** shows that one workspace as the Briefing did before, whether or not it is ticked, with a button back to the ticked products.
+- **Email and Confluence** are not read by this page. They arrive as items on My work.
+
 ## How long it takes to load
 
 Two reads feed the page. The quick read takes the kill conditions, the failed-review verdicts, today's merges and agent runs, and the calendar. It finishes in seconds. The slow read derives the state of every initiative from git history. It takes about half a minute on a fast machine, and much longer on a machine that is busy. The page never waits on the slow read:
@@ -18,7 +32,7 @@ Two reads feed the page. The quick read takes the kill conditions, the failed-re
 - **The first time**, the page says "Reading the repository for the first time" and counts the seconds. As soon as the quick read ends it draws what that read holds, and says in the header, the list and the dock that it is "still reading initiative state". Until then it does not say that nothing needs you. Blocked work, prototypes that wait for you and failed reviews appear when the slow read ends.
 - **After that**, a reload answers at once with the last read. A read older than 5 minutes is refreshed in the background, and the header says when it was read.
 - **The slow read runs only when the repository changed.** If you are on the same commit and nothing under `planning/` or `scripts/` changed, the page reuses the last initiative state. It runs at low priority, so it does not starve the machine.
-- **After a restart**, the last read comes back from a file in the workspace's state folder, `briefing-premium-model.json`. The file is a copy of derived data. You can delete it.
+- **After a restart**, the last read comes back from a file in the workspace's state folder, one `briefing-premium-products-<id>.json` for each product (`briefing-premium-model.json` for the one-workspace view). The file is a copy of derived data. You can delete it.
 - **If a read fails**, the header says "the latest read failed" with the reason, and the page stops saying it is still reading. The server waits two minutes before it tries again, so a failing read does not run in a loop. A slow read that failed is always tried again on the next refresh, even when the repository has not changed.
 - **If one record cannot be read**, only that record is left out. The header says how many were left out. A row or a Today item whose detail cannot be built still opens, with what the row itself says.
 

package/workspace/lib/briefing-premium-products.js

@@ -0,0 +1,121 @@
+'use strict';
+/* lib/briefing-premium-products.js — the premium Briefing across products (initiative briefing-premium-products).
+ *
+ *   choose({ workspaces, include })       → { available[{ ws, name, root, home, on }], ignored[] }   PURE. Which workspaces the Briefing reads.
+ *   splitKey(key)                         → { base, ws } | null                                      PURE. A merged row's key is kind:id:ws.
+ *   modelOfMany({ available, engine, runtimeDir }) → { state, model, as_of, ... }                    the route's answer, one workspace read and kept at a time.
+ *   rebuildOne({ root, runtimeDir })      after a write: that workspace's quick facts again, without the slow read.
+ *   peekModel()                           the last merged model, for the read-only agent to find a row in.
+ *
+ * THE SELECTION RULE. With nothing chosen, every registered workspace except the home one (PMOS itself) is read. With a choice (the setting
+ * ws.briefing.include, a list of workspace ids), exactly those are read, the home workspace included when it is listed. A workspace that is not
+ * selected is not read at all: no file of it is opened and no git command runs in it. An id in the choice that is no longer registered is ignored and returned.
+ *
+ * Each workspace keeps its own answer (memory and a file under the state folder), so one slow or broken repository costs only its own part:
+ * the others show, and the header names the one that is still being read or could not be. */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const BP = require('./briefing-premium.js');
+const W = require('./briefing-premium-writes.js');
+
+const STALE_MS = 5 * 60 * 1000;
+const RETRY_AFTER_ERROR_MS = 2 * 60 * 1000;
+
+/** workspaces: [{ id, name, root, home }]. include: an array of ids, or null for the default. */
+function choose({ workspaces, include, only }) {
+  const list = (workspaces || []).filter((w) => w && w.id && w.root);
+  const ids = new Set(list.map((w) => w.id));
+  const pick = Array.isArray(include) ? new Set(include) : null;
+  const available = list.map((w) => ({ ws: w.id, name: w.name || w.id, root: w.root, home: !!w.home, on: only ? w.id === only : pick ? pick.has(w.id) : !w.home }));
+  return { available, ignored: Array.isArray(include) ? include.filter((x) => !ids.has(x)) : [] };
+}
+
+/** A merged row's key is kind:id:ws. A key of the one-workspace page (kind:id) has no workspace and returns null. */
+function splitKey(key) {
+  const m = /^(blocked|decision|waited):([A-Za-z0-9][A-Za-z0-9._-]*):([A-Za-z0-9_-]{1,80})$/.exec(String(key || ''));
+  return m ? { base: m[1] + ':' + m[2], kind: m[1], id: m[2], ws: m[3] } : null;
+}
+
+/* ── one state per workspace ───────────────────────────────────────────────────────────────────────────────── */
+const states = new Map();
+const stateOf = (root) => { let s = states.get(root); if (!s) states.set(root, s = { kept: null, partial: null, inflight: null, startedAt: 0, lastError: null, lastErrorAt: 0 }); return s; };
+let last = null;
+
+const cacheFile = (dir, root) => path.join(dir, 'briefing-premium-products-' + crypto.createHash('sha1').update(root).digest('hex').slice(0, 10) + '.json');
+const loadCache = (dir, root) => { try { const j = JSON.parse(fs.readFileSync(cacheFile(dir, root), 'utf8')); return j && j.root === root && j.at && Array.isArray(j.initiatives) ? j : null; } catch { return null; } };
+const saveCache = (dir, root, k) => { try { fs.mkdirSync(dir, { recursive: true }); const f = cacheFile(dir, root), t = f + '.' + process.pid + '.tmp'; fs.writeFileSync(t, JSON.stringify({ at: k.at, root, key: k.key, ok: k.ok, initiatives: k.initiatives })); fs.renameSync(t, f); } catch { /* a cache that cannot be written is only a slower next start */ } };
+
+/** One workspace's read: the quick facts always, the slow initiative state only when its repository changed since the last answer. */
+async function refreshOne({ root, engine, runtimeDir }) {
+  const s = stateOf(root);
+  const key = await BP.repoKey(root);
+  const f = await BP.readFast({ root, now: Date.now(), runtimeDir, calendar: false });
+  let inits = s.kept && key && s.kept.key === key && s.kept.ok && s.kept.initiatives ? s.kept.initiatives : null;
+  if (!inits) {
+    if (!s.kept) s.partial = { at: Date.now(), f: Object.assign({}, f, { initiatives: [], pending: true }) };
+    inits = await BP.readInitiatives({ root, engine });
+  }
+  if (!inits) f.missing.push('workflow');
+  s.kept = { at: Date.now(), key, ok: !!inits, initiatives: inits || [], f: Object.assign({}, f, { initiatives: inits || [] }) };
+  s.partial = null; s.lastError = null; s.lastErrorAt = 0;
+  if (runtimeDir) saveCache(runtimeDir, root, s.kept);
+}
+function start(p, engine, runtimeDir) {
+  const s = stateOf(p.root);
+  if (!s.inflight && !(s.lastError && Date.now() - s.lastErrorAt < RETRY_AFTER_ERROR_MS)) {
+    s.startedAt = Date.now();
+    s.inflight = refreshOne({ root: p.root, engine, runtimeDir }).catch((e) => { s.lastError = String((e && e.stack) || e).split('\n').slice(0, 3).join(' | ').slice(0, 300); s.lastErrorAt = Date.now(); }).finally(() => { s.inflight = null; });
+  }
+  return s.inflight;
+}
+
+/** The merged answer for the workspaces that are on. `available` is choose()'s list (all of them, with `on`). */
+async function modelOfMany({ available, engine, runtimeDir }) {
+  const now = Date.now();
+  const on = (available || []).filter((a) => a.on);
+  const parts = [];
+  let asOf = null, refreshing = false, error = null, elapsed = 0;
+  for (const p of on) {
+    const s = stateOf(p.root);
+    if (!s.kept && runtimeDir) {
+      const c = loadCache(runtimeDir, p.root);
+      if (c) { const f = await BP.readFast({ root: p.root, now, runtimeDir, calendar: false }); s.kept = { at: c.at, key: c.key, ok: c.ok, initiatives: c.initiatives, f: Object.assign({}, f, { initiatives: c.initiatives }) }; }
+    }
+    if (!s.kept || Date.now() - s.kept.at > STALE_MS) start(p, engine, runtimeDir);
+    const product = { ws: p.ws, name: p.name };
+    if (s.kept) {
+      parts.push({ product, state: 'ready', f: s.kept.f });
+      asOf = asOf == null ? s.kept.at : Math.min(asOf, s.kept.at);
+      if (s.inflight) refreshing = true;
+      if (s.lastError) error = (error ? error + '; ' : '') + p.name + ': ' + s.lastError;
+    } else if (s.partial) {
+      parts.push({ product, state: 'ready', f: s.partial.f });
+      asOf = asOf == null ? s.partial.at : Math.min(asOf, s.partial.at);
+    } else if (s.lastError && !s.inflight) parts.push({ product, state: 'error', f: null, error: s.lastError });
+    else { parts.push({ product, state: 'reading', f: null }); elapsed = Math.max(elapsed, now - s.startedAt); }
+  }
+  const settled = parts.filter((p) => p.state === 'ready').length;
+  if (on.length && !settled && parts.every((p) => p.state === 'reading')) return { state: 'reading', elapsed_ms: elapsed };
+  if (on.length && !settled && parts.every((p) => p.state === 'error')) return { state: 'error', error: parts.map((p) => p.product.name + ': ' + p.error).join('; ').slice(0, 300) };
+  const model = BP.buildMany({ now, asOf: asOf || now, meetings: BP.readMeetings(runtimeDir, now), defers: Object.fromEntries(W.readDefers(runtimeDir, now)), available: (available || []).map((a) => ({ ws: a.ws, name: a.name, home: a.home, on: a.on })), parts });
+  last = model;
+  return { state: 'ready', model, as_of: asOf || now, refreshing, pending: model.pending, ...(error ? { error } : {}) };
+}
+
+/** After a write: the quick facts of one workspace again (the PM's decision or a returned run changed its records). */
+async function rebuildOne({ root, runtimeDir }) {
+  const s = stateOf(root);
+  if (s.inflight) await s.inflight;
+  if (!s.kept) return false;
+  const f = await BP.readFast({ root, now: Date.now(), runtimeDir, calendar: false });
+  if (!s.kept.ok) f.missing.push('workflow');
+  s.kept = Object.assign({}, s.kept, { f: Object.assign({}, f, { initiatives: s.kept.initiatives }) });
+  return true;
+}
+
+const peekModel = () => last;
+const settle = () => Promise.all([...states.values()].map((s) => s.inflight).filter(Boolean));
+const forget = () => { states.clear(); last = null; };
+
+module.exports = { choose, splitKey, modelOfMany, rebuildOne, peekModel, settle, forget, refreshOne, STALE_MS };

package/workspace/lib/briefing-premium.js

@@ -35,6 +35,7 @@ const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July',
 const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 const dateLine = (ms) => { const d = new Date(ms); return WEEKDAYS[d.getDay()] + ' ' + d.getDate() + ' ' + MONTHS[d.getMonth()]; };
 /* A short name for a sentence: the title up to its first dash, colon or bracket, without a leading article. */
+const joinNames = (a) => (a.length < 2 ? a.join('') : a.slice(0, -1).join(', ') + ' and ' + a[a.length - 1]);
 const shortName = (t) => clip(String(t || '').split(/\s[—–-]\s|:|\(/)[0].replace(/^(the|a|an)\s+/i, ''), 48);
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const shortDate = (ms) => { const d = new Date(ms); return d.getDate() + ' ' + MON[d.getMonth()]; };
@@ -75,6 +76,8 @@ const START_HOLD = 'Starting an agent from here arrives with the live conversati
 const tryD = (fn) => { try { return fn(); } catch { return null; } };
 const skipped = { n: 0 };
 
+/** Two products can hold an initiative of the same name, so a lookup by id also names the workspace (none in a one-workspace read). */
+const idk = (x, id) => (x.ws || '') + '|' + id;
 const live = (i) => i && !i.accepted && !i.stopped && !i.legacy;
 
 /* ── rows ─────────────────────────────────────────────────────────────────────────────────────────────────── */
@@ -206,15 +209,23 @@ function waitedRows(f) {
   }];
 }
 
-function rowsOf(f) {
-  const every = [].concat(blockedRows(f), decisionRows(f), waitedRows(f));
+/** A row of one product in a merged list: its key names the workspace (kind:id:ws) so two products never share a key, and it carries the product's name. */
+const tagRow = (r, p) => Object.assign({}, r, { key: r.key + ':' + p.ws, product: p.name, ws: p.ws });
+/** Every row of one set of facts, in the order the rules give, with those the PM put off split out. Not yet cut to the page's cap. */
+function allRowsOf(f) {
+  let every = [].concat(blockedRows(f), decisionRows(f), waitedRows(f));
+  if (f.product) every = every.map((r) => tagRow(r, f.product));
   const off = (r) => (f.defers && f.defers[r.key] > f.now);   // put off by the PM until a time that has not come
   const all = every.filter((r) => !off(r));
-  const putOff = every.filter(off).map((r) => ({ key: r.key, title: r.title, until: f.defers[r.key] }));
+  const putOff = every.filter(off).map((r) => ({ key: r.key, title: r.title, until: f.defers[r.key], ...(r.product ? { product: r.product } : {}) }));
+  return { all, putOff };
+}
+const cut = (all, putOff) => {
   const rows = all.slice(0, MAX_ROWS).map((r, k) => Object.assign({ n: k + 1, first: k === 0 }, r));
   rows.forEach((r) => delete r.order);
   return { rows, more: Math.max(0, all.length - rows.length), putOff };
-}
+};
+function rowsOf(f) { const a = allRowsOf(f); return cut(a.all, a.putOff); }
 
 /* ── hero ─────────────────────────────────────────────────────────────────────────────────────────────────── */
 function correctionRate(runs, from, to) {
@@ -244,9 +255,10 @@ function heroOf(f, rows) {
     const clauses = [];
     if (blocked.length) {
       const ordering = blocked.every((r) => r.stepKey === 'spec' || r.stepKey === 'prototype');
-      clauses.push({ t: num(blocked.length) + ' ' + plural(blocked.length, 'initiative is', 'initiatives are') + ' blocked' + (ordering ? ' on ordering' : ''), from: blocked.map((r) => r.from[0]) });
+      const where = [...new Set(blocked.map((r) => r.product).filter(Boolean))];
+      clauses.push({ t: num(blocked.length) + ' ' + plural(blocked.length, 'initiative is', 'initiatives are') + ' blocked' + (ordering ? ' on ordering' : '') + (where.length ? ' in ' + joinNames(where) : ''), from: blocked.map((r) => r.from[0]) });
     }
-    rest.forEach((r) => clauses.push({ t: r.hero, from: r.from }));
+    rest.forEach((r) => clauses.push({ t: r.hero + (r.product ? ' in ' + r.product : ''), from: r.from }));
     if (clauses.length) {
       const p = [['What is stuck is yours: ', 0]];
       clauses.forEach((c, k) => {
@@ -286,13 +298,13 @@ function mergeDialog(m, f) {
   };
 }
 function runDialog(r, t, byId) {
-  const i = byId.get(r.initiative_id), ap = r.pre_run_contract && r.pre_run_contract.PM_approved === true;
+  const i = byId.get(idk(r, r.initiative_id)), ap = r.pre_run_contract && r.pre_run_contract.PM_approved === true;
   const facts = [['Initiative', (i && i.title) ? clip(i.title, 70) : r.initiative_id], ['Run', r.run_id], ['Lane', r.lane || (i && i.lane)], ['Corrections', Number.isFinite(Number(r.human_corrections)) ? String(r.human_corrections) : ''], ['Contract approved', r.pre_run_contract ? (ap ? 'Yes' : 'No') : ''], ['Recorded', longDate(t) + ' ' + hhmm(t)]].filter((x) => x[1]);
   return {
     eye: 'Agent run', logTitle: 'Read from the run log', title: i ? clip(i.title, 90) : r.initiative_id, sub: hhmm(t) + ' · agent run',
     log: ['Read planning/runs/agent-runs.jsonl', 'Matched the run to its initiative' + (i ? '' : ' (no record found)'), 'Read its recorded fields'],
     say: 'This run is logged. Nothing needs you unless you disagree with it.',
-    head: 'The run', facts, opts: [], sel: null, nodef: '', action: 'Return this run to the agent', write: { kind: 'return', run: r.run_id },
+    head: 'The run', facts, opts: [], sel: null, nodef: '', action: 'Return this run to the agent', write: { kind: 'return', run: r.run_id, ...(r.ws ? { ws: r.ws } : {}) },
     pane: { label: 'Run record', file: 'planning/runs/agent-runs.jsonl', h: i ? clip(i.title, 90) : r.initiative_id, intro: '', rows: facts, paras: r.note ? [clip(r.note, 600)] : [], parasTitle: 'Its note' },
   };
 }
@@ -314,10 +326,10 @@ function todayOf(f) {
   for (const m of f.meetings || []) {
     items.push({ at: m.start, t: hhmm(m.start), kind: 'meeting', title: m.title, sub: [Math.round((m.end - m.start) / 60000) + ' min', m.with].filter(Boolean).join(' · '), src: 'Calendar', dialog: tryD(() => meetingDialog(m)) });
   }
-  for (const m of f.merges || []) if (m.at >= midnight && m.at <= f.now) items.push({ at: m.at, t: hhmm(m.at), kind: 'merge', title: clip(m.title, 110), sub: 'Merged to main', src: 'Merges', dialog: tryD(() => mergeDialog(m, f)) });
+  for (const m of f.merges || []) if (m.at >= midnight && m.at <= f.now) items.push({ at: m.at, t: hhmm(m.at), kind: 'merge', ...(m.product ? { product: m.product } : {}), title: clip(m.title, 110), sub: 'Merged to main', src: 'Merges', dialog: tryD(() => mergeDialog(m, f)) });
   const runs = (f.runs || []).filter((r) => { const t = Date.parse(r.created_at); return t >= midnight && t <= f.now; });
-  const byId = new Map(f.initiatives.map((i) => [i.id, i]));
-  for (const r of runs) { const t = Date.parse(r.created_at); items.push({ at: t, t: hhmm(t), kind: 'run', title: clip((byId.get(r.initiative_id) || {}).title || r.initiative_id, 110), sub: 'Agent run' + (Number.isFinite(Number(r.human_corrections)) ? ' · ' + r.human_corrections + ' ' + plural(Number(r.human_corrections), 'correction', 'corrections') : ''), src: 'Agent runs', dialog: tryD(() => runDialog(r, t, byId)) }); }
+  const byId = new Map(f.initiatives.map((i) => [idk(i, i.id), i]));
+  for (const r of runs) { const t = Date.parse(r.created_at); items.push({ at: t, t: hhmm(t), kind: 'run', ...(r.product ? { product: r.product } : {}), title: clip((byId.get(idk(r, r.initiative_id)) || {}).title || r.initiative_id, 110), sub: 'Agent run' + (Number.isFinite(Number(r.human_corrections)) ? ' · ' + r.human_corrections + ' ' + plural(Number(r.human_corrections), 'correction', 'corrections') : ''), src: 'Agent runs', dialog: tryD(() => runDialog(r, t, byId)) }); }
   const ahead = items.filter((x) => x.at > f.asOf).sort((a, b) => a.at - b.at), earlier = items.filter((x) => x.at <= f.asOf).sort((a, b) => b.at - a.at);
   const count = (k) => items.filter((x) => x.kind === k).length;
   return { ahead, earlier, now: { t: hhmm(f.asOf), label: 'snapshot' }, counts: { meeting: count('meeting'), merge: count('merge'), run: count('run') }, note: ahead.length + earlier.length ? null : 'Nothing is recorded for today yet.' };
@@ -348,6 +360,56 @@ function build(f) {
   };
 }
 
+
+/* ── several products (initiative briefing-premium-products) ──────────────────────────────────────────────── */
+const KIND_RANK = { blocked: 0, decision: 1, waited: 2 };
+const longest = (r) => { const d = (r.detail && r.detail.days) || []; return d.length ? d[d.length - 1] : 0; };
+
+/** Several products' facts → ONE model, in the same shape build() makes.
+ *   g = { now, asOf, meetings (shared, or null), defers { key: until }, available: [{ ws, name, home, on }],
+ *         parts: [{ product: { ws, name }, f (that product's facts) | null, state: 'ready' | 'reading' | 'error', error? }] }
+ * A row belongs to one product (its key ends with the workspace id) and the rows are put in one order: blocked first, then decisions, then reviews.
+ * A count is never summed across products: each product gets its own failed-review row. The hero and Today read the merged facts. */
+function buildMany(g) {
+  skipped.n = 0;
+  const now = g.now, asOf = g.asOf || g.now, meetings = g.meetings === undefined ? null : g.meetings;
+  const parts = (g.parts || []).map((p) => ({ product: p.product, state: p.state || 'ready', error: p.error, f: p.f ? Object.assign({ initiatives: [], runs: [], merges: [], evals: [], tripwires: null, missing: [], protoDecided: [] }, p.f, { now, asOf, meetings, defers: g.defers || {}, product: p.product }) : null }));
+  const read = parts.filter((p) => p.f && p.state !== 'error');
+  const every = [], putOff = [];
+  for (const p of read) { const a = allRowsOf(p.f); every.push(...a.all); putOff.push(...a.putOff); }
+  every.sort((a, b) => (KIND_RANK[a.kind] - KIND_RANK[b.kind]) || (a.kind === 'blocked' ? (a.order[0] - b.order[0]) || (a.order[1] < b.order[1] ? -1 : a.order[1] > b.order[1] ? 1 : 0) : a.kind === 'waited' ? longest(b) - longest(a) : 0));
+  const { rows, more } = cut(every, putOff);
+  const tag = (list, p) => list.map((x) => Object.assign({}, x, { ws: p.product.ws, product: p.product.name }));
+  const cf = {
+    now, asOf, meetings, defers: g.defers || {},
+    initiatives: [].concat(...read.map((p) => p.f.initiatives.map((i) => Object.assign({}, i, { ws: p.product.ws })))),
+    runs: [].concat(...read.map((p) => tag(p.f.runs, p))),
+    merges: [].concat(...read.map((p) => tag(p.f.merges, p))),
+    evals: [].concat(...read.map((p) => tag(p.f.evals, p))),
+  };
+  const available = g.available || [], inc = available.filter((a) => a.on), out = available.filter((a) => !a.on);
+  const waiting = parts.filter((p) => p.state === 'reading' || !p.f).filter((p) => p.state !== 'error'), failed = parts.filter((p) => p.state === 'error');
+  const pending = parts.some((p) => p.state === 'reading' || (p.f && p.f.pending));
+  const missing = [];
+  if (meetings === null) missing.push('calendar');
+  for (const p of read) for (const k of p.f.missing || []) missing.push(k + ' (' + p.product.name + ')');
+  for (const p of failed) missing.push(p.product.name);
+  const missText = [].concat(meetings === null ? ['the calendar'] : [], ...read.map((p) => (p.f.missing || []).map((k) => (SOURCE_NAME[k] || k) + ' of ' + p.product.name)), failed.map((p) => p.product.name + ' could not be read'));
+  const none = !inc.length;
+  const hero = none ? [{ parts: [{ t: available.length ? 'No product is included, so there is nothing to read. Pick one under Products.' : 'No product workspace is registered, so there is nothing to read.', s: false }], from: [] }]
+    : heroOf(cf, rows);
+  return {
+    date: dateLine(now),
+    pending,
+    header: { text: 'Real data · as of ' + hhmm(asOf) + ' · ' + (none ? 'no product included' : joinNames(inc.map((a) => a.name))) + (out.length ? ' · ' + joinNames(out.map((a) => a.name)) + ' not included' : '') + (missText.length ? ' · not read: ' + missText.join(', ') : '') + (waiting.length ? ' · reading ' + joinNames(waiting.map((p) => p.product.name)) : '') + (skipped.n ? ' · ' + skipped.n + (skipped.n === 1 ? ' record' : ' records') + ' could not be read and ' + (skipped.n === 1 ? 'was' : 'were') + ' left out' : ''), missing },
+    hero: hero.length ? hero : [{ parts: [{ t: pending ? 'Reading the initiative state. What needs you is not known yet.' : 'Nothing needs you and nothing moved today that the records show.', s: false }], from: [] }],
+    list: { title: 'What you need to do', rows, more, count: rows.length + more, pendingNote: pending ? 'Blocked work, prototypes waiting for you and failed reviews appear when the initiative state has been read.' : null, putOff: putOff.map((x) => ({ key: x.key, title: x.title, ...(x.product ? { product: x.product } : {}), until: x.until, text: (x.product ? x.product + ': ' : '') + x.title + ' · back ' + backAt(x.until, now) })), order: 'In this order: blocked work first, then decisions only you can make, then what has waited longest.' },
+    today: todayOf(cf),
+    dock: { needs: pending ? null : rows.length + more, label: plural(rows.length + more, 'needs you', 'need you'), next: rows[0] ? rows[0].title : null },
+    products: { available: available.map((a) => ({ ws: a.ws, name: a.name, home: !!a.home, on: !!a.on })), none },
+  };
+}
+
 /* ── I/O ──────────────────────────────────────────────────────────────────────────────────────────────────── */
 const readJsonl = (file) => { try { return fs.readFileSync(file, 'utf8').split('\n').map((l) => l.trim()).filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return null; } };
 const run = (cmd, args, opts) => new Promise((res) => {
@@ -406,8 +468,18 @@ async function repoKey(root) {
   return head.trim() + ':' + require('crypto').createHash('sha1').update(st || '').digest('hex').slice(0, 12);
 }
 
+/** Today's calendar rows, from the calendar PMOS holds (one for the whole computer, not one per workspace). null when it cannot be read. */
+function readMeetings(runtimeDir, now) {
+  try {
+    const CE = require('./calendar-events.js');
+    if (!runtimeDir) throw new Error('no runtime dir');
+    const all = CE.readAll(runtimeDir, { now });
+    return CE.eventsOn(all, dayKey(now)).map((e) => ({ start: Date.parse(e.start), end: Date.parse(e.end), title: e.title, with: e.with || '', initiative: e.initiative || null })).filter((e) => Number.isFinite(e.start));
+  } catch { return null; }
+}
+
 /** The quick read: runs, reviews, merges (with their files), the calendar and the kill conditions. No initiative state. */
-async function readFast({ root, now, runtimeDir }) {
+async function readFast({ root, now, runtimeDir, calendar = true }) {
   const f = { now: now || Date.now(), asOf: now || Date.now(), initiatives: [], runs: [], merges: [], evals: [], meetings: null, tripwires: null, missing: [] };
   const runs = readJsonl(path.join(root, 'planning', 'runs', 'agent-runs.jsonl')); if (runs) f.runs = runs; else f.missing.push('runs');
   const evals = readJsonl(path.join(root, 'planning', 'runs', 'evals.jsonl')); if (evals) f.evals = evals; else f.missing.push('evals');
@@ -423,12 +495,7 @@ async function readFast({ root, now, runtimeDir }) {
     m.files = nums.length; m.ins = ins; m.del = del; m.dirs = Object.entries(top).sort((a, b) => b[1] - a[1]).slice(0, 3).map((e) => e[0]);
     m.body = lines.filter((x) => !/^(\d+|-)\t(\d+|-)\t/.test(x)).join('\n').trim();
   }
-  try {
-    const CE = require('./calendar-events.js');
-    if (!runtimeDir) throw new Error('no runtime dir');
-    const all = CE.readAll(runtimeDir, { now: f.now });
-    f.meetings = CE.eventsOn(all, dayKey(f.now)).map((e) => ({ start: Date.parse(e.start), end: Date.parse(e.end), title: e.title, with: e.with || '', initiative: e.initiative || null })).filter((e) => Number.isFinite(e.start));
-  } catch { f.meetings = null; }
+  if (calendar) f.meetings = readMeetings(runtimeDir, f.now);
   f.tripwires = readTripwires(root);
   f.protoDecided = [...W.decidedPrototypes(root)];
   f.defers = Object.fromEntries(W.readDefers(runtimeDir, f.now));
@@ -511,4 +578,4 @@ const peekModel = (root) => (kept && kept.root === root ? kept.model : partial &
 const settle = () => inflight || Promise.resolve();
 const forget = () => { kept = null; partial = null; inflight = null; lastError = null; startedAt = 0; };
 
-module.exports = { build, hooks, refresh, readSources, readFast, readInitiatives, repoKey, readFm, readTripwires, modelOf, settle, forget, rebuild, peekModel, rowsOf, heroOf, todayOf, failedReviews, num };
+module.exports = { build, buildMany, allRowsOf, readMeetings, hooks, refresh, readSources, readFast, readInitiatives, repoKey, readFm, readTripwires, modelOf, settle, forget, rebuild, peekModel, rowsOf, heroOf, todayOf, failedReviews, num };

package/workspace/lib/routes-briefing-premium.js

@@ -20,6 +20,23 @@ const { repoScript } = require('./repo-script.js');
 const { correctionEvent } = require(repoScript('card-state.js'));
 const { appendOutbox } = require(repoScript('outbox.js'));
 
+const Prod = require('./briefing-premium-products.js');
+const settings = require('./settings-store.js');
+
+/** The workspaces the Briefing may read right now (initiative briefing-premium-products): choose()'s list, from the server's workspace list and the PM's setting. */
+function products(ctx, only) {
+  const home = ctx.homeRoot || ctx.selfRoot || null;
+  const list = (typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : []).map((w) => ({ id: w.id, name: w.label || w.name, root: w.root, home: !!home && path.resolve(w.root) === path.resolve(home) }));
+  return Prod.choose({ workspaces: list, include: settings.get(ctx.runtimeDir, 'ws.briefing.include', null), only });
+}
+/** The included product a merged row (or a returned run) belongs to: { root, ws } | { error }. null when the key is the one-workspace page's. */
+function ownerOf(ctx, ws) {
+  const a = products(ctx).available.find((x) => x.ws === ws);
+  if (!a) return { error: 'that product is not registered' };
+  if (!a.on) return { error: a.name + ' is not included in the Briefing' };
+  return { root: a.root, ws: a.ws };
+}
+
 const enginePath = () => ENGINE_PATHS.find((p) => fs.existsSync(p)) || null;
 
 const POSTS = ['decide', 'put-off', 'return', 'ask'];
@@ -37,21 +54,29 @@ async function post(req, res, url, ctx) {
   const b = got.body;
   const g = guard.requirePagePress(req, b);
   if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
-  const root = rootOf(url, ctx), runtimeDir = ctx.runtimeDir;
+  const runtimeDir = ctx.runtimeDir;
+  // A merged row's key ends with its workspace (kind:id:ws); the one-workspace page's key does not and keeps the old path.
+  const sk = Prod.splitKey(b.key);
+  let root = rootOf(url, ctx), merged = false;
+  if (sk || (act === 'return' && b.ws)) {
+    const o = ownerOf(ctx, sk ? sk.ws : String(b.ws));
+    if (o.error) { ctx.json(res, { ok: false, error: o.error }, 400); return true; }
+    root = o.root; merged = true;
+  }
   if (act === 'ask') {
-    let wsId; try { const w = ctx.getWs && ctx.getWs(url.searchParams.get('ws') || null); wsId = w && w.id; } catch { wsId = undefined; }
-    const a = Ag.ask({ runtimeDir, key: b.key, text: b.text, model: /^work:/.test(String(b.key || '')) ? WP.peekModel() : /^board:/.test(String(b.key || '')) ? BoardP.peekModel() : /^(init|doc):/.test(String(b.key || '')) ? InitP.peekModel() : BP.peekModel(root), spawnSession: ctx.spawnSession, wsId });
+    let wsId; try { const w = merged && sk ? { id: sk.ws } : ctx.getWs && ctx.getWs(url.searchParams.get('ws') || null); wsId = w && w.id; } catch { wsId = undefined; }
+    const a = Ag.ask({ runtimeDir, key: b.key, text: b.text, model: /^work:/.test(String(b.key || '')) ? WP.peekModel() : /^board:/.test(String(b.key || '')) ? BoardP.peekModel() : /^(init|doc):/.test(String(b.key || '')) ? InitP.peekModel() : sk ? Prod.peekModel() : BP.peekModel(root), spawnSession: ctx.spawnSession, wsId });
     ctx.json(res, a.body, a.status);
     return true;
   }
   let r;
   try {
-    if (act === 'decide') r = Wr.decide({ root, key: b.key, choice: b.choice, why: b.why });
+    if (act === 'decide') r = Wr.decide({ root, key: sk ? sk.base : b.key, choice: b.choice, why: b.why });
     else if (act === 'put-off') r = Wr.putOff({ runtimeDir, key: b.key, until: b.until });
     else r = Wr.returnRun({ root, runtimeDir, run: b.run, reason: b.reason, correctionEvent, appendOutbox });
   } catch (e) { r = { ok: false, status: 500, error: 'the record could not be written: ' + String((e && e.message) || e).slice(0, 160) }; }
   if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, r.status || 400); return true; }
-  try { await BP.rebuild({ root, runtimeDir }); } catch { /* the page re-reads on its next poll */ }
+  try { if (merged) await Prod.rebuildOne({ root, runtimeDir }); else await BP.rebuild({ root, runtimeDir }); } catch { /* the page re-reads on its next poll */ }
   ctx.json(res, { ok: true, wrote: act, ...(r.heading ? { heading: r.heading } : {}) });
   return true;
 }
@@ -72,6 +97,13 @@ module.exports = {
     }
     if (url.pathname !== '/api/briefing-premium') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    // No ws: the Briefing across the products the PM picked. A ws: that one workspace, read as before.
+    if (!url.searchParams.get('ws')) {
+      const sel = products(ctx);
+      const r = await Prod.modelOfMany({ available: sel.available, engine: enginePath(), runtimeDir: ctx.runtimeDir });
+      ctx.json(res, r.state === 'error' ? { ok: false, ...r } : { ok: true, ...r }, r.state === 'ready' ? 200 : r.state === 'reading' ? 202 : 500);
+      return true;
+    }
     let root;
     try { const w = ctx.getWs && ctx.getWs(url.searchParams.get('ws') || null); root = w && w.root; } catch { root = null; }
     root = root || path.resolve(__dirname, '..', '..');

package/workspace/lib/settings-store.js

@@ -33,6 +33,8 @@ const bool = (section, scope, def) => ({ section, scope, type: 'bool', def });
 const DEFS = Object.freeze({
   'ws.start': one('workspaces', 'computer', ['last', 'ask'], 'last'),
   'ws.briefing': one('workspaces', 'computer', ['one', 'all'], 'one'),
+  // the premium Briefing: which workspaces it reads (initiative briefing-premium-products). null = every one except the home workspace.
+  'ws.briefing.include': { section: 'workspaces', scope: 'computer', type: 'ids', max: 50, def: null },
   'board.template': one('boards', 'ws', ['product', 'project', 'simple'], 'product'),
   'board.rules': one('boards', 'ws', ['warn', 'off'], 'warn'),
   'board.templates': { section: 'boards', scope: 'computer', type: 'templates', def: TEMPLATES },
@@ -121,6 +123,7 @@ function validate(key, value) {
       if (typeof value !== 'string' || value.length > 64) return `${key} must be a time zone such as Asia/Jakarta, or empty for this computer's`;
       try { new Intl.DateTimeFormat('en', { timeZone: value }); return null; } catch { return `${value} is not a time zone this computer knows`; }
     }
+    case 'ids': return value === null || Array.isArray(value) && value.length <= d.max && value.every((x) => typeof x === 'string' && WS_ID.test(x)) && new Set(value).size === value.length ? null : `${key} must list at most ${d.max} workspace ids, each once`;
     case 'templates': {
       if (!value || typeof value !== 'object' || Array.isArray(value)) return `${key} must name the templates`;
       const ids = Object.keys(value);

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/premium.css

@@ -1196,3 +1196,17 @@ button.dsn:hover{box-shadow:inset 0 0 0 1.5px rgb(79,109,245)}
 .crmenu{max-height:min(60vh,420px);overflow:auto;overscroll-behavior:contain}
 .crmenu button{flex:none}
 .crmenu button span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+
+/* the Briefing across products (initiative briefing-premium-products): the product name on a row, and the picker built from the mockup's chip and menu */
+.pn{font:600 12.5px var(--mono);letter-spacing:.04em;color:var(--ink-2);margin-right:8px;padding:2px 8px;border-radius:999px;background:var(--well);white-space:nowrap}
+.pkw{position:relative;display:inline-flex;align-items:center}
+.pkw[hidden]{display:none}
+.pkw .fchip{height:44px}
+.pkmenu{left:auto;right:0;min-width:240px}
+.pkmenu .bx{flex:none;width:20px;height:20px;border-radius:6px;border:2px solid var(--ink-3);display:grid;place-items:center}
+.pkmenu button[aria-checked="true"] .bx{background:var(--solid);border-color:var(--solid)}
+.pkmenu button[aria-checked="true"] .bx::after{content:"";width:9px;height:5px;border-left:2px solid var(--on-solid);border-bottom:2px solid var(--on-solid);transform:rotate(-45deg) translate(1px,-1px)}
+.pkmenu .pkreset{margin-top:4px;border-top:1px solid var(--hair);border-radius:0 0 14px 14px;color:var(--ink-2)}
+.pkempty{padding:10px 14px}
+.top{position:relative;z-index:6}
+.pkw{z-index:40}

package/workspace/public/pm/premium.js

@@ -42,7 +42,7 @@ function drawRows() {
   const keys = rows.map((r) => r.key), off = (M.list.putOff || []).map((x) => x.key);   // a row put off is not done: it leaves both counts and is named below the list
   const base = (M.pending ? keys : baseline(keys)).filter((k) => !off.includes(k)), done = base.filter((k) => !keys.includes(k)).length, total = base.length;
   const order = rows.slice().sort((a, b) => (pinned.has(b.key) - pinned.has(a.key)) || (a.n - b.n));
-  L.innerHTML = order.map((r, i) => `<div class="rr${i < 3 ? ' lead' : ''}${i === 0 ? ' first' : ''}" data-key="${esc(r.key)}"${linkOf(r) ? ` data-link="${esc(linkOf(r))}"` : ''}><button class="rhd" aria-haspopup="dialog"><span class="rn">${STAMP(i + 1)}</span><span><span class="rt">${esc(r.title)}${i === 0 ? '<em class="tgf">Do this first</em>' : ''}</span><span class="rs">${esc(r.subject)}</span><span class="sug"><span>${esc(r.prepared)}</span></span><span class="skip">${esc(r.skip)}</span></span></button><button class="rpin" data-pin="${esc(r.key)}" aria-pressed="${pinned.has(r.key)}" aria-label="Pin ${esc(r.title)} to the top" title="Pin to the top"><svg class="i" viewBox="0 0 24 24"><path d="M9 4h6l-1 6 3 3H7l3-3zM12 13v7"/></svg></button></div>`).join('')
+  L.innerHTML = order.map((r, i) => `<div class="rr${i < 3 ? ' lead' : ''}${i === 0 ? ' first' : ''}" data-key="${esc(r.key)}"${linkOf(r) ? ` data-link="${esc(linkOf(r))}"` : ''}><button class="rhd" aria-haspopup="dialog"><span class="rn">${STAMP(i + 1)}</span><span><span class="rt">${esc(r.title)}${i === 0 ? '<em class="tgf">Do this first</em>' : ''}</span><span class="rs">${r.product ? `<b class="pn">${esc(r.product)}</b>` : ''}${esc(r.subject)}</span><span class="sug"><span>${esc(r.prepared)}</span></span><span class="skip">${esc(r.skip)}</span></span></button><button class="rpin" data-pin="${esc(r.key)}" aria-pressed="${pinned.has(r.key)}" aria-label="Pin ${esc(r.title)} to the top" title="Pin to the top"><svg class="i" viewBox="0 0 24 24"><path d="M9 4h6l-1 6 3 3H7l3-3zM12 13v7"/></svg></button></div>`).join('')
     + (M.list.more ? `<p class="note">${M.list.more} more ${M.list.more === 1 ? 'row is' : 'rows are'} not shown here.</p>` : '');
   const n = M.list.count;
   $('#movesCap').innerHTML = M.pending ? `${n} ${n === 1 ? 'row' : 'rows'} so far · still reading` : n ? `<b>${done} of ${total}</b> done · ${n} ${n === 1 ? 'row' : 'rows'} left` : 'All clear';
@@ -66,7 +66,7 @@ $('#rank').addEventListener('click', (e) => {
 const linkOf = (r) => ((r.from || []).find((x) => /^meeting:/.test(x)) || '').replace(/^meeting:/, '');
 function evHtml(e, i) {
   const lnk = e.kind === 'meeting' && (M.list.rows || []).some((r) => linkOf(r) === e.title) ? e.title : '';
-  return `<button class="ev src-${e.kind}"${lnk ? ` data-link="${esc(lnk)}"` : ''} data-i="${i}" style="animation:rise .6s var(--ease) both"><time>${esc(e.t)}</time><span class="gl-t"><svg class="i" viewBox="0 0 24 24">${ICON[e.kind]}</svg></span><span><b>${esc(e.title)}</b><span class="d">${esc(e.sub)}</span></span></button>`;
+  return `<button class="ev src-${e.kind}"${lnk ? ` data-link="${esc(lnk)}"` : ''} data-i="${i}" style="animation:rise .6s var(--ease) both"><time>${esc(e.t)}</time><span class="gl-t"><svg class="i" viewBox="0 0 24 24">${ICON[e.kind]}</svg></span><span><b>${esc(e.title)}</b><span class="d">${esc(e.sub)}${e.product ? ' · ' + esc(e.product) : ''}</span></span></button>`;
 }
 const ALL = () => M.today.ahead.concat(M.today.earlier);
 function drawChips() {
@@ -180,7 +180,7 @@ $('#dBody').addEventListener('click', (e) => {
     const w = openR.dialog.write, why = ($('#why') || {}).value || '', key = openR.key;
     WHY[key] = why;
     if (w.kind === 'decision') write('decide', { key, choice: SEL[key] || openR.dialog.sel, why }, async (res) => { delete WHY[key]; toast('Recorded in pm-decisions.md.'); closeDlg(); await load(); });
-    else write('return', { run: w.run, reason: RET[key] }, async () => { toast('Returned to the agent. It counts as a correction.'); closeDlg(); await load(); });
+    else write('return', { run: w.run, reason: RET[key], ...(w.ws ? { ws: w.ws } : {}) }, async () => { toast('Returned to the agent. It counts as a correction.'); closeDlg(); await load(); });
   }
 });
 $('#dBody').addEventListener('input', (e) => { if (e.target.id === 'why' && openR) { WHY[openR.key] = e.target.value; ctaState(openR); } });
@@ -197,6 +197,50 @@ function openEvent(e) {
   ['pointerleave', 'focusout'].forEach((ev) => document.addEventListener(ev, (e) => { const t = e.target.closest && e.target.closest('[data-link]'); if (t) lk(t, false); }, true));
 }
 
+
+/* ── the products the Briefing reads (initiative briefing-premium-products) ──────────────────────────────────────────────────────────── */
+const wsParam = () => new URLSearchParams(location.search).get('ws');
+function drawPick() {
+  const w = $('#pkw'), P = M.products, one = wsParam();
+  if (!w) return;
+  if (one) { w.hidden = false; $('#pick').hidden = true; $('#pickMenu').hidden = true; let a = $('#pickAll'); if (!a) { a = document.createElement('a'); a.id = 'pickAll'; a.className = 'fchip'; a.href = '/premium.html'; a.textContent = 'All picked products'; w.appendChild(a); } return; }
+  if ($('#pickAll')) $('#pickAll').remove();
+  $('#pick').hidden = false;
+  if (!P) { w.hidden = true; return; }
+  w.hidden = false;
+  const n = P.available.filter((x) => x.on).length;
+  $('#pickN').textContent = n + ' of ' + P.available.length;
+  $('#pickMenu').innerHTML = P.available.length
+    ? P.available.map((x) => `<button role="menuitemcheckbox" aria-checked="${x.on}" data-ws="${esc(x.ws)}"><i class="bx"></i><span>${esc(x.name)}</span>${x.home ? '<em>home</em>' : ''}</button>`).join('') + '<button role="menuitem" data-reset="1" class="pkreset"><span>Back to the default</span><em>all but home</em></button>'
+    : '<p class="note pkempty">No product workspace is registered.</p>';
+}
+function closePick() { $('#pickMenu').hidden = true; $('#pick').setAttribute('aria-expanded', 'false'); }
+$('#pick').addEventListener('click', (e) => {
+  e.stopPropagation();
+  const m = $('#pickMenu'), open = m.hidden;
+  m.hidden = !open; $('#pick').setAttribute('aria-expanded', open);
+  if (open) { const f = $('button', m); if (f) f.focus(); }
+});
+document.addEventListener('click', (e) => { if (!e.target.closest('#pkw')) closePick(); });
+$('#pkw').addEventListener('keydown', (e) => {
+  if (e.key === 'Escape') { closePick(); $('#pick').focus(); return; }
+  if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp') return;
+  const L = $$('#pickMenu button'), i = L.indexOf(document.activeElement); if (i < 0) return;
+  e.preventDefault(); L[(i + (e.key === 'ArrowDown' ? 1 : L.length - 1)) % L.length].focus();
+});
+$('#pickMenu').addEventListener('click', async (e) => {
+  const b = e.target.closest('button'); if (!b || !M || !M.products) return;
+  const on = M.products.available.filter((x) => x.on).map((x) => x.ws);
+  let body;
+  if (b.dataset.reset) body = { key: 'ws.briefing.include', reset: true };
+  else { const ws = b.dataset.ws, next = on.includes(ws) ? on.filter((x) => x !== ws) : on.concat(ws); body = { key: 'ws.briefing.include', value: next }; }
+  const res = await pmPost('/api/settings', body);
+  if (!res || res.ok !== true) { toast((res && res.error) || 'The choice was not saved.'); return; }
+  toast(b.dataset.reset ? 'Back to the default: every product except the home one.' : 'Saved. The Briefing now reads the products you ticked.');
+  await load();
+  const again = b.dataset.ws ? $(`#pickMenu [data-ws="${CSS.escape(b.dataset.ws)}"]`) : null; if (again) again.focus();
+});
+
 /* ── load ───────────────────────────────────────────────────────────────────────────────────────────────── */
 let readTimer = null;
 const ago = (ms) => { const m = Math.round(ms / 60000); return m < 1 ? 'just now' : m < 90 ? m + ' min ago' : Math.round(m / 60) + ' h ago'; };
@@ -207,7 +251,7 @@ async function load() {
   clearInterval(readTimer);
   if (r && r.state === 'reading') {
     // the first read has no end I can promise: say how long it has run, and ask again
-    const t0 = Date.now() - (r.elapsed_ms || 0), tick = () => { $('#brief').textContent = 'Reading the repository for the first time. ' + Math.round((Date.now() - t0) / 1000) + ' s so far. This page shows nothing until it has read, rather than guess.'; };
+    const t0 = Date.now() - (r.elapsed_ms || 0), tick = () => { $('#brief').textContent = 'Reading the products for the first time. ' + Math.round((Date.now() - t0) / 1000) + ' s so far. This page shows nothing until it has read, rather than guess.'; };
     tick(); readTimer = setInterval(tick, 1000); setTimeout(load, 3000);
     return;
   }
@@ -216,7 +260,7 @@ async function load() {
     $('#brief').textContent = 'The Briefing could not read the repository, so it shows nothing rather than guess.' + (r && r.error ? ' The reason: ' + r.error : status ? ' (the server answered ' + status + ')' : ' The server did not answer.');
     return;
   }
-  M = r.model; drawHero(); drawRows(); drawChips(); drawTl(); drawDock(); onScroll();
+  M = r.model; drawHero(); drawRows(); drawChips(); drawTl(); drawDock(); drawPick(); onScroll();
   const age = Date.now() - r.as_of;
   if (age > 5 * 60000) $('#snap').textContent += ' · read ' + ago(age) + (r.refreshing ? ', refreshing' : '');
   if (r.error) $('#snap').textContent += ' · the latest read failed: ' + r.error.slice(0, 120);

package/workspace/public/premium.html

@@ -35,6 +35,7 @@
  <header class="top rise" style="--d:0">
   <h1 class="vh">Briefing</h1><span class="glass name" aria-hidden="true">Briefing</span>
   <div class="tools tools-top"><span class="snap" id="snap">Reading the repository</span>
+   <span class="pkw" id="pkw" hidden><button class="fchip" id="pick" aria-haspopup="menu" aria-expanded="false" aria-controls="pickMenu">Products<em id="pickN"></em></button><div class="crmenu pkmenu" id="pickMenu" role="menu" hidden></div></span>
    <button class="glass round" id="theme" aria-label="Switch light or dark"><svg class="i" viewBox="0 0 24 24"><path d="M20 14.5A8 8 0 0 1 9.5 4 8 8 0 1 0 20 14.5z"/></svg></button></div>
  </header>
  <section class="hero">

package/workspace/server.js

@@ -9360,7 +9360,7 @@ async function handleRequest(req, res) {
   // pm-os-absorb Runs 2–5 — the planning layer's routes, one file per run (lib/route-modules.js). Last, so none shadows a route above.
   // meeting-notes Run 1: the Notes routes keep notes in the per-user runtime directory and start the agent-summary session.
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
-    runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession, endSupersededRuns, proSettings,
+    runtimeDir: STATE, homeRoot: HOME_ENABLED ? SELF_ROOT : null, spawnSession, jevModelOpts, sendToSession, endSupersededRuns, proSettings,
     // report-workspace: the schedule store a recurring report registers its draft-only schedule in, a skill's body, and the stop of a headless run
     scheduleStore: { read: readSchedules, write: writeSchedules },
     // report-structure-gaps: Draft it now on a report with a saved structure starts the draft session the schedule would, and the row reads its state

package/workspace/test-files.json

@@ -41,6 +41,7 @@
     "briefing-premium-work.test.js",
     "briefing-premium-board.test.js",
     "briefing-premium-initiative.test.js",
+    "briefing-premium-products.test.js",
     "calendar-events.test.js",
     "calendar-supersede.test.js",
     "tracker-read.test.js",
@@ -200,6 +201,7 @@
     "briefing-premium-work.test.js": 1,
     "briefing-premium-board.test.js": 1,
     "briefing-premium-initiative.test.js": 1,
+    "briefing-premium-products.test.js": 1,
     "calendar-events.test.js": 1,
     "calendar-supersede.test.js": 1,
     "tracker-read.test.js": 1,

package/workspace/test-lists/briefing-premium.json

@@ -5,6 +5,7 @@
     "briefing-premium-work-test.js",
     "briefing-premium-board-test.js",
     "briefing-premium-initiative-test.js",
+    "briefing-premium-products-test.js",
     "briefing-premium-agent-server.test.js"
   ],
   "seconds": {
@@ -12,6 +13,7 @@
     "briefing-premium-work-test.js": 80,
     "briefing-premium-board-test.js": 120,
     "briefing-premium-initiative-test.js": 120,
+    "briefing-premium-products-test.js": 90,
     "briefing-premium-agent-server.test.js": 40
   }
 }