create-pmos 0.124.0 → 0.126.0

package/workspace/public/pm/dest-initiatives.js

@@ -25,6 +25,9 @@ import { openSheet } from './initiative-sheet.js';
 import { openNewInitiative } from './new-initiative-sheet.js';
 import './cycle-review.js';
 import './triage-card.js';
+import './releases-view.js';
+import './lifecycle-lens.js';
+import './timeline-forecast-view.js';
 
 setInitiativeOpener(openSheet);
 
@@ -93,21 +96,31 @@ function draw(host, r, ctx, repo, ws) {
   if (r.extra && r.extra.dispose) { try { r.extra.dispose(r.body); } catch { /* the view is gone */ } }
   r.handle = null; r.extra = null;
 
+  // The Roadmap's control budget is fixed (first-paint-initiatives: PRD Q5, 24 plus the top bar), so only Timeline keeps its own
+  // tab; every other registered view (Releases, Lifecycle, Forecast, ...) sits behind one 'More' tab with a second row.
+  // Only the console3 views are grouped; any other view a later run registers keeps its own tab (the View-control contract).
+  const MORE_IDS = ['releases', 'lifecycle', 'forecast'];
+  const extras = initiativesViews().filter((v) => !BUILT_IN.includes(v.id)).map((v) => ({ id: v.id, label: v.label || v.id }));
+  const ownTab = extras.filter((v) => !MORE_IDS.includes(v.id));
+  const moreViews = extras.filter((v) => MORE_IDS.includes(v.id));
   const views = [
     { id: 'roadmap', label: COPY.roadmap },
     { id: 'list', label: COPY.list },
-    ...initiativesViews().filter((v) => !BUILT_IN.includes(v.id)).map((v) => ({ id: v.id, label: v.label || v.id })),
+    ...ownTab,
+    ...(moreViews.length ? [{ id: 'more', label: 'More' }] : []),
   ];
-  if (!views.some((v) => v.id === r.view)) r.view = 'roadmap';
+  if (!views.some((v) => v.id === r.view) && !moreViews.some((v) => v.id === r.view)) r.view = 'roadmap';
   // A phone shows Roadmap or List only, and has no view switch (pm/mobile.css): its screen is one job, to see where the
   // initiatives stand and open one. ⌘K changes between the two. Any other view falls back to Roadmap here without being
   // saved, so the desktop keeps its choice.
   if (phone() && !BUILT_IN.includes(r.view)) r.view = 'roadmap';
+  const inMore = moreViews.some((v) => v.id === r.view);
   r.key = keyOf(r, repo, ws);
 
   const head = el('div', { class: 'in-head' },
     el('h2', { class: 'in-head__title' }, COPY.title),
-    tabs({ variant: 'segmented', role: 'tablist', ariaLabel: COPY.views, items: views, value: r.view, attrs: { 'data-in-views': '' }, onChange: (id) => { r.view = id; saveView(id); r.draw(r.ctx); } }),
+    tabs({ variant: 'segmented', role: 'tablist', ariaLabel: COPY.views, items: views, value: inMore ? 'more' : r.view, attrs: { 'data-in-views': '' }, onChange: (id) => { r.view = id === 'more' ? moreViews[0].id : id; saveView(r.view); r.draw(r.ctx); } }),
+    inMore ? tabs({ variant: 'segmented', role: 'tablist', ariaLabel: 'More views', items: moreViews, value: r.view, attrs: { 'data-in-more': '' }, onChange: (id) => { r.view = id; saveView(id); r.draw(r.ctx); } }) : null,
     // Scan repository (scan-documents S7): the visible form of the sheet menu's and ⌘K's re-scan. It needs a workspace.
     ws ? button({ label: COPY.rescan, icon: 'refresh-cw', attrs: { 'data-in-scan': '', title: COPY.rescanHint }, onClick: () => rescanRepo(ws) }) : null,
     button({ label: COPY.newInitiative, icon: 'plus', variant: 'primary', attrs: { 'data-in-new': '' }, onClick: () => r.openNew() }));

package/workspace/public/pm/dest-mywork.js

@@ -19,6 +19,8 @@ import { icon, ensureSprite } from './icons.js';
 import { pmPost } from './http.js';
 import { wsOf } from './data.js';
 import { registerCommand, openDestination } from './registry.js';
+import { mountPmWork, disposePmWork } from './pm-work-view.js';
+import { mountSessions, disposeSessions } from './sessions-panel.js';
 import { myWork, loadMyWork, onMyWork } from './my-work-data.js';
 
 export const COPY = Object.freeze({
@@ -112,12 +114,16 @@ export function mountDestination(host, ctx) {
   ensureSprite();
   loadMyWork();
   draw(inst);
+  if (!inst.items) { inst.items = el('div', { 'data-pm-items-host': '' }); inst.root.appendChild(inst.items); mountPmWork(inst.items, ctx); }
+  if (!inst.sessions) { inst.sessions = el('div', { 'data-sessions-host': '' }); inst.root.appendChild(inst.sessions); mountSessions(inst.sessions, ctx); }
 }
 
 export function disposeDestination(host) {
   const inst = insts.get(host);
   if (!inst) return;
   if (inst.off) inst.off();
+  if (inst.items) disposePmWork(inst.items);
+  if (inst.sessions) disposeSessions(inst.sessions);
   inst.root.remove();
   insts.delete(host);
 }
@@ -277,7 +283,8 @@ function draw(inst) {
   const root = inst.root;
   const d = myWork();
   const head = header(inst, d);
-  if (head.parentNode !== root || inst.body.parentNode !== root) root.replaceChildren(head, inst.body);
+  // The PM items panel lives in the root too; a redraw of head and body must keep it.
+  if (head.parentNode !== root || inst.body.parentNode !== root) root.replaceChildren(head, inst.body, ...(inst.items ? [inst.items] : []), ...(inst.sessions ? [inst.sessions] : []));
   const fp = JSON.stringify([d, inst.tab, inst.open, inst.details, inst.busy]);
   if (fp === inst.last) return;
   // Focus stays in an instruction being typed: the redraw waits until the field is left.

package/workspace/public/pm/dest-reports.js

@@ -25,6 +25,11 @@ import { wsOf } from './data.js';
 import { COPY, cadenceName } from './reports-copy.js';
 import { openIssueSheet, openNotesSheet, draftNow, printReport, copyMarkdown, clearPrint, ensurePrintCss } from './report-view.js';
 import { openSlides, slideCards } from './report-slides.js';
+/* The report families and the outbox load on demand: they are only drawn when the PM opens the toggle, and their module tree (the c3
+ * panels) must not weigh on the first paint of the Reports page. `lazy()` resolves both modules once. */
+let lazyMods = null;
+const lazy = () => lazyMods || (lazyMods = Promise.all([import('./report-families-view.js'), import('./outbox-panel.js')]).then(([f, o]) => ({ ...f, ...o })));
+const disposeLazy = (fn, host) => { if (lazyMods) lazyMods.then((m) => m[fn](host)); };
 
 const SHOWN = 4;                                      // the reports listed before "Show older"
 const insts = new WeakMap();                          // host -> instance
@@ -49,6 +54,7 @@ function make(host) {
   const inst = {
     host, root, ws: null, loaded: false, error: null, reports: [], flags: [], sig: null, schedules: [], doc: null, docKey: null,
     sel: null, showAll: false, otherOpen: false, locked: false, stop: null, seq: 0, last: '',
+    extra: null, famHost: null, outHost: null, extraWs: null,
   };
   return inst;
 }
@@ -72,17 +78,56 @@ export function mountDestination(host, ctx) {
       refresh(inst);
     }
     draw(inst);
+    mountExtras(inst, ctx);
     return;
   }
   if (!inst.last) draw(inst);
+  mountExtras(inst, ctx);
 }
 
+/* Report families and the outbox sit under the page. They live in one container the page's own redraw never replaces
+ * (draw() puts it back last), so a redraw does not lose them. Mounted once per repository: the families read their sections
+ * from GET /api/report-families/facts (real initiatives and releases only), then the outbox. */
+function mountExtras(inst, ctx) {
+  if (!inst.ws || inst.extraWs === inst.ws) return;
+  inst.extraWs = inst.ws;
+  if (!inst.extra) {
+    inst.famHost = el('div', { 'data-reports-families': '' });
+    inst.outHost = el('div', { 'data-reports-outbox': '' });
+    inst.panel = el('div', { class: 'rp-extra__panel', hidden: true }, inst.famHost, inst.outHost);
+    // Collapsed by default: the page's control budget (first-paint, pm-frame Q5) counts what a first paint shows, so the
+    // families and the outbox cost one control until the PM opens them.
+    inst.toggle = button({ label: 'Report families and outbox', variant: 'ghost', attrs: { 'data-reports-extra-toggle': '', 'aria-expanded': 'false' }, onClick: () => toggleExtras(inst, ctx) });
+    inst.extra = el('div', { class: 'rp-extra', 'data-reports-extra': '' }, inst.toggle, inst.panel);
+  }
+  keepExtra(inst);
+  // A repository change resets to collapsed, with nothing mounted: the families read their own facts when opened.
+  inst.extraOpen = false; inst.panel.hidden = true; inst.toggle.setAttribute('aria-expanded', 'false');
+  disposeLazy('disposeReportFamilies', inst.famHost); disposeLazy('disposeOutbox', inst.outHost);
+}
+function toggleExtras(inst, ctx) {
+  inst.extraOpen = !inst.extraOpen;
+  inst.panel.hidden = !inst.extraOpen;
+  inst.toggle.setAttribute('aria-expanded', String(inst.extraOpen));
+  if (!inst.extraOpen || !inst.ws) return;
+  const ws = inst.ws;
+  disposeLazy('disposeReportFamilies', inst.famHost);
+  pmGet('/api/report-families/facts?ws=' + encodeURIComponent(ws)).then((j) => {
+    if (inst.extraWs !== ws || !inst.extraOpen || !insts.has(inst.host)) return;
+    lazy().then((m) => { if (inst.extraWs === ws && inst.extraOpen) m.mountReportFamilies(inst.famHost, { ...(ctx || {}), reportFacts: j && j.ok ? j.facts : {} }); });
+  });
+  lazy().then((m) => { if (inst.extraOpen) m.mountOutbox(inst.outHost, {}); });
+}
+const keepExtra = (inst) => { if (inst.extra && inst.ws && inst.extra.parentNode !== inst.root) inst.root.appendChild(inst.extra); };
+
 export function disposeDestination(host) {
   const inst = insts.get(host);
   if (!inst) return;
   if (inst.stop) inst.stop();
   inst.stop = null; inst.seq++;
   clearPrint();
+  if (inst.famHost) disposeLazy('disposeReportFamilies', inst.famHost);
+  if (inst.outHost) disposeLazy('disposeOutbox', inst.outHost);
   inst.root.remove();
   insts.delete(host);
 }
@@ -309,7 +354,8 @@ function goFullScreen() {
 }
 
 /** Rebuild the persistent root from the instance, if what it shows changed; keep the focus on the same control. */
-function draw(inst) {
+function draw(inst) { drawMain(inst); keepExtra(inst); }
+function drawMain(inst) {
   const root = inst.root;
   if (!inst.ws) { root.replaceChildren(empty({ text: COPY.noRepo })); inst.last = 'none'; return; }
   const fingerprint = JSON.stringify([inst.loaded, inst.error, inst.reports, inst.flags, inst.schedules, inst.sel, inst.doc && inst.doc.sha, inst.showAll, inst.otherOpen, inst.locked]);

package/workspace/public/pm/dest-today.js

@@ -22,6 +22,8 @@ import { state, setState, FIXTURE } from './state.js';
 import { COPY } from './today-copy.js';
 import { todayCard, acceptCard, rankNodes, scopeCtx, ensureFeed, feedOf, feedErrorOf, bannerOf, onFeed } from './today-cards.js';
 import { daySection, daySig, dayState, pressPrepare } from './today-day.js';
+import { mountBriefing, disposeBriefing } from './briefing-deck.js';
+import { mountCalendarViews, disposeCalendarViews } from './calendar-views.js';
 
 const SHOWN = 3;   // cards drawn before "Show more": the first paint holds at most 17 controls (first-paint-today.test.js)
 let expanded = false;
@@ -205,8 +207,60 @@ export function mountToday(host, ctx) {
   refocus(r.root, k);
 }
 
-export function mountDestination(host, ctx) { mountToday(host, ctx); }
+/* The destination: Today's own board, plus Briefing and Calendar (console3 wave D) as two more views of the same page.
+ * Each view has its own pane in one wrapper that survives every redraw (the container-survives-redraw rule: dest-mywork.js
+ * keeps inst.items the same way). Briefing and Calendar mount once, on first open, into their pane and are disposed with the
+ * destination; Today keeps drawing into its pane exactly as before, so its content is unchanged. */
+const VIEWS = [{ id: 'today', label: 'Today' }, { id: 'briefing', label: 'Briefing' }, { id: 'calendar', label: 'Calendar' }];
+const dests = new WeakMap();   // host -> { wrap, bar, panes, view, mounted }
+
+function destFor(host, ctx) {
+  let d = dests.get(host);
+  if (d) return d;
+  const panes = {};
+  for (const v of VIEWS) panes[v.id] = el('div', { class: 'td-view', 'data-today-view': v.id });
+  d = { wrap: null, bar: null, panes, view: 'today', mounted: {} };
+  const bar = tabs({
+    variant: 'segmented', role: 'radiogroup', ariaLabel: 'Today views', value: d.view,
+    items: VIEWS.map((v) => ({ id: v.id, label: v.label })),
+    onChange: (id) => { d.view = VIEWS.some((v) => v.id === id) ? id : 'today'; showView(host, d, d.ctx); },
+    attrs: { 'data-today': 'views' },
+  });
+  d.bar = bar;
+  d.wrap = el('div', { class: 'td-dest', 'data-today': 'dest' }, bar, ...VIEWS.map((v) => panes[v.id]));
+  dests.set(host, d);
+  return d;
+}
+
+function showView(host, d, ctx) {
+  for (const v of VIEWS) d.panes[v.id].hidden = v.id !== d.view;
+  d.bar.querySelectorAll('button[data-tab]').forEach((b) => {   // the segmented control does not track its own choice
+    const on = b.getAttribute('data-tab') === d.view;
+    b.setAttribute('aria-checked', on ? 'true' : 'false'); b.setAttribute('tabindex', on ? '0' : '-1');
+  });
+  if (d.view === 'today') mountToday(d.panes.today, ctx);
+  else if (d.view === 'briefing') { d.mounted.briefing = true; mountBriefing(d.panes.briefing, ctx); }
+  else if (d.view === 'calendar') { d.mounted.calendar = true; mountCalendarViews(d.panes.calendar, ctx); }
+}
+
+export function mountDestination(host, ctx) {
+  if (!host) return;
+  const d = destFor(host, ctx);
+  d.ctx = ctx;
+  if (!d.wrap.isConnected || d.wrap.parentNode !== host) host.replaceChildren(d.wrap);
+  showView(host, d, ctx);
+}
 export function disposeDestination(host) {
+  const d = dests.get(host);
+  if (d) {
+    for (const v of VIEWS) disposeToday(d.panes[v.id]);
+    if (d.mounted.briefing) disposeBriefing(d.panes.briefing);
+    if (d.mounted.calendar) disposeCalendarViews(d.panes.calendar);
+    dests.delete(host);
+  }
+  disposeToday(host);
+}
+function disposeToday(host) {
   const r = roots.get(host);
   if (r && r.off) r.off();
   roots.delete(host);

package/workspace/public/pm/doc-health-panel.js

@@ -0,0 +1,110 @@
+/* pm/doc-health-panel.js — console3 wave B2: the document's Health and History modes, and the Ask-the-agent diff.
+ *
+ * Health: "N of M checks" and the reason for each. A check with no input is shown as "not enough input" and is not
+ * in N or M. The result is recomputed by the server from the text on each read and is never stored here beyond a short hold.
+ * Fix with the agent: disabled until the agent session path is built. Ask the agent: the word diff of a before and an
+ * after, with Accept disabled (accept by slide needs the outbox and the slide, which are not built).
+ * History: the word diff between two revisions of the document, given as a list { id, text, label? }.
+ */
+import { el } from './dom.js';
+import { setState } from './state.js';
+import { ensureC3Css, c3ic } from './pm-work-view.js';
+
+/* R4b: the panels are drawn on the console3 mockup's document sheet markup (console3.html docPanel, lines 4090 to 4104; the diff,
+ * lines 4075 to 4076; the revision list, line 4102): `.dpn` holds `.chips2` (the shield and "N of M checks pass"), `ul.chgl`
+ * rows (`li.ok` or `li.bad` with the check and its reason), `ul.hx` for the revisions, and `.dpn.dfi > .dsec > h4 + p` with
+ * `<ins>` and `<del>` for the diff. The styles are pm/console3.css. The document panel mounts in the document rail, which has no
+ * `.c3` root, so each panel carries `c3 c3e`. Not lifted: the mockup's Read, Edit and Relations modes (the rail has its own),
+ * the per-check "Fix with the agent" chips (one disabled button stays, there is no agent session path), the section flags,
+ * and the document graph (no relations data is served here). */
+const wrap = (attrs, kids) => { ensureC3Css(); return el('div', { class: 'c3 c3e', ...attrs }, el('div', { class: 'dpn' }, kids)); };
+const hcol = (h) => (h.total === 0 ? 'var(--muted-foreground)' : h.passed === h.total ? 'var(--success)' : h.total - h.passed === 1 ? 'var(--warning)' : 'var(--destructive)');
+
+const held = new Map();   // ws|path -> { state, data, error, at }
+
+const NAMES = { fresh: 'Fresh', decisions: 'Matches decisions', data: 'Matches data', complete: 'Complete', traced: 'Traced', readers: 'Readers have the current version' };
+
+function readHealth(ws, rel) {
+  const k = ws + '|' + rel;
+  const cur = held.get(k);
+  if (cur && (cur.state === 'loading' || Date.now() - cur.at < 30000)) return cur;
+  const next = { state: 'loading', data: cur ? cur.data : null, at: Date.now() };
+  held.set(k, next);
+  fetch('/api/doc-health/check', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ ws, path: rel }) })
+    .then((r) => r.json())
+    .then((d) => { held.set(k, d && d.ok ? { state: 'ok', data: d.health, at: Date.now() } : { state: 'error', error: (d && d.error) || 'refused', at: Date.now() }); setState({}); },
+      (e) => { held.set(k, { state: 'error', error: (e && e.message) || 'could not reach the workspace server', at: Date.now() }); setState({}); });
+  return next;
+}
+
+/** What the Health mode shows now, for the rail's change key. */
+export function healthStamp(ws, rel) { const g = held.get(ws + '|' + rel); return g ? [g.state, g.error || null, g.data || null] : null; }
+
+export function refreshHealth(ws, rel) { held.delete(ws + '|' + rel); }
+
+/** The pure view of one healthOf answer. */
+export function healthView(h) {
+  const note = h.checks.filter((c) => c.pass === null).length;
+  return wrap({ 'data-rail': 'health' }, [
+    el('div', { class: 'chips2', 'data-health': 'count' }, [el('span', { class: 'ki', style: 'color:' + hcol(h) }, [c3ic('shield')]), el('b', null, `${h.passed} of ${h.total} checks pass`)]),
+    note ? el('p', { class: 'dim', style: 'font-size:var(--fs-2);margin:0', 'data-health': 'unanswered' }, `${note} check${note === 1 ? '' : 's'} not counted: not enough input.`) : null,
+    el('ul', { class: 'chgl' }, h.checks.map((c) => el('li', { class: c.pass === null ? '' : c.pass ? 'ok' : 'bad', 'data-check': c.id, 'data-pass': c.pass === null ? 'none' : String(c.pass) }, [
+      c3ic(c.pass === null ? 'info' : c.pass ? 'check' : 'alert', 'sm'),
+      el('span', null, (NAMES[c.id] || c.id) + ': ' + c.reason),
+      el('span', { class: 'tag' }, c.pass === null ? 'no input' : c.pass ? 'pass' : 'fail'),
+    ]))),
+    el('div', { class: 'chips2' }, [el('button', { type: 'button', class: 'pill', disabled: true, 'aria-disabled': 'true', 'data-health': 'fix',
+      title: 'Needs the agent session path, which is not built yet.' }, [c3ic('spark', 'sm'), 'Fix with the agent'])]),
+    el('div', { class: 'dim', style: 'font-size:var(--fs-2)' }, 'Health answers one question: can I trust this document without rereading it? Checks are recomputed from the text every time it changes.'),
+  ]);
+}
+
+/** The Health mode for one document. */
+export function healthPanel(o) {
+  const g = readHealth(o.ws, o.rel);
+  if (g.state === 'loading' && !g.data) return wrap({ 'data-rail': 'status' }, [el('div', { class: 'fold a' }, [el('span', { class: 'c3spin' }, [c3ic('spark', 'sm')]), 'Checking this document…'])]);
+  if (g.state === 'error') return wrap({ 'data-rail': 'status' }, [el('div', { class: 'fold w' }, [c3ic('alert', 'sm'), 'The checks could not run: ' + g.error + '. Nothing is shown.'])]);
+  return healthView(g.data);
+}
+
+const diffNode = (diff) => el('div', { class: 'dpn dfi', 'data-rail': 'diff' }, el('div', { class: 'dsec' + (diff.some((d) => d.op !== 'same') ? ' warn' : '') }, el('p', null, diff.map((d, i) => {
+  const tag = d.op === 'add' ? 'ins' : d.op === 'del' ? 'del' : 'span';
+  return [i ? ' ' : '', el(tag, { 'data-op': d.op }, d.text)];
+}).flat())));
+
+// The same plain LCS as scripts/doc-health.js, kept here because the page cannot load a CommonJS file.
+export function wordDiff(before, after) {
+  const a = String(before || '').split(/\s+/).filter(Boolean), b = String(after || '').split(/\s+/).filter(Boolean);
+  const L = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) L[i][j] = a[i] === b[j] ? L[i + 1][j + 1] + 1 : Math.max(L[i + 1][j], L[i][j + 1]);
+  const out = [];
+  const push = (op, text) => { const l = out[out.length - 1]; if (l && l.op === op) l.text += ' ' + text; else out.push({ op, text }); };
+  let i = 0, j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) { push('same', a[i]); i++; j++; } else if (L[i + 1][j] >= L[i][j + 1]) push('del', a[i++]); else push('add', b[j++]);
+  }
+  while (i < a.length) push('del', a[i++]);
+  while (j < b.length) push('add', b[j++]);
+  return out;
+}
+
+/** History mode: compare the newest revision with the one before it (or the pair the PM picked in `o.pick`). */
+export function historyPanel(o) {
+  const revs = Array.isArray(o.revisions) ? o.revisions : [];
+  if (revs.length < 2) return wrap({ 'data-rail': 'history' }, [el('div', { class: 'fold' }, [c3ic('info', 'sm'), 'Fewer than two revisions are known for this document, so there is nothing to compare.'])]);
+  const [from, to] = o.pick || [revs[revs.length - 2].id, revs[revs.length - 1].id];
+  const a = revs.find((r) => r.id === from), b = revs.find((r) => r.id === to);
+  if (!a || !b) return wrap({ 'data-rail': 'history' }, [el('div', { class: 'fold w' }, [c3ic('alert', 'sm'), 'That revision is not in the list.'])]);
+  return wrap({ 'data-rail': 'history' }, [
+    el('ul', { class: 'hx' }, revs.slice().reverse().map((r) => el('li', null, [el('span', { class: 'chip2' }, [c3ic('doc', 'sm'), r.id]), el('span', null, [el('b', null, r.label || r.id)]), el('span', { class: 'w' }, r.id === to ? 'newest compared' : r.id === from ? 'compared with' : '')]))),
+    el('h4', { style: 'margin:0;font-size:var(--fs-3)' }, `${a.label || a.id} to ${b.label || b.id}`),
+    diffNode(wordDiff(a.text, b.text)),
+  ]);
+}
+
+/** Ask the agent: the word diff of a supplied before and after. Accept needs the outbox and the slide. */
+export function askPanel({ before, after }) {
+  return wrap({ 'data-rail': 'ask' }, [diffNode(wordDiff(before, after)),
+    el('div', { class: 'chips2' }, [el('button', { type: 'button', class: 'pill', disabled: true, 'aria-disabled': 'true', 'data-ask': 'accept',
+      title: 'Accept by slide needs the outbox and the slide, which are not built yet.' }, [c3ic('check', 'sm'), 'Accept'])])]);
+}

package/workspace/public/pm/doc-rail.js

@@ -14,11 +14,12 @@ import { el, setChildren } from './dom.js';
 import { tabs, row } from './primitives.js';
 import { setState } from './state.js';
 import { copiesOf, wordsOf, openCopy } from './doc-remote.js';
+import { healthPanel, historyPanel, healthStamp } from './doc-health-panel.js';
 
 const SVG = 'http://www.w3.org/2000/svg';
 const graphs = new Map();     // ws|path -> { state, data, at }
 const rails = new Map();      // tab id -> { node, key }
-const modes = new Map();      // tab id -> 'outline' | 'graph'
+const modes = new Map();      // tab id -> 'outline' | 'graph' | 'health' | 'history'
 
 const VIA = { link: 'Link', frontmatter: 'Frontmatter', initiative: 'Initiative', anchor: 'Anchor', cites: 'Decision',
   supersedes: 'Supersedes', amended_by: 'Amended by' };
@@ -51,7 +52,7 @@ export function railNode(tab, o) {
   const ties = g.state === 'ok' && g.data ? g.data.ties || [] : [];
   const flagged = new Set(o.findings.map((f) => f.rel).filter(Boolean));
   const mode = modes.get(tab.id) || (o.heads.length > 1 ? 'outline' : 'graph');
-  const key = JSON.stringify([mode, o.heads, g.state, ties, copies.map((c) => [c.kind, wordsOf(c, o.ws, o.rel).text]), o.findings]);
+  const key = JSON.stringify([mode, mode === 'health' ? healthStamp(o.ws, o.rel) : 0, o.revisions, o.heads, g.state, ties, copies.map((c) => [c.kind, wordsOf(c, o.ws, o.rel).text]), o.findings]);
   let r = rails.get(tab.id);
   if (!r) { r = { node: el('aside', { class: 'fr-rail', 'data-rail': '' }), key: null }; rails.set(tab.id, r); }
   if (r.key === key) return r.node;
@@ -59,7 +60,8 @@ export function railNode(tab, o) {
   const n = ties.length + copies.length;
   const kids = [tabs({
     variant: 'segmented', ariaLabel: 'Beside the document', value: mode, full: true,
-    items: [{ id: 'outline', label: 'Outline' }, { id: 'graph', label: n ? 'Connections ' + n : 'Connections' }],
+    items: [{ id: 'outline', label: 'Outline' }, { id: 'graph', label: n ? 'Connections ' + n : 'Connections' },
+      { id: 'health', label: 'Health' }, { id: 'history', label: 'History' }],
     onChange: (m) => { modes.set(tab.id, m); setState({}); },
     attrs: { class: 'fr-rail__tabs', 'data-rail': 'tabs' },
   })];
@@ -69,6 +71,10 @@ export function railNode(tab, o) {
         o.heads.map((h) => row({ title: h.text, compact: true, onOpen: () => o.onGoto(h.i), openLabel: 'Go to ' + h.text,
           attrs: { class: 'fr-rail__head', 'data-level': String(h.level), 'data-rail': 'head' } })))
       : el('p', { class: 'fr-rail__note' }, 'No headings yet. A line that starts with # or ## is a heading.'));
+  } else if (mode === 'health') {
+    kids.push(healthPanel(o));
+  } else if (mode === 'history') {
+    kids.push(historyPanel(o));
   } else if (g.state === 'loading' && !g.data) {
     kids.push(el('p', { class: 'fr-rail__note', 'data-rail': 'status' }, 'Reading the ties of this file…'));
   } else if (g.state === 'error') {

package/workspace/public/pm/lifecycle-lens-model.js

@@ -0,0 +1,228 @@
+/* pm/lifecycle-lens-model.js — the pure half of the Lifecycle lens (console3 wave B1). No DOM, so node can import it.
+ *
+ * Stage is DERIVED, never set. The lens reads each initiative's `nine_stages` (scripts/nine-stages.js: one of
+ * done | current | pending | no-signal | skipped per stage). The roadmap payload does not carry `nine_stages` yet, so
+ * `nineOf` falls back to a small MIRROR of scripts/nine-stages.js (STAGES, LANE_STAGES, SIGNALLED and the status rule),
+ * fed by the rung the row's `stage.id` names. The mirror is approximate: the row's stage is the plan-tree group, not the
+ * engine's raw rung, so an accepted initiative cannot be told apart from one in Evaluate. When the server sends
+ * `nine_stages`, that wins and the mirror is not used.
+ */
+
+export const STAGES = ['discover', 'ideate', 'strategize', 'prioritize', 'plan', 'build', 'deliver', 'monitor', 'evaluate'];
+export const LABELS = { discover: 'Discover', ideate: 'Ideate', strategize: 'Strategize', prioritize: 'Prioritize', plan: 'Plan', build: 'Build', deliver: 'Deliver', monitor: 'Monitor', evaluate: 'Evaluate' };
+// Mirror of scripts/nine-stages.js LANE_STAGES and SIGNALLED.
+const LANE_STAGES = {
+  feature: STAGES,
+  discovery: ['discover', 'ideate', 'strategize', 'prioritize', 'evaluate'],
+  chore: ['plan', 'build', 'evaluate'],
+  incident: ['build', 'deliver', 'monitor', 'evaluate'],
+  content: ['ideate', 'plan', 'build', 'deliver'],
+  prototype: ['discover', 'ideate', 'evaluate'],
+};
+const SIGNALLED = new Set(['discover', 'plan', 'build', 'evaluate']);
+// The plan-tree group id of a row's stage, as an engine rung rank (nine-stages.js RANK). Unknown groups read intake.
+const GROUP_RANK = { intake: 0, spec: 1, brief: 1, draft: 1, contract: 2, build: 3, evaluate: 4, handoff: 4 };
+
+/** The nine statuses of one row: its own `nine_stages` when the server sent them, else the mirror. */
+export function nineOf(row) {
+  if (row && Array.isArray(row.nine_stages) && row.nine_stages.length) return row.nine_stages;
+  const lane = row && row.lane;
+  const laneSet = new Set(LANE_STAGES[lane] || STAGES);
+  const gid = row && row.stage && row.stage.id;
+  const rank = GROUP_RANK[gid] ?? 0;
+  const done = { discover: rank >= 1, plan: rank >= 2, build: rank >= 3, evaluate: rank >= 4 };
+  let cur = false;
+  return STAGES.map((key) => {
+    let status;
+    if (!laneSet.has(key)) status = 'skipped';
+    else if (!SIGNALLED.has(key)) status = 'no-signal';
+    else if (done[key]) status = 'done';
+    else status = 'pending';
+    if (status === 'pending' && !cur) { status = 'current'; cur = true; }
+    return { key, label: LABELS[key], status };
+  });
+}
+
+/** The stage an initiative sits in: the first `current`; else the last `done`; else null (nothing shows a stage yet). */
+export function stageBucket(nine) {
+  const list = Array.isArray(nine) ? nine : [];
+  const cur = list.find((s) => s.status === 'current');
+  if (cur) return cur.key;
+  let last = null;
+  for (const s of list) if (s.status === 'done') last = s.key;
+  return last;
+}
+
+/** Group rows by stage: { buckets: { discover: [row…], … }, unplaced: [row…] }. `scope` is an initiative id or null for all. */
+export function bucketRows(rows, scope) {
+  const buckets = Object.fromEntries(STAGES.map((k) => [k, []]));
+  const unplaced = [];
+  for (const r of rows || []) {
+    if (scope && r.id !== scope) continue;
+    const k = stageBucket(nineOf(r));
+    if (k && buckets[k]) buckets[k].push(r); else unplaced.push(r);
+  }
+  return { buckets, unplaced };
+}
+
+/** How one stage reads across the scoped rows: 'no-signal' when every row that uses it has no signal, 'skipped' when every row skips it. */
+export function stageNote(key, rows, scope) {
+  const sts = (rows || []).filter((r) => !scope || r.id === scope).map((r) => (nineOf(r).find((s) => s.key === key) || {}).status);
+  if (!sts.length) return null;
+  if (sts.every((s) => s === 'skipped')) return 'skipped';
+  if (sts.every((s) => s === 'skipped' || s === 'no-signal')) return 'no-signal';
+  return null;
+}
+
+/* ── what each stage needs (console3.html C3.REQ, line 4687): the requirement rows of the lens, each with who does it ── */
+export const REQ = {
+  discover: [['brief', 'Discovery brief with a stop rule', 'agent'], ['evidence', 'Evidence from 3 or more sources', 'agent'], ['cont', 'Continue or park', 'pm']],
+  ideate: [['opts', 'Two or more options, one recommended', 'agent']],
+  strategize: [['bet', 'Bet statement tied to the anchor', 'agent']],
+  prioritize: [['commit', 'Commit: it fits Now capacity', 'pm']],
+  plan: [['prd', 'PRD with done criteria', 'agent'], ['rub', 'Rubric and pre-run contract', 'agent'], ['plan', 'Breakdown reviewed', 'pm']],
+  build: [['tix', 'Build tickets merged, required CI green', 'factory'], ['rev', 'Review against the rubric', 'agent']],
+  deliver: [['rel', 'Release shipped', 'pm']],
+  monitor: [['out', 'Outcome check after 2 weeks', 'agent']],
+  evaluate: [['verd', 'Verdict: what we learned, next bet seeded', 'pm']],
+};
+/** Who does a requirement: [icon, word]. */
+export const reqWho = (w) => (w === 'pm' ? ['user', 'you'] : w === 'factory' ? ['branch', 'factory'] : ['spark', 'agent']);
+/** The agent's or factory's requirements of the same stage that are not done yet: a PM decision waits for them (c3prevPending). `isDone(key)` says what is done. */
+export const prevPending = (stage, key, isDone) => (REQ[stage] || []).filter((r) => r[2] !== 'pm' && r[0] !== key && !isDone(r[0]));
+/** What the agent is asked to draft, per requirement: [the offer, what it is]. */
+export const DRAFT_TEXT = {
+  brief: ['Draft the discovery brief', 'A one-page brief with a stop rule'], evidence: ['Gather the evidence', 'Three or more sources, each cited'], opts: ['Draft the options', 'Two or more, one recommended, with the cost of each'],
+  bet: ['Draft the bet statement', 'Tied to the anchor'], prd: ['Draft the PRD', 'Done criteria first'], rub: ['Draft the rubric and pre-run contract', 'The rubric is the spec; the contract is agreed before any build'],
+  rev: ['Review the build against the rubric', 'Outcome only, weighted, against the threshold'], out: ['Run the outcome check', 'Two weeks after release, from the data'],
+};
+/** The PM's decision per requirement: [yes label, yes effect], [no label, no effect], the sentence. */
+export const DECIDE_TEXT = {
+  cont: [['Continue to the next stage', 'The stop rule stays in force'], ['Park it, reason recorded', 'Frees the discovery slot'], 'The stop rule is the test. Read the evidence and decide: a close call is a reason to ask for more, not to guess.'],
+  commit: [['Commit it to Now', 'It fits Now capacity'], ['Keep it in Prioritize', 'Waits for capacity'], 'Now has a limit. The least sure bet goes back if it fills.'],
+  plan: [['Approve the plan', 'Breakdown, owners and dates are agreed'], ['Send the breakdown back', 'The agent revises it'], 'Check that every work item has an owner before you approve.'],
+  rel: [['Release it', 'The release is recorded as shipped by your slide'], ['Hold it', 'The date moves; promises are re-told'], 'Release needs its readiness checks and an outside change in Jira, which needs its own slide.'],
+  verd: [['Record the verdict: iterate', 'The next bet is seeded from the lesson'], ['Record the verdict: stop', 'Frees the capacity'], 'The verdict is a human judgement; the agent only drafts the evidence.'],
+};
+/** The stages a lane uses, in order (the lane's own list). */
+export const laneStages = (lane) => LANE_STAGES[lane] || STAGES;
+
+/* ── the derived panels of the lens (console3 wave L1). Ports of scripts/trust/reader.js (the PM's sample), sections 11 to 16:
+ *    11 PRIORITIZE  score = impact x confidence / effort, capacity in bets
+ *    12 DISCOVER    hypothesis status from weighted evidence; evidence whose source is not a known file is untraced
+ *    14 GATE LADDER the six gates in order, the next gate, order violations
+ *    15 RUBRIC      the weighted score against the threshold, the weakest dimension, the watermelon guard
+ *    16 NORTH STAR  corrections per agent run, lower is better
+ *  Pure: no DOM, no fetch. Real records feed them; nothing here invents a number. ── */
+const isNum = (v) => typeof v === 'number' && Number.isFinite(v);
+
+/** The score of an idea (reader.js section 11: impact x confidence / effort, two decimals). null when a figure is missing. */
+export function ideaScore(x) {
+  if (!x || !isNum(x.imp) || !isNum(x.conf) || !isNum(x.eff) || x.eff <= 0) return null;
+  return Math.round(x.imp * x.conf / x.eff * 100) / 100;
+}
+/** An ideas record (scripts/records: title, impact, effort, confidence; optional initiative, source, status, why) as the lens draws it. */
+export function normIdea(r) {
+  const o = r || {};
+  const st = ['new', 'short', 'committed', 'parked'].includes(o.status) ? o.status : o.status === 'shortlisted' ? 'short' : 'new';
+  return { id: String(o.rid || o.id || ''), n: String(o.title || ''), init: String(o.initiative || ''), imp: Number(o.impact), eff: Number(o.effort), conf: Number(o.confidence),
+    src: ['agent', 'customer', 'you'].includes(o.source) ? o.source : 'you', st, why: String(o.why || '') };
+}
+/** The ideas that are ranked: not parked, best score first (reader.js 11). */
+export const rankIdeas = (ideas) => (ideas || []).filter((x) => x.st !== 'parked' && ideaScore(x) != null).sort((a, b) => ideaScore(b) - ideaScore(a));
+/** Capacity: the effort the PM holds (shortlisted and committed) against the capacity figure. cap = null when none is recorded. */
+export function capacityUsed(ideas, cap) {
+  const used = (ideas || []).filter((x) => x.st === 'short' || x.st === 'committed').reduce((a, x) => a + (isNum(x.eff) ? x.eff : 0), 0);
+  return { used, cap: isNum(cap) ? cap : null, over: isNum(cap) ? Math.max(0, used - cap) : null };
+}
+
+/** A hypotheses record as the lens draws it. `evidence` is [{ src, dir: 'supports'|'refutes', w }]. */
+export function normHyp(r) {
+  const o = r || {};
+  const ev = (Array.isArray(o.evidence) ? o.evidence : []).filter((e) => e && typeof e === 'object').map((e) => ({ src: String(e.src || ''), dir: e.dir === 'refutes' ? 'refutes' : 'supports', w: isNum(Number(e.w)) ? Number(e.w) : 1, at: e.at ? String(e.at) : '' }));
+  return { id: String(o.rid || o.id || ''), t: String(o.title || ''), init: String(o.initiative || ''), falsifier: String(o.falsifier || ''), review_by: String(o.review_by || ''), ev };
+}
+/** The status of a hypothesis, as reader.js section 12 derives it: net = sum of the weights (supports plus, refutes minus); net >= 3 is supported,
+ *  net <= -2 is refuted, anything between is open. `known` is a Set (or object) of the sources that exist; a source outside it is untraced.
+ *  The reader has three statuses. The page splits "open" for display only, so the PM can tell an empty hypothesis from a contested one:
+ *  `shown` is untested (no evidence), mixed (evidence both ways), or open (one-sided but below the bar). `status` stays the reader's. */
+export function hypStatus(h, known) {
+  const ev = (h && h.ev) || [];
+  const net = ev.reduce((a, e) => a + (e.dir === 'supports' ? e.w : -e.w), 0);
+  const status = net >= 3 ? 'supported' : net <= -2 ? 'refuted' : 'open';
+  const has = known instanceof Set ? (s) => known.has(s) : known ? (s) => !!known[s] : () => false;
+  const untraced = ev.filter((e) => !has(e.src)).map((e) => e.src || '(no source)');
+  const sup = ev.filter((e) => e.dir === 'supports').length; const ref = ev.length - sup;
+  const shown = status !== 'open' ? status : !ev.length ? 'untested' : sup && ref ? 'mixed' : 'open';
+  return { status, shown, net, untraced, supports: sup, refutes: ref };
+}
+export const HYP_LABEL = { supported: 'Supported', refuted: 'Refuted', mixed: 'Mixed', untested: 'Untested', open: 'Open' };
+
+/** The six gates the mockup draws, and the engine step each reads (scripts/workflow-state.js steps; the rule text of each step is its `basis.rule`):
+ *  Spec = spec, Rubric = contract (done criteria and test method agreed, D13), Build = build, Quality = quality, Review = review, Acceptance = accept. */
+export const GATES = [['Spec', 'spec'], ['Rubric', 'contract'], ['Build', 'build'], ['Quality', 'quality'], ['Review', 'review'], ['Acceptance', 'accept']];
+const dayOf = (v) => { const m = /^(\d{4}-\d{2}-\d{2})/.exec(String(v || '')); return m ? m[1] : ''; };
+/** The gate ladder from one initiative's ladder row (the steps of `GET /api/console?name=ladder`). Each gate: { name, key, state, evidence, rule, date }.
+ *  state is done | next (the first gate not done, the one in progress) | open (not yet) | na (cut by the PM or not required) | unknown (the engine does not claim it, e.g. CI decides).
+ *  A violation is a gate done before an earlier gate that is not done (reader.js 14 `viol`): "Build before Rubric"; with first-seen dates, also a gate done on an earlier day than the gate before it. */
+export function gateLadder(row) {
+  const steps = (row && Array.isArray(row.steps)) ? row.steps : [];
+  const by = Object.fromEntries(steps.map((s) => [s.key, s]));
+  let nextAt = -1;
+  const gates = GATES.map(([name, key], i) => {
+    const s = by[key] || null;
+    let state = !s ? 'unknown' : s.status === 'done' ? 'done' : s.status === 'na' ? 'na' : s.status === 'unknown' ? 'unknown' : 'open';
+    if (state === 'open' && nextAt < 0) { nextAt = i; state = 'next'; }
+    return { name, key, state, evidence: s ? String(s.evidence || '') : 'the engine returned no step for this gate', rule: s && s.basis ? String(s.basis.rule || '') : '', date: s && s.basis ? dayOf(s.basis.first_seen) : '', blocking: !!(s && s.blocking) };
+  });
+  const viol = [];
+  gates.forEach((g, i) => {
+    if (g.state !== 'done') return;
+    gates.slice(0, i).forEach((p) => {
+      if (p.state === 'na' || p.state === 'unknown') return;
+      if (p.state !== 'done') viol.push(g.name + ' before ' + p.name);
+      else if (g.date && p.date && g.date < p.date) viol.push(g.name + ' before ' + p.name + ' (' + g.date + ' against ' + p.date + ')');
+    });
+  });
+  const next = gates.find((g) => g.state === 'next') || null;
+  return { gates, next, violations: viol, done: gates.filter((g) => g.state === 'done').length, counted: gates.filter((g) => g.state !== 'na').length, nextAction: row && row.next ? row.next : null, blockers: (row && row.blockers) || [], failures: (row && row.gate_failures) || [] };
+}
+/** The cells of the mockup's `.gt` bar: 'd' done, 'h' next (half), '' open, 'na', 'u' (unknown). */
+export const gateCell = (g) => (g.state === 'done' ? 'd' : g.state === 'next' ? 'h' : g.state === 'na' ? 'na' : g.state === 'unknown' ? 'u' : '');
+
+/** An evaluation row (planning/runs/evals.jsonl: score, threshold or pass_threshold, dimensions as { name: score }, verdict, evaluator_model) as the scorecard.
+ *  The recorded score is shown as recorded. A weight is used only when a row carries one (`dims` as [{ dim, w, score }], the sample's form); otherwise the
+ *  dimensions are unweighted and the page says so. Dimensions that are not numbers are dropped. */
+export function normEval(e) {
+  if (!e || typeof e !== 'object') return null;
+  let dims = [];
+  if (Array.isArray(e.dims)) dims = e.dims.filter((d) => d && isNum(d.score)).map((d) => ({ name: String(d.dim || d.name || ''), w: isNum(d.w) ? d.w : null, score: d.score }));
+  else if (e.dimensions && typeof e.dimensions === 'object') dims = Object.entries(e.dimensions).filter(([, v]) => isNum(v)).map(([k, v]) => ({ name: k, w: null, score: v }));
+  const weighted = dims.length && dims.every((d) => d.w != null);
+  const computed = weighted ? dims.reduce((a, d) => a + d.w * d.score, 0) : dims.length ? dims.reduce((a, d) => a + d.score, 0) / dims.length : null;
+  const score = isNum(e.score) ? e.score : computed;
+  const thr = isNum(e.threshold) ? e.threshold : isNum(e.pass_threshold) ? e.pass_threshold : null;
+  return { score, threshold: thr, dims, weighted: !!weighted, verdict: String(e.verdict || ''), model: String(e.evaluator_model || ''), at: String(e.recorded_at || e.at || ''), run: String(e.run_id || e.run || '') };
+}
+/** The verdict of a scorecard: passes (score at or over the threshold), the weakest dimension, and the watermelon guard (reader.js 15: a pass while a dimension scores under 0.6). */
+export function evalVerdict(ev) {
+  if (!ev || ev.score == null) return null;
+  const weakest = ev.dims.slice().sort((a, b) => a.score - b.score)[0] || null;
+  const passes = ev.threshold != null ? ev.score >= ev.threshold : null;
+  const watermelon = !!(passes && weakest && weakest.score < 0.6);
+  return { passes, weakest, watermelon, below: ev.threshold != null && !passes };
+}
+/** The newest evaluation per initiative from a list of rows (recorded_at, then file order). */
+export function latestEvals(rows) {
+  const out = {};
+  (rows || []).forEach((r, i) => { const id = r && r.initiative_id; if (!id) return; const at = String(r.recorded_at || r.at || ''); const p = out[id]; if (!p || at >= p.at) out[id] = { at, i, row: r }; });
+  return Object.fromEntries(Object.entries(out).map(([k, v]) => [k, v.row]));
+}
+/** Corrections per run (reader.js 16, lower is better), two decimals, for each bucket and the change from the first to the last. */
+export function correctionRate(series) {
+  const s = (series || []).filter((x) => x && x.runs > 0);
+  if (!s.length) return null;
+  const rate = (x) => Math.round(x.corrections / x.runs * 100) / 100;
+  const vals = s.map(rate);
+  return { now: vals[vals.length - 1], from: vals[0], vals, improved: vals[vals.length - 1] < vals[0] };
+}