create-pmos 0.253.0 → 0.255.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.253.0",
+  "version": "0.255.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
-assembled: 2026-10-17
+kernel-source: pmos@c9a1e5a
+assembled: 2026-10-18
 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-18T00:27:07Z"}
 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-18T00:27:07Z"}
 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-18T00:27:07Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-17
+## 2026-10-18
 
 - Adopted OKF v0.2 (D73).

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/briefing-premium-sources-test.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+'use strict';
+/* briefing-premium-sources-test.js — mail, Jira and Confluence on the premium Briefing (initiative briefing-premium-sources; planning/prd/briefing-premium-sources-prd.md S1 to S11).
+ * The real server with one product repository and a made-up morning brief written to <state>/briefs/<today>.json. Nothing here touches the PM's real briefs.
+ *   S1/S8 no brief for today: the header says so      S2/S5 the rows, each tagged Across products (the brief names no included initiative)
+ *   S3    the dialog opens an https link and records nothing      S7 the digests in Today      S9 the writes refuse a source key; the agent answers
+ *   S11   the source row and the digest look like the mockup's own row and Today item at 1280 and 390 px, light and dark; no sideways scroll
+ * 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-sources' });
+
+const BASE = T.BASE;
+const MOCKUP = path.join(__dirname, '..', 'prototype', 'premium-ux-concept', 'briefing-artifact.html');
+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-bps-'));
+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-sources assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+const pad = (n) => String(n).padStart(2, '0');
+const TODAY = (() => { const d = new Date(); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; })();
+const item = (id, o = {}) => ({ id, title: 'Item ' + id, why_now: 'Why ' + id, evidence: '', source: 'mail', initiative_id: null, owner: 'pm', effort: 'minutes', confidence: 0.9, worth_asking: false, kind: 'you', ...o });
+const BRIEF = {
+  date: TODAY, generated_at: new Date(Date.now() - 60000).toISOString(), sources: { mail: 'read', jira: 'read', confluence: 'read', slack: 'read' }, calendar: [],
+  priorities: [
+    item('aaaaaaaaaaa1', { title: 'Confirm the Thursday review', who: 'Anna Lee', verb: 'reply', todo: 'Confirm Thursday', link: 'https://mail.example/t/1', ask: 'Can you confirm?' }),
+    item('aaaaaaaaaaa2', { title: 'Sign off the vendor terms', source: 'confluence', who: 'Budi Santoso', verb: 'sign-off', link: 'https://wiki.example/p/2' }),
+    item('aaaaaaaaaaa3', { title: 'Look at the failing ticket', source: 'jira', who: 'Chen', verb: 'review', todo: 'Check the repro', link: 'https://jira.example/browse/AB-3' }),
+  ],
+  worth_asking: [item('bbbbbbbbbbb1', { title: 'A thread that may be for you', who: 'Dewi', confidence: 0.3, worth_asking: true })],
+  digests: [{ source: 'slack', name: '#launch', link: 'https://slack.example/c/1', decisions: ['Ship on Friday'], open: ['Who owns QA'], goals: [] }],
+  places: [], resolved: [],
+};
+const sh = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the briefing-premium-sources suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the briefing-premium-sources 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 root = path.join(tmp, 'idpf-repo');
+  fs.mkdirSync(root, { recursive: true }); fs.writeFileSync(path.join(root, 'AGENTS.md'), '# a\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']);
+  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 { j = null; } return { status: res.status, body: j }; };
+  const added = await json('POST', '/api/workspaces', { root, name: 'IDPF', focus: false });
+  ok('S0 the product is registered', !!(added.body && added.body.workspace));
+  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('S1 with no brief for today there are no source rows and the header says so', m0 && !m0.model.list.rows.some((r) => r.kind === 'source') && /no morning brief for today/.test(m0.model.header.text), m0 && m0.model.header.text);
+
+  // the brief is written where the workspace reads it: <state>/briefs/<today>.json
+  fs.mkdirSync(path.join(T.STATE_DIR, 'briefs'), { recursive: true });
+  fs.writeFileSync(path.join(T.STATE_DIR, 'briefs', TODAY + '.json'), JSON.stringify(BRIEF));
+  const m1 = (await json('GET', '/api/briefing-premium')).body.model;
+  const srcRows = m1.list.rows.filter((r) => r.kind === 'source');
+  ok('S2 four rows come from the brief: three priorities and one worth asking, in the brief\'s order', srcRows.length === 4 && srcRows[0].title === 'Confirm the Thursday review' && srcRows[3].title === 'A thread that may be for you', JSON.stringify(srcRows.map((r) => r.title)));
+  ok('S5 every row reads Across products, because the brief names no initiative of an included product', srcRows.every((r) => r.product === 'Across products'));
+  ok('S8 the header no longer says there is no brief', !/no morning brief/.test(m1.header.text), m1.header.text);
+
+  browser = await chromium.launch({ executablePath: exe });
+  const open = async ({ w = 1280, h = 900, theme = 'light' } = {}) => {
+    const ctx = await browser.newContext({ viewport: { width: w, height: h } });
+    const page = await ctx.newPage(); const errors = [];
+    page.on('pageerror', (e) => errors.push(String(e.message || e)));
+    await page.goto(BASE + '/premium.html?theme=' + theme, { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#rank .rr', { timeout: 60000 });
+    return { ctx, page, errors };
+  };
+
+  {
+    const { ctx, page, errors } = await open();
+    const rows = await page.$$eval('#rank .rr', (els) => els.map((e) => ({ key: e.dataset.key, title: e.querySelector('.rt').textContent.replace('Do this first', ''), subject: e.querySelector('.rs').textContent, sug: e.querySelector('.sug').textContent, skip: e.querySelector('.skip').textContent })));
+    ok('S2 the first row shows the source and sender, the verb and the prepared line, and why now', rows[0] && rows[0].subject === 'Across productsMail · Anna Lee' && rows[0].sug === 'Reply: Confirm Thursday' && rows[0].skip === 'Why now: Why aaaaaaaaaaa1', JSON.stringify(rows[0]));
+    ok('S2 a row with a verb and no prepared line shows the verb alone', rows[1] && rows[1].sug === 'Sign off' && /Confluence · Budi Santoso/.test(rows[1].subject), JSON.stringify(rows[1]));
+    ok('S6 the dock counts the rows', (await page.textContent('#dN')) === '4', await page.textContent('#dN'));
+    await page.click('#rank .rr:first-child .rhd');
+    await page.waitForSelector('#srcLink');
+    const link = await page.$eval('#srcLink', (a) => ({ href: a.href, target: a.target, rel: a.rel, h: Math.round(a.getBoundingClientRect().height) }));
+    ok('S3 the dialog opens the item\'s https link in a new tab', link.href === 'https://mail.example/t/1' && link.target === '_blank' && /noopener/.test(link.rel), JSON.stringify(link));
+    ok('S3 the dialog offers nothing that records or sends', (await page.$('#recBtn')) === null && (await page.$('[data-until]')) === null && (await page.$('#dBody [data-op]')) === null);
+    ok('S11 the link is at least 44 px high', link.h >= 44, String(link.h));
+    await page.keyboard.press('Escape');
+    const chip = await page.$eval('#srcChips', (e) => e.textContent);
+    ok('S7 Today lists Digests with their count', /Digests1/.test(chip), chip);
+    await page.click('#tl .ev.src-digest');
+    await page.waitForSelector('#dBody');
+    const dtxt = await page.textContent('#dlg');
+    ok('S7 the digest dialog holds its lines and its link', /Decision: Ship on Friday/.test(dtxt) && /Open: Who owns QA/.test(dtxt) && (await page.getAttribute('#srcLink', 'href')) === 'https://slack.example/c/1', dtxt.slice(0, 200));
+    ok('no page error', errors.length === 0, errors.join(' | '));
+    await ctx.close();
+  }
+
+  {
+    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 r1 = await json('POST', '/api/briefing-premium/put-off', { key: 'src:aaaaaaaaaaa1', until: 'later' }, press);
+    ok('S9 a source row cannot be put off', r1.status === 400, JSON.stringify(r1));
+    const r2 = await json('POST', '/api/briefing-premium/decide', { key: 'src:aaaaaaaaaaa1', choice: 'extend', why: 'No.' }, press);
+    ok('S9 a source row cannot be decided', r2.status >= 400, JSON.stringify(r2));
+    const r3 = await json('POST', '/api/briefing-premium/ask', { key: 'src:aaaaaaaaaaa1', text: 'Why is this on my list?' }, press);
+    ok('S9 the read-only agent can be asked about a source row', r3.status === 200 && r3.body.ok && r3.body.state === 'working', JSON.stringify(r3));
+  }
+
+  /* S11 fidelity: the source row against the mockup's second row, the digest against the mockup's Today item */
+  if (!fs.existsSync(MOCKUP)) ok('S11 the mockup is in the repository', false, MOCKUP);
+  else {
+    const PAIRS = [['row', '#rank .rr:nth-child(2)'], ['number', '#rank .rr:nth-child(2) .rn'], ['title', '#rank .rr:nth-child(2) .rt'], ['subject', '#rank .rr:nth-child(2) .rs'], ['prepared', '#rank .rr:nth-child(2) .sug'], ['skip', '#rank .rr:nth-child(2) .skip'], ['event', '#tl .ev:not(:first-of-type)'], ['eventTime', '#tl .ev:not(:first-of-type) time'], ['eventTitle', '#tl .ev:not(:first-of-type) b']];
+    const PROPS = ['fontSize', 'fontWeight', 'fontFamily', 'color', 'backgroundColor', 'borderRadius', 'paddingTop', 'paddingLeft', 'letterSpacing', 'lineHeight', 'boxShadow', 'borderTopColor'];
+    const grab = (pg, sel) => pg.evaluate(([pairs, props]) => { const o = {}; for (const [n, s] of pairs) { const e = /^#tl/.test(s) && window.__ev ? window.__ev(s) : document.querySelector(s); if (!e) { o[n] = null; continue; } const cs = getComputedStyle(e), r = e.getBoundingClientRect(), v = { left: Math.round(r.left), width: Math.round(r.width) }; props.forEach((k) => { v[k] = cs[k]; }); o[n] = v; } return o; }, [sel, PROPS]);
+    for (const [w, h] of [[1280, 900], [390, 844]]) for (const th of ['light', 'dark']) {
+      const m = await (await browser.newContext({ viewport: { width: w, height: h } })).newPage();
+      await m.goto('file://' + MOCKUP);
+      await until(() => m.evaluate(() => document.querySelectorAll('#rank .rr').length > 1 && document.querySelectorAll('#tl .ev').length > 0));
+      await m.evaluate((t) => { document.documentElement.dataset.theme = t; }, th);
+      const R = await open({ w, h, theme: th });
+      await R.page.evaluate(() => { window.__ev = (s) => { const d = document.querySelector('#tl .ev.src-digest'); return !d ? null : / time$/.test(s) ? d.querySelector('time') : / b$/.test(s) ? d.querySelector('b') : d; }; });
+      await sleep(500);
+      const a = await grab(m, PAIRS), c = await grab(R.page, PAIRS), diffs = [];
+      for (const [n] of PAIRS) {
+        if (!a[n] || !c[n]) { diffs.push(n + ' missing'); continue; }
+        for (const k of Object.keys(a[n])) {
+          if (k === 'left' || k === 'width') { if (['row', 'number', 'title', 'subject', 'prepared', 'skip', 'event', 'eventTime', 'eventTitle'].includes(n) && (k === 'left' || n !== 'row' && n !== 'event' && n !== 'eventTime')) continue; }
+          if ((k === 'left' || k === 'width') ? Math.abs(a[n][k] - c[n][k]) > 2 : a[n][k] !== c[n][k]) diffs.push(`${n}.${k} ${a[n][k]} | ${c[n][k]}`);
+        }
+      }
+      ok(`S11 the source row and the digest look like the mockup's at ${w} px, ${th}`, diffs.length === 0, diffs.join(' ; '));
+      const ov = await R.page.evaluate(() => document.documentElement.scrollWidth - innerWidth);
+      ok(`S11 no sideways scroll at ${w} px, ${th}`, ov <= 0, String(ov));
+      await m.context().close(); await R.ctx.close();
+    }
+  }
+  return finish();
+})().catch((e) => { console.error(e); finish(1); });

package/workspace/guide/briefing-premium.md

@@ -7,10 +7,37 @@ 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.
+- **Mail, Jira and Confluence** come from today's morning brief, which a scheduled skill in an agent session writes to the state folder (the server reaches none of those services). See "Mail, Jira and Confluence" below.
+
+## Mail, Jira and Confluence
+
+The page reads today's morning brief (`briefs/<date>.json` in the state folder) and the Jira tickets assigned to you. Nothing is sent, posted or recorded from these rows.
+
+- **Rows.** The brief's mail, Jira and Confluence items become rows in "What you need to do" when you own them, when they mention you, or when they are worth asking. Slack, GitHub, Drive, Figma and website items are left out, and so are agent-owned items that do not mention you. A row shows its source and sender, then the verb and the prepared line, then why it is on the list. Only fields the item holds are shown.
+- **Tickets.** An assigned Jira ticket becomes a row when it is overdue, due today, blocked or a decision, and your Work list has not marked it done or put it aside.
+- **The tag.** A row names a product only when the item names an initiative that belongs to exactly one product you included. Every other row reads "Across products". The page never guesses a product.
+- **The order.** These rows follow the repository rows: tickets first, then the brief's items in the brief's own order. The cap of seven rows is shared, and the rest are counted as more.
+- **The dialog** opens the item's link, when it is an https address, in a new tab. It records nothing. The read-only agent can be asked about the row.
+- **Today** lists one item per digest (a watched Slack channel, Jira project or Confluence space) with the decisions, open lines and goals the brief holds, under a Digests filter that appears when the brief has digests.
+- **The header** says "no morning brief for today" when there is none, or that the brief could not be read, or that it did not reach a source (mail, Jira, Confluence or Slack).
+- **`?ws=<id>`** does not show these rows.
+
 ## 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 +45,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-agent.js

@@ -16,7 +16,7 @@ const crypto = require('crypto');
 const headless = require('./headless.js');
 
 const THREADS = 'briefing-premium-threads.jsonl';
-const KEY_RE = /^(decision|blocked|waited|ev|work|board|init|doc):[A-Za-z0-9][A-Za-z0-9._:-]{0,100}$/;
+const KEY_RE = /^(decision|blocked|waited|src|ev|work|board|init|doc):[A-Za-z0-9][A-Za-z0-9._:-]{0,100}$/;
 const MAX_Q = 2000, MAX_A = 6000, MAX_QUESTIONS = 40, PROMPT_TURNS = 8;
 const fail = (status, error) => ({ status, body: { ok: false, error } });
 const clip = (s, n) => { s = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s; };

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, sources }) {
+  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, sources });
+  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 };