create-pmos 0.514.0 → 0.516.0

package/workspace/lib/board-metrics-premium.js

@@ -95,7 +95,10 @@ function build(f) {
       const ch = prev == null ? null : (() => { const d = live - prev; return { d, good: d < 0, txt: (d === 0 ? 'No change' : (d > 0 ? 'Up ' : 'Down ') + Math.abs(d)) + ' vs last week' }; })();
       return { key, label, value: String(live), text: 'of ' + open.length + ' open · ' + since, kind, ser, wk: W.map((w) => w.label), nt: ser.map(() => ''), dec: 0, suf: '', change: ch, since, def, lowBetter: true };
     };
-    tiles.push(hTile('blocked', 'Blocked', blocked, blocked ? 'bad' : '', DEFS.blocked), hTile('idle', 'Idle for a month', idle, idle ? 'warn' : '', DEFS.idle));
+    // Intelligence redesign A: an initiative with no activity on record is counted idle, and a month of watching is what makes that true. Until
+    // the history is a month old, the idle tile says the day it becomes known (Intelligence shows that instead of the count).
+    const known = first + IDLE_DAYS * DAY > now ? Rec.dayOf(first + IDLE_DAYS * DAY) : null;
+    tiles.push(hTile('blocked', 'Blocked', blocked, blocked ? 'bad' : '', DEFS.blocked), Object.assign(hTile('idle', 'Idle for a month', idle, idle ? 'warn' : '', DEFS.idle), known && open.some((i) => !Number.isFinite(Date.parse(i.last_activity))) ? { knownFrom: known, historyFrom: Rec.dayOf(first) } : {}));
     counted = { blocked, idle, open: open.length };
   }
 

package/workspace/lib/insights-goals.js

@@ -90,6 +90,8 @@ function goalFields(input, { today } = {}) {
   if (SOURCES[i.source]) f.source = i.source;
   const owner = tidy(i.owner, 60); if (owner) f.owner = owner;
   const guard = tidy(i.guardrail, 120); if (guard) f.guardrail = guard;
+  // Intelligence redesign A: a goal drafted from the OKR file reads that key result (lib/okr-goals.js readerOf), so it is never a second goal
+  const kr = tidy(i.kr, 40); if (kr && /^(?:O[\w-]*\.)?KR[\w.-]+$/i.test(kr)) f.kr = kr;
   return { ok: true, fields: f };
 }
 
@@ -119,7 +121,7 @@ function describe(text, goals) {
 function parseBudgets(md) {
   const out = [];
   for (const line of String(md || '').split('\n')) {
-    const m = /^\|\s*`health:([a-z0-9-]+)`\s*\|\s*([^|]*)\|\s*(\d+(?:\.\d+)?)\s*%\s*\|/.exec(line);
+    const m = /^\|\s*`?health:([a-z0-9-]+)`?\s*\|\s*([^|]*)\|\s*(\d+(?:\.\d+)?)\s*%\s*\|/.exec(line);
     if (m) out.push({ id: m[1], covers: m[2].trim(), cap: Number(m[3]) / 100 });
   }
   return out;

package/workspace/lib/insights-premium.js

@@ -23,6 +23,7 @@
 const IG = require('./insights-goals.js');
 const GS = require('./goal-status.js');   // batch 16 item 6: the one status of a goal, from its readings
 const MR = require('./metric-reads.js');
+const OG = require('./okr-goals.js');   // Intelligence redesign A: the OKR file is the goal list
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const isoDay = (v) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(v || '')); return m ? Date.UTC(+m[1], +m[2] - 1, +m[3]) : null; };
 const shortDate = (v) => { const t = isoDay(v); if (t === null) return ''; const d = new Date(t); return d.getUTCDate() + ' ' + MON[d.getUTCMonth()]; };
@@ -394,17 +395,55 @@ function okrOf(model, drafts) {
   const alert = a ? { rid: a.id, title: a.title, at: a.alert.day, txt: a.reading.txt, line: a.reading.line } : null;
   // the owner the page shows is the goal's owner string: a goal with one has an owner on the ✦ line too
   const named = goals.map((g) => (g.who || !g.owner ? g : Object.assign({}, g, { who: { name: g.owner, initials: GS.initials(g.owner), from: 'pm' } })));
-  return { line: GS.lineOf({ goals: named, drafts, alert, moved: GS.movedOf(named) }), alert };
+  let line = GS.lineOf({ goals: named, drafts, alert, moved: GS.movedOf(named) });
+  // Intelligence redesign A: with nothing read and nothing drafted, the line was "I have not read a goal yet" although the OKR file was read.
+  // It leads with what was read instead, then what waits on a source (grouped by the source the file names).
+  if (model.okrFile && line.tone === 'drafts' && !drafts) line = okrLead(model.okrFile, model.goals || []);
+  return { line, alert, more: moreOf(model) };
+}
+const noun = (n, one, many) => n + ' ' + (n === 1 ? one : many);
+/** The ✦ line from the OKR file (IgA1Open): what was read this week, then what waits on which source. Never a number without a reading. PURE. */
+function okrLead(F, goals) {
+  const krs = F.objectives.flatMap((o) => o.krs), byId = new Map(goals.map((g) => [g.id, g]));
+  const fresh = krs.filter((k) => { const g = k.read && byId.get(k.goal); return g && g.reading && g.reading.ageDays !== null && g.reading.ageDays <= 7; });
+  const per = F.period ? ' for ' + F.period.label : '';
+  const head = fresh.length ? 'Read this week: ' + fresh.slice(0, 2).map((k) => k.token + ' ' + byId.get(k.goal).nowTxt).join(', ') + (fresh.length > 2 ? ' and ' + (fresh.length - 2) + ' more' : '') + '.'
+    : F.read ? 'I read your OKR file: ' + noun(F.total, 'key result', 'key results') + per + ', ' + F.read + ' with a reading.'
+      : 'I read your OKR file: ' + noun(F.total, 'key result', 'key results') + per + '. None has a reading yet.';
+  const wait = Object.entries(F.needs).sort((a, b) => b[1] - a[1]);
+  const nw = wait.reduce((a, [, n]) => a + n, 0);
+  const sub = nw ? noun(nw, 'key result waits', 'key results wait') + ' on a source: ' + wait.slice(0, 3).map(([k, n]) => n + ' on ' + k).join(', ') + (wait.length > 3 ? ', and ' + (wait.length - 3) + ' more' : '') + '. I will not guess a number.' : '';
+  return { head, sub, tone: 'calm', keepAll: 0 };
+}
+/** More ✦ findings after the first line (IgA1Open's pager): outcome checks that are due, and late initiatives. Zero is silence. PURE. */
+function moreOf(model) {
+  const out = [];
+  const due = (model.outcomes || []).filter((r) => r.group === 'verdict' && r.promise && r.promise.overdue);
+  if (due.length) {
+    const r = due[0];
+    out.push({ text: (due.length === 1 ? 'An outcome check is due: ' : due.length + ' outcome checks are due. The oldest: ') + r.title + ', checked by ' + mdDate(r.promise.horizon) + '.',
+      why: r.promise.metric ? 'It promised: ' + clip(r.promise.metric, 140) : 'See Did it work? below.', outcome: r.id });
+  }
+  const late = model.lateRows || [];
+  if (late.length) out.push({ text: noun(late.length, 'initiative is late', 'initiatives are late') + ': ' + late.slice(0, 3).map((r) => r.title + (r.owner ? ' (' + r.owner + ')' : '')).join(', ') + (late.length > 3 ? ', and ' + (late.length - 3) + ' more' : '') + '.', why: 'Late is the Board’s own status for each.' });
+  return out;
 }
 /** Shipped work (Deliver, Monitor, Evaluate, or done) against what its anchor goal promised. PURE. */
-function outcomesOf(inits, goals, outcomes, verdicts, todayIso) {
+/* Intelligence redesign A (IgA3Outcomes): "Decided" and "kept" come only from a recorded verdict (this page's verdict, or the D57 outcome check in
+ * outcome_checks.jsonl). A status word ("done") never makes a row kept: before, "Decided 2 · 2 kept" showed with no verdict recorded anywhere.
+ * promises: { [initiative id]: { metric, horizon, disposition } } from lib/outcomes.js scan; a check date that has passed makes the row due. */
+const DISPO = { validated: 'Keep', refuted: 'Stop', inconclusive: 'Iterate' };
+function outcomesOf(inits, goals, outcomes, verdicts, todayIso, promises) {
   const ORDER = ['verdict', 'window', 'decided'];
   const rows = (inits || []).map(initOf).filter((r) => r.idx >= 5 || r.status === 'done');
   return rows.map((r) => {
     const g = goals.find((x) => anchorHits(r.anchor, { id: x.id, name: (outcomes.find((o) => o.id === x.id) || {}).name })) || null;
-    const vd = (verdicts && verdicts[r.id]) || null, o = g ? outcomes.find((x) => x.id === g.id) : null;
-    const group = vd || r.status === 'done' || r.status === 'cancelled' ? 'decided' : r.idx === 7 ? 'verdict' : 'window';
-    return Object.assign(r, { group, verdict: vd ? { verdict: vd.verdict, learned: vd.learned, at: vd.at ? String(vd.at).slice(0, 10) : null } : null,
+    const pr = (promises && promises[r.id]) || null;
+    const vd0 = (verdicts && verdicts[r.id]) || null, vd = vd0 || (pr && pr.disposition ? { verdict: DISPO[pr.disposition] || 'Iterate', learned: '', at: null, check: true } : null), o = g ? outcomes.find((x) => x.id === g.id) : null;
+    const dueNow = !!(pr && pr.horizon && pr.horizon <= todayIso);
+    const group = vd || r.status === 'cancelled' ? 'decided' : r.idx === 7 || r.status === 'done' || dueNow ? 'verdict' : 'window';
+    return Object.assign(r, { group, promise: pr ? { metric: pr.metric ? clip(pr.metric, 160) : '', horizon: pr.horizon || null, overdue: dueNow && !vd } : null,
+      verdict: vd ? { verdict: vd.verdict, learned: vd.learned || '', at: vd.at ? String(vd.at).slice(0, 10) : null, check: !!vd.check } : null,
       window: IG.windowOf({ shipAt: r.endAt, byAt: g ? g.byAt : null, verdict: vd, today: todayIso }),
       evidence: g && o ? IG.evidenceOf((o.readings || []).map((x) => ({ at: String(x.at), v: x.v })), r.endAt, g.unit) : [], goal: g ? { id: g.id, key: g.key, title: g.title, type: g.type, baseTxt: g.baseTxt, targetTxt: g.targetTxt, nowTxt: g.nowTxt, by: g.by, done: g.done, tone: g.tone, pace: g.pace } : null });
   }).sort((a, b) => ORDER.indexOf(a.group) - ORDER.indexOf(b.group));
@@ -412,6 +451,8 @@ function outcomesOf(inits, goals, outcomes, verdicts, todayIso) {
 
 /** The health budgets the board's initiatives anchor to (D59: an anchor health:<id>). A budget's floor or ceiling and its weekly readings are not
  * read on this page, so a budget holds only its id and what moves it. PURE. */
+/** A PMOS kit chore in a product repository: its work is on PMOS itself (adopting the kit, its gates, its paths), not on the product. */
+const isKitChore = (r) => !!r && /\b(pmos|kit|create-pmos)\b/i.test(String(r.title || '') + ' ' + String(r.id || '')) && (r.lane === 'chore' || /^health:/.test(String(r.anchor || '')));
 function budgetsOf(inits, registry) {
   const by = new Map();
   for (const b of registry || []) by.set(b.id, []);
@@ -476,11 +517,16 @@ function build(facts) {
   model.goals = goalsOf(outcomes, charts, f.initiatives || [], today, f.goalMeta || {}, f.watch || null);
   model.initiativesRead = Array.isArray(f.initiatives);
   const ins = f.ins || { charts: {}, verdicts: {}, targets: {} }, bid = board.id || '';
-  model.outcomes = outcomesOf(f.initiatives || [], model.goals, outcomes, ins.verdicts[bid] || {}, model.today);
-  model.budgets = budgetsOf(f.initiatives || [], f.budgets || []);
+  model.outcomes = outcomesOf(f.initiatives || [], model.goals, outcomes, ins.verdicts[bid] || {}, model.today, f.promises || null);
+  model.self = f.self === true;
+  // a product's budgets count its own work: the PMOS kit's chores in a product repository (kit adoption, the gates) are not its health work
+  model.budgets = budgetsOf(model.self ? f.initiatives || [] : (f.initiatives || []).filter((r) => !isKitChore(r)), f.budgets || []);
   model.budgetsRead = Array.isArray(f.budgets);
   budgetWatch(model.budgets, model.goals);
   model.metrics = GS.metricsOf(model.goals);
+  // Intelligence redesign A: the OKR file is the goal list; a KR metric record is a key result's reader (lib/okr-goals.js)
+  model.okrFile = OG.build({ okr: f.okr, goals: model.goals, initiatives: (f.initiatives || []).map(initOf), records: f.goalMeta || {}, today: model.today });
+  model.lateRows = Array.isArray(f.initiatives) ? f.initiatives.filter((r) => r && r.status === 'late').map(initOf) : [];
   model.okr = okrOf(model, (f.watch && f.watch.drafts) || 0);
   model.lateNow = Array.isArray(f.initiatives) ? f.initiatives.filter((r) => r && r.status === 'late').length : null;
   model.trends = Object.assign(IG.trendsOf(Array.isArray(f.initiatives) ? f.initiatives : null, model.today), { targets: ins.targets || {}, tiles: ins.tiles || {} });

package/workspace/lib/okr-goals.js

@@ -0,0 +1,200 @@
+'use strict';
+/* okr-goals.js — the OKR file is the goal list (Intelligence redesign A, frames IgA1Open, IgA2Goal; brief /mnt/project-files/intelligence-grill/brief-A-build.md).
+ *
+ *   read(root)                       → { ok, files, period, objectives, error }   the OKR documents of a workspace, parsed (no other read)
+ *   parse(text, file)                → { title, period, supersedes, objectives }    one document. PURE
+ *   periodOf(text, file)             → { label, short, from, to } | null            the document's period: a quarter, a half or a quarter range. PURE
+ *   matchAnchor(anchor, objectives)  → { o, k } | null                              the key result an initiative's parent_kr names. PURE
+ *   build({ okr, goals, initiatives, records, today }) → the model's okrFile. PURE
+ *
+ * WHY. Every product keeps an OKR file (IDPF: okrs-h2-2026.md, 10 key results), and the Board anchors initiatives to it (KR-A1, O-C.KR-C1), but
+ * Intelligence listed only the KR metric records, so IDPF showed 1 goal and OOH 0. Here the file's key results are the list. A KR metric record is
+ * a key result's READER (its readings and recipe), attached by its `kr` field or by its title naming the key result's id; it is never a second
+ * goal. A key result with no reader says what it needs (the source the file names), never a number (the proven-only rule).
+ *
+ * Where the files are: a product repository keeps them at pmos/planning/okrs/ (the kit layout); the PMOS repository at planning/okrs/. A file that
+ * says "Supersedes `okrs-…-v3.md`" drops that file. health-budgets.md, domains.md and kill-conditions.md declare no objective, so they are skipped.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const MONTHS = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'];
+const DAY = 864e5;
+const NOT_OKR = new Set(['health-budgets.md', 'domains.md', 'kill-conditions.md', 'index.md', 'log.md']);
+
+/* Tokens as scripts/anchor-resolve.js reads them: an objective is O1, O-A or "Objective 1"; a key result is KR1, KR1.2 or KR-A1. */
+const OBJ = '(O\\d+|O-[A-Za-z][A-Za-z0-9-]*|[Oo]bjective\\s*\\d+)';
+const KR = '(KR\\d+(?:\\.\\d+)*|KR-[A-Za-z][A-Za-z0-9-]*)';
+const END = '(?![A-Za-z0-9]|\\.\\d)';
+const RE_OBJ = new RegExp('^#{1,3}\\s+(?:\\*\\*)?' + OBJ + END + '(?:\\*\\*)?\\s*(?:[—–:-]\\s*(.*))?$');
+const RE_KR = new RegExp('^\\s*[-*]\\s*(\\*\\*)?\\s*' + KR + END + '(.*)$');
+const objId = (t) => { const s = String(t || '').trim(), n = /^objective\s*(\d+)$/i.exec(s); if (n) return 'o' + n[1]; const m = /^O-(.+)$/i.exec(s); return (m ? m[1] : s).toLowerCase(); };
+const krId = (t) => String(t || '').trim().toLowerCase();
+const clean = (s) => String(s == null ? '' : s).replace(/\*\*|`|\*/g, '').replace(/\[([^\]]+)\]\([^)]*\)/g, '$1').replace(/\s+/g, ' ').trim();
+const clip = (s, n) => { s = clean(s); return s.length > n ? s.slice(0, n - 1).replace(/\s+\S*$/, '') + '…' : s; };
+const qEnd = (y, q) => Date.UTC(y, q * 3, 0);
+const iso = (t) => new Date(t).toISOString().slice(0, 10);
+
+/** The document's period. A quarter range in the title ("FY2026 Q3 → FY2027 Q1") wins; then a `period:` line or the title or the file name:
+ *  "2026-H2", "H2 2026", "2026-Q3", "Q3 2026". → { label, short, from, to } (UTC ms) or null. PURE. */
+function periodOf(text, file) {
+  const s = String(text || ''), h1 = (/^#\s+(.+)$/m.exec(s) || [])[1] || '';
+  const qs = [...h1.matchAll(/(?:FY)?\s*(\d{4})\s*[-\s]?\s*Q([1-4])|Q([1-4])\s*[-\s]?\s*(?:FY)?\s*(\d{4})/gi)].map((m) => ({ y: +(m[1] || m[4]), q: +(m[2] || m[3]) }));
+  if (qs.length >= 2) {
+    const a = qs[0], b = qs[qs.length - 1];
+    if (b.y * 4 + b.q > a.y * 4 + a.q) return { label: 'Q' + a.q + ' ' + a.y + ' – Q' + b.q + ' ' + b.y, short: 'Q' + a.q + '–Q' + b.q, from: Date.UTC(a.y, (a.q - 1) * 3, 1), to: qEnd(b.y, b.q) };
+  }
+  const line = (/^\s*[-*]?\s*(?:.*?)\**period\**\s*:\**\s*([^·\n(]+)/im.exec(s) || [])[1] || '';
+  for (const src of [line, h1, path.basename(String(file || ''), '.md')]) {
+    let m = /(\d{4})\s*[-\s]?\s*H([12])(?![0-9])|(?<![A-Za-z])H([12])\s*[-\s]?\s*(\d{4})/i.exec(src);
+    if (m) { const y = +(m[1] || m[4]), h = +(m[2] || m[3]); return { label: 'H' + h + ' ' + y, short: 'H' + h, from: Date.UTC(y, (h - 1) * 6, 1), to: Date.UTC(y, h * 6, 0) }; }
+    m = /(\d{4})\s*[-\s]?\s*Q([1-4])(?![0-9])|(?<![A-Za-z])Q([1-4])\s*[-\s]?\s*(\d{4})/i.exec(src);
+    if (m) { const y = +(m[1] || m[4]), q = +(m[2] || m[3]); return { label: 'Q' + q + ' ' + y, short: 'Q' + q, from: Date.UTC(y, (q - 1) * 3, 1), to: qEnd(y, q) }; }
+  }
+  return null;
+}
+
+/** The day a key result is due, from its words: "by Dec 2026", "by end of FY2026 Q4", "by Q1 2027", "by end-Jul 2026". null when it names none. */
+function dueOf(text) {
+  const s = String(text || '');
+  let m = /\b(?:by|through)\s+(?:the\s+)?(?:end[-\s]+(?:of\s+)?)?(?:FY\s*)?(\d{4})\s*Q([1-4])\b|\bby\s+(?:the\s+)?(?:end[-\s]+(?:of\s+)?)?Q([1-4])\s*(?:FY\s*)?(\d{4})\b/i.exec(s);
+  if (m) return iso(qEnd(+(m[1] || m[4]), +(m[2] || m[3])));
+  m = /\b(?:by|through)\s+(?:the\s+)?(?:end[-\s]+(?:of\s+)?)?([A-Za-z]{3,9})\.?\s+(\d{4})\b/i.exec(s);
+  if (m) { const i = MONTHS.findIndex((x) => x.startsWith(m[1].toLowerCase().slice(0, 3))); if (i >= 0) return iso(Date.UTC(+m[2], i + 1, 0)); }
+  m = /\bby\s+(\d{1,2})\s+([A-Za-z]{3,9})\s+(\d{4})\b/i.exec(s);
+  if (m) { const i = MONTHS.findIndex((x) => x.startsWith(m[2].toLowerCase().slice(0, 3))); if (i >= 0) return iso(Date.UTC(+m[3], i, +m[1])); }
+  return null;
+}
+/** Where a key result is read from, in the file's words: "*Source:* x." or "Measured by: x." → the first clause, without links or code marks. */
+function sourceOf(text) {
+  const m = /(?:\*Source:\*|\bSource:|\bMeasured by:)\s*([^]*?)(?:\.\s|\.$|\*[A-Z][a-z]+:\*|$)/.exec(String(text || ''));
+  return m ? clip(m[1], 90) : '';
+}
+/** What a source needs, said as a connector or a place, never a path: a host name, New Relic, ServiceNow, Jira, or the words the file uses. */
+function needOf(source, host) {
+  const s = String(source || '');
+  if (!s || /^tbd\b/i.test(s)) return '';
+  if (/new relic/i.test(s)) return 'New Relic';
+  if (/servicenow/i.test(s)) return 'ServiceNow';
+  if (/\bjira\b/i.test(s)) return 'Jira';
+  const h = /\b([a-z0-9-]+(?:\.[a-z0-9-]+)+\.[a-z]{2,})(?:\/|\b)/i.exec(s);
+  if (h) return h[1];
+  if (/^\/[a-z]/i.test(s) && host) return host;
+  return clip(s, 60);
+}
+/** The line under a key result's name: "60.2% → ≥ 70% by Dec 2026", from "Baseline: … Target: …" or the bolded numbers. */
+function lineOf(text, due) {
+  const t = String(text || '');
+  const b = /\bBaseline:\s*([^.]+?)\.\s/i.exec(t), g = /\bTarget:\s*([^.]+?)(?:\.\s|;|$)/i.exec(t);
+  const bt = b && !/^tbd\b/i.test(clean(b[1])) ? clean(b[1]) : '';
+  if (bt || g) return clip([bt, g ? clean(g[1]) : ''].filter(Boolean).join(' → '), 110);
+  const bold = [...t.matchAll(/\*\*([^*]+)\*\*/g)].map((m) => clean(m[1])).filter((x) => /\d|parity|zero|go\/no-go/i.test(x));
+  const by = due ? ' by ' + MON[new Date(Date.parse(due)).getUTCMonth()] + ' ' + new Date(Date.parse(due)).getUTCFullYear() : '';
+  return bold.length ? clip(bold.slice(0, 2).join(' → ') + by, 110) : '';
+}
+
+/** One OKR document → { title, period, supersedes: [file names], objectives: [{ id, token, title, krs: [{ id, token, title, text, line, source, need, due, proposed, decision }] }] }. PURE. */
+function parse(text, file) {
+  const s = String(text || ''), lines = s.split('\n');
+  const objectives = [];
+  let cur = null, kr = null;
+  const close = () => { if (!kr) return; const t = kr.raw.join(' '); kr.text = clean(t); kr.due = dueOf(clean(t)); kr.source = sourceOf(t); kr.line = lineOf(t, kr.due); kr.proposed = kr.proposed || /\bPROPOSED\b/.test(t); kr.decision = /go\/no-go|\bdecided by\b|\bdecision\b/i.test(kr.title + ' ' + t.slice(0, 200)); delete kr.raw; kr = null; };
+  for (const line of lines) {
+    const o = RE_OBJ.exec(line);
+    if (o) { close(); cur = { id: objId(o[1]), token: o[1].replace(/\s+/g, ' '), title: clean(o[2] || ''), krs: [] }; objectives.push(cur); continue; }
+    if (/^#{1,6}\s/.test(line) || /^---\s*$/.test(line)) { close(); if (/^#{1,6}\s/.test(line)) cur = null; continue; }
+    const k = cur ? RE_KR.exec(line) : null;
+    if (k && !/^\s*(\*\*)?\s*(,|;|&|(and|or)\b)/i.test(k[3])) {
+      close();
+      let rest = k[3], title;
+      let body = rest;   // the words after the name: where the numbers are
+      if (k[1] && /^\s*\*\*/.test(rest)) { body = rest.replace(/^\s*\*\*/, '').replace(/^\s*[—–:.-]?\s*/, ''); title = body.split(/\.\s/)[0]; }   // **KR1.2** — name
+      else if (k[1]) { rest = rest.replace(/^\s*[—–:.-]?\s*/, ''); const e = rest.indexOf('**'); title = e >= 0 ? rest.slice(0, e) : rest.split(/\.\s/)[0]; body = e >= 0 ? rest.slice(e + 2) : rest; }
+      else { body = rest.replace(/^\s*[—–:.-]?\s*/, ''); title = body.split(/\.\s/)[0]; }
+      title = clean(title).replace(/^PROPOSED:\s*/i, '').replace(/\.$/, '');
+      if (!cur.krs.some((x) => x.id === krId(k[2]))) { kr = { id: krId(k[2]), token: k[2], title: clip(title, 110), proposed: /\bPROPOSED\b/.test(line), raw: [body] }; cur.krs.push(kr); }
+      continue;
+    }
+    if (kr) { if (/^\s*$/.test(line) || /^\s*[-*]\s/.test(line) && !/^\s{2,}/.test(line)) close(); else kr.raw.push(line); }
+  }
+  close();
+  // a host named once in the file is where its relative sources ("/native/login") live
+  const host = (/\b([a-z0-9-]+(?:\.[a-z0-9-]+)*\.(?:app|com|io|net|org|sg))\b/i.exec(s) || [])[1] || '';
+  for (const ob of objectives) for (const k of ob.krs) k.need = needOf(k.source, host);
+  const supersedes = [...s.matchAll(/\bSupersedes\s+`?([\w.-]+\.md)`?/gi)].map((m) => m[1]);
+  return { title: clean((/^#\s+(.+)$/m.exec(s) || [])[1] || ''), period: periodOf(s, file), supersedes, objectives: objectives.filter((o) => o.krs.length) };
+}
+
+/** The OKR documents of a workspace: pmos/planning/okrs/ first (a product repository), else planning/okrs/. Never throws. */
+function read(root) {
+  const dirs = [path.join(root, 'pmos', 'planning', 'okrs'), path.join(root, 'planning', 'okrs')];
+  for (const dir of dirs) {
+    let names;
+    try { names = fs.readdirSync(dir).filter((f) => f.endsWith('.md') && !NOT_OKR.has(f)).sort(); } catch { continue; }
+    const docs = [];
+    for (const f of names) {
+      try { const d = parse(fs.readFileSync(path.join(dir, f), 'utf8'), f); if (d.objectives.length) docs.push(Object.assign(d, { file: f })); } catch { /* an unreadable file declares nothing */ }
+    }
+    if (!docs.length) continue;
+    const gone = new Set(docs.flatMap((d) => d.supersedes));
+    const live = docs.filter((d) => !gone.has(d.file));
+    const use = live.length ? live : docs;
+    // one period for the page: the one of the newest document that names one (the files sort by name, so the last is the newest)
+    const withP = use.filter((d) => d.period);
+    const objectives = [], seen = new Set();
+    for (const d of use) for (const o of d.objectives) { const k = o.id; if (seen.has(k)) continue; seen.add(k); objectives.push(o); }
+    return { ok: true, files: use.map((d) => d.file), period: withP.length ? withP[withP.length - 1].period : null, objectives, error: null };
+  }
+  return { ok: false, files: [], period: null, objectives: [], error: 'no OKR file' };
+}
+
+/** The key result an anchor names: "KR-A1", "O-A.KR-A1", "okrs-q3-2026 → O1.KR1", "KR1.2 — … (pmos/planning/okrs/…v3.md)". A key result id
+ *  with no objective is matched when exactly one objective declares it. → { o, k } | null. PURE. */
+function matchAnchor(anchor, objectives) {
+  const s = String(anchor || '').replace(/\*\*/g, '').trim();
+  if (!s || /^(health|domain):/i.test(s)) return null;
+  const km = new RegExp('(?:^|[^A-Za-z0-9])' + KR + END).exec(s);
+  if (!km) return null;
+  const om = new RegExp('(?:^|[^A-Za-z0-9])' + OBJ + END).exec(s.slice(0, km.index + 1));
+  const kid = krId(km[1]), oid = om ? objId(om[1]) : null;
+  const hits = [];
+  for (const o of objectives || []) { if (oid && o.id !== oid) continue; const k = o.krs.find((x) => x.id === kid); if (k) hits.push({ o, k }); }
+  return hits.length === 1 ? hits[0] : null;
+}
+
+/** The record that reads a key result: its `kr` anchor names the key result, or its title starts with the key result's id. PURE. */
+function readerOf(o, k, goals) {
+  const G = goals || [];
+  return G.find((g) => { const m = g.kr ? matchAnchor(g.kr, [o]) : null; return m && m.k.id === k.id; })
+    || G.find((g) => new RegExp('^\\s*(?:' + o.token.replace(/[-.]/g, '\\$&') + '[.\\s]*)?' + k.token.replace(/[-.]/g, '\\$&') + END, 'i').test(String(g.title || '')))
+    || null;
+}
+
+/** The model's okrFile: the objectives and their key results, each with its reader (a goal of the model, by id), the initiatives that move it,
+ *  and what it needs when nothing reads it. Counts for the ✦ line and the All products row. PURE.
+ *  okr: read(); goals: the model's goals (each may carry `kr`, from its record); initiatives: the board rows (initOf'd); records: { [rid]: record } */
+function build({ okr, goals, initiatives, records, today }) {
+  if (!okr || !okr.ok || !okr.objectives.length) return null;
+  const G = (goals || []).map((g) => Object.assign({}, g, { kr: (records && records[g.id] && records[g.id].kr) || g.kr || null }));
+  const used = new Set();
+  const t = Date.parse(String(today || '').slice(0, 10)) || Date.now();
+  const P = okr.period ? Object.assign({}, okr.period, { day: t >= okr.period.from && t <= okr.period.to ? Math.round((t - okr.period.from) / DAY) + 1 : 0, days: Math.round((okr.period.to - okr.period.from) / DAY) + 1, fromAt: iso(okr.period.from), toAt: iso(okr.period.to) }) : null;
+  const moversOf = new Map();
+  for (const r of initiatives || []) { const m = matchAnchor(r.anchor, okr.objectives); if (!m) continue; const key = m.o.id + '::' + m.k.id; if (!moversOf.has(key)) moversOf.set(key, []); moversOf.get(key).push(r); }
+  const objectives = okr.objectives.map((o) => ({
+    id: o.id, token: o.token, title: o.title,
+    krs: o.krs.map((k) => {
+      const g = readerOf(o, k, G); if (g) used.add(g.id);
+      const read = !!(g && g.readings > 0);
+      return { key: o.id + '::' + k.id, token: k.token, title: k.title, line: k.line, due: k.due, proposed: k.proposed, decision: k.decision,
+        goal: g ? g.id : null, read, need: read || k.decision ? '' : g && g.recipe ? '' : k.need, source: k.source, moves: moversOf.get(o.id + '::' + k.id) || [] };
+    }),
+  }));
+  const krs = objectives.flatMap((o) => o.krs);
+  const needs = {};
+  for (const k of krs) if (!k.read && k.need) needs[k.need] = (needs[k.need] || 0) + 1;
+  return { files: okr.files, period: P, objectives, total: krs.length, read: krs.filter((k) => k.read).length, needs, readers: [...used] };
+}
+
+module.exports = { read, parse, periodOf, dueOf, sourceOf, needOf, matchAnchor, readerOf, build };

package/workspace/lib/report-acts.js

@@ -0,0 +1,189 @@
+'use strict';
+/* report-acts.js — the one ✓ of a report that waits for the PM, in Reports and dashboards (Reports and dashboards redesign R, frame RgR1Panel;
+ * brief /mnt/project-files/intelligence-grill/brief-E-R-build.md step 9).
+ *
+ *   defTitleOf(def)                       → the definition's title as a report name: "Daily report definition" → "Daily report". PURE
+ *   reportAboutOf(text, boards, here)        → { ws, name } of the one OTHER product a report names, or null. PURE
+ *   reportActOf({ id, setup, rows, def, about, sha }) → { act, label, … } | null    the report's one press. PURE
+ *   reportActsOf(facts)                      → { [report id]: act } for every report of the model, and { names, about }. PURE
+ *   leadOf(text)                       the opening sentence, past a line that only says the definition is not confirmed yet. PURE
+ *
+ * WHY. The grill (3 Nov, on 0.514.0) found the five drafts that wait for the PM at the bottom of the panel, under "Yours", named by their id
+ * ("daily"), previewed by the warning "this definition is a draft", and with no press that settles them. Each waiting report now has ONE ✓,
+ * the act that unblocks it, in this order:
+ *   move     the report is about another product than the one it sits in (Scarlet assessment in the IDPF workspace) → "Move to Scarlet"
+ *   confirm  its draft follows a definition an agent proposed and nobody has confirmed (status: draft, no setup) → "Confirm the definition"
+ *   issue    a draft waits and its definition is confirmed → "Issue" (POST /api/report/issue with the sha of the file as read)
+ *   resume   a set-up report is paused → "Resume"
+ * A report with none of these is not waiting for the PM and gets no ✓ (zero is silence).
+ *
+ * WHAT A NAME MATCHES. A product is named when its board name, as a whole word of four letters or more, is in the report's name or purpose and
+ * the product it sits in is not named too. Two other products named → no move: the report does not say which one it is about.
+ */
+const fs = require('fs');
+const path = require('path');
+const RS = () => require('./report-setups.js');   // read late: report-setups is wide, and this file only writes through its one writer
+const refuse = (status, error) => ({ ok: false, status, error });
+const clean = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** "Daily report definition" → "Daily report"; "Scarlet assessment report definition" → "Scarlet assessment report". '' when there is none. PURE. */
+function defTitleOf(def) {
+  const t = clean(def && def.title).replace(/^["']|["']$/g, '');
+  if (!t || (def && t === def.id)) return '';
+  return t.replace(/\s+(definition|template)$/i, '').replace(/\s+template$/i, '').trim();
+}
+
+/** A product's name in `text` as a whole word (case-insensitive). Names shorter than four letters never match: "PI" is not a product name in prose. */
+function mentionsProduct(text, name) {
+  const n = clean(name);
+  if (n.length < 4) return false;
+  return new RegExp('(^|[^A-Za-z0-9])' + escRe(n) + '(?![A-Za-z0-9])', 'i').test(String(text || ''));
+}
+
+/** The one other product a report is about. boards: [{ ws, name }]; here: the ws it sits in. → { ws, name } | null. PURE. */
+function reportAboutOf(text, boards, here) {
+  const B = (boards || []).filter((b) => b && b.ws && b.name);
+  const mine = B.find((b) => b.ws === here);
+  if (mine && mentionsProduct(text, mine.name)) return null;
+  const hit = B.filter((b) => b.ws !== here && mentionsProduct(text, b.name));
+  return hit.length === 1 ? { ws: hit[0].ws, name: clean(hit[0].name) } : null;
+}
+
+/** A report's one press. rows: its files, newest first ({ slot, state, path, archived }); setup: its setup or null; def: its definition or null.
+ *  → { act: 'move'|'confirm'|'issue'|'resume', label, … } | null. PURE. */
+function reportActOf({ id, setup, rows, def, about, sha }) {
+  const live = (rows || []).filter((r) => r && !r.archived);
+  const draft = live.find((r) => r.state !== 'issued') || null;
+  const issued = live.some((r) => r.state === 'issued');
+  if (about && setup && !issued) return { act: 'move', label: 'Move to ' + about.name, to: about.ws, toName: about.name, id };
+  if (setup && setup.paused) return { act: 'resume', label: 'Resume', id };
+  if (!draft) return null;
+  // an agent-written definition (the daily, weekly and monthly skills write status: draft and only the PM confirms it). A report the PM set up
+  // wrote its own definition with that press, so its draft is issued
+  if (!setup && def && def.status === 'draft') return { act: 'confirm', label: 'Confirm the definition', id, slot: draft.slot };
+  return { act: 'issue', label: 'Issue', id, slot: draft.slot, sha: sha || null, path: draft.path || '' };
+}
+
+/** Every report's press and display name. f: { rows, setups, defs, boards, here, shas }. → { acts, names, about }. PURE. */
+function reportActsOf(f) {
+  const rows = (f.rows || []).filter(Boolean), setups = (f.setups || []).filter(Boolean), defs = new Map((f.defs || []).filter(Boolean).map((d) => [d.id, d]));
+  const ids = [...new Set(setups.map((s) => s.id).concat(rows.map((r) => r.cadence)))];
+  const acts = {}, nameOf = {}, about = {};
+  for (const id of ids) {
+    const setup = setups.find((s) => s.id === id) || null, def = defs.get(id) || null, mine = rows.filter((r) => r.cadence === id);
+    const t = defTitleOf(def);
+    if (!setup && t) nameOf[id] = t;
+    const a = setup ? reportAboutOf([setup.name, setup.purpose].join(' · '), f.boards, f.here) : null;
+    if (a) about[id] = a;
+    const draft = mine.find((r) => !r.archived && r.state !== 'issued');
+    const act = reportActOf({ id, setup, rows: mine, def, about: a, sha: draft && f.shas ? f.shas[draft.path] : null });
+    if (act) acts[id] = act;
+  }
+  return { acts, names: nameOf, about };
+}
+
+/** A line that only says the definition is not confirmed: the daily skill puts it first in the Headline (report-daily.skill step 6). */
+const WARN = /\bdefinition\b[^.]*\b(draft|unconfirmed|not (yet )?confirmed|proposed|waits? for your)\b|\b(draft|unconfirmed|proposed)\b[^.]*\bdefinition\b/i;
+/** The opening sentence of a report, past the definition warning: its headline is the preview. `lead` is the caller's leadOf (insights-premium). PURE. */
+function leadPastWarning(text, lead) {
+  const first = lead(text);
+  if (!first || !WARN.test(first)) return first;
+  const t = String(text || ''), at = t.indexOf(first.replace(/…$/, '').slice(0, 40));
+  // the same paragraph's next sentence, else the next paragraph
+  if (at >= 0) {
+    const rest = t.slice(at).replace(/^[^]*?[.!?](\s+|$)/, '');
+    const next = lead('\n\n' + rest);
+    if (next && !WARN.test(next)) return next;
+  }
+  return '';
+}
+
+// ── the writes of the ✓ (their routes: lib/routes-report-setups.js confirm and move) ─────────────────────────────────────────────
+/** Confirm a definition (Reports and dashboards redesign R): the PM's ✓ turns `status: draft` into `status: stable` in its frontmatter. Only
+ *  that line changes. A definition with no frontmatter status, or one confirmed already, is left as it is. → { ok, path, sha, unchanged? } */
+function confirmDefinition(root, id, opts = {}) {
+  if (!RS().ID_RE.test(String(id || ''))) return refuse(400, 'the id is lower-case letters, digits and "-"');
+  const file = RS().definitionFile(root, id), rel = require('./report-draft.js').definitionPath(root, id);
+  let cur;
+  try { cur = fs.readFileSync(file, 'utf8'); } catch { return refuse(404, `there is no definition ${rel}`); }
+  const m = /^(---\r?\n)([\s\S]*?)(\r?\n---)/.exec(cur);
+  if (!m) return refuse(409, `${rel} has no frontmatter, so there is no status to confirm`);
+  if (!/^status:\s*["']?draft["']?\s*$/m.test(m[2])) return { ok: true, path: rel, sha: RS().shaOf(cur), unchanged: true };
+  const next = m[1] + m[2].replace(/^status:\s*["']?draft["']?\s*$/m, 'status: stable') + m[3] + cur.slice(m[0].length);
+  const tmp = file + '.tmp-' + process.pid;
+  try { fs.writeFileSync(tmp, next); fs.renameSync(tmp, file); } catch (e) { try { fs.unlinkSync(tmp); } catch { /* none */ } return refuse(500, 'could not write the definition; nothing changed: ' + String((e && e.message) || e).slice(0, 160)); }
+  void opts;
+  return { ok: true, path: rel, sha: RS().shaOf(next) };
+}
+
+/** Copy a folder's files, recursively, refusing to overwrite. → the repository-relative paths written under `to`. */
+function copyReportTree(from, to) {
+  const out = [];
+  fs.mkdirSync(to, { recursive: true });
+  for (const e of fs.readdirSync(from, { withFileTypes: true })) {
+    const a = path.join(from, e.name), b = path.join(to, e.name);
+    if (e.isDirectory()) out.push(...copyReportTree(a, b));
+    else if (e.isFile()) { fs.copyFileSync(a, b, fs.constants.COPYFILE_EXCL); out.push(b); }
+  }
+  return out;
+}
+
+/**
+ * Move a set-up report to the product it is about (Reports and dashboards redesign R, "✦ Move to Scarlet"): its definition, its drafts and its
+ * setup line go to `toRoot`, and it is removed here. A report with an ISSUED issue is refused (409): an issued report is never moved or deleted,
+ * it stays where it was issued. The id must be free in the target. Everything is copied before anything is removed here, so a failed copy
+ * leaves this workspace as it was (and removes what it copied). → { ok, id, moved: [rel] } | { ok: false, status, error }
+ */
+function moveReportTo(root, id, toRoot, opts = {}) {
+  const abs = path.resolve(String(root)), to = path.resolve(String(toRoot || ''));
+  if (!toRoot || to === abs) return refuse(400, 'say which product to move it to');
+  const file = RS().ledgerFile(abs), st = RS().fold(RS().readLines(file)), cur = st.setups.get(id);
+  if (!cur) return refuse(404, `no recurring report ${String(id).slice(0, 40)}`);
+  const docs = (require('./report-needs.js').reportsOf(abs).reports || []).filter((r) => r.cadence === id);
+  if (docs.some((r) => r.issued)) return refuse(409, `${cur.name} has issued reports. An issued report stays where it was issued, so it was not moved`);
+  const tst = RS().fold(RS().readLines(RS().ledgerFile(to)));
+  const srcDef = RS().definitionFile(abs, id), dstDef = RS().definitionFile(to, id);
+  const srcDir = path.join(RS().stateDir(abs), 'reports', id), dstDir = path.join(RS().stateDir(to), 'reports', id);
+  if (tst.setups.has(id) || fs.existsSync(dstDef) || fs.existsSync(dstDir)) return refuse(409, `${id} is taken in that product already. Nothing was moved`);
+  const now = opts.now == null ? new Date() : new Date(opts.now);
+  const written = [];
+  try {
+    if (fs.existsSync(srcDef)) {
+      const t = fs.readFileSync(srcDef, 'utf8').replace(/^(product:\s*).*$/m, '$1' + JSON.stringify(path.basename(to)));
+      fs.mkdirSync(path.dirname(dstDef), { recursive: true }); fs.writeFileSync(dstDef, t, { flag: 'wx' }); written.push(dstDef);
+    }
+    if (fs.existsSync(srcDir)) written.push(...copyReportTree(srcDir, dstDir));
+  } catch (e) {
+    for (const w of written.reverse()) { try { fs.unlinkSync(w); } catch { /* gone */ } }
+    try { fs.rmSync(dstDir, { recursive: true, force: true }); } catch { /* gone */ }
+    return refuse(500, 'the copy failed, so nothing was moved: ' + String((e && e.message) || e).slice(0, 160));
+  }
+  // the setup line in the target, as it is here, with its new home; then the schedule moves and it is removed here
+  const line = { ev: 'setup' };
+  for (const k of ['id', 'name', 'purpose', 'audience', 'source', 'output', 'schedule', 'sources', 'sections', 'learned_from', 'fixes', 'last_run', 'def_sha', 'from', 'storyline', 'ready']) if (cur[k] !== undefined) line[k] = cur[k];
+  line.product = path.basename(to); line.ws = opts.toWsId || null; line.moved_from = path.basename(abs);
+  RS().append(RS().ledgerFile(to), line, { now, by: opts.by });
+  if (cur.status === 'paused') RS().append(RS().ledgerFile(to), { ev: 'pause', id }, { now, by: opts.by });
+  if (cur.source === 'work') {
+    RS().unregisterSchedule(opts.scheduleStore, cur, opts.wsId);
+    if (cur.status !== 'paused') RS().registerSchedule(opts.scheduleStore, Object.assign({}, cur, { product: line.product }), { wsId: opts.toWsId, lastRun: cur.last_run, now });
+  }
+  RS().append(file, { ev: 'remove', id }, { now, by: opts.by });
+  try { if (fs.existsSync(srcDef)) fs.unlinkSync(srcDef); } catch { /* the copy is in place; a stale definition here is harmless */ }
+  try { fs.rmSync(srcDir, { recursive: true, force: true }); } catch { /* the drafts stay here too */ }
+  return { ok: true, id, moved: written.map((w) => path.relative(to, w)) };
+}
+
+/** The product page's ✦ line is Intelligence's (RgR4Make, "one brain"). The grill found the product page saying "2 things are behind: KR-C4,
+ *  KR-A1 · weekly update ready" while Intelligence said "I have not read a goal yet". Both now read the same model's line (lib/insights-premium.js
+ *  okrOf → model.okr.line); "Your weekly update is ready to send" follows it only in a week with news. Without that line, the dashboard's own
+ *  line stays. PURE. */
+function productLineOfIntel(intel, { deskReady, news, fallback }) {
+  const L = intel && intel.okr && intel.okr.line;
+  if (!L || !L.head) return fallback;
+  const rest = [L.sub || '', deskReady && news ? 'Your weekly update is ready to send.' : ''].filter(Boolean).join(' ');
+  return { lead: L.head, rest, tone: L.tone === 'crit' || L.tone === 'behind' ? 'warn' : 'calm' };
+}
+
+module.exports = { defTitleOf, reportAboutOf, reportActOf, reportActsOf, leadPastWarning, WARN, confirmDefinition, moveReportTo, productLineOfIntel };