create-pmos 0.505.0 → 0.507.0

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 };

package/workspace/lib/past-repeat.js

@@ -0,0 +1,126 @@
+'use strict';
+/* past-repeat.js — "You decided this before" (initiative ask-the-past). When the PM adds an initiative, PMOS reads what was decided or
+ * declined before (lib/past.js repeats) and, when the new idea repeats one, raises ONE finding under the initiative's blue ✦ (lib/proposals.js
+ * group `grill`, type `past`; public/pm/grill-words.js draws its words and mark). It quotes the earlier record and its line; the next step is to say what is different this time. Nothing
+ * changes before the PM's ✓, and ✕ drops it. Zero matches is silence.
+ *
+ * It is deterministic: no model, no session, no network. It still goes through THE ONE DOOR, lib/ai-guard.js: kill switch (PMOS_AI,
+ * PMOS_AI_PAST_REPEAT, Settings ai.off), the replay gate (the cases below, run once per version before anything shows), the check of every
+ * quote at its line, and the audit line. Until lib/ai-guard.js is on this machine, nothing is filed.
+ *
+ * Decision memory raises the other kind: "this contradicts an earlier decision" (keep, change or drop). This one says "you decided this
+ * before": the idea is a repeat, or a reminder of why it was set aside.
+ *
+ *   proposalFor(C, { ini, title, intent }) → [proposal] (the guard's shape) | []    PURE
+ *   findingOf(p) → the lib/grill.js finding input for one proposal
+ *   cases() → the replay cases
+ *   file({ root, dir, runtime, ws, board, ini, title, intent, env, guard?, now? }) → Promise<{ filed, dropped, held?, off?, none? }>
+ */
+const fs = require('fs');
+const crypto = require('crypto');
+const P = require('./past.js');
+const G = require('./grill.js');
+const PR = require('./proposals.js');
+
+const JOB = 'past-repeat';
+const VERSION = '1';
+const MIN_COVER = 0.6;          // the earlier record holds at least this share of what the idea is about
+const OWN = (ini) => new RegExp('(^|/)' + String(ini).replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\.md$');
+const hash = (s) => crypto.createHash('sha1').update(String(s)).digest('hex').slice(0, 10);
+const one = (v, n) => String(v == null ? '' : v).replace(/\s+/g, ' ').trim().slice(0, n);
+const KIND_WORD = { decision: 'decision', amendment: 'decision', adr: 'decision record', 'pm-decision': 'PM journal', 'out-of-scope': 'declined request', initiative: 'initiative', meeting: 'meeting' };
+
+function guardOf() { try { return require('./ai-guard.js'); } catch { return null; } }
+
+/** PURE. The idea → the "you decided this before" proposal, or nothing. */
+function proposalFor(C, { ini, title, intent } = {}) {
+  const idea = [title, intent].filter(Boolean).join('. ');
+  if (!idea.trim()) return [];
+  const own = ini ? OWN(ini) : null;
+  // a meeting decision lives in the per-user notes, outside the folders the guard checks a quote in: the chat cites it, the ✦ does not
+  const r = P.repeats(C, idea, { limit: 8, kinds: ['decision', 'adr', 'amendment', 'pm-decision', 'out-of-scope', 'initiative'] });
+  if (r.none || r.confidence === 'low') return [];
+  const hits = r.hits.filter((h) => h.cover >= MIN_COVER && !(own && own.test(h.path)) && !(ini && h.kind === 'initiative' && h.path.endsWith('/' + ini + '.md'))).slice(0, 3);
+  if (!hits.length) return [];
+  const top = hits[0];
+  const live = top.status === 'superseded' ? ` (later superseded${top.supersededBy && top.supersededBy.length ? ' by ' + top.supersededBy.join(', ') : ''})` : '';
+  const say = `${KIND_WORD[top.kind] || 'A record'}${top.date ? ' of ' + top.date : ''} already covers this${live}: "${one(top.quote, 160)}"`;
+  return [{
+    id: 'past-' + hash([ini || '', top.ref].join('|')),
+    title: one(top.title, 120),
+    say,
+    confidence: hits.length >= 2 && r.confidence === 'high' ? 'high' : r.confidence === 'high' ? 'medium' : r.confidence,
+    claims: hits.map((h) => ({ text: one(h.title, 160), sources: [{ label: h.id || (KIND_WORD[h.kind] || h.kind), ref: h.ref, quote: h.quote }] })),
+    data: { group: 'grill', angle: 'past', next: `Say what is different from "${one(top.title, 70)}" this time` },
+  }];
+}
+
+/** The lib/grill.js finding input for one guarded proposal. */
+function findingOf(p) {
+  const srcs = [];
+  for (const c of p.claims || []) for (const s of c.sources || []) if (!srcs.some((x) => x.ref === s.ref)) srcs.push({ label: one(s.label + ' · ' + s.ref, 80), ref: s.ref });
+  return { title: p.title, why: p.say, next: p.data && p.data.next, sources: srcs.slice(0, 8), key: p.id, rank: 2 };
+}
+
+/** The finding as lib/grill.js finding() shapes it, for angle `past` (group grill, section check: its own ✓, never Keep all). The angle
+ *  is not in grill.js ANGLES on purpose: a grill run never files it; only this module does, after the guard. */
+const LABEL = 'You decided this before';
+function grillProp(f) {
+  return { group: 'grill', type: 'past', section: 'check', title: one(LABEL + ': ' + f.title, 200), why: one(f.why + ' Next: ' + f.next, 460),
+    sources: f.sources.map((s) => ({ label: one(s.label, 80), ref: one(s.ref, 500) })), items: [], data: { angle: 'past', next: one(f.next, 140), rank: f.rank } };
+}
+
+/* The replay: a repeat of a declined request is raised with its line; an idea nothing covers is silence; an idea that is the initiative's
+ * own record is not a repeat of itself. */
+const FIXTURE = [
+  { path: 'planning/out-of-scope/graph-store.md', text: '---\ntype: Reference\ntitle: "A graph store for OKF ingestion (Neo4j-class)"\n---\n\n# A graph store for OKF ingestion (Neo4j-class)\n\n- decision: declined\n- date: 2026-06-29\n\n## Reasoning\n\nA Neo4j graph store was declined twice: the reads are joins, not path traversal.\n' },
+  { path: 'pm-decisions.md', text: '---\ntype: Decision\ntitle: "pm-decisions.md"\n---\n\n# pm-decisions.md\n\n## 2026-10-01 — Dark launch of the phone app dropped\n- decision: the phone app stays a web page; no store app.\n' },
+  { path: 'planning/initiatives/kg-graph-db.md', text: '---\ntype: Initiative\ntitle: "Store the knowledge graph in a Neo4j graph store"\nid: kg-graph-db\n---\n\n# Store the knowledge graph in a Neo4j graph store\n' },
+];
+function cases() {
+  const C = P.build(FIXTURE);
+  return [
+    { name: 'a repeat of a declined request is raised with its line', run: async () => proposalFor(C, { ini: 'kg-graph-db', title: 'Store the knowledge graph in a Neo4j graph store', intent: 'path traversal over OKF' }), expect: { filed: 1, cites: ['planning/out-of-scope/graph-store.md'] } },
+    { name: 'an idea nothing covers is silence', run: async () => proposalFor(C, { ini: 'x', title: 'Weekly espresso budget for the design team', intent: '' }), expect: { none: true } },
+  ];
+}
+let fixtureRoot = null;
+/** The replay reads the fixture's files from a folder of its own (the guard checks each quote on disk). */
+function replayRoot() {
+  if (fixtureRoot && fs.existsSync(fixtureRoot)) return fixtureRoot;
+  const os = require('os'), path = require('path');
+  fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pmos-past-replay-'));
+  for (const f of FIXTURE) { const p = path.join(fixtureRoot, f.path); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, f.text); }
+  return fixtureRoot;
+}
+
+/** Raise the finding for one new initiative, through the guard. dir: the workspace's PMOS state folder (proposals.jsonl, the audit);
+ *  runtime: the per-user state folder (meeting notes, Settings). */
+async function file({ root, dir, runtime, ws, board, ini, title, intent, env = process.env, guard = guardOf(), now = Date.now(), corpus = null } = {}) {
+  if (!guard) return { filed: [], dropped: [], off: 'the AI guardrail (lib/ai-guard.js) is not installed' };
+  if (!dir || !ini) return { filed: [], dropped: [], off: 'no PMOS state folder' };
+  const stop = guard.off(JOB, { env, settingsDir: runtime || null });
+  if (stop) return { filed: [], dropped: [], off: stop };
+  // the guard's own files (the replay record, the audit) live in the per-user state folder, never in the repository: a write under the
+  // repository's pmos/state is a record change the pages refresh on and Sync commits. Only the finding itself goes to proposals.jsonl.
+  const gdir = runtime || dir;
+  if (!guard.ready(gdir, JOB, VERSION)) {
+    const rp = await guard.replay(JOB, VERSION, cases(), { root: replayRoot(), stateDir: gdir });
+    if (!rp.ok) return { filed: [], dropped: [], held: true };
+  }
+  let C = corpus;
+  if (!C) { const CLI = require('./past-cli.js'); C = CLI.corpusFor(root, runtime).C; }
+  const props = proposalFor(C, { ini, title, intent });
+  if (!props.length) return { filed: [], dropped: [], none: true };
+  const run = 'pa' + Number(now).toString(36);
+  return guard.file({ job: JOB, version: VERSION, run, root, stateDir: gdir, settingsDir: runtime || null, env }, props, async (accepted) => {
+    const F = PR.read(dir);
+    for (const p of accepted) {
+      const prop = { id: G.idOf(ini, 'past', p.id), ...grillProp(findingOf(p)) };
+      if (F.drops.has(PR.sigOf(prop)) || PR.keptIds(F).has(prop.id)) continue;
+      PR.append(dir, null, { kind: 'propose', ini, board: board || '', run, ...prop, at: new Date(now).toISOString() });
+    }
+  });
+}
+
+module.exports = { JOB, VERSION, MIN_COVER, LABEL, proposalFor, findingOf, grillProp, cases, file, FIXTURE };