create-pmos 0.123.0 → 0.125.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-notes.js

@@ -207,7 +207,7 @@ async function refresh(inst) {
   if (seq !== inst.seq) return;
   if (r && r.ok) { inst.rows = r.notes || []; inst.error = null; } else { inst.rows = inst.rows || []; inst.error = (r && r.error) || COPY.readError; }
   if (!inst.open && inst.rows.length) inst.open = inst.rows[0].id;
-  if (one && one.ok && one.note && one.note.id === inst.open) inst.note = one.note;
+  if (one && one.ok && one.note && one.note.id === inst.open) { inst.note = one.note; inst.rec = one.recording || null; }
   else if (inst.open && !one) loadOpen(inst);
   drawLeft(inst);
   drawRight(inst);
@@ -217,8 +217,25 @@ async function loadOpen(inst) {
   const r = await pmGet('/api/notes/one?id=' + encodeURIComponent(id));
   if (inst.open !== id) return;
   inst.note = r && r.ok ? r.note : null;
+  inst.rec = r && r.ok ? r.recording || null : null;
   drawRight(inst);
 }
+/** The replay of the note's kept audio: one <audio> per note, kept across redraws so playback goes on. Null when no audio is kept. */
+function replayFor(inst, n) {
+  const rec = inst.rec;
+  if (!rec || n.private) { inst.audio = null; return null; }
+  const key = n.id + ':' + rec.bytes + ':' + (rec.cleaned ? 1 : 0);
+  if (inst.audio && inst.audio.key === key) return inst.audio.el;
+  if (inst.audio && !inst.audio.el.paused) return inst.audio.el;   // never cut a replay that is playing
+  const a = el('audio', { controls: true, preload: 'metadata', class: 'nt-audio', 'data-ntm-audio': '', src: '/api/notes/recording?id=' + encodeURIComponent(n.id) + '&b=' + rec.bytes + (rec.cleaned ? '&c=1' : '') });
+  inst.audio = { key, el: a };
+  return a;
+}
+function seekReplay(inst, ms) {
+  const a = inst.audio && inst.audio.el;
+  if (!a) return;
+  try { a.currentTime = Math.max(0, ms / 1000); a.play(); } catch { /* the audio is not ready */ }
+}
 function choose(inst, id) {
   if (inst.open === id) return;
   inst.open = id; inst.note = null; inst.ctxOpen = null; inst.info = false;
@@ -259,7 +276,7 @@ function drawRight(inst, force) {
   const n = inst.note;
   const live = dock.recordState();
   const held = !!n && live.mode !== 'idle' && live.id === n.id;
-  const sig = JSON.stringify([inst.open, n && [n.updated_at, n.title, n.final_notes && n.final_notes.at, (n.transcript || []).length, (n.highlights || []).length, n.agent && n.agent.markdown, iniName(n.initiative), n.state, n.resume_until, n.ended_at, (n.sessions || []).length, n.meeting && n.meeting.context && n.meeting.context.taken_at], live.mode, live.id, !!inst.rows, inst.ctxOpen, inst.info]);
+  const sig = JSON.stringify([inst.open, n && [n.updated_at, n.title, n.final_notes && n.final_notes.at, (n.transcript || []).length, (n.highlights || []).length, n.agent && n.agent.markdown, iniName(n.initiative), n.state, n.resume_until, n.ended_at, (n.sessions || []).length, n.meeting && n.meeting.context && n.meeting.context.taken_at], inst.rec && [inst.rec.bytes, inst.rec.cleaned], live.mode, live.id, !!inst.rows, inst.ctxOpen, inst.info]);
   // a held note draws again on every render: the clock, the lines and the paused minutes move. Nothing else draws without a change.
   if (!force && !held && sig === inst.rightSig) return;
   // a field being typed in is not redrawn under the cursor, except in the live block, whose fields are kept across redraws
@@ -387,6 +404,11 @@ function noteParts(inst, n, live) {
     if (V.renderLive(liveHost, { state: inst.ctx.state, setState: inst.ctx.setState, FIXTURE: inst.ctx.FIXTURE }, n.id)) out.push(liveHost);
   }
 
+  const replay = held ? null : replayFor(inst, n);
+  if (replay) out.push(el('section', { class: 'nt-pg-sec nt-pg-sec--first nt-pg-replay', 'data-ntm': 'replay' },
+    el('h3', { class: 'nt-pg-sec__h' }, el('span', null, 'Replay')), replay,
+    el('p', { class: 'nt-hint' }, 'Kept on this machine. Press a time in the discussion to play from there.')));
+
   const cf = conflictsOf(n);
   if (cf.length) {
     out.push(el('section', { class: 'nt-pg-conflicts', 'data-ntm': 'conflicts' },
@@ -438,7 +460,7 @@ function noteParts(inst, n, live) {
     out.push(el('details', { class: 'nt-pg-sec nt-pg-fold', 'data-ntm': 'discussion' },
       el('summary', { class: 'nt-pg-fold__sum' }, COPY.discussion + ' · ' + bits),
       p.topics.map((tp) => el('div', { class: 'nt-pg-topic' }, el('h4', { class: 'nt-pg-topic__h' }, tp.title), (tp.points || []).map((pt) => el('p', { class: 'nt-pg-topic__p' }, pt)))),
-      tr.length ? el('div', { class: 'nt-pg-trans' }, tr.map((x) => el('div', { class: 'nt-pg-li' }, el('span', { class: 'nt-pg-li__at' }, V.fmtTime(x.t || 0)), el('span', { class: 'nt-pg-li__text' }, x.text)))) : null));
+      tr.length ? el('div', { class: 'nt-pg-trans' }, tr.map((x) => el('div', { class: 'nt-pg-li' }, inst.audio && !held ? button({ label: V.fmtTime(x.t || 0), variant: 'ghost', size: 'sm', onClick: () => seekReplay(inst, x.t || 0), attrs: { 'data-ntm-seek': '', title: 'Play from here' } }) : el('span', { class: 'nt-pg-li__at' }, V.fmtTime(x.t || 0)), el('span', { class: 'nt-pg-li__text' }, x.text)))) : null));
   }
   return out.filter(Boolean);
 }

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') {