create-pmos 0.252.0 → 0.254.0

package/workspace/lib/initiative-premium.js

@@ -0,0 +1,147 @@
+'use strict';
+/* lib/initiative-premium.js — the premium initiative page's model, built from what the production Initiatives sheet reads (initiative briefing-premium-initiative).
+ *
+ *   build(facts)     → model   PURE. facts = { now, board, boards, row, sheet, docs, items, missing[], pending }
+ *   peekModel()      → the last model built, for the agent to find the initiative in (null before the first)
+ *
+ * facts come from the routes of lib/routes-boards.js, lib/routes-initiatives.js and lib/routes-core-docs.js:
+ *   row     GET /api/boards/initiative → .row { id, title, lane, stage, cat, owner, anchor, horizon, status, start, end, progress, warnings, updated, stageSource, workflow }
+ *   sheet   GET /api/initiatives/<id> → { initiative: { health, progress, display }, stepper: [{ id, label, state, owed }], waiting, files, derived }
+ *   docs    GET /api/core-docs?level=initiative → { summary, docs: [{ key, title, for, by, kind, st, when, open: { path }, act, running }] }
+ *   ladder  the workflow engine's ladder for this initiative (console-state.ladder → row): { steps: [{ key, status, evidence, rule }], next: { step, why, action } }
+ *   boards  [{ ws, id, name }] and siblings [{ id, title }]: the switchers of the crumb
+ *   items   GET /api/boards/items → .items [{ key, kind, src, title, status, blocked, owner, ini, start, end }] for the board; only this initiative's are used
+ *
+ * THE RULE THE FILE FOLLOWS (as the other premium models): a figure, chip, bar or date is made only from a field of a record. An owner or a finish date no
+ * record holds is not drawn. The repository records no result for each PRD requirement, so a requirement is drawn with no state of its own and the
+ * initiative's progress is said once. The mockup's description line, its "PMOS can help" suggestions and its demo tasks have no record and are not built. */
+
+const pad = (n) => String(n).padStart(2, '0');
+const hhmm = (ms) => { const d = new Date(ms); return pad(d.getHours()) + ':' + pad(d.getMinutes()); };
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const isoDay = (v) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(v || '')); return m ? new Date(+m[1], +m[2] - 1, +m[3]) : null; };
+const shortDate = (v) => { const d = isoDay(v); return d ? d.getDate() + ' ' + MON[d.getMonth()] : ''; };
+const plural = (n, one, many) => (n === 1 ? one : many);
+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 cap1 = (s) => (s ? String(s).charAt(0).toUpperCase() + String(s).slice(1) : '');
+const STATUS_LABEL = { 'on track': 'On track', 'at risk': 'At risk', late: 'Late', 'on hold': 'On hold', done: 'Done', cancelled: 'Cancelled' };
+const DOC_STATE = { missing: 'Not started', draft: 'Draft', ok: 'Up to date', stale: 'Stale', due: 'Due' };
+const BY = { drafts: 'PMOS drafts it', proposes: 'PMOS proposes', reviews: 'PMOS reviews', you: 'You write it', live: 'Live view' };
+const STEP_STATE = { done: 'Done', current: 'In progress', todo: 'To do', skipped: 'Skipped', blocked: 'Blocked' };
+const LAD_STATE = { done: 'Done', blocked: 'Blocked', pending: 'Waiting', unknown: 'Unknown', na: 'Not needed', 'no-signal': 'No signal', skipped: 'Skipped' };
+const CHECK_KEYS = /^(spec|contract|build|quality|review|accept)$/;
+const PHASE_OF_CAT = { Discover: 0, Plan: 1, Do: 2, Learn: 3 };
+const DOC_CAT_ORDER = ['Discover', 'Plan', 'Build', 'Evaluate'];
+const TECH = new Set(['record', 'rubric', 'stories', 'review', 'explainer']);   // the engineering side, as the mockup groups it
+const MAX_TASKS = 60;
+
+let last = null;
+const peekModel = () => last;
+
+function build(f) {
+  const now = f.now || Date.now();
+  const row = f.row || {}, sheet = f.sheet || null, ini = (sheet && sheet.initiative) || {}, board = f.board || {};
+  const missing = (f.missing || []).slice();
+  if (!f.ladder && !missing.includes('workflow steps')) missing.push('workflow steps');
+  const wf = (row.workflow && row.workflow.length ? row.workflow : board.workflow) || [];
+  const names = wf.map((s) => s.name), cur = names.indexOf(row.stage);
+  const id = row.id || '';
+  const key = 'init:' + id;
+
+  // ── header ──
+  const status = row.status || null, bad = status === 'late' || status === 'at risk';
+  const head = {
+    statusLabel: status ? (STATUS_LABEL[status] || cap1(status)) : null, tone: status === 'on track' || status === 'done' ? 'ok' : bad ? (status === 'late' ? 'bad' : 'warn') : 'mut',
+    meta: [board.name || '', row.owner || '', row.end ? 'planned finish ' + shortDate(row.end) : ''].filter(Boolean),
+    stage: row.stage || null, stageNote: row.stageSource === 'derived' ? 'derived by the workflow engine' : null,
+    strip: { names, seg: names.map((n, j) => (j < cur ? 'p' : j === cur ? 'n' : '')), cur: cur >= 0 ? cur : null },
+  };
+
+  // ── overview: the workflow engine's next step when it has one, else the sheet's waiting record ──
+  const w = sheet && sheet.waiting, disp = ini.display || {};
+  const lad = f.ladder || null, nx = lad && lad.next && lad.next.step ? lad.next : null;
+  const WHO = { agent: 'Agents can do it', pm: 'Waits on you', you: 'Waits on you', human: 'Waits on you' };
+  let overview;
+  if (nx) overview = { who: /^(review|accept|contract)$/.test(nx.step) ? 'Waits on you' : 'Agents can do it', h: 'Next: ' + nx.step, p: cap1(String(nx.why || '')).replace(/\.?$/, '.'), more: nx.action ? cap1(String(nx.action)).replace(/\.?$/, '.') : '', skip: 'it stays at ' + nx.step + '.', tone: bad ? 'warn' : '' };
+  else if (!sheet) overview = { missing: true, why: 'The initiative sheet could not be read, so the next step is not shown.' };
+  else if (w) overview = { who: WHO[w.on] || (w.on ? 'Waits on ' + w.on : ''), h: (w.act ? cap1(w.act) : 'Next step'), p: [w.action && w.action.label ? w.action.label : '', disp.line2 || ''].filter(Boolean).join('. '), tone: bad ? 'warn' : '' };
+  else overview = { none: true, why: 'Nothing is waiting on a person or an agent for this initiative.' };
+  const health = ini.health && Array.isArray(ini.health.reasons) ? ini.health.reasons.filter(Boolean).map((r) => clip(typeof r === 'string' ? r : (r && (r.text || r.reason || r.id)) || '', 200)).filter(Boolean) : [];
+  const warnings = (row.warnings || []).map((x) => clip(typeof x === 'string' ? x : x && (x.text || x.message || x.id) || '', 200)).filter(Boolean);
+  // the title is "short name — what it is for": the crumb shows the first part, the description the rest (the mockup's own rule); a title with no dash is shown whole and has no description
+  const full = String(row.title || id), dash = full.indexOf(' — ');
+  const crumbTitle = clip(dash > 0 ? full.slice(0, dash) : full, 70);
+  const desc = dash > 0 && full.slice(dash + 3).trim() ? clip(cap1(full.slice(dash + 3).trim()), 240) : '';
+
+  // ── checks: the engine's ladder with its evidence; the sheet's stepper when the engine did not answer ──
+  const steps = lad && Array.isArray(lad.steps) ? lad.steps : null;
+  const checks = steps
+    ? steps.filter((s) => CHECK_KEYS.test(s.key)).map((s) => ({ k: s.key, label: s.label || s.key, state: s.status, stateLabel: LAD_STATE[s.status] || cap1(s.status), owed: clip(s.evidence || s.rule || '', 220), cur: !!nx && nx.step === s.key }))
+    : ((sheet && sheet.stepper) || []).map((s) => ({ k: s.id, label: s.label || s.id, state: s.state === 'todo' ? 'pending' : s.state, stateLabel: STEP_STATE[s.state] || cap1(s.state), owed: s.owed ? clip(typeof s.owed === 'string' ? s.owed : s.owed.text || s.owed.what || '', 160) : '', cur: s.state === 'current' }));
+  const allSteps = steps ? steps.map((s) => ({ label: s.label || s.key, stateLabel: LAD_STATE[s.status] || cap1(s.status), note: clip(s.evidence || (s.basis && s.basis.rule) || s.rule || '', 220) })) : [];
+
+  // ── tasks: PRD requirements (no result per requirement) and the board's tracker items ──
+  const items = (f.items || []).filter((t) => t && t.ini === id).slice(0, MAX_TASKS);
+  const tracker = items.map((t, n) => ({ key: 'task:' + (t.uid || t.key || n), uid: t.uid || '', pmos: t.src === 'pmos', ref: t.key || t.ref || '', title: clip(t.title, 160), state: t.status || 'To do', src: t.src === 'jira' ? 'Jira (read-only)' : 'PMOS task', owner: t.owner || '', start: t.start || '', end: t.end || '', blocked: !!t.blocked, kind: t.kind || 'Task' }));
+  const dv = sheet && sheet.derived;
+  const reqs = dv && Array.isArray(dv.items) ? dv.items.slice(0, MAX_TASKS).map((x) => ({ key: 'req:' + x.id, ref: x.ref || x.id, title: clip(x.title, 160), state: null, src: 'PRD requirement' })) : [];
+  const prog = ini.progress || null;
+  const trackerDone = tracker.filter((t) => t.state === 'Done').length, trackerWip = tracker.filter((t) => t.state === 'In progress' || t.state === 'In review').length;
+  const dated = tracker.filter((t) => t.start && t.end);
+  const tasks = {
+    rows: tracker.concat(reqs), tracker: tracker.length, reqs: reqs.length,
+    cap: [reqs.length ? reqs.length + ' PRD ' + plural(reqs.length, 'requirement', 'requirements') : '', tracker.length ? tracker.length + ' from the board' : '', 'no tracker link'].filter(Boolean).join(' · '),
+    bar: tracker.length ? { done: trackerDone, wip: trackerWip, todo: tracker.length - trackerDone - trackerWip } : null,
+    basis: dv ? { source: dv.source || '', text: dv.basis || '', state: dv.state || '' } : null,
+    progress: prog && prog.total ? { done: prog.done, total: prog.total, label: prog.label || '' } : null,
+    byStatus: tracker.length > 0, timeline: dated.length > 0,
+    note: reqs.length ? 'The PRD lists these requirements. The repository records no result for each one, so none is drawn as done or open.' : tracker.length ? '' : 'This initiative has no PRD requirement list and no tracker item on its board.',
+  };
+
+  // ── documents ──
+  const dd = f.docs || null;
+  const all = dd ? (dd.docs || []).map((d) => ({
+    key: d.key, title: d.title, what: d.for || '', st: d.st, state: d.kind === 'live' ? 'Live' : DOC_STATE[d.st] || d.st || '', by: BY[d.by] || d.by || '', byKey: d.by || '',
+    when: d.when ? shortDate(d.when) : '', cat: d.cat === 'Do' ? 'Build' : d.cat === 'Learn' ? 'Evaluate' : d.cat || 'Board', path: d.open && d.open.path ? d.open.path : null, running: !!d.running, tech: TECH.has(d.key),
+    act: d.act && d.act.do === 'draft' ? { kind: 'draft', label: d.running ? 'Drafting' : d.act.label || 'Draft it' } : null,
+  })) : [];
+  const core = all.filter((d) => !d.tech);
+  const cnt = { all: core.length, none: core.filter((d) => d.st === 'missing').length, draft: core.filter((d) => d.st === 'draft').length, ok: core.filter((d) => d.st === 'ok' || d.st === 'live').length };
+  const docs = dd ? { rows: all, counts: cnt, techCount: all.length - core.length,
+    cap: core.length ? [cnt.draft ? cnt.draft + ' ' + plural(cnt.draft, 'draft', 'drafts') + ' to review' : '', cnt.none ? cnt.none + ' not started' : '', cnt.ok ? cnt.ok + ' up to date' : ''].filter(Boolean).join(' · ') : '',
+    scope: dd.scope || 'initiative:' + id } : { rows: [], counts: { all: 0, none: 0, draft: 0, ok: 0 }, techCount: 0, cap: '', missing: true };
+  if (!dd && !missing.includes('core documents')) missing.push('core documents');
+
+  // ── PMOS can help: only things a press can really do. A draft of a core document the initiative has not started (the existing read-only draft run), and a question for the read-only agent ──
+  const phase = Math.max(0, PHASE_OF_CAT[row.cat] != null ? PHASE_OF_CAT[row.cat] : Math.max(0, cur >= 0 && names.length ? Math.floor(cur / Math.max(1, names.length) * 4) : 0));
+  const help = [];
+  const nd = docs.rows.find((d) => d.st === 'missing' && !d.tech && d.act && d.act.kind === 'draft' && DOC_CAT_ORDER.indexOf(d.cat) <= phase);
+  if (nd) help.push({ label: 'Draft the ' + nd.title.toLowerCase(), kind: 'draft', key: nd.key });
+  const wantsOptions = bad || (lad && lad.next && /^(review|accept)$/.test(lad.next.step));
+  if (wantsOptions) help.push({ label: lad ? 'Summarise the review findings' : 'Lay out the options', kind: 'ask', q: lad ? 'Summarise the review findings for this initiative, from the evidence you can read in this repository. Say what you could not find.' : 'Lay out the options for this initiative, from what you can read in this repository, and say what you could not find. Do not recommend one unless the records do.' });
+  const upd = docs.rows.find((d) => d.key === 'status' && d.st === 'missing' && d.act && d.act.kind === 'draft');
+  if (phase === 2 && upd && !help.some((h) => h.key === 'status')) help.push({ label: 'Write the status update', kind: 'draft', key: upd.key });
+  const out = docs.rows.find((d) => d.key === 'outcome' && d.st === 'missing' && d.act && d.act.kind === 'draft');
+  if (phase === 3 && out && !help.some((h) => h.key === 'outcome')) help.push({ label: 'Draft the outcome review', kind: 'draft', key: out.key });
+
+  const files = ((sheet && sheet.files) || []).filter((x) => x && x.path).slice(0, 12).map((x) => ({ label: x.label || x.kind, path: x.path }));
+  const say = (row.title || id) + ' is ' + (status ? STATUS_LABEL[status] ? STATUS_LABEL[status].toLowerCase() : status : 'without a status') + (row.stage ? ', in the ' + row.stage + ' stage' : '') + '.'
+    + (row.stageSource === 'derived' ? ' The stage comes from the workflow engine, not from a person.' : '');
+  const facts = [['Lane', row.lane], ['Stage', row.stage], ['Anchor', row.anchor], ['Horizon', row.horizon], ['Status', head.statusLabel], ['Owner', row.owner], ['Planned finish', row.end ? shortDate(row.end) : ''], ['Progress', prog && prog.total ? prog.done + ' of ' + prog.total : '']].filter((x) => x[1]);
+
+  const model = {
+    pending: !!f.pending,
+    header: { text: 'Real data · as of ' + hhmm(now) + (missing.length ? ' · not read: ' + missing.join(', ') : ''), missing },
+    board: { name: board.name || '', id: board.id || null, ws: board.ws || null },
+    id, key, title: clip(row.title || id, 160), lane: row.lane || '', anchor: row.anchor || '',
+    head, overview, health, warnings, checks, allSteps, tasks, docs, files, desc, crumbTitle, help,
+    boards: f.boards || [], siblings: (f.siblings || []).slice(0, 100),
+    dock: { label: head.statusLabel || 'No status', stage: row.stage || '', next: String(overview.h || '').replace(/^Next: /, '') },
+    rows: [{ key, id, title: clip(row.title || id, 160), sub: [board.name, row.lane].filter(Boolean).join(' · '), dialog: { say, facts } }]
+      .concat(docs.rows.filter((d) => d.path).map((d) => ({ key: 'doc:' + id + ':' + d.key, id, title: d.title, sub: d.path, dialog: { say: d.title + ' is ' + (d.state || 'not started').toLowerCase() + '.', facts: [['File', d.path], ['State', d.state], ['Who writes it', d.by]].filter((x) => x[1]), files: [d.path] } }))),
+  };
+  last = model;
+  return model;
+}
+
+module.exports = { build, peekModel };

package/workspace/lib/my-work-premium.js

@@ -0,0 +1,151 @@
+'use strict';
+/* lib/my-work-premium.js — the premium My work page's model, built from the list the Work page reads (initiative briefing-premium-work).
+ *
+ *   build({ v, now })        → model   PURE. v is GET /api/pm-items' answer: { today, work: { inbox, today, upcoming, waiting, someday }, review, review_days }.
+ *   peekModel()              → the last model built, for the agent to find a row in (null before the first)
+ *
+ * THE RULE THE FILE FOLLOWS (as lib/briefing-premium.js): a sentence, a count or a chip is made only from a field of an item. A clause with no
+ * record is left out. The hero, the card headers and the dock read ONE definition of "to clear": inbox + today + agent drafts to review (M9).
+ * The tray is the PM's own unsorted captures: an item the PM added (source local) that no date or flag has placed yet, so it waits in the inbox
+ * placement. It is not counted as work to clear until the PM places it. The shelf, the capacity figure and the week bars of the mockup have no record
+ * behind them and are not built (PRD D15, amended by the PM 2026-10-17 to add the tray).
+ * An agent draft is the agent's text: it is shown labelled and is never counted as done. */
+
+const WORDS = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve'];
+const num = (n) => (n >= 0 && n <= 12 ? WORDS[n] : String(n));
+const plural = (n, one, many) => (n === 1 ? one : many);
+const pad = (n) => String(n).padStart(2, '0');
+const hhmm = (ms) => { const d = new Date(ms); return pad(d.getHours()) + ':' + pad(d.getMinutes()); };
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const MON = MONTHS.map((m) => m.slice(0, 3));
+const dateLine = (ms) => { const d = new Date(ms); return WEEKDAYS[d.getDay()] + ' ' + d.getDate() + ' ' + MONTHS[d.getMonth()]; };
+const isoDay = (iso) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(iso || '')); return m ? new Date(+m[1], +m[2] - 1, +m[3]) : null; };
+const shortDate = (iso) => { const d = isoDay(iso); return d ? d.getDate() + ' ' + MON[d.getMonth()] : ''; };
+const daysBetween = (fromIso, toIso) => { const a = isoDay(fromIso), b = isoDay(toIso); return a && b ? Math.round((b - a) / 86400000) : null; };
+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 MAX_PER = 8;
+const SECTIONS = [['inbox', 'Inbox'], ['today', 'Today'], ['upcoming', 'Upcoming'], ['someday', 'Someday']];
+const RUNNING = ['queued', 'working', 'sending'];
+const HOLD = { agent: 'Starting, approving or revising an agent draft from here is not built yet. It can write or post, so it needs its own decision.' };
+
+let last = null;
+const peekModel = () => last;
+
+function srcLabel(it) {
+  const s = String(it.source || 'local');
+  if (s === 'local') return 'Yours';
+  if (s === 'jira') return 'Jira';
+  if (s === 'wbs') return 'Board';
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+const isLocal = (it) => !it.source || it.source === 'local';
+const agentOf = (it) => (it && it.agent && it.agent.state) || null;
+const isReady = (it) => agentOf(it) === 'ready';
+const isRunning = (it) => RUNNING.includes(agentOf(it));
+
+function dueChip(it, today) {
+  if (!it.due) return { chip: null, overdue: false };
+  const d = daysBetween(today, it.due);
+  if (d == null) return { chip: null, overdue: false };
+  if (d < 0) return { chip: 'Overdue · ' + shortDate(it.due), overdue: true };
+  if (d === 0) return { chip: 'Today', overdue: false };
+  return { chip: shortDate(it.due), overdue: false };
+}
+
+function rowOf(it, list, v, inReview) {
+  const today = v.today, { chip, overdue } = dueChip(it, today);
+  const sub = [srcLabel(it), it.priority, it.waiting_on ? 'waiting on ' + it.waiting_on : null].filter(Boolean).join(' · ');
+  const days = it.waiting_since ? daysBetween(String(it.waiting_since).slice(0, 10), today) : null;
+  const facts = [
+    ['From', srcLabel(it)], ['Place', list === 'upcoming' ? 'Upcoming' : list.charAt(0).toUpperCase() + list.slice(1)], ['Due', it.due ? shortDate(it.due) + (overdue ? ' (overdue)' : '') : ''],
+    ['Priority', it.priority], ['Waiting on', it.waiting_on], ['Waiting since', it.waiting_since ? shortDate(String(it.waiting_since).slice(0, 10)) + (days != null ? ' (' + days + ' ' + plural(days, 'day', 'days') + ')' : '') : ''],
+    ['Not before', it.defer && it.defer > today ? shortDate(it.defer) : ''], ['Added', it.created_at ? shortDate(String(it.created_at).slice(0, 10)) : ''], ['Last touched', it.touched_at ? shortDate(String(it.touched_at).slice(0, 10)) : ''],
+  ].filter((x) => x[1]);
+  const draft = it.agent && it.agent.draft && (it.agent.draft.body || it.agent.draft.summary);
+  const actions = ['done', 'notyet'];
+  if (list !== 'today') actions.push('flag');
+  if (list !== 'someday') actions.push('park');
+  if (list !== 'waiting') actions.push('waiting');
+  actions.push('remove');
+  if (inReview) actions.push('keep');
+  const say = overdue ? 'This was due ' + shortDate(it.due) + ' and is still open.' : list === 'tray' ? 'You threw this in. It has no date or place yet. Place it, or drop it.' : list === 'inbox' ? 'This is new and has no date or place yet.' : list === 'waiting' ? 'You are waiting on ' + (it.waiting_on || 'someone') + (days != null ? ' for ' + days + ' ' + plural(days, 'day', 'days') : '') + '.' : 'This is on your list.';
+  return {
+    key: 'work:' + it.id, id: it.id, list, title: clip(it.title, 140), sub, chip, overdue, src: srcLabel(it),
+    agent: agentOf(it) && agentOf(it) !== 'suggest' ? agentOf(it) : null,
+    dialog: {
+      eye: 'Your item', logTitle: 'Read from your list',
+      log: ['Read the item (' + srcLabel(it) + ')', 'Placed it from its date, its flag and who it waits on: ' + list, inReview ? 'Found it untouched for ' + v.review_days + ' days' : 'Checked it against the seven-day review'],
+      say, head: 'Where it stands', facts,
+      write: { kind: 'work', id: it.id, actions },
+      hold: HOLD.agent,
+      pane: { label: 'Item record', file: 'pm-items · ' + it.id, h: clip(it.title, 120), intro: sub, rows: facts, paras: draft ? [clip(draft, 1500)] : [], parasTitle: draft ? 'Agent draft, not checked' : '' },
+    },
+  };
+}
+
+function build({ v, now }) {
+  now = now || Date.now();
+  v = v || {};
+  const today = v.today || new Date(now).toISOString().slice(0, 10);
+  v = Object.assign({ work: {}, review: [], review_days: 7 }, v, { today });
+  const work = Object.assign({ inbox: [], today: [], upcoming: [], waiting: [], someday: [] }, v.work);
+  const reviewIds = new Set((v.review || []).map((x) => x.id));
+  const tray = (work.inbox || []).filter(isLocal), arrivals = (work.inbox || []).filter((i) => !isLocal(i));
+  work.inbox = arrivals;
+  const all = [];
+  for (const [k] of SECTIONS.concat([['waiting', 'Waiting']])) for (const it of work[k] || []) all.push({ it, list: k });
+  for (const it of tray) all.push({ it, list: 'tray' });
+  const ready = all.filter((x) => isReady(x.it)), running = all.filter((x) => isRunning(x.it)), failed = all.filter((x) => agentOf(x.it) === 'failed');
+  const overdue = all.filter((x) => x.list !== 'waiting' && x.list !== 'someday' && x.it.due && x.it.due < today);
+  const dueToday = work.today.filter((it) => it.due === today);
+  const waitDays = (work.waiting || []).map((it) => (it.waiting_since ? daysBetween(String(it.waiting_since).slice(0, 10), today) : null)).filter((d) => d != null && d >= 0);
+  const longest = waitDays.length ? Math.max(...waitDays) : null;
+  const clear = work.inbox.length + work.today.length + ready.length;
+
+  const hero = [];
+  const cap1 = (parts) => [Object.assign({}, parts[0], { t: parts[0].t.charAt(0).toUpperCase() + parts[0].t.slice(1) })].concat(parts.slice(1));
+  const add = (parts, from) => hero.push({ parts: cap1(parts), from });
+  const first = [];
+  if (work.inbox.length) first.push({ t: num(work.inbox.length), s: true }, { t: ' new in your inbox' });
+  const bits = [];
+  if (overdue.length) bits.push([{ t: num(overdue.length), s: true }, { t: ' overdue' }]);
+  if (dueToday.length) bits.push([{ t: num(dueToday.length), s: true }, { t: ' due today' }]);
+  const line1 = [];
+  if (first.length) line1.push(...first);
+  for (const b of bits) { if (line1.length) line1.push({ t: ', ' }); line1.push(...b); }
+  if (line1.length) { line1.push({ t: '.' }); add(line1, [].concat(work.inbox.map((i) => i.id), overdue.map((x) => x.it.id), dueToday.map((i) => i.id))); }
+  if (tray.length) add([{ t: num(tray.length), s: true }, { t: ' ' + plural(tray.length, 'thing you threw in waits', 'things you threw in wait') + ' in your tray.' }], tray.map((i) => i.id));
+  if ((work.waiting || []).length) add([{ t: num(work.waiting.length), s: true }, { t: ' ' + plural(work.waiting.length, 'person owes', 'people owe') + ' you something' + (longest != null ? ', the longest for ' : '.') }].concat(longest != null ? [{ t: longest + ' ' + plural(longest, 'day', 'days'), s: true }, { t: '.' }] : []), work.waiting.map((i) => i.id));
+  if (ready.length) add([{ t: num(ready.length), s: true }, { t: ' agent ' + plural(ready.length, 'draft needs', 'drafts need') + ' your review.' }], ready.map((x) => x.it.id));
+  if ((v.review || []).length) add([{ t: num(v.review.length), s: true }, { t: ' ' + plural(v.review.length, 'item has', 'items have') + ' sat untouched for ' + v.review_days + ' days.' }], v.review.map((i) => i.id));
+  const empty = !hero.length;
+  if (empty) add([{ t: all.length ? 'Nothing is late and nothing is new. ' + num(all.length).replace(/^./, (c) => c.toUpperCase()) + ' ' + plural(all.length, 'item is', 'items are') + ' on your list.' : 'Your list is empty.', s: false }], []);
+
+  const sections = SECTIONS.map(([k, label]) => {
+    const items = work[k] || [];
+    return { key: k, label, n: items.length, more: Math.max(0, items.length - MAX_PER), rows: items.slice(0, MAX_PER).map((it) => rowOf(it, k, v, reviewIds.has(it.id))) };
+  });
+  const waitingRows = (work.waiting || []).slice(0, MAX_PER).map((it) => rowOf(it, 'waiting', v, reviewIds.has(it.id)));
+  const agentRows = ready.concat(running, failed.filter((x) => !ready.includes(x))).slice(0, MAX_PER).map((x) => rowOf(x.it, x.list, v, reviewIds.has(x.it.id)));
+  const trayRows = tray.slice(0, MAX_PER).map((it) => rowOf(it, 'tray', v, reviewIds.has(it.id)));
+  const rowsAll = [].concat(...sections.map((s) => s.rows), waitingRows, agentRows, trayRows);
+  const firstToday = sections[1].rows[0];
+  const model = {
+    date: dateLine(now), pending: false,
+    header: { text: 'Real data · as of ' + hhmm(now) + ' · Jira and Slack appear only when an agent session has read them', missing: [] },
+    hero, empty,
+    capture: { placeholder: 'Add anything: "Reply to Rina about SSO by Friday"', hint: 'One line. The date and priority are read from it.' },
+    plate: { title: 'On your plate', cap: clear + ' to clear', n: clear, sections, note: 'Each item comes from your list. A date shows only when one was set. Nothing changes in Jira or Slack from here.' },
+    tray: { title: 'Your tray', cap: tray.length ? tray.length + ' to place' : 'empty', n: tray.length, more: Math.max(0, tray.length - MAX_PER), rows: trayRows, note: 'Anything you add lands here first. Open one to place it: Today, Later, waiting on someone, or drop it. Nothing here counts as work to clear until you place it.' },
+    agents: { title: 'With agents', cap: ready.length ? num(ready.length) + ' to review' : running.length ? num(running.length) + ' running' : 'nothing running', counts: { running: running.length, ready: ready.length, failed: failed.length }, rows: agentRows, hold: HOLD.agent },
+    waiting: { title: 'Waiting on others', cap: longest != null ? 'longest ' + longest + ' ' + plural(longest, 'day', 'days') : (work.waiting || []).length ? num(work.waiting.length) + ' waiting' : '', n: (work.waiting || []).length, more: Math.max(0, (work.waiting || []).length - MAX_PER), rows: waitingRows },
+    review: { n: (v.review || []).length, days: v.review_days, ids: (v.review || []).map((i) => i.id) },
+    dock: { needs: clear, label: 'to clear', next: firstToday ? firstToday.title : (sections[0].rows[0] ? sections[0].rows[0].title : null) },
+    rows: rowsAll,
+  };
+  last = model;
+  return model;
+}
+
+module.exports = { build, peekModel, srcLabel, num };

package/workspace/lib/route-modules.js

@@ -49,6 +49,10 @@ const MODULES = Object.freeze([
   'routes-forecast',      // console3 B5: forecast, critical path, time machine and capacity (read-only)
   'routes-calendar-views', // console3 C2: Day/Week/Month/Quarter/Year cells, Gantt and the strategy lens (read-only)
   'routes-briefing',      // console3 C1: the day-part Briefing cards from the signal engine (read-only)
+  'routes-briefing-premium', // briefing-premium: the premium Briefing's page model from repository state (read-only)
+  'routes-my-work-premium', // briefing-premium-work: the premium My work page's model from the Work page's own list (read-only)
+  'routes-board-premium', // briefing-premium-board: the premium Board page's model from the Initiatives page's own routes (read-only)
+  'routes-initiative-premium', // briefing-premium-initiative: the premium initiative page's model from the Initiatives sheet's own routes (read-only)
   'routes-brief-page',    // console3 Briefing as the brief: Today agenda, Needs you and Mentions (read-only; writes go through routes-pm-items)
   'routes-mentions',      // console3 Briefing Mentions: the PM's read marks (page press only)
   'routes-phone-day',     // phone companion: the agent's finished drafts, the evening recap and tomorrow at a glance (read-only)

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

@@ -0,0 +1,61 @@
+'use strict';
+/* routes-board-premium.js — GET /api/board-premium[?ws=<id>&board=<id>] (initiative briefing-premium-board).
+ *
+ *   200 { ok, state: 'ready', model, as_of } | 202 { ok, state: 'reading' } | 500 { ok: false, state: 'error', error }
+ *   model is lib/board-premium.js build(), made from the answers of the routes the production Initiatives page reads: /api/boards, /api/boards/board,
+ *   /backlog, /columns, /sprints and /api/core-docs?level=board. Those routes derive the initiatives in the background and answer 202 while they do, so
+ *   this route answers 202 too and the page asks again: no request waits for the read. Read-only: the one press of the page (Draft it) goes to
+ *   POST /api/core-docs/draft from the page. */
+const BoardPremium = require('./board-premium.js');
+const boards = require('./routes-boards.js');
+const coreDocs = require('./routes-core-docs.js');
+
+/** GET `pathAndQuery` from a route module's own handler, as the Work page's route does, and return { status, body }. */
+async function via(mod, pathAndQuery, req, ctx) {
+  let out = { status: 500, body: null };
+  const c = Object.assign({}, ctx, { json: (res, obj, code) => { out = { status: code || 200, body: obj }; } });
+  const u = new URL('http://local' + pathAndQuery);
+  const handled = await mod.handle({ method: 'GET', headers: (req && req.headers) || {} }, {}, u, c);
+  return handled === false ? { status: 404, body: null } : out;
+}
+const qs = (o) => '?' + Object.entries(o).filter(([, v]) => v != null && v !== '').map(([k, v]) => k + '=' + encodeURIComponent(v)).join('&');
+
+module.exports = {
+  prefixes: ['/api/board-premium'],
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/board-premium') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    const fail = (error) => { ctx.json(res, { ok: false, state: 'error', error: String(error).slice(0, 240) }, 500); return true; };
+    try {
+      const list = await via(boards, '/api/boards', req, ctx);
+      if (!list.body || list.body.ok === false) return fail((list.body && list.body.error) || 'the boards could not be listed');
+      const all = list.body.boards || [];
+      const wantWs = url.searchParams.get('ws'), wantId = url.searchParams.get('board');
+      const pick = all.find((b) => (!wantWs || b.ws === wantWs) && (!wantId || b.id === wantId)) || all[0];
+      if (!pick) return fail('no board is registered');
+      const q = qs({ ws: pick.ws, board: pick.id });
+      const head = await via(boards, '/api/boards/board' + q, req, ctx);
+      if (head.status === 202 || (head.body && head.body.pending)) { ctx.json(res, { ok: true, state: 'reading' }, 202); return true; }
+      if (!head.body || head.body.ok === false) return fail((head.body && head.body.error) || 'the board could not be read');
+      const missing = [];
+      // the late and at-risk initiatives first (the board's own `risk` view, late before at risk), then its `now` view, each initiative once
+      const listOf = (a, n) => { const seen = new Set(), out = []; const rank = (r) => (r.status === 'late' ? 0 : 1); for (const r of [...((a && a.rows) || [])].sort((x, y) => rank(x) - rank(y))) { if (!seen.has(r.id)) { seen.add(r.id); out.push(r); } } for (const r of (n && n.rows) || []) if (!seen.has(r.id)) { seen.add(r.id); out.push(r); } return out.slice(0, 100); };
+      const [risk, now, cols, spr, docs] = await Promise.all([
+        via(boards, '/api/boards/backlog' + q + '&view=risk&limit=100', req, ctx),
+        via(boards, '/api/boards/backlog' + q + '&view=now&limit=100', req, ctx),
+        via(boards, '/api/boards/columns' + q, req, ctx),
+        via(boards, '/api/boards/sprints' + q, req, ctx),
+        via(coreDocs, '/api/core-docs' + qs({ level: 'board', ws: pick.ws, board: pick.id }), req, ctx),
+      ]);
+      const ok = (r, name) => { if (r.status === 202 || !r.body || r.body.ok === false || r.body.pending) { missing.push(name); return null; } return r.body; };
+      const rk = ok(risk, 'initiatives'), nw = ok(now, 'initiatives'), c = ok(cols, 'stages'), s = ok(spr, 'sprints'), d = ok(docs, 'core documents');
+      const model = BoardPremium.build({
+        now: Date.now(), pending: false, missing: missing.filter((m) => m !== 'core documents'), boards: all.map((x) => ({ ws: x.ws, id: x.id, name: x.name })),
+        board: head.body.board, counts: head.body.counts, nextRelease: head.body.nextRelease || null,
+        rows: listOf(rk, nw), columns: c ? c.columns : [], sprints: s || { source: 'none', sprints: [] }, docs: d,
+      });
+      ctx.json(res, { ok: true, state: 'ready', model, as_of: Date.now() });
+      return true;
+    } catch (e) { return fail((e && e.message) || e); }
+  },
+};

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

@@ -0,0 +1,115 @@
+'use strict';
+/* routes-briefing-premium.js — GET /api/briefing-premium[?ws=<id>] (initiative briefing-premium).
+ *
+ *   { ok, state: 'ready'|'reading'|'error', model, as_of, refreshing, elapsed_ms, error }
+ *   model is lib/briefing-premium.js build(): { date, header, hero, list, today, dock }. A read derives every initiative and takes from half a
+ *   minute upward, so no request waits for it: a kept answer is served at once (and refreshed in the background after 5 minutes, and kept on
+ *   disk across restarts), and with none the answer is 202 { state: 'reading', elapsed_ms } until the first read ends; `as_of` says when it was read. The POST routes decide, put-off and return are the PM's own calls and write through lib/briefing-premium-writes.js; ask starts the read-only agent (lib/briefing-premium-agent.js) and GET /thread?key= reads a row's conversation. A source that cannot be read is named in model.header.missing and never guessed.
+ */
+const path = require('path');
+const BP = require('./briefing-premium.js');
+const { ENGINE_PATHS } = require('./console-state.js');
+const fs = require('fs');
+const guard = require('./pm-guard.js');
+const Wr = require('./briefing-premium-writes.js');
+const Ag = require('./briefing-premium-agent.js');
+const WP = require('./my-work-premium.js');
+const BoardP = require('./board-premium.js');
+const InitP = require('./initiative-premium.js');
+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'];
+const rootOf = (url, ctx) => {
+  let root; try { const w = ctx.getWs && ctx.getWs(url.searchParams.get('ws') || null); root = w && w.root; } catch { root = null; }
+  return root || path.resolve(__dirname, '..', '..');
+};
+
+/** The PM's own calls (initiative briefing-premium-writes). Each appends one record and answers with the rebuilt model. */
+async function post(req, res, url, ctx) {
+  const act = url.pathname.slice('/api/briefing-premium/'.length);
+  if (req.headers && req.headers['x-pmos-session']) { ctx.json(res, { ok: false, error: 'an agent session cannot record the PM\'s decision' }, 403); return true; }
+  const got = await ctx.readJson(req);
+  if (!got.ok) { ctx.json(res, { ok: false, error: 'body must be JSON' }, 400); return true; }
+  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 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 = 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: 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 { 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;
+}
+
+module.exports = {
+  prefixes: ['/api/briefing-premium'],
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname.startsWith('/api/briefing-premium/') && POSTS.includes(url.pathname.slice('/api/briefing-premium/'.length))) {
+      if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+      return post(req, res, url, ctx);
+    }
+    if (url.pathname === '/api/briefing-premium/thread') {
+      if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+      const key = url.searchParams.get('key') || '';
+      if (!Ag.KEY_RE.test(key)) { ctx.json(res, { ok: false, error: 'key must name a row' }, 400); return true; }
+      ctx.json(res, { ok: true, ...Ag.threadOf(ctx.runtimeDir, key) });
+      return true;
+    }
+    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, '..', '..');
+    const r = await BP.modelOf({ root, engine: enginePath(), runtimeDir: ctx.runtimeDir });
+    // 200 with the model, 202 while the first read goes on, 500 with the reason when a read failed
+    ctx.json(res, r.state === 'error' ? { ok: false, ...r } : { ok: true, ...r }, r.state === 'ready' ? 200 : r.state === 'reading' ? 202 : 500);
+    return true;
+  },
+};

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

@@ -0,0 +1,68 @@
+'use strict';
+/* routes-initiative-premium.js — GET /api/initiative-premium?id=<id>[&ws=<id>&board=<id>] (initiative briefing-premium-initiative).
+ *
+ *   200 { ok, state: 'ready', model, as_of } | 202 { ok, state: 'reading' } | 404 { ok: false, state: 'error', error } | 500 { ok: false, state: 'error', error }
+ *   model is lib/initiative-premium.js build(), made from the answers of the routes the production Initiatives sheet reads: /api/boards/initiative,
+ *   /api/initiatives/<id>, /api/boards/items and /api/core-docs?level=initiative. Those routes derive the initiatives in the background and answer 202
+ *   while they do, so this route answers 202 too and the page asks again: no request waits for the read. Read-only: the one press of the page (Draft it)
+ *   goes to POST /api/core-docs/draft from the page. */
+const InitPremium = require('./initiative-premium.js');
+const boards = require('./routes-boards.js');
+const initiatives = require('./routes-initiatives.js');
+const coreDocs = require('./routes-core-docs.js');
+
+/** GET `pathAndQuery` from a route module's own handler, as the Work page's route does, and return { status, body }. */
+async function via(mod, pathAndQuery, req, ctx) {
+  let out = { status: 500, body: null };
+  const c = Object.assign({}, ctx, { json: (res, obj, code) => { out = { status: code || 200, body: obj }; } });
+  const u = new URL('http://local' + pathAndQuery);
+  const handled = await mod.handle({ method: 'GET', headers: (req && req.headers) || {} }, {}, u, c);
+  return handled === false ? { status: 404, body: null } : out;
+}
+const qs = (o) => '?' + Object.entries(o).filter(([, v]) => v != null && v !== '').map(([k, v]) => k + '=' + encodeURIComponent(v)).join('&');
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
+
+module.exports = {
+  prefixes: ['/api/initiative-premium'],
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/initiative-premium') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    const fail = (error, code) => { ctx.json(res, { ok: false, state: 'error', error: String(error).slice(0, 240) }, code || 500); return true; };
+    try {
+      const id = url.searchParams.get('id') || '';
+      if (!ID_RE.test(id)) return fail('id must name an initiative', 400);
+      const list = await via(boards, '/api/boards', req, ctx);
+      if (!list.body || list.body.ok === false) return fail((list.body && list.body.error) || 'the boards could not be listed');
+      const all = list.body.boards || [];
+      const wantWs = url.searchParams.get('ws'), wantId = url.searchParams.get('board');
+      const pick = all.find((b) => (!wantWs || b.ws === wantWs) && (!wantId || b.id === wantId)) || all[0];
+      if (!pick) return fail('no board is registered');
+      const q = qs({ ws: pick.ws, board: pick.id });
+      const head = await via(boards, '/api/boards/initiative' + q + '&id=' + encodeURIComponent(id), req, ctx);
+      if (head.status === 202 || (head.body && head.body.pending)) { ctx.json(res, { ok: true, state: 'reading' }, 202); return true; }
+      if (head.status === 404) return fail((head.body && head.body.error) || id + ' is not an initiative on a board', 404);
+      if (!head.body || head.body.ok === false) return fail((head.body && head.body.error) || 'the initiative could not be read');
+      const own = head.body.board || pick;
+      const missing = [];
+      const [sheet, items, docs] = await Promise.all([
+        via(initiatives, '/api/initiatives/' + encodeURIComponent(id) + qs({ ws: pick.ws }), req, ctx),
+        via(boards, '/api/boards/items' + qs({ ws: pick.ws, board: own.id }), req, ctx),
+        via(coreDocs, '/api/core-docs' + qs({ level: 'initiative', ws: pick.ws, board: own.id, id }), req, ctx),
+      ]);
+      const ok = (r, name) => { if (r.status === 202 || !r.body || r.body.ok === false || r.body.pending) { missing.push(name); return null; } return r.body; };
+      const sh = ok(sheet, 'the initiative sheet'), it = ok(items, 'tracker items'), dd = ok(docs, 'core documents');
+      // the workflow engine's own ladder for this one initiative: each step with the evidence it states, and the next step (the sheet's stepper holds neither)
+      let lad = null;
+      try { const w = ctx.getWs ? ctx.getWs(pick.ws) : null; const r = w && ctx.consoleState && ctx.consoleState.ladder ? ctx.consoleState.ladder({ root: w.root, id }) : null; lad = r && r.ok && r.row ? r.row : null; } catch { lad = null; }
+      if (!lad) missing.push('workflow steps');
+      const model = InitPremium.build({
+        now: Date.now(), pending: false, missing: missing.filter((m) => m !== 'core documents'),
+        board: { ws: own.ws || pick.ws, id: own.id, name: own.name, workflow: own.workflow },
+        row: head.body.row, sheet: sh, items: it ? it.items : [], docs: dd, ladder: lad,
+        boards: all.map((x) => ({ ws: x.ws, id: x.id, name: x.name })), siblings: it ? (it.initiatives || []).map((x) => ({ id: x.id, title: x.title })) : [],
+      });
+      ctx.json(res, { ok: true, state: 'ready', model, as_of: Date.now() });
+      return true;
+    } catch (e) { return fail((e && e.message) || e); }
+  },
+};

package/workspace/lib/routes-my-work-premium.js

@@ -0,0 +1,31 @@
+'use strict';
+/* routes-my-work-premium.js — GET /api/my-work-premium (initiative briefing-premium-work).
+ *
+ *   { ok, state: 'ready', model, as_of } | { ok: false, error }
+ *   model is lib/my-work-premium.js build(): the hero, the plate, the agents, the waiting list, the dock. It is built from the answer of GET /api/pm-items,
+ *   which the Work page reads, so the two pages show one list. Read-only: every press goes to the existing /api/pm-items routes from the page. */
+const WP = require('./my-work-premium.js');
+const pmItems = require('./routes-pm-items.js');
+
+/** GET /api/pm-items, answered by the route's own handler, so this page reads exactly what the Work page reads. */
+async function listView(req, ctx) {
+  let body = null;
+  const c = Object.assign({}, ctx, { json: (res, obj) => { body = obj; } });
+  await pmItems.handle({ method: 'GET', headers: (req && req.headers) || {} }, {}, new URL('http://local/api/pm-items'), c);
+  return body;
+}
+
+module.exports = {
+  prefixes: ['/api/my-work-premium'],
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/my-work-premium') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    let v = null, err = null;
+    try { v = await listView(req, ctx); } catch (e) { err = String((e && e.message) || e).slice(0, 200); }
+    if (!v || v.ok === false) { ctx.json(res, { ok: false, state: 'error', error: err || (v && v.error) || 'the list could not be read' }, 500); return true; }
+    let model;
+    try { model = WP.build({ v, now: Date.now() }); } catch (e) { ctx.json(res, { ok: false, state: 'error', error: 'the page could not be built: ' + String((e && e.message) || e).slice(0, 160) }, 500); return true; }
+    ctx.json(res, { ok: true, state: 'ready', model, as_of: Date.now() });
+    return true;
+  },
+};