create-pmos 0.253.0 → 0.255.0

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

@@ -0,0 +1,140 @@
+'use strict';
+/* lib/briefing-premium-sources.js — mail, Jira and Confluence on the premium Briefing (initiative briefing-premium-sources, S1 to S9).
+ *
+ *   build({ brief, myWork, itemLines, today, products }) → { rows, digests, state, notRead }   PURE.
+ *   readSources(ctx, now)                                → { brief, myWork, itemLines, today }   what the route reads.
+ *
+ * brief = { state: 'ok' | 'absent' | 'stale' | 'bad', brief? }: today's morning brief (lib/brief.js, <state>/briefs/<date>.json).
+ * products = (initiative id) → { ws, name } | null: the included products' initiatives. A row names a product only through it.
+ *
+ * THE RULE: a sentence, chip, name, count or link is made only from a field the brief or the ticket holds. A field it does not hold is left out.
+ * A row has no write: nothing here sends, replies, posts or records. PURE except readSources. */
+const fs = require('fs');
+const path = require('path');
+const Real = require('./briefing-real.js');
+const { localDate } = require('./brief.js');
+
+const SOURCE_WORD = { mail: 'Mail', jira: 'Jira', confluence: 'Confluence', slack: 'Slack' };
+const ROW_SOURCES = ['mail', 'jira', 'confluence'];
+const VERB_WORD = { reply: 'Reply', review: 'Review', decide: 'Decide', 'sign-off': 'Sign off', read: 'Read', do: 'Do' };
+const EFFORT_WORD = { minutes: 'minutes', 'an-hour': 'an hour', 'half-day': 'half a day', day: 'a day' };
+const ACROSS = 'Across products';
+const clip = (s, n) => { s = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s; };
+const text = (v, n) => (typeof v === 'string' && v.trim() ? clip(v, n) : '');
+const https = (v) => { const s = String(v || ''); try { return s.length <= 500 && new URL(s).protocol === 'https:' ? s : null; } catch { return null; } };
+const list = (v) => (Array.isArray(v) ? v : []);
+const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const pad = (n) => String(n).padStart(2, '0');
+const hhmm = (ms) => { const d = new Date(ms); return pad(d.getHours()) + ':' + pad(d.getMinutes()); };
+
+/** The items that become rows: a mail, Jira or Confluence item the PM owns, or that mentions the PM, or that is worth asking. */
+function rowItems(brief) {
+  const keep = (x) => x && typeof x === 'object' && x.id && text(x.title, 140) && ROW_SOURCES.includes(x.source);
+  const asks = list(brief.worth_asking).filter((x) => keep(x));
+  const mine = list(brief.priorities).filter((x) => keep(x) && (x.owner === 'pm' || x.mention === true));
+  return [...mine.map((x) => ({ x, ask: false })), ...asks.map((x) => ({ x, ask: true }))];
+}
+
+function itemRow(x, ask, brief, products) {
+  const src = SOURCE_WORD[x.source];
+  const verb = VERB_WORD[x.verb] || '';
+  const todo = text(x.todo, 200);
+  const hit = x.initiative_id && products ? products(x.initiative_id) : null;
+  const url = https(x.link);
+  const facts = [['Source', src], ['From', text(x.who, 120)], ['Where', text(x.where, 120)], ['About', text(x.about, 480)], ['Asked', text(x.ask, 240)], ['Quote', text(x.quote, 280)], ['Evidence', text(x.evidence, 240)],
+    ['Confidence', typeof x.confidence === 'number' ? Math.round(x.confidence * 100) + '%' + (ask ? ', below the bar: ask before acting' : '') : ''], ['Effort', EFFORT_WORD[x.effort] || ''],
+    ['Reply needed', typeof x.reply_needed === 'boolean' ? (x.reply_needed ? 'Yes' : 'No') : ''], ['Initiative', hit ? hit.name + ' · ' + x.initiative_id : ''], ['Due', text(x.due, 40)]].filter((f) => f[1]);
+  const why = text(x.why_now, 240);
+  return {
+    kind: 'source', key: 'src:' + x.id, title: text(x.title, 140),
+    subject: [src, text(x.who, 120), x.mention ? 'mentions you' : '', ask ? 'worth asking' : ''].filter(Boolean).join(' · '),
+    prepared: verb && todo ? verb + ': ' + todo : todo || verb || 'No prepared line is on record.',
+    skip: why ? 'Why now: ' + why : 'No reason is on record.',
+    product: hit ? hit.name : ACROSS, from: ['brief:' + x.id], detail: { source: x.source },
+    dialog: {
+      eye: src, logTitle: 'Read from the morning brief', title: text(x.title, 140), sub: [src, text(x.who, 120)].filter(Boolean).join(' · '),
+      log: ['Read the morning brief of ' + brief.date, 'Found this ' + src + ' item', hit ? 'It names the initiative ' + x.initiative_id + ' of ' + hit.name : 'It names no initiative of an included product, so it is not tied to a product'],
+      say: text(x.about, 480) || why || 'The brief holds no more on this item.',
+      head: 'The item', facts, opts: [], sel: null, nodef: '', link: url, linkLabel: 'Open in ' + src,
+      pane: { label: src, file: 'briefs/' + brief.date + '.json', h: text(x.title, 140), intro: why, rows: facts, paras: [], parasTitle: '' },
+    },
+  };
+}
+
+function ticketRow(n, today) {
+  const url = https(n.url);
+  const label = { clock: 'Due', alert: 'Blocked', reply: 'Asked', inbox: 'Status' };
+  const fact = (f) => { const t = String(f.text || ''); return [label[f.icon] || '', f.icon === 'clock' ? t.replace(/^Due /, '') : f.icon === 'inbox' ? t.split(' · ').slice(1).join(' · ') : t]; };
+  const facts = [['Source', 'Jira'], ['Ticket', n.src || ''], ...list(n.facts).map(fact)].filter((f) => f[0] && f[1]);
+  return {
+    kind: 'source', key: 'src:' + n.itemId, title: text(n.headline, 140),
+    subject: ['Jira', n.src, 'assigned to you'].filter(Boolean).join(' · '),
+    prepared: text(n.why, 200) || 'No prepared line is on record.',
+    skip: n.dueText ? cap(n.dueText) + '.' : 'No due date is on record.',
+    product: ACROSS, from: ['jira:' + n.itemId], detail: { source: 'jira' },
+    dialog: {
+      eye: 'Jira', logTitle: 'Read from your Jira tickets', title: text(n.headline, 140), sub: 'Jira · ' + (n.src || ''),
+      log: ['Read the tickets assigned to you', 'Checked your Work list for a done or put-off copy', 'Found none, so it stays'],
+      say: text(n.why, 200), head: 'The ticket', facts, opts: [], sel: null, nodef: '', link: url, linkLabel: 'Open ' + (n.src || 'the ticket') + ' in Jira',
+      pane: { label: 'Jira', file: 'Jira · assigned to you', h: text(n.headline, 140), intro: text(n.why, 200), rows: facts, paras: [], parasTitle: '' },
+    },
+  };
+}
+
+function digestItem(d, brief) {
+  const at = Date.parse(brief.generated_at);
+  if (!Number.isFinite(at) || !SOURCE_WORD[d.source] || !text(d.name, 120)) return null;
+  const dec = list(d.decisions).filter((s) => text(s, 140)), open = list(d.open).filter((s) => text(s, 140)), goals = list(d.goals).filter((s) => text(s, 140));
+  const src = SOURCE_WORD[d.source];
+  const sub = [dec.length ? dec.length + (dec.length === 1 ? ' decision' : ' decisions') : '', open.length ? open.length + ' open' : '', goals.length ? goals.length + (goals.length === 1 ? ' goal' : ' goals') : ''].filter(Boolean).join(' · ') || 'No lines on record';
+  const facts = [['Source', src], ['Name', text(d.name, 120)], ['Decisions', String(dec.length)], ['Open', String(open.length)], ['Goals', goals.length ? String(goals.length) : '']].filter((f) => f[1]);
+  return {
+    at, t: hhmm(at), kind: 'digest', title: src + ' · ' + text(d.name, 120), sub, src: 'Digests',
+    dialog: {
+      eye: 'Digest', logTitle: 'Read from the morning brief', title: src + ' · ' + text(d.name, 120), sub: sub,
+      log: ['Read the morning brief of ' + brief.date, 'Found the ' + src + ' digest of ' + text(d.name, 120)],
+      say: 'This is what the brief holds for ' + text(d.name, 120) + '. It is a summary, not a copy of the source.',
+      head: 'The digest', facts, opts: [], sel: null, nodef: '', link: https(d.link), linkLabel: 'Open in ' + src,
+      pane: { label: 'Digest', file: 'briefs/' + brief.date + '.json', h: src + ' · ' + text(d.name, 120), intro: '', rows: facts, parasTitle: 'What the digest holds',
+        paras: [...dec.map((s) => 'Decision: ' + text(s, 140)), ...open.map((s) => 'Open: ' + text(s, 140)), ...goals.map((s) => 'Goal: ' + text(s, 140))] },
+    },
+  };
+}
+
+/** The sources the brief says it did not read, named for the header: only the four that rows and digests come from. */
+function notReadOf(brief) {
+  const st = brief.sources && typeof brief.sources === 'object' ? brief.sources : {};
+  return ['mail', 'jira', 'confluence', 'slack'].filter((k) => st[k] === 'not-reached' || st[k] === 'off')
+    .map((k) => SOURCE_WORD[k].toLowerCase() + (st[k] === 'off' ? ' (switched off)' : ' (the brief says it was not reached)'));
+}
+
+function build({ brief, myWork, itemLines, today, products } = {}) {
+  const out = { rows: [], digests: [], state: 'absent', notRead: [], from: [] };
+  const b = brief && brief.state === 'ok' && brief.brief && brief.brief.date === today ? brief.brief : null;
+  out.state = b ? 'ok' : brief && brief.state === 'ok' ? 'stale' : (brief && brief.state) || 'absent';
+  const tickets = (Real.build({ brief: null, myWork, itemLines, today }).needs || []).filter((n) => n.origin === 'jira' && n.itemId)
+    .sort((a, c) => a._rank - c._rank || (c._late || 0) - (a._late || 0));
+  out.rows.push(...tickets.map((n) => ticketRow(n, today)));
+  if (b) {
+    out.rows.push(...rowItems(b).map(({ x, ask }) => itemRow(x, ask, b, products)));
+    out.digests = list(b.digests).map((d) => digestItem(d, b)).filter(Boolean);
+    out.notRead = notReadOf(b);
+  }
+  return out;
+}
+
+/** What the route reads each request. A source that fails gives nothing. */
+async function readSources(ctx, now) {
+  const today = localDate(now);
+  const dir = ctx && ctx.runtimeDir;
+  const out = { brief: { state: 'absent' }, myWork: [], itemLines: [], today };
+  if (!dir) return out;
+  let raw = null;
+  try { raw = fs.readFileSync(path.join(dir, 'briefs', today + '.json'), 'utf8'); } catch { /* no brief for today */ }
+  if (raw !== null) { try { const j = JSON.parse(raw); out.brief = j && typeof j === 'object' && !Array.isArray(j) ? { state: 'ok', brief: j } : { state: 'bad' }; } catch { out.brief = { state: 'bad' }; } }
+  const real = await Real.readSources(ctx, new Date(now), today).catch(() => null);
+  if (real) { out.myWork = real.myWork; out.itemLines = real.itemLines; }
+  return out;
+}
+
+module.exports = { build, readSources, ACROSS, SOURCE_WORD };

package/workspace/lib/briefing-premium.js

@@ -21,6 +21,7 @@ const fs = require('fs');
 const path = require('path');
 const { execFile } = require('child_process');
 const W = require('./briefing-premium-writes.js');
+const Src = require('./briefing-premium-sources.js');
 
 const DAY = 86400000;
 const MAX_ROWS = 7;
@@ -35,6 +36,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 +77,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 +210,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 +256,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 +299,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,13 +327,14 @@ 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)) }); }
+  for (const d of f.digests || []) items.push(d);
   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.' };
+  return { ahead, earlier, now: { t: hhmm(f.asOf), label: 'snapshot' }, counts: { meeting: count('meeting'), merge: count('merge'), run: count('run'), digest: count('digest') }, note: ahead.length + earlier.length ? null : 'Nothing is recorded for today yet.' };
 }
 
 /* ── the model ────────────────────────────────────────────────────────────────────────────────────────────── */
@@ -348,6 +362,64 @@ 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));
+  // mail, Jira and Confluence (initiative briefing-premium-sources): their rows follow the repositories' rows, and a row names a product only when exactly one included product holds its initiative
+  const owner = new Map();
+  for (const p of read) for (const i of p.f.initiatives) owner.set(i.id, owner.has(i.id) ? null : { ws: p.product.ws, name: p.product.name });
+  const sx = g.sources ? Src.build(Object.assign({}, g.sources, { products: (id) => owner.get(id) || null })) : null;
+  const { rows, more } = cut(every.concat(sx ? sx.rows : []), 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))),
+    digests: sx ? sx.digests : [],
+  };
+  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);
+  const srcRows = rows.filter((r) => r.kind === 'source'), srcSeen = [...new Set(srcRows.map((r) => r.detail.source))];
+  if (srcRows.length) hero.push({ parts: [{ t: num(srcRows.length) + ' ' + plural(srcRows.length, 'item', 'items') + ' from ' + joinNames(srcSeen.map((k) => Src.SOURCE_WORD[k])), s: true }, { t: ' ' + plural(srcRows.length, 'needs', 'need') + ' you.', s: false }], from: srcRows.map((r) => r.from[0]) });
+  const sxNote = !sx ? '' : sx.state === 'ok' ? (sx.notRead.length ? ' · not read by the morning brief: ' + sx.notRead.join(', ') : '') : sx.state === 'bad' ? ' · the morning brief could not be read' : ' · no morning brief for today';
+  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(', ') : '') + sxNote + (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 +478,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 +505,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 +588,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,24 @@ 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 Src = require('./briefing-premium-sources.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 +55,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 || /^src:/.test(String(b.key || '')) ? 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 +98,14 @@ 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 sources = await Src.readSources(ctx, Date.now()).catch(() => null);
+      const r = await Prod.modelOfMany({ available: sel.available, engine: enginePath(), runtimeDir: ctx.runtimeDir, sources });
+      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.255.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.253.0",
+      "version": "0.255.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.255.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

@@ -151,6 +151,7 @@ input[type=range]:active::-webkit-slider-thumb{transform:scale(1.15)}
 .dbody .kv{display:grid;grid-template-columns:110px minmax(0,1fr);gap:6px 14px;font-size:15px}
 .dbody .kv span:nth-child(odd){color:var(--ink-3)}
 .cta{height:48px;padding:0 24px;border-radius:var(--r-chip);background:var(--solid);color:var(--on-solid);font-weight:650;display:inline-flex;align-items:center;gap:8px;transition:transform .35s var(--spring)}
+a.cta{text-decoration:none}
 .cta:hover{transform:translateY(-2px)}
 .cta:active{transform:scale(.97)}
 .cta svg{width:18px;height:18px}
@@ -1196,3 +1197,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}