create-pmos 0.505.0 → 0.507.0

package/workspace/lib/rehearse-read.js

@@ -0,0 +1,159 @@
+'use strict';
+/* rehearse-read.js — the snapshot a rehearsal reads (initiative plan-rehearsal; lib/rehearse.js is the pure engine). READ ONLY: it writes
+ * nothing, and the server need not run. Every value comes through the readers the pmos verbs use, never from a ledger line by hand:
+ *
+ *   tasks     lib/routes-task-links.js frame (the Board's items of every board, Jira tickets and breakdown items too)
+ *   links     lib/task-links.js read (the approved links, folded)
+ *   rows      lib/routes-boards.js baseRows (each initiative's end, the Board's) and lib/initiative-rows.js (its anchor and record)
+ *   goals     the KR metric records (scripts/records) → lib/routes-c3-strategy.js outcomeOf → lib/insights-premium.js goalsOf, each with
+ *             lib/forecast.js goalForecast and the PM's kept baseline. The server's Insights route also files fixes and records turns;
+ *             this reads only, so it builds the goals itself
+ *   programs  lib/programs.js fold of this workspace's <state>/programs.jsonl
+ *
+ * THE SOURCES. A ledger is read twice: once folded (the values), once as lines, only to find the line number and a verbatim quote that
+ * an effect cites (`<path>:<line>`, relative to the repository root, as lib/ai-guard.js checks it). The value is never read from that line.
+ *
+ *   snapshotOf(root, { today?, stateDir? }) → snapshot (lib/rehearse.js)
+ *   refsOf(root, snap, files) → snap.refs · lineRef(root, file, test, label) → src | null
+ */
+const fs = require('fs');
+const path = require('path');
+const D = require('./driver.js');
+const TL = require('./task-links.js');
+const FC = require('./forecast.js');
+const { repoScript } = require('./repo-script.js');
+
+const rel = (root, f) => path.relative(root, f).split(path.sep).join('/');
+const QUOTE = 100, QUOTE_MIN = 12;
+
+/** The last line of `file` that passes `test`, as a source: { label, ref: '<path>:<line>', quote }. */
+function lineRef(root, file, test, label) {
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return null; }
+  const lines = text.split('\n');
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const m = test(lines[i]);
+    if (!m) continue;
+    let quote = (typeof m === 'string' ? m : lines[i]).trim().slice(0, QUOTE);
+    // a short line ("id: promo") is quoted with the line above it, as lib/ai-guard.js reads a quote across nearby lines
+    if (quote.length < QUOTE_MIN && i > 0) quote = (lines[i - 1].trim() + ' ' + quote).slice(0, QUOTE);
+    return { label, ref: rel(root, file) + ':' + (i + 1), quote };
+  }
+  return null;
+}
+const jsonHas = (k, v) => '"' + k + '":' + JSON.stringify(v);
+
+function ctxOf(root, stateDir) {
+  const w = { id: D.wsIdOf(root), name: path.basename(root), root };
+  return { w, ctx: { getWs: () => w, workspaceList: () => [w], stateDirFor: () => stateDir, selfRoot: path.resolve(__dirname, '..', '..') } };
+}
+
+function snapshotOf(root, o = {}) {
+  const today = o.today || new Date().toISOString().slice(0, 10);
+  const stateDir = o.stateDir || D.stateDirOf(root);
+  const missing = [], snap = { today, tasks: [], links: [], rows: [], goals: [], programs: [], refs: { links: {}, rows: {}, goals: {}, programs: {}, tasks: {} }, missing };
+  if (!stateDir) { missing.push('the PMOS state folder'); return snap; }
+  const RB = require('./routes-boards.js'), TLR = require('./routes-task-links.js'), rowsLib = require('./initiative-rows.js');
+  const { w, ctx } = ctxOf(root, stateDir);
+  const files = { records: {} };
+
+  // the initiatives: the Board's end, the record's anchor
+  let base = RB.baseRows(w);
+  if (base.pending) { try { rowsLib.deriveNow(root); } catch { /* answered below */ } base = RB.baseRows(w); }
+  const recOf = new Map();
+  try { const got = rowsLib.rowsFor(root); if (got && got.ok) for (const r of got.rows) recOf.set(r.id, r.record || null); } catch { /* no record paths */ }
+  if (base.ok) {
+    for (const r of base.rows) {
+      snap.rows.push({ id: r.id, title: r.title || r.id, end: r.end || null, anchor: r.anchor || null });
+      if (recOf.get(r.id)) files.records[r.id] = path.resolve(root, recOf.get(r.id));
+    }
+  } else missing.push('initiatives');
+
+  // the tasks of every board, and the approved links
+  try {
+    const fr = RB.frameFor(ctx, w), seen = new Set();
+    for (const b of fr.boards || []) {
+      const f = TLR.frame(ctx, w, b, { derive: true });
+      if (!f) { missing.push('board ' + b.id); continue; }
+      for (const [uid, x] of f.byUid) { if (seen.has(uid)) continue; seen.add(uid); snap.tasks.push(x); }
+    }
+  } catch { missing.push('tasks'); }
+  files.links = TL.ledgerFile(stateDir);
+  files.board = safe(() => RB.ledgerFile(ctx, w));
+  files.items = safe(() => require('./plan-ledgers.js').ledgerPath(root, 'plan-items'));
+  snap.links = TL.linksOf(TL.read(stateDir));
+
+  // the goals, each with today's forecast
+  try {
+    const R = require(repoScript('records/index.js')), dir = require('./records-dir.js').recordsDirFor(ctx, w.id);
+    const krs = R.list(dir, 'kr-metrics').filter((k) => k.retired !== true);
+    const strategy = require('./routes-c3-strategy.js'), Insights = require('./insights-premium.js');
+    const outcomes = krs.map((k) => strategy.outcomeOf(k, today)), meta = Object.fromEntries(krs.map((k) => [k.rid, k]));
+    const goals = Insights.goalsOf(outcomes, [], base.ok ? base.rows : [], Date.parse(today + 'T00:00:00Z'), meta, null);
+    const L = FC.read(stateDir);
+    files.krs = R.fileOf(dir, 'kr-metrics');
+    for (const g of goals) {
+      const forecast = FC.goalForecast(g, { today, baseline: L.baselines.get(g.id) || null });
+      snap.goals.push({ id: g.id, title: g.title, byAt: g.byAt, moves: (g.moves || []).map((m) => m.id), forecast: forecast ? { state: forecast.state, likely: forecast.likely } : null });
+    }
+  } catch { missing.push('goals'); }
+
+  // the programs whose milestones wait on these initiatives
+  try {
+    const P = require('./programs.js');
+    files.programs = path.join(stateDir, 'programs.jsonl');
+    for (const p of P.merge([{ ws: w.id, lines: readJsonl(files.programs) }])) {
+      if (p.archived) continue;
+      snap.programs.push({ id: p.id, title: p.title || p.id, milestones: (p.milestones || []).map((m) => ({ id: m.id, name: m.name, date: m.date || null, waits: m.waits || [], done: !!m.done, risk: m.risk === true })) });
+    }
+  } catch { missing.push('programs'); }
+  snap.refs = refsOf(root, snap, files);
+  return snap;
+}
+
+/** The sources an effect cites: the line of each link, initiative record, goal record, program charter and ◇ milestone flag.
+ *  files: { links, board?, krs?, programs?, records: { [initiative]: file } } (absolute paths). */
+function refsOf(root, snap, files) {
+  const R = { links: {}, rows: {}, goals: {}, programs: {}, tasks: {} }, F = files || {};
+  const after = (k) => (line) => (line.includes(k) ? line.slice(line.indexOf(k)) : null);
+  for (const l of snap.links || []) {
+    const k = jsonHas('from', l.from) + ',' + jsonHas('to', l.to);
+    const s = F.links && lineRef(root, F.links, (line) => (line.includes('"kind":"link"') ? after(k)(line) : null), 'link ' + l.from + ' → ' + l.to);
+    if (s) R.links[TL.keyOf(l.from, l.to)] = s;
+  }
+  for (const [ini, file] of Object.entries(F.records || {})) {
+    const a = lineRef(root, file, (l) => /^(parent_kr|anchor):/.test(l), ini + ' anchor');
+    if (a) R.rows[ini + ':anchor'] = a;
+    const idl = lineRef(root, file, (l) => /^id:/.test(l), ini + ' record (its end is the Board\'s, from its tasks)');
+    if (idl) R.rows[ini + ':end'] = idl;
+  }
+  for (const g of snap.goals || []) { const s = F.krs && lineRef(root, F.krs, after(jsonHas('rid', g.id)), 'goal ' + g.id); if (s) R.goals[g.id] = s; }
+  for (const p of snap.programs || []) { const s = F.programs && lineRef(root, F.programs, (line) => (line.includes('"kind":"program"') ? after(jsonHas('id', p.id))(line) : null), 'program ' + p.id); if (s) R.programs[p.id] = s; }
+  // each task's date: the last line of the Board or breakdown ledger that names the task and its due day (a ◇ flag line for a milestone
+  // with no date line). A ledger outside the repository (a worktree's main tree) is not cited: the guard reads only inside the root.
+  const inside = (f) => !!f && !path.relative(root, f).startsWith('..') && !path.isAbsolute(path.relative(root, f));
+  const ledgers = [F.board, F.items].filter(inside).map((f) => ({ f, lines: safe(() => fs.readFileSync(f, 'utf8').split('\n')) || [] }));
+  for (const t of snap.tasks || []) {
+    const uid = t.uid || t.key, due = String(t.end || t.due || '').slice(0, 10), id = JSON.stringify(uid);
+    if (!uid) continue;
+    for (const { f, lines } of ledgers) {
+      let i = lines.length - 1;
+      for (; i >= 0; i--) if (lines[i].includes(id) && (due ? lines[i].includes(due) : /milestone/.test(lines[i]))) break;
+      if (i < 0) continue;
+      const quote = lines[i].trim().slice(0, QUOTE);
+      R.tasks[uid] = { label: uid + (due ? ' due ' + due : ' milestone'), ref: rel(root, f) + ':' + (i + 1), quote };
+      break;
+    }
+  }
+  return R;
+}
+function safe(fn) { try { return fn(); } catch { return null; } }
+function readJsonl(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 { out.push(JSON.parse(raw)); } catch { /* a torn line is skipped */ } }
+  return out;
+}
+
+module.exports = { snapshotOf, refsOf, lineRef };

package/workspace/lib/rehearse.js

@@ -0,0 +1,279 @@
+'use strict';
+/* rehearse.js — rehearse a plan (initiative plan-rehearsal, PRD planning/prd/plan-rehearsal-prd.md). PURE: no file, no clock, no network.
+ * lib/rehearse-read.js reads the snapshot through the pmos readers; lib/rehearse-cli.js is `pmos rehearse`; lib/rehearse-guard.js is the
+ * kill switch, the evidence check and the audit line.
+ *
+ * Before the PM approves a change, Claude runs it here and shows what it breaks and what it helps: tasks in other initiatives, ◇ milestones,
+ * Jira tickets, committed ends, goals and program milestones. Nothing is changed. The PM approves in their own words.
+ *
+ *   rehearse(snap, change) → { ok, change, effects: [effect], counts: { breaks, helps, moves }, checked, missing } | { ok: false, error }
+ *   CHANGES: { kind: 'move', task, days? , start?, due? } · { kind: 'end', ini, to } · { kind: 'cut', task } · { kind: 'cut', ini }
+ *   effect: { tone: 'breaks' | 'helps' | 'moves', kind, ini, text, evidence: [{ label, ref, quote? }] }
+ *
+ * SNAPSHOT. { today: 'YYYY-MM-DD',
+ *   tasks:    [{ uid, title, ini, status, start, end, milestone, src }]   the shape lib/task-links.js taskOf reads
+ *   links:    [{ from, to, type, lag }]                                    the approved links
+ *   rows:     [{ id, title, end, anchor }]                                 the initiatives (end = the committed end)
+ *   goals:    [{ id, title, byAt, moves: [initiative id], forecast: { state, likely } | null }]   lib/forecast.js goalForecast
+ *   programs: [{ id, title, milestones: [{ id, name, date, waits: [initiative id], done }] }]
+ *   refs:     { links: { 'from>to': src }, rows: { 'ini:end' | 'ini:anchor': src }, goals: { id: src }, programs: { id: src }, tasks: { uid: src } }
+ *   missing:  ['goals', …]   what the reader could not read, said as it is }
+ *
+ * THE RULES.
+ *   - The effects are the DIFFERENCE between the plan as it is and the plan with the change. Both are first settled through the links
+ *     (lib/task-links.js settle, with every task allowed to move so the whole chain shows), so a link already broken today is not blamed
+ *     on the change.
+ *   - PROVEN ONLY. An effect is made from a link, a date and a record only. A goal effect says the date fact and the goal's forecast state
+ *     as it is today; it never estimates a new number. An effect with no source is dropped.
+ *   - QUIET. The tasks of the changed initiative that move with it are one `moves` line, not one line each. No effect: `effects` is empty.
+ */
+const TL = require('./task-links.js');
+const FC = require('./forecast.js');
+
+const KINDS = Object.freeze(['move', 'end', 'cut']);
+const MAX_LIST = 8;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const str = (v) => (typeof v === 'string' ? v : '');
+const days = (n) => (Math.abs(n) === 1 ? 'a day' : Math.abs(n) + ' days');
+const clip = (s, n) => { s = str(s).replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s; };
+const q = (s) => '"' + clip(s, 60) + '"';
+const has = (src) => !!(src && str(src.ref));
+
+/** The tasks as the engine reads them. */
+function tasksOf(list) {
+  const T = new Map();
+  for (const x of list || []) { if (!x || !(x.uid || x.key)) continue; const t = TL.taskOf(x); T.set(t.uid, t); }
+  return T;
+}
+const copy = (T) => { const C = new Map(); for (const [k, v] of T) C.set(k, { ...v }); return C; };
+const ALL = { has: () => true };
+/** Settle the links over T, every task allowed to move: answers the settled copy and what could not move. */
+function project(T, links, o) {
+  const C = copy(T);
+  const S = TL.settle(C, links, { seeds: o.seeds, today: o.today, ini: '', mode: 'quiet', allow: ALL });
+  for (const m of S.moves) { const t = C.get(m.uid); C.set(m.uid, { ...t, s: m.to.s, e: m.to.e }); }
+  return { T: C, moves: S.moves, clashes: S.clashes };
+}
+/** An initiative's last open day: its latest open task's end, or null. */
+function finishOf(T, ini) {
+  let f = null;
+  for (const t of T.values()) if (t.ini === ini && !t.closed && t.e != null && (f == null || t.e > f)) f = t.e;
+  return f;
+}
+/** When an initiative's work lands: its last open task's end; its committed end only when no open task has a date. A later deadline alone
+ *  does not move when the work lands (Wawan's Mac, 2026-11-03: extending an end flagged a milestone the work still met). */
+function landOf(T, row, ini) {
+  const f = finishOf(T, ini);
+  return f != null ? f : row && row.end ? TL.dn(row.end) : null;
+}
+/** The open task that ends an initiative's work, or null. */
+function lastOf(T, ini) {
+  let t = null;
+  for (const x of T.values()) if (x.ini === ini && !x.closed && x.e != null && (!t || x.e > t.e)) t = x;
+  return t;
+}
+
+function validate(snap, c) {
+  if (!c || !KINDS.includes(c.kind)) return 'the change is one of ' + KINDS.join(', ');
+  const T = (snap && snap.tasks) || [], rows = (snap && snap.rows) || [];
+  const isTask = (u) => T.some((t) => (t.uid || t.key) === u), isIni = (i) => rows.some((r) => r.id === i);
+  if (c.kind === 'move') {
+    if (!isTask(c.task)) return ((snap && snap.links) || []).some((l) => l && (l.from === c.task || l.to === c.task)) ? 'task ' + c.task + ' is named in a task link, but no board has it any more (removed or renamed)' : 'no task ' + str(c.task) + ' is on a board';
+    const n = [c.days != null, !!c.start, !!c.due].filter(Boolean).length;
+    if (!n) return 'say how it moves: --by <days>, --start or --due';
+    if (c.days != null && (!Number.isInteger(c.days) || c.days === 0 || Math.abs(c.days) > 730)) return '--by takes whole days, not 0, up to 730';
+    if (c.days != null && n > 1) return '--by goes alone; --start and --due go together';
+    for (const k of ['start', 'due']) if (c[k] && !DATE_RE.test(c[k])) return '--' + k + ' takes YYYY-MM-DD';
+  }
+  if (c.kind === 'end') { if (!isIni(c.ini)) return 'no initiative ' + str(c.ini); if (!DATE_RE.test(str(c.to))) return '--to takes YYYY-MM-DD'; }
+  if (c.kind === 'cut' && !(c.task ? isTask(c.task) : isIni(c.ini))) return c.task ? 'no task ' + c.task + ' is on a board' : 'no initiative ' + str(c.ini);
+  return '';
+}
+
+function rehearse(snap, change) {
+  const err = validate(snap, change);
+  if (err) return { ok: false, error: err };
+  const S = snap || {}, R = S.refs || {}, today = TL.dn(S.today);
+  const refL = (l) => (R.links || {})[TL.keyOf(l.from, l.to)] || null, refRow = (ini, k) => (R.rows || {})[ini + ':' + k] || null;
+  const rows = new Map((S.rows || []).map((r) => [r.id, r]));
+  const T0 = tasksOf(S.tasks);
+  const links0 = (S.links || []).filter((l) => l && T0.has(l.from) && T0.has(l.to));
+  const stale = (S.links || []).filter((l) => l && !(T0.has(l.from) && T0.has(l.to))).length;
+  const base = project(T0, links0, { today });   // the plan as it is
+  const titleOf = (u) => (base.T.get(u) || {}).title || u, iniTitle = (i) => (rows.get(i) || {}).title || i;
+  const c = change, effects = [];
+  let unsourced = 0;
+  const add = (e) => { const ev = (e.evidence || []).filter(has); if (ev.length) effects.push({ ...e, evidence: dedupe(ev) }); else unsourced++; };
+  const refT = (uid) => (R.tasks || {})[uid] || null;
+
+  // the change, applied to the plan as it is
+  let note = '';
+  let Ta = copy(base.T), links = links0, seeds = [], home = '', rowsA = new Map(rows), cutT = new Set(), cutIni = '';
+  if (c.kind === 'move') {
+    const t = Ta.get(c.task); home = t.ini; seeds = [t.uid];
+    let s = t.s, e = t.e;
+    if (c.days != null) { s = s == null ? null : s + c.days; e = e == null ? null : e + c.days; }
+    else {
+      if (c.start) { const ns = TL.dn(c.start); if (!c.due && e != null && s != null) e = e + (ns - s); s = ns; }
+      if (c.due) e = TL.dn(c.due);
+      if (s != null && e != null && e < s) return { ok: false, error: 'the due day would come before the start day' };
+    }
+    Ta.set(t.uid, { ...t, s, e });
+    if (c.days != null && t.e != null && today != null && t.e < today && !t.closed) note = q(t.title) + ' is late: due ' + TL.md(t.e) + '. --by ' + c.days + ' moves its due to ' + TL.md(t.e + c.days) + (t.e + c.days > today ? ', ' + days(t.e + c.days - today) + ' after today' : ', still before today') + '.';
+  } else if (c.kind === 'end') {
+    home = c.ini; rowsA.set(c.ini, { ...rows.get(c.ini), end: c.to });
+  } else if (c.task) {
+    home = Ta.get(c.task).ini; cutT.add(c.task);
+  } else {
+    home = cutIni = c.ini; for (const t of Ta.values()) if (t.ini === c.ini) cutT.add(t.uid);
+  }
+  if (cutT.size) { for (const u of cutT) Ta.delete(u); links = links0.filter((l) => !cutT.has(l.from) && !cutT.has(l.to)); }
+  const after = seeds.length ? project(Ta, links, { today, seeds }) : { T: Ta, moves: [], clashes: [] };
+  const TA = after.T;
+
+  // tasks that move: the changed initiative's in one line; another initiative's and every ◇ milestone each
+  const mine = [];
+  for (const m of after.moves) {
+    const b = base.T.get(m.uid), a = TA.get(m.uid);
+    if (!b || !a || a.e === b.e && a.s === b.s) continue;
+    const d = (a.e != null && b.e != null ? a.e - b.e : a.s - b.s), via = refL(m.link), why = q(titleOf(m.link.from));
+    const o = T0.get(m.uid), key = b.ms || a.s == null ? 'e' : 's';
+    const from = ' from ' + TL.md(b[key]) + (o && o[key] !== b[key] ? ' (' + TL.md(o[key]) + ' on the Board; late work before it already pushes it to ' + TL.md(b[key]) + ')' : '');
+    if (b.ms) add({ tone: 'breaks', kind: 'milestone', ini: b.ini, task: b.uid, text: '◇ ' + q(b.title) + (b.ini !== home ? ' in ' + q(iniTitle(b.ini)) : '') + ' moves ' + days(d) + ' later,' + from + ' to ' + TL.md(a.e) + '. It waits on ' + why + '.', evidence: [via, refT(b.uid)] });
+    else if (b.ini !== home) add({ tone: 'breaks', kind: 'task', ini: b.ini, task: b.uid, text: q(b.title) + ' in ' + q(iniTitle(b.ini)) + ' moves ' + days(d) + ' later,' + from + ' to ' + TL.md(a[key]) + '. It waits on ' + why + '.', evidence: [via] });
+    else mine.push({ m, d, via });
+  }
+  if (mine.length) {
+    const names = mine.slice(0, MAX_LIST).map((x) => q(titleOf(x.m.uid)) + ' +' + x.d + 'd').join(', ') + (mine.length > MAX_LIST ? ' and ' + (mine.length - MAX_LIST) + ' more' : '');
+    add({ tone: 'moves', kind: 'tasks', ini: home, text: (mine.length === 1 ? '1 task' : mine.length + ' tasks') + ' in ' + q(iniTitle(home)) + ' move with it: ' + names + '.', evidence: mine.map((x) => x.via) });
+  }
+  // a Jira ticket the links say must start later: PMOS cannot move it
+  const clashKey = (x) => x.uid + '<' + x.after;
+  const was = new Set(base.clashes.map(clashKey));
+  for (const x of after.clashes) {
+    if (x.kind !== 'jira' || was.has(clashKey(x))) continue;
+    add({ tone: 'breaks', kind: 'jira', ini: (TA.get(x.uid) || {}).ini || '', task: x.uid, text: x.uid + ' ' + q(titleOf(x.uid)) + ' would have to start ' + days(x.days) + ' later. It is a Jira ticket, so PMOS cannot move it; its assignee would.', evidence: [refL(x.link)] });
+  }
+  // what waited on a cut task: it loses what it waited on, and may start earlier
+  if (cutT.size) {
+    for (const l of links0) {
+      if (!cutT.has(l.from) || cutT.has(l.to)) continue;
+      const b = base.T.get(l.to); if (!b || b.closed) continue;
+      add({ tone: 'breaks', kind: 'loses', ini: b.ini, task: b.uid, text: q(b.title) + (b.ini !== home ? ' in ' + q(iniTitle(b.ini)) : '') + ' waits on ' + q(titleOf(l.from)) + ', which would be cut. Whatever it needed from it has to come from somewhere else.', evidence: [refL(l)] });
+    }
+  }
+  // a task moved earlier than a link into it allows: it would start before what it waits on is done
+  if (c.kind === 'move') {
+    const t1 = TA.get(c.task);
+    for (const l of links0) {
+      if (l.to !== c.task) continue;
+      const a = base.T.get(l.from); if (!a || a.closed) continue;
+      const short1 = TL.shortOf(TL.needOf(l, TA.get(l.from) || a, today), t1), short0 = TL.shortOf(TL.needOf(l, a, today), base.T.get(c.task));
+      if (short1 > 0 && short0 <= 0) add({ tone: 'breaks', kind: 'order', ini: t1.ini, task: t1.uid, text: q(t1.title) + ' would start ' + days(short1) + ' before ' + q(a.title) + (a.ini !== t1.ini ? ' in ' + q(iniTitle(a.ini)) : '') + ' allows. It waits on it (' + TL.TYPE_WORDS[l.type] + ').', evidence: [refL(l)] });
+    }
+  }
+  // what can start earlier: a task held tight by a task moved earlier now has room (a task that lost a cut task is said above)
+  if (c.kind === 'move' && moveDelta(base.T, Ta, c.task) < 0) {
+    const seen = new Set();
+    for (const l of links0) {
+      if (seen.has(l.to) || l.from !== c.task) continue;
+      const b = TA.get(l.to); if (!b || b.closed || b.jira || b.s == null || b.status !== 'To do') continue;
+      const roomB = roomOf(base.T, links0, b.uid, today), roomA = roomOf(TA, links, b.uid, today);
+      if (roomB > 0 || roomA <= 0) continue;
+      seen.add(b.uid);
+      add({ tone: 'helps', kind: 'earlier', ini: b.ini, task: b.uid, text: q(b.title) + (b.ini !== home ? ' in ' + q(iniTitle(b.ini)) : '') + ' could start up to ' + days(roomA) + ' earlier. Nothing moves it until you do.', evidence: [refL(l)] });
+    }
+  }
+  // committed ends: an initiative whose last task now ends after its committed end, or no longer does
+  const inis = new Set([...base.T.values()].map((t) => t.ini).concat(c.kind === 'end' ? [c.ini] : []));
+  for (const ini of inis) {
+    if (!ini || ini === cutIni) continue;
+    const r0 = rows.get(ini), r1 = rowsA.get(ini);
+    const end0 = r0 && r0.end ? TL.dn(r0.end) : null, end1 = r1 && r1.end ? TL.dn(r1.end) : null;
+    if (end1 == null) continue;
+    const f0 = finishOf(base.T, ini), f1 = finishOf(TA, ini);
+    const late0 = f0 != null && end0 != null && f0 > end0, late1 = f1 != null && f1 > end1;
+    const lt = lastOf(TA, ini);
+    const ev = [refRow(ini, 'end'), lt ? refT(lt.uid) : null].concat(after.moves.filter((m) => (TA.get(m.uid) || {}).ini === ini).slice(0, 2).map((m) => refL(m.link)));
+    if (!late0 && late1) add({ tone: 'breaks', kind: 'end', ini, text: q(iniTitle(ini)) + "'s last task would end " + TL.md(f1) + ', ' + days(f1 - end1) + ' after its committed end, ' + TL.md(end1) + '.', evidence: ev });
+    else if (late0 && !late1 && f1 != null) add({ tone: 'helps', kind: 'end', ini, text: q(iniTitle(ini)) + "'s last task would end " + TL.md(f1) + ', back inside its committed end, ' + TL.md(end1) + '.', evidence: ev });
+  }
+  // goals and program milestones: when each initiative's work lands, before and after
+  const land0 = new Map(), land1 = new Map();
+  for (const ini of new Set([...rows.keys(), ...inis])) { land0.set(ini, landOf(base.T, rows.get(ini), ini)); if (ini !== cutIni) land1.set(ini, landOf(TA, rowsA.get(ini), ini)); }
+  const lastRef = (ini) => { const t = lastOf(TA, ini) || lastOf(base.T, ini); return t ? refT(t.uid) : null; };
+  const movedIni = [...land0.keys()].filter((i) => i === cutIni || land0.get(i) !== land1.get(i));
+  for (const g of S.goals || []) {
+    const by = TL.dn(g.byAt); if (by == null) continue;
+    const fc = g.forecast && g.forecast.state ? ' Its forecast today: ' + FORECAST_WORDS(g.forecast) + '.' : '';
+    for (const ini of movedIni) {
+      if (!(g.moves || []).includes(ini)) continue;
+      const ev = [(R.goals || {})[g.id], refRow(ini, 'anchor')];
+      if (ini === cutIni) { add({ tone: 'breaks', kind: 'goal', ini, goal: g.id, text: 'Goal ' + q(g.title) + ' loses ' + q(iniTitle(ini)) + ', ' + ((g.moves || []).length === 1 ? 'the only initiative that moves it' : 'one of the ' + g.moves.length + ' initiatives that move it') + '.' + fc, evidence: ev }); continue; }
+      const a = land0.get(ini), b = land1.get(ini); if (a == null || b == null) continue;
+      if (a <= by && b > by) add({ tone: 'breaks', kind: 'goal', ini, goal: g.id, text: 'Goal ' + q(g.title) + ' is due ' + TL.md(by) + '. ' + q(iniTitle(ini)) + ', which moves it, would land ' + TL.md(b) + ', after that.' + fc, evidence: ev.concat([refRow(ini, 'end'), lastRef(ini)]) });
+      else if (a > by && b <= by) add({ tone: 'helps', kind: 'goal', ini, goal: g.id, text: 'Goal ' + q(g.title) + ' is due ' + TL.md(by) + '. ' + q(iniTitle(ini)) + ', which moves it, would land ' + TL.md(b) + ', in time.' + fc, evidence: ev.concat([refRow(ini, 'end'), lastRef(ini)]) });
+    }
+  }
+  const byIni = (L) => new Map([...L.entries()].filter(([, v]) => v != null).map(([k, v]) => [k, { state: null, high: TL.isoN(v) }]));
+  const B0 = byIni(land0), B1 = byIni(land1);
+  for (const p of S.programs || []) {
+    const ev0 = (R.programs || {})[p.id];
+    for (const m of (p.milestones || []).filter((x) => x && !x.done && x.name)) {
+      for (const ini of movedIni) {
+        if (!(m.waits || []).includes(ini)) continue;
+        const md = TL.dn(m.date), a = land0.get(ini), b = land1.get(ini);
+        const ctx = ' Program ' + q(p.title || p.id) + ': ' + atRiskWords(p, B0, B1, cutIni) + '.';
+        if (ini === cutIni) add({ tone: 'breaks', kind: 'program', ini, program: p.id, text: 'Milestone ' + q(m.name) + ' waits on ' + q(iniTitle(ini)) + ', which would be cut.' + ctx, evidence: [ev0] });
+        else if (md != null && a != null && b != null && a <= md && b > md) add({ tone: 'breaks', kind: 'program', ini, program: p.id, text: 'Milestone ' + q(m.name) + ' (' + TL.md(md) + ') waits on ' + q(iniTitle(ini)) + ', which would land ' + TL.md(b) + ', after it.' + ctx, evidence: [ev0, refRow(ini, 'end'), lastRef(ini)] });
+        else if (md != null && a != null && b != null && a > md && b <= md) add({ tone: 'helps', kind: 'program', ini, program: p.id, text: 'Milestone ' + q(m.name) + ' (' + TL.md(md) + ') waits on ' + q(iniTitle(ini)) + ', which would land ' + TL.md(b) + ', in time.' + ctx, evidence: [ev0, refRow(ini, 'end'), lastRef(ini)] });
+      }
+    }
+  }
+  const order = { breaks: 0, helps: 1, moves: 2 };
+  effects.sort((x, y) => order[x.tone] - order[y.tone]);
+  const counts = { breaks: 0, helps: 0, moves: 0 }; for (const e of effects) counts[e.tone]++;
+  return { ok: true, change: c, effects, counts, checked: { tasks: T0.size, links: links0.length, goals: (S.goals || []).length, programs: (S.programs || []).length }, missing: S.missing || [], unsourced, stale, note };
+}
+
+function moveDelta(T0, T1, uid) { const a = T0.get(uid), b = T1.get(uid); return a && b && a.e != null && b.e != null ? b.e - a.e : a && b && a.s != null && b.s != null ? b.s - a.s : 0; }
+/** How many days earlier `uid` could start under the links into it (and not before tomorrow). */
+function roomOf(T, links, uid, today) {
+  const b = T.get(uid); if (!b || b.s == null) return 0;
+  let need = today == null ? -Infinity : today + 1;
+  for (const l of links) {
+    if (l.to !== uid) continue;
+    const a = T.get(l.from); if (!a) continue;
+    const n = TL.needOf(l, a, today);
+    if (n.start != null) need = Math.max(need, n.start);
+    if (n.due != null && b.e != null) need = Math.max(need, b.s + (n.due - b.e));
+  }
+  return need === -Infinity ? 0 : Math.max(0, b.s - need);
+}
+const FORECAST_WORDS = (f) => ({ 'on-track': 'on track', 'at-risk': 'at risk', 'will-miss': 'will miss', 'too-early': 'too early to say', held: 'held, not read for over a week' }[f.state] || f.state) + (f.likely != null ? ', likely ' + f.likely : '');
+function atRiskWords(p, B0, B1, cutIni) {
+  const P1 = { ...p, milestones: (p.milestones || []).map((m) => (cutIni && (m.waits || []).includes(cutIni) ? { ...m, risk: true } : m)) };
+  const a = FC.programForecast(p, B0), b = FC.programForecast(P1, B1);
+  if (!a || !b) return 'no milestone forecast';
+  return b.atRisk + ' of ' + b.total + ' milestones at risk' + (b.atRisk !== a.atRisk ? ' (was ' + a.atRisk + ')' : '');
+}
+function dedupe(ev) { const seen = new Set(); return ev.filter((s) => { const k = s.ref + '|' + (s.quote || ''); if (seen.has(k)) return false; seen.add(k); return true; }); }
+
+/** The rehearsal in words, for the chat: breaks first, then helps, then what moves with it; each with its sources. */
+function textOf(r) {
+  if (!r.ok) return ['✗ ' + r.error];
+  const out = [];
+  if (!r.effects.length) out.push('Nothing else moves: no other task, initiative, goal or program milestone changes.');
+  for (const e of r.effects) {
+    out.push((e.tone === 'breaks' ? '✗ Breaks: ' : e.tone === 'helps' ? '✓ Helps: ' : '· Moves: ') + e.text);
+    out.push('    source: ' + e.evidence.map((s) => s.label + ' (' + s.ref + ')').join('; '));
+  }
+  if (r.note) out.push('Note: ' + r.note);
+  if (r.stale) out.push((r.stale === 1 ? '1 task link names' : r.stale + ' task links name') + ' a task no board has any more, so ' + (r.stale === 1 ? 'it is' : 'they are') + ' left out.');
+  if (r.unsourced) out.push((r.unsourced === 1 ? '1 effect is' : r.unsourced + ' effects are') + ' not shown: PMOS found no record line to cite for it.');
+  if (r.missing && r.missing.length) out.push('Not read: ' + r.missing.join(', ') + '. What depends on them is not shown.');
+  out.push('This was a rehearsal. Nothing changed. The PM approves the change in their own words before anyone makes it.');
+  return out;
+}
+
+module.exports = { KINDS, rehearse, textOf, validate, roomOf, finishOf, landOf };

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

package/workspace/lib/settings-store.js

@@ -101,6 +101,10 @@ const DEFS = Object.freeze({
   // and the monthly credit cap in US dollars. At the cap Claude pauses. `pmos grill mode|cap` reads and sets them.
   'grill.mode': one('checks', 'computer', ['full', 'exits', 'off'], 'full'),
   'grill.cap': { section: 'checks', scope: 'computer', type: 'dollars', min: 0, max: 500, def: 10 },
+  // The AI jobs' kill switch (lib/ai-guard.js): 'ai.on' false stops every AI job; 'ai.off' lists the jobs that are off one by one.
+  // `pmos ai off [job]` and `pmos ai on [job]` set them; PMOS_AI=off wins over both.
+  'ai.on': bool('checks', 'computer', true),
+  'ai.off': { section: 'checks', scope: 'computer', type: 'jobs', max: 40, def: [] },
 });
 
 /* The environment variables that win over a setting, here or in a setting's own store. `key` names the setting the page
@@ -112,6 +116,7 @@ const ENV = Object.freeze([
   { key: 'rec.final', env: 'PMOS_NOTES_FINAL', off: 'off', effect: 'The pass after Stop is off on this computer.' },
   { key: 'notes.wispr', env: 'PMOS_NOTES_WISPR', off: 'off', effect: 'Wispr Flow notes are not fetched on this computer.' },
   { key: 'notes.engine', env: 'PMOS_NOTES_QWEN', off: 'off', effect: 'Qwen3-ASR is not used on this computer.' },
+  { key: 'ai.on', env: 'PMOS_AI', off: 'off', effect: 'Every AI job is off on this computer: nothing is filed under ✦.' },
 ]);
 
 const WS_ID = /^[A-Za-z0-9_-]{1,80}$/;
@@ -163,6 +168,7 @@ function validate(key, value) {
     }
     // ['*'] alone is every workspace (the product picker's All, lib/briefing-premium-products.js)
     case 'ids': return value === null || Array.isArray(value) && (value.length === 1 && value[0] === '*' || value.length <= d.max && value.every((x) => typeof x === 'string' && WS_ID.test(x)) && new Set(value).size === value.length) ? null : `${key} must list at most ${d.max} workspace ids, each once, or ['*'] for every one`;
+    case 'jobs': return Array.isArray(value) && value.length <= d.max && value.every((x) => typeof x === 'string' && /^[a-z][a-z0-9-]{1,40}$/.test(x)) && new Set(value).size === value.length ? null : `${key} must list at most ${d.max} job ids, each once`;
     // Dress for the day (pm/cozy-seasons.js): a day's key is its charm key, as in DAYS there
     case 'country': return value === '' || typeof value === 'string' && /^[A-Z]{2}$/.test(value) ? null : `${key} must be a two-letter country code, or empty for this computer's`;
     case 'colors': return Array.isArray(value) && value.length === 2 && value.every((c) => DRESS_COLORS.includes(c)) ? null : `${key} must be two of ${DRESS_COLORS.join(', ')}`;

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.505.0",
+  "version": "0.507.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.505.0",
+      "version": "0.507.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.505.0",
+  "version": "0.507.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/grill-words.js

@@ -1,7 +1,7 @@
 /* pm/grill-words.js — the words and marks every page uses for Claude's checks (Grill and Forecast screens; canvas GrillResult, GrillLenses,
  * FcIntel, FcPhone). Pure: Node can import it.
  *
- *   ANGLE                    { [angle]: { label, icon (a 24-unit path) } }: premortem · redteam · voices · reframe · scope · whatif
+ *   ANGLE                    { [angle]: { label, icon (a 24-unit path) } }: premortem · redteam · voices · reframe · scope · whatif · decision · past
  *   findingOf(p)             a grill proposal (lib/grill.js finding) → { angle, label, icon, title, why, next, simulated }
  *                            the title and why without the angle prefix and the "Next:" tail lib/grill.js writes into them
  *   whenWord(iso, now)       'overnight' · 'today' · 'yesterday' · 'on Oct 30'
@@ -16,6 +16,8 @@ export const ANGLE = Object.freeze({
   reframe: { label: 'Reframe', icon: 'M4 8V4h4M20 8V4h-4M4 16v4h4M20 16v4h-4M9 9h6v6H9z' },
   scope: { label: 'Scope', icon: 'M4 6h16M7 12h10M10 18h4' },
   whatif: { label: 'What-if', icon: 'M4 18c4 0 4-12 8-12s4 12 8 12M4 12c4 0 4-6 8-6' },
+  decision: { label: 'Earlier decision', icon: 'M6 3h9l3 3v15H6zM9 9h6M9 13h6M9 17h3' },
+  past: { label: 'You decided this before', icon: 'M3 12a9 9 0 1 0 3-6.7M3 4v4h4M12 7v5l3 2' },
 });
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 
@@ -44,7 +46,7 @@ export function costWord(usd) {
   if (usd == null || !Number.isFinite(n)) return '';
   return n < 1 ? Math.max(1, Math.round(n * 100)) + '¢' : '$' + n.toFixed(2);
 }
-const WHY = { exit: 'before it leaves its stage', forecast: 'when its forecast turned', move: 'after its scope or dates moved', monthly: 'in the monthly look' };
+const WHY = { exit: 'before it leaves its stage', forecast: 'when its forecast turned', move: 'after its scope or dates moved', plan: 'when its PRD changed', monthly: 'in the monthly look' };
 export const whyWord = (r) => (r && WHY[r.why]) || '';
 export function runLine(r, now = Date.now()) {
   if (!r) return '';