create-pmos 0.504.0 → 0.506.0

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

package/workspace/lib/past.js

@@ -0,0 +1,353 @@
+'use strict';
+/* past.js — ask PMOS about the past (initiative ask-the-past). THE ONE RETRIEVAL LAYER over what PMOS already wrote down about earlier
+ * choices: "why did we drop X?", "when did we decide Y?", and "did we decide this before?" for a new idea. lib/decision-ledger.js
+ * (decision memory) and the initiative chat both read through it; nobody writes a second matcher.
+ *
+ * PURE. Takes the text of the records and returns passages, each with the line it rests on. No filesystem, no git, no network, no model.
+ * Same input → the same output. lib/past-cli.js does the reading (`pmos past ask|check|verify`).
+ *
+ * WHAT IS AN ENTRY. One thing that was decided, rejected or recorded, cut where the file itself cuts it:
+ *   decision     DECISIONS.md, one `### Dnn — title` section                       id Dnn
+ *   amendment    DECISIONS.md, one dated bullet of the amendment log              ids: the D-ids it names
+ *   adr          okf/products/pmos/adr/dNN-*.md, the whole file                   id Dnn
+ *   pm-decision  pm-decisions.md, one `## YYYY-MM-DD — title` entry
+ *   out-of-scope planning/out-of-scope/*.md, the whole file (a declined request)
+ *   initiative   planning/initiatives/*.md, the record: its title, status, why
+ *   discovery    discoveries.md, one `## ` entry (the run log; weighs less)
+ *   meeting      a decision caught in a meeting note, not marked wrong or deleted  (records, from the per-user state folder)
+ *   claim        a Jev claim the claims ledger holds                               (records)
+ *   ticket       a Jira ticket draft                                               (records)
+ * A record that cannot be read is not an entry; the CLI says which sources it read and which were not on this machine.
+ *
+ * HOW A PASSAGE IS FOUND. Words, not similarity of meaning: the question's content words (stop words and question words out, a light
+ * stem) are scored BM25 over each entry, its title counting three times. "Drop", "reject", "retire", "remove", "decline" and their kin are
+ * one family, so "why did we drop X" finds "X was retired". A D-id in the question ("D66") finds that decision first. Nothing is inferred.
+ *
+ * HONEST CONFIDENCE. An answer's confidence is the share of the question's distinct content (by weight) that the best entry holds:
+ *   high    ≥ 0.75 of it, and a second entry agrees (≥ 0.5)
+ *   medium  ≥ 0.6
+ *   low     ≥ 0.45  (shown, with "a weak match")
+ *   none    under 0.45, or no content word at all → "No record found". It never guesses.
+ *
+ * WHAT A HIT IS. { kind, id?, path, line, title, date, quote, ref: 'path:line', score, cover, status?, supersededBy? }. `quote` is the
+ * line's own text, verbatim (cut at 220 characters), so lib/ai-guard.js check() finds it at `ref`. A superseded or amended decision says
+ * so (from lib/decision-ledger.js when present, else from the ADR's own `superseded_by` / `amended_by` keys): an answer never quotes a
+ * dead decision as live.
+ *
+ *   build(files, records?)        → corpus   files: [{ path, text }] (repository Markdown); records: [{ kind, ref, title, text, date, quote? }]
+ *   search(corpus, question, o)   → { hits: [hit], none, confidence, terms }   o: { limit = 5, kinds }
+ *   repeats(corpus, idea, o)      → { hits, none, confidence }   only what was decided or declined (not the run log); the shape decision
+ *                                   memory reads: [{ kind, path, line, quote, date, id?, score }], ranked, none: true when nothing passes
+ *   verify(corpus, text)          → { refs: [{ ref, ok, why? }], ok }   every `path:line` an answer cites is one the corpus holds
+ *   isPastAsk(text)               → whether a message asks about the past ("why did we…", "did we ever…", "what did we decide…")
+ *   statusOf(corpus, id)          → { status, supersededBy, amendedBy } for a D-id
+ */
+
+const STOP = new Set(('a an and are as at be been being but by can could did do does doing done for from had has have having how i if in into '
+  + 'is it its me my no not of on or our ours should so than that the their them then there these they this those to too us was we were '
+  + 'what when where which who whom whose why will with would you your yours ever again any some all about over also just very really '
+  + 'pmos decide decided decision decisions choose chose chosen pick picked go went make made said say says tell told know think thought '
+  + 'don doesn didn isn aren wasn weren won haven hasn cannot must every need needs '
+  + 'one two use used using get got thing things way still now new old before after earlier first last').split(' '));
+/* One family: a "why did we drop X" question meets the words the records use for it. */
+const FAMILY = {
+  drop: ['drop', 'dropp', 'retir', 'remov', 'reject', 'declin', 'deprecat', 'cut', 'kill', 'delet', 'revert', 'abandon', 'repeal', 'lift', 'out-of-scope', 'scrap', 'stop', 'supersed'],
+};
+const FAMILY_OF = new Map();
+for (const [k, list] of Object.entries(FAMILY)) for (const w of list) FAMILY_OF.set(w, k);
+const KIND_WEIGHT = { decision: 1.15, adr: 1.0, amendment: 0.95, 'pm-decision': 1.0, 'out-of-scope': 1.1, initiative: 0.85, meeting: 1.0, claim: 0.6, ticket: 0.7, discovery: 0.55 };
+const DECIDED = new Set(['decision', 'adr', 'amendment', 'pm-decision', 'out-of-scope', 'initiative', 'meeting']);
+const QUOTE_MAX = 220;
+const TITLE_X = 3;
+const K1 = 1.2, B = 0.75;
+const CONF = { high: 0.75, medium: 0.6, low: 0.45 };
+
+/** A light stem: enough that "retired", "retiring" and "retire" meet, never so much that two words merge. */
+function stem(w) {
+  let s = w;
+  if (s.length > 5 && s.endsWith('ies')) s = s.slice(0, -3) + 'y';
+  else if (s.length > 5 && /(ing|ion)$/.test(s)) s = s.slice(0, -3);
+  else if (s.length > 4 && s.endsWith('ed')) s = s.slice(0, -2);
+  else if (s.length > 4 && s.endsWith('es') && !s.endsWith('ses')) s = s.slice(0, -2);
+  else if (s.length > 3 && s.endsWith('s') && !s.endsWith('ss')) s = s.slice(0, -1);
+  if (s.length > 4 && s.endsWith('e')) s = s.slice(0, -1);
+  return s;
+}
+const fold = (t) => String(t == null ? '' : t).toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '');
+function words(t) { return fold(t).replace(/\bout of scope\b/g, 'out-of-scope').match(/[a-z0-9][a-z0-9-]*[a-z0-9]|[a-z0-9]/g) || []; }
+/** A word as the index holds it: a D-id stays whole ("d66"), a family word becomes its family, else its stem. */
+function termOf(w) {
+  const d = /^d0*(\d{2,3})$/.exec(w); if (d) return 'd' + d[1];
+  if (w === 'out-of-scope') return 'drop';
+  const s = stem(w);
+  for (const [root, fam] of FAMILY_OF) if (s === root || s.startsWith(root) && s.length - root.length <= 3) return fam;
+  return s;
+}
+function termsOf(text, { keepStop = false } = {}) {
+  const out = [];
+  for (const w of words(text)) {
+    if (w.includes('-')) { for (const p of w.split('-')) if (p && (keepStop || !STOP.has(p)) && p.length > 1) out.push(termOf(p)); if (w === 'out-of-scope') out.push('drop'); continue; }
+    if (!keepStop && STOP.has(w)) continue;
+    if (w.length < 2 && !/\d/.test(w)) continue;
+    out.push(termOf(w));
+  }
+  return out;
+}
+const did = (s) => { const m = /\bD0*(\d{2,3})\b/i.exec(String(s || '')); return m ? 'D' + (m[1].length < 2 ? '0' + m[1] : m[1]) : null; };
+const dids = (s) => [...new Set((String(s || '').match(/\bD\d{2,3}\b/g) || []))];
+const isoOf = (s) => { const m = /\b(20\d{2}-\d{2}-\d{2})\b/.exec(String(s || '')); return m ? m[1] : null; };
+
+/* ── frontmatter (one-line `key: value`, as lib/related-docs.js reads it) ── */
+function front(text) {
+  const m = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(String(text || ''));
+  if (!m) return { fm: {}, bodyLine: 1 };
+  const fm = {};
+  for (const l of m[1].split('\n')) { const k = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(l); if (k) fm[k[1]] = k[2].replace(/^["']|["']$/g, '').trim(); }
+  return { fm, bodyLine: m[0].split('\n').length };
+}
+
+/* ── cutting files into entries ── */
+function sections(path, text, re, make) {
+  const lines = String(text || '').split('\n');
+  const out = [];
+  let cur = null, fence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s{0,3}(```|~~~)/.test(lines[i])) fence = !fence;
+    const m = !fence && re.exec(lines[i]);
+    if (m) { if (cur) out.push(cur); cur = make(m, i + 1); if (cur) cur.lines = [lines[i]]; continue; }
+    if (cur) { if (/^#{1,2}\s/.test(lines[i]) && !fence) { out.push(cur); cur = null; continue; } cur.lines.push(lines[i]); }
+  }
+  if (cur) out.push(cur);
+  return out.map((e) => ({ ...e, path, text: e.lines.join('\n') }));
+}
+function wholeFile(path, text, kind, extra = {}) {
+  const { fm, bodyLine } = front(text);
+  const lines = String(text || '').split('\n');
+  const h1 = lines.findIndex((l, i) => i >= bodyLine - 1 && /^#\s+/.test(l));
+  const title = fm.title || (h1 >= 0 ? lines[h1].replace(/^#\s+/, '') : path.split('/').pop().replace(/\.md$/, ''));
+  return { kind, path, line: h1 >= 0 ? h1 + 1 : bodyLine, title, date: isoOf(fm.date) || isoOf(fm.timestamp), text: lines.slice(bodyLine - 1).join('\n'), lines: lines.slice(bodyLine - 1), from: bodyLine, fm, ...extra };
+}
+function entriesOf(file) {
+  const p = file.path, t = file.text;
+  if (p === 'DECISIONS.md') {
+    const dec = sections(p, t, /^###\s+(D\d{2,3})\s+[—–-]\s+(.+?)\s*$/, (m, line) => ({ kind: 'decision', id: m[1], title: m[1] + ' — ' + m[2], line, from: line }));
+    const amend = [];
+    const lines = String(t).split('\n');
+    const logAt = lines.findIndex((l) => /^##\s+Amendment log/i.test(l));
+    if (logAt >= 0) for (let i = logAt + 1; i < lines.length; i++) {
+      const m = /^-\s+(20\d{2}-\d{2}-\d{2})\s+[—–-]\s+(.+)$/.exec(lines[i]);
+      if (!m) continue;
+      const ids = dids(m[2]);
+      amend.push({ kind: 'amendment', id: ids[0] || null, ids, path: p, line: i + 1, from: i + 1, date: m[1], title: 'Amendment ' + m[1] + (ids.length ? ' (' + ids.join(', ') + ')' : ''), text: m[2], lines: [lines[i]] });
+    }
+    return dec.concat(amend);
+  }
+  if (p === 'pm-decisions.md') return sections(p, t, /^##\s+(20\d{2}-\d{2}-\d{2})\s+[—–-]\s+(.+?)\s*$/, (m, line) => ({ kind: 'pm-decision', title: m[2], date: m[1], line, from: line, ids: dids(m[2]) }));
+  if (p === 'discoveries.md') return sections(p, t, /^##\s+(.+?)\s*$/, (m, line) => ({ kind: 'discovery', title: m[1], date: isoOf(m[1]), line, from: line }));
+  let m = /^okf\/products\/pmos\/adr\/(d\d{2,3})[-.]/i.exec(p);
+  if (m) { const e = wholeFile(p, t, 'adr'); e.id = 'D' + m[1].slice(1).replace(/^0(?=\d{2})/, ''); return [e]; }
+  if (/^planning\/out-of-scope\/(?!README\.md$|index\.md$)[^/]+\.md$/.test(p)) {
+    const e = wholeFile(p, t, 'out-of-scope');
+    const dl = /^-\s*date:\s*(.+)$/m.exec(e.text); if (dl && !e.date) e.date = isoOf(dl[1]);
+    return [e];
+  }
+  if (/^planning\/initiatives\/[^/]+\.md$/.test(p) && !/\/(index|README)\.md$/.test(p)) {
+    const e = wholeFile(p, t, 'initiative');
+    e.id = e.fm.id || null; e.status = e.fm.status || '';
+    // the record's own words about where it stands count as text (a "status:" line often holds the why of a drop)
+    if (e.status) e.text = e.title + '\n' + e.status + '\n' + e.text;
+    return [e];
+  }
+  return [];
+}
+
+/* ── the index ── */
+function indexEntry(e) {
+  const tTerms = termsOf(e.title || ''), bTerms = termsOf(e.text || '');
+  const tf = new Map();
+  for (const w of tTerms) tf.set(w, (tf.get(w) || 0) + TITLE_X);
+  for (const w of bTerms) tf.set(w, (tf.get(w) || 0) + 1);
+  for (const x of e.ids || (e.id ? [e.id] : [])) { const k = 'd' + String(x).slice(1).replace(/^0(?=\d)/, ''); tf.set(k, (tf.get(k) || 0) + TITLE_X); }
+  e.tf = tf; e.len = tTerms.length * TITLE_X + bTerms.length;
+  return e;
+}
+
+/** files: [{ path, text }]; records: [{ kind, ref, title, text, date, quote?, line? }] from the per-user state folder. */
+function build(files, records = []) {
+  const entries = [];
+  const adrMeta = new Map();
+  for (const f of files || []) {
+    if (!f || typeof f.path !== 'string') continue;
+    for (const e of entriesOf(f)) entries.push(e);
+  }
+  for (const e of entries) if (e.kind === 'adr' && e.id) adrMeta.set(e.id, { superseded_by: e.fm.superseded_by || e.fm.supersededBy || '', amended_by: e.fm.amended_by || '', status: e.fm.status || '' });
+  for (const r of records || []) {
+    if (!r || !r.ref || !(r.text || r.title)) continue;
+    const m = /^(.*):(\d+)$/.exec(String(r.ref));
+    entries.push({ kind: r.kind || 'meeting', path: m ? m[1] : String(r.ref), line: m ? +m[2] : (r.line || 1), from: m ? +m[2] : 1, title: String(r.title || r.text).slice(0, 160), date: isoOf(r.date) || null,
+      text: String(r.text || ''), lines: [String(r.quote || r.text || '')], fixedQuote: r.quote || null, ids: dids(r.text) });
+  }
+  // decision status: lib/decision-ledger.js (decision memory) when it is here, else the ADR's own keys
+  let ledger = null;
+  try {
+    const DL = require('./decision-ledger.js');
+    const dec = (files || []).find((f) => f && f.path === 'DECISIONS.md');
+    if (DL && typeof DL.parse === 'function' && dec) {
+      ledger = DL.parse(dec.text, { path: 'DECISIONS.md' });
+      if (typeof DL.addAdr === 'function') for (const f of files || []) if (f && /^okf\/products\/pmos\/adr\//.test(f.path)) DL.addAdr(ledger, f);
+    }
+  } catch { ledger = null; }
+  const status = new Map();
+  if (ledger && ledger.decisions instanceof Map) for (const d of ledger.decisions.values()) status.set(d.id, { status: d.status || 'active', supersededBy: d.supersededBy || [], amendedBy: d.amendedBy || [], ...(d.partial ? { partial: true } : {}) });
+  // the ADR's own keys fill in what the ledger does not say (or stand alone when there is no ledger)
+  for (const [id, a] of adrMeta) {
+    const sup = dids(a.superseded_by), am = dids(a.amended_by), had = status.get(id);
+    if (had && had.status !== 'active') continue;
+    const st = sup.length || /supersed|revert/i.test(a.status) ? 'superseded' : am.length ? 'amended' : 'active';
+    if (had && st === 'active') continue;
+    status.set(id, { status: st, supersededBy: sup, amendedBy: am });
+  }
+  for (const e of entries) indexEntry(e);
+  const df = new Map();
+  for (const e of entries) for (const w of e.tf.keys()) df.set(w, (df.get(w) || 0) + 1);
+  const avg = entries.reduce((s, e) => s + e.len, 0) / Math.max(1, entries.length);
+  const lineSet = new Map();
+  const recPaths = new Set(entries.map((e) => e.path));
+  for (const f of files || []) if (f && typeof f.path === 'string' && recPaths.has(f.path)) lineSet.set(f.path, String(f.text || '').split('\n').length);
+  for (const r of records || []) if (r && r.ref) { const m = /^(.*):(\d+)$/.exec(String(r.ref)); const p = m ? m[1] : String(r.ref); lineSet.set(p, Math.max(lineSet.get(p) || 0, m ? +m[2] + 2 : 3)); }
+  const kinds = {};
+  for (const e of entries) kinds[e.kind] = (kinds[e.kind] || 0) + 1;
+  return { entries, df, avg, n: entries.length, status, lineSet, kinds, ledger: !!ledger };
+}
+
+const idf = (C, w) => { const n = C.df.get(w) || 0; return Math.log(1 + (C.n - n + 0.5) / (n + 0.5)); };
+function bm25(C, e, q) {
+  let s = 0;
+  for (const w of q) {
+    const f = e.tf.get(w); if (!f) continue;
+    s += idf(C, w) * (f * (K1 + 1)) / (f + K1 * (1 - B + B * e.len / C.avg));
+  }
+  return s;
+}
+/** The line of the entry that holds most of the question (by weight): its own number and its own words. */
+function bestLine(C, e, q, at = 0) {
+  if (e.fixedQuote) return { line: e.line, quote: clip(e.fixedQuote) };
+  let best = { line: e.line, quote: clip((e.lines || [])[0] || e.title), w: -1 };
+  const ls = e.lines || [];
+  for (let i = at; i < Math.min(ls.length, at + WINDOW); i++) {
+    const raw = ls[i]; if (!raw || !raw.trim() || /^---\s*$/.test(raw)) continue;
+    const have = new Set(termsOf(raw));
+    let w = 0; for (const t of q) if (have.has(t)) w += idf(C, t);
+    if (w > best.w + 1e-9) best = { line: e.from + i, quote: clip(raw), w };
+  }
+  return best;
+}
+function clip(s) {
+  let t = String(s == null ? '' : s).trim().replace(/^[-*>#\s]+/, '').trim();
+  if (t.length > QUOTE_MAX) { t = t.slice(0, QUOTE_MAX); const sp = t.lastIndexOf(' '); if (sp > QUOTE_MAX * 0.6) t = t.slice(0, sp); }
+  return t;
+}
+
+const WINDOW = 4;
+/** The terms of the entry's title, joined with the best run of WINDOW lines (by how many of the question's terms it holds). */
+function local(e, q) {
+  const title = new Set(termsOf(e.title || ''));
+  for (const x of e.ids || (e.id ? [e.id] : [])) title.add('d' + String(x).slice(1).replace(/^0(?=\d)/, ''));
+  const ls = e.lines || [];
+  const per = ls.map((l) => new Set(termsOf(l)));
+  let best = { n: -1, terms: title, at: 0 };
+  for (let i = 0; i < Math.max(1, per.length); i++) {
+    const u = new Set(title);
+    for (let j = i; j < Math.min(per.length, i + WINDOW); j++) for (const t of per[j]) u.add(t);
+    let n = 0; for (const t of q) if (u.has(t)) n++;
+    if (n > best.n) best = { n, terms: u, at: i };
+  }
+  return best;
+}
+
+function statusOf(C, id) { return (C && C.status && C.status.get(id)) || null; }
+
+function rank(C, text, { limit = 5, kinds = null } = {}) {
+  const all = termsOf(text);
+  const q = [...new Set(all)];
+  if (!q.length) return { hits: [], none: true, confidence: 'none', terms: [] };
+  // the weight of what was asked: the family word counts less than the subject (it says how, not what)
+  const wq = (t) => idf(C, t) * (t === 'drop' ? 0.35 : 1);
+  const total = q.reduce((s, t) => s + wq(t), 0) || 1;
+  const asked = new Set(q.filter((t) => /^d\d{2,3}$/.test(t)));
+  const scored = [];
+  for (const e of C.entries) {
+    if (kinds && !kinds.has(e.kind)) continue;
+    let s = bm25(C, e, q);
+    if (!s) continue;
+    s *= (KIND_WEIGHT[e.kind] || 0.8);
+    // a D-id the question names finds that decision first
+    if (asked.size && [...(e.ids || (e.id ? [e.id] : []))].some((d) => asked.has('d' + String(d).slice(1).replace(/^0(?=\d)/, '')))) s *= 2.5;
+    scored.push({ e, s });
+  }
+  scored.sort((a, b) => b.s - a.s);
+  // what the question asks must sit TOGETHER: in the title, or within a few lines of each other (a long record that names each word
+  // somewhere is not an answer). The cover is that local share, and it is what the confidence reads.
+  const pool = scored.slice(0, 60);
+  for (const x of pool) {
+    const L = local(x.e, q);
+    let have = 0; for (const t of q) if (L.terms.has(t)) have += wq(t);
+    x.cover = have / total; x.verb = !q.includes('drop') || L.terms.has('drop'); x.at = L.at;
+    x.s *= (0.4 + x.cover) * (x.verb ? 1 : 0.85);
+  }
+  scored.length = 0;
+  scored.push(...pool);
+  scored.sort((a, b) => b.s - a.s || String(a.e.path).localeCompare(String(b.e.path)) || a.e.line - b.e.line);
+  // one hit per decision: the section, its ADR and its amendment lines are the same decision; keep the best of each, then the next one
+  const seen = new Set(), hits = [];
+  for (const x of scored) {
+    const key = x.e.kind === 'amendment' ? x.e.path + ':' + x.e.line : (x.e.id && (x.e.kind === 'decision' || x.e.kind === 'adr') ? 'D:' + x.e.id : x.e.path + ':' + x.e.line);
+    if (seen.has(key)) continue; seen.add(key);
+    const b = bestLine(C, x.e, q, x.at);
+    const st = x.e.id && (x.e.kind === 'decision' || x.e.kind === 'adr') ? statusOf(C, x.e.id) : null;
+    hits.push({ kind: x.e.kind, ...(x.e.id ? { id: x.e.id } : {}), path: x.e.path, line: b.line, ref: x.e.path + ':' + b.line, title: x.e.title, date: x.e.date || null, quote: b.quote,
+      score: Math.round(x.s * 1000) / 1000, cover: Math.round(x.cover * 100) / 100, ...(x.verb ? {} : { dropSaid: false }), ...(x.e.kind === 'initiative' && x.e.status ? { recordStatus: clip(x.e.status) } : {}),
+      ...(st && st.status !== 'active' ? { status: st.status, supersededBy: st.supersededBy, amendedBy: st.amendedBy, ...(st.partial ? { partial: true } : {}) } : {}) });
+    if (hits.length >= limit) break;
+  }
+  const top = hits[0];
+  let confidence = 'none';
+  if (top) {
+    if (top.dropSaid === false && top.cover >= CONF.low) confidence = 'low';
+    else if (top.cover >= CONF.high && hits.slice(1).some((h) => h.cover >= 0.5)) confidence = 'high';
+    else if (top.cover >= CONF.medium) confidence = 'medium';
+    else if (top.cover >= CONF.low) confidence = 'low';
+  }
+  const none = confidence === 'none';
+  return { hits: none ? [] : hits.filter((h) => h.cover >= CONF.low * 0.8), none, confidence, terms: q };
+}
+
+/** "why did we drop X?" → the passages that answer it, best first. */
+function search(C, question, o = {}) { return rank(C, question, { limit: o.limit || 5, kinds: o.kinds ? new Set(o.kinds) : null }); }
+
+/** A new idea → what was decided or declined about it before. The run log is not a decision; an idea is long, so it is cut to its
+ *  12 most telling words first (the words rarest across the records), and the bar is the same honest one. */
+function repeats(C, idea, o = {}) {
+  // a word no record holds still counts (rarest of all): an idea made of new words is not a repeat, however well one old word matches
+  const q = [...new Set(termsOf(idea))].sort((a, b) => idf(C, b) - idf(C, a) || a.localeCompare(b)).slice(0, o.words || 12);
+  const r = rank(C, q.join(' '), { limit: o.limit || 5, kinds: new Set(o.kinds || [...DECIDED]) });
+  return { hits: r.hits, none: r.none, confidence: r.confidence, terms: r.terms };
+}
+
+/** Every `path:line` an answer cites must be one the records hold, at a line that exists. */
+function verify(C, text) {
+  const refs = [];
+  const re = /(?:^|[\s(`[])((?:state:)?[A-Za-z0-9_./-]+\.(?:md|jsonl|json)):(\d+)\b/g;
+  let m;
+  while ((m = re.exec(String(text || '')))) {
+    const p = m[1].replace(/^\.\//, ''), line = +m[2];
+    const n = C.lineSet.get(p);
+    refs.push(n == null ? { ref: p + ':' + line, ok: false, why: 'not a record PMOS read' } : line < 1 || line > n ? { ref: p + ':' + line, ok: false, why: 'that line is not in the file' } : { ref: p + ':' + line, ok: true });
+  }
+  return { refs, ok: refs.length > 0 && refs.every((r) => r.ok) };
+}
+
+const ASK_RE = /(\bwhy (did|didn'?t|had) (we|i|you|pmos|the team)\b|\bwhy (was|were) .{1,80}\b(dropped|rejected|retired|removed|declined|chosen|picked|stopped|cut|killed|reverted|deprecated|decided|added|made|changed)\b|\bwhy (did|do) we (ever )?(decide|choose|pick|drop|stop|reject|retire|remove)\b|\bwhen did (we|i|you|pmos)\b|\bdid (we|i|you) (ever|already|decide|drop|try|reject|retire)\b|\bha(ve|s) (we|i|you|pmos) (ever|already) (decided|dropped|tried|rejected|retired|discussed|done)\b|\bwhat did (we|i|you) decide\b|\b(we|i) decided (this|that|it) before\b|\bis (this|that|it) a repeat\b|\bask (pmos )?(about )?the past\b)/i;
+const isPastAsk = (text) => { const s = String(text == null ? '' : text).trim(); return !s.startsWith('/') && ASK_RE.test(s); };
+
+module.exports = { build, search, repeats, verify, isPastAsk, statusOf, termsOf, stem, entriesOf, CONF, KIND_WEIGHT, QUOTE_MAX };

package/workspace/lib/pmos-verbs.js

@@ -56,6 +56,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): briefing-source-flow added it through the same table.
   source: Object.freeze({ module: 'source-cli.js', run: null, guide: 'data-freshness.md',
     help: 'pmos source save|status|show — the stored read of each tool the Briefing uses: Mail, Slack, Confluence and the rest (pmos source help)' }),
+  // Not a pm-os-absorb verb (run: null): ask-the-past added it through the same table.
+  past: Object.freeze({ module: 'past-cli.js', run: null, guide: 'ask-the-past.md',
+    help: 'pmos past ask|check|verify|sources … — why did we decide or drop something: the records that say so, each with its line (pmos past help)' }),
   // Not a pm-os-absorb verb (run: null): Home's Mentions A+ (premium-agreed-design) added it through the same table.
   mention: Object.freeze({ module: 'mention-cli.js', run: null, guide: 'home.md',
     help: 'pmos mention list|draft — Home\'s Mentions: what waits on you, and the proposed reply Claude changes from a chat (pmos mention help)' }),
@@ -78,6 +81,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): feedback batch 12 items 2, 3 and 4 (Claude proposes, the one ✦) added it through the same table.
   propose: Object.freeze({ module: 'propose-cli.js', run: null, guide: 'claude-proposes.md',
     help: 'pmos propose look|found|date|done|name|status … — what Claude\'s run files under an initiative\'s ✦ for the PM to keep or drop (pmos propose help)' }),
+  // Not a pm-os-absorb verb (run: null): the AI-ideas round (2026-11-03) added it through the same table: the kill switch and audit of lib/ai-guard.js.
+  ai: Object.freeze({ module: 'ai-cli.js', run: null, guide: 'claude-proposes.md',
+    help: 'pmos ai status|off|on|log … — the AI jobs: their kill switch, replay state and audit (pmos ai help)' }),
   // Not a pm-os-absorb verb (run: null): Grill and Forecast part G-A (Claude grills an initiative by itself) added it through the same table.
   grill: Object.freeze({ module: 'grill-cli.js', run: null, guide: 'claude-proposes.md',
     help: 'pmos grill find|voices|status|mode|cap|spend … — what Claude\'s grill run files under an initiative\'s ✦, and when it grills and what it may spend (pmos grill help)' }),
@@ -87,6 +93,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): batch 16 item 7 (Your impact) added it through the same table.
   impact: Object.freeze({ module: 'impact-cli.js', run: null, guide: 'your-impact.md',
     help: 'pmos impact add|end|status … — what Claude\'s impact run files for you to check, ✓ real or ✕ not real (pmos impact help)' }),
+  // Not a pm-os-absorb verb (run: null): initiative weekly-drift-check added it through the same table.
+  drift: Object.freeze({ module: 'drift-cli.js', run: null, guide: 'what-you-missed.md',
+    help: 'pmos drift show|replay|status — the weekly check for quiet drift: what it would show, its replay on your real records, and its last result (pmos drift help)' }),
   driver: Object.freeze({ module: 'driver-cli.js', run: null, guide: 'initiative-driver.md',
     help: 'pmos driver propose|status|keep|return|drop|pause|resume|mode … — the Initiative Driver: drafts for you to keep, send back or drop (pmos driver help)' }),
   // Not a pm-os-absorb verb (run: null): initiative horizon-scan added it through the same table; horizon-scan-portfolio added section, propose, setting and --boards.

package/workspace/lib/proposal-runs.js

@@ -71,6 +71,7 @@ function create(deps) {
   const active = new Map();   // run → { ws, ini, dir, session, why }
   const warn = deps.warn || (() => {});
   const lastScan = new Map(); // ws → ms of the last morning-check scan
+  const pastSeen = new Set(); // ws|initiative: the "You decided this before" look ran (ask-the-past)
 
   function ended(run, r, now = Date.now()) {
     const a = active.get(run); if (!a) return;
@@ -170,6 +171,24 @@ function create(deps) {
     return null;
   }
 
+  /* ask-the-past: a new initiative that repeats what was decided or declined before gets one "You decided this before" finding under its ✦
+   * (lib/past-repeat.js, through lib/ai-guard.js). Deterministic and local: no session, no model. Once per initiative while the server runs;
+   * a second pass files the same id, so a restart repeats nothing the PM sees. */
+  function pastOnce(w, dir, ini) {
+    const k = w.id + '|' + ini;
+    if (pastSeen.has(k) || !w.root) return;
+    pastSeen.add(k);
+    let row = {};
+    try { row = (deps.rowOf && deps.rowOf(w, ini)) || {}; } catch { row = {}; }
+    let board = '';
+    try { board = (deps.boardOf && deps.boardOf(w, ini)) || ''; } catch { board = ''; }
+    const PRP = require('./past-repeat.js');
+    let runtime = null;
+    try { runtime = require('./state-root.js').defaultRoot(); } catch { runtime = null; }
+    Promise.resolve().then(() => PRP.file({ root: w.root, dir, runtime, ws: w.id, board, ini, title: row.title || ini, intent: row.intent || '', env: deps.env || process.env }))
+      .catch((e) => warn('you decided this before', e));
+  }
+
   function stop(run) { const a = active.get(run); if (a && a.session && deps.stop) deps.stop(a.session); }
 
   function tick({ now = Date.now(), env } = {}) {
@@ -188,6 +207,7 @@ function create(deps) {
       try { created = deps.created(w) || []; } catch { created = []; }
       for (const c of created) {
         if (!c || !c.initiative || String(c.at || '') < epoch || F.looks.has(c.initiative)) continue;
+        pastOnce(w, dir, c.initiative);
         const r = start({ ws: w.id, ini: c.initiative, why: 'populate', press: false, now });
         if (r.ok) return { started: c.initiative, why: 'populate' };
         if (r.held) return { held: true };   // the governor said wait: the next tick tries again

package/workspace/lib/route-modules.js

@@ -114,6 +114,7 @@ const MODULES = Object.freeze([
   'routes-goal-status',   // batch 16 item 6: the goals' one status from readings (product page), notify choice, recipe, Read now, test read, CSV readings
   'routes-refresh',       // data-refresh-settings: Settings › Data refresh: what refreshes, when, the refresh log, Refresh now
   'routes-impact-views',  // batch 16 item 7 (Your impact, Phase 4): the chapter card's read, a stage that closed this week (boards.jsonl; read-only)
+  'routes-drift',         // weekly-drift-check: What would I have missed, Home's weekly ✦ and its ⋯ drop and Undo (runtime drift/drift.jsonl; page-press POST)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-drift.js

@@ -0,0 +1,62 @@
+'use strict';
+/* routes-drift.js — "What would I have missed" over HTTP (initiative weekly-drift-check; lib/drift.js). The ledger is the person's own, in the
+ * runtime folder (<runtime>/drift/drift.jsonl): outside every repository. Nothing here sends anything, and nothing here starts the check: it
+ * runs by itself each Monday (lib/drift-runs.js).
+ *
+ *   GET  /api/drift/check            → { ok, on, check: { week, label, looked, items, notRead } | null }   Home's ✦ for last week; null in a quiet
+ *                                      week, before the product's replay passed, or when everything shown was dropped
+ *   POST /api/drift/drop   { id }    → { ok }   ⋯ "Not right, drop it": it never comes back (PRD R5)
+ *   POST /api/drift/undo   { id }    → { ok }   the drop taken back
+ *   POST /api/drift/looked { week }  → { ok }   the card was shown for that week
+ *
+ * THE SWITCH. PMOS_DRIFT=off, or the shared guard's switch (lib/ai-guard.js off: PMOS_AI, the ai settings): every GET answers { ok, on: false }
+ * and every POST 409. WHO WRITES: a POST that carries an agent session header is refused (403); pm-guard requirePagePress checks the page. */
+const guard = require('./pm-guard.js');
+const D = require('./drift.js');
+const R = require('./drift-runs.js');
+
+const text = (v) => (typeof v === 'string' ? v : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const nowMs = (ctx) => { const t = Date.parse((ctx.env || process.env).PMOS_DRIFT_NOW || ''); return Number.isFinite(t) ? t : Date.now(); };
+function isOn(ctx) {
+  const env = ctx.env || process.env;
+  if (R.off(env)) return false;
+  try { const AG = require('./ai-guard.js'); return !AG.off(D.JOB, { env, settingsDir: ctx.runtimeDir }); } catch { return true; }
+}
+
+async function handle(req, res, url, ctx) {
+  const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+  const what = url.pathname.replace(/^\/api\/drift\/?/, '');
+  const dir = D.dirOf(ctx.runtimeDir);
+  if (what === 'check') {
+    if (req.method !== 'GET') return send(bad(405, 'GET only'));
+    if (!isOn(ctx)) return send({ status: 200, body: { ok: true, on: false } });
+    const F = dir ? D.read(dir) : D.fold([]);
+    return send({ status: 200, body: { ok: true, on: true, check: D.checkView(F, D.weekOf(nowMs(ctx))) } });
+  }
+  if (!['drop', 'undo', 'looked'].includes(what)) return send(bad(404, 'no such drift route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'Only you drop an item, from the page.'));
+  const rd = await ctx.readJson(req);
+  if (!rd.ok) return send(bad(400, 'the body is not JSON'));
+  const body = rd.body || {};
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return send(bad(g.status, g.error));
+  if (!isOn(ctx)) return send(bad(409, 'The weekly check is off.'));
+  if (!dir) return send(bad(409, 'There is no runtime folder.'));
+  const F = D.read(dir), at = new Date(nowMs(ctx)).toISOString();
+  if (what === 'looked') {
+    const week = text(body.week);
+    if (week !== D.prevWeek(D.weekOf(nowMs(ctx)))) return send(bad(400, 'week is the Monday of last week, YYYY-MM-DD: the week the check shows'));
+    if (!F.looked.has(week)) D.append(dir, { kind: 'looked', week }, at);
+    return send({ status: 200, body: { ok: true } });
+  }
+  const id = text(body.id);
+  const item = F.weeks.flatMap((w) => w.items).reverse().find((x) => x.id === id);
+  if (!item) return send(bad(404, 'There is no such item.'));
+  if (what === 'drop') { if (!F.drops.has(id)) D.append(dir, { kind: 'drop', id, level: item.level || 0 }, at); }
+  else { if (!F.drops.has(id)) return send(bad(409, 'This item is not dropped.')); D.append(dir, { kind: 'undo', id }, at); }
+  return send({ status: 200, body: { ok: true } });
+}
+
+module.exports = { prefixes: ['/api/drift'], handle };