create-pmos 0.133.0 → 0.135.0

package/workspace/lib/engine/signals/detectors.js

@@ -0,0 +1,370 @@
+'use strict';
+// Detector registry. Each detector is a pure function over a normalized facts object (see facts.js) that
+// returns signals in the shared schema:
+//   {id, page, key, entity, magnitude 0..1, deadlineDays, deadlineSource?, lens?, isNew?, irreversible?, positive?,
+//    policyCritical?, promiseMissed?, strategic?, child?, capTag?, resolves?, blockedBy?, shape?, title, facts[]}
+// Ported from prototype/pmos-console-handoff/sample/detectors.js and present.js (branch feat/console3-merge),
+// with the file reads replaced by reads of the facts object. Titles carry computed numbers, never typed ones.
+// Families that the sample reads from fixtures files and that this repo has no reader for yet simply return
+// no signals when the matching facts family is empty.
+
+const { slipMag, sig } = require('./score');
+const { DAY, dateMs, fmt } = require('./facts');
+
+const REG = [];
+const reg = (page, id, fn) => REG.push({ page, id, fn });
+const s = (o) => sig(o);
+const dd = (a, b) => Math.round((dateMs(a) - dateMs(b)) / DAY);
+const short = (d) => String(d).slice(5, 10);
+const sum = (a, k) => a.reduce((x, y) => x + (k ? y[k] : y), 0);
+const cap = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+
+// ---------- BRIEFING (present.js signals, generalised from one hard-coded initiative to every initiative) ----------
+reg('briefing', 'forecast-slip', (f) => f.inis.filter((i) => i.slip > 0 && i.promised).flatMap((i) => {
+  const key = 'replan:' + i.id;
+  const meet = i.meeting && f.daysTo(i.meeting.at);
+  const out = [s({
+    id: 'forecast-slip', page: 'briefing', key, entity: i.id, magnitude: slipMag(i.slip, i.tolerance),
+    promiseMissed: i.slip > i.tolerance && i.holders.length > 0,
+    deadlineDays: i.meeting ? meet : i.daysToPromise,
+    deadlineSource: i.meeting ? `the ${i.meeting.title} at ${String(i.meeting.at).slice(11, 16)}` : 'the promise date',
+    lens: 'Plan', strategic: true, isNew: true, shape: 'series',
+    title: `${i.title} lands ${i.slip} days late${i.slipFromEdits || i.slipFromAdds ? `: ${i.slipFromEdits} of ${i.slip} come from critical-path slips, ${i.slipFromAdds} from added scope` : ''}`,
+    facts: [`forecast ${short(i.forecast)} vs promise ${short(i.promised)}`, `${i.criticalPath.join(' > ') || 'no path'} on the critical path`,
+      i.meeting ? `decision needed before ${i.meeting.title}` : `promise in ${Math.round(i.daysToPromise)} days`],
+    options: i.options, initiative: i.id, tolerance: i.tolerance,
+  })];
+  if (i.slipFromEdits) out.push(s({ id: 'critical-path-edits', page: 'briefing', key, entity: i.id, magnitude: slipMag(i.slipFromEdits, i.tolerance), child: true }));
+  if (i.adds) out.push(s({ id: 'scope-creep', page: 'briefing', key, entity: i.id, magnitude: Math.min(1, i.adds / 5), child: true }));
+  return out;
+}));
+reg('briefing', 'stale-holder', (f) => f.holdersSent.filter((h) => h.truth && h.told).map((h) => {
+  const ini = f.inis.find((i) => i.id === h.initiative) || f.inis[0] || { tolerance: 1 };
+  const gap = dd(h.truth, h.told);
+  return s({
+    id: 'stale-holder', page: 'briefing', key: 'comms:' + h.to, entity: h.to, magnitude: slipMag(gap, ini.tolerance),
+    promiseMissed: gap > ini.tolerance, irreversible: true,
+    deadlineDays: h.dueAt ? f.daysTo(h.dueAt) : 1, deadlineSource: h.dueSource || 'the next report to leadership',
+    lens: 'Close', blockedBy: h.blockedBy, isNew: true, shape: 'compare',
+    title: `${gap} days apart: ${h.to} holds ${short(h.told)}; the true date is ${short(h.truth)}`,
+    facts: [`told ${short(h.told)}, true ${short(h.truth)}`, 'external: needs your update'],
+  });
+}).filter((x) => x.magnitude > 0));
+reg('briefing', 'report-blocked', (f) => (f.report && f.report.send && f.report.send !== 'allowed' ? [s({
+  id: 'report-blocked', page: 'briefing', key: 'comms:report', entity: 'report', magnitude: 0.6, promiseMissed: true, irreversible: true,
+  deadlineDays: f.daysTo(f.report.due), deadlineSource: 'the report due time', lens: 'Close', shape: 'rows',
+  title: `Report due ${String(f.report.due).replace('T', ' ')} cannot send: ${f.report.send}`, facts: [f.report.send],
+})] : []));
+reg('briefing', 'doc-conflict', (f) => {
+  const conflicts = f.edges.filter((e) => e.state === 'conflict');
+  return conflicts.map((e) => {
+    const down = new Set(f.edges.filter((x) => x.from === e.from).map((x) => x.to));
+    return s({
+      id: 'doc-conflict', page: 'briefing', key: 'conflict:' + e.from + '>' + e.to, entity: e.to, magnitude: Math.min(1, (down.size + 1) / 6),
+      deadlineDays: 30, lens: 'Unblock', isNew: true, shape: 'graph',
+      title: `${e.from} conflicts with ${e.to}${e.reason ? ' (' + e.reason + ')' : ''}; ${down.size} documents build on ${e.from}`, facts: [`${down.size} downstream`],
+    });
+  });
+});
+reg('briefing', 'anchor-order', (f) => f.inis.filter((i) => !i.done && (i.parent_kr === null || i.parent_kr === '')).map((i) => s({
+  id: 'anchor-order', page: 'briefing', key: 'anchor:' + i.id, entity: i.id, magnitude: 0.5, deadlineDays: 14, lens: 'Plan', policyCritical: true, shape: 'rows',
+  title: `${i.title} has no anchor`, facts: ['no KR or health budget', `lane: ${i.lane}`],
+})));
+reg('briefing', 'rubric-weak', (f) => {
+  const w = weakest(f.rubric);
+  return w && w.score < 0.6 ? [s({
+    id: 'rubric-weak', page: 'briefing', key: 'quality', entity: 'rubric', magnitude: 1 - w.score, deadlineDays: 7, lens: 'Close', shape: 'bars',
+    title: `Rubric passes at ${total(f.rubric).toFixed(2)} but ${w.dim} scores ${w.score}`, facts: [`threshold ${f.rubric.threshold}`, `${w.dim} ${w.score}`],
+  })] : [];
+});
+reg('briefing', 'waiting', (f) => f.waiting.map((w) => s({
+  id: 'waiting', page: 'briefing', key: 'waiting:' + w.who, entity: w.who, magnitude: 0.2, deadlineDays: 7, lens: 'Unblock', shape: 'rows',
+  title: `Waiting on ${w.who}`, facts: [`waiting since ${short(w.since)}`, w.blocks ? `blocks ${w.blocks}` : ''].filter(Boolean),
+})));
+reg('briefing', 'north-star-win', (f) => northStar(f, 'briefing', 'win'));
+reg('briefing', 'audit-disagree', (f) => (f.audit && f.audit.disagreed > 0 ? [s({
+  id: 'audit-disagree', page: 'briefing', key: 'audit', entity: 'trust', magnitude: 0.5, deadlineDays: 14, lens: 'Reflect', shape: 'ring',
+  title: `You disagreed with ${f.audit.disagreed} of the last ${f.audit.samples} sampled agent actions`, facts: [`${f.audit.samples} samples`],
+})] : []));
+
+// helpers over rubric, runs, KR
+function weakest(rubric) {
+  if (!rubric || !rubric.dims || !rubric.dims.length) return null;
+  return rubric.dims.reduce((a, b) => (b.score < a.score ? b : a));
+}
+const total = (rubric) => sum(rubric.dims.map((d) => d.w * d.score));
+function northStar(f, page, key) {
+  const r = f.runs;
+  if (r.length < 2) return [];
+  const rt = (x) => x.corrections / Math.max(1, x.outputs);
+  const first = rt(r[0]);
+  if (!first) return [];
+  const imp = 1 - rt(r[r.length - 1]) / first;
+  // Only an achieved improvement is a win. A worsening rate is shown as a plain signal, not a win.
+  return [s({
+    id: 'north-star', page, key, entity: 'agent-runs', magnitude: Math.min(1, Math.abs(imp)), deadlineDays: 60, lens: 'Reflect',
+    positive: imp > 0, strategic: true, shape: 'series', series: r.map(rt),
+    title: `Human correction rate ${imp > 0 ? 'down' : 'up'} ${Math.round(Math.abs(imp) * 100)}% over ${r.length} runs`,
+    facts: [`${first.toFixed(2)} to ${rt(r[r.length - 1]).toFixed(2)} corrections per output`],
+  })];
+}
+function krProjection(f) {
+  const { kr, metric } = f;
+  if (!kr || metric.length < 2) return null;
+  const last = metric[metric.length - 1], first = metric[0];
+  const toBy = Math.max(1, dd(kr.by, last.at));
+  const slope = (last.value - first.value) / Math.max(1, dd(last.at, first.at));
+  const proj = +(last.value + slope * toBy).toFixed(2);
+  const shortBy = (i) => { const m = metric[i]; const sl = (m.value - first.value) / Math.max(1, dd(m.at, first.at)); return +(kr.target - (m.value + sl * Math.max(1, dd(kr.by, m.at)))).toFixed(2); };
+  return { last, slope, proj, short: +(kr.target - proj).toFixed(2), toBy, shortSeries: metric.slice(2).map((_, i) => shortBy(i + 2)) };
+}
+const workLoad = (f) => { const t = f.work.filter((w) => w.lens === 'today'); return { items: t, load: sum(t.map((w) => w.effort_min || 0)) }; };
+
+// ---------- CALENDAR ----------
+reg('calendar', 'cal.milestone-status', (f) => f.inis.filter((i) => i.promised && !i.done).flatMap((i) => {
+  if (i.status === 'no plan') return [s({ id: 'cal.no-plan:' + i.id, page: 'calendar', key: 'plan:' + i.id, entity: i.id, magnitude: 0.6, deadlineDays: i.daysToPromise, lens: 'Plan', shape: 'rows', title: `${i.title} is promised ${i.promised} but has no plan, so no forecast`, facts: ['promised ' + i.promised, '0 tickets'] })];
+  if (['delayed', 'at risk', 'overdue'].includes(i.status)) {
+    return [s({
+      id: 'cal.milestone:' + i.id, page: 'calendar', key: 'milestone:' + i.id, entity: i.id, magnitude: Math.max(0.2, slipMag(i.slip, i.tolerance)),
+      promiseMissed: i.slip > i.tolerance && i.holders.length > 0, deadlineDays: i.daysToPromise, deadlineSource: 'the promise date', shape: 'compare', isNew: true,
+      title: `${i.title} is ${i.status}: promised ${i.promised}, forecast ${i.forecast}`, facts: [i.status],
+    })];
+  }
+  return [];
+}));
+reg('calendar', 'cal.day-load', (f) => {
+  const { items, load } = workLoad(f);
+  return load > f.capFocusMin ? [s({
+    id: 'cal.day-load', page: 'calendar', key: 'load:today', entity: 'today', magnitude: Math.min(1, (load - f.capFocusMin) / f.capFocusMin), deadlineDays: 0, lens: 'Plan', shape: 'ring',
+    title: `Today holds ${Math.round(load / 6) / 10}h of work for ${Math.round(f.capFocusMin / 6) / 10}h of focus time`, facts: [items.length + ' items in Today'],
+  })] : [];
+});
+reg('calendar', 'cal.due-cluster', (f) => {
+  const by = {};
+  f.work.filter((w) => w.due && w.lens !== 'done').forEach((w) => (by[w.due] = by[w.due] || []).push(w));
+  return Object.entries(by).filter(([, v]) => v.length >= 3).map(([d, v]) => s({
+    id: 'cal.due-cluster:' + d, page: 'calendar', key: 'dues:' + d, entity: d, magnitude: Math.min(1, v.length / 6), deadlineDays: f.daysTo(d), capTag: 'Just in', shape: 'rows',
+    title: `${v.length} items fall due on ${d}`, facts: v.map((x) => x.title),
+  }));
+});
+reg('calendar', 'cal.kr-deviation', (f) => {
+  const p = krProjection(f);
+  return p && p.short > 0 ? [s({
+    id: 'cal.kr-deviation', page: 'calendar', key: 'kr', entity: f.kr.title, magnitude: Math.min(1, p.short / Math.max(0.0001, f.kr.target - f.kr.baseline)), deadlineDays: f.daysTo(f.kr.by),
+    strategic: true, lens: 'Plan', shape: 'series',
+    title: `${f.kr.metric} is ${p.last.value} against a ${f.kr.target} target; at this pace it ends the period at ${p.proj} (${p.short} short)`,
+    facts: ['slope ' + p.slope.toFixed(4) + '/day', 'needs ' + ((f.kr.target - p.last.value) / p.toBy).toFixed(4) + '/day'],
+  })] : [];
+});
+reg('calendar', 'cal.pivot-signal', (f) => {
+  const p = krProjection(f);
+  const ss = p ? p.shortSeries : [];
+  return ss.length >= 3 && ss.every((v) => v > 0) && ss[ss.length - 1] >= ss[0] ? [s({
+    id: 'cal.pivot-signal', page: 'calendar', key: 'kr', entity: f.kr.title, magnitude: 0.7, deadlineDays: 30, strategic: true, child: true,
+    title: `Shortfall has been positive for ${ss.length} checks: ${ss.join(', ')}`, facts: ['pivot watch'],
+  })] : [];
+});
+reg('calendar', 'cal.report-due', (f) => (f.report && f.report.send && f.report.send !== 'allowed' ? [s({
+  id: 'cal.report-due', page: 'calendar', key: 'report:' + (f.report.id || 'weekly'), entity: 'report', magnitude: 0.6, promiseMissed: true,
+  deadlineDays: Math.max(0, f.daysTo(f.report.due)), deadlineSource: 'the report due time', irreversible: true, lens: 'Close', shape: 'rows',
+  title: `Report is due ${String(f.report.due).replace('T', ' ')} and cannot send: ${f.report.send}`, facts: [f.report.send],
+})] : []));
+
+// ---------- WORK ----------
+reg('work', 'work.overload', (f) => REG.find((d) => d.id === 'cal.day-load').fn(f).map((x) => ({ ...x, page: 'work' })));
+reg('work', 'work.quick-win', (f) => f.work.filter((w) => w.lens === 'today' && w.effort_min <= 20 && w.resolves).map((w) => s({
+  id: 'work.quick-win:' + w.item, page: 'work', key: 'quick:' + w.item, entity: w.item, magnitude: 0.5, deadlineDays: f.daysTo(w.due || f.nowDate), capTag: 'Opportunity',
+  resolves: w.resolves, lens: 'Close', shape: 'number', title: `"${w.title}" takes ${w.effort_min} minutes and resolves the "${w.resolves}" card`, facts: ['resolves ' + w.resolves],
+})));
+reg('work', 'work.chase-waiting', (f) => f.work.filter((w) => w.lens === 'waiting' && w.due && f.daysTo(w.due) <= 3).map((w) => s({
+  id: 'work.chase:' + w.item, page: 'work', key: 'chase:' + w.item, entity: w.item, magnitude: 0.4, deadlineDays: f.daysTo(w.due), capTag: 'Just in', lens: 'Unblock', shape: 'rows',
+  title: `"${w.title}" is due ${w.due} and still waiting on ${w.on}`, facts: ['waiting on ' + w.on],
+})));
+reg('work', 'work.untriaged', (f) => {
+  const u = f.work.filter((w) => !w.lens);
+  if (!u.length) return [];
+  let load = workLoad(f).load;
+  const sug = (w) => {
+    const d = w.due ? f.daysTo(w.due) : null;
+    if (d !== null && d <= 0) { load += w.effort_min || 0; return ['Today', 'due today']; }
+    if (d !== null && d <= 1) { if (load + (w.effort_min || 0) <= f.capFocusMin) { load += w.effort_min || 0; return ['Today', 'due tomorrow and it fits']; } return ['Week', 'due tomorrow but Today is full']; }
+    return d !== null && d <= 7 ? ['Week', 'due within 7 days'] : ['Later', d === null ? 'no due date' : 'due in ' + d + ' days'];
+  };
+  const rows = u.map((w) => ({ w, s: sug(w) }));
+  return [s({
+    id: 'work.untriaged', page: 'work', key: 'triage', entity: 'inbox', magnitude: Math.min(1, u.length / 8), deadlineDays: 1, capTag: 'Just in', lens: 'Plan', isNew: true, shape: 'rows',
+    title: `${u.length} items are untriaged; suggested: ${rows.map((r) => r.w.title.split(' ').slice(0, 3).join(' ') + ' to ' + r.s[0] + ' (' + r.s[1] + ')').join('; ')}`, facts: rows.map((r) => r.w.item + ' ' + r.s[0]),
+  })];
+});
+reg('work', 'work.mis-lensed', (f) => f.work.filter((w) => w.lens === 'later' && w.due && f.daysTo(w.due) <= 1).map((w) => s({
+  id: 'work.mis-lensed:' + w.item, page: 'work', key: 'lens:' + w.item, entity: w.item, magnitude: 0.5, deadlineDays: f.daysTo(w.due), capTag: 'Just in',
+  title: `"${w.title}" is parked in Later but due ${w.due}`, facts: [],
+})));
+
+// ---------- INITIATIVES: lifecycle lenses ----------
+reg('discover', 'discover.untraced-evidence', (f) => f.hyps.flatMap((h) => {
+  const miss = h.evidence.filter((e) => !f.docs[e.src]);
+  const tot = sum(h.evidence.map((e) => e.w)) || 1;
+  return miss.length ? [s({
+    id: 'discover.untraced:' + h.slug, page: 'discover', key: 'hyp:' + h.slug, entity: h.slug, magnitude: sum(miss.map((e) => e.w)) / tot, deadlineDays: 14, shape: 'rows',
+    title: `"${h.title}": ${miss.length} of ${h.evidence.length} pieces of evidence point to a missing source (${miss.map((e) => e.src).join(', ')})`,
+    facts: ['net ' + sum(h.evidence.map((e) => (e.dir === 'supports' ? e.w : -e.w)))],
+  })] : [];
+}));
+reg('discover', 'discover.stale-evidence', (f) => Object.entries(f.docs).filter(([, d]) => ['Research', 'Benchmark'].includes(d.type) && d.stale_after && d.stale_after < f.nowDate).map(([id, d]) => s({
+  id: 'discover.stale:' + id, page: 'discover', key: 'stale:' + id, entity: id, magnitude: 0.5, deadlineDays: 7, shape: 'number', title: `${d.title} went stale on ${d.stale_after}`, facts: ['rev ' + d.rev],
+})));
+reg('discover', 'discover.open-hypothesis', (f) => f.hyps.filter((h) => { const n = sum(h.evidence.map((e) => (e.dir === 'supports' ? e.w : -e.w))); return n < 3 && n > -2; }).map((h) => s({
+  id: 'discover.open:' + h.slug, page: 'discover', key: 'hyp:' + h.slug, entity: h.slug, magnitude: 0.4, deadlineDays: 21, child: true, title: `"${h.title}" is still open`, facts: [],
+})));
+reg('ideate', 'ideate.quick-win', (f) => f.ideas.filter((i) => i.effort <= 2 && i.score >= 1.5).map((i) => s({
+  id: 'ideate.quick:' + i.slug, page: 'ideate', key: 'idea:' + i.slug, entity: i.slug, magnitude: Math.min(1, i.score / 3), deadlineDays: 30, shape: 'rows',
+  title: `${i.title}: score ${i.score} for effort ${i.effort}, not on the roadmap`, facts: ['impact ' + i.impact, 'confidence ' + i.confidence],
+})));
+reg('ideate', 'ideate.unanchored', (f) => f.ideas.filter((i) => !i.parent_kr).map((i) => s({
+  id: 'ideate.unanchored:' + i.slug, page: 'ideate', key: 'idea:' + i.slug, entity: i.slug, magnitude: 0.5, deadlineDays: 14, title: `${i.title} has no KR anchor`, facts: [],
+})));
+reg('ideate', 'ideate.concentration', (f) => {
+  if (f.ideas.length < 4) return [];
+  const by = {}; f.ideas.forEach((i) => { by[i.parent_kr] = (by[i.parent_kr] || 0) + 1; });
+  const [k, n] = Object.entries(by).sort((a, b) => b[1] - a[1])[0];
+  return n === f.ideas.length ? [s({ id: 'ideate.concentration', page: 'ideate', key: 'concentration', entity: k, magnitude: 0.4, deadlineDays: 30, title: `All ${n} ideas aim at one KR (${k}); nothing explores the others`, facts: [] })] : [];
+});
+reg('strategize', 'strategize.kr-deviation', (f) => REG.find((d) => d.id === 'cal.kr-deviation').fn(f).map((x) => ({ ...x, page: 'strategize' })));
+reg('strategize', 'strategize.unanchored', (f) => f.inis.filter((i) => !i.done && !i.parent_kr).map((i) => s({
+  id: 'strategize.unanchored:' + i.id, page: 'strategize', key: 'anchor:' + i.id, entity: i.id, magnitude: 0.5, deadlineDays: 14, policyCritical: true, shape: 'rows',
+  title: `${i.title} has no KR or health budget`, facts: ['horizon ' + i.horizon],
+})));
+reg('strategize', 'strategize.single-bet', (f) => {
+  const now = f.inis.filter((i) => i.horizon === 'now');
+  return now.length === 1 && f.inis.length >= 3 ? [s({ id: 'strategize.single-bet', page: 'strategize', key: 'bets', entity: 'portfolio', magnitude: 0.4, deadlineDays: 30, strategic: true, title: `Everything in flight rides on one bet (${now[0].title}); ${f.inis.length - 1} others are Next or Later`, facts: [] })] : [];
+});
+reg('prioritize', 'prioritize.capacity-free', (f) => {
+  const inflight = f.inis.filter((i) => i.horizon === 'now').length, CAP = 4;
+  return inflight < CAP && f.ideas.length ? [s({
+    id: 'prioritize.capacity', page: 'prioritize', key: 'capacity', entity: 'portfolio', magnitude: Math.min(1, (CAP - inflight) / CAP), deadlineDays: 14, shape: 'ring',
+    title: `${inflight} of ${CAP} bets in flight; the top idea is ${f.ideas[0].title} (score ${f.ideas[0].score})`, facts: f.ideas.slice(0, 3).map((i) => i.title + ' ' + i.score),
+  })] : [];
+});
+reg('prioritize', 'prioritize.score-vs-roadmap', (f) => {
+  const onRoad = new Set(f.inis.map((i) => String(i.id).split('/').pop()));
+  const top = f.ideas.filter((i) => !onRoad.has(i.slug));
+  return top.length && f.inis.some((i) => i.horizon === 'next' && !i.hasPlan) ? [s({
+    id: 'prioritize.rank', page: 'prioritize', key: 'capacity', entity: 'portfolio', magnitude: 0.4, deadlineDays: 14, child: true,
+    title: `${top[0].title} (score ${top[0].score}) outranks work already placed in Next that has no plan`, facts: [],
+  })] : [];
+});
+reg('plan', 'plan.critical-density', (f) => {
+  const crit = f.tickets.filter((t) => t.onCriticalPath);
+  const share = f.tickets.length ? crit.length / f.tickets.length : 0;
+  return share >= 0.5 ? [s({ id: 'plan.density', page: 'plan', key: 'fragile', entity: 'plan', magnitude: share, deadlineDays: 14, shape: 'bars', title: `${crit.length} of ${f.tickets.length} tickets are on the critical path: any slip moves the date`, facts: crit.map((t) => t.key) })] : [];
+});
+reg('plan', 'plan.long-ticket', (f) => {
+  const L = f.tickets.filter((t) => t.dur > 10 && t.status !== 'done');
+  return L.length ? [s({ id: 'plan.long', page: 'plan', key: 'split', entity: 'plan', magnitude: Math.min(1, Math.max(...L.map((t) => t.dur)) / 30), deadlineDays: 7, shape: 'bars', title: `${L.length} open tickets run over 10 days (${L.map((t) => t.key + ' ' + t.dur + 'd').join(', ')}); long tickets hide slips, so split them`, facts: L.map((t) => t.key + ' owner ' + t.owner) })] : [];
+});
+reg('plan', 'plan.unplanned', (f) => f.inis.filter((i) => !i.hasPlan && ['now', 'next'].includes(i.horizon)).map((i) => s({
+  id: 'plan.unplanned:' + i.id, page: 'plan', key: 'plan:' + i.id, entity: i.id, magnitude: 0.5, deadlineDays: i.promised ? i.daysToPromise : 60,
+  title: `${i.title} is in ${i.horizon} with no work breakdown`, facts: ['promised ' + (i.promised || 'none')],
+})));
+reg('monitor', 'monitor.slip', (f) => f.inis.filter((i) => i.slip > 0).map((i) => s({
+  id: 'monitor.slip:' + i.id, page: 'monitor', key: 'slip:' + i.id, entity: i.id, magnitude: slipMag(i.slip, i.tolerance), promiseMissed: i.slip > i.tolerance && i.holders.length > 0,
+  deadlineDays: i.daysToPromise, deadlineSource: 'the promise date', isNew: true, shape: 'series', title: `Forecast ${i.forecast} is ${i.slip} days past the promise`, facts: [],
+})));
+reg('monitor', 'monitor.scope', (f) => f.inis.filter((i) => i.tripScope && i.tripScope !== 'ok').map((i) => s({
+  id: 'monitor.scope:' + i.id, page: 'monitor', key: 'slip:' + i.id, entity: i.id, magnitude: Math.min(1, i.adds / 5), deadlineDays: 14, child: true, title: `${i.adds} scope additions since baseline (${i.tripScope})`, facts: [],
+})));
+reg('monitor', 'monitor.gate-order', (f) => f.inis.filter((i) => i.gateViolations.length).map((i) => s({
+  id: 'monitor.gate:' + i.id, page: 'monitor', key: 'gate:' + i.id, entity: i.id, magnitude: 0.5, deadlineDays: 14, policyCritical: true, shape: 'rows',
+  title: `${i.title}: ${i.gateViolations[0].gate} passed before an earlier gate`, facts: [],
+})));
+reg('monitor', 'monitor.doc-health', (f) => Object.entries(f.docs).filter(([, d]) => d.exists !== false && d.checks).flatMap(([id, d]) => {
+  const vals = Object.values(d.checks), n = vals.filter(Boolean).length;
+  return n <= vals.length / 2 ? [s({
+    id: 'monitor.health:' + id, page: 'monitor', key: 'doc:' + id, entity: id, magnitude: 1 - n / vals.length, deadlineDays: 14, isNew: true, shape: 'rows',
+    title: `${d.title}: ${n} of ${vals.length} checks pass (${Object.entries(d.checks).filter(([, v]) => !v).map(([k]) => k).join(', ')})`, facts: [],
+  })] : [];
+}));
+reg('evaluate', 'evaluate.rubric-weak', (f) => REG.find((d) => d.id === 'rubric-weak').fn(f).map((x) => ({ ...x, page: 'evaluate', key: 'rubric' })));
+reg('evaluate', 'evaluate.calibration', (f) => (f.calibration && f.calibration.verdict !== 'calibrated' ? [s({
+  id: 'evaluate.calibration', page: 'evaluate', key: 'calibration', entity: 'confidence', magnitude: 0.5, deadlineDays: 30, shape: 'bars',
+  title: `Confidence figures are ${f.calibration.verdict}`, facts: ['brier ' + f.calibration.brier],
+})] : []));
+reg('evaluate', 'evaluate.north-star', (f) => northStar(f, 'evaluate', 'win'));
+reg('evaluate', 'evaluate.retro-missing', (f) => f.inis.filter((i) => i.retroMissing).map((i) => s({
+  id: 'evaluate.retro:' + i.id, page: 'evaluate', key: 'retro:' + i.id, entity: i.id, magnitude: 0.4, deadlineDays: 14, title: `${i.id} was accepted with no retrospective`, facts: [],
+})));
+
+// ---------- INITIATIVES: views ----------
+reg('roadmap', 'roadmap.overcommit', (f) => {
+  const n = f.inis.filter((i) => i.horizon === 'now').length;
+  return n > 4 ? [s({ id: 'roadmap.overcommit', page: 'roadmap', key: 'cap', entity: 'portfolio', magnitude: Math.min(1, (n - 4) / 4), deadlineDays: 7, title: `${n} bets in Now against a capacity of 4`, facts: [] })] : [];
+});
+reg('roadmap', 'roadmap.unanchored', (f) => REG.find((d) => d.id === 'strategize.unanchored').fn(f).map((x) => ({ ...x, page: 'roadmap' })));
+reg('roadmap', 'roadmap.no-forecast', (f) => f.inis.filter((i) => ['now', 'next'].includes(i.horizon) && !i.hasPlan).map((i) => s({
+  id: 'roadmap.no-forecast:' + i.id, page: 'roadmap', key: 'plan:' + i.id, entity: i.id, magnitude: 0.4, deadlineDays: 30, title: `${i.title} sits in ${i.horizon} with no forecast date`, facts: [],
+})));
+const lateTickets = (f) => f.tickets.filter((t) => t.status !== 'done' && t.end && dateMs(t.end) < dateMs(f.nowDate));
+reg('tickets', 'tickets.late', (f) => lateTickets(f).map((t) => s({
+  id: 'tickets.late:' + t.key, page: 'tickets', key: 'late:' + t.key, entity: t.key, magnitude: 0.5, deadlineDays: 0, title: `${t.key} should have finished ${t.end} and is ${t.status || 'not started'}`, facts: [],
+})));
+reg('tickets', 'tickets.blocked', (f) => {
+  const st = Object.fromEntries(f.tickets.map((t) => [t.key, t.status]));
+  return f.tickets.filter((t) => t.status === 'doing' && (t.deps || []).some((d) => st[d] !== 'done')).map((t) => s({
+    id: 'tickets.blocked:' + t.key, page: 'tickets', key: 'blocked:' + t.key, entity: t.key, magnitude: 0.6, deadlineDays: 3,
+    title: `${t.key} is in progress but waits on ${t.deps.filter((d) => st[d] !== 'done').join(', ')}`, facts: [],
+  }));
+});
+reg('tickets', 'tickets.unowned', (f) => f.tickets.filter((t) => !t.owner && t.status !== 'done').map((t) => s({
+  id: 'tickets.unowned:' + t.key, page: 'tickets', key: 'owner:' + t.key, entity: t.key, magnitude: 0.5, deadlineDays: 7, title: `${t.key} has no owner`, facts: [],
+})));
+reg('tickets', 'tickets.agent-proposed', (f) => {
+  const open = f.tickets.filter((t) => t.origin && String(t.origin).startsWith('claude-code/') && !t.edits && t.status !== 'done');
+  return open.length ? [s({ id: 'tickets.agent-proposed', page: 'tickets', key: 'proposals', entity: 'agent', magnitude: Math.min(1, open.length / 5), deadlineDays: 3, isNew: true, shape: 'rows', title: `${open.length} agent-added tickets are open: ${open.map((t) => t.key).join(', ')}`, facts: open.map((t) => t.key + ' ' + (t.pts || 0) + 'pts') })] : [];
+});
+reg('documents', 'documents.coverage', (f) => {
+  const miss = Object.entries(f.docs).filter(([, d]) => d.required && d.exists === false).map(([id, d]) => d.title || id);
+  const gone = f.edges.filter((e) => e.state === 'missing').map((e) => e.from);
+  const all = miss.concat(gone);
+  return all.length ? [s({ id: 'documents.coverage', page: 'documents', key: 'coverage', entity: 'documents', magnitude: 0.5, deadlineDays: 14, shape: 'rows', title: `${all.length} required document${all.length > 1 ? 's' : ''} missing: ${all.join(', ')}`, facts: [] })] : [];
+});
+reg('documents', 'documents.conflicts', (f) => f.edges.filter((e) => e.state === 'conflict').map((e) => s({
+  id: 'documents.conflict:' + e.from + '>' + e.to, page: 'documents', key: 'conflict:' + e.from + '>' + e.to, entity: e.to, magnitude: 0.67, deadlineDays: 30, isNew: true, shape: 'graph',
+  title: `${e.from} conflicts with ${e.to}${e.reason ? ' (' + e.reason + ')' : ''}`, facts: [],
+})));
+reg('documents', 'documents.stale', (f) => Object.entries(f.docs).filter(([, d]) => d.stale_after && d.stale_after < f.nowDate && d.exists !== false).map(([id, d]) => s({
+  id: 'documents.stale:' + id, page: 'documents', key: 'stale:' + id, entity: id, magnitude: 0.4, deadlineDays: 7, title: `${d.title} is past its review date ${d.stale_after}`, facts: [],
+})));
+
+// ---------- REPORTS ----------
+reg('reports', 'reports.claims-blocked', (f) => {
+  const bad = (f.report && f.report.blockedClaims) || [];
+  return bad.length ? [s({
+    id: 'reports.claims', page: 'reports', key: 'report', entity: 'report', magnitude: Math.min(1, bad.length / Math.max(1, f.report.claimCount || bad.length) + 0.2), promiseMissed: true, deadlineDays: 1,
+    deadlineSource: 'the report due time', irreversible: true, shape: 'rows', title: `Report: ${bad.length} of ${f.report.claimCount || bad.length} claims block sending`, facts: bad.slice(0, 3).map((x) => String(x).slice(0, 60)),
+  })] : [];
+});
+reg('reports', 'reports.audience-leak', (f) => (f.report && f.report.ticketKeyLeaks > 0 && f.report.audience === 'leadership' ? [s({
+  id: 'reports.leak', page: 'reports', key: 'report', entity: 'report', magnitude: 0.3, deadlineDays: 1, child: true, title: `${f.report.ticketKeyLeaks} section(s) use ticket keys, which leadership does not read`, facts: [],
+})] : []));
+reg('reports', 'reports.cadence', (f) => (f.report && f.report.due ? [s({
+  id: 'reports.cadence', page: 'reports', key: 'report', entity: 'report', magnitude: 0.3, deadlineDays: Math.max(0, f.daysTo(f.report.due)), child: true, title: `Weekly digest is due ${String(f.report.due).replace('T', ' ')}`, facts: [],
+})] : []));
+reg('reports', 'reports.holders', (f) => f.holdersSent.filter((h) => h.truth && h.told && dd(h.truth, h.told) !== 0).map((h) => {
+  const ini = f.inis.find((i) => i.id === h.initiative) || f.inis[0] || { tolerance: 1 };
+  const g = dd(h.truth, h.told);
+  return s({
+    id: 'reports.holder:' + h.to, page: 'reports', key: 'holders', entity: h.to, magnitude: slipMag(g, ini.tolerance), promiseMissed: g > ini.tolerance, deadlineDays: 1,
+    deadlineSource: 'the next report to leadership', irreversible: true, isNew: true, shape: 'compare', title: `${h.to} holds ${h.told} for ${h.subject}; the true date is ${h.truth}`, facts: [g + ' days apart'],
+  });
+}));
+
+function run(facts, pages) {
+  const want = pages === 'all' || !pages ? null : Array.isArray(pages) ? pages : [pages];
+  const out = [];
+  for (const d of REG) if (!want || want.includes(d.page)) { const r = d.fn(facts) || []; out.push(...r); }
+  return out;
+}
+const pagesList = () => [...new Set(REG.map((d) => d.page))];
+
+module.exports = { REG, run, pages: pagesList, count: () => REG.length, weakest, total, krProjection, fmt };

package/workspace/lib/engine/signals/facts-cli.js

@@ -0,0 +1,8 @@
+'use strict';
+// facts-cli.js — readRepoFacts as a child process: `node facts-cli.js <root> [today]` prints the facts as JSON.
+// readRepoFacts runs git once per initiative (minutes on ~300 records) and is synchronous, so a server that called it in its
+// own process would stop answering for that long. workspace/lib/facts-async.js runs this file instead.
+const { readRepoFacts } = require('./facts.js');
+const root = process.argv[2];
+const today = process.argv[3] || '';
+process.stdout.write(JSON.stringify(readRepoFacts(root, today ? { today } : {})));

package/workspace/lib/engine/signals/facts.js

@@ -0,0 +1,197 @@
+'use strict';
+// The facts boundary of the signal engine. Detectors read ONE plain facts object and nothing else.
+//
+// normalizeFacts(raw) fills every family with a safe default and derives slip, tolerance and days-to helpers.
+// It is pure. readRepoFacts(root) is the only function that touches the repo, and the tests do not use it.
+//
+// WIRED TO REAL DATA (readRepoFacts): initiative records (id, title, lane, anchor `parent_kr`, stage, accepted,
+//   horizon, `promised`, `planned_days`, `slip_tolerance_days`) from planning/initiatives/*.md through
+//   scripts/workflow-state.js listInitiatives and computeWorkflow, which also supply the gate-order
+//   violations (`gate_failures`). Work-item status per item comes from the repo's work-item ledger and its plan items (see layout-paths.js).
+//
+// ALSO WIRED (when the files exist): ideas, hypotheses, decisions and the KR metric with its readings, from
+//   the repo's records folder through scripts/records (layout-paths.js: planning/records, or pmos/state/records in a tenant).
+//
+// NOT WIRED TO REAL DATA YET (detectors for these families return nothing until a reader fills them; the
+// test fixtures fill them by hand):
+//   forecast and plan engine (forecast date, critical path, edits, scope additions, what-if options),
+//   promise ledger and who-was-told (holders, sent messages), calendar links (meetings), personal ledger
+//   (lenses, effort, due), document edges and document health,
+//   rubric dimension scores, calibration, agent-run correction rates, report claims, audit samples,
+//   waiting-on records.
+//
+// Raw facts shape (every key optional):
+//   now 'YYYY-MM-DDTHH:MM' | 'YYYY-MM-DD', stance 'hold'|'move', capFocusMin,
+//   inis[{id,title,promised,forecast,hasPlan,plannedDays,slip_tolerance_days,parent_kr,horizon,lane,done,
+//         holders[{who,told}], meeting{title,at}, slipFromEdits, slipFromAdds, adds, criticalPath[], tripScope,
+//         options[{id,label,slipAfter,touches[],promiseChange}], gateViolations[{gate}], retroMissing, accepted}],
+//   tickets[{key,status,dur,owner,deps[],end,pts,origin,edits}],
+//   docs{id:{title,type,rev,stale_after,exists,checks{name:bool}}}, edges[{from,to,state,reason}],
+//   work[{item,title,lens,due,on,effort_min,resolves}], kr{title,metric,target,baseline,by}, metric[{at,value}],
+//   events[{id,at,end,title,attendees,initiative,sensitivity,label:'reported'}] (imported calendar events),
+//   ideas[{slug,title,impact,confidence,effort,parent_kr}], hyps[{slug,title,evidence[{src,dir,w}]}],
+//   rubric{threshold,dims[{dim,w,score}]}, calibration{verdict,brier,rows[]}, runs[{outputs,corrections}],
+//   report{due,blockedClaims[],claimCount,ticketKeyLeaks,audience}, holdersSent[{to,subject,told,truth}],
+//   audit{disagreed,samples}, waiting[{who,since,blocks}].
+
+const fs = require('fs');
+const path = require('path');
+const { defaultTolerance } = require('./score');
+
+const DAY = 864e5;
+const dateMs = (s) => Date.parse(String(s).slice(0, 10) + 'T00:00:00Z');
+const ms = (s) => (String(s).includes('T') ? Date.parse(String(s).length === 16 ? s + ':00Z' : s) : dateMs(s));
+const fmt = (m) => new Date(m).toISOString().slice(0, 10);
+
+function temporalStatus({ promised, forecast, hasPlan, now, tol, done }) {
+  if (done) return 'done';
+  if (!hasPlan || !forecast) return 'no plan';
+  if (dateMs(promised) < dateMs(now)) return 'overdue';
+  const slip = Math.round((dateMs(forecast) - dateMs(promised)) / DAY);
+  if (slip > tol) return 'delayed';
+  if (slip > 0) return 'at risk';
+  return 'on track';
+}
+
+function normalizeFacts(raw, today) {
+  const r = raw || {};
+  const now = today || r.now || new Date().toISOString().slice(0, 16);
+  const nowDate = String(now).slice(0, 10);
+  const daysTo = (t) => (t == null ? null : (String(t).includes('T') ? (ms(t) - ms(now)) / DAY : (dateMs(t) - dateMs(nowDate)) / DAY));
+  const inis = (r.inis || []).map((i) => {
+    const hasPlan = i.hasPlan !== undefined ? i.hasPlan : !!i.forecast;
+    const tolerance = i.slip_tolerance_days != null ? Number(i.slip_tolerance_days) : defaultTolerance(i.plannedDays);
+    const slip = i.promised && i.forecast ? Math.round((dateMs(i.forecast) - dateMs(i.promised)) / DAY) : 0;
+    return {
+      slipFromEdits: 0, slipFromAdds: 0, adds: 0, criticalPath: [], options: [], gateViolations: [], holders: [], ...i,
+      hasPlan, tolerance, slip,
+      daysToPromise: i.promised ? daysTo(i.promised) : null,
+      status: temporalStatus({ promised: i.promised, forecast: i.forecast, hasPlan, now: nowDate, tol: tolerance, done: i.done }),
+    };
+  });
+  return {
+    now, nowDate, daysTo, stance: r.stance === 'move' ? 'move' : 'hold', capFocusMin: r.capFocusMin || 255,
+    inis, tickets: r.tickets || [], docs: r.docs || {}, edges: r.edges || [], work: r.work || [],
+    kr: r.kr || null, metric: r.metric || [],
+    ideas: (r.ideas || []).map((i) => ({ ...i, score: +((i.impact * i.confidence) / i.effort).toFixed(2) })).sort((a, b) => b.score - a.score),
+    decisions: r.decisions || [], hyps: r.hyps || [], rubric: r.rubric || null, calibration: r.calibration || null, runs: r.runs || [],
+    events: r.events || [],
+    report: r.report || null, holdersSent: r.holdersSent || [], audit: r.audit || null, waiting: r.waiting || [],
+  };
+}
+
+// ---- real-data reader (not exercised by the tests) ----
+// workflow-state.js exports cleanly (its CLI runs only under require.main), but it is still required inside the
+// function so that importing this module never reads the repo.
+function readRepoFacts(root, opts) {
+  const base = path.resolve(root || process.cwd());
+  // A product repo (the kit) may not carry scripts/workflow-state.js; fall back to the copy that ships beside this module.
+  const own = path.join(base, 'scripts', 'workflow-state.js');
+  const ws = require(require('fs').existsSync(own) ? own : path.join(__dirname, '..', 'workflow-state.js'));
+  const range = sharedRange(ws, base);
+  const inis = [];
+  for (const id of ws.listInitiatives(base)) {
+    let w;
+    try { w = ws.computeWorkflow(id, range ? { root: base, range } : { root: base }); } catch { continue; }
+    if (!w || !w.ok) continue;
+    const fm = readFrontmatter(path.join(base, w.record || `planning/initiatives/${id}.md`));
+    inis.push({
+      id, title: w.title || id, lane: w.lane, parent_kr: w.anchor || fm.parent_kr || null, stage: w.stage,
+      done: !!w.accepted, horizon: fm.horizon || (w.accepted ? 'done' : 'now'), promised: fm.promised || null,
+      plannedDays: fm.planned_days != null ? Number(fm.planned_days) : null,
+      slip_tolerance_days: fm.slip_tolerance_days != null ? Number(fm.slip_tolerance_days) : undefined,
+      gateViolations: (w.gate_failures || []).map((g) => ({ gate: g.rule || g.gate || String(g) })),
+      // a stopped initiative (D70 lifecycle: on-hold, closed, cancelled); the Calendar tidy-up reads it
+      ...(w.stopped && w.stopped.state ? { stopped: { state: String(w.stopped.state) } } : {}),
+    });
+  }
+  // Ask where this repo keeps its files (the PMOS repo and a kit tenant differ), then read the factory work items and, for any
+  // layout, the PM's plan items: a tenant has plan items and no work-items ledger.
+  const LP = require('./layout-paths.js');
+  const P = LP.pathsFor(base);
+  const tickets = readWorkItems(P.workItemsFile);
+  try {
+    const have = new Set(tickets.map((t) => t.key));
+    for (const f of LP.planItemFacts(fs.readFileSync(P.planItemsFile, 'utf8'))) if (!have.has(f.key)) tickets.push(f);
+  } catch { /* no plan-items ledger in this repo */ }
+  const rec = readRecordFacts(P.recordsDir);
+  // Imported calendar events (scripts/calendar-import.js), when the caller names the runtime dir or passes events.
+  let events = (opts && opts.events) || [];
+  if (!events.length && opts && opts.runtimeDir) {
+    try { const CI = require('../calendar-import.js'); events = CI.foldEvents(CI.readLines(path.join(opts.runtimeDir, 'calendar-import', 'events.jsonl'))); } catch { events = []; }
+  }
+  return normalizeFacts({ inis, tickets, events, ...rec }, opts && opts.today);
+}
+
+// ONE commit range for every initiative (workspace-data-freshness R1). computeWorkflow called without a range builds its own
+// for each initiative, and on a range with no commits (HEAD level with main) firstAppearance then walks the history once
+// per artifact path: 78 s for 324 records here, about 90% of it in those walks. The range is built once, and every path ever
+// added is put in its `added` index with the answer the per-path walk gives: the position of its first add when that commit
+// is in the range, else -1 ("already existed before the range"). The range's own adds keep their index. The walk runs with
+// rename detection off, as a path-limited `git log -- <path>` effectively does. workflow-state.js is not changed.
+// null when the range cannot be built; each initiative then builds its own, as before.
+function sharedRange(ws, base) {
+  if (typeof ws.commitRange !== 'function') return null;
+  let range;
+  try { range = ws.commitRange(base); } catch { return null; }
+  if (!range || !range.ok || !(range.added instanceof Map)) return range || null;
+  let out;
+  try {
+    out = require('child_process').execFileSync('git', ['-C', base, 'log', '--reverse', '--no-renames', '--diff-filter=A', '--name-only', '--format=%x1e%H'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 512 * 1024 * 1024 });
+  } catch { return range; }
+  // oldest first, and the FIRST add of a path wins: the walk answers with the first commit that added it
+  const added = new Map();
+  for (const chunk of out.split('\x1e')) {
+    const lines = chunk.split('\n');
+    const sha = (lines.shift() || '').trim();
+    if (!sha) continue;
+    const at = range.index.has(sha) ? range.index.get(sha) : -1;
+    for (const l of lines) { const f = l.trim(); if (f && !added.has(f)) added.set(f, at); }
+  }
+  for (const [f, at] of range.added) added.set(f, at);
+  return { ...range, added };
+}
+
+// Ideas, hypotheses, decisions and the KR metric from planning/records/*.jsonl (scripts/records). Empty lists when the
+// files do not exist. The KR is the first metric that has a reading, else the first one defined.
+function readRecordFacts(recordsDir) {
+  let all;
+  try { all = require('../records/index.js').readAll(recordsDir); } catch { return {}; }
+  const krs = all['kr-metrics'] || [];
+  const k = krs.find((m) => (m.readings || []).length) || krs[0] || null;
+  return {
+    ideas: (all.ideas || []).map((i) => ({ slug: i.rid, title: i.title, impact: i.impact, confidence: i.confidence, effort: i.effort, parent_kr: i.parent_kr || null, initiative: i.initiative || null })),
+    hyps: (all.hypotheses || []).map((h) => ({ slug: h.rid, title: h.title, evidence: Array.isArray(h.evidence) ? h.evidence : [], falsifier: h.falsifier, review_by: h.review_by })),
+    decisions: all.decisions || [],
+    kr: k ? { title: k.title || k.metric, metric: k.metric, target: k.target, baseline: k.baseline, by: k.by } : null,
+    metric: k ? k.readings.map((r) => ({ at: r.at, value: r.value })) : [],
+  };
+}
+
+function readFrontmatter(file) {
+  let t; try { t = fs.readFileSync(file, 'utf8'); } catch { return {}; }
+  const m = t.match(/^---\n([\s\S]*?)\n---/); const o = {};
+  if (!m) return o;
+  for (const l of m[1].split('\n')) {
+    const i = l.indexOf(':'); if (i < 1) continue;
+    o[l.slice(0, i).trim()] = l.slice(i + 1).trim().replace(/^["']|["']$/g, '');
+  }
+  return o;
+}
+
+function readWorkItems(file) {
+  let t; try { t = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const items = new Map();
+  for (const line of t.split('\n')) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    if (!e.item_id) continue;
+    const it = items.get(e.item_id) || { key: e.item_id, initiative: e.initiative_id, status: 'todo' };
+    if (e.event && e.event !== 'declared') it.status = /done|merged|accepted|passed/.test(e.event) ? 'done' : /start|doing|claim/.test(e.event) ? 'doing' : it.status;
+    items.set(e.item_id, it);
+  }
+  return [...items.values()];
+}
+
+module.exports = { DAY, dateMs, ms, fmt, temporalStatus, normalizeFacts, readRepoFacts };

package/workspace/lib/engine/signals/index.js

@@ -0,0 +1,33 @@
+'use strict';
+// present(facts, { lens, zoom, today }): facts > detectors > signals > cluster > score > tag > select > anatomy.
+// Returns { cards (the selected cards, in order), folded (count), extraCritical (keys), belowFloor (count), signals }.
+// Options: lens (Plan|Unblock|Close|Reflect|null), zoom (day|week|month), today ('YYYY-MM-DD[THH:MM]'),
+//   pages (detector pages, default ['briefing']; 'all' runs every detector), weights, limit, critCap, pinMax,
+//   floor (relevance floor on the score, default FLOOR).
+// Relevance before variety: a card shows only when its score is at or above the floor and it has a source the reader can
+// open (a page) and a headline that says what happened. Critical cards always pass. Zero cards is a valid answer.
+
+const { normalizeFacts } = require('./facts');
+const detectors = require('./detectors');
+const S = require('./score');
+const sel = require('./select');
+const { buildCard } = require('./cards');
+const kinds = require('./kinds');
+
+const FLOOR = 0.15;
+const relevant = (c, floor) => !!c.page && !!String(c.title || '').trim() && (c.tag === 'Critical' || c.score >= floor);
+
+function present(rawFacts, opts = {}) {
+  const f = normalizeFacts(rawFacts, opts.today);
+  const lens = opts.lens === undefined ? null : opts.lens;
+  const signals = detectors.run(f, opts.pages || ['briefing']);
+  const scored = S.scoreAll(S.cluster(signals), lens, opts.weights);
+  const floor = typeof opts.floor === 'number' ? opts.floor : FLOOR;
+  const kept = scored.filter((c) => relevant(c, floor));
+  const zoomed = sel.inZoom(kept, opts.zoom || 'week');
+  const r = sel.select(zoomed, { limit: opts.limit || 5, critCap: opts.critCap || 3, pinMax: opts.pinMax || 2 });
+  const ctx = { pinned: r.pinned, lens, stance: f.stance, rubric: f.rubric, holdersOf: (id) => (f.inis.find((i) => i.id === id) || { holders: [] }).holders.length };
+  return { cards: r.shown.map((c) => buildCard(c, ctx)), folded: r.folded.length, extraCritical: r.extraCrit.map((c) => c.key), belowFloor: scored.length - kept.length, signals };
+}
+
+module.exports = { present, FLOOR, relevant, kinds, ...S, select: sel.select, normalizeFacts, detectors };