create-pmos 0.124.0 → 0.125.0

package/workspace/lib/jobs-to-be-done.js

@@ -0,0 +1,52 @@
+'use strict';
+/* jobs-to-be-done.js — a standing need the PM serves, written as when, I want, so (planning-flows run 2).
+ *
+ * A job to be done is NOT a goal task (goals.js). A goal task is one thing to finish; a job is a need that many items
+ * serve over time. An item names a job by id (`job`), and the count is taken over every item that names it, whatever
+ * list the item is in.
+ *
+ * The append-only store has events `created`, `edited` and `deleted`. Like pm-items.js, the file is written only
+ * through appendEvent(), and the fold of the whole file is the current list. A deleted job's items are reassigned by
+ * item-edit events returned from deleteJob(), so the caller appends them in the same batch.
+ */
+const pmItems = require('./pm-items.js');
+
+// Draft a job from one line. Only the three parts the PM wrote are filled; a missing part is left empty, never invented.
+function draftJob(text) {
+  const s = String(text || '').replace(/\s+/g, ' ').trim();
+  const pick = (re) => { const m = s.match(re); return m ? m[1].trim().replace(/[,;]$/, '') : ''; };
+  return {
+    when: pick(/\bwhen\s+(.+?)(?=,?\s*I want\b|,?\s*so\b|$)/i),
+    want: pick(/\bI want\s+(.+?)(?=,?\s*so\b|$)/i),
+    so: pick(/\bso\s+(.+)$/i),
+  };
+}
+
+// Fold the job events into current jobs, keyed by id.
+function foldJobs(lines) {
+  const jobs = new Map();
+  for (const ev of lines) {
+    if (!ev || !ev.id) continue;
+    if (ev.event === 'created') jobs.set(ev.id, { ...ev.fields, id: ev.id });
+    else if (ev.event === 'edited' && jobs.has(ev.id)) jobs.set(ev.id, { ...jobs.get(ev.id), ...ev.fields });
+    else if (ev.event === 'deleted') jobs.delete(ev.id);
+  }
+  return [...jobs.values()];
+}
+
+// Deleting a job: every item that names it is reassigned to `reassignTo` (another job's id, or null for none). The
+// result is the job's `deleted` event plus one item edit per affected item, to be appended together.
+function deleteJob(jobId, items, reassignTo, now = new Date()) {
+  const at = now.toISOString();
+  const affected = items.filter((i) => i.job === jobId);
+  const edits = affected.map((i) => ({ event: 'edited', id: i.id, fields: { job: reassignTo || null }, at }));
+  return { events: [{ event: 'deleted', id: jobId, at }, ...edits], reassigned: affected.length };
+}
+
+// `done of total` for one job, over every item that names it.
+function progress(jobId, items) {
+  const mine = items.filter((i) => i.job === jobId);
+  return { done: mine.filter((i) => i.done === true).length, total: mine.length };
+}
+
+module.exports = { draftJob, foldJobs, deleteJob, progress, appendEvent: pmItems.appendEvent, readLines: pmItems.readLines };

package/workspace/lib/outbox-store.js

@@ -0,0 +1,87 @@
+'use strict';
+/* outbox-store.js — the file layer over scripts/outbox.js (console3 wave B3). Sends NOTHING.
+ *
+ *   <runtime>/outbox/outbox.jsonl    append-only; one line per event: queued | edited | pressed | sent
+ *   <runtime>/outbox/items/<id>.json the scripts/trust/outbox.js item, written only when a sender is registered
+ *   <runtime>/outbox/sent.jsonl      the trust ledger of sends (one 'send' line per send, with the override flag)
+ *   <runtime>/outbox/promises.jsonl  the promise ledger, through scripts/promises.js (scripts/trust/ledger.js)
+ *
+ * foldOutbox(lines) is pure: the latest version per id. A queued or edited line carries the state scripts/outbox.js
+ * computed from the trust claim rules: 'queued' or 'blocked'. A 'pressed' line (a PM press with no channel connected)
+ * leaves the state and records last_result. A 'pressed' or 'sent' line counts only for the hash it names, so an edit
+ * (a new hash) clears it. The send itself is scripts/trust/outbox.js (queue, confirm, execute): see executeSend.
+ */
+const fs = require('fs');
+const path = require('path');
+const outbox = require('../../scripts/outbox.js');
+const promises = require('../../scripts/promises.js');
+const T = require('../../scripts/trust/outbox.js');
+const L = require('../../scripts/trust/ledger.js');
+
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'outbox');
+const outboxFile = (runtimeDir) => path.join(dirOf(runtimeDir), 'outbox.jsonl');
+const itemsDir = (runtimeDir) => path.join(dirOf(runtimeDir), 'items');
+const sentFile = (runtimeDir) => path.join(dirOf(runtimeDir), 'sent.jsonl');
+const promisesFile = (runtimeDir) => path.join(dirOf(runtimeDir), 'promises.jsonl');
+
+function readLines(file) {
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const l of raw.split('\n')) {
+    if (!l.trim()) continue;
+    try { out.push(JSON.parse(l)); } catch { /* a torn line is skipped */ }
+  }
+  return out;
+}
+
+function foldOutbox(lines = []) {
+  const byId = new Map();
+  for (const ev of lines) {
+    if (!ev || !ev.id) continue;
+    if (ev.event === 'queued' || ev.event === 'edited') {
+      const { event, ...entry } = ev;
+      byId.set(ev.id, { ...entry, state: ev.state === 'blocked' ? 'blocked' : 'queued', last_result: null, refused: null, created_at: (byId.get(ev.id) || {}).created_at || ev.at });
+    } else if (ev.event === 'pressed' || ev.event === 'sent') {
+      const cur = byId.get(ev.id);
+      if (!cur || cur.hash !== ev.hash) continue;
+      if (ev.event === 'sent') byId.set(ev.id, { ...cur, state: 'sent', last_result: 'sent' });
+      else byId.set(ev.id, { ...cur, last_result: ev.reason || null });
+    }
+  }
+  return [...byId.values()];
+}
+
+const readOutbox = (runtimeDir) => foldOutbox(readLines(outboxFile(runtimeDir)));
+const appendEvent = (runtimeDir, event, now) => outbox.appendOutbox(outboxFile(runtimeDir), event, now);
+
+const readPromises = (runtimeDir) => readLines(promisesFile(runtimeDir));
+// `actor` comes from the call path (scripts/trust/ledger.js actorFrom); it is required, never read from the fields.
+function addPromise(runtimeDir, fields, now, actor) {
+  const ev = promises.recordPromise(fields);
+  promises.appendPromise(promisesFile(runtimeDir), ev, actor, now);
+  return ev;
+}
+function markKept(runtimeDir, sourceEntryHash, now, actor) {
+  const ev = promises.keptEvent(sourceEntryHash);
+  promises.appendPromise(promisesFile(runtimeDir), ev, actor, now);
+  return ev;
+}
+const listBroken = (runtimeDir, today) => promises.brokenPromises(readPromises(runtimeDir), today);
+
+/**
+ * The real send, only when a sender is registered. PM press (the page-press actor is the UI), then the server executes
+ * exactly what was confirmed, through scripts/trust/outbox.js. The connector runs inside execute and nowhere else.
+ */
+function executeSend(runtimeDir, entry, { reason, claimsSend }, sender, now) {
+  const dir = itemsDir(runtimeDir);
+  const ui = L.actorFrom({ ui: true });
+  const item = { id: entry.id, channel: entry.channel, to: entry.recipient, subject: entry.subject || '', body: entry.body };
+  T.queue(dir, item, ui, { send: claimsSend });
+  T.confirm(dir, entry.id, ui, { reason });
+  const r = T.execute(dir, entry.id, T.SERVER, (o) => sender(o), sentFile(runtimeDir));
+  appendEvent(runtimeDir, { event: 'sent', id: entry.id, hash: entry.hash }, now);
+  return r;
+}
+
+module.exports = { executeSend, itemsDir, sentFile, outboxFile, promisesFile, readLines, foldOutbox, readOutbox, appendEvent, readPromises, addPromise, markKept, listBroken };

package/workspace/lib/pm-items.js

@@ -0,0 +1,115 @@
+'use strict';
+/* pm-items.js — the PM's own work items (planning-flows run 1, PRD decision 2).
+ *
+ * An append-only JSONL store of items the PM adds for themselves (created here) or that came from a source
+ * (imported: Jira, Gmail, Figma, local). Nothing is edited in place: an edit, a drop and a delete are new lines,
+ * and the fold of the whole file is the current list. Stage is never stored; a list is derived from the due
+ * date, priority and waiting-on fields by placement() below.
+ *
+ * SINGLE WRITER: appendEvent() is the only function that writes the file. Callers pass the event; they never
+ * choose `at` or `by` themselves (attribution comes from the call path, as in plan-items.js).
+ */
+const fs = require('fs');
+const path = require('path');
+
+const UNDO_MS = 8000;
+const LISTS = ['waiting', 'today', 'week', 'triage', 'later'];
+const WEEKDAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+
+const DUE_WORD = /\b(?:due|by)\s+(today|tomorrow|sun(?:day)?|mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:r(?:s(?:day)?)?)?|fri(?:day)?|sat(?:urday)?)\b/i;
+function iso(d) { return d.toISOString().slice(0, 10); }
+function addDays(d, n) { const x = new Date(d.getTime()); x.setUTCDate(x.getUTCDate() + n); return x; }
+
+// Parse one line the PM typed or dictated. `today` is a Date (UTC midnight is fine). Returns the fields only; the
+// caller decides what to do with an empty title.
+function parseLine(text, today) {
+  let rest = String(text || '').trim();
+  const out = { title: '', due: null, priority: null, waiting_on: null };
+  // Priority: "P1" (as before) or the shorthand "!1", the mockup's "Try: Send Dana the new date by Fri !1".
+  const p = rest.match(/\bP([1-3])\b/i) || rest.match(/(?:^|\s)!([1-3])(?=\s|$)/);
+  if (p) { out.priority = `P${p[1]}`; rest = rest.replace(p[0], ' '); }
+  const w = rest.match(/\bwaiting on\s+([^,;]+?)(?=\s+(?:by|due|P[1-3])\b|$)/i);
+  if (w) { out.waiting_on = w[1].trim(); rest = rest.replace(w[0], ' '); }
+  const dueIso = rest.match(/\b(?:due|by)\s+(\d{4}-\d{2}-\d{2})\b/i);
+  if (dueIso) { out.due = dueIso[1]; rest = rest.replace(dueIso[0], ' '); }
+  else {
+    const word = rest.match(DUE_WORD);
+    if (word) {
+      const k = word[1].toLowerCase();
+      let d = new Date(today.getTime());
+      if (k === 'tomorrow') d = addDays(d, 1);
+      else if (k !== 'today') {
+        // The next occurrence, counting today as a match only when it is that weekday. A day may be abbreviated: Fri, Tue, Thu.
+        const diff = (WEEKDAYS.findIndex((w) => w.startsWith(k.slice(0, 3))) - d.getUTCDay() + 7) % 7;
+        d = addDays(d, diff);
+      }
+      out.due = iso(d);
+      rest = rest.replace(word[0], ' ');
+    }
+  }
+  out.title = rest.replace(/\s+/g, ' ').replace(/[,;]\s*$/, '').trim();
+  return out;
+}
+
+// Place an item in one of five lists. Waiting first (the PM is not the one who must act), then the date, then
+// undated items in Triage, then everything dated later.
+function placement(item, today) {
+  // An explicit move wins, then a park; both hold until the PM moves or unparks the item.
+  if (item.list_override && LISTS.includes(item.list_override)) return item.list_override;
+  if (item.parked) return 'later';
+  if (item.waiting_on) return 'waiting';
+  if (!item.due) return 'triage';
+  const due = item.due;
+  const t = iso(today);
+  if (due <= t) return 'today';
+  if (due <= iso(addDays(today, 7))) return 'week';
+  return 'later';
+}
+
+// Fold the event lines into the current items, keyed by id. A dropped or deleted item is removed.
+function fold(lines) {
+  const items = new Map();
+  for (const ev of lines) {
+    if (!ev || !ev.id) continue;
+    if (ev.event === 'created') items.set(ev.id, { ...ev.fields, id: ev.id, source: ev.source || 'local', created_at: ev.at });
+    else if (ev.event === 'edited' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), ...ev.fields });
+    else if (ev.event === 'done' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: true, done_at: ev.at });
+    else if (ev.event === 'reopened' && items.has(ev.id)) items.set(ev.id, { ...items.get(ev.id), done: false, done_at: null });
+    else if (ev.event === 'dropped' || ev.event === 'deleted') items.delete(ev.id);
+  }
+  return [...items.values()];
+}
+
+// The delete rule: an item created here is deleted; an imported one is only dropped from the PM's list (its source
+// keeps it). The caller passes the item's source so the rule is applied in one place.
+// The removal keeps a snapshot of the item, so an undo inside the window can restore it exactly.
+function removalEvent(item, now) {
+  const created = !item.source || item.source === 'local';
+  return { event: created ? 'deleted' : 'dropped', id: item.id, at: now.toISOString(), snapshot: { ...item } };
+}
+
+// The created event that restores the last removal of `id`, when it is still inside the undo window. Null otherwise.
+function undoEvent(lines, id, now = new Date()) {
+  const removal = [...lines].reverse().find((ev) => ev && ev.id === id && (ev.event === 'deleted' || ev.event === 'dropped'));
+  if (!removal || !removal.snapshot || !canUndo(removal.at, now)) return null;
+  const { id: _id, source, created_at, ...fields } = removal.snapshot;
+  return { event: 'created', id, fields, source: source || 'local', restored: true };
+}
+
+function canUndo(removedAt, now) {
+  return now.getTime() - new Date(removedAt).getTime() <= UNDO_MS;
+}
+
+// The one writer. The caller passes the file path and the event; `at` is set here.
+function appendEvent(file, event, now = new Date()) {
+  const line = JSON.stringify({ ...event, at: now.toISOString() }) + '\n';
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, line);
+}
+
+function readLines(file) {
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } });
+}
+
+module.exports = { UNDO_MS, LISTS, parseLine, placement, fold, removalEvent, undoEvent, canUndo, appendEvent, readLines };

package/workspace/lib/route-modules.js

@@ -38,6 +38,27 @@ const MODULES = Object.freeze([
   'routes-reports',       // Run 5 (5C): drafts, Issue, notes
   'routes-notes',         // meeting-notes Run 1: the Notes view (typed notes, dictation, transcripts, summaries)
   'routes-my-work',       // initiative my-work: the ranked list of work assigned to the PM, the brief, Read again
+  'routes-intake',        // planning-flows run 4: one-line intake draft (drafts only)
+  'routes-pm-items',      // planning-flows runs 1-2: the PM's own items and jobs to be done (add, edit, remove, undo)
+  'routes-runs',          // console3 agent surfaces: runs grouped for the sessions panel, PM answers, corrections
+  'routes-releases',      // console3 A4: releases ledger, read side
+  'routes-doc-health',    // console3 B2: the six document health checks, recomputed from text
+  'routes-outbox',        // console3 B3: the outbox queue, hash-bound confirm (no channel connected)
+  'routes-report-families', // console3 B4: the four report families and the claims check (read-only)
+  'routes-forecast',      // console3 B5: forecast, critical path, time machine and capacity (read-only)
+  'routes-calendar-views', // console3 C2: Day/Week/Month/Quarter/Year cells, Gantt and the strategy lens (read-only)
+  'routes-briefing',      // console3 C1: the day-part Briefing cards from the signal engine (read-only)
+  'routes-report-facts',  // console3 D: GET /api/report-families/facts (read-only, real data only)
+  'routes-records',       // console3 E1a: ideas, hypotheses, decisions, KR metrics, bets (GET list; page-press add/edit/reading)
+  'routes-doc-sheet',     // console3 E1c: document sheet: revisions, edit with why, propose and accept by hash
+  'routes-calendar-import', // console3 E2a: cached calendar events (page-press import; metadata only, sensitivity required)
+  'routes-roadmap-ops',   // console3 E1b: bets (add, move with swap proposal, take off, anchor suggestions), breakdown, people
+  'routes-signals',       // console3 E2a: signal rules, readings and trips
+  'routes-c3-init',       // console3 Initiatives sub-views of /c3.html: Roadmap and Breakdown reads (read-only)
+  '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-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-briefing.js

@@ -0,0 +1,100 @@
+'use strict';
+/* routes-briefing.js — GET /api/briefing?lens=Plan|Unblock|Close|Reflect&zoom=day|week|month[&now=ISO] (console3 wave C1).
+ *
+ *   { ok, lens, zoom, cards, ticker, banner }
+ *
+ * `cards` are the engine's selected cards (scripts/signals present() over readRepoFacts of the repo root), with the card
+ * anatomy untouched. `ticker` is one line per top card, built from the card's own headline and deadline. `banner` is the
+ * pinned Critical card, or null. Read-only: no write route. The default lens follows the clock. An engine failure answers
+ * { ok:false, error } with 500 and never throws out of the handler.
+ */
+const path = require('path');
+
+const LENSES = ['Plan', 'Unblock', 'Close', 'Reflect'];
+const ZOOMS = ['day', 'week', 'month'];
+
+function lensFor(date) {
+  const h = date.getHours();
+  return h < 11 ? 'Plan' : h < 14 ? 'Unblock' : h < 17 ? 'Close' : 'Reflect';
+}
+
+function tickerOf(cards) {
+  return cards.slice(0, 3).map((c) => {
+    const d = c.deadline && c.deadline.days != null ? ' (' + (c.deadline.days < 1 ? 'within a day' : Math.round(c.deadline.days) + 'd') + ')' : '';
+    return c.tag + ': ' + c.headline + d;
+  });
+}
+
+// readRepoFacts derives every initiative's stage from git (minutes for ~300 records), so one read per root and day is kept 5 minutes.
+const factsMemo = new Map();
+function factsOnce(eng, root, iso) {
+  const k = root + '|' + iso, hit = factsMemo.get(k), now = Date.now();
+  if (hit && now - hit.at < 5 * 60 * 1000) return hit.facts;
+  const facts = eng.readRepoFacts(root, { today: iso });
+  factsMemo.clear(); factsMemo.set(k, { at: now, facts });
+  return facts;
+}
+
+function loadEngine() {
+  // the engine is this repo's; `root` only says which repo's initiatives it reads
+  const sig = path.resolve(__dirname, '..', '..', 'scripts', 'signals');
+  const { present } = require(path.join(sig, 'index.js'));
+  const { readRepoFacts } = require(path.join(sig, 'facts.js'));
+  return { present, readRepoFacts };
+}
+
+/** Pure handler: (query, { root, now, load }) -> { code, body }. `load` is injectable for tests. */
+function briefing(query, opts = {}) {
+  const q = query || {};
+  const root = opts.root || path.resolve(__dirname, '..', '..');
+  let now = q.now ? new Date(q.now) : (opts.now ? new Date(opts.now) : new Date());
+  if (isNaN(now.getTime())) now = new Date();
+  const lens = LENSES.includes(q.lens) ? q.lens : lensFor(now);
+  const zoom = ZOOMS.includes(q.zoom) ? q.zoom : 'week';
+  try {
+    const eng = (opts.load || loadEngine)(root);
+    const iso = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0');
+    const facts = opts.load ? eng.readRepoFacts(root, { today: iso }) : factsOnce(eng, root, iso);
+    let useLens = lens;
+    let cards = eng.present(facts, { lens, zoom, today: iso }).cards || [];
+    // When the clock's lens has no card, show the lens that has the most (ties keep the clock's lens). On the real repo
+    // this is usually all four empty: the briefing detectors read promised dates, forecasts, holders and the like, and no
+    // initiative record carries them yet. The answer then stays empty and says so by fallback_lens being absent.
+    let fallback = false;
+    if (!cards.length && !q.lens) {
+      for (const l of LENSES) {
+        if (l === lens) continue;
+        const c = eng.present(facts, { lens: l, zoom, today: iso }).cards || [];
+        if (c.length > cards.length) { cards = c; useLens = l; fallback = true; }
+      }
+    }
+    const banner = cards.find((c) => c.pinned && c.tag === 'Critical') || null;
+    return { code: 200, body: { ok: true, lens: useLens, zoom, cards, ticker: tickerOf(cards), banner, ...(fallback ? { fallback_lens: true } : {}) } };
+  } catch (e) {
+    return { code: 500, body: { ok: false, error: 'the signal engine failed: ' + (e && e.message ? e.message : String(e)) } };
+  }
+}
+
+module.exports = {
+  prefixes: ['/api/briefing'],
+  briefing, lensFor, tickerOf,
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/briefing') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    const q = Object.fromEntries(url.searchParams.entries());
+    let root;
+    try { const w = ctx.getWs && ctx.getWs(q.ws || null); root = w && w.root; } catch { root = null; }
+    // The repo read runs in a child process (facts-async.js), so the server keeps answering while it works.
+    const useRoot = root || path.resolve(__dirname, '..', '..');
+    let now = q.now ? new Date(q.now) : new Date();
+    if (isNaN(now.getTime())) now = new Date();
+    const iso = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0');
+    let facts;
+    try { facts = await require('./facts-async.js').readFactsAsync(useRoot, { today: iso }); }
+    catch (e) { ctx.json(res, { ok: false, error: 'the signal engine failed: ' + (e && e.message ? e.message : String(e)) }, 500); return true; }
+    const eng = loadEngine();
+    const out = briefing(q, { root: useRoot, load: () => ({ present: eng.present, readRepoFacts: () => facts }) });
+    ctx.json(res, out.body, out.code);
+    return true;
+  },
+};

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

@@ -0,0 +1,53 @@
+'use strict';
+/* routes-c3-init.js — read-only data for the Initiatives sub-views of /c3.html (Roadmap and Breakdown). Nothing is written here.
+ *
+ *   GET /api/c3-init/roadmap   → { ok, bets, capacity, people, krs }   bets: the folded bets records; capacity: roadmap-ops capacityLine
+ *   GET /api/c3-init/breakdown → { ok, items, phases, sources, people, capacity, history }
+ *                                items: scripts/breakdown-ops list (PMOS-only work); capacity: capacityLoad per person over 2 weeks;
+ *                                history: the last 8 add/edit/delete/dependency events, newest first; events: all of them, oldest first (who added and changed each item).
+ * People come from <runtime>/people.json, the file routes-forecast.js and POST /api/roadmap-ops/people use. The writes are the
+ * existing POST /api/roadmap-ops/* routes, which this file does not touch. */
+const fs = require('fs');
+const path = require('path');
+const roadmapOps = require('./routes-roadmap-ops.js');
+const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
+const roadmap = require(path.join(__dirname, '..', '..', 'scripts', 'roadmap-ops.js'));
+const breakdown = require(path.join(__dirname, '..', '..', 'scripts', 'breakdown-ops.js'));
+
+function readPeople(runtimeDir) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(runtimeDir, 'people.json'), 'utf8'));
+    return (j.people || []).filter((p) => p && p.id).map((p) => ({ id: p.id, points_per_week: Number(p.points_per_week) || 5 }));
+  } catch { return []; }
+}
+
+function roadmapRead(ctx) {
+  const root = roadmapOps.rootOf(ctx);
+  const bets = records.list(root, 'bets');
+  const people = readPeople(ctx.runtimeDir);
+  const krs = records.list(root, 'kr-metrics').map((k) => ({ id: k.rid, title: k.metric }));
+  return { status: 200, body: { ok: true, bets, capacity: roadmap.capacityLine(bets, people), people, krs } };
+}
+
+function breakdownRead(ctx) {
+  const root = roadmapOps.rootOf(ctx);
+  const items = breakdown.list(root);
+  const people = readPeople(ctx.runtimeDir);
+  const events = breakdown.readLines(root).filter((e) => ['add', 'edit', 'delete', 'dependency'].includes(e.kind))
+    .map((e) => ({ kind: e.kind, rid: e.rid, why: e.why || '', at: e.at, by: e.by || '', title: (e.fields && e.fields.title) || (e.snapshot && e.snapshot.title) || '' }));
+  const history = events.slice(-8).reverse();
+  return { status: 200, body: { ok: true, items, phases: breakdown.PHASES, sources: breakdown.SOURCES, people, capacity: breakdown.capacityLoad(items, people, 2), history, events } };
+}
+
+module.exports = {
+  prefixes: ['/api/c3-init'],
+  roadmapRead, breakdownRead,
+  handle: async (req, res, url, ctx) => {
+    if (req.method !== 'GET') return false;
+    const sub = url.pathname.slice('/api/c3-init'.length);
+    const r = sub === '/roadmap' ? roadmapRead(ctx) : sub === '/breakdown' ? breakdownRead(ctx) : null;
+    if (!r) return false;
+    ctx.json(res, r.body, r.status);
+    return true;
+  },
+};

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

@@ -0,0 +1,119 @@
+'use strict';
+/* routes-c3-life.js — read-only data for the Lifecycle lens of /c3.html (the panels the lens draws beyond the stage list). Nothing is written here.
+ *
+ *   GET /api/c3-life → { ok, evals, corrections, sources, as_of }
+ *     evals:       the newest evaluation row per initiative from planning/runs/evals.jsonl:
+ *                  { [initiative_id]: { run_id, score, threshold, verdict, dimensions, evaluator_model, recorded_at, findings: [{ severity, text }] (3 at most) } }
+ *     corrections: human corrections per agent run from planning/runs/agent-runs.jsonl: { runs, corrections, series: [{ from, runs, corrections }] }
+ *                  (the last six 7-day buckets that hold a run, oldest first; a run counts in the week of its created_at)
+ *     capacity:    { points, basis } effort points for two weeks from the people file (points_per_week of each person, times two), or null when no person is recorded
+ *     sources:     for every `src` named by the evidence of a hypotheses record: true when that file exists inside the repository. A path that
+ *                  leaves the repository (`..`, an absolute path outside it) is never read and reads false.
+ * Gates need no route: GET /api/console?name=ladder&id=<initiative> already returns the ladder steps. Calibration: GET /api/console?name=radar.
+ * Repo facts are not read here (readRepoFacts is synchronous and slow); only two small JSONL files and the existence of named files are. */
+const fs = require('fs');
+const path = require('path');
+const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
+
+const REPO = path.join(__dirname, '..', '..');
+const DAY = 86400000;
+const memo = new Map();   // file -> { key, lines }
+
+/** The lines of a JSONL file, parsed; a line that does not parse is skipped. Cached by size and modified time. */
+function readJsonl(file) {
+  let st;
+  try { st = fs.statSync(file); } catch { return []; }
+  const key = st.size + ':' + st.mtimeMs;
+  const hit = memo.get(file);
+  if (hit && hit.key === key) return hit.lines;
+  const lines = [];
+  try { for (const l of fs.readFileSync(file, 'utf8').split('\n')) { if (!l.trim()) continue; try { lines.push(JSON.parse(l)); } catch { /* a bad line is skipped */ } } } catch { return []; }
+  memo.set(file, { key, lines });
+  return lines;
+}
+
+const num = (v) => typeof v === 'number' && Number.isFinite(v);
+
+/** The newest evaluation per initiative (recorded_at, then file order). Findings are cut to three short lines. */
+function latestEvals(rows) {
+  const best = {};
+  rows.forEach((r, i) => {
+    const id = r && r.initiative_id; if (!id) return;
+    const at = String(r.recorded_at || r.at || '');
+    const p = best[id];
+    if (!p || at >= p.at) best[id] = { at, i, r };
+  });
+  const out = {};
+  for (const [id, { r }] of Object.entries(best)) {
+    const dims = {};
+    if (r.dimensions && typeof r.dimensions === 'object') for (const [k, v] of Object.entries(r.dimensions)) if (num(v)) dims[k] = v;
+    out[id] = {
+      run_id: r.run_id == null ? '' : String(r.run_id), score: num(r.score) ? r.score : null,
+      threshold: num(r.threshold) ? r.threshold : num(r.pass_threshold) ? r.pass_threshold : null,
+      verdict: String(r.verdict || ''), dimensions: dims, ...(Array.isArray(r.dims) ? { dims: r.dims.filter((d) => d && num(d.score)).map((d) => ({ dim: String(d.dim || ''), w: num(d.w) ? d.w : null, score: d.score })) } : {}), evaluator_model: String(r.evaluator_model || ''), recorded_at: String(r.recorded_at || r.at || ''),
+      findings: (Array.isArray(r.findings) ? r.findings : []).filter((f) => f && typeof f === 'object' && f.text).slice(0, 3).map((f) => ({ severity: String(f.severity || ''), text: String(f.text).slice(0, 240) })),
+    };
+  }
+  return out;
+}
+
+/** Human corrections per run, in the last six 7-day buckets that hold a run. A run with no human_corrections number counts as a run with none recorded: left out. */
+function correctionSeries(rows) {
+  const runs = rows.filter((r) => r && num(r.human_corrections) && Date.parse(r.created_at || r.recorded_at || ''));
+  if (!runs.length) return { runs: 0, corrections: 0, series: [] };
+  const t = (r) => Date.parse(r.created_at || r.recorded_at);
+  const first = Math.min(...runs.map(t));
+  const buckets = new Map();
+  for (const r of runs) { const k = Math.floor((t(r) - first) / (7 * DAY)); const b = buckets.get(k) || { from: new Date(first + k * 7 * DAY).toISOString().slice(0, 10), runs: 0, corrections: 0 }; b.runs += 1; b.corrections += r.human_corrections; buckets.set(k, b); }
+  const series = [...buckets.entries()].sort((a, b) => a[0] - b[0]).map(([, b]) => b).slice(-6);
+  return { runs: runs.length, corrections: runs.reduce((a, r) => a + r.human_corrections, 0), series };
+}
+
+/** For every evidence `src` of a hypotheses record: does that file exist inside `root`? Nothing outside `root` is looked at. */
+function sourcesOf(root, hyps) {
+  const out = {};
+  const base = path.resolve(root);
+  for (const h of hyps) for (const e of (Array.isArray(h.evidence) ? h.evidence : [])) {
+    const s = e && typeof e.src === 'string' ? e.src : '';
+    if (!s || s in out) continue;
+    const abs = path.resolve(base, s);
+    out[s] = (abs === base || abs.startsWith(base + path.sep)) && fs.existsSync(abs);
+  }
+  return out;
+}
+
+/** Effort points the team holds over two weeks: the people file (<runtime>/people.json, the one routes-c3-init.js reads), points_per_week summed, times two. null when none. */
+function capacityOf(runtimeDir) {
+  let people = [];
+  try { people = (JSON.parse(fs.readFileSync(path.join(runtimeDir, 'people.json'), 'utf8')).people || []).filter((p) => p && p.id && num(Number(p.points_per_week))); } catch { people = []; }
+  if (!people.length) return null;
+  const ppw = people.reduce((a, p) => a + Number(p.points_per_week), 0);
+  return { points: ppw * 2, basis: 'Team of ' + people.length + ' at ' + ppw + ' points a week, over 2 weeks' };
+}
+
+function read(ctx) {
+  const root = (ctx && ctx.repoRoot) || REPO;
+  const recordsDir = (ctx && ctx.recordsDir) || path.join(root, 'planning', 'records');
+  let hyps = [];
+  try { hyps = records.list(recordsDir, 'hypotheses'); } catch { hyps = []; }
+  return { status: 200, body: {
+    ok: true,
+    evals: latestEvals(readJsonl(path.join(root, 'planning', 'runs', 'evals.jsonl'))),
+    corrections: correctionSeries(readJsonl(path.join(root, 'planning', 'runs', 'agent-runs.jsonl'))),
+    capacity: ctx && ctx.runtimeDir ? capacityOf(ctx.runtimeDir) : null,
+    sources: sourcesOf(root, hyps),
+    as_of: new Date().toISOString(),
+  } };
+}
+
+module.exports = {
+  prefixes: ['/api/c3-life'],
+  read, latestEvals, correctionSeries, sourcesOf, capacityOf,
+  handle: async (req, res, url, ctx) => {
+    if (req.method !== 'GET' || url.pathname !== '/api/c3-life') return false;
+    let r;
+    try { r = read(ctx); } catch (e) { r = { status: 500, body: { ok: false, error: 'the lifecycle panels could not be read: ' + String((e && e.message) || 'error').slice(0, 120) } }; }
+    ctx.json(res, r.body, r.status);
+    return true;
+  },
+};