create-pmos 0.505.0 → 0.506.0

package/workspace/lib/drift.js

@@ -0,0 +1,227 @@
+'use strict';
+/* drift.js — "What would I have missed": the weekly check for quiet drift (initiative weekly-drift-check). THE PURE CORE and THE ONE WRITER of
+ * <runtime>/drift/drift.jsonl. lib/drift-facts.js reads the records; lib/drift-runs.js runs the week; lib/routes-drift.js and pm/home-drift.js
+ * show it. Pure apart from read/append: every time comes in.
+ *
+ * STRUCTURED SIGNALS ONLY (PRD R1). An item is made only from records: task lines and their due-date history, initiative rows, the boards ledger's
+ * ini-end lines and the Jira snapshots. No model, no chat or meeting text. Three kinds:
+ *   stalled   a live initiative with an open task and no task line and no record activity for STALL_DAYS
+ *   slipped   an open task whose due date moved later at least twice, the last move inside the week under review
+ *   jira      (a) the initiative is closed and one of its Jira tickets is still open; (b) every ticket (two or more) was resolved at least
+ *             JIRA_DONE_DAYS ago and the initiative is still live
+ * At most MAX items (R2). Every item carries `claims`, each with the records it came from as { label, ref, quote }: `ref` is path:line from the
+ * repository root and `quote` is that line's own text, so lib/ai-guard.js can check every quote against the file (R3).
+ *
+ *   detect(facts, asOf)            PURE → candidates [{ id, kind, level, score, ws, title, say, confidence, claims, data }]
+ *   pick(cands, F)                 PURE → at most MAX, without what the PM dropped, and without what was shown at the same level (R5)
+ *   weekOf(ms) · weekEnd(week)     the Monday (YYYY-MM-DD, local) that starts the week of ms · the Monday 00:00 after it, in ms
+ *   fold(lines) → { weeks, drops, looked, replays }   ·   checkView(F, thisWeek) → the GET body when a check is to show, else null
+ *   dirOf(runtime) · ledgerFile(dir) · read(dir) · append(dir, line, at)
+ *
+ * THE LEDGER (PRIVATE, in the per-user runtime folder, outside every repository). One line per event, { at, kind, ... }:
+ *   week    { week, run, items: [proposal], notRead: [string] }   the week's result (an empty items list is a quiet week; it shows nothing)
+ *   drop    { id, level }    the PM's ⋯ "Not right, drop it"     undo { id }     looked { week }
+ *   replay  { version, ws: [id], weeks: [{ week, ids }], ok, failed }   `pmos drift replay`; a product's items show only after one with ok (R6)
+ */
+const fs = require('fs');
+const path = require('path');
+
+const VERSION = 'drift-1';
+const JOB = 'drift';
+const DAY = 86400000;
+const MAX = 3;
+const STALL_DAYS = 14;
+const JIRA_DONE_DAYS = 7;
+const OPEN = new Set(['To do', 'In progress']);
+const LEDGER = 'drift.jsonl';
+const LINES = new Set(['week', 'drop', 'undo', 'looked', 'replay']);
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const isDate = (s) => /^\d{4}-\d{2}-\d{2}$/.test(String(s || '').slice(0, 10));
+const dayMs = (s) => Date.parse(String(s).slice(0, 10) + 'T00:00:00Z');
+/** 5 Nov, or 5 Nov 2027 when the year is not `year` (a date that moved into another year must not read as moving earlier). */
+const short = (s, year) => { const t = dayMs(s); if (!Number.isFinite(t)) return String(s); const d = new Date(t); return d.getUTCDate() + ' ' + MON[d.getUTCMonth()] + (year && d.getUTCFullYear() !== year ? ' ' + d.getUTCFullYear() : ''); };
+const clip = (s, n) => { const t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n - 1).trimEnd() + '…' : t; };
+const days = (n) => (n === 1 ? '1 day' : n + ' days');
+const pad = (n) => String(n).padStart(2, '0');
+const localDay = (ms) => { const d = new Date(ms); return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()); };
+
+/* ── weeks (local time: the PM's Monday) ─────────────────────────────────────────────────────────────────────── */
+function weekOf(ms) { const d = new Date(ms); d.setHours(0, 0, 0, 0); d.setDate(d.getDate() - ((d.getDay() + 6) % 7)); return localDay(d.getTime()); }
+function weekStart(week) { const [y, m, dd] = String(week).split('-').map(Number); return new Date(y, m - 1, dd).getTime(); }
+function weekEnd(week) { const d = new Date(weekStart(week)); d.setDate(d.getDate() + 7); return d.getTime(); }
+function prevWeek(week) { const d = new Date(weekStart(week)); d.setDate(d.getDate() - 7); return localDay(d.getTime()); }
+
+/* ── detection ──────────────────────────────────────────────────────────────────────────────────────────────── */
+const src = (label, s) => (s && s.ref && s.quote ? { label: clip(label, 60), ref: s.ref, quote: s.quote } : null);
+const claim = (text, sources) => ({ text: clip(text, 240), sources: sources.filter(Boolean) });
+
+/** A task as it stood at asOf: its state, due and the due moves, from its own lines only. null when it did not exist yet or was removed. */
+function taskAt(t, asOf) {
+  const lines = (t.lines || []).filter((l) => Number.isFinite(l.at) && l.at <= asOf).sort((a, b) => a.at - b.at);
+  if (!lines.length || lines[0].kind !== 'task') return null;
+  let state = lines[0].state || 'To do', due = isDate(lines[0].due) ? lines[0].due.slice(0, 10) : null, removed = false;
+  // A SLIP is a day on which the due date ended later than it began. Several moves in one day are one decision (a re-plan, a drag and its
+  // fix-ups), never several slips: the replay on real ledgers showed three "slips" made minutes apart in one sitting.
+  const slips = [];
+  let day = null, dayFrom = null, dayLast = null;
+  const closeDay = () => { if (dayLast && dayFrom && dayLast.to && dayLast.to > dayFrom) slips.push({ at: dayLast.at, from: dayFrom, to: dayLast.to, src: dayLast.src }); };
+  for (const l of lines.slice(1)) {
+    if (l.kind === 'task-remove') { removed = true; continue; }
+    if (l.kind === 'task-restore') { removed = false; continue; }
+    if (l.kind !== 'task-update') continue;
+    if (l.state) state = l.state;
+    if (typeof l.due === 'string') {
+      const nd = isDate(l.due) ? l.due.slice(0, 10) : null;
+      const d = localDay(l.at);
+      if (d !== day) { closeDay(); day = d; dayFrom = due; dayLast = null; }
+      dayLast = { at: l.at, to: nd, src: l.src };
+      due = nd;
+    }
+  }
+  closeDay();
+  if (removed) return null;
+  return { id: t.id, initiative: t.initiative, title: t.title, milestone: !!t.milestone, state, due, slips, last: lines[lines.length - 1] };
+}
+
+function stalledOf(P, ini, tasks, asOf) {
+  const open = tasks.filter((t) => OPEN.has(t.state));
+  if (!open.length) return null;
+  const last = tasks.map((t) => t.last).sort((a, b) => b.at - a.at)[0];
+  const act = Number.isFinite(ini.lastActivity) && ini.lastActivity <= asOf ? ini.lastActivity : null;
+  const moved = Math.max(last.at, act || 0);
+  const quiet = Math.floor((asOf - moved) / DAY);
+  if (quiet < STALL_DAYS) return null;
+  const level = Math.floor(quiet / STALL_DAYS);
+  const lastWhen = localDay(last.at);
+  return {
+    id: 'stalled:' + P.ws + ':' + ini.id, kind: 'stalled', level, score: 40 + Math.min(quiet, 60) / 2, ws: P.ws, product: P.name, initiative: ini.id,
+    title: clip(ini.title, 90) + ' has gone quiet',
+    say: 'Nothing on ' + clip(ini.title, 90) + ' has moved for ' + days(quiet) + ', while ' + open.length + (open.length === 1 ? ' task is' : ' tasks are') + ' still open. It still looks live on the Board.',
+    confidence: 'high',
+    claims: [
+      claim(open.length + (open.length === 1 ? ' open task: ' : ' open tasks, the first: ') + clip(open[0].title, 80) + ' (' + open[0].state + ')', [src(open[0].id, open[0].last.src)]),
+      claim('The last task change was on ' + short(lastWhen) + (act && act > last.at ? ', and the last record change on ' + short(localDay(act)) : ''), [src('last change', last.src), act && act > last.at ? src('record', ini.src) : null]),
+    ],
+    data: { ws: P.ws, product: P.name, initiative: ini.id, quiet, open: open.length },
+  };
+}
+
+function slippedOf(P, ini, t, asOf) {
+  if (!OPEN.has(t.state) || t.slips.length < 2) return null;
+  const lastSlip = t.slips[t.slips.length - 1];
+  if (lastSlip.at <= asOf - 7 * DAY) return null;   // the news is a slip inside the week under review
+  const first = t.slips[0].from, y = new Date(asOf).getUTCFullYear(), n = t.slips.length, shown = t.slips.slice(-3);
+  return {
+    id: 'slipped:' + P.ws + ':' + t.id, kind: 'slipped', level: t.slips.length, score: (t.milestone ? 90 : 70) + Math.min(t.slips.length, 6), ws: P.ws, product: P.name, initiative: ini.id,
+    title: (t.milestone ? 'Milestone ' : '') + clip(t.title, 80) + ' slipped again',
+    say: 'Its date was moved later on ' + n + ' different days, from ' + short(first, y) + ' to ' + short(lastSlip.to, y) + (n > shown.length ? '. The last ' + shown.length + ' are below' : '') + '. It is in ' + clip(ini.title, 80) + '.',
+    confidence: 'high',
+    claims: shown.map((s) => claim('Moved from ' + short(s.from, y) + ' to ' + short(s.to, y) + ' on ' + short(localDay(s.at), y), [src(t.id, s.src)])),
+    data: { ws: P.ws, product: P.name, initiative: ini.id, task: t.id, slips: t.slips.length, milestone: t.milestone },
+  };
+}
+
+function jiraOf(P, ini, J, asOf) {
+  if (!J || !J.tickets || !J.tickets.length) return null;
+  const openAt = (k) => !(k.resolved && dayMs(k.resolved) <= asOf) && (k.category !== 'done' || (k.resolved && dayMs(k.resolved) > asOf));
+  const closedAt = ini.closedAt != null && ini.closedAt <= asOf;
+  if (closedAt) {
+    const open = J.tickets.filter(openAt);
+    if (!open.length) return null;
+    return {
+      id: 'jira:' + P.ws + ':' + ini.id, kind: 'jira', level: open.length, score: 80, ws: P.ws, product: P.name, initiative: ini.id,
+      title: clip(ini.title, 80) + ' is closed, but Jira is not',
+      say: 'It was ' + ini.closedWhy + ' on ' + short(localDay(ini.closedAt)) + ', while ' + open.length + (open.length === 1 ? ' of its Jira tickets is' : ' of its Jira tickets are') + ' still open' + (open.length > 3 ? '. The first 3 are below.' : '.'),
+      confidence: 'high',
+      claims: [claim('Closed: ' + ini.closedWhy, [src('closed', ini.closedSrc)]),
+        ...open.slice(0, 3).map((k) => claim(k.key + ' is ' + (k.status || 'open') + ' in Jira (read ' + short(J.fetchedAt) + ')', [src(k.key, k.src)]))],
+      data: { ws: P.ws, product: P.name, initiative: ini.id, open: open.map((k) => k.key) },
+    };
+  }
+  if (!ini.live || J.tickets.length < 2) return null;
+  const res = J.tickets.map((k) => (k.resolved && dayMs(k.resolved) <= asOf ? dayMs(k.resolved) : null));
+  if (res.some((r) => r == null)) return null;
+  const lastDone = Math.max(...res);
+  if (asOf - lastDone < JIRA_DONE_DAYS * DAY) return null;
+  return {
+    id: 'jira-done:' + P.ws + ':' + ini.id, kind: 'jira', level: 1, score: 60, ws: P.ws, product: P.name, initiative: ini.id,
+    title: 'Jira finished ' + clip(ini.title, 70) + ', PMOS did not',
+    say: 'All ' + J.tickets.length + ' of its Jira tickets were resolved by ' + short(new Date(lastDone).toISOString()) + ', but the initiative is still open in PMOS.',
+    confidence: 'high',
+    claims: J.tickets.slice(0, 3).map((k) => claim(k.key + ' resolved ' + short(k.resolved), [src(k.key, k.src)])),
+    data: { ws: P.ws, product: P.name, initiative: ini.id, tickets: J.tickets.length },
+  };
+}
+
+/** facts: [{ ws, name, initiatives: [{ id, title, live, closedAt, closedWhy, closedSrc, lastActivity, src }], tasks: [{ id, initiative, title,
+ *  milestone, lines: [{ at, kind, state?, due?, src }] }], jira: { [initiative]: { fetchedAt, tickets: [{ key, status, category, resolved, src }] } } }] */
+function detect(facts, asOf) {
+  const out = [];
+  for (const P of Array.isArray(facts) ? facts : []) {
+    const byIni = new Map();
+    for (const t of P.tasks || []) { const a = taskAt(t, asOf); if (!a) continue; if (!byIni.has(a.initiative)) byIni.set(a.initiative, []); byIni.get(a.initiative).push(a); }
+    for (const ini of P.initiatives || []) {
+      try {
+        const tasks = byIni.get(ini.id) || [];
+        if (ini.live && tasks.length) { const s = stalledOf(P, ini, tasks, asOf); if (s) out.push(s); }
+        if (ini.live) for (const t of tasks) { const s = slippedOf(P, ini, t, asOf); if (s) out.push(s); }
+        const j = jiraOf(P, ini, (P.jira || {})[ini.id], asOf); if (j) out.push(j);
+      } catch { /* one record that cannot be read costs its own item, nothing more */ }
+    }
+  }
+  for (const c of out) c.confidence = new Set(c.claims.flatMap((x) => x.sources.map((s) => s.ref))).size >= 2 ? 'high' : 'medium';
+  return out.filter((c) => c.claims.length && c.claims.every((x) => x.sources.length)).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+}
+
+/** At most MAX: never one the PM dropped (at any level), never one already shown at the same or a higher level (R5). */
+function pick(cands, F, max = MAX) {
+  const shown = new Map();
+  for (const w of (F && F.weeks) || []) for (const it of w.items || []) shown.set(it.id, Math.max(shown.get(it.id) || 0, it.level || 0));
+  const dropped = (F && F.drops) || new Map();
+  return (cands || []).filter((c) => !dropped.has(c.id) && !(shown.has(c.id) && shown.get(c.id) >= c.level)).slice(0, max);
+}
+
+/* ── the ledger ─────────────────────────────────────────────────────────────────────────────────────────────── */
+const dirOf = (runtime) => (runtime ? path.join(runtime, 'drift') : null);
+const ledgerFile = (dir) => path.join(dir, LEDGER);
+function readLines(file) {
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const raw of text.split('\n')) { if (!raw.trim()) continue; try { const o = JSON.parse(raw); if (o && LINES.has(o.kind)) out.push(o); } catch { /* a torn line has no effect */ } }
+  return out;
+}
+function fold(lines) {
+  const F = { weeks: [], drops: new Map(), looked: new Set(), replays: [] };
+  for (const l of lines || []) {
+    if (l.kind === 'week' && typeof l.week === 'string') F.weeks.push({ week: l.week, at: l.at, run: l.run, items: Array.isArray(l.items) ? l.items : [], notRead: Array.isArray(l.notRead) ? l.notRead : [], ...(l.held ? { held: true } : {}) });
+    else if (l.kind === 'drop' && typeof l.id === 'string') F.drops.set(l.id, l.level || 0);
+    else if (l.kind === 'undo' && typeof l.id === 'string') F.drops.delete(l.id);
+    else if (l.kind === 'looked' && typeof l.week === 'string') F.looked.add(l.week);
+    else if (l.kind === 'replay') F.replays.push(l);
+  }
+  return F;
+}
+const read = (dir) => fold(readLines(ledgerFile(dir)));
+function append(dir, line, at) {
+  if (!dir || !LINES.has(line && line.kind)) throw new Error('not a drift ledger line');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(ledgerFile(dir), JSON.stringify({ at: at || new Date().toISOString(), ...line }) + '\n', { mode: 0o600 });
+}
+/** The products whose replay of this version passed: only their items show (R6). */
+const replayed = (F, version = VERSION) => new Set((F.replays || []).filter((r) => r.ok === true && r.version === version).flatMap((r) => (Array.isArray(r.ws) ? r.ws : [])));
+
+/** The card for the week before `thisWeek`, while that is the latest result. null in a quiet week, before a replay, or with nothing left. */
+function checkView(F, thisWeek) {
+  const ok = replayed(F);
+  if (!ok.size) return null;
+  const want = prevWeek(thisWeek);
+  const w = [...F.weeks].reverse().find((x) => x.week === want);
+  const items = w ? w.items.filter((it) => ok.has(it.ws)).map((it) => ({ ...it, dropped: F.drops.has(it.id) })) : [];
+  if (!items.length) return null;
+  if (items.every((x) => x.dropped) && F.looked.has(w.week)) return null;
+  return { week: w.week, label: 'Last week', looked: F.looked.has(w.week), items, notRead: w.notRead };
+}
+
+module.exports = { VERSION, JOB, MAX, STALL_DAYS, JIRA_DONE_DAYS, DAY, detect, pick, taskAt, weekOf, weekStart, weekEnd, prevWeek, localDay,
+  dirOf, ledgerFile, readLines, fold, read, append, replayed, checkView };

package/workspace/lib/grill-cli.js

@@ -5,6 +5,9 @@
  *   pmos grill find <angle> --json <file|->     one finding or a list: { "title", "why", "next", "sources": [{ "label", "ref" }], "key"?, "rank"? }
  *   pmos grill voices --sources <n>             how many stored research and meeting-note sources the run found for Voices
  *   pmos grill status                           the open, kept and dropped findings on this initiative (in a run)
+ *   pmos grill decisions [--all]                the decisions that stand, one line each (--all: the superseded and reverted ones too)
+ *   pmos grill find decision --json <file|->    a plan that goes against a decision that stands (lib/decision-memory.js checks it, and
+ *                                               lib/ai-guard.js replays, audits and files it)
  *   pmos grill mode [full|exits|off]            when Claude grills by itself (read, or set)
  *   pmos grill cap [<dollars>]                  the monthly credit cap (read, or set)
  *   pmos grill spend                            this month: spent, cap, runs, paused
@@ -15,7 +18,7 @@ const fs = require('fs');
 const G = require('./grill.js');
 const PR = require('./proposals.js');
 
-const COMMANDS = { grill: ['find', 'voices', 'status', 'mode', 'cap', 'spend'] };
+const COMMANDS = { grill: ['find', 'voices', 'status', 'decisions', 'mode', 'cap', 'spend'] };
 const USAGE = [
   'usage: pmos grill find|voices|status|mode|cap|spend — Claude grills an initiative by itself; each finding waits under its ✦',
   '  pmos grill find <' + G.ANGLES.join('|') + '> --json <file|->',
@@ -23,6 +26,9 @@ const USAGE = [
   '      voices needs ' + G.VOICES_MIN + ' sources or more and is tagged "' + G.SIMULATED.voices + '"; whatif is tagged "' + G.SIMULATED.whatif + '".',
   '  pmos grill voices --sources <n>    the stored research and meeting notes you found for Voices (under ' + G.VOICES_MIN + ': no Voices)',
   '  pmos grill status',
+  '  pmos grill decisions [--all]       the decisions that stand (with --all: what superseded the others)',
+  '  pmos grill find decision --json -  { "decision": "D79", "quote": "<its words>", "plan": { "label", "ref": "<path>:<line>", "quote": "<the plan\'s words>" },',
+  '      "conflict": "<one line>", "recommend": "keep|change|drop", "next": "<one next step>", "confidence": "high|medium" }',
   '  pmos grill mode [full|exits|off]   when Claude grills by itself',
   '  pmos grill cap [<dollars>]         the monthly credit cap; at the cap Claude pauses',
   '  pmos grill spend                   what this month spent',
@@ -42,6 +48,15 @@ async function run(argv, { say = (s) => console.log(s), env = process.env, stdin
   if (!verb || ['help', '--help', '-h'].includes(verb)) { for (const l of USAGE) say(l); return verb ? 0 : 1; }
   if (!COMMANDS.grill.includes(verb)) { say(`unknown grill command "${verb}" — one of ${COMMANDS.grill.join(', ')}`); return 2; }
   const inRun = !!env.PMOS_GRILL_RUN;
+  const rootOf = () => env.PMOS_GRILL_ROOT || (() => { try { return require('child_process').execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return process.cwd(); } })();
+
+  /* ── the decisions that stand (decision memory): readable in a run and out of it ── */
+  if (verb === 'decisions') {
+    const L = require('./decision-ledger.js').load(rootOf());
+    if (!L) { say('no DECISIONS.md in this repository'); return 0; }
+    for (const l of require('./decision-ledger.js').index(L, { all: args.includes('--all') })) say(l);
+    return 0;
+  }
 
   /* ── the PM's verbs ── */
   if (verb === 'mode' || verb === 'cap' || verb === 'spend') {
@@ -84,6 +99,12 @@ async function run(argv, { say = (s) => console.log(s), env = process.env, stdin
   }
   const angle = args[1];
   if (!G.ANGLES.includes(angle)) { say('✗ the angle is one of ' + G.ANGLES.join(', ')); return 2; }
+  if (angle === 'decision') {
+    const jsonAt = args.indexOf('--json'), src = jsonAt >= 0 ? args[jsonAt + 1] : null;
+    if (!src) { say('usage: pmos grill find decision --json <file|->'); return 2; }
+    const r = readJson(src, stdin); if (r.error) { say('✗ ' + r.error); return 1; }
+    return require('./decision-memory.js').fileRun({ root: rootOf(), file, run: runId, ini, board, env, now, say, P, settingsDir: stateOf(env) }, Array.isArray(r.body) ? r.body : [r.body]);
+  }
   if (angle === 'voices' && !(me.voices >= G.VOICES_MIN)) { say(`✗ Voices needs ${G.VOICES_MIN} stored sources or more: run pmos grill voices --sources <n> first, and leave Voices out under ${G.VOICES_MIN}`); return 1; }
   const jsonAt = args.indexOf('--json'), src = jsonAt >= 0 ? args[jsonAt + 1] : null;
   if (!src) { say(`usage: pmos grill find ${angle} --json <file|->`); return 2; }

package/workspace/lib/grill-runs.js

@@ -2,7 +2,7 @@
 /* grill-runs.js — Claude's runs that grill an initiative by themselves (Grill and Forecast, part G-A; lib/grill.js says what and when).
  *
  *   create(deps) → { tick(opts), start({ ws, board, ini, why, key, detail, now }), stop(run), active() }
- *   promptOf(skill, o) → the prompt of one run. o: { run, why, detail, ini, title, intent, stage, stages, today, open, dropped, budget }
+ *   promptOf(skill, o) → the prompt of one run. o: { run, why, detail, ini, title, intent, stage, stages, today, open, dropped, budget, decisions }
  *
  * ONE RUN KIND (headless kind `grill`, origin `grill:<ws>:<initiative>:<run>`). The run reads the repository, the stored reads, the
  * stored research and meeting notes, and files with `pmos grill find`, pinned by the server to this initiative and run (PMOS_GRILL_FILE,
@@ -12,6 +12,8 @@
  * deps: { workspaces() → [w], isLead(w), stateDirFor(w), runtimeDir(), rowOf(w, id) → { title, intent, stage, stages } | null,
  *         exits(w) → [{ ini, board, stage }] (stages about to end), shapes(w) → [{ ini, board, n, end }] (open tasks, latest due),
  *         looks(w) → [{ ini, board, n, end }] (running initiatives with open tasks, for the monthly look),
+ *         plans(w) → [{ ini, board, path, sig }] (optional: each initiative's PRD and a signature of its text, for the `plan` trigger;
+ *         without it, lib/decision-memory.js plansIn reads the records of the initiatives looks(w) returns),
  *         goalInis(w, goalId) → [{ id, endAt, status }] (the initiatives anchored to that goal), checks(w, day) → [{ ini, board, tasks }] (late or at-risk work), turned(dir, sinceIso) → [forecast `turned` line] (lib/forecast.js),
  *         api { available(env), run({ prompt, root, env, budget, signal }) → Promise<{ ok, code, costUsd, note?, stopped? }> } (lib/grill-api.js; optional),
  *         setting(key) (lib/settings-store.js get), open(now) → bool, headlessOff() → bool, env, promptFor(skillId), spawn(spec), stop(session), warn }
@@ -28,6 +30,7 @@ const WHY = {
   exit: 'The initiative is about to leave its stage. Grill it before it does: what would make the next stage fail?',
   forecast: 'Its forecast just turned. Grill it: why, and what would bring it back?',
   move: 'Its scope or dates moved a lot. Grill it: is the plan still the right plan?',
+  plan: 'Its PRD changed. Check the new plan against the decisions that stand (the decision angle) first, then grill it.',
   monthly: 'The monthly look at running work (late work first, then the initiatives grilled longest ago). Grill it.',
   ask: 'The PM asked for it in the initiative\'s chat. Grill it now: what would make it fail, and what is the next step?',
 };
@@ -39,6 +42,7 @@ function promptOf(skill, o) {
     + `- Its workflow's stages, in order:\n${list((o.stages || []).map((s) => s.key + ' · ' + s.name), 'not known')}\n`
     + `- Open findings already under its ✦ (do not file them again):\n${list(o.open, 'none')}\n`
     + `- Dropped by the PM (do not file these again unless the evidence is new):\n${list(o.dropped, 'none')}\n`
+    + (o.decisions && o.decisions.length ? `- The decisions that stand (for the decision angle; Read the line for a decision's words):\n${list(o.decisions, 'none')}\n` : '')
     + `- Your budget: $${o.budget}. Stop when you have your findings.\n\n`
     + 'File with `pmos grill find` only (the server pins this initiative and run). Send nothing.';
 }
@@ -101,9 +105,12 @@ function create(deps) {
     const mine = [...P.props.values()].filter((p) => p.ini === ini && p.group === 'grill');
     const dropped = mine.filter((p) => P.drops.has(PR.sigOf(p))).slice(0, 20).map((p) => one(p.title, 120));
     const open = mine.filter((p) => !P.drops.has(PR.sigOf(p)) && !kept.has(p.id)).slice(0, 20).map((p) => one(p.title, 120));
-    const prompt = promptOf(skill, { run, why, detail, ini, title: row.title || ini, intent: row.intent || '', stage: row.stage || '', stages: row.stages || [], today: localDay(now), open, dropped, budget: b.budget });
+    // decision memory: the decisions that stand go in the prompt, so the run checks the plan against all of them, not a search's hits
+    let decisions = [];
+    try { const DL = require('./decision-ledger.js'), L = w.root ? DL.load(w.root) : null; decisions = L ? DL.index(L) : []; } catch (e) { warn('grill decisions', e); }
+    const prompt = promptOf(skill, { run, why, detail, ini, title: row.title || ini, intent: row.intent || '', stage: row.stage || '', stages: row.stages || [], today: localDay(now), open, dropped, budget: b.budget, decisions });
     active.set(run, { session: null });
-    const env = { PMOS_GRILL_FILE: PR.ledgerFile(dir), PMOS_GRILL_LOG: G.logFile(rt), PMOS_GRILL_WS: ws, PMOS_GRILL_BOARD: board || '', PMOS_GRILL_INI: ini, PMOS_GRILL_RUN: run, PMOS_GRILL_BUDGET: String(b.budget) };
+    const env = { PMOS_GRILL_FILE: PR.ledgerFile(dir), PMOS_GRILL_LOG: G.logFile(rt), PMOS_GRILL_ROOT: w.root || '', PMOS_GRILL_WS: ws, PMOS_GRILL_BOARD: board || '', PMOS_GRILL_INI: ini, PMOS_GRILL_RUN: run, PMOS_GRILL_BUDGET: String(b.budget) };
     // With an API key the run goes to the Claude API (lib/grill-api.js); without one it stays a background agent session
     if (deps.api && deps.api.available(deps.env)) {
       const ctl = new AbortController();
@@ -158,6 +165,16 @@ function create(deps) {
       const what = G.moved(prev, cur);
       if (what) out.push({ ws: w.id, board: s.board, ini: s.ini, why: 'move', key: `move:${w.id}:${s.ini}:${cur.n}:${cur.end}`, detail: what });
     }
+    // decision memory: a PRD that changed since the last look is checked against the decisions that stand. The first look only records it
+    // the PRDs come from deps.plans, else from the running initiatives' records in the workspace (lib/decision-memory.js plansIn)
+    const plans = deps.plans ? () => deps.plans(w) : () => (w.root && deps.looks ? require('./decision-memory.js').plansIn(w.root, deps.looks(w)) : []);
+    for (const p of tryList(plans)) {
+      if (!p || !p.ini || !p.sig) continue;
+      const prev = F.plans.get(w.id + '|' + p.ini);
+      if (prev === p.sig) continue;
+      try { G.append(deps.runtimeDir(), { kind: 'plan', ws: w.id, ini: p.ini, sig: p.sig }, now); } catch (e) { warn('grill plan', e); }
+      if (prev) out.push({ ws: w.id, board: p.board || '', ini: p.ini, why: 'plan', key: `plan:${w.id}:${p.ini}:${p.sig}`, detail: 'its PRD changed: ' + one(p.path, 120) });
+    }
     // the monthly look: every running initiative with open work, at most once in 30 days each (Wawan 2026-11-02: "why only one?").
     // Late work first, then the ones never grilled, then the ones grilled longest ago; the cap decides how far down the list a month goes.
     const late = tryList(() => deps.checks && deps.checks(w, localDay(now))), seen = new Set();

package/workspace/lib/grill.js

@@ -7,7 +7,8 @@
  * finding is one proposal under the initiative's blue ✦ (lib/proposals.js, group `grill`, type = the angle), with a next step. The PM keeps,
  * drops or undoes it there. Nothing changes before the PM's ✓; the ✓ adds the next step as a task. Zero findings is silence.
  *
- * THE ANGLES: premortem · redteam · voices · reframe · scope · whatif. Voices are simulated from stored research and meeting notes only,
+ * THE ANGLES: premortem · redteam · voices · reframe · scope · whatif · decision. `decision` (decision memory) is a plan that goes against an
+ * earlier decision that still stands; it quotes both sides verbatim and is checked by lib/decision-memory.js, not by finding(). Voices are simulated from stored research and meeting notes only,
  * and only with 3 sources or more ("Simulated, not evidence"). A what-if is "Simulated, not the plan". The angle and the tag are in the
  * proposal's own title, so the ✦ list shows them as it is.
  *
@@ -15,6 +16,8 @@
  *   exit      the initiative is about to leave its stage (most of the stage's tasks are closed), once per stage
  *   forecast  its forecast, or the forecast of a goal it moves, turned at-risk or will-miss (lib/forecast.js `turned` lines), once per turn
  *   move      its scope or dates moved a lot since the last look (tasks ±30% and 3 or more, or the end ±14 days)
+ *   plan      its PRD changed since the last look (decision memory: a new plan is checked against the decisions that stand). The first
+ *             look only records the PRD; a run starts when it changes after that
  *   monthly   every running initiative with open work, at most once in 30 days each: late work first, then the ones grilled longest ago
  * `exits` runs only the first. Every run counts against the monthly credit cap (grill.cap, US dollars): before a run the cap must hold
  * the run's whole budget, which goes to the run as --max-budget-usd, so the month never goes beyond the cap. At the cap Claude pauses and
@@ -28,10 +31,11 @@
  *   voices  { run, n }                                  how many stored research and note sources the run found for Voices
  *   end     { run, ok, cost, error? }                   cost: US dollars the run spent (lib/headless.js parseResult costUsd)
  *   snap    { ws, ini, n, end }                         the open tasks and the latest due date the last look saw (for `move`)
+ *   plan    { ws, ini, sig }                            the signature of its PRD the last look saw (for `plan`)
  *   paused  { month, spent, cap }                       the cap held a run back this month; written once per month
  *
  *   logFile(dir) · readLines(file) · read(dir) → fold · append(dir, line)
- *   fold(lines)                              PURE → { runs: Map run → r, keys: Set, lastAt: Map ws|ini → iso, snaps: Map, paused: Set month }
+ *   fold(lines)                              PURE → { runs: Map run → r, keys: Set, lastAt: Map ws|ini → iso, snaps: Map, plans: Map, paused: Set month }
  *   monthOf(ms) · spentIn(F, month)          the month's spend (an open run counts its whole budget)
  *   budgetFor(F, { cap, now })               PURE → { ok, budget, spent } | { ok: false, spent, why: 'cap' }
  *   moved(prev, cur)                         PURE → '' | what moved, in words
@@ -44,11 +48,11 @@ const path = require('path');
 const crypto = require('crypto');
 
 const LOG = 'grill-runs.jsonl';
-const KINDS = new Set(['start', 'voices', 'end', 'snap', 'paused']);
-const ANGLES = Object.freeze(['premortem', 'redteam', 'voices', 'reframe', 'scope', 'whatif']);
-const LABEL = Object.freeze({ premortem: 'Premortem', redteam: 'Red team', voices: 'Voices', reframe: 'Reframe', scope: 'Scope', whatif: 'What-if' });
+const KINDS = new Set(['start', 'voices', 'end', 'snap', 'plan', 'paused']);
+const ANGLES = Object.freeze(['premortem', 'redteam', 'voices', 'reframe', 'scope', 'whatif', 'decision']);
+const LABEL = Object.freeze({ premortem: 'Premortem', redteam: 'Red team', voices: 'Voices', reframe: 'Reframe', scope: 'Scope', whatif: 'What-if', decision: 'Earlier decision' });
 const SIMULATED = Object.freeze({ voices: 'Simulated, not evidence', whatif: 'Simulated, not the plan' });
-const WHYS = Object.freeze(['exit', 'forecast', 'move', 'monthly', 'ask']);
+const WHYS = Object.freeze(['exit', 'forecast', 'move', 'plan', 'monthly', 'ask']);
 const MODES = Object.freeze(['full', 'exits', 'off']);
 const VOICES_MIN = 3;
 const RUN_MAX_USD = 2;        // one run never spends more than this
@@ -92,7 +96,7 @@ function append(dir, ev, at = new Date()) {
 }
 
 function fold(lines) {
-  const runs = new Map(), keys = new Set(), lastAt = new Map(), snaps = new Map(), paused = new Set();
+  const runs = new Map(), keys = new Set(), lastAt = new Map(), snaps = new Map(), plans = new Map(), paused = new Set();
   for (const l of lines || []) {
     if (!isObj(l)) continue;
     if (l.kind === 'start' && str(l.run)) {
@@ -102,9 +106,10 @@ function fold(lines) {
     } else if (l.kind === 'voices') { const r = runs.get(l.run); if (r) r.voices = Number(l.n) || 0; }
     else if (l.kind === 'end') { const r = runs.get(l.run); if (r) { r.ended = true; r.ok = !!l.ok; r.cost = Number.isFinite(Number(l.cost)) && l.cost !== null ? Number(l.cost) : null; r.endAt = str(l.at); if (l.error) r.error = str(l.error); } }
     else if (l.kind === 'snap') snaps.set(l.ws + '|' + l.ini, { n: Number(l.n) || 0, end: str(l.end), at: str(l.at) });
+    else if (l.kind === 'plan') plans.set(l.ws + '|' + l.ini, str(l.sig));
     else if (l.kind === 'paused') paused.add(str(l.month));
   }
-  return { runs, keys, lastAt, snaps, paused };
+  return { runs, keys, lastAt, snaps, plans, paused };
 }
 
 /* ── the credit cap ── */
@@ -152,6 +157,8 @@ const LIM = { title: 140, why: 300, next: 140, label: 80, ref: 500 };
 /** → { prop } | { error }. input: { title, why, next, sources: [{ label, ref }], key?, rank? } */
 function finding(angle, input) {
   if (!ANGLES.includes(angle)) return { error: 'the angle is one of ' + ANGLES.join(', ') };
+  // an earlier decision has its own shape and its own checks (lib/decision-memory.js); `pmos grill find decision` files it
+  if (angle === 'decision') return { error: 'the decision angle files through lib/decision-memory.js (pmos grill find decision)' };
   if (!isObj(input)) return { error: 'the finding is a JSON object' };
   const title = one(input.title, LIM.title), why = one(input.why, LIM.why), next = one(input.next, LIM.next);
   if (!title) return { error: 'title is the finding in one short line' };

package/workspace/lib/past-chat.js

@@ -0,0 +1,32 @@
+'use strict';
+/* past-chat.js — what a chat knows when the PM asks it about the past (initiative ask-the-past). There is no search box and no button: the PM
+ * asks in the initiative chat ("why did we drop X?", "did we ever decide Y?"), and this rule reaches the session first, as lib/program-chat.js
+ * does for programs.
+ *
+ * THE GUARDRAIL IS THE RULE'S ORDER. The chat runs `pmos past ask`, answers ONLY from the lines it prints, cites each as path:line, checks its
+ * draft with `pmos past verify`, and says "No record found" when the records hold nothing. It never guesses a reason, never quotes a
+ * superseded decision as the live rule, and never changes a record while answering.
+ *
+ *   isAsk(text)        → whether a message asks about the past (lib/past.js isPastAsk)
+ *   rule()             → the rule's lines
+ *   wrap(text)         → the message as PMOS types it into a live session
+ */
+const P = require('./past.js');
+
+const MARK = '[PMOS past]';
+const SAYS = 'The PM asks: ';
+const RULE = [
+  'The PM asks about the past. Answer from the records PMOS keeps, never from memory:',
+  '1. Run `pmos past ask "<the PM\'s question, in their words>"`. It prints the records that answer it, each with its path:line and its own words, and how sure the match is.',
+  '2. Answer in two to four sentences, from those lines only. Put the path:line after each claim, as printed. Say when it was decided and by which record (for example D66).',
+  '3. A line marked SUPERSEDED is history: say what replaced it. A weak match says so in your answer.',
+  '4. If it prints "No record found", or its lines do not really answer the question, say "No record found" and name what PMOS read. Never guess a reason.',
+  '5. Before you answer, run `pmos past verify --text "<your answer>"` and fix every citation it marks ✗.',
+  'Do not change any record, task or decision while you answer. If the PM then wants something changed, ask first.',
+].join('\n');
+
+const isAsk = (text) => P.isPastAsk(text);
+const rule = () => RULE;
+function wrap(text) { return MARK + ' ' + RULE + '\n\n' + SAYS + String(text == null ? '' : text); }
+
+module.exports = { MARK, isAsk, rule, wrap, RULE };

package/workspace/lib/past-cli.js

@@ -0,0 +1,147 @@
+'use strict';
+/* past-cli.js — `pmos past …`: ask PMOS about the past (initiative ask-the-past; lib/past.js is the engine).
+ *
+ *   pmos past ask "<question>" [--json] [--limit N]   the records that answer it, each with its path:line and its own words, and how sure
+ *                                                     the match is; "No record found" when nothing answers it
+ *   pmos past check "<idea>" [--json]                 what was decided or declined before about this idea ("you decided this before")
+ *   pmos past verify --text "<answer>" | --file <f>   every path:line the answer cites is a record PMOS read, at a line that exists
+ *   pmos past sources                                 which records were read, and which were not on this machine
+ *
+ * WHAT IT READS. The repository's tracked records: DECISIONS.md, the ADRs, pm-decisions.md, planning/out-of-scope/, planning/initiatives/
+ * and discoveries.md; and, in the per-user state folder, the decisions caught in meeting notes that the PM did not mark wrong or delete
+ * (lib/meeting-points.js). A private note is never read. Chat transcripts and Jira tickets are not past records PMOS keeps on this machine,
+ * so they are named as not read rather than guessed at.
+ *
+ * WHAT IT NEVER DOES. It writes nothing, sends nothing and calls no model. The answer in words is the chat's: the initiative chat runs
+ * `pmos past ask`, answers only from what it prints and cites each line (lib/past-chat.js).
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const P = require('./past.js');
+const { defaultRoot } = require('./state-root');
+const { parseArgs } = require('./schedule-cli');
+
+const COMMANDS = { past: ['ask', 'check', 'verify', 'sources'] };
+const USAGE = [
+  'usage: pmos past ask|check|verify|sources — ask PMOS about the past, with the source of every answer',
+  '  pmos past ask "<question>" [--json] [--limit N]',
+  '  pmos past check "<idea>" [--json]',
+  '  pmos past verify --text "<answer>" | --file <path>',
+  '  pmos past sources',
+];
+const REPO_RE = /^(DECISIONS\.md|pm-decisions\.md|discoveries\.md|okf\/products\/pmos\/adr\/[^/]+\.md|planning\/out-of-scope\/[^/]+\.md|planning\/initiatives\/[^/]+\.md)$/;
+const NOT_READ = ['chat transcripts (PMOS keeps no searchable copy)', 'Jira tickets (no ticket history on this machine)'];
+const KIND_WORD = { decision: 'decision', amendment: 'amendment', adr: 'decision record', 'pm-decision': 'PM journal', 'out-of-scope': 'declined request',
+  initiative: 'initiative', discovery: 'run log', meeting: 'meeting decision', claim: 'claim', ticket: 'ticket' };
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+
+/** The repository's past records: [{ path, text }]. */
+function repoFiles(root) {
+  const out = [];
+  for (const rel of git(root, ['ls-files', '-z', '*.md']).split('\0').filter((p) => REPO_RE.test(p))) {
+    try { out.push({ path: rel, text: fs.readFileSync(path.join(root, rel), 'utf8') }); } catch { /* a file that cannot be read is not a record */ }
+  }
+  return out;
+}
+
+/** The decisions caught in the PM's meeting notes: [{ kind: 'meeting', ref, title, text, date, quote }]. A private note, and a point marked
+ *  wrong or deleted, is left out. */
+function meetingRecords(stateDir) {
+  const dir = path.join(stateDir || '', 'notes');
+  let names = [];
+  try { names = fs.readdirSync(dir).filter((f) => /^[A-Za-z0-9_-]{1,80}\.json$/.test(f)); } catch { return { records: [], read: false, notes: 0 }; }
+  let MR = null, MP = null;
+  try { MR = require('./meeting-replay.js'); MP = require('./meeting-points.js'); } catch { return { records: [], read: false, notes: 0 }; }
+  const out = []; let notes = 0;
+  for (const f of names) {
+    let n = null;
+    try { n = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')); } catch { continue; }
+    if (!n || n.private) continue;
+    notes++;
+    const id = f.slice(0, -5);
+    const verdicts = MP.pointsOf(stateDir, id);
+    const caught = MR.caughtOf(n);
+    const when = String((n.meeting && n.meeting.start) || n.created_at || '').slice(0, 10);
+    const title = String((n.meeting && n.meeting.title) || n.title || 'Meeting').slice(0, 100);
+    caught.decision.forEach((d, i) => {
+      const pid = 'd' + (i + 1);
+      if (verdicts[pid] === 'wrong' || verdicts[pid] === 'deleted') return;
+      out.push({ kind: 'meeting', ref: 'state:notes/' + f + ':1', title: title + ' — ' + d.text, text: d.text + (d.quote ? '\n' + d.quote : ''), date: when, quote: d.text,
+        ...(verdicts[pid] === 'confirmed' ? { confirmed: true } : {}) });
+    });
+  }
+  return { records: out, read: true, notes };
+}
+
+function corpusFor(cwd, stateDir) {
+  let root;
+  try { root = git(cwd, ['rev-parse', '--show-toplevel']).trim(); } catch { root = null; }
+  const files = root ? repoFiles(root) : [];
+  const m = meetingRecords(stateDir);
+  return { root, C: P.build(files, m.records), meetings: m };
+}
+
+function sourcesLine(C, meetings) {
+  const k = C.kinds || {};
+  const parts = [];
+  const n = (key, word) => { if (k[key]) parts.push(k[key] + ' ' + word); };
+  n('decision', 'decisions'); n('adr', 'decision records'); n('amendment', 'amendments'); n('pm-decision', 'PM journal entries');
+  n('out-of-scope', 'declined requests'); n('initiative', 'initiatives'); n('discovery', 'run-log entries');
+  parts.push(meetings.read ? (k.meeting || 0) + ' meeting decisions from ' + meetings.notes + ' notes' : 'no meeting notes on this machine');
+  return 'Read: ' + parts.join(', ') + '. Not read: ' + NOT_READ.join('; ') + '.';
+}
+
+function hitLines(h, i) {
+  const st = h.status === 'reverted' ? ' · REVERTED: not the live rule' : h.status === 'superseded' ? ` · SUPERSEDED${h.partial ? ' in part' : ''}${h.supersededBy && h.supersededBy.length ? ' by ' + h.supersededBy.join(', ') : ''}: not the live rule`
+    : h.status === 'amended' ? ` · amended${h.amendedBy && h.amendedBy.length ? ' by ' + h.amendedBy.join(', ') : ''}` : '';
+  const out = [`${i + 1}. ${h.title}  (${KIND_WORD[h.kind] || h.kind}${h.date ? ', ' + h.date : ''}${st})`, `   ${h.ref}  "${h.quote}"`];
+  if (h.recordStatus) out.push(`   its status: ${h.recordStatus}`);
+  if (h.dropSaid === false) out.push('   (names the subject, but does not say it was dropped)');
+  return out;
+}
+
+const CONF_WORD = { high: 'a strong match: two or more records agree', medium: 'a fair match', low: 'a weak match: read the lines before you rely on them' };
+
+function run(argv, { say = console.log, cwd = process.cwd(), stateDir = defaultRoot() } = {}) {
+  const args = argv[0] === 'past' ? argv.slice(1) : argv.slice();
+  const verb = args[0];
+  if (!verb || verb === 'help' || verb === '--help') { for (const l of USAGE) say(l); return verb ? 0 : 2; }
+  if (!COMMANDS.past.includes(verb)) { say(`✗ unknown past command "${verb}" — one of ${COMMANDS.past.join(', ')}`); return 2; }
+  const { pos, flags } = parseArgs(args.slice(1));
+  const { C, meetings, root } = corpusFor(cwd, stateDir);
+  if (!root && !meetings.read) { say('✗ this is not a git repository and there are no meeting notes here, so there is no past to read'); return 1; }
+
+  if (verb === 'sources') { say(sourcesLine(C, meetings)); return 0; }
+
+  if (verb === 'verify') {
+    let text = flags.text;
+    if (flags.file) { try { text = fs.readFileSync(String(flags.file), 'utf8'); } catch (e) { say('✗ cannot read ' + flags.file + ': ' + (e.code || e.message)); return 1; } }
+    if (typeof text !== 'string' || !text.trim()) { say('✗ give the answer with --text "<answer>" or --file <path>'); return 2; }
+    const v = P.verify(C, text);
+    if (!v.refs.length) { say('✗ the answer cites no record (path:line). Cite the lines `pmos past ask` printed, or say no record was found.'); return 1; }
+    for (const r of v.refs) say(`${r.ok ? '✓' : '✗'} ${r.ref}${r.ok ? '' : ' — ' + r.why}`);
+    say(v.ok ? 'Every citation is a record PMOS read.' : 'Remove or fix the citations marked ✗ before you answer.');
+    return v.ok ? 0 : 1;
+  }
+
+  const q = pos.join(' ').trim();
+  if (!q) { say(`✗ give the ${verb === 'ask' ? 'question' : 'idea'} in quotes: pmos past ${verb} "<${verb === 'ask' ? 'question' : 'idea'}>"`); return 2; }
+  const limit = Math.max(1, Math.min(10, Number(flags.limit) || 5));
+  const r = verb === 'ask' ? P.search(C, q, { limit }) : P.repeats(C, q, { limit });
+  if (flags.json) { say(JSON.stringify({ question: q, confidence: r.confidence, none: r.none, hits: r.hits, read: sourcesLine(C, meetings) }, null, 1)); return 0; }
+  if (r.none) {
+    say(verb === 'ask' ? `No record found for "${q}".` : `No earlier decision found about "${q}".`);
+    say('Nothing PMOS keeps answers it. Say so plainly, and do not guess a reason.');
+    say(sourcesLine(C, meetings));
+    return 0;
+  }
+  say(`${verb === 'ask' ? 'What the records say' : 'You decided this before'}: ${CONF_WORD[r.confidence]}.`);
+  r.hits.forEach((h, i) => { for (const l of hitLines(h, i)) say(l); });
+  say('Answer only from these lines. Cite each one as path:line. A superseded decision is history, not the rule. If they do not answer the question, say no record was found.');
+  say(sourcesLine(C, meetings));
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE, corpusFor, repoFiles, meetingRecords, REPO_RE };