create-pmos 0.505.0 → 0.507.0

package/workspace/guide/what-you-missed.md

@@ -0,0 +1,42 @@
+---
+type: Guide
+title: "What you might have missed"
+description: "The weekly check for quiet drift: what it looks for, when it says nothing, how to drop an item, the replay that comes first, how to switch it off, and the pmos drift commands."
+timestamp: 2026-11-03
+---
+
+# What you might have missed
+
+Once a week PMOS looks across your products for work that looks fine on the surface but has quietly drifted. It shows at most three items, as one ✦ in Home's chat. In a quiet week it says nothing.
+
+## What it looks for
+
+It reads only records. It does not read chats or meetings, and it uses no model, so it costs no credits.
+
+- **Gone quiet.** An initiative that is still live and has open tasks, but no task and no record has changed for 14 days.
+- **Slipped again.** An open task whose due date moved later at least twice, with the last move in the week it checks. A milestone comes first.
+- **Jira and PMOS disagree.** The initiative is closed but one of its Jira tickets is still open. Or every Jira ticket was resolved at least 7 days ago and the initiative is still open.
+
+Each item shows the records it came from: the task, the dates and when they moved, the Jira key and its status. The facts are read from records. Whether they matter is for you to judge.
+
+## When it runs
+
+It runs by itself each Monday, inside your day-check hours, for the week before. You never start it. The card stays in Home's chat for the week.
+
+## Drop an item
+
+Open ⋯ on an item and choose **Not right, drop it**. A dropped item never comes back. Undo brings it back. An item you have already seen comes back only when it gets worse: another slip, two more quiet weeks, or more open tickets.
+
+## The replay comes first
+
+Nothing shows for a product until its replay has passed. In the product's repository, run `pmos drift replay`. It runs the check on each of the last four weeks of real records, checks that no week has more than three items, and checks that every quote is at the line it cites. The shared guard then runs its own replay.
+
+## Switch it off
+
+Set `PMOS_DRIFT=off`, or turn Claude's checks off with `pmos ai off drift`. Every result, drop, undo and replay is a line in your own ledger, `drift/drift.jsonl` in the runtime folder. Only you see it. Nothing leaves PMOS, and nothing changes a task, an initiative or a Jira ticket.
+
+## Commands
+
+- `pmos drift show [--weeks <n>]`: what each of the last weeks would have shown for this repository. It writes nothing.
+- `pmos drift replay`: the replay of the last four weeks of this repository.
+- `pmos drift status`: the last weekly result and the replays on record.

package/workspace/lib/ai-cli.js

@@ -0,0 +1,63 @@
+'use strict';
+/* ai-cli.js — `pmos ai`: the kill switch and the audit of the AI jobs that file through lib/ai-guard.js.
+ *
+ *   pmos ai status [--json]      the switch, each job's replay state and its last run
+ *   pmos ai off [<job>]          turn every AI job off, or one job
+ *   pmos ai on [<job>]           turn every AI job on again, or one job
+ *   pmos ai log [<job>] [--n N]  the last audit lines: filed, dropped (with why), held, off, replay
+ *
+ * A background run never changes the switch: inside one (PMOS_AI_RUN set) off and on refuse. PMOS_AI=off in the environment wins
+ * over Settings. Exit codes: 0 done, 1 refused, 2 usage. Nothing is sent. */
+const AG = require('./ai-guard.js');
+
+const COMMANDS = { ai: ['status', 'off', 'on', 'log'] };
+const USAGE = [
+  'usage: pmos ai status|off|on|log — the AI jobs: their kill switch and what each one filed or dropped',
+  '  pmos ai status [--json]      is each job on, has its replay passed, what did its last run file',
+  '  pmos ai off [<job>]          every AI job off, or one job',
+  '  pmos ai on [<job>]           every AI job on again, or one job',
+  '  pmos ai log [<job>] [--n N]  the last audit lines',
+  'A job files only proposals. Each one cites its sources and waits under ✦ for your ✓. Nothing is sent.',
+];
+const flag = (args, k) => { const i = args.indexOf('--' + k); return i >= 0 ? (args[i + 1] === undefined || args[i + 1].startsWith('--') ? true : args[i + 1]) : undefined; };
+const stateOf = (env) => require('./state-root.js').defaultRoot({ env });
+
+function run(argv, { say = (s) => console.log(s), env = process.env, stateDir = null } = {}) {
+  const args = argv[0] === 'ai' ? argv.slice(1) : argv.slice();
+  const verb = args[0];
+  if (!verb || ['help', '--help', '-h'].includes(verb)) { for (const l of USAGE) say(l); return verb ? 0 : 1; }
+  if (!COMMANDS.ai.includes(verb)) { say(`unknown ai command "${verb}" — one of ${COMMANDS.ai.join(', ')}`); return 2; }
+  const dir = stateDir || stateOf(env);
+  const job = args[1] && !args[1].startsWith('--') ? args[1] : null;
+
+  if (verb === 'status') {
+    const s = AG.status({ stateDir: dir, settingsDir: dir, env });
+    if (flag(args, 'json')) { say(JSON.stringify(s)); return 0; }
+    say(`AI jobs: ${s.on ? 'on' : 'off'}${s.settingsOff.length ? ' · off one by one: ' + s.settingsOff.join(', ') : ''}`);
+    if (!s.jobs.length) say('  no job has run yet');
+    for (const j of s.jobs) {
+      const rep = j.replay ? `replay v${j.replay.version} ${j.replay.ok ? 'passed' : 'FAILED'}` : 'no replay yet: everything is held';
+      const last = j.last ? ` · last run ${String(j.last.at).slice(0, 16).replace('T', ' ')}: ${j.last.filed} filed, ${j.last.dropped} dropped` : '';
+      say(`  ${j.job}: ${j.off ? 'off' : 'on'} · ${rep}${last}`);
+    }
+    return 0;
+  }
+  if (verb === 'log') {
+    const n = Math.min(500, Math.max(1, Number(flag(args, 'n')) || 20));
+    const lines = AG.readAudit(dir, { job, limit: n });
+    if (!lines.length) { say('no audit lines yet'); return 0; }
+    for (const l of lines) {
+      const { at, job: j, event, ...rest } = l;
+      say(`${String(at).slice(0, 19).replace('T', ' ')} ${j || '-'} ${event} ${JSON.stringify(rest)}`);
+    }
+    return 0;
+  }
+  if (env.PMOS_AI_RUN) { say('✗ an AI run never changes its own switch'); return 1; }
+  const r = AG.setOff(dir, job, verb === 'off');
+  if (!r || !r.ok) { say('✗ ' + ((r && r.error) || 'could not save')); return 1; }
+  const envWins = verb === 'on' && AG.off(job, { env, settingsDir: null });
+  say(`${job || 'every AI job'}: ${verb}${envWins ? ' in Settings, but ' + envWins + ' wins' : ''}`);
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/ai-guard.js

@@ -0,0 +1,314 @@
+'use strict';
+/* ai-guard.js — THE ONE DOOR every AI job's output passes before the PM sees it (the AI-ideas round, 2026-11-03: decision memory,
+ * the weekly what-I'd-miss check, ask about the past, and the features after them). A job runs in the PM's usual background Claude
+ * session (lib/headless.js, as grill does). It may file only proposals, and each one goes through file() below:
+ *
+ *   kill switch → replay gate → check each proposal → audit → deliver(accepted)
+ *
+ * THE PROPOSAL (the only thing a job may file):
+ *   { id, title, say, confidence: 'high'|'medium'|'low'|'none',
+ *     claims: [{ text, sources: [{ label, ref, quote }] }], data? }
+ *   ref is `path:line` relative to the repository root, or `state:<file>:line` for a ledger in the job's state folder. Other refs
+ *   (`jira:KEY`, a URL) are kept as context but are unverified. confidence 'none' is "no record": claims may be empty, and that is a
+ *   valid, complete answer.
+ *
+ * THE RULES (check):
+ *   propose-only    a key named write, apply, ops, patch, send, command or exec anywhere in the proposal rejects it
+ *   every claim     at least 1 verified source: the quote (12+ characters) is found within ±2 lines of ref, case and spacing ignored
+ *   honest          'high' needs 2 or more distinct verified refs; 'none' must have no claims
+ *   bounded         at most `max` proposals per run (default 3); the rest are dropped, in the order given
+ *
+ * THE REPLAY GATE: a job's (job, version) shows nothing until replay() has passed for it. A replay runs the job's own cases (its
+ * deterministic part or a recorded model output, never the model) and the guard's negative cases made from the job's first filed
+ * proposal: a fabricated quote, a missing source, a ref outside the repository and a write key. Each of those must be dropped.
+ *
+ * THE KILL SWITCH: PMOS_AI=off (every job), PMOS_AI_<JOB>=off (one job, dashes as underscores), Settings 'ai.on' false, or the job
+ * in Settings 'ai.off'. `pmos ai off [job]` and `pmos ai on [job]` set the Settings ones.
+ *
+ * THE AUDIT: <stateDir>/ai-audit.jsonl, one line per event { at, job, version?, run?, event, ... }. Events: start, filed, dropped,
+ * held, off, replay, end. No line holds a file body or a key: only ids, refs, reasons and counts.
+ *
+ *   off(job, { env, settingsDir }) → null | reason
+ *   check(p, { root, stateDir }) → { ok, p, errors }
+ *   replay(job, version, cases, { root, stateDir }) → Promise<{ ok, failed: [{ name, why }] }>
+ *   ready(stateDir, job, version) → bool
+ *   file({ job, version, run, root, stateDir, settingsDir?, env?, max? }, proposals, deliver) → Promise<{ filed, dropped, held?, off? }>
+ *   audit(stateDir, line) · readAudit(stateDir, { job?, limit? }) → [line] · status({ stateDir, settingsDir, env }) → summary
+ *   setOff(settingsDir, job | null, off) → { ok } | { ok: false, error }
+ */
+const fs = require('fs');
+const path = require('path');
+
+const AUDIT = 'ai-audit.jsonl';
+const REPLAYS = 'ai-replays.json';
+const MAX = 3;
+const QUOTE_MIN = 12;
+const NEAR = 2;
+const CONF = ['high', 'medium', 'low', 'none'];
+const WRITE_KEYS = new Set(['write', 'apply', 'ops', 'patch', 'send', 'command', 'exec']);
+const JOB_ID = /^[a-z][a-z0-9-]{1,40}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/;
+
+const flagOff = (v) => /^(off|0|false|no)$/i.test(String(v == null ? '' : v).trim());
+const one = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
+const norm = (s) => String(s == null ? '' : s).toLowerCase().replace(/\s+/g, ' ').trim();
+const envName = (job) => 'PMOS_AI_' + String(job).toUpperCase().replace(/-/g, '_');
+
+/* ── kill switch ─────────────────────────────────────────────────────────────────────────── */
+
+function settings(settingsDir) {
+  if (!settingsDir) return { on: true, off: [] };
+  try {
+    const S = require('./settings-store.js');
+    const offList = S.get(settingsDir, 'ai.off');
+    return { on: S.get(settingsDir, 'ai.on') !== false, off: Array.isArray(offList) ? offList : [] };
+  } catch { return { on: true, off: [] }; }
+}
+
+/** null when the job may run; else the reason it is off. */
+function off(job, { env = process.env, settingsDir = null } = {}) {
+  if (flagOff((env || {}).PMOS_AI)) return 'every AI job is off (PMOS_AI)';
+  if (job && flagOff((env || {})[envName(job)])) return `${job} is off (${envName(job)})`;
+  const s = settings(settingsDir);
+  if (!s.on) return 'every AI job is off (Settings)';
+  if (job && s.off.includes(job)) return `${job} is off (Settings)`;
+  return null;
+}
+
+function setOff(settingsDir, job, isOff) {
+  const S = require('./settings-store.js');
+  if (!job) return S.set(settingsDir, 'ai.on', !isOff);
+  if (!JOB_ID.test(String(job))) return { ok: false, error: `${JSON.stringify(String(job))} is not a job id (lowercase letters, digits and dashes)` };
+  const cur = settings(settingsDir).off.filter((x) => x !== job);
+  return S.set(settingsDir, 'ai.off', isOff ? [...cur, job].sort() : cur);
+}
+
+/* ── the citation check ──────────────────────────────────────────────────────────────────── */
+
+function linesOf(abs, cache) {
+  if (cache.has(abs)) return cache.get(abs);
+  let L = null;
+  try { const st = fs.statSync(abs); if (st.isFile() && st.size <= 20e6) L = fs.readFileSync(abs, 'utf8').split('\n'); } catch { /* unreadable: unverified */ }
+  cache.set(abs, L);
+  return L;
+}
+
+/** Where a ref points: { abs, line } for a verifiable ref, { context: true } for jira:/http refs, { error } otherwise. */
+function resolveRef(ref, { root, stateDir }) {
+  const r = String(ref || '').trim();
+  if (!r) return { error: 'a source has no ref' };
+  if (/^(https?:\/\/|jira:|slack:|mail:|calendar:)/i.test(r)) return { context: true };
+  const m = /^(state:)?(.+):(\d+)$/.exec(r);
+  if (!m) return { error: `ref ${JSON.stringify(one(r, 80))} is not path:line` };
+  const base = m[1] ? stateDir : root;
+  if (!base) return { error: `ref ${JSON.stringify(one(r, 80))} names a folder this run has none of` };
+  const baseAbs = path.resolve(base);
+  const abs = path.resolve(baseAbs, m[2]);
+  if (abs !== baseAbs && !abs.startsWith(baseAbs + path.sep)) return { error: `ref ${JSON.stringify(one(r, 80))} is outside the ${m[1] ? 'state folder' : 'repository'}` };
+  return { abs, line: Number(m[3]) };
+}
+
+function quoteAt(L, line, quote) {
+  const q = norm(quote);
+  if (!L || line < 1 || line > L.length) return false;
+  const from = Math.max(0, line - 1 - NEAR), to = Math.min(L.length, line + NEAR);
+  return norm(L.slice(from, to).join(' ')).includes(q);
+}
+
+function writeKey(v, depth = 0) {
+  if (!v || typeof v !== 'object' || depth > 8) return null;
+  for (const [k, x] of Object.entries(v)) {
+    if (WRITE_KEYS.has(String(k).toLowerCase())) return k;
+    const deep = writeKey(x, depth + 1);
+    if (deep) return deep;
+  }
+  return null;
+}
+
+/** Check one proposal. Pure apart from reading the cited files. → { ok, p (normalized), errors } */
+function check(p, { root, stateDir, cache = new Map() } = {}) {
+  const errors = [];
+  if (!p || typeof p !== 'object' || Array.isArray(p)) return { ok: false, p: null, errors: ['a proposal must be an object'] };
+  const wk = writeKey(p);
+  if (wk) errors.push(`propose-only: the key "${wk}" names a write`);
+  const id = String(p.id || '').trim();
+  if (!ID.test(id)) errors.push('id is missing or has characters other than letters, digits and . _ : -');
+  const title = one(p.title, 200), say = one(p.say, 1200);
+  if (!title) errors.push('title is empty');
+  if (!say) errors.push('say is empty');
+  const confidence = String(p.confidence || '').trim();
+  if (!CONF.includes(confidence)) errors.push(`confidence must be one of ${CONF.join(', ')}`);
+  const claimsIn = p.claims == null ? [] : p.claims;
+  if (!Array.isArray(claimsIn)) errors.push('claims must be a list');
+  const claims = [];
+  const verifiedRefs = new Set();
+  (Array.isArray(claimsIn) ? claimsIn : []).slice(0, 20).forEach((c, i) => {
+    const text = one(c && c.text, 600);
+    if (!text) { errors.push(`claim ${i + 1} has no text`); return; }
+    const srcIn = Array.isArray(c.sources) ? c.sources.slice(0, 8) : [];
+    if (!srcIn.length) { errors.push(`claim ${i + 1} cites no source`); return; }
+    const sources = [];
+    let verified = 0;
+    for (const s of srcIn) {
+      const ref = one(s && s.ref, 300), quote = String((s && s.quote) || '').slice(0, 2000), label = one(s && s.label, 120) || ref;
+      const at = resolveRef(ref, { root, stateDir });
+      if (at.error) { errors.push(`claim ${i + 1}: ${at.error}`); continue; }
+      if (at.context) { sources.push({ label, ref, quote: one(quote, 400), verified: false }); continue; }
+      if (norm(quote).length < QUOTE_MIN) { errors.push(`claim ${i + 1}: the quote for ${ref} is shorter than ${QUOTE_MIN} characters`); continue; }
+      if (!quoteAt(linesOf(at.abs, cache), at.line, quote)) { errors.push(`claim ${i + 1}: the quote is not at ${ref}`); continue; }
+      sources.push({ label, ref, quote: one(quote, 400), verified: true });
+      verifiedRefs.add(ref);
+      verified++;
+    }
+    if (!verified) { errors.push(`claim ${i + 1} has no verified source`); return; }
+    claims.push({ text, sources });
+  });
+  if (confidence === 'none' && Array.isArray(claimsIn) && claimsIn.length) errors.push('confidence none ("no record") must have no claims');
+  if (confidence && confidence !== 'none' && Array.isArray(claimsIn) && !claimsIn.length) errors.push('a proposal with claims must cite them; use confidence none for "no record"');
+  if (confidence === 'high' && verifiedRefs.size < 2) errors.push('confidence high needs 2 or more distinct verified sources');
+  const data = p.data && typeof p.data === 'object' && !Array.isArray(p.data) ? p.data : undefined;
+  if (errors.length) return { ok: false, p: null, errors };
+  return { ok: true, p: { id, title, say, confidence, claims, ...(data ? { data } : {}) }, errors: [] };
+}
+
+/* ── audit ───────────────────────────────────────────────────────────────────────────────── */
+
+function audit(stateDir, line) {
+  if (!stateDir) return;
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.appendFileSync(path.join(stateDir, AUDIT), JSON.stringify({ at: new Date().toISOString(), ...line }) + '\n', { mode: 0o600 });
+  } catch { /* the audit never stops a run; a failed append is lost, never thrown */ }
+}
+
+function readAudit(stateDir, { job = null, limit = 200 } = {}) {
+  let text = '';
+  try { text = fs.readFileSync(path.join(stateDir, AUDIT), 'utf8'); } catch { return []; }
+  const out = [];
+  for (const s of text.split('\n')) {
+    if (!s.trim()) continue;
+    try { const o = JSON.parse(s); if (!job || o.job === job) out.push(o); } catch { /* a torn line */ }
+  }
+  return out.slice(-limit);
+}
+
+/* ── the replay gate ─────────────────────────────────────────────────────────────────────── */
+
+function readReplays(stateDir) {
+  try { const o = JSON.parse(fs.readFileSync(path.join(stateDir, REPLAYS), 'utf8')); return o && typeof o === 'object' ? o : {}; } catch { return {}; }
+}
+function writeReplays(stateDir, o) {
+  fs.mkdirSync(stateDir, { recursive: true });
+  const f = path.join(stateDir, REPLAYS), tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(o, null, 2) + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, f);
+}
+const keyOf = (job, version) => `${job}@${version}`;
+
+function ready(stateDir, job, version) {
+  const r = readReplays(stateDir)[keyOf(job, version)];
+  return !!(r && r.ok === true);
+}
+
+/* What the guard alone would file from a list: the same checks as file(), without the gate, audit or deliver. */
+function sift(list, opts) {
+  const cache = new Map(), filed = [], dropped = [];
+  const arr = Array.isArray(list) ? list : [];
+  for (const [i, p] of arr.entries()) {
+    const id = p && p.id ? String(p.id) : `#${i + 1}`;
+    if (filed.length >= (opts.max || MAX)) { dropped.push({ id, why: `over the ${opts.max || MAX} proposals a run may file` }); continue; }
+    const c = check(p, { ...opts, cache });
+    if (c.ok) filed.push(c.p); else dropped.push({ id, why: c.errors.join('; ') });
+  }
+  return { filed, dropped };
+}
+
+/* The guard's own negative cases, made from a proposal that passed. Each must be dropped. */
+function negatives(p) {
+  const clone = () => JSON.parse(JSON.stringify(p));
+  const first = (q) => q.claims[0].sources.find((s) => s.verified !== false) || q.claims[0].sources[0];
+  const out = [];
+  if (!p.claims || !p.claims.length) return out;
+  { const q = clone(); first(q).quote = 'this sentence was never written anywhere in the sources ' + Date.now(); out.push({ name: 'a fabricated quote is dropped', p: q }); }
+  { const q = clone(); q.claims[0].sources = []; out.push({ name: 'a claim with no source is dropped', p: q }); }
+  { const q = clone(); first(q).ref = '../../etc/passwd:1'; out.push({ name: 'a ref outside the repository is dropped', p: q }); }
+  { const q = clone(); q.data = { ...(q.data || {}), apply: { op: 'set' } }; out.push({ name: 'a write key is dropped', p: q }); }
+  return out;
+}
+
+function expectFails(name, expect, got) {
+  const e = expect || {};
+  if (e.none && got.filed.length) return `expected nothing filed, got ${got.filed.length}`;
+  if (Number.isInteger(e.filed) && got.filed.length !== e.filed) return `expected ${e.filed} filed, got ${got.filed.length}${got.dropped.length ? ' (dropped: ' + one(got.dropped.map((d) => d.why).join(' | '), 300) + ')' : ''}`;
+  if (Number.isInteger(e.min) && got.filed.length < e.min) return `expected at least ${e.min} filed, got ${got.filed.length}`;
+  if (Array.isArray(e.ids)) for (const id of e.ids) if (!got.filed.some((p) => p.id === id)) return `expected ${id} to be filed`;
+  if (Array.isArray(e.cites)) for (const c of e.cites) if (!got.filed.some((p) => p.claims.some((cl) => cl.sources.some((s) => s.verified && s.ref.split(':').slice(0, -1).join(':').replace(/^state:/, '') === c)))) return `expected a verified citation of ${c}`;
+  if (Array.isArray(e.dropped)) for (const sub of e.dropped) if (!got.dropped.some((d) => d.why.includes(sub))) return `expected a drop that says "${sub}"`;
+  return null;
+}
+
+/** Run a job's replay cases plus the guard's negatives; record the result for (job, version). */
+async function replay(job, version, cases, { root, stateDir, max = MAX } = {}) {
+  const failed = [];
+  let seed = null;
+  if (!JOB_ID.test(String(job || ''))) return { ok: false, failed: [{ name: 'job', why: 'the job id is not valid' }] };
+  if (!Array.isArray(cases) || !cases.length) failed.push({ name: '(cases)', why: 'a job needs at least 1 replay case' });
+  for (const c of Array.isArray(cases) ? cases : []) {
+    const name = one(c && c.name, 120) || '(unnamed)';
+    let list;
+    try { list = await c.run(); } catch (e) { failed.push({ name, why: 'the case threw: ' + one(e && e.message, 200) }); continue; }
+    const got = sift(list, { root, stateDir, max });
+    const why = expectFails(name, c.expect, got);
+    if (why) failed.push({ name, why });
+    if (!seed) seed = got.filed.find((p) => p.claims.length) || null;
+  }
+  if (seed) for (const n of negatives(seed)) {
+    const got = sift([n.p], { root, stateDir, max });
+    if (got.filed.length) failed.push({ name: n.name, why: 'the guard filed it' });
+  } else if (!failed.length) failed.push({ name: '(negatives)', why: 'no case filed a cited proposal, so the guard could not test its own drops; add a case that files one' });
+  const ok = !failed.length;
+  if (stateDir) {
+    const all = readReplays(stateDir);
+    all[keyOf(job, version)] = { ok, at: new Date().toISOString(), cases: (cases || []).length, failed: failed.slice(0, 20) };
+    try { writeReplays(stateDir, all); } catch { /* an unwritten pass keeps the gate shut: the safe side */ }
+    audit(stateDir, { job, version: String(version), event: 'replay', ok, failed: failed.map((f) => f.name + ': ' + one(f.why, 160)).slice(0, 10) });
+  }
+  return { ok, failed };
+}
+
+/* ── the door ────────────────────────────────────────────────────────────────────────────── */
+
+async function file(o, proposals, deliver) {
+  const { job, version, run = null, root, stateDir, settingsDir = stateDir, env = process.env, max = MAX } = o || {};
+  const base = { job, version: String(version), ...(run ? { run } : {}) };
+  if (!JOB_ID.test(String(job || ''))) return { filed: [], dropped: [], error: 'the job id is not valid' };
+  const why = off(job, { env, settingsDir });
+  if (why) { audit(stateDir, { ...base, event: 'off', why }); return { filed: [], dropped: [], off: why }; }
+  const list = Array.isArray(proposals) ? proposals : [];
+  if (!ready(stateDir, job, version)) {
+    audit(stateDir, { ...base, event: 'held', n: list.length, why: 'no passing replay for this version' });
+    return { filed: [], dropped: [], held: true };
+  }
+  const got = sift(list, { root, stateDir, max });
+  for (const d of got.dropped) audit(stateDir, { ...base, event: 'dropped', id: d.id, why: one(d.why, 400) });
+  if (!got.filed.length) { audit(stateDir, { ...base, event: 'end', filed: 0, dropped: got.dropped.length }); return { filed: [], dropped: got.dropped }; }
+  try { await deliver(got.filed); } catch (e) {
+    audit(stateDir, { ...base, event: 'end', filed: 0, dropped: got.dropped.length, error: 'deliver failed: ' + one(e && e.message, 200) });
+    return { filed: [], dropped: got.dropped, error: 'deliver failed' };
+  }
+  for (const p of got.filed) audit(stateDir, { ...base, event: 'filed', id: p.id, confidence: p.confidence, refs: p.claims.flatMap((c) => c.sources.map((s) => s.ref)).slice(0, 12) });
+  audit(stateDir, { ...base, event: 'end', filed: got.filed.length, dropped: got.dropped.length });
+  return { filed: got.filed.map((p) => p.id), dropped: got.dropped };
+}
+
+/** What `pmos ai status` shows: the switch, each job's replay state and its last run. */
+function status({ stateDir, settingsDir = stateDir, env = process.env } = {}) {
+  const s = settings(settingsDir), reps = readReplays(stateDir), lines = readAudit(stateDir, { limit: 2000 });
+  const jobs = {};
+  for (const [k, r] of Object.entries(reps)) { const [job, version] = k.split('@'); (jobs[job] = jobs[job] || { job }).replay = { version, ok: r.ok, at: r.at }; }
+  for (const l of lines) if (l.job && l.event === 'end') (jobs[l.job] = jobs[l.job] || { job: l.job }).last = { at: l.at, filed: l.filed, dropped: l.dropped };
+  for (const j of Object.values(jobs)) j.off = off(j.job, { env, settingsDir });
+  return { on: !flagOff((env || {}).PMOS_AI) && s.on, settingsOff: s.off, jobs: Object.values(jobs).sort((a, b) => a.job.localeCompare(b.job)) };
+}
+
+module.exports = { AUDIT, REPLAYS, MAX, QUOTE_MIN, off, setOff, check, replay, ready, file, audit, readAudit, status, envName, resolveRef };

package/workspace/lib/briefing-premium-agent.js

@@ -17,6 +17,7 @@ const headless = require('./headless.js');
 const Goal = require('./goal-chat.js');
 const ReportChat = require('./report-chat.js');
 const ProgramChat = require('./program-chat.js');
+const PastChat = require('./past-chat.js');
 const WorkflowChat = require('./workflow-chat.js');
 const IniChat = require('./initiative-chat.js');
 
@@ -221,6 +222,8 @@ function chat({ runtimeDir, key, text, model, context, sessions, wsId, iniInfo,
   if (cmd) { const b = Goal.begin({ runtimeDir, key, text: cmd.text, now }); if (b.error) return fail(400, b.error); msg = b.prompt; goal = b.id; }
   // D99: the New workflow chat (Settings › Workflows) carries the workflow rule on every message (lib/workflow-chat.js)
   else if (WorkflowChat.isKey(key) && !q.startsWith('/')) msg = WorkflowChat.wrap(q);
+  // ask-the-past: "why did we drop X?" in any chat carries the past rule: answer from `pmos past ask`, cite every line, "No record found" when none
+  else if (PastChat.isAsk(q)) msg = PastChat.wrap(q);
   // bug 2026-10-25: in a live initiative chat, a message about a stage, a workflow or a move carries the initiative's workflow and stage, read now
   else if (alive && /^init:/.test(key) && IniChat.isAsk(q)) msg = IniChat.wrap(q, info(), iniId(key));
   // premium-reports-from-chat R1: a message about a report, a chart or a dashboard carries the pmos-report rule (lib/report-chat.js)