create-pmos 0.508.0 → 0.509.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.508.0",
+  "version": "0.509.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {
@@ -32,6 +32,19 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.509.0",
+      "at": "2026-11-03T14:11:23.227Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1198,
+          "t": "No initiative without an expected outcome",
+          "s": "No initiative without an expected outcome",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.508.0",
       "at": "2026-11-03T12:33:41.832Z",
@@ -440,19 +453,6 @@
           "k": "fix"
         }
       ]
-    },
-    {
-      "v": "0.489.0",
-      "at": "2026-11-02T07:07:12.466Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1151,
-          "t": "Background runs can read through connectors; stop on a repeated denied tool",
-          "s": "Background runs can read through connectors; stop on a repeated denied tool",
-          "k": "fix"
-        }
-      ]
     }
   ]
 }

package/payload/AGENTS.md

@@ -33,7 +33,7 @@ It refuses frontmatter, fenced and indented code, table rows, headings, delibera
 
 | Hosted tool (as skills name them) | File-mode equivalent |
 |---|---|
-| `create_initiative` | write `pmos/state/initiatives/<id>.md` (frontmatter: id, title, parent_kr, stage, status, **type** — the D56 lane, default `feature` — plus `intent` for the chore lane, prd_path, rubric_path, created; optionally `outcome_metric` + `outcome_horizon` — the D57 declaration for post-ship success criteria) |
+| `create_initiative` | write `pmos/state/initiatives/<id>.md` (frontmatter: id, title, parent_kr, stage, status, **type** — the D56 lane, default `feature` — plus `intent` for the chore lane, prd_path, rubric_path, created; plus `outcome_metric` + `outcome_horizon` — the D57 declaration for post-ship success criteria. No initiative goes without one: after you create it, and once its PRD exists, run `pmos outcomes propose <id>` and show the cited draft; write it with `pmos outcomes declare` only after the PM's yes) |
 | `save_spec` | the PRD file itself at `pmos/planning/prd/<id>-prd.md` (set `prd_path` on the initiative file) |
 | `get_spec` / `get_planning_artifact` | read `pmos/planning/…` |
 | `get_skill` | read `pmos/skills/<name>.skill` |

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@c4e0e4ba
+kernel-source: pmos@be5277db
 assembled: 2026-11-03
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T14:11:20Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T14:11:20Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T14:11:20Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "v": "0.509.0",
+  "at": "2026-11-03T14:11:23.227Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1198,
+    "t": "No initiative without an expected outcome",
+    "s": "No initiative without an expected outcome",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.508.0",
   "at": "2026-11-03T12:33:41.832Z",

package/workspace/guide/index.md

@@ -80,6 +80,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [Breakdown › Timeline](timeline.md): an initiative's items on a time axis, split by stage, with milestones, today, and the at-risk flag when an item starts before its predecessor ends.
 - [Initiatives › Timeline](initiatives-timeline.md): when each initiative runs, one row per initiative, and how to reorder rows by their grip.
 - [Workflows](workflows.md): Settings › Workflows, the stages each kind of initiative goes through, New workflow in the chat, and `pmos workflow`.
+- [Expected outcomes](outcomes.md): every initiative says what should change once it ships and when to check it. Claude drafts each one from the PRD or the KR, you keep it with ✓, and `pmos outcomes`.
 - [Rehearse a plan](rehearse.md): before you approve a date change or a cut, Claude shows what it breaks or helps in other initiatives, goals and program milestones, with the record each effect comes from, and `pmos rehearse`.
 - [Forecasts](forecast.md): how a goal, a delivery, a program and a health budget are forecast, the states, the kept baseline, and `pmos forecast`.
 - [Programs on the Board](programs.md): All products, programs first then products, By product, the program panel and its milestones, and the 60 % side panels.

package/workspace/guide/outcomes.md

@@ -0,0 +1,39 @@
+---
+type: Guide
+title: "Expected outcomes"
+description: "Every initiative says what should change once it ships and the date to check it. How Claude drafts them, how you keep one, how a due check is recorded, and the pmos outcomes commands."
+timestamp: 2026-11-03
+---
+
+# Expected outcomes
+
+Every initiative has an expected outcome: what should change once it ships, and the date to check it. Shipping is not the end. The check date is when you look at whether it worked.
+
+## Claude drafts it
+
+You do not type it. Once a day Claude reads each product and drafts the outcome of every initiative that has none, and a check date for an outcome that has no date.
+
+- **The outcome** comes from the PRD's success criteria: the first item under a heading that names success, outcome, metric, goal or signal. When there is no such PRD, it comes from the KR the initiative is anchored to.
+- **The check date** is 30 days after the last task of the initiative is due. When no task has a due date yet, it is 90 days from today.
+- **Nothing to cite, no draft.** When there is no PRD success item and no KR, Claude does not guess. It asks you in the chat what should change.
+
+Each draft waits under the initiative's ✦ in the Viewer, in its own group, Expected outcome. It shows the lines it comes from. ✓ keeps it: the outcome and the date are written to the initiative's record. ✕ drops it, and it does not come back unless what it rests on changes. Undo puts back what was there.
+
+A new initiative gets its draft at the next daily read after its PRD or its tasks give Claude something to cite. At most 3 drafts a day per product show, so a backfill stays quiet.
+
+## When a check is due
+
+When the check date passes, Today shows the check. Tell Claude whether it worked, did not work, or you cannot tell yet, and what shows it: a number, a link or what you saw. Claude records your verdict with the evidence. A verdict is always yours. Claude never records one from a metric alone.
+
+## Switch it off
+
+`pmos ai off outcomes` stops the drafts, and `pmos ai on outcomes` starts them again. `PMOS_OUTCOMES=off` stops the daily read.
+
+## The commands
+
+Run them in the product's repository, or pass `--root <dir>`.
+
+- `pmos outcomes list` shows the checks that are due, the outcomes with no date and the initiatives with no outcome. It changes nothing.
+- `pmos outcomes propose [<id>]` shows Claude's drafts, each with the lines it cites. Before the first draft of a repository it replays them on that repository's records, and shows nothing unless the replay passes.
+- `pmos outcomes declare <id> --metric "<text>" --horizon <YYYY-MM-DD>` writes the outcome and its check date, after you said yes.
+- `pmos outcomes record <id> <worked|didnt-work|cant-tell> --evidence "<text>"` records your verdict on a due check.

package/workspace/lib/initiative-cli.js

@@ -149,7 +149,9 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     const r = writer.createInitiative(root, input, { actor, now });
     if (!r.ok) return fail(r.error);
     startOnDefault(root, r, actor);
-    return done({ id: r.id, path: r.path }, `✓ ${r.id} added at the end of the Roadmap (${r.path}). Commit the record to keep it.`);
+    // no initiative without an expected outcome (outcome-for-every-initiative): say what Claude drafts next, or that the PM names it
+    return done({ id: r.id, path: r.path }, `✓ ${r.id} added at the end of the Roadmap (${r.path}). Commit the record to keep it.\n`
+      + `✦ It needs an expected outcome and a date to check it. Claude drafts them from the PRD's success criteria once it is written (pmos outcomes propose ${r.id}); until then, ask the PM what should change once it ships.`);
   }
 
   if (verb === 'list') {

package/workspace/lib/initiative-writer.js

@@ -247,6 +247,57 @@ function writeAnchor(root, id, text0) {
   return { ok: true, id, from, anchor: text0 };
 }
 
+/** D57's two lines on a record: `outcome_metric` (what should move) and `outcome_horizon` (the date to check it). The PM's yes to a ✦
+ *  from `pmos outcomes propose` reaches here through `pmos outcomes declare` (lib/outcomes-cli.js). Only those two lines change; a line
+ *  that is not there yet is added at the end of the front matter. → { ok: true, id, from: { metric, horizon }, metric, horizon } | refusal */
+function setOutcome(root, id, { metric, horizon } = {}, { actor, today } = {}) {
+  if (!actorLib.valid(actor)) return refuse(500, 'initiative-writer: the caller must pass the actor from pm-guard.js or actor.js');
+  const m = typeof metric === 'string' ? metric.replace(/\s+/g, ' ').trim() : '';
+  if (!m || !ONE_LINE(m, 300) || m.length < 8) return refuse(400, 'say what should move once it ships, in one line of 8 to 300 characters', 'metric');
+  const h = typeof horizon === 'string' ? horizon.trim() : '';
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(h) || Number.isNaN(Date.parse(h + 'T00:00:00Z'))) return refuse(400, 'the check date is YYYY-MM-DD', 'horizon');
+  if (h < (today || new Date().toISOString().slice(0, 10))) return refuse(400, `the check date ${h} has passed already: pick a date from today on`, 'horizon');
+  const f = recordFile(root, id);
+  if (!f.ok) return f;
+  const text = fs.readFileSync(f.file, 'utf8');
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/.exec(text);
+  if (!fm) return refuse(409, `the record of ${id} has no front matter — nothing was saved`, 'id');
+  const lines = fm[1].split(/\r?\n/);
+  const from = {};
+  for (const [key, val, name] of [['outcome_metric', m, 'metric'], ['outcome_horizon', h, 'horizon']]) {
+    const at = lines.findIndex((l) => l.startsWith(key + ':'));
+    from[name] = at >= 0 ? unquote(lines[at].slice(key.length + 1)) : '';
+    const line = `${key}: ${name === 'horizon' ? val : q(val)}`;
+    if (at >= 0) lines[at] = line; else lines.push(line);
+  }
+  if (from.metric === m && from.horizon === h) return { ok: true, id, from, metric: m, horizon: h, same: true };
+  try { fs.writeFileSync(f.file, '---\n' + lines.join('\n') + '\n---' + fm[2] + text.slice(fm[0].length), { flag: 'w' }); } catch { return refuse(500, 'the record could not be written — nothing was saved'); }
+  return { ok: true, id, from, metric: m, horizon: h };
+}
+
+/** The Undo of a ✓ on an outcome ✦: the two lines back to `from` (a line that was not there is removed), only while they still say `to`.
+ *  A record the PM edited since keeps its edit (→ { ok: true, kept: true }). */
+function restoreOutcome(root, id, from = {}, to = {}, { actor } = {}) {
+  if (!actorLib.valid(actor)) return refuse(500, 'initiative-writer: the caller must pass the actor from pm-guard.js or actor.js');
+  const f = recordFile(root, id);
+  if (!f.ok) return f;
+  const text = fs.readFileSync(f.file, 'utf8');
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/.exec(text);
+  if (!fm) return refuse(409, `the record of ${id} has no front matter — nothing was saved`, 'id');
+  let lines = fm[1].split(/\r?\n/);
+  const val = (key) => { const l = lines.find((x) => x.startsWith(key + ':')); return l ? unquote(l.slice(key.length + 1)) : ''; };
+  if (val('outcome_metric') !== String(to.metric || '') || val('outcome_horizon') !== String(to.horizon || '')) return { ok: true, id, kept: true };
+  for (const [key, v, name] of [['outcome_metric', from.metric, 'metric'], ['outcome_horizon', from.horizon, 'horizon']]) {
+    const at = lines.findIndex((l) => l.startsWith(key + ':'));
+    if (!v) { if (at >= 0) lines.splice(at, 1); continue; }
+    const line = `${key}: ${name === 'horizon' ? v : q(v)}`;
+    if (at >= 0) lines[at] = line; else lines.push(line);
+  }
+  lines = lines.filter((l, i) => l !== '' || i < lines.length - 1);
+  try { fs.writeFileSync(f.file, '---\n' + lines.join('\n') + '\n---' + fm[2] + text.slice(fm[0].length), { flag: 'w' }); } catch { return refuse(500, 'the record could not be written — nothing was saved'); }
+  return { ok: true, id };
+}
+
 function withdrawSplit(root, id, want, { actor } = {}) {
   if (!actorLib.valid(actor)) return refuse(500, 'initiative-writer: the caller must pass the actor from pm-guard.js or actor.js');
   const f = recordFile(root, id);
@@ -258,4 +309,4 @@ function withdrawSplit(root, id, want, { actor } = {}) {
   return { ok: true, removed: true };
 }
 
-module.exports = { createInitiative, renameInitiative, setAnchor, restoreAnchor, withdrawSplit, recordSha, slugOf, ID_RE, INPUT_KEYS };
+module.exports = { setOutcome, restoreOutcome, createInitiative, renameInitiative, setAnchor, restoreAnchor, withdrawSplit, recordSha, slugOf, ID_RE, INPUT_KEYS };

package/workspace/lib/outcome-props.js

@@ -0,0 +1,120 @@
+'use strict';
+/* outcome-props.js — Claude drafts every missing expected outcome by itself (initiative outcome-for-every-initiative; lib/outcomes.js).
+ *
+ *   create(deps) → { tick({ now }), runProduct(w, { now }) }
+ *   cases(S, drafts) → the replay cases of one product (lib/ai-guard.js replay)
+ *
+ * Once a day per product, in the hours the PM allows (deps.open), the server reads each product's records (lib/outcomes.js scan) and files
+ * what it drafts under the initiative's blue ✦ (lib/proposals.js group `outcome`): an expected outcome and a check date for an initiative
+ * that has none, or a check date for an outcome that has no date. A new initiative is drafted at the next tick, so "at creation" means within
+ * the tick after its PRD or its tasks give Claude something to cite (the PM chose this on 2026-11-03: Claude drafts at creation, no refusal).
+ * No model and no session: the drafts are the PRD's and the KR's own words, each claim cited with path:line and that line's text.
+ *
+ * THE DOOR. Every draft goes through lib/ai-guard.js file(): the kill switch (PMOS_AI, PMOS_AI_OUTCOMES, Settings), the citation check and the
+ * audit. Its replay gate is per product (version `outcomes-1:<ws>`): before a product's first filing the server replays the drafts on that
+ * product's real records, with the guard's planted fabrications, and files nothing until that passed. The audit and the replay record live in
+ * the per-user runtime folder, never in the repository.
+ *
+ * WHAT IT WRITES: `propose` lines in the product's proposals.jsonl, at most PER_DAY a day per product (quiet by default; a backfill of 60
+ * takes a few weeks of mornings, or `pmos outcomes propose` in a sitting). A draft the PM dropped (✕) or kept is not filed again. When a
+ * record has its outcome by another way (`pmos outcomes declare`, an edit), the open draft is dropped. It never writes a record: only the PM's ✓.
+ *
+ * deps: { workspaces() → [w], isLead(w), stateDirFor(w), boardOf(w, id) → board id | null, runtime() → the per-user state folder, open(now),
+ *         env, every (ms, its own timer), mayRun(), warn(what, err) }
+ */
+const crypto = require('crypto');
+const O = require('./outcomes.js');
+const PR = require('./proposals.js');
+
+const PER_DAY = 3;
+const flagOff = (v) => /^(off|0|false|no)$/i.test(String(v == null ? '' : v).trim());
+const off = (env) => flagOff((env || process.env).PMOS_OUTCOMES);
+const localDay = (ms) => { const d = new Date(ms); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); };
+const guardLib = () => { try { return require('./ai-guard.js'); } catch { return null; } };
+const versionOf = (w) => O.VERSION + ':' + w.id;
+const typeOf = (d) => (d.data.kind === 'undated' ? 'date' : 'new');
+
+/** The proposals line a draft becomes. */
+function lineOf(d, board, run) {
+  const type = typeOf(d), ini = d.data.initiative;
+  const sources = d.claims.flatMap((c) => c.sources).map((s) => ({ label: s.label, ref: s.ref }));
+  const c = PR.clean('outcome', type, { title: type === 'date' ? 'A date to check the outcome' : 'What should change once it ships', why: d.say, sources,
+    items: [{ id: 'outcome', title: d.data.metric, due: d.data.horizon }], data: { metric: d.data.metric, horizon: d.data.horizon } });
+  if (c.error) return null;
+  return { kind: 'propose', ini, board, run, id: PR.idOf(ini, 'outcome', type, ''), ...c.prop };
+}
+
+/** One product's replay cases: its own drafts must all pass, and an initiative with nothing to cite gets no draft. */
+function cases(S, list) {
+  const out = [{ name: 'the drafts of ' + S.root.split(/[\\/]/).pop(), run: async () => list.slice(0, PER_DAY), expect: { filed: Math.min(PER_DAY, list.length) } }];
+  out.push({ name: 'nothing to cite, no draft', run: async () => O.drafts({ ...S, due: [], undated: [], missing: [{ id: 'zz-no-source', title: 'No source', fm: {}, prd: '', anchor: '' }] }, { tasks: [] }).drafts, expect: { none: true } });
+  return out;
+}
+
+function create(deps) {
+  const warn = deps.warn || (() => {});
+  const lastDay = new Map();   // ws id → the local day it ran
+  let busy = false;
+
+  async function runProduct(w, { now = Date.now() } = {}) {
+    const dir = deps.stateDirFor(w); if (!dir) return { ws: w.id, filed: 0, why: 'no state folder' };
+    const rt = deps.runtime && deps.runtime();
+    const S = O.scan(w.root, { today: localDay(now) });
+    const F = PR.read(dir), kept = PR.keptIds(F);
+    // a record that has its outcome now: its open draft goes (zero is silence)
+    const has = new Map(S.subjects.map((it) => [it.id, it]));
+    for (const p of F.props.values()) {
+      if (p.group !== 'outcome' || kept.has(p.id)) continue;
+      const it = has.get(p.ini), sig = PR.sigOf(p);
+      if (F.drops.has(sig)) continue;
+      if (!it || (it.metric && (p.type === 'new' || it.horizon))) PR.append(dir, { by: 'pmos:outcomes' }, { kind: 'drop', ini: p.ini, sig });
+    }
+    const D = O.drafts(S).drafts.filter((d) => d.data.kind === 'missing' || d.data.kind === 'undated');
+    const fresh = [];
+    for (const d of D) {
+      const board = deps.boardOf(w, d.data.initiative); if (!board) continue;
+      const l = lineOf(d, board, ''); if (!l) continue;
+      const prev = F.props.get(l.id);
+      if (kept.has(l.id)) continue;
+      if (prev && (F.drops.has(PR.sigOf(prev)) || (prev.type === l.type && prev.data && prev.data.metric === l.data.metric))) continue;   // dropped for good, or filed already (a default date that moves a day is not news)
+      fresh.push({ d, board });
+    }
+    if (!fresh.length) return { ws: w.id, filed: 0 };
+    const AG = guardLib(); if (!AG) return { ws: w.id, filed: 0, why: 'the shared guard is not installed' };
+    const version = versionOf(w), run = 'oc' + now.toString(36) + crypto.randomBytes(3).toString('hex');
+    if (!AG.off(O.JOB, { env: deps.env || process.env, settingsDir: rt }) && !AG.ready(rt, O.JOB, version)) {
+      const rep = await AG.replay(O.JOB, version, cases(S, fresh.map((x) => x.d)), { root: w.root, stateDir: rt, max: PER_DAY });
+      if (!rep.ok) { warn('outcomes replay ' + w.id, new Error(rep.failed.map((f) => f.name + ': ' + f.why).join('; '))); return { ws: w.id, filed: 0, replay: rep }; }
+    }
+    const byId = new Map(fresh.map((x) => [x.d.id, x]));
+    const r = await AG.file({ job: O.JOB, version, run, root: w.root, stateDir: rt, settingsDir: rt, env: deps.env || process.env, max: PER_DAY }, fresh.map((x) => x.d),
+      async (acc) => { for (const p of acc) { const x = byId.get(p.id); const l = x && lineOf(x.d, x.board, run); if (l) PR.append(dir, { by: 'agent:outcomes' }, l); } });
+    return { ws: w.id, filed: (r.filed || []).length, held: !!r.held, off: r.off || null };
+  }
+
+  async function tick({ now = Date.now() } = {}) {
+    if (off(deps.env) || busy) return { off: off(deps.env), running: busy };
+    let open = true;
+    try { open = deps.open ? !!deps.open(now) : true; } catch { open = true; }
+    if (!open) return { closed: true };
+    busy = true;
+    const out = [];
+    try {
+      const day = localDay(now);
+      for (const w of deps.workspaces()) {
+        if (lastDay.get(w.id) === day) continue;
+        try { if (deps.isLead && !deps.isLead(w)) continue; } catch { continue; }
+        lastDay.set(w.id, day);
+        try { out.push(await runProduct(w, { now })); } catch (e) { warn('outcomes ' + w.id, e); }
+      }
+    } finally { busy = false; }
+    return { ran: out };
+  }
+  if (deps.every > 0) {
+    const t = setInterval(() => { try { if (deps.mayRun && !deps.mayRun()) return; } catch { /* no lock: run */ } tick({}).catch((e) => warn('outcomes tick', e)); }, deps.every);
+    if (t.unref) t.unref();
+  }
+  return { tick, runProduct };
+}
+
+module.exports = { create, cases, lineOf, off, PER_DAY };

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.509.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.508.0",
+      "version": "0.509.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.509.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/ini-props.js

@@ -27,6 +27,7 @@ const I = {
   doc: 'M7 3h7l5 5v13H7zM14 3v5h5', tasks: 'M8 6h12M8 12h12M8 18h12M4 6h.01M4 12h.01M4 18h.01', stage: 'M5 21V4M5 4h12l-2 4 2 4H5',
   link: 'M10 14a4 4 0 0 0 5.66 0l3-3a4 4 0 0 0-5.66-5.66l-1 1M14 10a4 4 0 0 0-5.66 0l-3 3a4 4 0 0 0 5.66 5.66l1-1',
   cal: 'M4 5h16v15H4zM8 3v4M16 3v4M4 10h16', done: 'M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18M8 12l3 3 5-6', name: 'M4 20h4L19 9l-4-4L4 16zM13 7l4 4',
+  goal: 'M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18M12 7a5 5 0 1 0 0 10 5 5 0 0 0 0-10M12 11a1 1 0 1 0 0 2 1 1 0 0 0 0-2',
   ask: 'M4 5h16v11H9l-5 4z', maybe: 'M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18M9.5 9.5a2.5 2.5 0 1 1 3.5 2.3c-.6.3-1 .9-1 1.6M12 17h.01', keep: 'M5 12l5 5 9-10', ignore: 'M5 12h14',
 };
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
@@ -35,7 +36,7 @@ const md = (iso) => { const m = DAY.exec(String(iso || '')); return m ? MON[+m[2
 const span = (a, b) => (a && b && a !== b ? md(a) + ' – ' + md(b) : md(a || b));
 const plural = (n, a, b) => n + ' ' + (n === 1 ? a : b);
 const clip = (s, n) => { s = String(s || ''); return s.length > n ? s.slice(0, n - 1) + '…' : s; };
-const GROUP = { found: 'Found elsewhere', dates: 'Dates', status: 'Looks done', names: 'Names', links: 'Links', grill: 'Claude grilled it' };
+const GROUP = { outcome: 'Expected outcome', found: 'Found elsewhere', dates: 'Dates', status: 'Looks done', names: 'Names', links: 'Links', grill: 'Claude grilled it' };
 
 /* ── the chip and the live look ── */
 export function chipOf(p) {
@@ -93,9 +94,10 @@ const titleOf = (p) => {
   if (p.group === 'found') return p.type === 'stage' ? 'Stage: ' + ((p.data && p.data.stage) || '') : p.type === 'docs' ? plural(n, 'document', 'documents') : p.type === 'tasks' ? plural(n, 'task', 'tasks') : p.type === 'link' ? 'Already in another initiative' : p.type === 'maybe' ? 'Maybe this initiative' : plural(n, 'thing', 'things') + ' not placed';
   if (p.group === 'status') return plural(n, 'task looks', 'tasks look') + ' done';
   if (p.group === 'names') return 'Tidy ' + plural(n, 'name', 'names');
+  if (p.group === 'outcome') return p.type === 'date' ? 'A date to check the outcome' : 'What should change once it ships';
   return '';
 };
-const iconOf = (p) => (p.group === 'found' ? (p.type === 'stage' ? I.stage : p.type === 'docs' ? I.doc : p.type === 'tasks' ? I.tasks : p.type === 'link' ? I.link : I.maybe)
+const iconOf = (p) => (p.group === 'outcome' ? I.goal : p.group === 'found' ? (p.type === 'stage' ? I.stage : p.type === 'docs' ? I.doc : p.type === 'tasks' ? I.tasks : p.type === 'link' ? I.link : I.maybe)
   : p.group === 'dates' ? I.cal : p.group === 'status' ? I.done : p.group === 'names' ? I.name : I.link);
 const ib = (attr, label, icon, cls = '') => `<button type="button" class="pp-ib${cls ? ' ' + cls : ''}" ${attr} aria-label="${esc(label)}" title="${esc(label)}">${SVG(icon, 16, 2.2)}</button>`;
 function itemHtml(p, x) {
@@ -107,6 +109,7 @@ function itemHtml(p, x) {
     else { t = x.title; m = x.other ? 'In ' + x.other.title : x.why || ''; }
   } else if (p.group === 'dates') { t = x.title || x.task; m = (x.from && x.from.due ? md(x.from.due) + ' → ' : '') + span(x.to && x.to.start, x.to && x.to.due) + (x.jira ? ' · Jira: a drafted comment' : '') + (x.ms ? ' · ◇ a promise' : ''); }
   else if (p.group === 'status') { t = x.title || taskTitle(p.ini, x.task); m = x.jira ? 'Jira: a drafted comment' : ''; }
+  else if (p.group === 'outcome') { t = x.title; m = x.due ? 'Check on ' + md(x.due) : ''; }
   else if (p.group === 'names') { t = x.to; m = 'Was: ' + (x.from || '') + (x.jira ? ' · Jira: a drafted comment' : ''); }
   return `<div class="pp-it"><span class="w"><b>${esc(clip(t, 90))}</b>${m ? `<small>${esc(m)}</small>` : ''}</span>${x.sig ? ib(`data-pp-dropit="${esc(x.sig)}"`, 'Leave this one out', I.x) : ''}</div>`;
 }

package/workspace/run-tests.js

@@ -445,8 +445,10 @@ function traceChanges(changes, ctx) {
     return w;
   };
   const users1 = (f) => {
-    // a path or a file name: './x', '/x.js' or 'x.js'. A bare quoted word ('grill') is a string, not a use of lib/grill.js.
-    const re = new RegExp(`[/'"\`]${reEsc(stemOf(f))}\\.m?js['"\`]|/${reEsc(stemOf(f))}['"\`]`);
+    // a path or a file name: './x', '../lib/x', 'lib/x', '/x.js' or 'x.js'. A bare quoted word ('grill') is a string, not a use of lib/grill.js,
+    // and neither is a folder path that ends in the same word ('memory/proposals' in lib/headless.js is not lib/proposals.js: it sent every
+    // change of proposals.js to every suite).
+    const re = new RegExp(`[/'"\`]${reEsc(stemOf(f))}\\.m?js['"\`]|(?:\\.\\.?|\\blib)/(?:[\\w.-]+/)*${reEsc(stemOf(f))}['"\`]`);
     const pathRe = new RegExp(`/${reEsc(stemOf(f))}(?:\\.m?js)?['"\`]`);
     let n = 0;
     for (const g of code) {

package/workspace/server.js

@@ -3092,6 +3092,20 @@ const driftRuns = require('./lib/drift-runs.js').create({
   every: TICK_MS,   // its own tick, as often as the server's; only the server that owns the schedules runs it
   mayRun: () => { try { return scheduleOwner.mayRun(); } catch { return true; } },
   warn: (what, e) => warnWriteFail(what, e) });
+// outcome-for-every-initiative (D57): once a day Claude drafts each missing expected outcome and check date under the ✦ of the initiative,
+// from the success criteria of the PRD or the KR (lib/outcome-props.js, lib/outcomes.js). No session and no model; through the shared guard,
+// its audit in the runtime folder. A ✓ of the PM writes the record. Off with PMOS_OUTCOMES=off or pmos ai off outcomes.
+const outcomeProps = require('./lib/outcome-props.js').create({
+  workspaces: () => [...workspaces.values()],
+  isLead: (w) => isPlanNeedsTree(w),
+  stateDirFor: (w) => stateDirFor(w),
+  boardOf: (w, id) => require('./lib/routes-boards.js').boardIndex(proposalCtx(), w).of(id),
+  runtime: () => STATE,
+  open: (now) => !proactiveLib.inQuietHours(now, proSettings().quiet),
+  env: process.env,
+  every: TICK_MS,
+  mayRun: () => { try { return scheduleOwner.mayRun(); } catch { return true; } },
+  warn: (what, e) => warnWriteFail(what, e) });
 // batch 16 item 6 ("Claude runs the OKRs"): Claude reads each goal with its recipe (lib/metric-read-runs.js) when its cadence comes round, files the
 // value with its source and time, says honestly what it could not read and drafts the fix. A broken limit opens one alert: a bell line only when
 // the goal's notify is push. At most 2 runs at once, one per product. PMOS_METRIC_READ=off.

package/workspace/test-lists/outcome-for-every-initiative.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "outcome-for-every-initiative: every initiative has an expected outcome and a check date. The scan, the cited drafts, the guard and its replay, the daily filer under the ✦, the record writers, pmos outcomes, check-outcomes --root and ✓ / Undo through the routes (lib/outcomes.js, lib/outcome-props.js, lib/outcomes-cli.js, lib/initiative-writer.js setOutcome, lib/proposals.js group outcome, lib/routes-proposals.js).",
+  "modules": ["outcomes.test.js"],
+  "seconds": { "outcomes.test.js": 8 }
+}