create-pmos 0.508.0 → 0.510.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.508.0",
+  "version": "0.510.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,38 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.510.0",
+      "at": "2026-11-03T14:29:03.666Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1197,
+          "t": "Clean Updates lines: no, one PR number, no repeated title, right group",
+          "s": "Clean Updates lines: no, one PR number, no repeated title, right group",
+          "k": "fix"
+        },
+        {
+          "n": 1199,
+          "t": "A Board product head's name opens its page in the Viewer",
+          "s": "A Board product head's name opens its page in the Viewer",
+          "k": "new"
+        }
+      ]
+    },
+    {
+      "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",
@@ -427,32 +459,6 @@
           "k": "fix"
         }
       ]
-    },
-    {
-      "v": "0.490.0",
-      "at": "2026-11-02T08:52:24.978Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1153,
-          "t": "Sign-in session takes keys; login check names the login",
-          "s": "Sign-in session takes keys; login check names the login",
-          "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@c10daf2f
 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:29:00Z"}
 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:29:00Z"}
 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:29:00Z"}
 status: stable
 ---
 

package/workspace/board-programs-test.js

@@ -99,6 +99,9 @@ process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
     ok('O pressing the band dispatches bd:program with the program id and opens no initiative panel', (await events(p)).join() === 'project-ascent' && await p.evaluate(() => !/Initiative/.test(((window.czViewer && window.czViewer.current()) || {}).kind || '')), JSON.stringify(await events(p)));
     await p.keyboard.press('Escape'); await p.waitForFunction(() => { const v = document.querySelector('#czViewer'); return !v || v.hidden; });
 
+    // batch 26 item 3: a product head's tile and name open its page in Home's Viewer; the chevron is its own button and folds
+    const ph = await p.evaluate(() => { const o = document.querySelector('#ibBody .bt-prd [data-prodopen]'), f = document.querySelector('#ibBody .bt-prd [data-fold]'); return { open: !!o && !o.contains(f) && /^Open IDPF, a product$/.test(o.getAttribute('aria-label')) && !!o.querySelector('.bd-ti'), fold: !!f && f.hasAttribute('aria-expanded') }; });
+    ok('P a product head: the tile and name are one button that opens the product, the fold is a separate button', ph.open && ph.fold, JSON.stringify(ph));
     await p.click('#ibBody .bt-pg [data-fold]');
     const f1 = await p.evaluate(() => ({ kids: document.querySelectorAll('#ibBody .bt-kid').length, band: !!document.querySelector('#ibBody .bt-pg'), exp: document.querySelector('#ibBody .bt-pg [data-fold]').getAttribute('aria-expanded'), st: localStorage.getItem('pmos.board.fold') }));
     ok('F the program group folds to its band row, and the fold is stored', f1.kids === 0 && f1.band && f1.exp === 'false' && /g:project-ascent/.test(f1.st), JSON.stringify(f1));

package/workspace/changelog.json

@@ -1,4 +1,36 @@
 [
+ {
+  "v": "0.510.0",
+  "at": "2026-11-03T14:29:03.666Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1197,
+    "t": "Clean Updates lines: no, one PR number, no repeated title, right group",
+    "s": "Clean Updates lines: no, one PR number, no repeated title, right group",
+    "k": "fix"
+   },
+   {
+    "n": 1199,
+    "t": "A Board product head's name opens its page in the Viewer",
+    "s": "A Board product head's name opens its page in the Viewer",
+    "k": "new"
+   }
+  ]
+ },
+ {
+  "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/guide/programs.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Programs on the Board: All products, groupings and the program panel"
 description: "A program groups initiatives across products. How it shows on the Board (stage track, Kanban, timeline and List), the All products mode, the By product grouping, the program panel and the side panel width."
-timestamp: 2026-11-01
+timestamp: 2026-11-03
 ---
 
 # Programs on the Board
@@ -18,6 +18,7 @@ A cancelled or archived initiative leaves its program's views: the band, the pro
 - The product picker is the same chip and list as on Home (see [Home](home.md)). It shows the tiles of the ticked products, or **All**. When the list closes, the Board shows the ticked products, merged as on All products. The pick is the saved setting that Home and Insights share, so a reload keeps it, and a product that you untick here goes from Home too.
 - An address with `?ws=`, `?board=`, `?all=1` or `?pick=` is a one-off view: the Board shows what the address names and does not change the saved pick. A change in the list saves the pick and opens the Board without those parts.
 - A program comes first. Its band shows the stage spread of its initiatives, the next milestone and how many initiatives are ready for it. Under the band, the initiatives sit under a small heading for each product. Then each product has its own group.
+- A product's group head works like a program's: press the product's tile or name to open its page in Home's Viewer. Press the chevron to fold the group. This works in every view: the stage track, Kanban, the timeline and List. On a shared board, the product's name is plain text.
 - To group by product only, open **Filter** and choose **By product**. A program member then shows a small layers icon and stays under its product in every view, the timeline included. A chip shows while By product is on.
 - **Kanban** shows programs as swimlanes, then products. Press a column header to fold the column to a strip with its count. An empty column starts folded. The Board remembers each fold.
 - The **timeline** draws a program row that brackets its initiatives' bars, on every span. Program milestones are diamonds. Milestones that are close together merge into one diamond with a count.

package/workspace/guide/settings.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Settings in console3: one home for each setting"
 description: "How to open Settings in console3, what each section holds, what the scope tags and the environment notes mean, and where the settings are kept."
-timestamp: 2026-11-01
+timestamp: 2026-11-03
 ---
 
 # Settings in console3: one home for each setting
@@ -70,7 +70,7 @@ Open **Updates**. PMOS asks the npm registry for the latest version at once, and
 Under the update card, **Updates** shows what changed in the published kits. **This week** is open: it is the one you need. A week runs Monday to Sunday. Every earlier week, last week included, is folded into **Archive**. Press **Archive** to list the earlier weeks (**Week of** a date), each with its counts, and press a week to read it. When there is nothing for this week yet, the newest week with changes is the open one.
 
 - Each week has up to three groups: **New** (a feature), **Improved** (a faster or better thing that already existed) and **Fixed** (a problem that is gone). A group with nothing in it is not shown, and a week with nothing to show is not listed.
-- Each line is a bold name and one sentence, copied from the pull request that made the change, with its number at the end. Work that you cannot see in PMOS (notes, tests, run logs) is left out.
+- Each line is a bold name and one sentence, copied from the pull request that made the change, with its number at the end. When the name and the sentence say the same thing, the line shows it once. Work that you cannot see in PMOS (notes, tests, run logs) is left out, and so are notes for the people who build PMOS, such as "[skip publish]" or "(batch 25 item 11)".
 - A week shows **Ready to install** when one of its kits is newer than the version you run.
 - A kit published before PMOS kept the kind of each change has no kind. Its title decides: a word such as "fix" or "no longer" puts it under **Fixed**, and anything else under **Improved**.
 - **What's new** is not a section of its own any more. The button on the update card in **General** opens **Updates**.

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/kit-update.js

@@ -122,12 +122,24 @@ const npxArgs = (src, version, rest) => (src && src.kind === 'local'
   ? ['-y', `--package=${src.path}`, '--', PKG_NAME, ...rest]
   : ['-y', `${PKG_NAME}@${version}`, ...rest]);
 
-/** One changelog entry as the page may show it, or null: a version, a time, and PRs with a number, a summary and, from
- *  kit-changelog format 2, a title. */
+/** One changelog entry as the page may show it, or null: a version, a time, and PRs with a number, a summary, from
+ *  kit-changelog format 2 a title, and from format 3 a kind (k: new, imp, fix or x), which decides New, Improved or Fixed.
+ *  Kits published before kit-changelog dropped "[skip publish]" kept it in the text and lost the PR number to an inline
+ *  "(#123)"; both are repaired here, so every line ends in one muted number. */
+const KINDS = new Set(['new', 'imp', 'fix', 'x']);
+const SKIP_TAG = /\s*\[(?:skip|no)[ -][a-z]+\]/gi;
+const PR_REF = /\s*\(#(\d+)\)/;
+const WORK_TAG = /\s*\((?:batch \d+|canvas |D\d+\b)[^()]*\)\s*$/i;   // "(batch 25 item 11)", "(canvas TplA)", "(D105)": how it was made, not what it does
+const tidy = (t) => t.replace(SKIP_TAG, '').replace(new RegExp(PR_REF.source, 'g'), '').replace(/\s+/g, ' ').trim().replace(WORK_TAG, '').trim();
+function cleanPr(p) {
+  const t = typeof p.t === 'string' ? p.t : '', ref = PR_REF.exec(t) || PR_REF.exec(p.s);
+  const n = Number.isInteger(p.n) ? p.n : ref ? Number(ref[1]) : null;
+  const tt = tidy(t).slice(0, 200), s = tidy(p.s).slice(0, 400);
+  return { n, ...(tt ? { t: tt } : {}), s: s || tt, ...(KINDS.has(p.k) ? { k: p.k } : {}) };
+}
 function cleanEntry(e) {
   if (!e || !validVersion(e.v)) return null;
-  const prs = (Array.isArray(e.prs) ? e.prs : []).filter((p) => p && typeof p.s === 'string' && p.s.trim())
-    .map((p) => ({ n: Number.isInteger(p.n) ? p.n : null, ...(typeof p.t === 'string' && p.t.trim() ? { t: p.t.trim().slice(0, 200) } : {}), s: p.s.trim().slice(0, 400) }));
+  const prs = (Array.isArray(e.prs) ? e.prs : []).filter((p) => p && typeof p.s === 'string' && p.s.trim()).map(cleanPr).filter((p) => p.s);
   return { v: e.v, at: typeof e.at === 'string' && !Number.isNaN(Date.parse(e.at)) ? e.at : null, prs };
 }
 const cleanList = (list) => (Array.isArray(list) ? list.map(cleanEntry).filter(Boolean) : []);

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