create-pmos 0.508.0 → 0.510.0

package/workspace/lib/outcomes-cli.js

@@ -0,0 +1,138 @@
+'use strict';
+/* outcomes-cli.js — `pmos outcomes`: no initiative without an expected outcome (initiative outcome-for-every-initiative; lib/outcomes.js, D57).
+ *
+ *   pmos outcomes list [--json]                       every initiative's outcome state in this repository: checks due, outcomes with no
+ *                                                     date, initiatives with no outcome, pending and checked. Reads only.
+ *   pmos outcomes propose [<id>] [--max <n>] [--json] Claude's ✦ drafts, each claim cited path:line, through the shared guard
+ *                                                     (lib/ai-guard.js). Before the first draft of a repository it replays them on its real
+ *                                                     records. Writes only the guard's audit, in the per-user folder.
+ *   pmos outcomes declare <id> --metric "<text>" --horizon <YYYY-MM-DD>
+ *                                                     the PM's yes to a draft: writes the record's outcome_metric and outcome_horizon lines
+ *   pmos outcomes record <id> <worked|didnt-work|cant-tell> --evidence "<text>"
+ *                                                     the PM's verdict on a check that is due (validated | refuted | inconclusive are the
+ *                                                     same words), appended to the outcome ledger. Evidence is required.
+ *   every command: [--root <dir>] (default: this repository)
+ *
+ * The agent runs declare and record only after the PM said yes in the chat; the line names who wrote it (lib/actor.js). A verdict is the
+ * PM's (D57): never record one from a metric alone. Exit codes: 0 done, 1 refused, 2 usage. Nothing is sent.
+ */
+const path = require('path');
+const { execFileSync } = require('child_process');
+const O = require('./outcomes.js');
+
+const COMMANDS = { outcomes: ['list', 'propose', 'declare', 'record'] };
+const USAGE = [
+  'usage: pmos outcomes list|propose|declare|record — every initiative has an expected outcome and a date to check it',
+  '  pmos outcomes list [--json]                          checks due, outcomes with no date, initiatives with no outcome; reads only',
+  '  pmos outcomes propose [<id>] [--max <n>] [--json]    Claude\'s ✦ drafts from the PRD and the KR, each one cited',
+  '  pmos outcomes declare <id> --metric "<text>" --horizon <YYYY-MM-DD>    the PM said yes: write the outcome and its check date',
+  '  pmos outcomes record <id> <worked|didnt-work|cant-tell> --evidence "<text>"    the PM\'s verdict on a due check',
+  'Run it in the product\'s repository, or pass --root <dir>. Show each ✦ to the PM and write only after a yes.',
+];
+const VERDICT = { worked: 'validated', validated: 'validated', 'didnt-work': 'refuted', "didn't-work": 'refuted', refuted: 'refuted', 'cant-tell': 'inconclusive', "can't-tell": 'inconclusive', inconclusive: 'inconclusive' };
+
+function parse(args) {
+  const pos = [], flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith('--')) { pos.push(a); continue; }
+    const k = a.slice(2);
+    if (k === 'json') flags.json = true;
+    else flags[k] = args[i + 1] !== undefined && !String(args[i + 1]).startsWith('--') ? args[++i] : '';
+  }
+  return { pos, flags };
+}
+function repoRoot(cwd) {
+  try { return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || cwd; } catch { return cwd; }
+}
+const wsIdOf = (root) => { try { return require('./driver.js').wsIdOf(root); } catch { return require('crypto').createHash('sha1').update(path.resolve(root)).digest('hex').slice(0, 10); } };
+const draftText = (p) => `✦ ${p.title}\n  ${p.say}\n${p.claims.map((c) => '    · ' + c.text + ' [' + c.sources.map((s) => s.ref).join(', ') + ']').join('\n')}`
+  + (p.data && p.data.kind !== 'due' ? `\n  Yes → pmos outcomes declare ${p.data.initiative} --metric ${JSON.stringify(p.data.metric)} --horizon ${p.data.horizon}`
+    : p.data ? `\n  Verdict → pmos outcomes record ${p.data.initiative} worked|didnt-work|cant-tell --evidence "<what shows it>"` : '');
+
+async function run(argv, { say = (s) => console.log(s), env = process.env, cwd = process.cwd(), now = Date.now(), isTTY, runtime } = {}) {
+  const args = argv[0] === 'outcomes' ? argv.slice(1) : argv.slice();
+  const sub = args[0];
+  if (!sub || ['help', '--help', '-h'].includes(sub)) { for (const l of USAGE) say(l); return sub ? 0 : 1; }
+  if (!COMMANDS.outcomes.includes(sub)) { say(`unknown outcomes command "${sub}". Use one of: ${COMMANDS.outcomes.join(', ')}`); return 2; }
+  const { pos, flags } = parse(args.slice(1));
+  const allowed = { list: ['json', 'root'], propose: ['json', 'root', 'max'], declare: ['json', 'root', 'metric', 'horizon'], record: ['json', 'root', 'evidence'] }[sub];
+  for (const k of Object.keys(flags)) if (!allowed.includes(k)) { say(`✗ --${k} is not an option of pmos outcomes ${sub}`); return 2; }
+  const root = path.resolve(flags.root || repoRoot(cwd));
+  const today = O.todayOf(now);
+  const fail = (error, code = 1) => { say(flags.json ? JSON.stringify({ ok: false, error }) : '✗ ' + error); return code; };
+
+  if (sub === 'list') {
+    if (pos.length) return fail('pmos outcomes list takes no argument', 2);
+    const S = O.scan(root, { today });
+    const pick = (a) => a.map((it) => ({ id: it.id, title: it.title, lane: it.lane, metric: it.metric || null, horizon: it.horizon || null }));
+    if (flags.json) { say(JSON.stringify({ ok: true, total: S.subjects.length, due: pick(S.due), undated: pick(S.undated), missing: pick(S.missing), recent: S.recent, pending: pick(S.pending), disposed: S.disposed.map((d) => ({ id: d.id, disposition: d.disposition })), shippedWithout: S.shippedWithout, notRead: S.notRead })); return 0; }
+    const named = S.due.length + S.undated.length + S.pending.length + S.disposed.length;
+    say(`${S.subjects.length} initiatives · ${named} name an expected outcome · ${named - S.undated.length} of those have a check date · ${S.disposed.length} checked`);
+    if (S.due.length) say(`\n${S.due.length} check${S.due.length === 1 ? '' : 's'} due:\n` + S.due.map((it) => `  ${it.id} — since ${O.short(it.horizon)} · ${it.metric}`).join('\n'));
+    if (S.undated.length) say(`\n${S.undated.length} with no check date:\n` + S.undated.map((it) => `  ${it.id} — ${it.metric}`).join('\n'));
+    if (S.missing.length) say(`\n${S.missing.length} under way with no expected outcome${S.recent ? ` (${S.recent} edited in the last 30 days)` : ''}:\n` + S.missing.slice(0, 15).map((it) => `  ${it.id} — ${it.title}`).join('\n') + (S.missing.length > 15 ? `\n  … and ${S.missing.length - 15} more (--json lists all)` : ''));
+    if (S.shippedWithout) say(`\n${S.shippedWithout} accepted with no outcome: too late to declare, counted only.`);
+    if (S.notRead.length) say('Not read: ' + S.notRead.join(', '));
+    if (S.due.length || S.undated.length || S.missing.length) say('\nClaude drafts each one: pmos outcomes propose');
+    return 0;
+  }
+
+  if (sub === 'propose') {
+    if (pos.length > 1) return fail('pmos outcomes propose takes at most one initiative id', 2);
+    const max = flags.max === undefined ? 3 : Number(flags.max);
+    if (!Number.isInteger(max) || max < 1 || max > 10) return fail('--max is a whole number from 1 to 10', 2);
+    const S = O.scan(root, { today });
+    if (pos[0] && !S.subjects.some((it) => it.id === pos[0])) return fail(`no initiative ${pos[0]} here (or it is stopped, or on a document lane)`);
+    const { drafts, ask } = O.drafts(S, { only: pos[0] || null });
+    const askText = ask.length ? `${ask.length} with nothing to draft from (no success criteria in a PRD, no KR to cite): ask the PM what should change once each ships — ${ask.slice(0, 8).map((a) => a.id).join(', ')}${ask.length > 8 ? ', …' : ''}` : '';
+    if (!drafts.length) { if (flags.json) say(JSON.stringify({ ok: true, drafts: [], ask })); else say(askText || 'Nothing to draft: every initiative here has its expected outcome and check date.'); return 0; }
+    let AG = null; try { AG = require('./ai-guard.js'); } catch { AG = null; }
+    if (!AG) return fail('the shared guard (lib/ai-guard.js) is not installed, so nothing can show');
+    const rt = runtime || require('./state-root.js').defaultRoot({ env });
+    const version = O.VERSION + ':' + wsIdOf(root);
+    const isOff = AG.off(O.JOB, { env, settingsDir: rt });
+    if (isOff) return fail(isOff + ': nothing drafted. pmos ai on outcomes turns it back on.');
+    let replayed = null;
+    if (!AG.ready(rt, O.JOB, version)) {
+      const cases = require('./outcome-props.js').cases(S, drafts).map((c, i) => (i === 0 ? { ...c, run: async () => drafts.slice(0, max), expect: { filed: Math.min(max, drafts.length) } } : c));
+      replayed = await AG.replay(O.JOB, version, cases, { root, stateDir: rt, max });
+      if (!replayed.ok) return fail('the replay on this repository\'s records did not pass, so nothing shows:\n' + replayed.failed.map((f) => '  - ' + f.name + ': ' + f.why).join('\n'));
+    }
+    let shown = [];
+    const r = await AG.file({ job: O.JOB, version, run: 'cli' + now.toString(36), root, stateDir: rt, settingsDir: rt, env, max }, drafts.slice(0, max), async (acc) => { shown = acc; });
+    if (r.error) return fail(r.error);
+    if (flags.json) { say(JSON.stringify({ ok: true, drafts: shown, dropped: r.dropped, more: Math.max(0, drafts.length - max), ask, replayed: replayed ? replayed.ok : null })); return 0; }
+    if (replayed) say('✓ replayed on this repository\'s records first: every draft cites a line that says it.');
+    for (const p of shown) say(draftText(p));
+    if (r.dropped.length) say(`(${r.dropped.length} dropped by the guard: ${r.dropped.map((d) => d.id).join(', ')})`);
+    const more = drafts.length - Math.min(max, drafts.length);
+    if (more > 0) say(`${more} more to draft: run pmos outcomes propose again after these.`);
+    if (askText) say(askText);
+    return 0;
+  }
+
+  const id = pos[0];
+  const actor = require('./actor.js').fromCli({ isTTY: isTTY === undefined ? !!(process.stdin.isTTY && process.stdout.isTTY) : isTTY, env });
+
+  if (sub === 'declare') {
+    if (!id || pos.length > 1) return fail('usage: pmos outcomes declare <id> --metric "<text>" --horizon <YYYY-MM-DD>', 2);
+    const r = require('./initiative-writer.js').setOutcome(root, id, { metric: flags.metric, horizon: flags.horizon }, { actor, today });
+    if (!r.ok) return fail(r.error, r.status === 400 ? 2 : 1);
+    if (flags.json) { say(JSON.stringify({ ok: true, id, metric: r.metric, horizon: r.horizon, from: r.from, same: !!r.same })); return 0; }
+    say(r.same ? `${id} already expects that, checked on ${O.short(r.horizon)}.` : `✓ ${id} expects: ${r.metric} · check on ${O.short(r.horizon)}. Commit the record to keep it.`);
+    return 0;
+  }
+
+  // record
+  if (!id || pos.length !== 2) return fail('usage: pmos outcomes record <id> <worked|didnt-work|cant-tell> --evidence "<text>"', 2);
+  const disposition = VERDICT[String(pos[1]).toLowerCase()];
+  if (!disposition) return fail('the verdict is worked, didnt-work or cant-tell (or validated, refuted, inconclusive)', 2);
+  const r = O.recordCheck(root, { initiative: id, disposition, evidence: flags.evidence, by: actor.by, via: actor.via }, { now });
+  if (!r.ok) return fail(r.error);
+  if (flags.json) { say(JSON.stringify({ ok: true, file: r.file, line: r.line })); return 0; }
+  say(`✓ ${id}: ${disposition} — ${r.line.evidence} (${r.file}). Commit it to keep it.`);
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE, VERDICT };

package/workspace/lib/outcomes.js

@@ -0,0 +1,312 @@
+'use strict';
+/* outcomes.js — no initiative without an outcome (initiative outcome-for-every-initiative; D57). THE PURE-ISH CORE of `pmos outcomes`:
+ * it reads the records and drafts the ✦ proposals; lib/outcomes-cli.js prints them, and every proposal passes lib/ai-guard.js first.
+ *
+ * D57 lets an initiative declare `outcome_metric` (what should move once it ships) and `outcome_horizon` (the date to check it), and the
+ * outcome ledger takes the PM's verdict. On real data almost nothing used it (2026-11-03: 10 of 62 product initiatives named an outcome,
+ * 8 had a date, 0 were checked; 3 checks were overdue). The field was optional and nothing asked for it. This module makes Claude ask:
+ *
+ *   scan(root, { today })  → { subjects, missing (newest first), recent (how many of them were edited in the last 30 days), undated, due, pending, disposed, shippedWithout, notRead }
+ *       every WORK initiative of the repository (document lanes are files, D86) that is not stopped. `missing` is a live one (not accepted)
+ *       with no outcome_metric; `shippedWithout` counts the accepted ones with none (too late to declare, only counted).
+ *   drafts(root, S, { today, only? }) → [proposal]   ranked: due checks, then undated outcomes, then missing outcomes
+ *       due       ✦ "Check the outcome": the record's metric and date lines cited; the PM says validated | refuted | inconclusive.
+ *       undated   ✦ a check date for a declared metric.
+ *       missing   ✦ an outcome AND a check date. The metric comes from the PRD's success criteria (the first item under a heading that
+ *                 names success, outcome, metric, goal or signal), else from the anchor's line in the OKR files or the health budgets.
+ *                 With neither, there is nothing to cite, so there is no proposal: the item is listed under `ask` for the PM to name.
+ *       The date is DAYS_AFTER days after the latest due date of the initiative's tasks (that task line cited), else DEFAULT_DAYS from today.
+ *   Every proposal is the ai-guard shape { id, title, say, confidence, claims: [{ text, sources: [{ label, ref, quote }] }], data }, where
+ *   ref is path:line from the repository root and quote is that line's text. data = { kind, initiative, metric?, horizon? }: what
+ *   `pmos outcomes declare` / `record` write once the PM says yes. Nothing here writes.
+ *
+ *   setOutcome lives in lib/initiative-writer.js (the one writer of a record); recordCheck below is the one writer of an outcome line
+ *   from `pmos outcomes record` (the same ledger kit/scripts/pmos-log.sh outcome and scripts/record-outcome.js append to).
+ */
+const fs = require('fs');
+const path = require('path');
+
+const VERSION = 'outcomes-1';
+const JOB = 'outcomes';
+const DAY = 86400000;
+const DAYS_AFTER = 30;
+const DEFAULT_DAYS = 90;
+const RECENT_DAYS = 30;
+const DISPOSITIONS = Object.freeze(['validated', 'refuted', 'inconclusive']);
+const HEADING = /^#{2,3}\s+.*\b(success|outcome|metric|goal|signal)/i;
+const ID_RE = /^[a-z0-9][a-z0-9._-]*$/;
+
+const rel = (root, f) => path.relative(root, f).split(path.sep).join('/');
+const cut = (s, n = 400) => { const t = String(s == null ? '' : s).replace(/\s+$/, ''); return t.length > n ? t.slice(0, n) : t; };
+const clip = (s, n) => { const t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); if (t.length <= n) return t; const c = t.slice(0, n - 1); return (c.slice(0, c.lastIndexOf(' ')) || c).replace(/[,;:\s]+$/, '') + '…'; };
+const isDate = (s) => /^\d{4}-\d{2}-\d{2}$/.test(String(s || ''));
+const addDays = (day, n) => new Date(Date.parse(day + 'T00:00:00Z') + n * DAY).toISOString().slice(0, 10);
+const todayOf = (now = Date.now()) => new Date(now).toISOString().slice(0, 10);
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const short = (d) => { const t = new Date(Date.parse(d + 'T00:00:00Z')); return Number.isFinite(t.getTime()) ? t.getUTCDate() + ' ' + MON[t.getUTCMonth()] + ' ' + t.getUTCFullYear() : String(d); };
+const unquote = (v) => { const t = String(v || '').trim(); return /^".*"$/.test(t) ? t.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\') : /^'.*'$/.test(t) ? t.slice(1, -1) : t; };
+
+function layoutOf(root) {
+  try { const l = require('./console-state').loadEngine(); if (l.ok) return l.engine.layout(root); } catch { /* fall through */ }
+  const kit = fs.existsSync(path.join(root, 'pmos', 'state'));
+  return { root, kit, initiatives: kit ? path.join(root, 'pmos', 'state', 'initiatives') : path.join(root, 'planning', 'initiatives'), runsDir: kit ? path.join(root, 'pmos', 'state') : path.join(root, 'planning', 'runs') };
+}
+
+function linesOf(file) { try { return fs.readFileSync(file, 'utf8').split('\n'); } catch { return null; } }
+
+/** The leading frontmatter as { key: { value, n (1-based line), text } }. */
+function frontOf(L) {
+  const out = {};
+  if (!L || !/^---\s*$/.test(L[0] || '')) return out;
+  for (let i = 1; i < L.length && i < 200; i++) {
+    if (/^---\s*$/.test(L[i])) break;
+    const m = /^([A-Za-z_][A-Za-z0-9_]*):[^\S\n]*(.*)$/.exec(L[i]);
+    if (m && !(m[1] in out)) out[m[1]] = { value: unquote(m[2]), n: i + 1, text: L[i] };
+  }
+  return out;
+}
+
+function jsonRows(file) {
+  const L = linesOf(file); if (!L) return [];
+  const out = [];
+  for (const s of L) { if (!s.trim()) continue; try { const o = JSON.parse(s); if (o && typeof o === 'object') out.push(o); } catch { /* torn */ } }
+  return out;
+}
+/** A ledger from the runs folder and, in a kit tree, the state folder too (as lib/today.js readLedger does), each file once. */
+function ledger(root, L, name) {
+  const files = [...new Set([path.join(L.runsDir, name), path.join(root, 'pmos', 'state', name), path.join(root, 'planning', 'runs', name)])];
+  return files.flatMap(jsonRows);
+}
+
+const STOPPED = new Set(['paused', 'cancelled', 'canceled', 'stopped', 'dropped', 'archived', 'killed']);
+function workGroup(root) { try { return require('./initiative-rows.js').workGroupOf(root) || {}; } catch { return {}; } }
+
+/** Every subject of the outcome rule in this repository, read from the records and ledgers (no derivation, no git). */
+function scan(root, { today = todayOf() } = {}) {
+  root = path.resolve(root);
+  const L = layoutOf(root);
+  const notRead = [];
+  let files = [];
+  try { files = fs.readdirSync(L.initiatives).filter((f) => f.endsWith('.md')).sort(); } catch { notRead.push('the initiative records'); }
+  const groups = workGroup(root);
+  const accepted = new Set();
+  for (const a of ledger(root, L, 'acceptances.jsonl')) {
+    if (!a || !a.initiative_id) continue;
+    const act = String(a.action || '').toLowerCase();
+    if (a.accepted === true || ['accept', 'approve', 'merge', 'publish'].includes(act)) accepted.add(String(a.initiative_id));
+  }
+  const life = new Map();
+  for (const r of ledger(root, L, 'lifecycle.jsonl')) if (r && typeof r.initiative_id === 'string' && r.state) life.set(r.initiative_id, String(r.state).toLowerCase());
+  let deleted = new Set();
+  try { const D = require('./ini-deleted.js'); if (typeof D.idsOf === 'function') deleted = new Set(D.idsOf(root)); } catch { /* none */ }
+  const disposedBy = new Map();
+  for (const c of ledger(root, L, 'outcome_checks.jsonl')) if (c && c.initiative_id && DISPOSITIONS.includes(c.disposition)) disposedBy.set(String(c.initiative_id), c);
+
+  const subjects = [], missing = [], undated = [], due = [], pending = [], disposed = [];
+  let shippedWithout = 0;
+  for (const f of files) {
+    const file = path.join(L.initiatives, f);
+    const Ls = linesOf(file); if (!Ls) { notRead.push(rel(root, file)); continue; }
+    const fm = frontOf(Ls);
+    const id = (fm.id && fm.id.value) || f.replace(/\.md$/, '');
+    if (!ID_RE.test(id) || deleted.has(id)) continue;
+    const lane = (fm.lane && fm.lane.value) || (fm.type && fm.type.value !== 'Initiative' ? fm.type.value : '') || 'feature';
+    if (groups[lane] && groups[lane] !== 'work') continue;            // a document lane is a file, not a bet (D86)
+    const st = life.get(id) || (fm.status && fm.status.value ? '' : '');
+    if (STOPPED.has(st)) continue;
+    const it = {
+      id, lane, title: (fm.title && fm.title.value) || id, record: rel(root, file), fm, accepted: accepted.has(id),
+      anchor: fm.parent_kr ? fm.parent_kr.value : '', metric: fm.outcome_metric ? fm.outcome_metric.value : '',
+      horizon: fm.outcome_horizon && isDate(fm.outcome_horizon.value) ? fm.outcome_horizon.value : '',
+      prd: fm.prd_path ? fm.prd_path.value : '',
+    };
+    subjects.push(it);
+    if (!it.metric) { if (it.accepted) shippedWithout++; else missing.push(it); continue; }
+    const d = disposedBy.get(id);
+    if (d) disposed.push({ ...it, disposition: d.disposition });
+    else if (!it.horizon) undated.push(it);
+    else if (it.horizon <= today) due.push(it);
+    else pending.push(it);
+  }
+  due.sort((a, b) => (a.horizon < b.horizon ? -1 : 1));
+  // newest first: the record's timestamp is its last edit. `recent` is what was touched in the last RECENT_DAYS days, where a backfill
+  // starts (an old record with no acceptance line may well have shipped long ago: D94 merges need none).
+  const stamp = (it) => String((it.fm.timestamp || {}).value || '').slice(0, 10);
+  missing.sort((a, b) => stamp(b).localeCompare(stamp(a)) || a.id.localeCompare(b.id));
+  const since = addDays(today, -RECENT_DAYS);
+  const recent = missing.filter((it) => stamp(it) >= since).length;
+  return { root, layout: L, today, subjects, recent, missing, undated, due, pending, disposed, shippedWithout, notRead };
+}
+
+/* ── sources ──────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const src = (root, file, n, text, label) => ({ label, ref: rel(root, file) + ':' + n, quote: cut(String(text).trim()) });
+const recSrc = (S, it, key, label) => { const e = it.fm[key]; return e ? src(S.root, path.join(S.root, it.record), e.n, e.text, label) : null; };
+
+function prdFile(root, it) {
+  const cands = [];
+  if (it.prd) cands.push(path.join(root, it.prd), path.join(root, 'pmos', it.prd));
+  cands.push(path.join(root, 'planning', 'prd', it.id + '-prd.md'), path.join(root, 'pmos', 'planning', 'prd', it.id + '-prd.md'));
+  for (const f of cands) {
+    const abs = path.resolve(f);
+    if (abs !== root && !abs.startsWith(root + path.sep)) continue;
+    try { if (fs.statSync(abs).isFile()) return abs; } catch { /* next */ }
+  }
+  return null;
+}
+
+/** A metric line in text: a list item, or a sentence, stripped of its marker and bold. */
+/** The first sentence: a declared outcome is one claim, not the paragraph around it. */
+const firstSentence = (t) => { const m = /^(.{24,}?[.!?])(\s+[A-Z(“"]|\s*$)/.exec(t); return m ? m[1] : t; };
+const metricText = (line) => clip(firstSentence(String(line).replace(/^\s*(?:[-*+]|\d+[.)])\s+/, '').replace(/\*\*([^*]+)\*\*/g, '$1').replace(/`([^`]+)`/g, '$1').replace(/^R\d+\s*[—–-]\s*/, '').trim()), 220);
+
+/** The first item under the PRD's success heading. → { metric, source } | null */
+function prdMetric(root, it) {
+  const f = prdFile(root, it); if (!f) return null;
+  const Ls = linesOf(f); if (!Ls) return null;
+  for (let i = 0; i < Ls.length; i++) {
+    if (!HEADING.test(Ls[i])) continue;
+    for (let j = i + 1; j < Ls.length && j < i + 40; j++) {
+      const t = Ls[j];
+      if (/^#{1,3}\s/.test(t)) break;
+      if (!t.trim() || /^\s*(>|\||<!--|```)/.test(t) || /^\s*\*[^*].*\*\s*$/.test(t)) continue;
+      const m = metricText(t);
+      if (m.replace(/[^A-Za-z0-9]/g, '').length < 12) continue;
+      return { metric: m, source: src(root, f, j + 1, t, 'PRD: ' + clip(Ls[i].replace(/^#+\s*/, ''), 50)) };
+    }
+  }
+  return null;
+}
+
+/** The anchor's own line in the OKR files or the health budgets. → { metric, source } | null */
+function anchorMetric(root, it) {
+  const a = String(it.anchor || '').trim();
+  // a KR names what should move; a health budget (D59) names only a cap and a review trigger, and a domain names a topic, so neither is cited
+  if (!a || /^(domain|health):/.test(a)) return null;
+  const token = a;
+  const dirs = [path.join(root, 'planning', 'okrs'), path.join(root, 'pmos', 'planning', 'okrs')];
+  for (const d of dirs) {
+    let fl = []; try { fl = fs.readdirSync(d).filter((x) => x.endsWith('.md')).sort(); } catch { continue; }
+    for (const x of fl) {
+      const f = path.join(d, x), Ls = linesOf(f) || [];
+      const i = Ls.findIndex((l) => l.includes(token) && !/^\s*(type|title|timestamp):/.test(l));
+      if (i < 0) continue;
+      const text = Ls[i];
+      const cells = text.split('|').map((c) => c.trim()).filter(Boolean);
+      const words = cells.length > 1 ? cells.filter((c) => !c.includes(token)).sort((p, q) => q.length - p.length)[0] : text.replace(token, '');
+      const m = metricText(String(words || '').replace(/^[:\s—–-]+/, ''));
+      if (m.replace(/[^A-Za-z0-9]/g, '').length < 12) continue;
+      return { metric: 'Moves ' + a + ': ' + m, source: src(root, f, i + 1, text, 'Anchor ' + clip(a, 40)) };
+    }
+  }
+  return null;
+}
+
+/** The latest due date among the initiative's tasks, with that task line. → { due, source } | null */
+function taskDue(root, it, tasks) {
+  let best = null;
+  for (const t of tasks || []) {
+    if (t.initiative !== it.id) continue;
+    for (const l of t.lines || []) if (typeof l.due === 'string' && isDate(l.due.slice(0, 10)) && l.src && (!best || l.due.slice(0, 10) > best.due)) best = { due: l.due.slice(0, 10), source: { label: 'Task: ' + clip(t.title, 50), ref: l.src.ref, quote: l.src.quote } };
+  }
+  return best;
+}
+
+function tasksOf(root) {
+  try {
+    const Facts = require('./drift-facts.js');
+    const stateDir = require('./driver.js').stateDirOf(root);
+    let storeFile = null; try { const s = require('./task-store.js').storeFor(root); storeFile = s && s.file; } catch { storeFile = null; }
+    return Facts.tasksOf(root, stateDir ? path.join(stateDir, 'boards.jsonl') : null, storeFile, []).tasks;
+  } catch { return []; }
+}
+
+/** The check date to propose: DAYS_AFTER after the last task's due date, never sooner than a week from today. */
+function horizonFor(S, it, tasks) {
+  const t = taskDue(S.root, it, tasks);
+  const floor = addDays(S.today, 7);
+  if (t) { const h = addDays(t.due, DAYS_AFTER); return { horizon: h < floor ? floor : h, lastDue: t.due, why: `${DAYS_AFTER} days after its last task is due`, source: t.source }; }
+  return { horizon: addDays(S.today, DEFAULT_DAYS), lastDue: null, why: `${DEFAULT_DAYS} days from today, as it has no task with a due date yet`, source: null };
+}
+
+/* ── drafts ───────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const claim = (text, sources) => ({ text: clip(text, 240), sources: sources.filter(Boolean) });
+
+function dueDraft(S, it) {
+  const p = prdMetric(S.root, it);
+  const claims = [claim(`It expects: ${clip(it.metric, 160)}`, [recSrc(S, it, 'outcome_metric', 'Expected outcome')]),
+    claim(`Its check date was ${short(it.horizon)}`, [recSrc(S, it, 'outcome_horizon', 'Check date')])];
+  if (p) claims.push(claim('The PRD says what success looks like', [p.source]));
+  return {
+    id: `outcome-due:${it.id}`, title: `Check the outcome of ${clip(it.title, 80)}`, confidence: 'medium', claims,
+    say: `Its check date passed on ${short(it.horizon)}. Did "${clip(it.metric, 120)}" happen? Tell me worked, didn't work or can't tell yet, and what shows it, and I'll record it.`,
+    data: { kind: 'due', initiative: it.id, metric: it.metric, horizon: it.horizon },
+  };
+}
+
+function undatedDraft(S, it, tasks) {
+  const h = horizonFor(S, it, tasks);
+  const claims = [claim(`It expects: ${clip(it.metric, 160)}, with no check date`, [recSrc(S, it, 'outcome_metric', 'Expected outcome')])];
+  if (h.source) claims.push(claim(`Its last task is due on ${short(h.lastDue)}`, [h.source]));
+  return {
+    id: `outcome-date:${it.id}`, title: `Set a check date for ${clip(it.title, 80)}`, confidence: h.source ? 'medium' : 'low', claims,
+    say: `It names an outcome but no date to check it, so it can never come due. I suggest checking on ${short(h.horizon)}, ${h.why}.`,
+    data: { kind: 'undated', initiative: it.id, metric: it.metric, horizon: h.horizon },
+  };
+}
+
+function missingDraft(S, it, tasks) {
+  const m = prdMetric(S.root, it) || anchorMetric(S.root, it);
+  if (!m) return null;                                  // nothing to cite: the PM names it (proven-only)
+  const h = horizonFor(S, it, tasks);
+  const claims = [claim(`${m.source.label.startsWith('PRD') ? 'Its PRD' : 'Its anchor'} says: ${m.metric}`, [m.source])];
+  if (h.source) claims.push(claim(`Its last task is due on ${short(h.lastDue)}`, [h.source]));
+  return {
+    id: `outcome-new:${it.id}`, title: `Expected outcome for ${clip(it.title, 80)}`, confidence: claims.length > 1 && m.source.label.startsWith('PRD') ? 'medium' : 'low', claims,
+    say: `It has no expected outcome yet. I suggest: "${m.metric}", checked on ${short(h.horizon)} (${h.why}).`,
+    data: { kind: 'missing', initiative: it.id, metric: m.metric, horizon: h.horizon },
+  };
+}
+
+/** The ✦ drafts for this repository, ranked; `only` limits them to one initiative. → { drafts, ask: [{ id, title }] } */
+function drafts(S, { only = null, tasks } = {}) {
+  const T = tasks || tasksOf(S.root);
+  const pick = (list) => (only ? list.filter((it) => it.id === only) : list);
+  const out = [], ask = [];
+  for (const it of pick(S.due)) out.push(dueDraft(S, it));
+  for (const it of pick(S.undated)) out.push(undatedDraft(S, it, T));
+  for (const it of pick(S.missing)) {
+    const d = missingDraft(S, it, T);
+    if (d) out.push(d); else ask.push({ id: it.id, title: it.title });
+  }
+  return { drafts: out, ask };
+}
+
+/* ── the outcome ledger: the one writer behind `pmos outcomes record` ───────────────────────────────────────── */
+
+/** Append the PM's verdict. Evidence is required for all three (an `inconclusive` with no reason is the cheapest lie). */
+function recordCheck(root, { initiative, disposition, evidence, by, via }, { now = Date.now() } = {}) {
+  root = path.resolve(root);
+  if (typeof initiative !== 'string' || !ID_RE.test(initiative)) return { ok: false, error: 'name the initiative by its id' };
+  if (!DISPOSITIONS.includes(disposition)) return { ok: false, error: `the verdict is one of ${DISPOSITIONS.join(', ')}` };
+  const ev = String(evidence || '').replace(/\s+/g, ' ').trim();
+  if (ev.length < 12) return { ok: false, error: 'say what shows it (--evidence, at least 12 characters): a number, a link or what you saw' };
+  if (ev.length > 1000) return { ok: false, error: 'keep the evidence under 1000 characters' };
+  const S = scan(root, { today: todayOf(now) });
+  const it = S.subjects.find((x) => x.id === initiative);
+  if (!it) return { ok: false, error: `no initiative ${initiative} here (or it is stopped)` };
+  if (!it.metric) return { ok: false, error: `${initiative} declares no expected outcome yet: declare it first (pmos outcomes declare)` };
+  const dir = S.layout.runsDir;
+  const file = path.join(dir, 'outcome_checks.jsonl');
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const st = (() => { try { return fs.lstatSync(file); } catch { return null; } })();
+    if (st && !st.isFile()) return { ok: false, error: 'the outcome ledger is not a plain file — nothing was saved' };
+    const line = { initiative_id: initiative, disposition, evidence: ev, date: todayOf(now), at: new Date(now).toISOString(), by: by || 'agent:unknown', via: via || 'cli' };
+    fs.appendFileSync(file, JSON.stringify(line) + '\n');
+    return { ok: true, file: rel(root, file), line };
+  } catch (e) { return { ok: false, error: 'the outcome ledger could not be written: ' + String((e && e.message) || e).slice(0, 160) }; }
+}
+
+module.exports = { VERSION, JOB, DAYS_AFTER, DEFAULT_DAYS, DISPOSITIONS, scan, drafts, prdMetric, anchorMetric, horizonFor, recordCheck, todayOf, short, frontOf };

package/workspace/lib/pmos-verbs.js

@@ -99,6 +99,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): initiative weekly-drift-check added it through the same table.
   drift: Object.freeze({ module: 'drift-cli.js', run: null, guide: 'what-you-missed.md',
     help: 'pmos drift show|replay|status — the weekly check for quiet drift: what it would show, its replay on your real records, and its last result (pmos drift help)' }),
+  // Not a pm-os-absorb verb (run: null): initiative outcome-for-every-initiative added it through the same table.
+  outcomes: Object.freeze({ module: 'outcomes-cli.js', run: null, guide: 'outcomes.md',
+    help: 'pmos outcomes list|propose|declare|record — every initiative\'s expected outcome and check date: Claude\'s cited drafts, the PM\'s yes, and the verdict when a check is due (pmos outcomes help)' }),
   driver: Object.freeze({ module: 'driver-cli.js', run: null, guide: 'initiative-driver.md',
     help: 'pmos driver propose|status|keep|return|drop|pause|resume|mode … — the Initiative Driver: drafts for you to keep, send back or drop (pmos driver help)' }),
   // Not a pm-os-absorb verb (run: null): initiative horizon-scan added it through the same table; horizon-scan-portfolio added section, propose, setting and --boards.

package/workspace/lib/proposals.js

@@ -15,6 +15,9 @@
  *   dates   one proposal per stage: its late and at-risk tasks to new dates and its plan with them, plus what a moved task's links reach
  *   status  "looks done": the evidence says the work happened
  *   names   tidy names, before → after; the detail cut moves to the task's notes
+ *   outcome the expected outcome and its check date (D57; lib/outcomes.js, filed by lib/outcome-props.js): type new (no outcome yet) or date
+ *           (an outcome with no date). data { metric, horizon }; one item { id: 'outcome', title: the metric, due: the date }. Always section
+ *           'check': its own ✓, never Keep all. ✓ writes the record's outcome_metric and outcome_horizon lines (lib/initiative-writer.js)
  *   grill   what Claude found when it grilled the initiative by itself (lib/grill.js): type = the angle, no items, a next step in data.next;
  *           always section 'check' (its own ✓, never Keep all). 3 show, best rank first; the group's `more` counts the rest
  *
@@ -53,8 +56,8 @@ const crypto = require('crypto');
 
 const LEDGER = 'proposals.jsonl';
 const KINDS = new Set(['epoch', 'look', 'src', 'end', 'propose', 'drop', 'keep', 'undo']);
-const GROUPS = ['found', 'dates', 'status', 'names'];
-const TYPES = { found: ['stage', 'docs', 'tasks', 'link', 'maybe', 'unplaced'], dates: ['stage', 'task'], status: ['done'], names: ['tidy'] };
+const GROUPS = ['found', 'dates', 'status', 'names', 'outcome'];
+const TYPES = { found: ['stage', 'docs', 'tasks', 'link', 'maybe', 'unplaced'], dates: ['stage', 'task'], status: ['done'], names: ['tidy'], outcome: ['new', 'date'] };
 const SOURCES = ['drive', 'docs', 'sheets', 'slides', 'jira', 'calendar', 'notes', 'mail', 'slack', 'confluence', 'chat', 'repo'];
 const SOURCE_NAMES = { drive: 'Drive and Slides', docs: 'Docs', sheets: 'Sheets', slides: 'Slides', jira: 'Jira', calendar: 'Calendar and meeting notes', notes: 'Meeting notes',
   mail: 'Gmail', slack: 'Slack', confluence: 'Confluence', chat: 'Chat', repo: 'This repository' };
@@ -145,7 +148,14 @@ function clean(group, type, input) {
     if (input.since != null) { if (!DAY_RE.test(String(input.since))) return { error: 'since is YYYY-MM-DD' }; data.since = String(input.since); }
   }
   if (group === 'dates' && str(input.stage)) data.stage = one(input.stage, 60);
-  return { prop: { group, type, section, title: one(input.title, LIM.title) || null, why, sources: s.v, items, data } };
+  if (group === 'outcome') {
+    const d = isObj(input.data) ? input.data : {};
+    const metric = one(d.metric, 300), horizon = str(d.horizon);
+    if (metric.length < 8) return { error: 'data.metric is what should move once it ships' };
+    if (!DAY_RE.test(horizon)) return { error: 'data.horizon is the check date, YYYY-MM-DD' };
+    data.metric = metric; data.horizon = horizon;
+  }
+  return { prop: { group, type, section: group === 'outcome' ? 'check' : section, title: one(input.title, LIM.title) || null, why, sources: s.v, items, data } };
 }
 /** The proposal's own id: one per initiative, group, type and key, so a newer run files over the older one. */
 const idOf = (ini, group, type, key) => 'pr-' + hash([ini, group, type, key || ''].join('|'));
@@ -313,7 +323,7 @@ function datesOf(ini, T, o = {}) {
 }
 
 /* ── what r.props carries ── */
-const ORDER = { found: 0, dates: 1, status: 2, names: 3, links: 4, grill: 5 };
+const ORDER = { outcome: -1, found: 0, dates: 1, status: 2, names: 3, links: 4, grill: 5 };
 const GRILL_SHOWN = 3;
 /**
  * One initiative's proposals, as the ✦ and the Viewer draw them, or null when there is nothing to show.

package/workspace/lib/routes-proposals.js

@@ -133,6 +133,11 @@ function applyOne(ctx, p, g, f, ini, x, choices, outbox) {
         if (was) { TL.append(dir, g.actor, { kind: 'unlink', from: l.from, to: l.to }); add({ op: 'unlink', from: l.from, to: l.to, link: { type: was.type, lag: was.lag, source: was.source } }); }
       }
     }
+  } else if (x.group === 'outcome') {
+    // the expected outcome and its check date (lib/outcomes.js): ✓ writes the record's two D57 lines, Undo puts back what was there
+    const d = x.data || {};
+    const r = require('./initiative-writer.js').setOutcome(p.w.root, ini, { metric: d.metric, horizon: d.horizon }, { actor: g.actor });
+    if (r.ok && !r.same) add({ op: 'outcome', from: r.from, to: { metric: r.metric, horizon: r.horizon } });
   } else if (x.group === 'grill') {
     // a grill finding (lib/grill.js): ✓ adds its next step as a task, with the finding and its sources in the notes
     // ✎ on the finding: the PM's own words for the next step (choices[id]) replace Claude's
@@ -296,6 +301,7 @@ const WRITES = {
       else if (w.op === 'prd') { try { const file = path.resolve(p.w.root, w.file), text = fs.readFileSync(file, 'utf8'); if (text.includes(w.to)) { fs.writeFileSync(file, text.split(w.to).join(w.from)); back++; } else kept++; } catch { kept++; } continue; }
       else if (w.op === 'doc' || w.op === 'linked' || w.op === 'ran') { back++; continue; }   // the fold leaves an undone batch out
       else if (w.op === 'outbox') { kept++; continue; }   // a drafted comment waits in the outbox, where the PM drops it
+      else if (w.op === 'outcome') { const r2 = require('./initiative-writer.js').restoreOutcome(p.w.root, k.ini, w.from || {}, w.to || {}, { actor: g.actor }); if (r2.ok && !r2.kept) back++; else kept++; continue; }   // a record edited since keeps its edit
       if (r && r.body && r.body.ok) back++; else kept++;
     }
     PR.append(dir, g.actor, { kind: 'undo', batch: id });

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/bd-prog.js

@@ -10,8 +10,8 @@
  *   readyHtml(m, whole)                     a milestone's readiness as small diamonds, one per initiative it waits on
  *   mergeBoards(list)                       All products: one Board model from every product's model, each row keeping its own product
  *   bandHtml(g, st, o)                      the stage track's program row: tile, title, products, your count, its spread, its next milestones
- *   prodHtml(g, o) · subHtml(name)          a product group's head row (tile, name, goal dots, chevron) and a program's product sub-row
- *   prodCell(g, dots)                       the head's fold button alone (the timeline's product lane, batch 11 item 17); dots replace the goal dots
+ *   prodHtml(g, o) · subHtml(name)          a product group's head row (tile and name open the product, goal dots, chevron folds) and a program's product sub-row
+ *   prodCell(g, dots)                       the head's open (tile, name) and fold buttons alone (the timeline's product lane, batch 11 item 17); dots replace the goal dots
  *   goalsFrom(fn) · goalsHtml(name)         the goal dots of a product head, from Home's source (pm/home-list.js goalsOf); fn(name) gives its rows
  *
  * A program has no stage of its own (PM, 2026-10-23): the band shows only what its initiatives say. With one product picked, the program shows
@@ -173,9 +173,14 @@ export function prodHtml(g, cls = 'bt-prd') {
 /** The fold button of a product head alone: the timeline's product lane (batch 11 item 17, PlmA1Board) puts it in the name cell, its track beside it. */
 export function prodCell(g, dots) {
   // the calm timeline (batch 13 item 4) passes its own dots: none while open, one per initiative off track while folded
+  // the tile and name open the product's page in the Viewer (batch 26 item 3, as Home's header and a program's title do); the rest folds
   const open = !folded(g.key), gl = dots !== undefined ? dots : open ? goalsHtml(g.name) : '';
-  return `<button type="button" class="bd-prdb" data-fold="${esc(g.key)}" aria-expanded="${open}" aria-label="${esc(g.name)}, ${g.rows.length} ${plural(g.rows.length, 'initiative', 'initiatives')}. ${open ? 'Fold' : 'Show'}">${tileHtml(g.name)}<span>${esc(g.name)}</span>${gl}${open || dots !== undefined ? '' : `<span class="n">${g.rows.length}</span>`}${SV(open ? CHEV_D : CHEV_R)}</button>`;
+  return `<span class="bd-prdb">${prodOpen(g, 'bd-prdo')}<button type="button" class="bd-prdf" data-fold="${esc(g.key)}" aria-expanded="${open}" aria-label="${esc(g.name)}, ${g.rows.length} ${plural(g.rows.length, 'initiative', 'initiatives')}. ${open ? 'Fold' : 'Show'}" title="${open ? 'Fold' : 'Show'}">${gl}${open || dots !== undefined ? '' : `<span class="n">${g.rows.length}</span>`}${SV(open ? CHEV_D : CHEV_R)}</button></span>`;
 }
+/** A product's workspace, from its rows (All products: each row keeps its own); '' when the rows carry none (the page uses its own board's). */
+export const prodWs = (g) => ((g.rows || []).find((r) => r && r.ws) || {}).ws || '';
+/** A product head's tile and name as one button: it opens that product's page in the Viewer (pm/premium-board.js data-prodopen). */
+export const prodOpen = (g, cls) => `<button type="button" class="${cls}" data-prodopen="${esc(g.name)}" data-prodws="${esc(prodWs(g))}" aria-label="Open ${esc(g.name)}, a product">${tileHtml(g.name)}<span>${esc(g.name)}</span></button>`;
 /** The goal dots of a product's head (PgBoard .gd), from the same source as Home's product header (pm/home-list.js goalsOf): one per KR or
  *  budget its open initiatives anchor to, green on track, amber at risk. With no goal anchored, nothing is drawn. The page sets the rows. */
 let ROWS_OF = null;
@@ -191,11 +196,11 @@ export const subHtml = (name, cls = 'bt-psb') => `<div class="${cls}" role="row"
 export const memberIcon = (programs, id) => { const p = (programs || []).find((x) => x.id === id); return p ? `<span class="bd-pgi" role="img" aria-label="In ${esc(p.title)}" title="In ${esc(p.title)}">${SV(PROG)}</span>` : ''; };
 
 /** A Kanban swimlane's head (PgKanban .lh): a program's tile, title, your count and its next milestones merged into one counted diamond with
- *  the readiness of the first; a product's tile and name. Both fold with the chevron; the program's title opens the program. */
+ *  the readiness of the first; a product's tile and name. Both fold with the chevron; the title opens the program or the product. */
 export function laneHtml(g, st) {
   const open = !folded(g.key);
   const fb = (label) => `<button type="button" class="bd-ib sm bd-fold" data-fold="${esc(g.key)}" aria-expanded="${open}" aria-label="${open ? 'Fold' : 'Show'} ${esc(label)}" title="${open ? 'Fold' : 'Show'}">${SV(open ? CHEV_D : CHEV_R)}</button>`;
-  if (g.kind !== 'program') return `<button type="button" class="bd-lho" data-fold="${esc(g.key)}" aria-expanded="${open}" aria-label="${esc(g.name)}, ${g.rows.length} ${plural(g.rows.length, 'initiative', 'initiatives')}. ${open ? 'Fold' : 'Show'}">${tileHtml(g.name)}<span>${esc(g.name)}</span></button><span class="bd-sp"></span>${open ? goalsHtml(g.name) : ''}${fb(g.name)}`;
+  if (g.kind !== 'program') return `${prodOpen(g, 'bd-lho')}<span class="bd-sp"></span>${open ? goalsHtml(g.name) : ''}${fb(g.name)}`;
   const p = g.program, c = nextCluster(st);
   const ms = c ? `<span class="bd-pm2${c.late ? ' late' : ''}" title="${esc(c.items.map((m) => m.name + (m.day ? ' ' + m.day : '')).join(' · '))}"><i class="bd-dm"></i><b>${esc(c.label)}</b>${esc(c.range)}${readyHtml(c.first, whole(st))}</span>` : '';
   return `<button type="button" class="bd-lho" data-prog="${esc(p.id)}" aria-haspopup="dialog" aria-label="${esc(p.title)}, a program. Open the program">${progTile()}<span>${esc(p.title)}</span></button>${yoursHtml(st)}<span class="bd-sp"></span>${ms}${fb(p.title)}`;