create-pmos 0.127.0 → 0.128.0

package/workspace/lib/report-dashboards.js

@@ -0,0 +1,194 @@
+'use strict';
+/* report-dashboards.js — the Reports dashboards of /c3.html (console3 Reports). Pure except the layout store.
+ *
+ *   LIBRARY · DEFAULTS                           the seven reports and which ones each scope shows until the PM changes it
+ *   boardOf(ini, fallbackSlug)                   the board an initiative sits on
+ *   currentQuarter(today)                        { start, end } of the quarter that holds today
+ *   deliveryRows(inis, range, today, filterFn)   rows in the shape deliveryCard of public/pm/c3-cal-strategy.js reads
+ *   scopeFilter(body, facts, scope, id, today, opts)   the /api/c3-strategy body narrowed to a scope, plus delivery and range
+ *   validKey · readLayouts · writeLayout         the layout store: <runtimeDir>/report-dashboards/layouts.json
+ *
+ * The layout store is the only I/O. It writes under the runtime directory the caller names, with a temp file and a rename, and never
+ * touches the repository. Everything else reads values it is handed. */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const model = require('../../scripts/calendar-model.js');
+
+const ALL = ['portfolio', 'board', 'initiative'];
+const LIBRARY = Object.freeze([
+  { id: 'north', title: 'North star', question: 'Is the one number we steer by moving toward its target?', source: 'KR metric records', scopes: ['portfolio'] },
+  { id: 'outcomes', title: 'Quarter outcomes', question: 'Which key results are on their line, and which are behind?', source: 'KR metric records', scopes: ALL.slice() },
+  { id: 'signals', title: 'Early signals', question: 'What is drifting before it becomes a miss?', source: 'Signal rules and KR metric records', scopes: ALL.slice() },
+  { id: 'delivery', title: 'Delivery against promise', question: 'Will each initiative land by the date we promised?', source: 'Initiative records', scopes: ALL.slice() },
+  { id: 'maturity', title: 'Maturity by pillar', question: 'How mature is each pillar, and which one lags?', source: 'Pillar maturity record', scopes: ['portfolio'] },
+  { id: 'bets', title: 'Bets and checkpoints', question: 'Which bets are placed in which quarter, and when do we review them?', source: 'Bet and hypothesis records', scopes: ALL.slice() },
+  { id: 'synergy', title: 'Synergy coverage', question: 'Which key results have no active bet behind them?', source: 'Bet and KR metric records', scopes: ALL.slice() },
+].map((r) => Object.freeze({ ...r, scopes: Object.freeze(r.scopes) })));
+const IDS = LIBRARY.map((r) => r.id);
+
+const DEFAULTS = Object.freeze({
+  portfolio: Object.freeze(['north', 'outcomes', 'signals', 'delivery', 'maturity', 'bets']),
+  board: Object.freeze(['outcomes', 'signals', 'delivery', 'bets']),
+  initiative: Object.freeze(['signals', 'delivery', 'bets']),
+});
+
+const ID_RE = /^[A-Za-z0-9._-]{1,80}$/;
+const pad = (n) => String(n).padStart(2, '0');
+const isDate = (s) => typeof s === 'string' && /^\d{4}-\d{2}-\d{2}/.test(s) && !Number.isNaN(Date.parse(s.slice(0, 10) + 'T00:00:00Z'));
+const DAY = 864e5;
+const ms = (s) => Date.parse(String(s).slice(0, 10) + 'T00:00:00Z');
+
+/** The board of an initiative: the domain of a `domain:<id>` anchor, else the fallback slug (the workspace). */
+function boardOf(ini, fallbackSlug) {
+  const a = ini && typeof ini.parent_kr === 'string' ? ini.parent_kr.trim() : '';
+  const m = /^domain:([A-Za-z0-9][A-Za-z0-9._-]{0,79})$/.exec(a);
+  if (m) return m[1];
+  return fallbackSlug == null || fallbackSlug === '' ? null : String(fallbackSlug);
+}
+
+function currentQuarter(today) {
+  const r = model.rangeFor('quarter', String(today).slice(0, 10));
+  return { start: r.start, end: r.end };
+}
+
+/* ---- delivery ------------------------------------------------------------------------------------------------------------------ */
+const STATUS = { 'on time': 'ok', 'at risk': 'risk', delayed: 'late', overdue: 'over' };
+const isParked = (i) => i.parked === true || i.lane === 'parked' || i.stage === 'parked' || i.status === 'parked';
+
+/** Rows for the Delivery against promise card. Only initiatives with a promised date; no plan, no row. Dates are YYYY-MM-DD. */
+function deliveryRows(inis, range, today, filterFn) {
+  const list = (inis || []).filter((i) => i && i.id && (typeof filterFn !== 'function' || filterFn(i)));
+  const byId = new Map(list.map((i) => [i.id, i]));
+  const gantt = model.ganttRows(list, 'quarter', range.start, { today });
+  const rows = [];
+  for (const g of gantt) {
+    const ini = byId.get(g.id) || {};
+    if (!g.promised) continue;
+    let st = STATUS[g.status];
+    if (ini.done) st = 'done';
+    else if (isParked(ini)) st = 'park';
+    if (!st) continue;
+    const fc = (g.forecast && (g.forecast.end || g.forecast.start)) || g.promised;
+    const start = (g.planned && g.planned.start) || g.promised;
+    const p = typeof ini.progress === 'number' ? ini.progress : typeof ini.pct === 'number' ? ini.pct : null;
+    const late = st === 'over' ? Math.max(1, Math.round((ms(today) - ms(g.promised)) / DAY)) : 0;
+    rows.push({ id: g.id, n: g.title || g.id, kind: 'init', start, due: g.promised, fc, pct: p !== null && p >= 0 && p <= 1 ? p : null, st,
+      why: (g.title || g.id) + ': ' + g.status + (g.slip_days > 0 ? ', ' + g.slip_days + ' days past the plan' : ''), late, go: g.id });
+  }
+  return rows;
+}
+
+/* ---- scope filter -------------------------------------------------------------------------------------------------------------- */
+function notesOf(cols, rows) {
+  const notes = [];
+  cols.forEach((c, j) => { if (!rows.some((r) => !r.parked && r.weights[j] > 0)) notes.push({ icon: 'alert', tone: 'bad', text: c.n + ' has no active bet.' }); });
+  rows.forEach((r) => { if (!r.weights.some((w) => w > 0)) notes.push({ icon: 'info', tone: 'warn', text: r.title + ' is not anchored to a KR metric, so it adds to no outcome.' }); });
+  return notes;
+}
+
+/**
+ * Narrow the c3-strategy body to a scope.
+ *   portfolio  everything
+ *   board      bets and timeline rows whose initiative sits on the board; the key results those bets name; their signals
+ *   initiative the bets of that initiative; the key results its parent_kr or its bets name; its own delivery row
+ * Rule signals ('rule:...') and the north star stay at portfolio. Checkpoints narrow only when opts.hypotheses (the hypothesis records) is
+ * given, because the body carries no initiative for a checkpoint; without it a board or initiative shows none.
+ * opts: { slug (the workspace slug, the board of an initiative with no domain anchor), hypotheses }.
+ */
+function scopeFilter(body, facts, scope, id, today, opts = {}) {
+  const b = body || {};
+  const inis = (facts && facts.inis) || [];
+  const range = currentQuarter(today);
+  const slug = opts.slug;
+  const base = { ...b, scope, id: scope === 'portfolio' ? null : id, today, range };
+  if (scope === 'portfolio') return { ...base, delivery: { rows: deliveryRows(inis, range, today) } };
+
+  let onScope;
+  if (scope === 'board') onScope = (i) => boardOf(i, slug) === id;
+  else if (scope === 'initiative') onScope = (i) => i.id === id;
+  else throw new Error('scope must be portfolio, board or initiative');
+  const iniIds = new Set(inis.filter(onScope).map((i) => i.id));
+  const tl = b.timeline || { rows: [] };
+  const syn = b.synergy || { columns: [], rows: [] };
+  const betIds = new Set(syn.rows.filter((r) => r.initiative && iniIds.has(r.initiative)).map((r) => r.id));
+  tl.rows.forEach((r) => { if (r.initiative && iniIds.has(r.initiative)) betIds.add(r.id); });
+
+  // the key results: those the scoped bets name (by rid or by metric name), plus, for an initiative, its own anchor
+  const outcomes = b.outcomes || [];
+  const named = new Set();
+  const nameKr = (ref) => { if (!ref) return; const s = String(ref); outcomes.forEach((o) => { if (o.id === s || o.name === s) named.add(o.id); }); };
+  syn.rows.forEach((r, i) => { if (betIds.has(r.id)) syn.columns.forEach((c, j) => { if (r.weights[j] > 0) named.add(c.id); }); });
+  tl.rows.forEach((r) => { if (betIds.has(r.id)) nameKr(r.sub); });
+  if (scope === 'initiative') inis.filter(onScope).forEach((i) => nameKr(i.parent_kr));
+  const krs = new Set(outcomes.filter((o) => named.has(o.id)).map((o) => o.id));
+
+  const cols = syn.columns.map((c, j) => ({ c, j })).filter((x) => krs.has(x.c.id));
+  const rows = syn.rows.filter((r) => betIds.has(r.id)).map((r) => ({ ...r, weights: cols.map((x) => r.weights[x.j]) }));
+  const synergy = b.synergy && rows.length ? { ...syn, columns: cols.map((x) => x.c), rows, notes: notesOf(cols.map((x) => x.c), rows) } : null;
+
+  const trows = tl.rows.filter((r) => betIds.has(r.id));
+  let cps = [];
+  if (Array.isArray(opts.hypotheses)) {
+    const labels = new Set(opts.hypotheses.filter((h) => h && h.initiative && iniIds.has(h.initiative) && isDate(h.review_by)).map((h) => String(h.title) + ', ' + String(h.review_by).slice(0, 10)));
+    cps = (tl.checkpoints || []).filter((c) => labels.has(c.label));
+  }
+  const timeline = b.timeline && (trows.length || cps.length) ? { ...tl, rows: trows, checkpoints: cps } : null;
+
+  const signals = (b.signals || []).filter((s) => /^kr:/.test(s.id) && krs.has(s.id.slice(3)));
+  const out = {
+    ...base, north: null, outcomes: outcomes.filter((o) => krs.has(o.id)), signals, synergy, timeline,
+    sources: { ...(b.sources || {}), kr_metrics: krs.size, bets: betIds.size, hypotheses: cps.length },
+    delivery: { rows: deliveryRows(inis, range, today, onScope) },
+  };
+  return out;
+}
+
+/* ---- layout store -------------------------------------------------------------------------------------------------------------- */
+const validKey = (key) => typeof key === 'string' && (key === 'portfolio' || /^(?:board|initiative):[A-Za-z0-9._-]{1,80}$/.test(key));
+const validId = (id) => typeof id === 'string' && ID_RE.test(id);
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'report-dashboards');
+const fileOf = (runtimeDir) => path.join(dirOf(runtimeDir), 'layouts.json');
+
+/** { [key]: [reportId] }. A missing or damaged file reads as no layouts; an entry that is not valid is dropped. */
+function readLayouts(runtimeDir) {
+  let raw;
+  try { raw = JSON.parse(fs.readFileSync(fileOf(runtimeDir), 'utf8')); } catch { return {}; }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const src = raw.layouts && typeof raw.layouts === 'object' ? raw.layouts : raw;
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!validKey(k) || !Array.isArray(v)) continue;
+    const ids = [...new Set(v.filter((x) => IDS.includes(x)))];
+    out[k] = ids;
+  }
+  return out;
+}
+
+/** Store the reports for a key, or drop the key when reports is null. Returns { ok, layouts } or { ok:false, error }. */
+function writeLayout(runtimeDir, key, reports) {
+  if (!runtimeDir || typeof runtimeDir !== 'string') return { ok: false, error: 'no runtime directory' };
+  if (!validKey(key)) return { ok: false, error: 'key must be portfolio, board:<id> or initiative:<id>' };
+  let list = null;
+  if (reports !== null) {
+    if (!Array.isArray(reports)) return { ok: false, error: 'reports must be a list of report ids, or null to reset' };
+    const bad = reports.find((r) => typeof r !== 'string' || !IDS.includes(r));
+    if (bad !== undefined) return { ok: false, error: 'unknown report id: ' + String(bad).slice(0, 80) };
+    list = [...new Set(reports)];
+  }
+  const layouts = readLayouts(runtimeDir);
+  if (list === null) delete layouts[key]; else layouts[key] = list;
+  const dir = dirOf(runtimeDir);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = path.join(dir, 'layouts.json.' + process.pid + '.' + crypto.randomBytes(4).toString('hex') + '.tmp');
+  try {
+    fs.writeFileSync(tmp, JSON.stringify({ layouts }, null, 2) + '\n');
+    fs.renameSync(tmp, fileOf(runtimeDir));
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* nothing to remove */ }
+    return { ok: false, error: 'the layout could not be saved: ' + String((e && e.message) || e) };
+  }
+  return { ok: true, layouts };
+}
+
+module.exports = { LIBRARY, DEFAULTS, boardOf, currentQuarter, deliveryRows, scopeFilter, validKey, validId, readLayouts, writeLayout };

package/workspace/lib/route-modules.js

@@ -58,6 +58,7 @@ const MODULES = Object.freeze([
   'routes-c3-timeline',   // console3 Initiatives Timeline of /c3.html: every check of the plan as a whole frame, three sources in one Gantt (read-only)
   'routes-c3-life',       // console3 Lifecycle lens panels: newest evaluation per initiative, corrections per run, evidence sources (read-only)
   'routes-c3-strategy',   // console3 Calendar Quarter and Year panes: outcomes, north star, signals, synergy, bets (read-only)
+  'routes-c3-reports',    // console3 Reports dashboards: library, per-scope data, page-press layouts (layouts are the only write)
   'routes-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');

package/workspace/lib/routes-c3-reports.js

@@ -0,0 +1,108 @@
+'use strict';
+/* routes-c3-reports.js — the Reports dashboards of /c3.html (console3 Reports). The only write is a layout, by a page press.
+ *
+ *   GET  /api/report-dashboards?ws=                     → { ok, library, layouts, defaults, boards: [{ id, title }], initiatives: [{ id, title, board }] }
+ *   GET  /api/report-dashboards/data?scope=&id=&ws=     → the GET /api/c3-strategy body narrowed to the scope, plus delivery: { rows }, range: { start, end },
+ *                                                          and scope, id, today echoed. 400 on a bad scope or a missing id; 404 for an id nothing holds.
+ *   POST /api/report-dashboards/layout { key, reports }  → { ok, key, reports, layouts }   reports: null resets the key to its default.
+ *                                                          400 on an unknown key or report id; 403 without a page press.
+ *
+ * Initiatives come from the workspace's facts (lib/facts-async.js), like routes-calendar-views.js. Key results, bets and hypotheses
+ * come from the same records as routes-c3-strategy.js. The handlers are pure over their inputs so a test needs no server.
+ */
+const path = require('path');
+const guard = require('./pm-guard.js');
+const strategy = require('./routes-c3-strategy.js');
+const rd = require('./report-dashboards.js');
+
+const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });
+const pad = (n) => String(n).padStart(2, '0');
+const todayStr = () => { const d = new Date(); return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()); };
+const cap = (s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
+
+/** boards and initiatives from the facts. A board is boardOf(ini, slug); its title is its id, capitalised. */
+function catalogue(facts, slug) {
+  const inis = ((facts && facts.inis) || []).filter((i) => i && i.id);
+  const initiatives = inis.map((i) => ({ id: String(i.id), title: String(i.title || i.id), board: rd.boardOf(i, slug) }));
+  const seen = new Map();
+  initiatives.forEach((i) => { if (i.board && !seen.has(i.board)) seen.set(i.board, { id: i.board, title: cap(i.board) }); });
+  return { boards: [...seen.values()], initiatives };
+}
+
+function list({ facts, runtimeDir, slug }) {
+  const c = catalogue(facts, slug);
+  return { status: 200, body: { ok: true, library: rd.LIBRARY, layouts: rd.readLayouts(runtimeDir), defaults: rd.DEFAULTS, boards: c.boards, initiatives: c.initiatives } };
+}
+
+/** query { scope, id }; deps { facts, build() → the c3-strategy body, today, slug, hypotheses }. */
+function data(query, deps) {
+  const scope = query && query.scope; const id = query && query.id;
+  if (!['portfolio', 'board', 'initiative'].includes(scope)) return fail(400, 'scope must be portfolio, board or initiative');
+  if (scope !== 'portfolio') {
+    if (typeof id !== 'string' || !id) return fail(400, 'id is required for the ' + scope + ' scope');
+    if (!rd.validId(id)) return fail(400, 'id is not a valid id');
+    const c = catalogue(deps.facts, deps.slug);
+    const found = scope === 'board' ? c.boards.some((b) => b.id === id) : c.initiatives.some((i) => i.id === id);
+    if (!found) return fail(404, 'no ' + scope + ' has the id ' + id);
+  }
+  const today = deps.today || todayStr();
+  try {
+    const body = deps.build(today);
+    return { status: 200, body: rd.scopeFilter(body, deps.facts, scope, id || null, today, { slug: deps.slug, hypotheses: deps.hypotheses }) };
+  } catch (e) { return fail(500, String((e && e.message) || e)); }
+}
+
+function layout(req, body, runtimeDir) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return fail(g.status, g.error);
+  if (!rd.validKey(body.key)) return fail(400, 'key must be portfolio, board:<id> or initiative:<id>');
+  if (!('reports' in body)) return fail(400, 'reports must be a list of report ids, or null to reset');
+  const r = rd.writeLayout(runtimeDir, body.key, body.reports);
+  if (!r.ok) return fail(/could not be saved|no runtime/.test(r.error) ? 500 : 400, r.error);
+  return { status: 200, body: { ok: true, key: body.key, reports: r.layouts[body.key] || null, layouts: r.layouts } };
+}
+
+const rootOf = (ctx) => (ctx && ctx.recordsDir) || path.join((ctx && ctx.repoRoot) || path.join(__dirname, '..', '..'), 'planning', 'records');
+
+async function readFacts(w) {
+  return require('./facts-async.js').readFactsAsync(path.resolve(w.root));
+}
+
+module.exports = {
+  prefixes: ['/api/report-dashboards'],
+  catalogue, list, data, layout,
+  handle: async (req, res, url, ctx) => {
+    const p = url.pathname;
+    const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+    if (p === '/api/report-dashboards' || p === '/api/report-dashboards/data') {
+      if (req.method !== 'GET') return send(fail(405, 'GET only'));
+      const w = ctx.getWs(url.searchParams.get('ws'));
+      if (!w) return send(fail(404, 'no workspace is registered'));
+      const slug = w.id || (w.root ? path.basename(path.resolve(w.root)) : null);
+      if (p === '/api/report-dashboards/data') {
+        const scope = url.searchParams.get('scope'); const id = url.searchParams.get('id');
+        // answer a bad request before reading the repository
+        if (!['portfolio', 'board', 'initiative'].includes(scope)) return send(fail(400, 'scope must be portfolio, board or initiative'));
+        if (scope !== 'portfolio' && !id) return send(fail(400, 'id is required for the ' + scope + ' scope'));
+      }
+      let facts;
+      try { facts = await readFacts(w); }
+      catch (e) { return send(fail(500, 'the dashboards could not read the repository: ' + (e && e.message ? e.message : String(e)))); }
+      if (p === '/api/report-dashboards') return send(list({ facts, runtimeDir: ctx.runtimeDir, slug }));
+      const root = rootOf(ctx);
+      let hypotheses = [];
+      try { hypotheses = require('../../scripts/records/index.js').list(root, 'hypotheses'); } catch { hypotheses = []; }
+      return send(data({ scope: url.searchParams.get('scope'), id: url.searchParams.get('id') }, {
+        facts, slug, hypotheses,
+        build: (today) => strategy.build(root, path.join(ctx.runtimeDir || '.', 'signals', 'signals.jsonl'), today),
+      }));
+    }
+    if (p === '/api/report-dashboards/layout') {
+      if (req.method !== 'POST') return send(fail(405, 'POST only'));
+      const got = await ctx.readJson(req);
+      if (!got.ok) return send(fail(400, 'invalid JSON body'));
+      return send(layout(req, got.body || {}, ctx.runtimeDir));
+    }
+    return false;
+  },
+};

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.127.0",
+  "version": "0.128.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-cal-strategy.js

@@ -523,6 +523,7 @@ export function dispose(host) {
 }
 
 /* The panel builders, for the other places the mockup draws the same panels (Initiatives > Lifecycle > Strategize, Reports > Product): see c3-strategy-panels.js. */
-export const PANEL_BUILDERS = { north: northCard, outcomes: outcomesCard, signals: signalsCard, synergy: synergyCard, maturity: maturityCard, bets: betsCard };
+export const PANEL_BUILDERS = { north: northCard, outcomes: outcomesCard, signals: signalsCard, synergy: synergyCard, maturity: maturityCard, bets: betsCard,
+  delivery: deliveryCard };
 export { readModel, fresh as modelFresh, dstr as todayStr };
 export const cachedModel = () => (fresh() ? cache.model : null);

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

@@ -0,0 +1,97 @@
+/* pm/c3-demo-rep3.js — DEMO answers for the Reports dashboards (c3-reports.js) on /c3.html?demo=1.
+ *
+ *   GET  /api/report-dashboards            the library of seven reports, the defaults, two boards and five initiatives
+ *   GET  /api/report-dashboards/data       the Calendar's demo strategy answer (c3-demo-cal3.js STRATEGY) narrowed to the scope
+ *   POST /api/report-dashboards/layout     checks the key and the report ids as the real route does (400 on an unknown one), and
+ *                                          keeps the layout in this tab's sessionStorage, so a reload shows it. Nothing reaches the server.
+ *   POST /api/outbox/draft                 answers with an entry in the real route's shape. Nothing is queued.
+ *
+ * Wiring: c3-demo.js imports installRep3 and calls it in installDemo() AFTER its own fetch wrapper is in place, the way it installs
+ * c3-demo-rep2.js. This wrapper must sit OVER c3-demo.js's: that wrapper answers every non-GET with { ok: true }, so a wrapper under it
+ * (as c3-demo-cal3.js is, for a GET) would never see the layout POST. Real mode never loads this file.
+ * The board and initiative narrowing is the demo's own: the real route narrows by boardOf(ini) in lib/report-dashboards.js. */
+import { STRATEGY } from './c3-demo-cal3.js';
+
+const LIBRARY = [
+  { id: 'north', title: 'North star', question: 'Is the north-star metric on its plan?', source: 'KR metric readings', scopes: ['portfolio'] },
+  { id: 'outcomes', title: 'Quarter outcomes', question: 'Where is each key result, where should it be, and where will it land?', source: 'KR metric records', scopes: ['portfolio', 'board', 'initiative'] },
+  { id: 'signals', title: 'Early signals', question: 'What is drifting before the numbers say so?', source: 'Signal rules and KR readings', scopes: ['portfolio', 'board', 'initiative'] },
+  { id: 'delivery', title: 'Delivery against promise', question: 'Which promised dates will hold?', source: 'Initiative plans and promised dates', scopes: ['portfolio', 'board', 'initiative'] },
+  { id: 'maturity', title: 'Maturity by pillar', question: 'Where does each pillar stand against its target?', source: 'Pillar maturity records', scopes: ['portfolio'] },
+  { id: 'bets', title: 'Bets and their checkpoints', question: 'When does each bet persevere or pivot?', source: 'Bets and hypotheses', scopes: ['portfolio', 'board', 'initiative'] },
+  { id: 'synergy', title: 'Synergy and coverage', question: 'Do the bets add up to the key results?', source: 'Bets and their parent KR', scopes: ['portfolio', 'board'] },
+];
+const DEFAULTS = { portfolio: ['north', 'outcomes', 'signals', 'delivery', 'bets', 'synergy', 'maturity'], board: ['outcomes', 'delivery', 'signals', 'bets', 'synergy'], initiative: ['delivery', 'signals', 'outcomes', 'bets'] };
+const BOARDS = [{ id: 'shop', title: 'Shop' }, { id: 'enterprise', title: 'Enterprise' }];
+const INITIATIVES = [{ id: 'checkout', title: 'Checkout v2', board: 'shop' }, { id: 'search', title: 'Search relevance', board: 'shop' }, { id: 'returns', title: 'Returns experience', board: 'shop' },
+  { id: 'onb', title: 'Self-serve onboarding', board: 'shop' }, { id: 'sso', title: 'SSO and SCIM', board: 'enterprise' }];
+/* which initiatives each demo signal is about (the rule's subject); 'rel' is about the whole portfolio */
+const SIG_INI = { conv: ['checkout'], ret: ['returns'], slip: ['checkout'], churn: ['checkout'], dep: ['checkout', 'sso'], gate: ['search'], ent: ['sso'] };
+const KEY = 'pmos.c3.demo.rep3.layouts';
+const RANGE = { start: '2026-10-01', end: '2026-12-31' };
+
+const store = {
+  read() { try { return JSON.parse(sessionStorage.getItem(KEY) || '{}') || {}; } catch { return {}; } },
+  write(v) { try { sessionStorage.setItem(KEY, JSON.stringify(v)); } catch { /* no storage: the page keeps the layout itself */ } },
+};
+
+function scoped(scope, id) {
+  const S = STRATEGY;
+  const base = { ok: true, demo: true, scope, id: id || null, today: S.today, range: RANGE };
+  if (scope == 'portfolio') return { ...base, north: S.north, outcomes: S.outcomes, signals: S.signals, synergy: S.synergy, timeline: S.timeline, maturity: S.maturity, delivery: S.delivery, sources: S.sources };
+  const set = new Set(scope === 'board' ? INITIATIVES.filter((x) => x.board === id).map((x) => x.id) : INITIATIVES.some((x) => x.id === id) ? [id] : []);
+  const rows = S.synergy.rows.filter((r) => set.has(r.initiative));
+  const cols = S.synergy.columns.map((c, j) => rows.some((r) => r.weights[j] > 0));
+  const pillars = new Set(S.synergy.columns.filter((_, j) => cols[j]).map((c) => c.n));
+  return { ...base,
+    north: null, maturity: null,
+    outcomes: S.outcomes.filter((k) => pillars.has(k.pillar)),
+    signals: S.signals.filter((s) => (SIG_INI[s.id] || []).some((i) => set.has(i))),
+    synergy: { ...S.synergy, columns: S.synergy.columns.filter((_, j) => cols[j]), rows: rows.map((r) => ({ ...r, weights: r.weights.filter((_, j) => cols[j]) })), notes: [] },
+    timeline: { ...S.timeline, rows: S.timeline.rows.filter((r) => set.has(r.initiative)), checkpoints: set.has('returns') ? S.timeline.checkpoints.slice(0, 1) : [] },
+    delivery: { rows: S.delivery.rows.filter((r) => r.kind === 'init' && set.has(r.id)) },
+  };
+}
+
+const json = (body, status) => new Response(JSON.stringify(body), { status: status || 200, headers: { 'content-type': 'application/json' } });
+const KEY_RE = /^(portfolio|board:([\w.-]+)|initiative:([\w.-]+))$/;
+function layout(b) {
+  const m = KEY_RE.exec(String(b.key || ''));
+  if (!m || (m[2] && !BOARDS.some((x) => x.id === m[2])) || (m[3] && !INITIATIVES.some((x) => x.id === m[3]))) return json({ ok: false, error: 'unknown dashboard key: ' + b.key }, 400);
+  const L = store.read();
+  if (b.reports === null) { delete L[b.key]; store.write(L); return json({ ok: true, key: b.key, reports: null }); }
+  if (!Array.isArray(b.reports)) return json({ ok: false, error: 'reports must be a list of report ids, or null' }, 400);
+  const bad = b.reports.find((r) => !LIBRARY.some((x) => x.id === r));
+  if (bad !== undefined) return json({ ok: false, error: 'unknown report id: ' + bad }, 400);
+  L[b.key] = [...new Set(b.reports)]; store.write(L);
+  return json({ ok: true, key: b.key, reports: L[b.key] });
+}
+let seq = 0;
+function draft(b) {
+  if (!b.body || !String(b.body).trim()) return json({ ok: false, error: 'body required' }, 400);
+  return json({ ok: true, entry: { id: 'out-demo-rep3-' + (++seq), channel: b.channel, recipient: b.recipient || null, subject: b.subject || '', body: b.body, origin: 'pm', state: 'queued', hash: 'demo' + seq, claims: { ok: true, refused: [] }, last_result: null } });
+}
+
+export function installRep3() {
+  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) {
+        if (method === 'GET' && u.pathname === '/api/report-dashboards') return Promise.resolve(json({ ok: true, library: LIBRARY, layouts: store.read(), defaults: DEFAULTS, boards: BOARDS, initiatives: INITIATIVES }));
+        if (method === 'GET' && u.pathname === '/api/report-dashboards/data') {
+          const scope = u.searchParams.get('scope') || 'portfolio'; const id = u.searchParams.get('id') || '';
+          if (!['portfolio', 'board', 'initiative'].includes(scope)) return Promise.resolve(json({ ok: false, error: 'unknown scope: ' + scope }, 400));
+          return Promise.resolve(json(scoped(scope, id)));
+        }
+        if (method === 'POST' && (u.pathname === '/api/report-dashboards/layout' || u.pathname === '/api/outbox/draft')) {
+          let b = {}; try { b = init && init.body ? JSON.parse(init.body) : {}; } catch { b = {}; }
+          return Promise.resolve(u.pathname === '/api/outbox/draft' ? draft(b) : layout(b));
+        }
+      }
+    } catch { /* an unreadable request goes on as it is */ }
+    return prev(input, init);
+  };
+}

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

@@ -22,6 +22,7 @@ import './c3-demo-life.js';     // Lifecycle panels: ideas, hypotheses, lessons,
 import './c3-demo-misc2.js';   // Work Today lens as the mockup's; the Reflect lens's "What I could stop" (installMisc2 wraps the fetch after the briefing fixtures)
 import { timeline } from './c3-demo-time.js';   // Initiatives Timeline: every check as a frame, in the real /api/c3-timeline shape
 import './c3-demo-plan2.js';   // Commitments, Why it slips, Dependencies and Releases of Deliver: sets window.__c3planfx (c3-plan-panels.js, timeline-forecast-view.js, releases-view.js read it in demo only)
+import { installRep3 } from './c3-demo-rep3.js';   // Reports dashboards: GET /api/report-dashboards and /data, POST layout (installed OVER this file's wrapper, see its header)
 
 const realFetch = window.fetch.bind(window);
 
@@ -110,4 +111,4 @@ export function demoPill() {
 }
 
 export const DEMO_WS = D.WS_ID;
-export function installDemo() { freezeClock(); install(); installInit(); import('./c3-demo-rep2.js').then((m) => m.installRep2()); window.__c3demo = true; window.__c3demoReady = import('./c3-demo-brief-ix.js').then((m) => m.installBriefIx()).then(() => import('./c3-demo-misc2.js')).then((m) => m.installMisc2()); }   // Briefing case files, people and a simulated agent (c3-shell.js waits for __c3demoReady)
+export function installDemo() { freezeClock(); install(); installRep3(); installInit(); import('./c3-demo-rep2.js').then((m) => m.installRep2()); window.__c3demo = true; window.__c3demoReady = import('./c3-demo-brief-ix.js').then((m) => m.installBriefIx()).then(() => import('./c3-demo-misc2.js')).then((m) => m.installMisc2()); }   // Briefing case files, people and a simulated agent (c3-shell.js waits for __c3demoReady)

package/workspace/public/pm/c3-reports.css

@@ -0,0 +1,62 @@
+/* pm/c3-reports.css — the Reports dashboards of the console3 page (c3-reports.js links it once, as ensureC3Css links console3.css).
+ * Tokens only. Corners: 6px on a control, 8px on a container, else 0 (R27 as amended 2026-10-07). The console3 primitives (.card, .seg,
+ * .fold, .nrow, .xp) come from console3.css; this file adds the page's own layout under .rp3. */
+.rp3{display:grid;gap:var(--sp-4);min-width:0;align-content:start}
+.rp3-intro{margin:0;color:var(--muted-foreground);font-size:var(--fs-3)}
+.rp3-pane{display:grid;gap:var(--sp-4);min-width:0;align-content:start}
+.rp3-pane[hidden]{display:none}
+.rp3 .rp3-tabs{justify-self:start;flex-wrap:wrap;max-width:100%}
+.rp3 .rp3-tabs button[aria-selected="true"]{background:var(--background);color:var(--foreground);box-shadow:0 0 0 1px var(--border)}
+.rp3 .rp3-tabs .tag{margin-left:2px}
+.rp3-bar{display:flex;flex-wrap:wrap;gap:8px 12px;align-items:center;min-width:0}
+.rp3 .rp3-scope{flex-wrap:wrap;max-width:100%}
+.rp3-pick{display:inline-flex;gap:8px;align-items:center;min-width:0;max-width:100%;font-size:var(--fs-2)}
+.rp3-select{min-width:0;max-width:100%;min-height:32px;border:1px solid var(--border);border-radius:6px;background:var(--background);color:var(--foreground);font:var(--fs-2) var(--mono);padding:4px 8px}
+.rp3-select:disabled{opacity:.6;cursor:not-allowed}
+.rp3-head{display:flex;flex-wrap:wrap;gap:8px 12px;align-items:center;justify-content:space-between;min-width:0}
+.rp3-ttl{display:grid;gap:2px;min-width:0}
+.rp3-ttl h2{margin:0;font:600 var(--fs-5)/1.3 var(--sans);overflow-wrap:anywhere}
+.rp3-ttl .dim{font:var(--fs-2) var(--mono)}
+.rp3-acts{display:flex;flex-wrap:wrap;gap:6px;align-items:center}
+.rp3-btn{display:inline-flex;gap:6px;align-items:center;min-height:32px;padding:4px 10px;border:1px solid var(--border);border-radius:6px;background:var(--background);color:var(--foreground);font:500 var(--fs-2) var(--mono);cursor:pointer}
+.rp3-btn[aria-pressed="true"],.rp3-btn.rp3-pri{background:var(--foreground);color:var(--background);border-color:var(--foreground)}
+.rp3-btn:disabled{opacity:.5;cursor:not-allowed}
+.rp3-btn:focus-visible,.rp3-select:focus-visible,.rp3-about:focus-visible,.rp3-librow:focus-visible{outline:2px solid color-mix(in oklab, var(--ring) 50%, var(--foreground));outline-offset:2px}
+.rp3-ib{padding:4px 6px}
+.rp3-rot .ic{transform:rotate(90deg)}
+@media (hover:hover){
+.rp3-btn:not(:disabled):hover{border-color:var(--ring)}
+.rp3-about:hover{color:var(--foreground)}
+}
+@media (pointer:coarse){
+.rp3-btn,.rp3-select{min-height:44px}
+.rp3-about{min-height:44px}
+.rp3-librow{min-height:48px}
+}
+.rp3-note{margin:0;font-size:var(--fs-3)}
+.rp3-status{margin:0;font-size:var(--fs-2)}
+.rp3-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,440px),1fr));gap:var(--sp-4);align-items:start;min-width:0}
+.rp3-w{display:grid;gap:6px;min-width:0;align-content:start}
+.rp3-w>.card{min-width:0}
+.rp3-w svg{max-width:100%}
+.rp3.editing .rp3-w{outline:1px dashed var(--ring);outline-offset:6px;border-radius:8px}
+.rp3-wh{display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;justify-content:space-between;min-width:0}
+.rp3-wt{font:600 var(--fs-3) var(--sans);overflow-wrap:anywhere}
+.rp3-about{display:flex;gap:6px;align-items:center;color:var(--muted-foreground);font:var(--fs-2) var(--mono);cursor:pointer;padding:4px 2px;border-radius:6px}
+.rp3-case{display:grid;gap:6px;padding:8px 2px 4px;font-size:var(--fs-3)}
+.rp3-case p{margin:0}
+.rp3-add .sh h3{margin:0;font:600 var(--fs-3) var(--sans)}
+.rp3-addrow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:10px;align-items:center;padding:8px 2px;border-bottom:1px solid var(--border)}
+.rp3-librow .tt{font-size:var(--fs-4)}
+.rp3-libcard{padding-top:10px;min-width:0}
+.rp3-share{display:grid;gap:var(--sp-4);min-width:0}
+.rp3-frame{border:1px solid var(--border);background:var(--card);border-radius:8px;padding:14px;display:grid;gap:12px;min-width:0}
+.rp3-frame h4{margin:0 0 4px;padding-bottom:4px;border-bottom:1px solid var(--border);font:500 var(--fs-1) var(--mono);text-transform:uppercase;letter-spacing:.07em;color:var(--muted-foreground)}
+.rp3-frame h5{margin:8px 0 2px;font:600 var(--fs-3) var(--sans)}
+.rp3-frame p{margin:0;overflow-wrap:anywhere}
+.rp3-hl{font:600 var(--fs-4)/1.35 var(--sans)}
+.rp3-nums{margin:4px 0 0;padding-left:18px;color:var(--muted-foreground);font-size:var(--fs-2)}
+.rp3-why{margin:0;border-left:3px solid var(--warning);background:var(--muted);padding:8px 10px;font-size:var(--fs-2)}
+.rp3-wrap{flex-wrap:wrap}
+.ph .rp3-grid,.rp3.ph .rp3-grid{grid-template-columns:minmax(0,1fr)}
+.ph .rp3-addrow,.rp3.ph .rp3-addrow{grid-template-columns:minmax(0,1fr)}