create-pmos 0.506.0 → 0.508.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.506.0",
+  "version": "0.508.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,32 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.508.0",
+      "at": "2026-11-03T12:33:41.832Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1196,
+          "t": "Decision memory keeps the guard's audit in the per-user folder",
+          "s": "Decision memory keeps the guard's audit in the per-user folder",
+          "k": "fix"
+        }
+      ]
+    },
+    {
+      "v": "0.507.0",
+      "at": "2026-11-03T12:15:29.445Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1194,
+          "t": "Rehearse a plan before you approve it (pmos rehearse)",
+          "s": "Rehearse a plan before you approve it (pmos rehearse)",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.506.0",
       "at": "2026-11-03T12:09:23.758Z",
@@ -427,32 +453,6 @@
           "k": "fix"
         }
       ]
-    },
-    {
-      "v": "0.488.0",
-      "at": "2026-11-02T06:16:07.264Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1148,
-          "t": "Report Viewer follows the agreed design RfH2 (batch 23 item 3)",
-          "s": "Report Viewer follows the agreed design RfH2 (batch 23 item 3)",
-          "k": "new"
-        }
-      ]
-    },
-    {
-      "v": "0.487.0",
-      "at": "2026-11-02T05:32:30.382Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1147,
-          "t": "Batch 23 feedback",
-          "s": "Batch 23 feedback",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/AGENTS.md

@@ -54,6 +54,8 @@ State files are **append-only**: never rewrite or delete an existing line or ini
 
 **Read current state through `pmos`, never from a ledger line.** A `.jsonl` ledger is a log of changes: a later line replaces an earlier one, so its first line for a task can hold dates that were changed long ago. Read an initiative's tasks, with the state and the start and due day the Board timeline shows, with `pmos task list <initiative> --all` (add `--json` for fields). Read the Board with `pmos board`, and initiatives with `pmos initiative list`. Never quote a date, owner or state that you read from `boards.jsonl` or another ledger by hand. When `pmos` cannot answer, say so; do not fall back to the raw file.
 
+**Rehearse a change before you make it.** When the PM asks you to move a task's dates, change an initiative's end date, or cut a task or an initiative, run `pmos rehearse move|end|cut …` first and show the PM what it prints: what the change breaks and what it helps in other initiatives, goals and program milestones, each with its source. Then wait. Make the change with `pmos task set` or `pmos task state` only after the PM says yes in their own words; a rehearsal is never approval. When it says nothing else moves, say so in one line and go on. When it says rehearsals are off, make the change as asked.
+
 ## Work-type lanes (D56)
 
 Every initiative carries a `type` — the lane picks what the gate requires **before** work; the kernel (anchor — a KR **or** `health:<id>` from `planning/okrs/health-budgets.md` (D59) — eval-before-work in lane-appropriate form, human Acceptance, append-only state) holds in every lane. Unknown/missing type = `feature`, the strictest lane. The enum is closed — never invent a lane; a work shape with no lane escalates to the PM.

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@d606c914
+kernel-source: pmos@c4e0e4ba
 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:09:20Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
 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:09:20Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
 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:09:20Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T12:33:39Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,30 @@
 [
+ {
+  "v": "0.508.0",
+  "at": "2026-11-03T12:33:41.832Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1196,
+    "t": "Decision memory keeps the guard's audit in the per-user folder",
+    "s": "Decision memory keeps the guard's audit in the per-user folder",
+    "k": "fix"
+   }
+  ]
+ },
+ {
+  "v": "0.507.0",
+  "at": "2026-11-03T12:15:29.445Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1194,
+    "t": "Rehearse a plan before you approve it (pmos rehearse)",
+    "s": "Rehearse a plan before you approve it (pmos rehearse)",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.506.0",
   "at": "2026-11-03T12:09:23.758Z",

package/workspace/fixtures/rehearse-replay.json

@@ -0,0 +1,159 @@
+{
+  "_comment": "A recorded snapshot for the rehearse replay cases (lib/rehearse-guard.js). `contents` are the ledger and record files its sources cite; the guard writes them to a temporary folder and computes every source from them, so each effect cites a line that is really there.",
+  "today": "2026-11-03",
+  "tasks": [
+    {
+      "uid": "a1",
+      "title": "Design checkout",
+      "ini": "checkout",
+      "status": "To do",
+      "start": "2026-11-05",
+      "end": "2026-11-10"
+    },
+    {
+      "uid": "a2",
+      "title": "Build checkout",
+      "ini": "checkout",
+      "status": "To do",
+      "start": "2026-11-11",
+      "end": "2026-11-20"
+    },
+    {
+      "uid": "b1",
+      "title": "Launch promo",
+      "ini": "promo",
+      "status": "To do",
+      "start": "2026-11-21",
+      "end": "2026-11-25"
+    },
+    {
+      "uid": "b2",
+      "title": "Promo live",
+      "ini": "promo",
+      "status": "To do",
+      "start": "2026-11-28",
+      "end": "2026-11-28",
+      "milestone": true
+    },
+    {
+      "uid": "J-1",
+      "title": "API change",
+      "ini": "promo",
+      "status": "To do",
+      "start": "2026-11-21",
+      "end": "2026-11-23",
+      "src": "jira"
+    }
+  ],
+  "links": [
+    {
+      "from": "a1",
+      "to": "a2",
+      "type": "fs",
+      "lag": 0
+    },
+    {
+      "from": "a2",
+      "to": "b1",
+      "type": "fs",
+      "lag": 0
+    },
+    {
+      "from": "b1",
+      "to": "b2",
+      "type": "fs",
+      "lag": 0
+    },
+    {
+      "from": "a2",
+      "to": "J-1",
+      "type": "fs",
+      "lag": 0
+    }
+  ],
+  "rows": [
+    {
+      "id": "checkout",
+      "title": "Checkout",
+      "end": "2026-11-22",
+      "anchor": "conv"
+    },
+    {
+      "id": "promo",
+      "title": "Promo",
+      "end": "2026-11-30",
+      "anchor": "conv"
+    }
+  ],
+  "goals": [
+    {
+      "id": "conv",
+      "title": "Checkout conversion",
+      "byAt": "2026-11-29",
+      "moves": [
+        "checkout",
+        "promo"
+      ],
+      "forecast": {
+        "state": "at-risk",
+        "likely": 2.6
+      }
+    }
+  ],
+  "programs": [
+    {
+      "id": "q4",
+      "title": "Q4 holiday",
+      "milestones": [
+        {
+          "id": "m",
+          "name": "Holiday ready",
+          "date": "2026-11-30",
+          "waits": [
+            "promo"
+          ],
+          "done": false
+        }
+      ]
+    }
+  ],
+  "files": {
+    "links": "rehearse-links.jsonl",
+    "krs": "rehearse-krs.jsonl",
+    "programs": "rehearse-programs.jsonl",
+    "records": {
+      "checkout": "rehearse-checkout.txt",
+      "promo": "rehearse-promo.txt"
+    }
+  },
+  "contents": {
+    "rehearse-links.jsonl": [
+      "{\"at\":\"2026-10-20T09:00:00Z\",\"by\":\"pm\",\"kind\":\"link\",\"board\":\"b\",\"ini\":\"checkout\",\"from\":\"a1\",\"to\":\"a2\",\"type\":\"fs\",\"lag\":0,\"source\":\"page\"}",
+      "{\"at\":\"2026-10-20T09:01:00Z\",\"by\":\"pm\",\"kind\":\"link\",\"board\":\"b\",\"ini\":\"promo\",\"from\":\"a2\",\"to\":\"b1\",\"type\":\"fs\",\"lag\":0,\"source\":\"page\"}",
+      "{\"at\":\"2026-10-20T09:02:00Z\",\"by\":\"pm\",\"kind\":\"link\",\"board\":\"b\",\"ini\":\"promo\",\"from\":\"b1\",\"to\":\"b2\",\"type\":\"fs\",\"lag\":0,\"source\":\"page\"}",
+      "{\"at\":\"2026-10-20T09:03:00Z\",\"by\":\"pm\",\"kind\":\"link\",\"board\":\"b\",\"ini\":\"promo\",\"from\":\"a2\",\"to\":\"J-1\",\"type\":\"fs\",\"lag\":0,\"source\":\"chat\"}"
+    ],
+    "rehearse-krs.jsonl": [
+      "{\"rid\":\"conv\",\"metric\":\"Checkout conversion\",\"unit\":\"%\",\"baseline\":2.1,\"target\":3,\"by\":\"2026-11-29\"}"
+    ],
+    "rehearse-programs.jsonl": [
+      "{\"at\":\"2026-10-01T00:00:00Z\",\"kind\":\"program\",\"id\":\"q4\",\"title\":\"Q4 holiday\",\"milestones\":[{\"id\":\"m\",\"name\":\"Holiday ready\",\"date\":\"2026-11-30\",\"waits\":[\"promo\"]}]}"
+    ],
+    "rehearse-checkout.txt": [
+      "---",
+      "type: Initiative",
+      "title: \"Checkout\"",
+      "id: checkout",
+      "parent_kr: conv",
+      "---"
+    ],
+    "rehearse-promo.txt": [
+      "---",
+      "type: Initiative",
+      "title: \"Promo\"",
+      "id: promo",
+      "parent_kr: conv",
+      "---"
+    ]
+  }
+}

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`.
+- [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.
 - [Board](board.md): one Kanban for the items of every initiative, its filters, Release, and `pmos board`.

package/workspace/guide/rehearse.md

@@ -0,0 +1,52 @@
+---
+type: Guide
+title: "Rehearse a plan: what a change breaks or helps, before you approve it"
+description: "How Claude rehearses a date change or a cut before you approve it, what each effect means, where its source comes from, the guardrails, and the pmos rehearse commands."
+timestamp: 2026-11-03
+---
+
+# Rehearse a plan
+
+When you ask Claude in your session to move a task, change an initiative's end date, or cut a task or a whole initiative, Claude first rehearses the change. It shows you what the change breaks and what it helps, and it waits for your yes. The rehearsal changes nothing. There is no button: you approve in your own words, and only then does Claude make the change.
+
+## What a rehearsal shows
+
+Each line is one effect, with the record it comes from under it.
+
+- **✗ Breaks** — something gets worse because of the change:
+  - a task in another initiative moves later, because it waits on the changed task through a task link;
+  - a ◇ milestone moves;
+  - a Jira ticket would have to start later. PMOS cannot move a Jira ticket, so its assignee would have to;
+  - a task would start before a task it waits on allows (a task moved earlier than its link allows);
+  - an initiative's last task now ends after the initiative's end date;
+  - a goal's date falls before the new end of an initiative that moves the goal, or the goal loses an initiative (a cut). The line adds the goal's forecast as it is today ([Forecasts](forecast.md));
+  - a program milestone that waits on the initiative comes after its date, or waits on an initiative you would cut;
+  - a task that waited on a cut task loses what it waited on.
+- **✓ Helps** — something gets better: an initiative or a goal is back in time, a program milestone clears, or a task held by a task you move earlier could start earlier.
+- **· Moves** — the tasks of the same initiative that move with the change, in one line.
+
+When nothing else changes, the rehearsal says so in one line.
+
+A moved task's line gives the date it moves from. When late work before it already pushes it past the Board's date, the line gives both. A task that is already late gets a note with where its due day goes. When a task link names a task no board has any more (it was removed or renamed), the rehearsal leaves that link out and says how many it left out.
+
+## How it decides
+
+The effects are the difference between the plan as it is and the plan with the change. Both are first settled through your approved [task links](workflows.md), so a link that is already broken today is not blamed on the change. Only what a record and the date arithmetic prove is said. A goal effect gives the date fact and today's forecast state; it never estimates a new number. An initiative's work lands when its last open task ends. Its end date counts only when no open task has a date, so moving an end date later does not flag a goal or a program milestone that the work still meets. An effect for which PMOS finds no record line to cite is not shown, and the rehearsal says how many it left out.
+
+## The guardrails
+
+- **Propose-only.** The rehearsal writes nothing except one audit line.
+- **Every effect cites its source**: the line of the task link, the initiative record, the goal's KR metric record or the program charter. Before an effect is shown, PMOS checks that the quoted text is really at that line. An effect whose source cannot be found is not shown, and the rehearsal says how many were left out.
+- **Replay-tested.** A new version of the rehearsal shows nothing until its recorded cases pass (one of them checks that a change nothing waits on says nothing).
+- **Kill switch.** `pmos ai off rehearse` turns rehearsals off, and `pmos ai on rehearse` turns them on again. `PMOS_AI_REHEARSE=off` or `PMOS_AI=off` in the environment also turns them off.
+- **Audit.** Each rehearsal adds lines to the AI audit log: `pmos rehearse log`, or `pmos ai log rehearse` for every line.
+
+## The commands
+
+- `pmos rehearse move <task> --by <days>` — the task moves later by whole days, or earlier with a minus (`--by -2`).
+- `pmos rehearse move <task> --start YYYY-MM-DD [--due YYYY-MM-DD]`, or `--due YYYY-MM-DD` alone — the task gets new dates. A new start alone keeps the task's length.
+- `pmos rehearse end <initiative> --to YYYY-MM-DD` — the initiative's end date changes.
+- `pmos rehearse cut <task|initiative>` — what if we cut this. An initiative id cuts the whole initiative; a task id cuts one task.
+- `pmos rehearse log [--n N]` — the last rehearsals.
+
+Every command takes `--json` and `--root <repository>`. Exit codes: 0 done, 1 off or refused, 2 usage.

package/workspace/lib/decision-memory.js

@@ -199,14 +199,15 @@ const versionOf = (L) => VERSION + '-' + hash(JSON.stringify(pairsOf(L)));
  * `pmos grill find decision`: check each finding, then hand the good ones to lib/ai-guard.js, which holds them until the replay of this
  * version passed (the replay runs here when it has not), checks the evidence again, audits, and calls deliver. deliver appends the grill
  * proposal to the initiative's ✦ ledger, as `pmos grill find` does for the other angles. → exit code: 0 filed or nothing to file, 1 refused.
- * o: { root, file (proposals.jsonl), run, ini, board, env, now, say, P (the proposals fold), settingsDir (Settings, for the kill switch) }
+ * o: { root, file (proposals.jsonl), run, ini, board, env, now, say, P (the proposals fold), settingsDir (the per-user state folder: Settings for the kill switch, and the guard's audit and replay record) }
  */
 async function fileRun(o, bodies) {
   const say = o.say || (() => {}), env = o.env || process.env;
   const PR = require('./proposals.js'), AG = require('./ai-guard.js');
   const off = offWhy(env); if (off) { say('✗ ' + off); return 1; }
   const L = DL.load(o.root);
-  const stateDir = path.dirname(o.file), version = versionOf(L);
+  // the guard's audit and replay record live in the per-user state folder, never in the repository's state (Sync would commit them)
+  const stateDir = o.settingsDir || require('./state-root.js').defaultRoot({ env }), version = versionOf(L);
   const props = []; let bad = 0;
   for (const b of bodies) {
     const c = checkFinding(L, b, { root: o.root, ini: o.ini });

package/workspace/lib/pmos-verbs.js

@@ -84,6 +84,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): the AI-ideas round (2026-11-03) added it through the same table: the kill switch and audit of lib/ai-guard.js.
   ai: Object.freeze({ module: 'ai-cli.js', run: null, guide: 'claude-proposes.md',
     help: 'pmos ai status|off|on|log … — the AI jobs: their kill switch, replay state and audit (pmos ai help)' }),
+  // Not a pm-os-absorb verb (run: null): the AI-ideas round (2026-11-03, feature 5, plan-rehearsal) added it through the same table.
+  rehearse: Object.freeze({ module: 'rehearse-cli.js', run: null, guide: 'rehearse.md',
+    help: 'pmos rehearse move|end|cut|log … — what a change would break or help in other initiatives, goals and dates, before the PM approves it (pmos rehearse help)' }),
   // Not a pm-os-absorb verb (run: null): Grill and Forecast part G-A (Claude grills an initiative by itself) added it through the same table.
   grill: Object.freeze({ module: 'grill-cli.js', run: null, guide: 'claude-proposes.md',
     help: 'pmos grill find|voices|status|mode|cap|spend … — what Claude\'s grill run files under an initiative\'s ✦, and when it grills and what it may spend (pmos grill help)' }),

package/workspace/lib/rehearse-cli.js

@@ -0,0 +1,102 @@
+'use strict';
+/* rehearse-cli.js — `pmos rehearse`: what a change would break or help, before the PM approves it (initiative plan-rehearsal).
+ *
+ *   pmos rehearse move <task> --by <days> | --start YYYY-MM-DD [--due YYYY-MM-DD] | --due YYYY-MM-DD   a task's dates change
+ *   pmos rehearse end <initiative> --to YYYY-MM-DD                                                    an initiative's end changes
+ *   pmos rehearse cut <task|initiative>                                                               what if we cut this
+ *   pmos rehearse log [--n N]                                                                         the last rehearsals (the audit)
+ *   every command takes --json and --root <repository>
+ *
+ * It reads through lib/rehearse-read.js, runs lib/rehearse.js and shows only the effects lib/ai-guard.js lets through (lib/rehearse-guard.js).
+ * It changes nothing: the one write is the audit line in <runtime>/ai-audit.jsonl. The PM approves the change in their own words; only
+ * then does the session make it, with `pmos task set`, `pmos task state` or the PM's own act. Exit codes: 0 done, 1 off or refused,
+ * 2 usage. Nothing is sent. */
+const path = require('path');
+const { execFileSync } = require('child_process');
+const RH = require('./rehearse.js');
+
+const COMMANDS = { rehearse: ['move', 'end', 'cut', 'log'] };
+const USAGE = [
+  'usage: pmos rehearse move|end|cut|log — what a change would break or help, before the PM approves it. Nothing changes.',
+  '  pmos rehearse move <task> --by <days>                       the task moves later (or earlier, with a minus) by whole days',
+  '  pmos rehearse move <task> --start YYYY-MM-DD [--due YYYY-MM-DD] | --due YYYY-MM-DD',
+  '  pmos rehearse end <initiative> --to YYYY-MM-DD               the initiative\'s end date changes',
+  '  pmos rehearse cut <task|initiative>                          what if we cut this',
+  '  pmos rehearse log [--n N]                                    the last rehearsals',
+  'Each effect names the record it comes from. Show it to the PM, and make the change only after the PM says yes.',
+];
+const VALUE = new Set(['by', 'start', 'due', 'to', 'root', 'today', 'n']);
+const BOOL = new Set(['json']);
+
+function parse(args) {
+  const pos = [], flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const m = /^--([a-z-]+)(?:=(.*))?$/.exec(args[i]);
+    if (!m) { pos.push(args[i]); continue; }
+    if (m[2] !== undefined) flags[m[1]] = m[2];
+    else if (VALUE.has(m[1]) && args[i + 1] !== undefined && !/^--[a-z]/.test(args[i + 1])) flags[m[1]] = args[++i];
+    else flags[m[1]] = true;
+  }
+  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 runtimeOf = (env) => require('./state-root.js').defaultRoot({ env });
+
+async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), env = process.env, stateDir = null, snapshot = null } = {}) {
+  const args = argv[0] === 'rehearse' ? argv.slice(1) : argv.slice();
+  const verb = args[0];
+  if (!verb || ['help', '--help', '-h'].includes(verb)) { for (const l of USAGE) say(l); return verb ? 0 : 1; }
+  if (!COMMANDS.rehearse.includes(verb)) { say(`unknown rehearse command "${verb}" — one of ${COMMANDS.rehearse.join(', ')}`); return 2; }
+  const { pos, flags } = parse(args.slice(1));
+  for (const k of Object.keys(flags)) if (!VALUE.has(k) && !BOOL.has(k)) { say(`unknown option --${k}`); return 2; }
+  for (const k of Object.keys(flags)) if (VALUE.has(k) && flags[k] === true) { say(`--${k} needs a value`); return 2; }
+  const json = !!flags.json, runtime = stateDir || runtimeOf(env);
+  const G = require('./rehearse-guard.js'), AG = require('./ai-guard.js');
+
+  if (verb === 'log') {
+    const n = Math.min(200, Math.max(1, Number(flags.n) || 10));
+    const lines = AG.readAudit(runtime, { job: G.JOB, limit: 2000 }).filter((l) => l.event === 'start' || l.event === 'end' || l.event === 'off' || l.event === 'held').slice(-n * 2);
+    if (json) { say(JSON.stringify({ ok: true, lines })); return 0; }
+    if (!lines.length) { say('No rehearsal yet.'); return 0; }
+    for (const l of lines) say(`${String(l.at).slice(0, 16).replace('T', ' ')} ${l.event}${l.change ? ' ' + l.change.kind + ' ' + (l.change.task || l.change.ini || '') : ''}${l.filed != null ? ' · ' + l.filed + ' shown, ' + l.dropped + ' dropped' : ''}${l.why ? ' · ' + l.why : ''}`);
+    return 0;
+  }
+
+  const usage = { move: 'usage: pmos rehearse move <task> --by <days> | --start YYYY-MM-DD [--due YYYY-MM-DD] | --due YYYY-MM-DD', end: 'usage: pmos rehearse end <initiative> --to YYYY-MM-DD', cut: 'usage: pmos rehearse cut <task|initiative>' }[verb];
+  if (pos.length !== 1) { say(usage); return 2; }
+  const allowed = { move: ['by', 'start', 'due'], end: ['to'], cut: [] }[verb];
+  for (const k of ['by', 'start', 'due', 'to']) if (flags[k] !== undefined && !allowed.includes(k)) { say(`--${k} is not an option of ${verb}`); return 2; }
+  const fail = (error, code = 1) => { if (json) say(JSON.stringify({ ok: false, error })); else say('✗ ' + error); return code; };
+
+  // the kill switch first: an off rehearsal reads nothing
+  const off = AG.off(G.JOB, { env, settingsDir: runtime });
+  if (off) { AG.audit(runtime, { job: G.JOB, version: G.VERSION, event: 'off', why: off }); return fail('rehearsals are off: ' + off + '. `pmos ai on rehearse` turns them on.'); }
+
+  const root = flags.root ? path.resolve(cwd, flags.root) : repoRoot(cwd);
+  const snap = snapshot || require('./rehearse-read.js').snapshotOf(root, { today: typeof flags.today === 'string' ? flags.today : undefined });
+  const id = pos[0];
+  let change;
+  if (verb === 'move') {
+    if (flags.by !== undefined && !/^-?\d+$/.test(String(flags.by))) return fail('--by takes whole days, e.g. --by 3 or --by -2', 2);
+    change = { kind: 'move', task: id, ...(flags.by !== undefined ? { days: Number(flags.by) } : {}), ...(flags.start ? { start: flags.start } : {}), ...(flags.due ? { due: flags.due } : {}) };
+  } else if (verb === 'end') change = { kind: 'end', ini: id, to: flags.to };
+  else change = (snap.rows || []).some((r) => r.id === id) ? { kind: 'cut', ini: id } : { kind: 'cut', task: id };
+
+  const r = RH.rehearse(snap, change);
+  if (!r.ok) return fail(r.error, /^(say how|--)/.test(r.error) ? 2 : 1);
+  const g = await G.guarded(r, { root, stateDir: runtime, env });
+  if (g.off) return fail('rehearsals are off: ' + g.off);
+  if (g.held) return fail('the rehearsal replay did not pass, so nothing is shown: ' + (g.failed || []).map((f) => f.name + ' (' + f.why + ')').join('; ') + '. `pmos ai status` shows it.');
+  const shown = { ...r, effects: g.effects, counts: { breaks: 0, helps: 0, moves: 0 } };
+  for (const e of shown.effects) shown.counts[e.tone]++;
+  if (json) { say(JSON.stringify({ ok: true, change, effects: shown.effects, counts: shown.counts, dropped: g.dropped.length, missing: r.missing, changed: false })); return 0; }
+  for (const l of RH.textOf(shown).slice(0, -1)) say(l);
+  if (g.dropped.length) say(`${g.dropped.length === 1 ? '1 effect is' : g.dropped.length + ' effects are'} not shown: PMOS could not find its source at the line it cites.`);
+  say(RH.textOf(shown).slice(-1)[0]);
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/rehearse-guard.js

@@ -0,0 +1,81 @@
+'use strict';
+/* rehearse-guard.js — a rehearsal's effects through the shared door, lib/ai-guard.js (initiative ai-job-guard): the kill switch, the
+ * replay gate, the citation check and the audit. Nothing here duplicates the guard; this file only says what a rehearsal files and
+ * which recorded cases it must pass.
+ *
+ *   JOB · VERSION                          'rehearse', and the version of the engine's output (bump it when lib/rehearse.js changes)
+ *   proposalsOf(result) → [proposal]       one ai-guard proposal per effect: its text, its sources, its tone in data
+ *   cases(fixture?) → [replay case]        the recorded snapshot fixtures/rehearse-replay.json, replayed through the engine
+ *   fixture(file?) → { root, snap }        that snapshot, its cited files written to a temporary folder (root), its sources computed from them
+ *   guarded(result, o) → Promise<{ off?, held?, effects, dropped }>
+ *       o: { root, stateDir (the runtime folder), env, run }. Runs the replay first when this version has not passed it, then files
+ *       the effects. An effect whose source the guard cannot find at its line is dropped and never shown (proven only).
+ *
+ * The audit lines go to <runtime>/ai-audit.jsonl with the job `rehearse`; `pmos ai log rehearse` reads them, and `pmos ai off rehearse`
+ * (or PMOS_AI_REHEARSE=off, or PMOS_AI=off) turns rehearsals off. */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const AG = require('./ai-guard.js');
+const RH = require('./rehearse.js');
+const RR = require('./rehearse-read.js');
+
+const JOB = 'rehearse';
+const VERSION = '2';
+const MAX = 40;
+const FIXTURE = path.join(__dirname, '..', 'fixtures', 'rehearse-replay.json');
+const TITLE = { breaks: 'Breaks', helps: 'Helps', moves: 'Moves with it' };
+
+const idOf = (e) => 'rh:' + e.kind + ':' + crypto.createHash('sha1').update(e.text).digest('hex').slice(0, 12);
+function proposalsOf(r) {
+  if (!r || !r.ok) return [];
+  return r.effects.map((e) => ({
+    id: idOf(e), title: TITLE[e.tone] + ': ' + e.kind, say: e.text,
+    confidence: new Set(e.evidence.map((s) => s.ref)).size >= 2 ? 'high' : 'medium',
+    claims: [{ text: e.text, sources: e.evidence.map((s) => ({ label: s.label, ref: s.ref, quote: s.quote || '' })) }],
+    data: { tone: e.tone, kind: e.kind, ini: e.ini || null, task: e.task || null, goal: e.goal || null, program: e.program || null },
+  }));
+}
+
+function fixture(file = FIXTURE) {
+  const snap = JSON.parse(fs.readFileSync(file, 'utf8'));
+  // the files its sources cite, written where the guard can read them at their lines
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pmos-rehearse-replay-'));
+  for (const [name, lines] of Object.entries(snap.contents || {})) fs.writeFileSync(path.join(root, path.basename(name)), lines.join('\n') + '\n');
+  const f = snap.files || {}, abs = (x) => path.join(root, x);
+  delete snap.contents;
+  snap.refs = RR.refsOf(root, snap, { links: abs(f.links), krs: abs(f.krs), programs: abs(f.programs), records: Object.fromEntries(Object.entries(f.records || {}).map(([k, v]) => [k, abs(v)])) });
+  return { root, snap };
+}
+/** The recorded cases: the engine on a fixed snapshot, never a model. */
+function cases(F = fixture()) {
+  const { snap } = F;
+  const run = (change, edit) => async () => proposalsOf(RH.rehearse(edit ? edit(JSON.parse(JSON.stringify(snap))) : snap, change));
+  return [
+    { name: 'a change nothing waits on says nothing', run: run({ kind: 'move', task: 'b2', days: 1 }), expect: { none: true } },
+    { name: 'a later task moves another initiative, a milestone and a Jira ticket, with the link lines', run: run({ kind: 'move', task: 'a1', days: 5 }), expect: { min: 5, cites: ['rehearse-links.jsonl', 'rehearse-programs.jsonl'] } },
+    { name: 'cutting an initiative names the goal it moves and what waited on it', run: run({ kind: 'cut', ini: 'checkout' }), expect: { min: 3, cites: ['rehearse-krs.jsonl', 'rehearse-checkout.txt', 'rehearse-links.jsonl'] } },
+    { name: 'a link broken before the change is not blamed on it', run: run({ kind: 'end', ini: 'checkout', to: '2026-11-25' }, (s) => { s.tasks[2].start = '2026-11-18'; return s; }), expect: { none: true } },
+  ];
+}
+
+async function guarded(result, o = {}) {
+  const env = o.env || process.env, stateDir = o.stateDir, run = o.run || 'rh-' + crypto.randomBytes(4).toString('hex');
+  const off = AG.off(JOB, { env, settingsDir: stateDir });
+  if (off) { AG.audit(stateDir, { job: JOB, version: VERSION, run, event: 'off', why: off }); return { off, effects: [], dropped: [] }; }
+  if (!AG.ready(stateDir, JOB, VERSION)) {
+    const F = fixture(), rp = await AG.replay(JOB, VERSION, cases(F), { root: F.root, stateDir, max: MAX });
+    try { fs.rmSync(F.root, { recursive: true, force: true }); } catch { /* a temporary folder */ }
+    if (!rp.ok) return { held: true, failed: rp.failed, effects: [], dropped: [] };
+  }
+  AG.audit(stateDir, { job: JOB, version: VERSION, run, event: 'start', change: result.change, effects: result.effects.length });
+  const P = proposalsOf(result), byId = new Map(P.map((p, i) => [p.id, result.effects[i]]));
+  let shown = [];
+  const got = await AG.file({ job: JOB, version: VERSION, run, root: o.root, stateDir, settingsDir: stateDir, env, max: MAX }, P, async (filed) => { shown = filed.map((p) => byId.get(p.id)).filter(Boolean); });
+  if (got.off) return { off: got.off, effects: [], dropped: [] };
+  if (got.held) return { held: true, effects: [], dropped: [] };
+  return { effects: shown, dropped: got.dropped || [] };
+}
+
+module.exports = { JOB, VERSION, MAX, FIXTURE, proposalsOf, fixture, cases, guarded };

package/workspace/lib/rehearse-read.js

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

package/workspace/lib/rehearse.js

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

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/test-lists/plan-rehearsal.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Rehearse a plan (initiative plan-rehearsal): the pure engine on a recorded snapshot, the shared guard's replay and citation check over its effects, the kill switch, the audit and `pmos rehearse`.",
+  "modules": ["rehearse.test.js"],
+  "seconds": { "rehearse.test.js": 2 }
+}