create-pmos 0.252.0 → 0.254.0

package/workspace/lib/briefing-premium.js

@@ -0,0 +1,581 @@
+'use strict';
+/* lib/briefing-premium.js — the premium Briefing's page model, built from repository state (initiative briefing-premium, R2 to R9).
+ *
+ *   build(facts)                  → model   PURE. The hero, the ordered rows, the Today timeline, the dock and the header.
+ *   readSources({ root, now })    → facts   what the route reads. A source that cannot be read is named in `missing`, never guessed.
+ *   modelOf({ root })             → { state, model, as_of }   the route's answer: a kept snapshot, refreshed in the background.
+ *
+ * facts = { now (ms), asOf (ms), initiatives[], runs[], merges[], evals[], meetings[]|null, tripwires[]|null, missing[] }
+ *   initiatives  one per record: { id, title, lane, stage, accepted, stopped, anchor, last_activity (s), blockers[], next, steps[{key,status,next,rule}] }
+ *   runs         agent runs: { initiative_id, created_at, human_corrections }
+ *   merges       commits to the trunk: { at (ms), title }
+ *   evals        review verdicts: { initiative_id, verdict, recorded_at }
+ *   meetings     today's calendar rows: { start (ms), end (ms), title, with, initiative }, or null when the calendar cannot be read
+ *   tripwires    dated kill conditions: { id, name, date, decided }, or null when the file cannot be read
+ *
+ * THE RULE THE WHOLE FILE FOLLOWS: a sentence, a count or a "if you skip" line is made only from a record that holds it. A clause with
+ * no record is left out; nothing is softened or rounded into a claim. Every clause carries `from`, the records it came from, so a test
+ * can assert the trace rather than read it. The hero, the list and the dock read ONE list of rows (R8), so they cannot disagree.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const W = require('./briefing-premium-writes.js');
+
+const DAY = 86400000;
+const MAX_ROWS = 7;
+const WORDS = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve'];
+const num = (n) => (n >= 0 && n <= 12 ? WORDS[n] : String(n));
+const plural = (n, one, many) => (n === 1 ? one : many);
+const pad = (n) => String(n).padStart(2, '0');
+const hhmm = (ms) => { const d = new Date(ms); return pad(d.getHours()) + ':' + pad(d.getMinutes()); };
+const dayKey = (ms) => { const d = new Date(ms); return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()); };
+const startOfDay = (ms) => { const d = new Date(ms); d.setHours(0, 0, 0, 0); return d.getTime(); };
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const dateLine = (ms) => { const d = new Date(ms); return WEEKDAYS[d.getDay()] + ' ' + d.getDate() + ' ' + MONTHS[d.getMonth()]; };
+/* A short name for a sentence: the title up to its first dash, colon or bracket, without a leading article. */
+const joinNames = (a) => (a.length < 2 ? a.join('') : a.slice(0, -1).join(', ') + ' and ' + a[a.length - 1]);
+const shortName = (t) => clip(String(t || '').split(/\s[—–-]\s|:|\(/)[0].replace(/^(the|a|an)\s+/i, ''), 48);
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const shortDate = (ms) => { const d = new Date(ms); return d.getDate() + ' ' + MON[d.getMonth()]; };
+const longDate = (ms) => shortDate(ms) + ' ' + new Date(ms).getFullYear();
+const isoShort = (iso) => { const t = Date.parse(iso + 'T12:00:00'); return Number.isFinite(t) ? shortDate(t) : iso; };
+const mdClean = (s) => String(s || '').replace(/\*\*/g, '').replace(/`/g, '').replace(/\s+/g, ' ').trim();
+const clip = (s, n) => { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s; };
+
+/* What each blocked step means for the PM. The verb-first title and the consequence come from the rule the step enforces
+ * (scripts/workflow-state.js), so they state what the rule does, not a guess about the work. */
+const STEP = {
+  prototype: { title: 'Get a prototype started', skip: 'the prototype lane does not start, and the initiative stays blocked.' },
+  spec: { title: 'Put the spec ahead of the build', skip: 'the build stays ahead of the spec, so the order check keeps failing.' },
+  contract: { title: 'Agree the contract', skip: 'the contract stays unagreed, so the run has no done-criteria to check.' },
+  anchor: { title: 'Anchor the initiative', skip: 'the initiative stays unanchored, and unanchored work is rejected.' },
+  route: { title: 'Route the initiative', skip: 'the initiative has no lane, so no lane rule can run.' },
+};
+const stepOf = (key) => STEP[key] || { title: 'Unblock the ' + key + ' step', skip: 'the ' + key + ' step stays blocked.' };
+
+/* The options a decision offers. They name the choices the repository's own rules give (D41 for a tripwire, D60 for a prototype); none is marked
+ * Recommended, because no recommendation is on record. `draft` is the sentence the draft entry shows once the option is chosen. */
+const OPT_TRIPWIRE = [
+  { k: 'reshape', t: 'Reshape the bet', d: 'Change what the condition guards, and say why. It goes in pm-decisions.md.', draft: 'Recorded as a draft decision: reshape the bet.' },
+  { k: 'extend', t: 'Extend the date', d: 'Move it and say why. It goes in pm-decisions.md so it is not a silent default.', draft: 'Recorded as a draft decision: extend the date. The new date goes here.' },
+  { k: 'retire', t: 'Retire the condition', d: 'Stop watching it, and say why.', draft: 'Recorded as a draft decision: retire the condition.' },
+];
+const OPT_PROTOTYPE = [
+  { k: 'promote', t: 'Promote it', d: 'Derive the feature PRD and rubric from it (D60). The prototype itself never ships.', draft: 'Recorded as a draft disposition: promote.' },
+  { k: 'iterate', t: 'Iterate', d: 'Another round of specimens, then look again.', draft: 'Recorded as a draft disposition: iterate.' },
+  { k: 'kill', t: 'Kill it', d: 'Stop the initiative and say why.', draft: 'Recorded as a draft disposition: kill.' },
+];
+const NO_REC = 'No option is chosen for you: no recommendation is on record.';
+const fmRows = (fm) => (fm ? [['Lane', fm.lane], ['Anchor', fm.parent_kr], ['Status', fm.status && clip(fm.status, 260)]].filter((r) => r[1]) : []);
+
+/* A record the builder cannot read must cost its own row or dialog and nothing more. tryD gives a dialog or null; a record that throws is skipped and counted,
+ * and the header says how many (never silently). */
+const START_HOLD = 'Starting an agent from here arrives with the live conversation (the next slice).';
+const tryD = (fn) => { try { return fn(); } catch { return null; } };
+const skipped = { n: 0 };
+
+/** Two products can hold an initiative of the same name, so a lookup by id also names the workspace (none in a one-workspace read). */
+const idk = (x, id) => (x.ws || '') + '|' + id;
+const live = (i) => i && !i.accepted && !i.stopped && !i.legacy;
+
+/* ── rows ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+function blockedRows(f) {
+  const out = [];
+  for (const i of f.initiatives) {
+    try {
+    if (!live(i)) continue;
+    const st = (i.steps || []).find((s) => s.status === 'blocked' && s.blocking !== false) || (i.steps || []).find((s) => s.status === 'blocked');
+    if (!st) continue;
+    const m = stepOf(st.key);
+    out.push({
+      kind: 'blocked', key: 'blocked:' + i.id, title: m.title, subject: clip(i.title, 90),
+      prepared: st.next ? 'Next step: ' + clip(st.next, 140) : 'No next step is on record.',
+      skip: 'If you skip: ' + m.skip,
+      from: [i.id], stepKey: st.key, order: [-(i.blockers || []).length, i.id],
+      detail: { id: i.id, step: st.key, rule: st.rule || null, next: st.next == null ? null : String(st.next), record: i.record || null },
+      dialog: tryD(() => ({
+        eye: 'Unblock', logTitle: 'Read from the repository',
+        log: ['Read the initiative record' + (i.record ? ' (' + i.record + ')' : ''), 'Ran the workflow order rules on it', 'Found the step that blocks it: ' + st.key],
+        say: i.id + ' is blocked at the ' + st.key + ' step.' + (st.rule ? ' The rule it does not meet: ' + clip(st.rule, 200) : ''),
+        hold: START_HOLD, head: 'The way through',
+        facts: [['Blocked at', st.key], ['Initiative', i.id], ['The check', st.rule && clip(st.rule, 200)], ['Record', i.record]].filter((x) => x[1]),
+        opts: st.next ? [{ k: 'next', t: clip(st.next[0].toUpperCase() + st.next.slice(1), 140), d: 'The next step on record.' }] : [],
+        sel: st.next ? 'next' : null,
+        nodef: st.next ? '' : 'No next step is on record.',
+        prim: { next: 'Start: ' + clip(st.next || '', 40) },
+        pane: { label: 'Initiative record', file: i.record || i.id, h: clip(i.title, 90), rows: fmRows(i.fm) },
+      })),
+    });
+    } catch { skipped.n++; }
+  }
+  return out.sort((a, b) => (a.order[0] - b.order[0]) || (a.order[1] < b.order[1] ? -1 : 1));
+}
+
+function decisionRows(f) {
+  const out = [];
+  const meetings = f.meetings || [];
+  for (const i of f.initiatives) {
+    try {
+    if (!live(i) || i.lane !== 'prototype') continue;
+    if ((i.steps || []).some((s) => s.status === 'blocked')) continue;
+    if (i.stage !== 'accept' && i.stage !== 'eval') continue;
+    if ((f.protoDecided || []).includes(i.id)) continue;   // the PM recorded its disposition (pm-decisions.md)
+    const mt = meetings.find((x) => x.initiative === i.id && x.start >= f.now - 0);
+    out.push({
+      kind: 'decision', key: 'decision:' + i.id, title: 'Decide: promote, iterate or kill', subject: clip(i.title, 90) + (mt ? ' · needed at the ' + hhmm(mt.start) + ' ' + mt.title : ''),
+      prepared: 'No recommendation is on record.',
+      skip: 'If you skip: ' + (mt ? 'the ' + hhmm(mt.start) + ' ' + mt.title + ' runs without a disposition.' : 'the prototype stays without a disposition.'),
+      hero: 'the ' + shortName(i.title) + ' waits for your call', from: [i.id].concat(mt ? ['meeting:' + mt.title] : []),
+      detail: { id: i.id, record: i.record || null },
+      dialog: tryD(() => ({
+        eye: 'Decide with evidence', logTitle: 'Read from the repository',
+        log: ['Read the initiative record' + (i.record ? ' (' + i.record + ')' : ''), 'Checked the prototype lane rule (D60): a prototype needs your disposition', f.meetings === null ? 'The calendar could not be read, so no meeting was looked for' : mt ? 'Found a meeting that needs it: ' + hhmm(mt.start) + ' ' + mt.title : 'Looked for a meeting that needs it: none found'],
+        say: 'This prototype waits for your disposition: promote, iterate or kill (D60). ' + NO_REC,
+        head: 'Where it stands',
+        facts: [['Initiative', i.id], ['Lane', i.lane], ['Stage', i.stage], ['Anchor', i.anchor], ['Needed at', mt ? hhmm(mt.start) + ' ' + mt.title : ''], ['Record', i.record]].filter((x) => x[1]),
+        write: { kind: 'decision' }, opts: OPT_PROTOTYPE, sel: null, nodef: NO_REC,
+        prim: { promote: 'Hold to record: promote', iterate: 'Hold to record: iterate', kill: 'Hold to record: kill' },
+        pane: { label: 'Disposition record', file: 'pm-decisions.md · draft entry', h: shortName(i.title), intro: longDate(f.now) + '. ' + clip(i.title, 90) + ' (a prototype) waits for a disposition.', evidence: [['Lane', i.lane], ['Stage', i.stage], ['Anchor', i.anchor], ['Recommendation', 'None is on record']].filter((x) => x[1]), optsDraft: true },
+      })),
+    });
+    } catch { skipped.n++; }
+  }
+  for (const t of f.tripwires || []) {
+    try {
+    const due = Date.parse(t.date + 'T23:59:59');
+    if (!Number.isFinite(due) || due >= f.now || t.decided) continue;
+    const short = String(t.name || t.id).split(/[—:]/)[0].trim();
+    out.push({
+      kind: 'decision', key: 'decision:' + t.id, title: 'Decide what the missed ' + t.id + ' date means', subject: clip(t.name, 90),
+      prepared: 'No recommendation is on record.', skip: 'If you skip: no decision is on record and the tripwire stays fired.',
+      hero: 'the ' + clip(short, 40) + ' tripwire missed its date', from: ['tripwire:' + t.id],
+      detail: { id: t.id, date: t.date },
+      dialog: tryD(() => ({
+        eye: 'Decide with evidence', logTitle: 'Read from the repository',
+        log: ['Read the kill condition (planning/okrs/kill-conditions.md · ' + t.id + ')', 'Checked pm-decisions.md for an entry on or after ' + t.date, 'Found none'],
+        say: 'The ' + t.id + ' date, ' + isoShort(t.date) + ', passed and no decision is on record. Firing is not automatic action: it forces your decision. ' + NO_REC,
+        head: 'The evidence',
+        facts: [['Condition', mdClean(t.name)], ['Threshold', mdClean(t.threshold)], ['Date it fired', t.date], ['Review cadence', mdClean(t.cadence)], ['Firing triggers', mdClean(t.fires)], ['Decision on record', 'None found']].filter((x) => x[1]),
+        write: { kind: 'decision' }, opts: OPT_TRIPWIRE, sel: null, nodef: NO_REC,
+        prim: { reshape: 'Hold to record: reshape', extend: 'Hold to record: extend', retire: 'Hold to record: retire' },
+        pane: { label: 'Decision record', file: 'pm-decisions.md · draft entry', h: t.id + ': ' + clip(mdClean(t.name).split(/[—:]/)[0], 50), intro: longDate(f.now) + '. Tripwire ' + t.id + ': the date (' + isoShort(t.date) + ') passed with no recorded decision.', evidence: [['Threshold', mdClean(t.threshold)], ['Firing triggers', mdClean(t.fires)], ['Decision on record', 'None found']].filter((x) => x[1]), optsDraft: true },
+      })),
+    });
+    } catch { skipped.n++; }
+  }
+  return out;
+}
+
+const leadOf = (e) => { const a = Array.isArray(e.findings) ? e.findings[0] : null; const t = typeof a === 'string' ? a : a && (a.summary || a.text || a.title || a.finding); return t ? clip(t, 220) : (e.lead_finding ? clip(e.lead_finding, 220) : ''); };
+function failedReviews(f) {
+  const last = new Map();
+  for (const e of f.evals || []) {
+    if (!e || !e.initiative_id || e.verdict === 'SKIPPED') continue;
+    const t = Date.parse(e.recorded_at);
+    if (!Number.isFinite(t)) continue;
+    const p = last.get(e.initiative_id);
+    if (!p || t > p.t) last.set(e.initiative_id, { t, verdict: e.verdict, score: e.score, thr: e.pass_threshold, lead: leadOf(e) });
+  }
+  const byId = new Map(f.initiatives.map((i) => [i.id, i]));
+  const out = [];
+  for (const [id, v] of last) {
+    const i = byId.get(id);
+    if (v.verdict !== 'FAIL' || !live(i)) continue;
+    out.push({ id, days: Math.floor((f.now - v.t) / DAY), score: v.score, thr: v.thr, lead: v.lead, title: i.title, anchor: i.anchor });
+  }
+  return out;
+}
+
+function waitedRows(f) {
+  const fr = failedReviews(f);
+  if (!fr.length) return [];
+  const ds = fr.map((x) => x.days).sort((a, b) => a - b), lo = ds[0], hi = ds[ds.length - 1], n = fr.length;
+  const span = lo === hi ? lo + ' days' : lo + ' to ' + hi + ' days';
+  return [{
+    kind: 'waited', key: 'waited:reviews', title: 'Weigh ' + n + ' failed ' + plural(n, 'review', 'reviews'), subject: 'Waiting ' + span + ' · ' + n + ' ' + plural(n, 'item', 'items'),
+    prepared: n + ' ' + plural(n, 'verdict', 'verdicts') + ', each with findings on record.',
+    skip: 'If you skip: the ' + num(n) + ' ' + plural(n, 'review stays', 'reviews stay') + ' open and ' + plural(n, 'keeps', 'keep') + ' ageing (' + span + ' now).',
+    hero: num(n) + ' failed ' + plural(n, 'review is', 'reviews are') + ' still open', from: fr.map((x) => x.id), detail: { ids: fr.map((x) => x.id), days: ds },
+    dialog: tryD(() => ({
+      eye: 'Weigh the reviews', logTitle: 'Read from the repository',
+      log: ['Read planning/runs/evals.jsonl', 'Kept the latest verdict of each initiative', 'Found ' + n + ' that failed and have no later review'],
+      say: num(n)[0].toUpperCase() + num(n).slice(1) + ' ' + plural(n, 'review failed and none since has passed', 'reviews failed and none since has passed') + '. No proposal is on record for ' + plural(n, 'it', 'any of them') + '.',
+      head: 'The reviews',
+      items: fr.slice().sort((a, b) => b.days - a.days).map((x) => ({ t: clip(x.title || x.id, 80), m: x.days + ' days' + (x.anchor ? ' · ' + x.anchor : ''), s: x.score != null ? 'Scored ' + x.score + (x.thr != null ? ' of ' + x.thr : '') : 'No score recorded', lead: x.lead })),
+      pane: { label: n + ' failed ' + plural(n, 'review', 'reviews'), list: true },
+    })),
+  }];
+}
+
+/** A row of one product in a merged list: its key names the workspace (kind:id:ws) so two products never share a key, and it carries the product's name. */
+const tagRow = (r, p) => Object.assign({}, r, { key: r.key + ':' + p.ws, product: p.name, ws: p.ws });
+/** Every row of one set of facts, in the order the rules give, with those the PM put off split out. Not yet cut to the page's cap. */
+function allRowsOf(f) {
+  let every = [].concat(blockedRows(f), decisionRows(f), waitedRows(f));
+  if (f.product) every = every.map((r) => tagRow(r, f.product));
+  const off = (r) => (f.defers && f.defers[r.key] > f.now);   // put off by the PM until a time that has not come
+  const all = every.filter((r) => !off(r));
+  const putOff = every.filter(off).map((r) => ({ key: r.key, title: r.title, until: f.defers[r.key], ...(r.product ? { product: r.product } : {}) }));
+  return { all, putOff };
+}
+const cut = (all, putOff) => {
+  const rows = all.slice(0, MAX_ROWS).map((r, k) => Object.assign({ n: k + 1, first: k === 0 }, r));
+  rows.forEach((r) => delete r.order);
+  return { rows, more: Math.max(0, all.length - rows.length), putOff };
+};
+function rowsOf(f) { const a = allRowsOf(f); return cut(a.all, a.putOff); }
+
+/* ── hero ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+function correctionRate(runs, from, to) {
+  const w = runs.filter((r) => { const t = Date.parse(r.created_at); return Number.isFinite(t) && t >= from && t < to && Number.isFinite(Number(r.human_corrections)); });
+  if (w.length < 10) return null;
+  const c = w.reduce((a, r) => a + Number(r.human_corrections), 0);
+  return { rate: Math.round((c / w.length) * 100), runs: w.length };
+}
+
+function heroOf(f, rows) {
+  const seg = (parts) => parts.map(([t, s]) => ({ t, s: !!s }));
+  const sentences = [];
+  const midnight = startOfDay(f.now);
+  const merged = (f.merges || []).filter((m) => m.at >= midnight && m.at <= f.now);
+  const cur = correctionRate(f.runs || [], f.now - 7 * DAY, f.now + 1), prev = correctionRate(f.runs || [], f.now - 14 * DAY, f.now - 7 * DAY);
+  {
+    const p = [];
+    if (merged.length) p.push(['Agents merged ', 0], [num(merged.length) + ' ' + plural(merged.length, 'change', 'changes') + ' today', 1]);
+    if (cur && prev && cur.rate !== prev.rate) {
+      const lower = cur.rate < prev.rate;
+      p.push([p.length ? ', and corrections went from ' : 'Corrections went from ', 0], [prev.rate + ' to ' + cur.rate + ' per 100 runs', 1], [' in a week' + (lower ? ', the direction you want' : ', the wrong direction') + '.', 0]);
+    } else if (p.length) p.push(['.', 0]);
+    if (p.length) sentences.push({ parts: seg(p), from: merged.length ? ['merges'] : ['runs'] });
+  }
+  {
+    const blocked = rows.filter((r) => r.kind === 'blocked'), rest = rows.filter((r) => r.hero);
+    const clauses = [];
+    if (blocked.length) {
+      const ordering = blocked.every((r) => r.stepKey === 'spec' || r.stepKey === 'prototype');
+      const where = [...new Set(blocked.map((r) => r.product).filter(Boolean))];
+      clauses.push({ t: num(blocked.length) + ' ' + plural(blocked.length, 'initiative is', 'initiatives are') + ' blocked' + (ordering ? ' on ordering' : '') + (where.length ? ' in ' + joinNames(where) : ''), from: blocked.map((r) => r.from[0]) });
+    }
+    rest.forEach((r) => clauses.push({ t: r.hero + (r.product ? ' in ' + r.product : ''), from: r.from }));
+    if (clauses.length) {
+      const p = [['What is stuck is yours: ', 0]];
+      clauses.forEach((c, k) => {
+        p.push([c.t, 1]);
+        p.push([k === clauses.length - 1 ? '.' : k === clauses.length - 2 ? ' and ' : ', ', 0]);
+      });
+      sentences.push({ parts: seg(p), from: [].concat(...clauses.map((c) => c.from)) });
+    }
+  }
+  {
+    const cut = f.now - 30 * DAY / 1, recent = f.initiatives.filter((i) => i.last_activity != null && i.last_activity * 1000 >= cut && !i.stopped);
+    const upkeep = recent.filter((i) => /^health:/.test(i.anchor || ''));
+    const idle = f.initiatives.filter((i) => live(i) && i.last_activity != null && i.last_activity * 1000 < cut);
+    const p = [];
+    if (recent.length >= 5 && upkeep.length / recent.length >= 0.25) {
+      const share = upkeep.length / recent.length;
+      p.push([share >= 0.45 && share <= 0.55 ? 'half of recent work is upkeep' : Math.round(share * 100) + '% of recent work is upkeep', 1]);
+    }
+    if (idle.length) { if (p.length) p.push([', and ', 0]); p.push([idle.length + ' ' + plural(idle.length, 'initiative has', 'initiatives have') + ' sat idle for a month', 1]); }
+    if (p.length) sentences.push({ parts: seg([['The slower risk is drift: ', 0]].concat(p, [['.', 0]])), from: upkeep.map((i) => i.id).concat(idle.map((i) => i.id)) });
+  }
+  return sentences;
+}
+
+/* ── today ────────────────────────────────────────────────────────────────────────────────────────────────── */
+const EV_NEXT = 'Acting on it arrives in the next slice. This page writes nothing.';
+function mergeDialog(m, f) {
+  const pr = (/\(#(\d+)\)\s*$/.exec(m.title) || [])[1], title = m.title.replace(/\s*\(#\d+\)\s*$/, '');
+  const files = m.files != null ? m.files : null;
+  const facts = files == null ? [] : [['Files', files + ' changed, +' + m.ins + ' −' + m.del], ['Mostly in', (m.dirs || []).join(', ')]].filter((x) => x[1]);
+  return {
+    eye: 'Merged today', logTitle: 'Read from git', title, sub: (pr ? '#' + pr + ' · ' : '') + hhmm(m.at) + ' · merged to main',
+    log: ['Read the commit on main' + (m.sha ? ' (' + m.sha.slice(0, 8) + ')' : ''), files == null ? 'The commit details could not be read' : 'Counted its files and lines', m.body ? 'Read its message' : 'It has no message body'],
+    say: 'This reached main today. Nothing needs you unless you disagree with it.',
+    head: 'What changed', facts, opts: [], sel: null, nodef: '', action: 'Return this run to the agent', hold: 'A merge has no run of its own to return. Open the agent run in Today to return it.',
+    pane: { label: 'Summary', file: (pr ? '#' + pr + ' · ' : '') + 'merged to main', h: title, intro: files == null ? '' : files + ' files changed, +' + m.ins + ' −' + m.del + (m.dirs && m.dirs.length ? '. Mostly in ' + m.dirs.join(', ') + '.' : '.'), paras: m.body ? String(m.body).split(/\n\s*\n/).map((x) => x.replace(/\s+/g, ' ').trim()).filter(Boolean).slice(0, 8) : [], parasTitle: 'From the commit message' },
+  };
+}
+function runDialog(r, t, byId) {
+  const i = byId.get(idk(r, r.initiative_id)), ap = r.pre_run_contract && r.pre_run_contract.PM_approved === true;
+  const facts = [['Initiative', (i && i.title) ? clip(i.title, 70) : r.initiative_id], ['Run', r.run_id], ['Lane', r.lane || (i && i.lane)], ['Corrections', Number.isFinite(Number(r.human_corrections)) ? String(r.human_corrections) : ''], ['Contract approved', r.pre_run_contract ? (ap ? 'Yes' : 'No') : ''], ['Recorded', longDate(t) + ' ' + hhmm(t)]].filter((x) => x[1]);
+  return {
+    eye: 'Agent run', logTitle: 'Read from the run log', title: i ? clip(i.title, 90) : r.initiative_id, sub: hhmm(t) + ' · agent run',
+    log: ['Read planning/runs/agent-runs.jsonl', 'Matched the run to its initiative' + (i ? '' : ' (no record found)'), 'Read its recorded fields'],
+    say: 'This run is logged. Nothing needs you unless you disagree with it.',
+    head: 'The run', facts, opts: [], sel: null, nodef: '', action: 'Return this run to the agent', write: { kind: 'return', run: r.run_id, ...(r.ws ? { ws: r.ws } : {}) },
+    pane: { label: 'Run record', file: 'planning/runs/agent-runs.jsonl', h: i ? clip(i.title, 90) : r.initiative_id, intro: '', rows: facts, paras: r.note ? [clip(r.note, 600)] : [], parasTitle: 'Its note' },
+  };
+}
+function meetingDialog(m) {
+  const mins = Math.round((m.end - m.start) / 60000);
+  const facts = [['Time', hhmm(m.start) + ' to ' + hhmm(m.end)], ['Length', mins + ' min'], ['People', m.with], ['Initiative', m.initiative]].filter((x) => x[1]);
+  return {
+    eye: 'Calendar', logTitle: 'Read from the calendar', title: m.title, sub: hhmm(m.start) + ' · ' + mins + ' min' + (m.with ? ' · ' + m.with : ''),
+    log: ['Read the calendar PMOS holds', 'Found this meeting for today', m.initiative ? 'Found its linked initiative: ' + m.initiative : 'It names no initiative'],
+    say: 'This meeting is in the calendar PMOS holds. PMOS holds no prep for it.',
+    head: 'The meeting', facts, opts: [], sel: null, nodef: '',
+    pane: { label: 'Meeting', file: 'Calendar', h: m.title, intro: longDate(m.start) + ', ' + hhmm(m.start) + ' to ' + hhmm(m.end) + '.', rows: facts, paras: [], parasTitle: '' },
+  };
+}
+
+function todayOf(f) {
+  const midnight = startOfDay(f.now);
+  const items = [];
+  for (const m of f.meetings || []) {
+    items.push({ at: m.start, t: hhmm(m.start), kind: 'meeting', title: m.title, sub: [Math.round((m.end - m.start) / 60000) + ' min', m.with].filter(Boolean).join(' · '), src: 'Calendar', dialog: tryD(() => meetingDialog(m)) });
+  }
+  for (const m of f.merges || []) if (m.at >= midnight && m.at <= f.now) items.push({ at: m.at, t: hhmm(m.at), kind: 'merge', ...(m.product ? { product: m.product } : {}), title: clip(m.title, 110), sub: 'Merged to main', src: 'Merges', dialog: tryD(() => mergeDialog(m, f)) });
+  const runs = (f.runs || []).filter((r) => { const t = Date.parse(r.created_at); return t >= midnight && t <= f.now; });
+  const byId = new Map(f.initiatives.map((i) => [idk(i, i.id), i]));
+  for (const r of runs) { const t = Date.parse(r.created_at); items.push({ at: t, t: hhmm(t), kind: 'run', ...(r.product ? { product: r.product } : {}), title: clip((byId.get(idk(r, r.initiative_id)) || {}).title || r.initiative_id, 110), sub: 'Agent run' + (Number.isFinite(Number(r.human_corrections)) ? ' · ' + r.human_corrections + ' ' + plural(Number(r.human_corrections), 'correction', 'corrections') : ''), src: 'Agent runs', dialog: tryD(() => runDialog(r, t, byId)) }); }
+  const ahead = items.filter((x) => x.at > f.asOf).sort((a, b) => a.at - b.at), earlier = items.filter((x) => x.at <= f.asOf).sort((a, b) => b.at - a.at);
+  const count = (k) => items.filter((x) => x.kind === k).length;
+  return { ahead, earlier, now: { t: hhmm(f.asOf), label: 'snapshot' }, counts: { meeting: count('meeting'), merge: count('merge'), run: count('run') }, note: ahead.length + earlier.length ? null : 'Nothing is recorded for today yet.' };
+}
+
+/* ── the model ────────────────────────────────────────────────────────────────────────────────────────────── */
+const SOURCE_NAME = { calendar: 'the calendar', merges: 'merges', runs: 'agent runs', workflow: 'initiative state', evals: 'review verdicts', tripwires: 'kill conditions' };
+
+const backAt = (ms, now) => (startOfDay(ms) === startOfDay(now) ? 'at ' + hhmm(ms) : dateLine(ms) + ' ' + hhmm(ms));
+function build(f) {
+  skipped.n = 0;
+  f = Object.assign({ pending: false, initiatives: [], runs: [], merges: [], evals: [], meetings: null, tripwires: null, missing: [] }, f);
+  f.asOf = f.asOf || f.now;
+  const { rows, more, putOff } = rowsOf(f);
+  const hero = heroOf(f, rows);
+  const today = todayOf(f);
+  const missing = (f.missing || []).slice();
+  if (f.meetings === null && !missing.includes('calendar')) missing.push('calendar');
+  if (f.tripwires === null && !missing.includes('tripwires')) missing.push('tripwires');
+  return {
+    date: dateLine(f.now),
+    pending: !!f.pending,
+    header: { text: 'Real data · as of ' + hhmm(f.asOf) + (missing.length ? ' · not read: ' + missing.map((k) => SOURCE_NAME[k] || k).join(', ') : '') + (f.pending ? ' · reading initiative state' : '') + (skipped.n ? ' · ' + skipped.n + (skipped.n === 1 ? ' record' : ' records') + ' could not be read and ' + (skipped.n === 1 ? 'was' : 'were') + ' left out' : ''), missing },
+    hero: hero.length ? hero : [{ parts: [{ t: f.pending ? 'Reading the initiative state. What needs you is not known yet.' : 'Nothing needs you and nothing moved today that the records show.', s: false }], from: [] }],
+    list: { title: 'What you need to do', rows, more, count: rows.length + more, pendingNote: f.pending ? 'Blocked work, prototypes waiting for you and failed reviews appear when the initiative state has been read.' : null, putOff: putOff.map((x) => ({ key: x.key, title: x.title, until: x.until, text: x.title + ' · back ' + backAt(x.until, f.now) })), order: 'In this order: blocked work first, then decisions only you can make, then what has waited longest.' },
+    today,
+    dock: { needs: f.pending ? null : rows.length + more, label: plural(rows.length + more, 'needs you', 'need you'), next: rows[0] ? rows[0].title : null },
+  };
+}
+
+
+/* ── several products (initiative briefing-premium-products) ──────────────────────────────────────────────── */
+const KIND_RANK = { blocked: 0, decision: 1, waited: 2 };
+const longest = (r) => { const d = (r.detail && r.detail.days) || []; return d.length ? d[d.length - 1] : 0; };
+
+/** Several products' facts → ONE model, in the same shape build() makes.
+ *   g = { now, asOf, meetings (shared, or null), defers { key: until }, available: [{ ws, name, home, on }],
+ *         parts: [{ product: { ws, name }, f (that product's facts) | null, state: 'ready' | 'reading' | 'error', error? }] }
+ * A row belongs to one product (its key ends with the workspace id) and the rows are put in one order: blocked first, then decisions, then reviews.
+ * A count is never summed across products: each product gets its own failed-review row. The hero and Today read the merged facts. */
+function buildMany(g) {
+  skipped.n = 0;
+  const now = g.now, asOf = g.asOf || g.now, meetings = g.meetings === undefined ? null : g.meetings;
+  const parts = (g.parts || []).map((p) => ({ product: p.product, state: p.state || 'ready', error: p.error, f: p.f ? Object.assign({ initiatives: [], runs: [], merges: [], evals: [], tripwires: null, missing: [], protoDecided: [] }, p.f, { now, asOf, meetings, defers: g.defers || {}, product: p.product }) : null }));
+  const read = parts.filter((p) => p.f && p.state !== 'error');
+  const every = [], putOff = [];
+  for (const p of read) { const a = allRowsOf(p.f); every.push(...a.all); putOff.push(...a.putOff); }
+  every.sort((a, b) => (KIND_RANK[a.kind] - KIND_RANK[b.kind]) || (a.kind === 'blocked' ? (a.order[0] - b.order[0]) || (a.order[1] < b.order[1] ? -1 : a.order[1] > b.order[1] ? 1 : 0) : a.kind === 'waited' ? longest(b) - longest(a) : 0));
+  const { rows, more } = cut(every, putOff);
+  const tag = (list, p) => list.map((x) => Object.assign({}, x, { ws: p.product.ws, product: p.product.name }));
+  const cf = {
+    now, asOf, meetings, defers: g.defers || {},
+    initiatives: [].concat(...read.map((p) => p.f.initiatives.map((i) => Object.assign({}, i, { ws: p.product.ws })))),
+    runs: [].concat(...read.map((p) => tag(p.f.runs, p))),
+    merges: [].concat(...read.map((p) => tag(p.f.merges, p))),
+    evals: [].concat(...read.map((p) => tag(p.f.evals, p))),
+  };
+  const available = g.available || [], inc = available.filter((a) => a.on), out = available.filter((a) => !a.on);
+  const waiting = parts.filter((p) => p.state === 'reading' || !p.f).filter((p) => p.state !== 'error'), failed = parts.filter((p) => p.state === 'error');
+  const pending = parts.some((p) => p.state === 'reading' || (p.f && p.f.pending));
+  const missing = [];
+  if (meetings === null) missing.push('calendar');
+  for (const p of read) for (const k of p.f.missing || []) missing.push(k + ' (' + p.product.name + ')');
+  for (const p of failed) missing.push(p.product.name);
+  const missText = [].concat(meetings === null ? ['the calendar'] : [], ...read.map((p) => (p.f.missing || []).map((k) => (SOURCE_NAME[k] || k) + ' of ' + p.product.name)), failed.map((p) => p.product.name + ' could not be read'));
+  const none = !inc.length;
+  const hero = none ? [{ parts: [{ t: available.length ? 'No product is included, so there is nothing to read. Pick one under Products.' : 'No product workspace is registered, so there is nothing to read.', s: false }], from: [] }]
+    : heroOf(cf, rows);
+  return {
+    date: dateLine(now),
+    pending,
+    header: { text: 'Real data · as of ' + hhmm(asOf) + ' · ' + (none ? 'no product included' : joinNames(inc.map((a) => a.name))) + (out.length ? ' · ' + joinNames(out.map((a) => a.name)) + ' not included' : '') + (missText.length ? ' · not read: ' + missText.join(', ') : '') + (waiting.length ? ' · reading ' + joinNames(waiting.map((p) => p.product.name)) : '') + (skipped.n ? ' · ' + skipped.n + (skipped.n === 1 ? ' record' : ' records') + ' could not be read and ' + (skipped.n === 1 ? 'was' : 'were') + ' left out' : ''), missing },
+    hero: hero.length ? hero : [{ parts: [{ t: pending ? 'Reading the initiative state. What needs you is not known yet.' : 'Nothing needs you and nothing moved today that the records show.', s: false }], from: [] }],
+    list: { title: 'What you need to do', rows, more, count: rows.length + more, pendingNote: pending ? 'Blocked work, prototypes waiting for you and failed reviews appear when the initiative state has been read.' : null, putOff: putOff.map((x) => ({ key: x.key, title: x.title, ...(x.product ? { product: x.product } : {}), until: x.until, text: (x.product ? x.product + ': ' : '') + x.title + ' · back ' + backAt(x.until, now) })), order: 'In this order: blocked work first, then decisions only you can make, then what has waited longest.' },
+    today: todayOf(cf),
+    dock: { needs: pending ? null : rows.length + more, label: plural(rows.length + more, 'needs you', 'need you'), next: rows[0] ? rows[0].title : null },
+    products: { available: available.map((a) => ({ ws: a.ws, name: a.name, home: !!a.home, on: !!a.on })), none },
+  };
+}
+
+/* ── I/O ──────────────────────────────────────────────────────────────────────────────────────────────────── */
+const readJsonl = (file) => { try { return fs.readFileSync(file, 'utf8').split('\n').map((l) => l.trim()).filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return null; } };
+const run = (cmd, args, opts) => new Promise((res) => {
+  const { nice, ...o } = opts || {};
+  const c = execFile(cmd, args, Object.assign({ maxBuffer: 64 * 1024 * 1024, timeout: 30 * 60 * 1000 }, o), (e, out) => res(e ? null : String(out)));
+  if (nice) { try { require('os').setPriority(c.pid, nice); } catch { /* a platform without it runs at normal priority */ } }
+});
+
+/** The kill conditions with a dated firing threshold (planning/okrs/kill-conditions.md summary table), and whether pm-decisions.md
+ * holds an entry for one on or after its date. null when the file cannot be read. */
+function readTripwires(root) {
+  let kc, pm = '';
+  try { kc = fs.readFileSync(path.join(root, 'planning', 'okrs', 'kill-conditions.md'), 'utf8'); } catch { return null; }
+  try { pm = fs.readFileSync(path.join(root, 'pm-decisions.md'), 'utf8'); } catch { pm = ''; }
+  const blocks = pm.split(/^## /m).slice(1).map((b) => ({ date: (b.match(/^(\d{4}-\d{2}-\d{2})/) || [])[1], text: b }));
+  const out = [];
+  for (const l of kc.split('\n')) {
+    const m = /^\|\s*(KC\d+)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/.exec(l);
+    if (!m) continue;
+    const d = /\*\*(\d{4}-\d{2}-\d{2})\*\*/.exec(m[3]);
+    if (!d) continue;
+    const decided = blocks.some((b) => b.date && b.date >= d[1] && new RegExp('\\b' + m[1] + '\\b').test(b.text));
+    out.push({ id: m[1], name: m[2], date: d[1], decided, threshold: m[3], cadence: m[4], fires: m[5] });
+  }
+  return out;
+}
+
+/** The few one-line frontmatter values the dialog shows, from an initiative record. null when the file cannot be read. */
+function readFm(root, rel) {
+  let t;
+  try { t = fs.readFileSync(path.join(root, rel), 'utf8'); } catch { return null; }
+  const m = /^---\n([\s\S]*?)\n---/.exec(t);
+  if (!m) return null;
+  const out = {};
+  for (const k of ['lane', 'parent_kr', 'status']) {
+    const r = new RegExp('^' + k + ':\\s*(.*)$', 'm').exec(m[1]);
+    if (r && r[1].trim()) out[k] = r[1].trim().replace(/^"(.*)"$/, '$1');
+  }
+  return out;
+}
+
+/** The slow read: every initiative's workflow state, from the engine (a git history walk). Runs at low priority so it does not starve the machine. null on failure. */
+async function readInitiatives({ root, engine }) {
+  const wf = engine ? await run(process.execPath, [engine, '--json', '--root', root], { cwd: root, nice: 10 }) : null;
+  let list;
+  try { list = JSON.parse(wf).map((x) => ({ id: x.id, title: x.title, lane: x.lane, stage: x.stage, accepted: !!x.accepted, stopped: !!x.stopped, legacy: !!x.legacy, anchor: x.anchor, last_activity: x.last_activity, blockers: x.blockers || [], next: x.next, record: x.record, steps: (x.steps || []).map((s) => ({ key: s.key, status: s.status, next: s.next, rule: (s.basis && s.basis.rule) || s.rule, blocking: s.blocking })) })); } catch { return null; }
+  for (const i of list) if (i.record && !i.accepted && (i.lane === 'prototype' || i.steps.some((x) => x.status === 'blocked'))) i.fm = readFm(root, i.record);
+  return list;
+}
+
+/** What changes the engine's answer: the commit the repository is on, and any uncommitted change under planning/ or scripts/. null when git cannot say. */
+async function repoKey(root) {
+  const head = await run('git', ['-C', root, 'rev-parse', 'HEAD']);
+  if (head === null) return null;
+  const st = await run('git', ['-C', root, 'status', '--porcelain', '--', 'planning', 'scripts']);
+  return head.trim() + ':' + require('crypto').createHash('sha1').update(st || '').digest('hex').slice(0, 12);
+}
+
+/** Today's calendar rows, from the calendar PMOS holds (one for the whole computer, not one per workspace). null when it cannot be read. */
+function readMeetings(runtimeDir, now) {
+  try {
+    const CE = require('./calendar-events.js');
+    if (!runtimeDir) throw new Error('no runtime dir');
+    const all = CE.readAll(runtimeDir, { now });
+    return CE.eventsOn(all, dayKey(now)).map((e) => ({ start: Date.parse(e.start), end: Date.parse(e.end), title: e.title, with: e.with || '', initiative: e.initiative || null })).filter((e) => Number.isFinite(e.start));
+  } catch { return null; }
+}
+
+/** The quick read: runs, reviews, merges (with their files), the calendar and the kill conditions. No initiative state. */
+async function readFast({ root, now, runtimeDir, calendar = true }) {
+  const f = { now: now || Date.now(), asOf: now || Date.now(), initiatives: [], runs: [], merges: [], evals: [], meetings: null, tripwires: null, missing: [] };
+  const runs = readJsonl(path.join(root, 'planning', 'runs', 'agent-runs.jsonl')); if (runs) f.runs = runs; else f.missing.push('runs');
+  const evals = readJsonl(path.join(root, 'planning', 'runs', 'evals.jsonl')); if (evals) f.evals = evals; else f.missing.push('evals');
+  const since = new Date(startOfDay(f.now)).toISOString();
+  const log = await run('git', ['-C', root, 'log', '--first-parent', '--since=' + since, '--format=%H%x09%ct%x09%s', (await run('git', ['-C', root, 'rev-parse', '--verify', '-q', 'origin/main'])) ? 'origin/main' : 'HEAD']);
+  if (log === null) f.missing.push('merges'); else f.merges = log.split('\n').filter(Boolean).map((l) => { const [h, t, ...s] = l.split('\t'); return { sha: h, at: Number(t) * 1000, title: s.join('\t') }; });
+  for (const m of f.merges.slice(0, 30)) {
+    const sh = await run('git', ['-C', root, 'show', '--numstat', '--format=%b', m.sha]);
+    if (sh === null) continue;
+    const lines = sh.split('\n'), nums = lines.filter((x) => /^(\d+|-)\t(\d+|-)\t/.test(x)), top = {};
+    let ins = 0, del = 0;
+    for (const x of nums) { const [a, d, ...fp] = x.split('\t'); ins += Number(a) || 0; del += Number(d) || 0; const pth = fp.join('\t').split('/'); const k = pth.length > 1 ? pth[0] : pth[0]; top[k] = (top[k] || 0) + 1; }
+    m.files = nums.length; m.ins = ins; m.del = del; m.dirs = Object.entries(top).sort((a, b) => b[1] - a[1]).slice(0, 3).map((e) => e[0]);
+    m.body = lines.filter((x) => !/^(\d+|-)\t(\d+|-)\t/.test(x)).join('\n').trim();
+  }
+  if (calendar) f.meetings = readMeetings(runtimeDir, f.now);
+  f.tripwires = readTripwires(root);
+  f.protoDecided = [...W.decidedPrototypes(root)];
+  f.defers = Object.fromEntries(W.readDefers(runtimeDir, f.now));
+  return f;
+}
+
+
+/** Both reads, for a caller that wants the whole facts (the tests). */
+async function readSources({ root, now, engine, runtimeDir }) {
+  const f = await readFast({ root, now, runtimeDir });
+  const inits = await readInitiatives({ root, engine });
+  if (inits) f.initiatives = inits; else f.missing.push('workflow');
+  return f;
+}
+
+/* ── the route's kept answer ──────────────────────────────────────────────────────────────────────────────── */
+/* ── the route's kept answer ─────────────────────────────────────────────────────────────────────────────
+ * A first read takes from about half a minute on a fast machine to much longer on a slow one, so no request waits for it.
+ *   - an answer in memory is served at once, however old, and a read older than 5 minutes is refreshed in the background;
+ *   - after a restart the last answer is read back from <runtimeDir>/briefing-premium-model.json (a derived cache, safe to delete);
+ *   - with neither, the answer is { state: 'reading', elapsed_ms } at once and the read goes on in the background;
+ *   - a read that fails is kept as { state: 'error', error } until the next try, so the page can say why. */
+let kept = null, partial = null, inflight = null, startedAt = 0, lastError = null, lastErrorAt = 0;
+const hooks = { build };   // a seam for the suite: a failing build
+const RETRY_AFTER_ERROR_MS = 2 * 60 * 1000;
+const STALE_MS = 5 * 60 * 1000;
+const CACHE_FILE = 'briefing-premium-model.json';
+const loadCache = (dir) => { try { const j = JSON.parse(fs.readFileSync(path.join(dir, CACHE_FILE), 'utf8')); return j && j.model && j.at && j.root ? j : null; } catch { return null; } };
+const saveCache = (dir, k) => { try { fs.mkdirSync(dir, { recursive: true }); const f = path.join(dir, CACHE_FILE), t = f + '.' + process.pid + '.tmp'; fs.writeFileSync(t, JSON.stringify(k)); fs.renameSync(t, f); } catch { /* a cache that cannot be written is only a slower next start */ } };
+
+/* One refresh. The quick read always runs. The slow one (every initiative's state) runs only when the repository changed since the last answer
+ * (same commit and no uncommitted change under planning/ or scripts/); otherwise the last initiatives are reused. With no earlier answer, the
+ * quick read's model is served as a partial one while the slow read goes on, so the page shows what it can at once and says what is pending. */
+async function refresh({ root, engine, runtimeDir }) {
+  const key = await repoKey(root);
+  const f = await readFast({ root, now: Date.now(), runtimeDir });
+  let inits = kept && kept.root === root && key && kept.key === key && kept.ok && kept.initiatives ? kept.initiatives : null;   // a failed slow read is never reused: it is tried again
+  if (!inits) {
+    if (!kept) partial = { at: Date.now(), root, model: hooks.build(Object.assign({}, f, { initiatives: [], pending: true })) };
+    inits = await readInitiatives({ root, engine });
+  }
+  if (!inits) f.missing.push('workflow');
+  kept = { at: Date.now(), root, key, ok: !!inits, initiatives: inits || [], model: hooks.build(Object.assign({}, f, { initiatives: inits || [] })) };
+  partial = null; lastError = null; lastErrorAt = 0;
+  if (runtimeDir) saveCache(runtimeDir, kept);
+}
+function modelOf({ root, engine, runtimeDir }) {
+  const start = () => {
+    // a read that just failed is not started again on every poll: the page shows why, and the next try waits
+    if (!inflight && !(lastError && Date.now() - lastErrorAt < RETRY_AFTER_ERROR_MS)) {
+      startedAt = Date.now();
+      inflight = refresh({ root, engine, runtimeDir }).catch((e) => { lastError = String((e && e.stack) || e).split('\n').slice(0, 3).join(' | ').slice(0, 300); lastErrorAt = Date.now(); }).finally(() => { inflight = null; });
+    }
+    return inflight;
+  };
+  if (kept && kept.root !== root) kept = null;
+  if (partial && partial.root !== root) partial = null;
+  if (!kept && runtimeDir) { const c = loadCache(runtimeDir); if (c && c.root === root) kept = c; }
+  if (kept) {
+    if (Date.now() - kept.at > STALE_MS) start();
+    return Promise.resolve({ state: 'ready', model: kept.model, as_of: kept.at, refreshing: !!inflight, ...(lastError ? { error: lastError } : {}) });
+  }
+  start();
+  if (partial) return Promise.resolve({ state: 'ready', model: partial.model, as_of: partial.at, pending: !(lastError && !inflight), elapsed_ms: Date.now() - startedAt, ...(lastError ? { error: lastError } : {}) });
+  if (lastError && !inflight) return Promise.resolve({ state: 'error', error: lastError });
+  return Promise.resolve({ state: 'reading', elapsed_ms: Date.now() - startedAt });
+}
+/** After a write: rebuild the kept answer from fresh records without the slow read. A caller waits for a read in progress first. */
+async function rebuild({ root, runtimeDir }) {
+  await settle();
+  if (!kept || kept.root !== root) return false;
+  const f = await readFast({ root, now: Date.now(), runtimeDir });
+  if (!kept.ok) f.missing.push('workflow');
+  kept = Object.assign({}, kept, { model: hooks.build(Object.assign({}, f, { initiatives: kept.initiatives })) });
+  if (runtimeDir) saveCache(runtimeDir, kept);
+  return true;
+}
+/** The model the route holds for this root, for the agent to find a row in. null before the first read. */
+const peekModel = (root) => (kept && kept.root === root ? kept.model : partial && partial.root === root ? partial.model : null);
+const settle = () => inflight || Promise.resolve();
+const forget = () => { kept = null; partial = null; inflight = null; lastError = null; startedAt = 0; };
+
+module.exports = { build, buildMany, allRowsOf, readMeetings, hooks, refresh, readSources, readFast, readInitiatives, repoKey, readFm, readTripwires, modelOf, settle, forget, rebuild, peekModel, rowsOf, heroOf, todayOf, failedReviews, num };

package/workspace/lib/engine/workflow-state.js

@@ -323,7 +323,7 @@ function buildRange(root, { spec, whole }) {
 
   // Where each path was ADDED, as an index into the same range. `--diff-filter=A` in one pass.
   const added = new Map();
-  const addLog = git(root, ['log', '--reverse', '--format=%x1e%H', '--diff-filter=A', '--name-only', range]);
+  const addLog = git(root, ['log', '--reverse', '--no-renames', '--format=%x1e%H', '--diff-filter=A', '--name-only', range]);   // no rename detection: a path renamed into place is an add, as the per-path lookup below sees it
   if (addLog != null) {
     for (const chunk of addLog.split('\x1e')) {
       if (!chunk.trim()) continue;
@@ -358,6 +358,11 @@ function firstAppearance(root, range, rel) {
   // ever been committed — so the fallback below only runs for a PR range, where "added before the
   // range" and "never committed" are genuinely different answers and only git can tell them apart.
   if (range.added && range.added.has(rel)) return range.added.get(rel);
+  // A TRACKED path that this range did not add was added before it: -1, exactly what the per-path
+  // `git log` below would conclude, from the one shared `ls-files`. That per-path call was one
+  // subprocess per record on a branch ahead of main, and most of a board read's time.
+  const tracked = trackedIn(root, range);
+  if (tracked && tracked.has(rel)) return -1;
   const log = git(root, ['log', '--diff-filter=A', '--reverse', '--format=%H', '--', rel]);
   const sha = log ? log.split('\n').map((s) => s.trim()).filter(Boolean)[0] : null;
   if (!sha) return onDisk ? Infinity : null;

package/workspace/lib/headless.js

@@ -63,7 +63,7 @@ const HEADLESS_SKILLS = Object.freeze([
 // The note passes that run headless, by the origin prefix lib/routes-notes.js gives them.
 const HEADLESS_ORIGINS = Object.freeze(['notes-bullets:', 'notes-summary:']);
 // page-starts-agent: Ask the agent on a document. The run reads and answers with the revised text; it writes nothing.
-const ASK_ORIGINS = Object.freeze(['doc-ask:', 'focus-companion:']);   // focus-companion: the Meeting focus page's quiet companion and its private questions (read-only, nothing sent)
+const ASK_ORIGINS = Object.freeze(['doc-ask:', 'focus-companion:', 'briefing-ask:']);   // focus-companion: the Meeting focus page's quiet companion and its private questions (read-only, nothing sent)
 // initiative-driver: one short run for one initiative or one Work task. Its origin is `drive:<kind>:<id>`.
 const DRIVE_ORIGINS = Object.freeze(['drive:']);
 // horizon-scan: a scan is two runs. The web run (origin `scan-web:<board>:<scan>`) reads the public web for the kept watch list and sees nothing of