create-pmos 0.505.0 → 0.507.0

package/workspace/lib/drift-facts.js

@@ -0,0 +1,151 @@
+'use strict';
+/* drift-facts.js — what the weekly drift check reads, per product (initiative weekly-drift-check). Read-only: it writes nothing anywhere.
+ *
+ *   factsOf(w, { stateDir, rows? }) → { ws, name, root, initiatives, tasks, jira, notRead }   the shape lib/drift.js detect() takes
+ *
+ * The same records `pmos task list` and `pmos initiative list` read, but kept LINE BY LINE with their place in the file, so each claim cites
+ * path:line and that line's own text (lib/ai-guard.js checks the quote), and so a replay can cut every ledger at a past week's end:
+ *   - task lines: <state>/boards.jsonl and the initiative ledger (lib/task-store.js), task / task-update / task-remove / task-restore and
+ *     task-milestone; a line copied by the D104 migration is the same text in both and counts once (the initiative ledger's copy is cited);
+ *   - the initiative rows (lib/initiative-rows.js: live, accepted, stopped, last activity, the record) minus the ones the PM deleted;
+ *   - closing: the boards ledger's ini-end lines (a dated "won't do"), the acceptances ledger and the row's stopped date;
+ *   - Jira: the snapshot each linked initiative keeps (lib/jira-status.js), its ticket table line cited.
+ * A source that cannot be read is named in notRead, never guessed. */
+const fs = require('fs');
+const path = require('path');
+
+const TASK_KINDS = new Set(['task', 'task-update', 'task-remove', 'task-restore', 'task-milestone']);
+const cut = (s) => { const t = String(s || '').replace(/\s+$/, ''); return t.length > 400 ? t.slice(0, 400) : t; };
+const rel = (root, f) => path.relative(root, f).split(path.sep).join('/');
+
+/** Every JSON line of a file, with its 1-based line number and text. [] when there is no file; null when it cannot be read. */
+function jsonLines(file) {
+  let text;
+  try { text = fs.readFileSync(file, 'utf8'); } catch (e) { return e && e.code === 'ENOENT' ? [] : null; }
+  const out = [];
+  text.split('\n').forEach((raw, i) => {
+    const t = raw.replace(/\r$/, '');
+    if (!t.trim()) return;
+    try { const o = JSON.parse(t); if (o && typeof o === 'object' && !Array.isArray(o)) out.push({ o, n: i + 1, text: t }); } catch { /* torn line */ }
+  });
+  return out;
+}
+const atOf = (o) => { const t = Date.parse(o && o.at); return Number.isFinite(t) ? t : null; };
+const lineSrc = (root, file, l) => ({ ref: rel(root, file) + ':' + l.n, quote: cut(l.text) });
+
+function tasksOf(root, boardFile, storeFile, notRead) {
+  const board = boardFile ? jsonLines(boardFile) : [];
+  const store = storeFile ? jsonLines(storeFile) : [];
+  if (board === null) notRead.push('the boards ledger');
+  if (store === null) notRead.push('the initiative task ledger');
+  const seen = new Set();
+  const all = [];
+  for (const [file, lines] of [[storeFile, store || []], [boardFile, board || []]]) {
+    for (const l of lines) { if (!TASK_KINDS.has(l.o.kind) || seen.has(l.text)) continue; seen.add(l.text); all.push({ file, l }); }
+  }
+  const tasks = new Map(), milestone = new Map();
+  for (const { file, l } of all) {
+    const o = l.o, at = atOf(o);
+    if (o.kind === 'task-milestone') { if (typeof o.task === 'string' && typeof o.milestone === 'boolean') milestone.set(o.task, { at, v: o.milestone }); continue; }
+    if (typeof o.task !== 'string' || at === null) continue;
+    if (o.kind === 'task') {
+      if (typeof o.initiative !== 'string' || tasks.has(o.task)) continue;
+      tasks.set(o.task, { id: o.task, initiative: o.initiative, title: String(o.title || o.task), lines: [] });
+    }
+    const t = tasks.get(o.task);
+    if (!t) continue;
+    if (o.kind === 'task-update' && typeof o.initiative === 'string' && o.initiative) t.initiative = o.initiative;
+    if (o.kind === 'task-update' && typeof o.title === 'string' && o.title.trim()) t.title = o.title.trim();
+    t.lines.push({ at, kind: o.kind, state: typeof o.state === 'string' ? (o.state === 'In review' ? 'In progress' : o.state) : undefined, due: typeof o.due === 'string' ? o.due : undefined, src: lineSrc(root, file, l) });
+  }
+  for (const t of tasks.values()) { const m = milestone.get(t.id); t.milestone = !!(m && m.v); }
+  return { tasks: [...tasks.values()], board: board || [] };
+}
+
+/** The line of a record file that names it (title, else id), for the initiative's own citation. */
+function recordSrc(root, record) {
+  if (!record) return null;
+  const f = path.join(root, record);
+  let lines;
+  try { lines = fs.readFileSync(f, 'utf8').split('\n'); } catch { return null; }
+  const i = Math.max(lines.findIndex((x) => /^title:/.test(x)), lines.findIndex((x) => /^id:/.test(x)));
+  return i >= 0 && lines[i].trim().length >= 12 ? { ref: rel(root, f) + ':' + (i + 1), quote: cut(lines[i]) } : null;
+}
+
+function acceptancesOf(root) {
+  try {
+    const dir = require('./plan-ledgers.js').runsDir(root);
+    const f = path.join(dir, 'acceptances.jsonl');
+    const out = new Map();
+    for (const l of jsonLines(f) || []) {
+      const o = l.o; if (!o.initiative_id || o.accepted !== true) continue;
+      const at = Date.parse(o.accepted_at || o.at);
+      if (Number.isFinite(at)) out.set(o.initiative_id, { at, src: lineSrc(root, f, l) });
+    }
+    return out;
+  } catch { return new Map(); }
+}
+
+function jiraOf(root, notRead) {
+  const out = {};
+  let JS;
+  try { JS = require('./jira-status.js'); } catch { return out; }
+  let linked = [];
+  try { linked = JS.linkedInitiatives(root); } catch { notRead.push('the Jira links'); return out; }
+  for (const q of linked) {
+    const id = q.initiative || q.id;
+    if (!id) continue;
+    let snap = null, text = '';
+    try { snap = JS.readSnapshot(root, id); text = fs.readFileSync(JS.snapshotPath(root, id), 'utf8'); } catch { snap = null; }
+    if (!snap) continue;
+    const lines = text.split('\n');
+    const file = rel(root, JS.snapshotPath(root, id));
+    const tickets = [];
+    for (const [key, r] of snap.tickets) {
+      if (r.stale) continue;   // a ticket the last search did not return: its reading is old, so it says nothing now
+      const i = lines.findIndex((x) => x.startsWith('|') && x.includes('| ' + key + ' |'));
+      tickets.push({ key, status: r.status || '', category: r.category, resolved: r.resolved || null, src: i >= 0 ? { ref: file + ':' + (i + 1), quote: cut(lines[i]) } : null });
+    }
+    if (tickets.length && tickets.every((k) => k.src)) out[id] = { fetchedAt: snap.fetchedAt, tickets };
+  }
+  return out;
+}
+
+/** w: { id, name, root }. rows: the initiative rows when the caller has them (lib/initiative-rows.js read), else they are derived now. */
+function factsOf(w, { stateDir, rows } = {}) {
+  const root = w.root;
+  const notRead = [];
+  let R = rows;
+  if (!R) {
+    const IR = require('./initiative-rows.js');
+    let r = IR.rowsFor(root);
+    if (r && r.pending) r = IR.deriveNow(root);
+    R = r && r.ok ? r.rows : null;
+  }
+  if (!R) notRead.push('the initiative records');
+  let storeFile = null;
+  try { const s = require('./task-store.js').storeFor(root); storeFile = s && s.file; } catch { storeFile = null; }
+  const boardFile = stateDir ? path.join(stateDir, 'boards.jsonl') : null;
+  const { tasks, board } = tasksOf(root, boardFile, storeFile, notRead);
+  const ends = new Map();
+  for (const l of board) {
+    const o = l.o; if (o.kind !== 'ini-end' || typeof o.id !== 'string') continue;
+    if (o.back === true) ends.delete(o.id); else { const at = atOf(o); if (at !== null) ends.set(o.id, { at, src: lineSrc(root, boardFile, l) }); }
+  }
+  const acc = acceptancesOf(root);
+  const initiatives = [];
+  for (const r of R || []) {
+    if (!r || r.ok === false || !r.id || (r.group && r.group !== 'work')) continue;
+    const end = ends.get(r.id), a = r.accepted ? acc.get(r.id) : null;
+    const stopAt = r.stopped && Date.parse(r.stopped.at);
+    const closed = end ? { at: end.at, why: 'set to Won\'t do', src: end.src } : a ? { at: a.at, why: 'accepted', src: a.src } : null;
+    initiatives.push({
+      id: r.id, title: r.title || r.id, live: !r.accepted && !r.stopped && !end && !r.legacy,
+      closedAt: closed ? closed.at : Number.isFinite(stopAt) ? stopAt : null, closedWhy: closed ? closed.why : 'stopped', closedSrc: closed ? closed.src : recordSrc(root, r.record),
+      lastActivity: Date.parse(r.last_activity) || null, src: recordSrc(root, r.record),
+    });
+  }
+  return { ws: w.id, name: w.name || w.id, root, initiatives, tasks, jira: jiraOf(root, notRead), notRead };
+}
+
+module.exports = { factsOf, jsonLines, tasksOf };

package/workspace/lib/drift-runs.js

@@ -0,0 +1,149 @@
+'use strict';
+/* drift-runs.js — the week of "What would I have missed" (initiative weekly-drift-check): the weekly run and the replay.
+ *
+ *   off(env)                                  → true when PMOS_DRIFT is off|0|false|no
+ *   verify(root, source)                      → true when source.quote is the text at source.ref (path:line, ±2 lines), inside root
+ *   simulate(facts, weeks, F0)                PURE → [{ week, asOf, items }]: what each week would have shown, oldest first, each week's
+ *                                             picks counted as shown for the next (R5), as the weekly run does
+ *   replay({ products, now, F }) → { ok, weeks, failed, ws }   the last REPLAY_WEEKS weeks on the real records (PRD R6), checked
+ *   create(deps) → { tick({ now }), runWeek({ now }) }
+ *
+ * ONE RUN A WEEK, for the person, across every open product. It is not a Claude session: the signals are structured (PRD R1), so the server
+ * reads the records and decides, with no model and no credits. It runs from the Monday of a week, inside the day-check window, for the week
+ * before; a week that has a result is not run again. Its only write is the week line of <runtime>/drift/drift.jsonl (lib/drift.js).
+ *
+ * THE GUARD (the shared guardrail layer, lib/ai-guard.js). Every item goes through AG.file before it is kept: the kill switch (PMOS_AI,
+ * the ai settings), the replay gate for (drift, VERSION), a check of every quote against its file, a cap of three and the audit log
+ * (<state>/ai-audit.jsonl). When the guard is not installed, nothing is shown: the week is written as held.
+ *
+ * deps: { runtime() → folder, products() → [{ w: { id, name, root }, stateDir, rows? }] | null (null: not ready, try again), open(now) → bool, env,
+ *         every? (ms: its own timer), mayRun?() → bool (the server that owns the schedules), warn(what, err) } */
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const D = require('./drift.js');
+const Facts = require('./drift-facts.js');
+
+const REPLAY_WEEKS = 4;
+const PROOF_WEEKS = 12;   // how far back the replay looks for one real item to prove the guard on, when the four weeks were quiet
+const flagOff = (v) => /^(off|0|false|no)$/i.test(String(v || '').trim());
+const off = (env) => flagOff((env || process.env).PMOS_DRIFT);
+function guardLib() { try { return require('./ai-guard.js'); } catch { return null; } }
+
+const norm = (s) => String(s || '').toLowerCase().replace(/\s+/g, ' ').trim();
+function verify(root, s) {
+  const m = /^(.+):(\d+)$/.exec(String((s && s.ref) || ''));
+  if (!m || !root || norm(s.quote).length < 12) return false;
+  const f = path.resolve(root, m[1]);
+  if (f !== path.resolve(root) && !f.startsWith(path.resolve(root) + path.sep)) return false;
+  let lines;
+  try { lines = fs.readFileSync(f, 'utf8').split('\n'); } catch { return false; }
+  const n = Number(m[2]);
+  return norm(lines.slice(Math.max(0, n - 3), n + 2).join(' ')).includes(norm(s.quote));
+}
+
+/** What each of `weeks` (Mondays, oldest first) would have shown. F0: the ledger before them (its drops and shown items count). */
+function simulate(facts, weeks, F0) {
+  const F = { weeks: [...((F0 && F0.weeks) || [])], drops: new Map((F0 && F0.drops) || []) };
+  const out = [];
+  for (const week of weeks) {
+    const asOf = D.weekEnd(week);
+    const items = D.pick(D.detect(facts, asOf), F);
+    out.push({ week, asOf, items });
+    F.weeks.push({ week, items });
+  }
+  return out;
+}
+
+const lastWeeks = (now, n) => { const out = []; let w = D.prevWeek(D.weekOf(now)); for (let i = 0; i < n; i++) { out.unshift(w); w = D.prevWeek(w); } return out; };
+
+/** The replay (PRD R6, C3, C5): every week at most three items, every claim with a source, every source's quote found in its file. */
+function replay({ products, now = Date.now(), F, facts: given }) {
+  const facts = given || products.map((p) => Facts.factsOf(p.w, { stateDir: p.stateDir, rows: p.rows }));
+  const weeks = simulate(facts, lastWeeks(now, REPLAY_WEEKS), { weeks: [], drops: (F && F.drops) || new Map() });
+  const rootOf = new Map(facts.map((f) => [f.ws, f.root]));
+  const failed = [];
+  for (const w of weeks) {
+    if (w.items.length > D.MAX) failed.push({ week: w.week, why: 'more than ' + D.MAX + ' items' });
+    for (const it of w.items) {
+      for (const c of it.claims) {
+        if (!c.sources.length) failed.push({ week: w.week, id: it.id, why: 'a claim with no source: ' + c.text });
+        for (const s of c.sources) if (!verify(rootOf.get(it.ws), s)) failed.push({ week: w.week, id: it.id, why: 'the quote is not at ' + s.ref });
+      }
+    }
+  }
+  return { ok: !failed.length, weeks, failed, ws: facts.map((f) => f.ws), notRead: [...new Set(facts.flatMap((f) => f.notRead.map((x) => f.name + ': ' + x)))], facts };
+}
+
+/** The guard's own replay of (drift, VERSION) for one product: each replayed week is a case, plus a quiet week that must say nothing. */
+async function guardReplay(AG, p, weeks, factsOne) {
+  const cases = weeks.map((w) => {
+    const mine = w.items.filter((it) => it.ws === p.w.id);
+    return { name: 'week of ' + w.week, run: async () => mine.map(proposalOf), expect: mine.length ? { filed: mine.length } : { none: true } };
+  });
+  cases.push({ name: 'a quiet week says nothing', run: async () => D.pick(D.detect([{ ...factsOne, tasks: [], jira: {} }], Date.now()), { weeks: [], drops: new Map() }).map(proposalOf), expect: { none: true } });
+  // the guard needs one case that files a cited proposal: when the four weeks were quiet, the latest real item of the last PROOF_WEEKS weeks
+  if (!cases.some((c) => c.expect.filed)) {
+    const back = lastWeeks(Date.now(), PROOF_WEEKS).reverse();
+    const found = back.map((w) => D.detect([factsOne], D.weekEnd(w))[0]).find(Boolean);
+    if (found) cases.push({ name: 'a real item from the week before ' + D.localDay(Date.now()), run: async () => [proposalOf(found)], expect: { filed: 1 } });
+  }
+  return AG.replay(D.JOB, D.VERSION, cases, { root: p.w.root, stateDir: p.stateDir });
+}
+
+/** The proposal the guard checks: the shared shape, with this check's own fields under data. */
+function proposalOf(it) {
+  return { id: it.id, title: it.title, say: it.say, confidence: it.confidence, claims: it.claims.map((c) => ({ text: c.text, sources: c.sources })),
+    data: { ...it.data, kind: it.kind, level: it.level, ws: it.ws, product: it.product, initiative: it.initiative } };
+}
+const keepOf = (it) => ({ id: it.id, kind: it.kind, level: it.level, ws: it.ws, product: it.product, initiative: it.initiative, title: it.title, say: it.say, confidence: it.confidence, claims: it.claims });
+
+function create(deps) {
+  const warn = deps.warn || (() => {});
+  let busy = false;
+  const dirNow = () => D.dirOf(deps.runtime && deps.runtime());
+
+  async function runWeek({ now = Date.now() } = {}) {
+    const dir = dirNow(); if (!dir) return { started: null, error: 'There is no runtime folder.' };
+    const F = D.read(dir), reviewed = D.prevWeek(D.weekOf(now));
+    if (F.weeks.some((w) => w.week === reviewed)) return { started: null, done: true };
+    const run = 'dr' + now.toString(36) + crypto.randomBytes(3).toString('hex');
+    const products = deps.products();
+    if (!products) return { started: null, waiting: true };   // a product's initiative rows are still being read: the next tick tries again
+    const facts = [];
+    for (const p of products) { try { facts.push(Facts.factsOf(p.w, { stateDir: p.stateDir, rows: p.rows })); } catch (e) { warn('drift facts ' + p.w.id, e); } }
+    const picked = D.pick(D.detect(facts, D.weekEnd(reviewed)), F);
+    const notRead = [...new Set(facts.flatMap((f) => f.notRead.map((x) => f.name + ': ' + x)))];
+    const AG = guardLib();
+    let kept = [], held = false;
+    if (!AG) held = picked.length > 0;
+    else {
+      for (const p of products) {
+        const mine = picked.filter((it) => it.ws === p.w.id);
+        if (!mine.length) continue;
+        const r = await AG.file({ job: D.JOB, version: D.VERSION, run, root: p.w.root, stateDir: p.stateDir, env: deps.env || process.env, max: D.MAX }, mine.map(proposalOf),
+          async (acc) => { const ids = new Set(acc.map((a) => a.id)); kept = kept.concat(mine.filter((it) => ids.has(it.id))); });
+        if (r && (r.held || r.off)) held = true;
+      }
+    }
+    D.append(dir, { kind: 'week', week: reviewed, run, items: kept.map(keepOf), notRead, ...(held ? { held: true } : {}) }, new Date(now).toISOString());
+    return { started: run, items: kept.length, held };
+  }
+
+  async function tick({ now = Date.now() } = {}) {
+    if (off(deps.env) || busy) return { off: off(deps.env), running: busy };
+    let open = true;
+    try { open = deps.open ? !!deps.open(now) : true; } catch { open = true; }
+    if (!open) return { started: null, closed: true };
+    busy = true;
+    try { return await runWeek({ now }); } catch (e) { warn('drift week', e); return { started: null, error: String((e && e.message) || e) }; } finally { busy = false; }
+  }
+  // its own timer when the server asks for one (deps.every): unref'd, so it never holds the process open
+  if (deps.every > 0) {
+    const t = setInterval(() => { try { if (deps.mayRun && !deps.mayRun()) return; } catch { /* no lock: run */ } tick({}).catch((e) => warn('drift tick', e)); }, deps.every);
+    if (t.unref) t.unref();
+  }
+  return { tick, runWeek };
+}
+
+module.exports = { off, verify, simulate, replay, guardReplay, proposalOf, keepOf, lastWeeks, create, REPLAY_WEEKS };

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