create-pmos 0.192.0 → 0.194.0

package/workspace/lib/routes-meeting-focus.js

@@ -55,14 +55,32 @@ function linesOf(runtimeDir, keys) {
 
 /* ── the meeting, its note and its brief ──────────────────────────────────────────────────────────────────────────── */
 
+const minuteOf = (t) => { const ms = Date.parse(t); return Number.isFinite(ms) ? Math.floor(ms / 60000) : null; };
+const normTitle = (t) => require('./calendar-memory.js').normTitle(t);
+/** A meeting named by its start and title (a recording whose meeting has no stored id). The start is compared as an instant, not as
+ * text: a note keeps its meeting's start in UTC ("…T07:00:00.000Z") while the calendar writes it with the local offset ("…T15:00:00+08:00").
+ * Same minute and same title first, then the only meeting of that title on that local day (a meeting moved after the note linked it). */
+function findByStart(events, by) {
+  const m = minuteOf(by.at); if (m === null) return null;
+  const rows = (events || []).filter((e) => e && e.id && minuteOf(e.at) !== null);
+  const title = by.title ? normTitle(by.title) : '';
+  const atMin = rows.filter((e) => minuteOf(e.at) === m);
+  const both = title ? atMin.filter((e) => normTitle(e.title) === title) : atMin;
+  if (both.length) return both[0];
+  if (!title) return null;
+  const day = localDay(m * 60000);
+  const named = rows.filter((e) => normTitle(e.title) === title && localDay(Date.parse(e.at)) === day);
+  return named.length === 1 ? named[0] : null;
+}
 function findEvent(events, id, date, by) {
-  if (!id && by && by.at) {   // a meeting without a stored id: its start and title name it
-    const hit = (events || []).filter((e) => e && e.id && e.at === String(by.at) && (!by.title || e.title === String(by.title)));
-    return hit[0] || null;
-  }
+  if (!id && by && by.at) return findByStart(events, by);
   const rows = (events || []).filter((e) => e && e.id && (String(e.id) === id || baseId(e.id) === baseId(id)));
   const onDay = rows.filter((e) => !date || String(e.at || '').slice(0, 10) === date);
-  return onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+  const hit = onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+  if (hit) return hit;
+  // a date that is the UTC day of the start, not its local day (an early-morning meeting east of UTC): the start names it
+  if (by && by.at) return findByStart(events, by);
+  return rows.find((e) => String(e.id) === id) || null;   // an occurrence id names one meeting whatever the day says
 }
 /** A recording that is not on the calendar (a talk in the corridor): the note stands in for the meeting. It has no end, no people
  * and no brief, so focus shows what is said, PMOS's notes and Captured, and no topics from an invite. */

package/workspace/lib/vendor/scripts/migrate-layout.js

@@ -67,7 +67,7 @@ function registry() {
   try {
     REGISTRY = new Set(fs.readFileSync(path.join(PMOS_ROOT, 'scripts', 'frontmatter_registry.txt'), 'utf8')
       .split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#')));
-  } catch { REGISTRY = new Set(['Concept', 'ADR', 'Template', 'Playbook', 'Reference', 'Initiative', 'PRD', 'Story', 'Rubric', 'OKR', 'Radar', 'Checklist', 'Calibration', 'Research', 'Design', 'Prototype', 'Handover', 'Decision', 'Principle', 'Debt', 'Discovery', 'Guide']); }
+  } catch { REGISTRY = new Set(['Concept', 'ADR', 'Template', 'Playbook', 'Reference', 'Initiative', 'PRD', 'Story', 'Rubric', 'OKR', 'Radar', 'Checklist', 'Calibration', 'Research', 'Design', 'Prototype', 'Handover', 'Review', 'Decision', 'Principle', 'Debt', 'Discovery', 'Guide']); }
   return REGISTRY;
 }
 

package/workspace/lib/vendor/workspace/lib/doc-category.js

@@ -47,7 +47,7 @@ const TYPE_TO_CATEGORY = {
   Concept: 'knowledge', ADR: 'spec-artifact', Template: 'other', Playbook: 'knowledge', Reference: null,
   Initiative: 'spec-artifact', PRD: 'prd', Story: 'spec-artifact', Rubric: 'spec-artifact', OKR: 'spec-artifact',
   Radar: 'report', Checklist: 'other', Calibration: 'report', Research: null, Design: 'spec-artifact',
-  Prototype: 'other', Handover: 'report',
+  Prototype: 'other', Handover: 'report', Review: 'report',
   Decision: 'spec-artifact', Principle: 'knowledge', Debt: 'report', Discovery: 'report', Guide: 'knowledge',
 };
 

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.192.0",
+  "version": "0.194.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.192.0",
+      "version": "0.194.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.192.0",
+  "version": "0.194.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/c3-brief-needs.js

@@ -21,6 +21,7 @@ import { cardView, TAG_STYLE } from './briefing-model.js';
 import { onBriefPage } from './c3-brief-data.js';
 import { button, ensureComponentsCss } from './primitives.js';
 import { loadDriverNeeds, needsRow as driverRow } from './c3-driver.js';
+import { needsLoc } from './c3-core-docs.js';
 
 const reduced = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
 const post = (path, body) => pmPost(path, body).catch(() => ({ ok: false }));
@@ -175,6 +176,8 @@ export function needsSection(S) {
   /* the agent's rows: drafts waiting on the PM, a target the PM is blocking. A press opens the initiative (its Overview holds the strip) or Work. */
   let agentSig = '';
   const goAgent = (n) => {
+    const docsLoc = n.kind === 'core-doc-drafts' ? needsLoc(n) : null;
+    if (docsLoc) { try { const u = new URL(location.href); u.searchParams.set('init', docsLoc); history.replaceState(history.state, '', u); } catch { /* no history */ } if (hooks.go) hooks.go({ action: 'goinit' }); try { window.dispatchEvent(new CustomEvent('pmos:ini-go', { detail: { loc: docsLoc } })); } catch { /* the page reads the address when it mounts */ } return; }
     if (n.initiative_id) { try { const u = new URL(location.href); u.searchParams.set('init', 'ini:' + encodeURIComponent(n.ws) + ':' + encodeURIComponent(n.initiative_id) + ':overview'); history.replaceState(history.state, '', u); } catch { /* no history */ } }
     if (hooks.go) hooks.go({ action: n.initiative_id ? 'goinit' : 'gowork' });
   };

package/workspace/public/pm/c3-core-docs.css

@@ -0,0 +1,18 @@
+/* pm/c3-core-docs.css — the core documents of a level (c3-core-docs.js): the agent colour for a draft, the actions under a row, the
+ * panel above a draft in the document sheet. Scoped to .cd-host and .cd-panel; tokens only. */
+.c3 .cd-host { display: contents; }
+.c3 .cd-host .nrow > .acts { grid-column: 2; display: flex; gap: 6px; flex-wrap: wrap; justify-content: flex-start; align-items: flex-start; }
+.c3 .cd-host .st.cd-ag, .c3 .cd-panel .st.cd-ag { color: var(--agent); border-color: color-mix(in oklab, var(--agent) 45%, transparent); background: color-mix(in oklab, var(--agent) 8%, transparent); }
+.c3 .cd-host .chip2.cd-agc { color: var(--agent); }
+.c3 .cd-panel { display: grid; gap: var(--sp-2); min-width: 0; }
+.c3 .cd-panel .fold { border-color: color-mix(in oklab, var(--agent) 45%, transparent); }
+.c3 .cd-oh { margin-top: var(--sp-3); }
+/* The quiet pages (c3-quiet.css) hide teaching sentences and every chip after the second. The approved mockup of the Docs views keeps both:
+ * a row says what the document is for, who reads it, how often it changes and who writes it. */
+.c3 .cd-host .ini-note, .c3 .cd-panel .ini-note { display: block !important; }
+.c3 .cd-host .nrow .nb > .chips > :nth-child(n+3) { display: inline-flex !important; }
+.c3 [data-ini="pf-docs"] .ini-lhm .dim { display: block !important; }
+.c3 .cd-host .sect .sh2 .ini-meta { display: inline !important; }
+/* the heading above the board's other documents: the look of a section heading, without a card around the search and the groups */
+.c3 .cd-host .cd-oh { display: flex; justify-content: space-between; align-items: center; gap: 8px; padding: var(--sp-3) 0 var(--sp-2); border-bottom: 1px solid var(--border); }
+.c3 .cd-host .cd-oh h2 { margin: 0; font: 500 var(--fs-2) var(--mono); color: var(--muted-foreground); text-transform: uppercase; letter-spacing: .06em; display: flex; gap: 8px; align-items: center; }

package/workspace/public/pm/c3-core-docs.js

@@ -0,0 +1,234 @@
+/* pm/c3-core-docs.js — the core documents of a level (initiative core-documents, PRD section 6; the approved mockup 43-doc-levels.js).
+ * Each level answers one question for one reader: Portfolio, Board, Initiative. Its Docs view starts with the level's core set, from
+ *   GET  /api/core-docs?ws&level=portfolio|board|initiative&board&id   { ok, level, scope, question, reader, rhythm, build, wfTpl, stage, cat,
+ *                                                                          summary, docs: [entry + state] }
+ *   POST /api/core-docs/draft { ws, scope, key }          { ok, run }   Draft it, and Redraft ("Ask PMOS to change it")
+ *   POST /api/core-docs/issue { ws, scope, key, slot }    { ok }        Issue it
+ * The server holds the sets, the states and the drafts; this file draws them and holds nothing.
+ *
+ *   coreDocs(env)    -> { left, right, dispose }   two hosts to put in the columns of cols(): the sections and the cards. env =
+ *                      { api, level, board?, id?, ws, today, toast, nav: { tab(tab), tool(tool), reports() }, boardRow?, iniDocs?: { docs, initiatives } }
+ *   needsLoc(row)    -> the `init=` address of the Docs view a Briefing row (kind core-doc-drafts) opens
+ *   segBadge(n)      the count badge of the Portfolio's Documents segment
+ * A press on a row opens `open`: { path } the document sheet, { tab } the board tab, { tool } the initiative's Overview tool, { reports } Reports.
+ * Review the draft opens the draft in the document sheet. The sheet holds the actions: a panel above the draft (docAbove, the sheet's own hook)
+ * with Issue it and Ask PMOS to change it, which asks for a new draft. Nothing is sent to anyone; the PM's press issues it. */
+import { el } from './dom.js';
+import { icon, pbtn, lk, chip, tag, st, note, sect, card, list, nrow, plural, day, ago, sw, chgl, mono, put, ensureIniCss } from './c3-ini-ui.js';
+
+const BY = { you: 'You write it', proposes: 'PMOS proposes', drafts: 'PMOS drafts it', files: 'PMOS files it', watches: 'PMOS watches it', keeps: 'PMOS keeps it current', live: 'Live view', reviews: 'PMOS reviews, you accept' };
+const AGENT_BY = ['drafts', 'proposes', 'files', 'watches', 'keeps', 'reviews'];
+const CAT_IC = { Discover: 'search', Plan: 'cal', Do: 'bolt', Learn: 'up' };
+const CAT_ORDER = ['Discover', 'Plan', 'Do', 'Learn'];
+const POLL_MS = 4000;
+const PENDING_MS = 1500;
+
+function ensureCss() {
+  if (typeof document === 'undefined' || document.querySelector('link[data-c3-cd]')) return;
+  ensureIniCss();
+  const l = document.createElement('link');
+  l.rel = 'stylesheet'; l.href = new URL('./c3-core-docs.css', import.meta.url).href; l.setAttribute('data-c3-cd', '');
+  document.head.appendChild(l);
+}
+
+/** The count badge of the Portfolio's Documents segment (hidden at 0). */
+export function segBadge(n) { return el('span', { class: 'bdg', 'data-cd': 'seg-badge', ...(n ? {} : { hidden: '' }) }, String(n || 0)); }
+
+/** The address of the Docs view a Briefing row opens, as the `init=` value (c3-initiatives.js parseLoc). Null when the row names no scope. */
+export function needsLoc(row) {
+  const r = row || {};
+  const raw = String(r.scope || (/(?:^|:)(portfolio|board:[^:|]+|ini(?:tiative)?:[^:|]+)$/.exec(String(r.run_id || '')) || [])[1] || '');
+  if (raw == 'portfolio') return 'docs';
+  let m = /^board:(.+)$/.exec(raw);
+  if (m) return 'board:' + encodeURIComponent(m[1]) + ':docs';
+  m = /^ini(?:tiative)?:(.+)$/.exec(raw);
+  const id = m ? m[1] : r.initiative_id;
+  if (id) return 'ini:' + encodeURIComponent(r.board || r.ws || '') + ':' + encodeURIComponent(id) + ':docs';
+  return null;
+}
+
+/* ── the sheet's draft panel ── */
+const DRAFTS = new Map();   // path -> { ws, api, scope, key, slot, toast, ui, done }
+const NODES = new WeakMap();
+let hooked = null;
+function hookSheet() {
+  if (!hooked) hooked = import('./c3-doc-sheet.js').then((m) => { m.docAbove.push(({ doc, key }) => { const e = DRAFTS.get(doc.path); if (!e) return null; if (!NODES.has(key)) NODES.set(key, draftPanel(e)); return NODES.get(key); }); return m; });
+  return hooked;
+}
+function draftPanel(e) {
+  const msg = el('div', { class: 'fold w', role: 'alert', hidden: '', 'data-cd': 'panel-error' });
+  const fail = (t) => { msg.textContent = t; msg.hidden = false; };
+  let busy = false;
+  const act = (path, body, done) => async () => {
+    if (busy) return; busy = true; msg.hidden = true;
+    const r = await e.api.post(path, { scope: e.scope, key: e.key, ...body }).catch(() => null);
+    busy = false;
+    if (!r || !r.ok) { fail((r && r.error) || 'no answer'); return; }
+    done(); if (e.ui && e.ui.close) e.ui.close();
+    if (e.done) e.done();
+  };
+  const issue = act('/api/core-docs/issue', { slot: e.slot }, () => { DRAFTS.delete(e.path); e.toast('Issued. Nothing was sent to anyone.'); });
+  const redraft = act('/api/core-docs/draft', {}, () => { e.toast('PMOS is drafting it again. The new draft replaces this one when it is ready.'); });
+  return el('div', { class: 'cd-panel', 'data-cd': 'draft-panel' },
+    el('div', { class: 'fold' }, icon('spark', 'sm'), el('span', null, ' PMOS drafted this from its sources. Nothing is sent. Read it, change what you like, then issue it.')),
+    el('div', { class: 'chips2' }, pbtn('primary', 'Issue it', 'check', { 'data-cd-issue': e.key, onclick: issue }), pbtn('outline', 'Ask PMOS to change it', 'spark', { 'data-cd-redraft': e.key, onclick: redraft })),
+    msg);
+}
+
+/* ── rows ── */
+const summaryLine = (docs) => {
+  const n = (s) => docs.filter((d) => d.st === s).length;
+  return [n('draft') ? plural(n('draft'), 'draft') + ' to review' : '', n('due') ? n('due') + ' due' : '', n('missing') ? n('missing') + ' not started' : ''].filter(Boolean).join(', ') || 'Everything is up to date';
+};
+const isAgent = (d) => d.running || d.st === 'draft';
+
+function stChip(d) {
+  if (d.running) return el('span', { class: 'st cd-ag', 'data-cd-state': 'running' }, icon('spark', 'sm'), 'Agent drafting');
+  const a = { 'data-cd-state': d.st };
+  switch (d.st) {
+    case 'ok': return st('ok', 'check', 'Up to date', a);
+    case 'due': return st('warn', 'clock', d.due ? 'Due ' + day(d.due) : 'Due now', a);
+    case 'draft': return el('span', { class: 'st cd-ag', ...a }, icon('spark', 'sm'), 'Draft ready' + (d.due ? ', due ' + day(d.due) : ''));
+    case 'missing': return st('bad', 'alert', 'Not started', a);
+    case 'stale': return st('warn', 'clock', 'Out of date', a);
+    default: return el('span', { class: 'chip2 dim', ...a }, 'Comes later');
+  }
+}
+const byChip = (k) => (AGENT_BY.includes(k) ? el('span', { class: 'chip2 cd-agc' }, icon('spark', 'sm'), BY[k]) : chip(icon(k === 'live' ? 'eye' : 'user', 'sm'), BY[k] || k));
+
+function pathNameOf(env, d) { return d.title + (env.scopeLabel ? ' · ' + env.scopeLabel : ''); }
+
+async function openSheetFor(env, d, path, draft) {
+  try {
+    const m = await hookSheet();
+    const ui = m.openDocSheet({ ws: env.ws, doc: { path, name: pathNameOf(env, d), ty: draft ? 'Draft' : 'Document', v: '', st: draft ? 'draft' : d.st, ini: env.level === 'initiative' ? env.id : '', iniName: '' },
+      library: () => env.api.get('/api/docs/library', env.board ? { board: env.board } : {}) });
+    if (draft) { const e = DRAFTS.get(path); if (e) e.ui = ui; }
+    return ui;
+  } catch { env.toast('The document sheet could not open. The file is ' + path + '.'); return null; }
+}
+
+function press(env, d, redraw) {
+  const o = d.open || null;
+  if (!o) return null;
+  if (o.path) return () => openSheetFor(env, d, o.path, false);
+  if (o.tab) return () => env.nav.tab(o.tab);
+  if (o.tool) return () => env.nav.tool(o.tool);
+  if (o.reports) return () => env.nav.reports();
+  return null;
+}
+
+function review(env, d, redraw) {
+  const p = d.draft && d.draft.path;
+  if (!p) return () => env.toast('The draft has no file yet. Try again in a moment.');
+  return () => {
+    DRAFTS.set(p, { path: p, ws: env.ws, api: env.api, scope: env.scope, key: d.key, slot: d.draft.slot, toast: env.toast, ui: null, done: redraw });
+    openSheetFor(env, d, p, true);
+  };
+}
+
+async function draftIt(env, d, redraw) {
+  const r = await env.api.post('/api/core-docs/draft', { scope: env.scope, key: d.key }).catch(() => null);
+  if (!r || !r.ok) { env.toast('The draft did not start: ' + ((r && r.error) || 'no answer') + '.'); return; }
+  env.toast('PMOS is drafting the ' + d.title.toLowerCase() + '. It lands here as a draft for you to review.');
+  redraw();
+}
+
+function coreRow(env, d, redraw) {
+  const open = press(env, d, redraw);
+  const meta = [d.when && !['later', 'missing'].includes(d.st) ? chip(icon('clock', 'sm'), (d.st === 'draft' ? 'drafted ' : 'updated ') + ago(d.when, env.today)) : null,
+    d.flag ? st('warn', 'alert', d.flag) : null, d.staleWhy && d.st === 'stale' ? chip(d.staleWhy) : null];
+  let action = null;
+  if (!d.running && d.st === 'draft') action = pbtn('primary', 'Review the draft', 'spark', { 'data-cd-review': d.key, onclick: review(env, d, redraw) });
+  else if (!d.running && d.kind === 'doc' && d.by !== 'you' && (d.st === 'missing' || d.st === 'stale')) action = pbtn('outline', 'Draft it', 'spark', { 'data-cd-draft': d.key, onclick: () => draftIt(env, d, redraw) });
+  return nrow({ ic: d.ic || 'doc', hot: isAgent(d) || d.st === 'missing', title: [d.title, d.isNew ? [' ', tag('new')] : null], onOpen: open || undefined, openLabel: open ? 'Open ' + d.title : undefined,
+    titleAttrs: { 'data-cd-open': d.key }, sub: d['for'] || '',
+    chips: [stChip(d), d.cadence ? chip(icon('cal', 'sm'), d.cadence) : null, d.reader ? chip(icon('user', 'sm'), d.reader) : null, byChip(d.by), ...meta],
+    right: [action], attrs: { 'data-cd-row': d.key, 'data-cd-st': d.running ? 'running' : d.st } });
+}
+
+/* ── the sections ── */
+function coreSection(env, data, redraw) {
+  return sect({ ic: 'doc', title: 'Core documents', count: data.docs.length, attrs: { 'data-cd': 'core' }, right: mono(summaryLine(data.docs)) },
+    list(data.docs.map((d) => coreRow(env, d, redraw)), { 'data-cd': 'core-list' }));
+}
+
+function iniSections(env, data, redraw) {
+  const cur = data.cat || 'Plan';
+  return CAT_ORDER.map((c) => {
+    const ds = data.docs.filter((d) => d.cat === c);
+    if (!ds.length) return null;
+    const ic = CAT_IC[c];
+    const a = (extra) => ({ 'data-cd-cat': c, ...extra });
+    if (ds.every((d) => d.st === 'later')) return sect({ ic, title: c, count: ds.length, attrs: a({ 'data-cd-fold': 'later' }), right: chip('Comes later') },
+      el('div', { class: 'chips2' }, ...ds.map((d) => el('span', { class: 'chip2 dim' }, icon(d.ic || 'doc', 'sm'), d.title))));
+    if (c !== cur && ds.every((d) => d.st === 'ok' && !d.running)) return sect({ ic, title: c, count: ds.length, attrs: a({ 'data-cd-fold': 'done' }), right: st('ok', 'check', 'All ' + ds.length + ' up to date') },
+      el('div', { class: 'chips2' }, ...ds.map((d) => { const o = press(env, d, redraw); return o ? lk({ onclick: o, 'data-cd-chip': d.key }, icon(d.ic || 'doc', 'sm'), d.title) : el('span', { class: 'chip2' }, icon(d.ic || 'doc', 'sm'), d.title); })));
+    return sect({ ic, title: c + (c === cur ? ' · now' : ''), count: ds.length, attrs: a({ 'data-cd-fold': 'open' }), right: chip(sw(c), ds.filter((d) => d.st === 'ok').length + ' of ' + ds.length + ' done') },
+      list(ds.map((d) => coreRow(env, d, redraw))));
+  }).filter(Boolean);
+}
+
+/* ── the cards of the right column ── */
+const levelCard = (data, extra) => card({ ic: 'info', title: 'What this level is for', attrs: { 'data-cd': 'level' } },
+  el('p', { class: 'ini-p' }, el('b', null, data.question || '')),
+  note('Read by ' + (data.reader || 'the team') + '. Changes ' + (data.rhythm || 'as it changes') + '.' + (data.level == 'portfolio' ? ' Boards and initiatives link up to it through their key result, so nothing here repeats what a board says.' : '')),
+  ...extra);
+
+function draftsCard(env, data, redraw) {
+  const ds = data.docs.filter((d) => d.st === 'draft' && !d.running);
+  return card({ ic: 'spark', title: 'Drafts waiting for you', attrs: { 'data-cd': 'drafts' } },
+    ds.length ? chgl(ds.map((d) => el('li', null, icon('spark', 'sm'), el('span', null, lk({ onclick: review(env, d, redraw), 'data-cd-wait': d.key }, d.title), d.due ? ' due ' + day(d.due) : ''), tag('Briefing'))))
+      : note('No draft is waiting.'),
+    note('Drafts also show as one Briefing card. Nothing is sent until you issue it.'));
+}
+const connectCard = () => card({ ic: 'init', title: 'How the levels connect', attrs: { 'data-cd': 'connect' } }, chgl([
+  el('li', null, icon('alert', 'sm'), el('span', null, 'Risks are written once, on the initiative. Board risks and cross-board risks collect them.')),
+  el('li', null, icon('up', 'sm'), el('span', null, 'Each initiative\'s outcome review feeds the board retro and the quarterly review.')),
+  el('li', null, icon('report', 'sm'), el('span', null, 'Status reports at every level come from the same dashboard, so they agree.'))]));
+
+function rightCards(env, data, redraw) {
+  if (data.level == 'portfolio') return [levelCard(data, []), draftsCard(env, data, redraw), connectCard()];
+  if (data.level === 'board') {
+    const b = env.boardRow || {};
+    const ini = env.iniDocs;
+    return [levelCard(data, [note(data.build ? 'Build and deliver is on, so the set adds the sprint review and release notes' + (b.jira ? ' from Jira ' + b.jira : '') + '.' : 'Build and deliver is off, so there is no sprint review or release notes. Progress comes from PMOS tasks.')]),
+      card({ ic: 'doc', title: 'Initiative documents', attrs: { 'data-cd': 'ini-docs' } },
+        note('Each initiative keeps its own PRD, rubric, risks and outcome review on its Docs tab.' + (ini ? ' ' + plural(ini.docs, 'document') + ' across ' + plural(ini.initiatives, 'initiative') + '.' : '')))];
+  }
+  return [levelCard(data, [note('The set grows with the workflow: each stage adds the documents it needs, and later stages wait.'), data.wfTpl === 'research' ? note('Research only: nothing gets built, so there is no PRD, rubric, design or launch checklist.') : null]),
+    card({ ic: 'alert', title: 'Order rules', attrs: { 'data-cd': 'order' } }, note('A missing PRD or rubric before Build shows as a warning on the initiative, never a block. The CI gate still needs a PRD and a rubric before a pull request merges.'))];
+}
+
+/** The two hosts of a level's core documents. Reads the set, draws it, and reads it again after a press and while an agent drafts. */
+export function coreDocs(env) {
+  ensureCss();
+  const left = el('div', { class: 'cd-host', 'data-cd-host': 'left' }, note('Reading the core documents'));
+  const right = el('div', { class: 'cd-host', 'data-cd-host': 'right' });
+  let dead = false; let timer = null; let seq = 0; let last = null;
+  const get = () => env.api.get('/api/core-docs', { level: env.level, board: env.level == 'portfolio' ? '' : env.board, id: env.level === 'initiative' ? env.id : '' });
+  async function load() {
+    const token = ++seq;
+    const r = await get().catch(() => null);
+    if (dead || token !== seq) return;
+    clearTimeout(timer);
+    if (r && r.pending) { // the initiative rows are still loading: say so and ask again
+      put(left, note('Reading the core documents')); put(right);
+      timer = setTimeout(() => { if (!dead && left.isConnected) load(); }, PENDING_MS); return;
+    }
+    if (!r || !r.ok || !Array.isArray(r.docs)) {
+      put(left, el('div', { class: 'fold w', role: 'alert', 'data-cd': 'error' }, icon('alert', 'sm'), 'The core documents could not be read: ' + ((r && r.error) || 'no answer') + '.'));
+      put(right); return;
+    }
+    const redraw = () => { load(); };
+    last = { r, redraw };
+    put(left, ...(env.level === 'initiative' ? iniSections({ ...env, scope: r.scope }, r, redraw) : [coreSection({ ...env, scope: r.scope }, r, redraw)]));
+    put(right, ...rightCards({ ...env, scope: r.scope }, r, redraw));
+    if (env.onData) env.onData(r);
+    if (r.docs.some((d) => d.running)) timer = setTimeout(() => { if (!dead && left.isConnected) load(); }, POLL_MS);
+  }
+  load();
+  return { left, right, dispose() { dead = true; clearTimeout(timer); }, reload: load,
+    /** The counts of the board's other documents, for the Initiative documents card. */
+    setIniDocs(v) { env.iniDocs = v; if (last) put(right, ...rightCards({ ...env, scope: last.r.scope }, last.r, last.redraw)); } };
+}

package/workspace/public/pm/c3-demo-coredocs.js

@@ -0,0 +1,211 @@
+/* pm/c3-demo-coredocs.js — DEMO ONLY (/c3.html?demo=1): the core documents of each level (initiative core-documents; the approved mockup
+ * 43-doc-levels.js). It answers GET /api/core-docs with the shape of the route (the three sets, a state for each entry, drafts), the three
+ * POSTs (draft, issue, drop) and the documents the rows open (GET /api/doc and the sheet's revisions, proposals and log for
+ * planning/core-docs/...). A write changes the in-memory state only. A draft that was asked for shows "Agent drafting" for a few seconds, then
+ * becomes a draft to review; an issue turns a draft into an up-to-date document.
+ *
+ * The mockup's boards and initiatives are mapped to the ones this demo holds (c3-demo-boards.js): Microsite (Build and deliver off) is
+ * "Office move"; IDPF-15 (in Build) is IDPF-12; IDPF-21 (research only, Discover) is IDPF-21; IDPF-09 (in Evaluate, with an outcome review
+ * draft) is IDPF-62, an Evaluate initiative of the same board. Dates come from the demo's today.
+ * Wiring: c3-demo.js calls installCoreDocs() after installBoards(), so this wrapper is outermost. Real mode never loads this file. */
+import { TODAY } from './c3-demo-data.js';
+
+const DAY = 86400000;
+const ymd = (n) => { const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(TODAY); const t = new Date(Date.UTC(+m[1], +m[2] - 1, +m[3]) + n * DAY); return t.toISOString().slice(0, 10); };
+
+const SCOPE_Q = { portfolio: 'Are we betting on the right things?', board: 'Is this area moving, and what comes next?', initiative: 'What are we building, why, and did it work?' };
+const READER = { portfolio: 'leadership', board: 'the board owner, the team and the engineering lead', initiative: 'you, the builders and the reviewers' };
+const RHYTHM = { portfolio: 'each quarter, with a monthly pulse', board: 'every sprint or two weeks', initiative: 'at each stage' };
+
+/* the core sets: key, title, ic, for, reader, cadence, by, kind (doc | live | report), cat, isNew, state, when, due, flag, home */
+const PF = [
+  { key: 'strategy', title: 'Product strategy', ic: 'target', for: 'Vision, where we play and what we will not do. Every board and key result traces to it.', reader: 'Leadership, every PM', cadence: 'Yearly, reviewed each quarter', by: 'you', st: 'ok', w: -9, flag: '2 key results do not trace to it', isNew: true },
+  { key: 'okrs', title: 'OKRs and health budgets', ic: 'flag', for: 'The key results initiatives anchor to, and the budgets maintenance work runs on.', reader: 'Leadership, PMs', cadence: 'Quarterly', by: 'proposes', st: 'ok', w: -12 },
+  { key: 'roadmap', title: 'Portfolio roadmap', ic: 'cal', for: 'Bets by quarter (Now, Next, Later) and the key result each serves. A sendable copy of the Roadmap.', reader: 'Leadership, stakeholders', cadence: 'Monthly', by: 'drafts', st: 'draft', w: 0, due: 4 },
+  { key: 'invest', title: 'Investment mix', ic: 'cols', for: 'Where the effort goes: by board, by key result, and feature work against upkeep.', reader: 'Leadership', cadence: 'Quarterly', by: 'drafts', st: 'draft', w: 0, due: 4, isNew: true },
+  { key: 'scan', title: 'Horizon scan reports', ic: 'search', for: 'Benchmark, competitive, insight and productivity reports, each with proposals.', reader: 'PMs, leadership', cadence: 'Weekly scan', by: 'drafts', st: 'ok', w: -1, kind: 'report' },
+  { key: 'status', title: 'Portfolio status report', ic: 'report', for: 'One page: progress on key results, what changed, what needs a decision.', reader: 'Leadership', cadence: 'Every two weeks', by: 'drafts', st: 'due', w: -10, due: 4, kind: 'report' },
+  { key: 'decisions', title: 'Decision log', ic: 'scale', for: 'Decisions that cross boards, and why they were made.', reader: 'Everyone', cadence: 'As decided', by: 'files', st: 'ok', w: -2 },
+  { key: 'kill', title: 'Kill conditions', ic: 'x', for: 'The result that would make us stop a bet.', reader: 'Leadership', cadence: 'Quarterly', by: 'watches', st: 'ok', w: -30, flag: '1 tripped' },
+  { key: 'prisks', title: 'Cross-board risks', ic: 'alert', for: 'The few risks that span boards, rolled up from the risks each initiative records.', reader: 'Leadership, board owners', cadence: 'Monthly', by: 'drafts', st: 'ok', w: -3, isNew: true },
+  { key: 'quarter', title: 'Quarterly review', ic: 'up', for: 'What landed, what moved the key results, and what we learned. Built from outcome reviews.', reader: 'Leadership', cadence: 'Quarterly', by: 'drafts', st: 'ok', w: -6, isNew: true },
+  { key: 'context', title: 'Market and user context', ic: 'notes', for: 'Jobs to be done, the market map and the research behind them.', reader: 'PMs', cadence: 'When research lands', by: 'keeps', st: 'ok', w: -20 },
+];
+const BD = [
+  { key: 'charter', title: 'Board charter', ic: 'flag', for: 'Why this board exists: purpose, owner, the key results it serves, scope in and out, how work flows.', reader: 'Owner, team, new joiners', cadence: 'When the board changes', by: 'drafts', st: 'ok', w: -15, isNew: true },
+  { key: 'backlog', title: 'Roadmap and backlog', ic: 'todo', for: 'Initiatives by stage, horizon and owner.', reader: 'Team, stakeholders', cadence: 'Live', by: 'live', st: 'ok', kind: 'live', tab: 'initiatives' },
+  { key: 'intake', title: 'Intake log', ic: 'inbox', for: 'Asks received, accepted or declined, and why.', reader: 'Owner, requesters', cadence: 'Live', by: 'live', st: 'ok', kind: 'live', tab: 'triage' },
+  { key: 'bstatus', title: 'Board status report', ic: 'report', for: 'Progress, slips, asks and what needs a decision, for the owner\'s manager.', reader: 'Stakeholders', cadence: 'Every two weeks', by: 'drafts', st: 'draft', w: 0, due: 2, kind: 'report' },
+  { key: 'capacity', title: 'Capacity plan', ic: 'user', for: 'Who works on the board, their points a week, and whether the plan fits.', reader: 'Owner, eng lead', cadence: 'Each sprint', by: 'drafts', st: 'ok', w: -6, flag: 'Ana is at 112%', isNew: true },
+  { key: 'metrics', title: 'Board metrics', ic: 'up', for: 'The few numbers this board moves, with one definition each.', reader: 'Team', cadence: 'Quarterly', by: 'keeps', st: 'ok', w: -40 },
+  { key: 'brisks', title: 'Board risks', ic: 'alert', for: 'Risks on this board\'s initiatives and the waits on other boards. Written on each initiative, collected here.', reader: 'Owner', cadence: 'Every two weeks', by: 'drafts', st: 'ok', w: -1, isNew: true },
+  { key: 'sprint', title: 'Sprint review', ic: 'clock', for: 'What the sprint committed and finished, what slipped and why.', reader: 'Team, stakeholders', cadence: 'Each sprint', by: 'drafts', st: 'draft', w: 0, build: true, isNew: true },
+  { key: 'release', title: 'Release notes', ic: 'out', for: 'What each release holds, every line cited.', reader: 'Team, support, customers', cadence: 'Each release', by: 'drafts', st: 'due', due: 3, build: true, kind: 'live', tab: 'releases' },
+  { key: 'retro', title: 'Board retro', ic: 'undo', for: 'Patterns across this board\'s initiatives, from their learnings and outcome reviews.', reader: 'Team', cadence: 'Quarterly', by: 'drafts', st: 'ok', w: -6, isNew: true },
+];
+const IN = [
+  { key: 'record', title: 'Initiative record', ic: 'init', cat: 'Discover', for: 'Identity, anchor, lane and stage, with links to everything else. The gate checks it.', by: 'drafts' },
+  { key: 'problem', title: 'Problem statement', ic: 'notes', cat: 'Discover', for: 'The problem, who has it and the evidence.', by: 'drafts', tool: 'problem' },
+  { key: 'research', title: 'Research notes', ic: 'search', cat: 'Discover', for: 'Interviews, data pulls and anything else the problem rests on.', by: 'drafts' },
+  { key: 'rice', title: 'Priority (RICE)', ic: 'scale', cat: 'Plan', for: 'Why now, compared with the rest of the board.', by: 'proposes', tool: 'rice' },
+  { key: 'prd', title: 'PRD', ic: 'doc', cat: 'Plan', for: 'What and why, requirements and done criteria.', by: 'drafts' },
+  { key: 'rubric', title: 'Eval rubric', ic: 'check', cat: 'Plan', for: 'How the result will be judged, agreed before the build.', by: 'drafts' },
+  { key: 'design', title: 'Design and mockup', ic: 'eye', cat: 'Plan', for: 'The approved look and flows.', by: 'drafts' },
+  { key: 'stories', title: 'User stories and ADRs', ic: 'tree', cat: 'Plan', for: 'Slices the builders pick up, and technical decisions with their reasons.', by: 'drafts' },
+  { key: 'risks', title: 'Risks', ic: 'alert', cat: 'Do', for: 'What could sink it. Rolls up to the board and the portfolio.', by: 'drafts', tool: 'risks' },
+  { key: 'launch', title: 'Launch checklist and comms', ic: 'out', cat: 'Do', for: 'What must be true to ship, and who hears about it.', by: 'drafts', tool: 'release' },
+  { key: 'review', title: 'Review verdict and acceptance', ic: 'shield', cat: 'Do', for: 'The review gate result and your sign-off.', by: 'reviews' },
+  { key: 'update', title: 'Status update', ic: 'report', cat: 'Do', for: 'A short update for stakeholders while it is active.', by: 'drafts', kind: 'report' },
+  { key: 'explainer', title: 'Explainer', ic: 'info', cat: 'Learn', for: 'What changed, in plain words, for support and new readers.', by: 'drafts' },
+  { key: 'outcome', title: 'Outcome review', ic: 'up', cat: 'Learn', for: 'Did it move the key result, and what we learned. Feeds the quarterly review.', by: 'drafts', isNew: true },
+];
+const CAT_ORDER = ['Discover', 'Plan', 'Do', 'Learn'];
+/* states the mockup gives its demo initiatives; anything not listed comes from the stage */
+const INI_STATE = {
+  'IDPF-12': { record: 'ok', problem: 'ok', research: 'ok', rice: 'ok', prd: 'ok', rubric: 'ok', design: 'ok', stories: 'ok', risks: 'ok', launch: 'due', review: 'later', update: 'draft' },
+  'IDPF-21': { record: 'ok', problem: 'draft', research: 'due' },
+  'IDPF-62': { record: 'ok', problem: 'ok', research: 'ok', rice: 'ok', prd: 'ok', rubric: 'ok', design: 'ok', stories: 'ok', risks: 'ok', launch: 'ok', review: 'ok', update: 'ok', explainer: 'ok', outcome: 'draft' },
+};
+
+/* the documents the rows open: the mockup's, as markdown; any other entry gets a short generic body */
+const BODY = {
+  invest: '## Headline\nIDPF takes 46% of the effort and Payments 28%. Upkeep is 22% against a 20% budget. Two key results get no effort this quarter.\n\n## By board\n- IDPF: 46%\n- Payments: 28%\n- Growth: 14%\n- Office move: 6%\n- Hiring Q4: 4%\n\n## Feature work against upkeep\n- Feature (anchored to a key result): 78%\n- Upkeep (health budgets): 22% of a 20% budget\n\n## Worth a look\n- KR 2.1 Activation has three initiatives on two boards. One shared definition of "activated" would save rework.\n- KR 3.3 and KR 5.1 have no initiative at all.\n',
+  sprint: '## Headline\nThe sprint committed 44 points and finished 36 (82%). Two stories slipped, both waiting on QA.\n\n## Finished\n- IDPF-1175 Setup step 2: first API key\n- IDPF-1210 Spike: token bucket per partner\n\n## Carried over\n- IDPF-1182 Workspace provisioning API, 5 points: waiting for QA\n- IDPF-1190 QA test plan for beta, 3 points: blocked, no QA this sprint\n\n## For the next sprint\n- Add QA capacity before committing the beta.\n',
+  charter: '## Purpose\nGive developers a platform they can set up and build on alone: identity, keys, limits and the first API call.\n\n## Serves\n- KR 2.1 Activation to 45%\n- KR 1.3 Partner uptime 99.9%\n\n## Scope\n- In: sign-in, workspaces, keys, limits, SDKs\n- Out: billing (Payments board)\n\n## How work flows\nBuild and deliver is on. Two-week sprints. New asks arrive in Triage.\n',
+  outcome: '## The bet\nIf developers can create and test a key on one page, more of them make a first API call within one day.\n\n## Did it move the key result?\nYes. First API call within one day rose from 52% to 61% in the five weeks after release (target for the initiative: 60%).\n\n## Kill conditions\nNone tripped.\n\n## What we learned\n- A test call on the same page mattered more than the new layout.\n- We should have measured rotation before; we have no baseline.\n\n## What next\n- Close the initiative as Hit.\n',
+};
+const PRETTY = { portfolio: 'portfolio', board: 'board', initiative: 'initiative' };
+
+const slugOf = (scope) => scope.replace(/[^A-Za-z0-9]+/g, '-').toLowerCase();
+const pathOf = (scope, key, slot) => 'planning/core-docs/' + slugOf(scope) + '/' + key + '/' + slot + '.md';
+const parseScope = (scope) => { const m = /^(portfolio|board|initiative):?(.*)$/.exec(String(scope || '')); return m ? { level: m[1], id: m[2] } : null; };
+
+/* ── state: what a press changed ── */
+const OV = new Map();   // scope|key -> { st, when, draft, running, issued }
+const ovKey = (scope, key) => scope + '|' + key;
+
+function boardInfo(id) {
+  const S = typeof window !== 'undefined' ? window.__c3boards : null;
+  const b = S && S.boards ? S.boards.find((x) => x.id === id) : null;
+  return b ? { id, name: b.name, build: !!b.build, jira: b.jira || '', owner: b.owner } : { id, name: id, build: id === 'idpf', jira: '', owner: 'You' };
+}
+function iniInfo(id) {
+  const S = typeof window !== 'undefined' ? window.__c3boards : null;
+  const r = S && S.rows ? S.rows.find((x) => x.id === id) : null;
+  if (!r) return null;
+  const b = S.boards.find((x) => x.id === r.board);
+  const wf = r.workflow || (b && b.workflow) || [];
+  const stage = (wf.find((s) => s.name === r.stage) || {});
+  return { id, board: r.board, stage: r.stage, cat: stage.cat || 'Plan', wfTpl: r.template || (b && b.template) || 'product' };
+}
+
+function entryOf(scope, e, base) {
+  const o = OV.get(ovKey(scope, e.key)) || {};
+  const stt = o.st || base.st;
+  const when = o.when !== undefined ? o.when : base.when;
+  const draft = stt === 'draft' ? (o.draft || { slot: ymd(0), path: pathOf(scope, e.key, ymd(0)) }) : null;
+  let open = null;
+  if (e.tab) open = { tab: e.tab }; else if (e.tool) open = { tool: e.tool }; else if (e.kind === 'report') open = { reports: true };
+  else if (stt === 'draft') open = { path: draft.path };
+  else if (stt === 'ok' || stt === 'due' || stt === 'stale') open = when ? { path: pathOf(scope, e.key, when) } : null;
+  return { key: e.key, title: e.title, ic: e.ic, for: e.for, reader: e.reader || null, cadence: e.cadence || null, by: e.by, kind: e.kind || 'doc', cat: e.cat || null, isNew: !!e.isNew,
+    st: stt, when: when || null, due: base.due != null ? (typeof base.due === 'number' ? ymd(base.due) : base.due) : null, flag: o.st ? null : base.flag || null, staleWhy: null, open, draft, running: !!o.running };
+}
+const summaryOf = (docs) => { const n = (s) => docs.filter((d) => d.st === s).length; return { draft: n('draft'), due: n('due'), missing: n('missing'), stale: n('stale') }; };
+
+function setOf(scope) {
+  const sc = parseScope(scope);
+  if (!sc) return null;
+  const head = { ok: true, level: sc.level, scope, question: SCOPE_Q[sc.level], reader: READER[sc.level], rhythm: RHYTHM[sc.level], build: null, wfTpl: null, stage: null, cat: null };
+  let docs;
+  if (sc.level == 'portfolio') docs = PF.map((e) => entryOf(scope, e, { ...e, when: e.w != null ? ymd(e.w) : null }));
+  else if (sc.level === 'board') {
+    const b = boardInfo(sc.id); head.build = b.build;
+    docs = BD.filter((e) => !e.build || b.build).map((e) => {
+      const idpf = sc.id === 'idpf';
+      const st0 = e.key === 'charter' && sc.id === 'office' ? 'missing' : idpf ? e.st : (e.st === 'draft' ? 'ok' : e.st);
+      return entryOf(scope, e, { ...e, st: st0, when: st0 === 'missing' ? null : (e.w != null ? ymd(e.w) : null), flag: idpf ? e.flag : null });
+    });
+  } else {
+    const i = iniInfo(sc.id); if (!i) return { ok: false, error: 'No initiative ' + sc.id };
+    const b = boardInfo(i.board); head.build = b.build; head.stage = i.stage; head.cat = i.cat; head.wfTpl = i.wfTpl;
+    const cur = CAT_ORDER.indexOf(i.cat); const given = INI_STATE[sc.id] || {}; const research = i.wfTpl === 'research';
+    docs = IN.filter((e) => (b.build || !['rubric', 'stories', 'review'].includes(e.key) || i.board === 'idpf') && (!research || ['record', 'problem', 'research', 'rice', 'risks', 'update', 'outcome'].includes(e.key))).map((e) => {
+      const at = CAT_ORDER.indexOf(e.cat);
+      const st0 = given[e.key] || (at > cur ? 'later' : at === cur ? 'due' : 'ok');
+      return entryOf(scope, e, { ...e, st: st0, when: st0 === 'ok' ? ymd(-(at + 2) * 6) : st0 === 'draft' ? ymd(0) : null });
+    });
+  }
+  return { ...head, summary: summaryOf(docs), docs };
+}
+
+function bodyText(scope, key, slot) {
+  const sc = parseScope(scope) || {};
+  const all = [...PF, ...BD, ...IN]; const e = all.find((x) => x.key === key) || { title: key, for: '' };
+  const title = e.title + (sc.level === 'board' ? ' · ' + boardInfo(sc.id).name : sc.level === 'initiative' ? ' · ' + sc.id : '');
+  let body = BODY[key];
+  if (key === 'charter' && sc.id === 'office') body = '## Purpose\nMove the Jakarta office in 2027 with one contractor, and keep the team working through it.\n\n## Serves\n- Project milestone: lease signed\n\n## How work flows\nProject workflow. Build and deliver is off: the work is PMOS tasks, no Jira.\n';
+  if (!body) body = '## Summary\n' + (e.for || 'The document.') + '\n\n## Sources\n- Records PMOS reads for this ' + (PRETTY[sc.level] || 'level') + '\n';
+  const draftedBy = '---\ntitle: ' + title + '\nsource: core-docs:' + key + '\nslot: ' + slot + '\n---\n';
+  return draftedBy + '# ' + title + '\n\n' + body;
+}
+
+const json = (b, status) => new Response(JSON.stringify(b), { status: status || 200, headers: { 'content-type': 'application/json' } });
+const KEYED = (p) => /^planning\/core-docs\/([^/]+)\/([^/]+)\/(\d{4}-\d{2}-\d{2})\.md$/.exec(String(p || ''));
+
+function answer(method, path, q, body) {
+  if (path === '/api/core-docs' && method === 'GET') {
+    const level = q.get('level');
+    const scope = level == 'portfolio' ? 'portfolio' : level === 'board' ? 'board:' + (q.get('board') || '') : 'initiative:' + (q.get('id') || '');
+    const out = setOf(scope);
+    return out && out.ok ? json(out) : json(out || { ok: false, error: 'No such level.' }, out ? 404 : 400);
+  }
+  if (path.startsWith('/api/core-docs/') && method !== 'GET') {
+    const k = ovKey(body.scope, body.key);
+    if (path === '/api/core-docs/draft') {
+      const cur = OV.get(k) || {};
+      if (cur.running) return json({ ok: false, error: 'A draft is already running for this document.' }, 409);
+      const prev = (setOf(body.scope) || { docs: [] }).docs.find((d) => d.key === body.key) || {};
+      OV.set(k, { ...cur, running: true, st: prev.st === 'draft' ? 'draft' : cur.st || prev.st });
+      setTimeout(() => { OV.set(k, { st: 'draft', when: ymd(0), draft: { slot: ymd(0), path: pathOf(body.scope, body.key, ymd(0)) }, running: false }); }, 5000);
+      return json({ ok: true, run: 'demo-core-doc-' + body.key });
+    }
+    if (path === '/api/core-docs/issue') { OV.set(k, { st: 'ok', when: ymd(0), running: false }); return json({ ok: true }); }
+    if (path === '/api/core-docs/drop') { OV.set(k, { st: 'missing', when: null, running: false }); return json({ ok: true }); }
+  }
+  /* the documents the rows open */
+  const m = KEYED(q.get('path') || (body && body.path));
+  if (m) {
+    const slug = m[1]; const key = m[2]; const slot = m[3];
+    const scope = slug == 'portfolio' ? 'portfolio' : slug.startsWith('board-') ? 'board:' + slug.slice(6) : 'initiative:' + (/^initiative-(.+)$/.exec(slug) || [])[1];
+    const sc = scope.startsWith('initiative:') ? 'initiative:' + String(scope.slice(11)).toUpperCase() : scope;
+    if (path === '/api/doc') return new Response(bodyText(sc, key, slot), { status: 200, headers: { 'content-type': 'text/markdown; charset=utf-8' } });
+    const p = q.get('path') || body.path;
+    if (path === '/api/doc-sheet/revisions') return json({ ok: true, path: p, revisions: [{ rev: 1, by: 'claude-code/session', at: slot + 'T08:10:00.000Z', why: 'Drafted from the sources', before_hash: '', after_hash: '' }] });
+    if (path === '/api/doc-sheet/proposals') return json({ ok: true, path: p, proposals: [] });
+    if (path === '/api/doc-sheet/log') return json({ ok: true, path: p, revisions: [{ rev: 1, by: 'claude-code/session', at: slot + 'T08:10:00.000Z', why: 'Drafted from the sources', via: 'sheet', text_by: 'agent', before_hash: '', after_hash: '' }], events: [] });
+    if (path === '/api/doc-health/check') return json({ ok: true, path: p, health: { passed: 3, total: 3, checks: [{ id: 'fresh', pass: true, reason: 'drafted today' }, { id: 'complete', pass: true, reason: 'Required sections present' }, { id: 'traced', pass: true, reason: 'Sources listed' }] } });
+  }
+  return null;
+}
+
+let installed = false;
+export function installCoreDocs() {
+  if (installed || typeof window === 'undefined') return;
+  installed = true;
+  const prev = window.fetch;
+  window.fetch = (input, init) => {
+    try {
+      const raw = typeof input === 'string' ? input : input instanceof URL ? input.href : input && input.url;
+      const method = String((init && init.method) || (input && input.method) || 'GET').toUpperCase();
+      const u = new URL(raw, location.origin);
+      if (u.origin === location.origin && (u.pathname.startsWith('/api/core-docs') || u.pathname.startsWith('/api/doc'))) {
+        let b = {};
+        if (method !== 'GET') { try { b = init && init.body ? JSON.parse(init.body) : {}; } catch { b = {}; } }
+        const out = answer(method, u.pathname, u.searchParams, b);
+        if (out) return Promise.resolve(out);
+      }
+    } catch { /* an unreadable request goes on as it is */ }
+    return prev(input, init);
+  };
+}

package/workspace/public/pm/c3-demo.js

@@ -13,6 +13,7 @@ import * as D from './c3-demo-data.js';
 import { installInit } from './c3-demo-init.js';
 import { focusGet, focusPost } from './c3-demo-focus.js';   // Meeting focus: the mockup's Partner API review (GET /api/meeting-focus, its ask poll, and the topic and ask POSTs)
 import { installBoards } from './c3-demo-boards.js';   // Initiatives boards: answers every /api/boards GET and POST (installed outermost, in installDemo)
+import { installCoreDocs } from './c3-demo-coredocs.js';   // Core documents of each level: GET /api/core-docs and its POSTs (installed outermost, after installBoards)
 import './c3-demo-cal-ix.js';   // Calendar and the ribbon: sets window.__c3calix (calendar-views.js reads it in demo only)
 import './c3-demo-cal3.js';   // Calendar Quarter and Year: answers GET /api/c3-strategy (chained under this file's fetch wrapper)
 import './c3-demo-rep-ix.js';   // Reports fixtures: sets window.__c3repix (report-families-view.js reads it in demo only)
@@ -123,4 +124,4 @@ export function demoPill() {
 }
 
 export const DEMO_WS = D.WS_ID;
-export function installDemo() { freezeClock(); install(); installRep3(); installInit(); installBoards(); const repReady = import('./c3-demo-rep2.js').then((m) => { m.installRep2(); return import('./c3-demo-rs.js'); }).then((m) => m.installRs()); window.__c3demo = true; window.__c3demoReady = Promise.all([repReady, import('./c3-demo-brief-ix.js')]).then(([, m]) => m.installBriefIx()).then(() => import('./c3-demo-misc2.js')).then((m) => m.installMisc2()).then(() => import('./c3-demo-brief-page.js')).then((m) => m.installBriefPage()); }   // Briefing case files, people and a simulated agent (c3-shell.js waits for __c3demoReady)
+export function installDemo() { freezeClock(); install(); installRep3(); installInit(); installBoards(); installCoreDocs(); const repReady = import('./c3-demo-rep2.js').then((m) => { m.installRep2(); return import('./c3-demo-rs.js'); }).then((m) => m.installRs()); window.__c3demo = true; window.__c3demoReady = Promise.all([repReady, import('./c3-demo-brief-ix.js')]).then(([, m]) => m.installBriefIx()).then(() => import('./c3-demo-misc2.js')).then((m) => m.installMisc2()).then(() => import('./c3-demo-brief-page.js')).then((m) => m.installBriefPage()); }   // Briefing case files, people and a simulated agent (c3-shell.js waits for __c3demoReady)