create-pmos 0.493.0 → 0.495.0

package/workspace/lib/board-trail.js

@@ -74,6 +74,28 @@ const pathOf = (v) => (typeof v === 'string' && /^[\w./-]+\.md$/.test(v.trim())
 
 /** The default io: the files of `root`, its git history (one `git log` per HEAD), the Jira draft and reading, the OKR anchors. */
 const gitCache = new Map();
+/** The size and time of HEAD and its reflog in the git directory that holds `root` (a linked worktree's own one too), or null when they
+ *  cannot be read: then the caller asks git, as before. */
+function headStamp(root) {
+  let dir = path.resolve(root);
+  for (let i = 0; i < 40; i++) {
+    const dot = path.join(dir, '.git');
+    let gitDir = null;
+    try {
+      const st = fs.statSync(dot);
+      if (st.isDirectory()) gitDir = dot;
+      else { const m = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(dot, 'utf8')); if (m) gitDir = path.resolve(dir, m[1].trim()); }
+    } catch { /* not here: look one level up */ }
+    if (gitDir) {
+      try {
+        const a = fs.statSync(path.join(gitDir, 'HEAD')), b = fs.statSync(path.join(gitDir, 'logs', 'HEAD'));
+        return gitDir + '|' + a.size + ':' + a.mtimeMs + '|' + b.size + ':' + b.mtimeMs;
+      } catch { return null; }
+    }
+    const up = path.dirname(dir); if (up === dir) return null; dir = up;
+  }
+  return null;
+}
 function defaultIo(root) {
   const read = (rel) => { try { return fs.readFileSync(path.join(root, rel), 'utf8'); } catch { return null; } };
   return {
@@ -81,16 +103,21 @@ function defaultIo(root) {
     list: (dir) => { try { return fs.readdirSync(path.join(root, dir)); } catch { return []; } },
     records: () => { try { return fs.readdirSync(path.join(root, 'planning', 'initiatives')).filter((f) => f.endsWith('.md') && f !== 'README.md' && f !== 'index.md').map((f) => 'planning/initiatives/' + f); } catch { return []; } },
     firstSeen: () => {
+      // page-open-speed: HEAD's reflog moves on every commit, checkout and reset, so while it is unchanged the cached map stands and
+      // no `git` runs at all (the trail asked `git rev-parse` on every Board open, ~30 ms on the thread every answer waits for).
+      const hit = gitCache.get(root);
+      const stamp = headStamp(root);
+      if (hit && stamp && hit.stamp === stamp) return hit.map;
       let head = '';
       try { head = execFileSync('git', ['-C', root, 'rev-parse', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return new Map(); }
-      const hit = gitCache.get(root); if (hit && hit.head === head) return hit.map;
+      if (hit && hit.head === head) { hit.stamp = stamp; return hit.map; }
       const map = new Map();
       try {
         const out = execFileSync('git', ['-C', root, 'log', '--diff-filter=A', '--name-only', '--format=@@%at', '--', 'planning'], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
         let at = 0;
         for (const line of out.split('\n')) { if (line.startsWith('@@')) at = Number(line.slice(2)) * 1000; else if (line.trim()) map.set(line.trim(), at); }   // newest first: the last write is the first appearance
       } catch { /* not a git checkout: no dates */ }
-      gitCache.set(root, { head, map });
+      gitCache.set(root, { head, map, stamp });
       return map;
     },
     jira: (id) => {
@@ -258,4 +285,4 @@ function trail({ root, ids, rows = [], moves = [], now = Date.now(), io } = {})
   return { ok: true, at: new Date(now).toISOString(), usual, usualBy, themes: out, items };
 }
 
-module.exports = { trail, frontmatter, partsOf, ladderDates, median, STAGES, MIN_SAMPLES, TONES };
+module.exports = { trail, defaultIo, frontmatter, partsOf, ladderDates, median, STAGES, MIN_SAMPLES, TONES };

package/workspace/lib/engine/workflows.js

@@ -4,8 +4,9 @@
  *
  *   CATS · ENDS · OUTPUT_KINDS · WHEN_MODES · DECIDE · ICONS · PRODUCT_FEATURE_ID · PRODUCT_FEATURE
  *   check(wf, { existing })              → { ok, workflow } | { ok:false, status, error }   validate and normalise one workflow
- *   fold(lines)                          → { byId: Map, draft }                              the library (Product feature first)
- *   list(folded, counts?)                → [workflow + { count }]                            Product feature first, archived last
+ *   fold(lines)                          → { byId: Map, draft, defaultId }                   the library (Product feature first)
+ *   list(folded, counts?)                → [workflow + { count, default? }]                  Product feature first, archived last
+ *   defaultOf(folded)                    → the workflow a new initiative starts on (Product feature when none is set or it is archived)
  *   resolve(folded, id)                  → the workflow (Product feature when the id is unknown or missing)
  *   stageByRef(wf, ref)                  → the stage a key or a name names, or null
  *   switchTarget(from, to, stageKey)     → the key an initiative lands on when it switches workflow (the bridge's stage, see mapOf)
@@ -27,6 +28,8 @@
  *   wf-save    { wf }                       create or edit (Product feature is never saved: it is built in)
  *   wf-archive { id, archived }
  *   wf-draft   { draft | null, note? }      the one open draft the chat wrote (null clears it)
+ *   wf-default { id }                       the workflow a new initiative starts on, for this workspace (batch 24 item 3, canvas DfA). The last
+ *                                           line wins. Product feature can be the default. An unknown or archived id reads as Product feature.
  */
 
 const { STAGES: LIFE, LABELS, OUTPUTS, MILESTONES } = require('./nine-stages');
@@ -134,7 +137,7 @@ function check(wf) {
 /** Fold workflows.jsonl (objects or JSON strings), oldest first. */
 function fold(lines) {
   const byId = new Map([[PRODUCT_FEATURE_ID, PRODUCT_FEATURE]]);
-  let draft = null;
+  let draft = null, defaultId = null;
   for (const raw of lines || []) {
     let e = raw;
     if (typeof raw === 'string') { try { e = JSON.parse(raw); } catch { continue; } }
@@ -153,14 +156,24 @@ function fold(lines) {
       byId.set(e.id, w);
     } else if (e.kind === 'wf-draft') {
       draft = isObj(e.draft) ? { draft: e.draft, note: typeof e.note === 'string' ? e.note : '', at: e.at || null } : null;
+    } else if (e.kind === 'wf-default' && typeof e.id === 'string' && e.id) {
+      defaultId = e.id;
     }
   }
-  return { byId, draft };
+  return { byId, draft, defaultId };
+}
+
+/** The workflow a new initiative starts on: the last wf-default line's workflow, or Product feature when none is set, the id is not in the
+ *  library, or that workflow is archived. */
+function defaultOf(folded) {
+  const w = folded && folded.defaultId ? folded.byId.get(folded.defaultId) : null;
+  return w && !w.archived ? w : PRODUCT_FEATURE;
 }
 
 /** The library as a list: Product feature first, then by name, archived last. counts: { [id]: n } initiatives on each. */
 function list(folded, counts = {}) {
-  const all = [...folded.byId.values()].map((w) => ({ ...w, count: counts[w.id] || 0 }));
+  const def = defaultOf(folded).id;
+  const all = [...folded.byId.values()].map((w) => ({ ...w, count: counts[w.id] || 0, ...(w.id === def ? { default: true } : {}) }));
   const rank = (w) => (w.id === PRODUCT_FEATURE_ID ? 0 : w.archived ? 2 : 1);
   return all.sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name));
 }
@@ -269,5 +282,5 @@ const milestonesOf = (wf) => (wf || PRODUCT_FEATURE).stages.filter((s) => s.mile
 
 module.exports = {
   CATS, CAT_LABEL, ENDS, OUTPUT_KINDS, WHEN_MODES, DECIDE, ICONS, PRODUCT_FEATURE_ID, PRODUCT_FEATURE,
-  slug, check, fold, list, resolve, stageByRef, switchTarget, proposeBridge, mapOf, removedInUse, stagesOf, copyOf, milestonesOf,
+  slug, check, fold, list, defaultOf, resolve, stageByRef, switchTarget, proposeBridge, mapOf, removedInUse, stagesOf, copyOf, milestonesOf,
 };

package/workspace/lib/git-shape.js

@@ -0,0 +1,21 @@
+'use strict';
+/* git-shape.js — where a folder sits in git, read from the disk with no `git` run (page-open-speed). */
+const fs = require('fs');
+const path = require('path');
+
+/** A cheap stamp of where `root` sits in git, read from the disk with no `git` run: the nearest `.git` entry above it, whether it is a
+ *  directory (a main tree) or a file (a linked worktree, with the file's time: it names the tree's git directory).
+ *  A directory's time is left out: git touches it on every commit, and a main tree stays the main tree. It changes when the folder becomes, or stops being, a repository
+ *  or a worktree, so an answer about the repository's SHAPE (which tree is the main one) can be kept until it changes instead of asking
+ *  `git` again on a clock (page-open-speed). 'none' when no `.git` is found up to the file-system root. */
+function shapeStamp(root) {
+  if (!root) return 'none';
+  let dir = path.resolve(root);
+  for (let i = 0; i < 64; i++) {
+    try { const st = fs.statSync(path.join(dir, '.git')); return dir + '|' + (st.isDirectory() ? 'd' : 'f|' + st.mtimeMs); } catch { /* look one level up */ }
+    const up = path.dirname(dir); if (up === dir) break; dir = up;
+  }
+  return 'none';
+}
+
+module.exports = { shapeStamp };

package/workspace/lib/grill-runs.js

@@ -11,6 +11,7 @@
  *
  * deps: { workspaces() → [w], isLead(w), stateDirFor(w), runtimeDir(), rowOf(w, id) → { title, intent, stage, stages } | null,
  *         exits(w) → [{ ini, board, stage }] (stages about to end), shapes(w) → [{ ini, board, n, end }] (open tasks, latest due),
+ *         looks(w) → [{ ini, board, n, end }] (running initiatives with open tasks, for the monthly look),
  *         goalInis(w, goalId) → [{ id, endAt, status }] (the initiatives anchored to that goal), checks(w, day) → [{ ini, board, tasks }] (late or at-risk work), turned(dir, sinceIso) → [forecast `turned` line] (lib/forecast.js),
  *         api { available(env), run({ prompt, root, env, budget, signal }) → Promise<{ ok, code, costUsd, note?, stopped? }> } (lib/grill-api.js; optional),
  *         setting(key) (lib/settings-store.js get), open(now) → bool, headlessOff() → bool, env, promptFor(skillId), spawn(spec), stop(session), warn }
@@ -27,7 +28,7 @@ const WHY = {
   exit: 'The initiative is about to leave its stage. Grill it before it does: what would make the next stage fail?',
   forecast: 'Its forecast just turned. Grill it: why, and what would bring it back?',
   move: 'Its scope or dates moved a lot. Grill it: is the plan still the right plan?',
-  monthly: 'The monthly look at running work that feels off (it has late work). Grill it.',
+  monthly: 'The monthly look at running work (late work first, then the initiatives grilled longest ago). Grill it.',
   ask: 'The PM asked for it in the initiative\'s chat. Grill it now: what would make it fail, and what is the next step?',
 };
 
@@ -50,6 +51,16 @@ function pickFor(inis) {
   return run.length ? run[0].id : null;
 }
 
+/** PURE. The monthly look's order. late: [{ ini, board, tasks }] (late or at-risk work), open: [{ ini, board, n }] (running initiatives with
+ * open tasks), lastOf(ini) → ms of its last grill (0: never). → [{ ini, board, last, detail }]: late work first, then never grilled, then the
+ * one grilled longest ago; within each, the most open work first. */
+function monthlyOrder(late, open, lastOf) {
+  const out = new Map();
+  for (const c of late || []) if (c && c.ini && !out.has(c.ini)) out.set(c.ini, { ini: c.ini, board: c.board, last: lastOf(c.ini), late: true, n: (c.tasks || []).length, detail: (c.tasks || []).length + ' late or at-risk tasks' });
+  for (const c of open || []) if (c && c.ini && !out.has(c.ini) && Number(c.n) > 0) out.set(c.ini, { ini: c.ini, board: c.board, last: lastOf(c.ini), late: false, n: Number(c.n), detail: c.n + ' open tasks' + (c.end ? ', the latest due ' + c.end : '') });
+  return [...out.values()].sort((a, b) => (b.late - a.late) || (a.last - b.last) || (b.n - a.n));
+}
+
 function create(deps) {
   const active = new Map();   // run → { session }
   const warn = deps.warn || (() => {});
@@ -147,10 +158,14 @@ function create(deps) {
       const what = G.moved(prev, cur);
       if (what) out.push({ ws: w.id, board: s.board, ini: s.ini, why: 'move', key: `move:${w.id}:${s.ini}:${cur.n}:${cur.end}`, detail: what });
     }
-    for (const c of tryList(() => deps.checks && deps.checks(w, localDay(now)))) {
-      const last = Date.parse(F.lastAt.get(w.id + '|' + c.ini) || '') || 0;
-      if (now - last < G.MONTHLY_DAYS * 864e5) continue;
-      out.push({ ws: w.id, board: c.board, ini: c.ini, why: 'monthly', key: `monthly:${w.id}:${c.ini}:${G.monthOf(now)}`, detail: (c.tasks || []).length + ' late or at-risk tasks' });
+    // the monthly look: every running initiative with open work, at most once in 30 days each (Wawan 2026-11-02: "why only one?").
+    // Late work first, then the ones never grilled, then the ones grilled longest ago; the cap decides how far down the list a month goes.
+    const late = tryList(() => deps.checks && deps.checks(w, localDay(now))), seen = new Set();
+    const looks = monthlyOrder(late, tryList(() => deps.looks && deps.looks(w)), (ini) => Date.parse(F.lastAt.get(w.id + '|' + ini) || '') || 0);
+    for (const c of looks) {
+      if (seen.has(c.ini)) continue; seen.add(c.ini);
+      if (now - c.last < G.MONTHLY_DAYS * 864e5) continue;
+      out.push({ ws: w.id, board: c.board, ini: c.ini, why: 'monthly', key: `monthly:${w.id}:${c.ini}:${G.monthOf(now)}`, detail: c.detail });
     }
     return out;
   }
@@ -182,4 +197,4 @@ function create(deps) {
   return { tick, start, stop, dueOf, active: () => [...active.keys()] };
 }
 
-module.exports = { create, promptOf, pickFor, WHY, MAX };
+module.exports = { create, promptOf, pickFor, monthlyOrder, WHY, MAX };

package/workspace/lib/grill.js

@@ -15,7 +15,7 @@
  *   exit      the initiative is about to leave its stage (most of the stage's tasks are closed), once per stage
  *   forecast  its forecast, or the forecast of a goal it moves, turned at-risk or will-miss (lib/forecast.js `turned` lines), once per turn
  *   move      its scope or dates moved a lot since the last look (tasks ±30% and 3 or more, or the end ±14 days)
- *   monthly   a running initiative with late work, at most once in 30 days
+ *   monthly   every running initiative with open work, at most once in 30 days each: late work first, then the ones grilled longest ago
  * `exits` runs only the first. Every run counts against the monthly credit cap (grill.cap, US dollars): before a run the cap must hold
  * the run's whole budget, which goes to the run as --max-budget-usd, so the month never goes beyond the cap. At the cap Claude pauses and
  * says so once per month (a `paused` line).

package/workspace/lib/impact.js

@@ -9,6 +9,10 @@
  * ticket that moved after your decision, a spec used, a KR that moved after your initiative delivered), with the source to open it. Never
  * logins, ticks, time, messages sent, or Claude's own work.
  *
+ * COUNTED BY DEFAULT (batch 23 item 4, canvas IcA). An item counts unless the PM drops it (✕, "Not right, drop it"). The check of week W is open
+ * during the week after W; when that week ends, every row of W nobody dropped is real. A closed week is judged for the gate only when the
+ * check card was shown to the PM (a `looked` line), so the gate never opens on weeks nobody saw. An explicit ✓ (older ledgers) still counts.
+ *
  * NO NUMBERS LEAVE THIS FILE. The views carry words: grow is rest · bud · leaf · full; the gate is measuring · open · short. The gate's rate
  * is written to the ledger (the brief's "record the rate") and never shown.
  *
@@ -18,6 +22,7 @@
  *   end      { run, ok, error? }                       the run ended
  *   verdict  { id, real: true | false }                the PM's ✓ or ✕ in the weekly check
  *   undo     { id }                                    a row back to unchecked
+ *   looked   { week }                                  the weekly check card was shown to the PM for that week
  *   seen     { ids }                                   read on a Phase 2 surface; ends its celebration
  *   gate     { state, real, judged, weeks }            the gate changed: measuring → open (and stays), or → short
  *
@@ -34,7 +39,7 @@ const path = require('path');
 const crypto = require('crypto');
 
 const LEDGER = 'impact.jsonl';
-const LINES = new Set(['run', 'item', 'end', 'verdict', 'undo', 'seen', 'gate']);
+const LINES = new Set(['run', 'item', 'end', 'verdict', 'undo', 'seen', 'gate', 'looked']);
 const KINDS = ['thanks', 'unblock', 'used', 'kr'];
 const SOURCE_TYPES = ['slack', 'mail', 'jira', 'doc', 'meeting', 'kr', 'board', 'initiative'];
 const GROW = ['rest', 'bud', 'leaf', 'full'];
@@ -115,7 +120,7 @@ function clean(input) {
 
 /* ── the fold ── */
 function fold(lines) {
-  const items = new Map(), runs = [];
+  const items = new Map(), runs = [], looked = new Set();
   let gate = { state: 'measuring' };
   const runOf = (id) => runs.find((r) => r.run === id);
   for (const l of lines || []) {
@@ -129,10 +134,11 @@ function fold(lines) {
       items.set(c.item.id, { ...c.item, real: null, read: false, filed: str(l.at), run: str(l.run) });
     } else if (l.kind === 'verdict' && str(l.id)) { const it = items.get(l.id); if (it && typeof l.real === 'boolean') { it.real = l.real; it.checkedAt = str(l.at); } }
     else if (l.kind === 'undo' && str(l.id)) { const it = items.get(l.id); if (it) { it.real = null; it.read = false; } }
-    else if (l.kind === 'seen' && Array.isArray(l.ids)) { for (const id of l.ids) { const it = items.get(String(id)); if (it && it.real === true) it.read = true; } }
+    else if (l.kind === 'seen' && Array.isArray(l.ids)) { for (const id of l.ids) { const it = items.get(String(id)); if (it && it.real !== false) it.read = true; } }
     else if (l.kind === 'gate' && ['measuring', 'open', 'short'].includes(l.state)) { if (gate.state !== 'open') gate = { state: l.state, at: str(l.at) }; }
+    else if (l.kind === 'looked' && DAY_RE.test(str(l.week))) looked.add(l.week);
   }
-  return { items, runs, gate };
+  return { items, runs, gate, looked };
 }
 
 const weekIs = (it, start) => weekOf(dayOf(Date.parse(it.at)), start);
@@ -144,14 +150,21 @@ function itemsByWeek(F, start) {
   return m;
 }
 
-/** PURE. The gate before Phase 2: a checked week is a finished week whose every item has ✓ or ✕. Across the checked weeks, at least 9 of 10
- *  judged items real, over at least two weeks and ten items: open (and it stays open once written). Ten or more judged and under 9 of 10: short. */
+/** The check of week `w` is closed once the week after it has ended: rows nobody dropped are real from then on. */
+const closed = (w, thisWeek) => w < addDays(thisWeek, -7);
+/** Counts in your impact: not dropped. A row still in its open check counts too (the card says so: "counted them in your impact"). */
+const counts = (x) => x.real !== false;
+
+/** PURE. The gate before Phase 2: a judged week is a finished week whose every item has ✓ or ✕, or a closed week whose check card the PM saw
+ *  (rows nobody dropped are real). Across the judged weeks, at least 9 of 10 items real, over at least two weeks and ten items: open (and it
+ *  stays open once written). Ten or more judged and under 9 of 10: short. */
 function gateOf(F, thisWeek, start = 'mon') {
-  const W = itemsByWeek(F, start);
+  const W = itemsByWeek(F, start), saw = F.looked || new Set();
   let real = 0, judged = 0, weeks = 0;
   for (const [w, list] of W) {
-    if (w >= thisWeek || !list.length || list.some((x) => x.real === null)) continue;
-    weeks++; judged += list.length; real += list.filter((x) => x.real === true).length;
+    if (w >= thisWeek || !list.length) continue;
+    if (list.some((x) => x.real === null) && !(closed(w, thisWeek) && saw.has(w))) continue;
+    weeks++; judged += list.length; real += list.filter(counts).length;
   }
   if (F.gate && F.gate.state === 'open') return { state: 'open', real, judged, weeks };
   const state = weeks < GATE_WEEKS || judged < GATE_ITEMS ? 'measuring' : real * 10 >= judged * 9 ? 'open' : 'short';
@@ -163,7 +176,7 @@ const growOf = (n) => GROW[n <= 0 ? 0 : n === 1 ? 1 : n <= 3 ? 2 : 3];
 function weekView(F, o) {
   const thisWeek = weekOf(o.today, o.start), week = o.week && DAY_RE.test(o.week) ? weekOf(o.week, o.start) : thisWeek;
   const live = gateOf(F, thisWeek, o.start).state === 'open';
-  const real = live ? (itemsByWeek(F, o.start).get(week) || []).filter((x) => x.real === true).sort(byNewest) : [];
+  const real = live ? (itemsByWeek(F, o.start).get(week) || []).filter(counts).sort(byNewest) : [];
   const cel = real.find((x) => !x.read);
   return { live, first: F.items.size === 0, week, from: week, to: addDays(week, 6), label: labelOf(week, thisWeek), grow: growOf(real.length),
     celebrate: cel ? cel.id : null, quiet: real.length === 0, items: real.map(shown) };
@@ -176,19 +189,19 @@ function weeksView(F, o) {
   const W = itemsByWeek(F, o.start), all = [...W.keys()].filter((w) => w <= thisWeek).sort();
   const weeks = [];
   if (all.length) for (let w = thisWeek; w >= all[0]; w = addDays(w, -7)) {
-    const real = (W.get(w) || []).filter((x) => x.real === true).sort(byNewest);
+    const real = (W.get(w) || []).filter(counts).sort(byNewest);
     weeks.push({ week: w, from: w, to: addDays(w, 6), label: labelOf(w, thisWeek), quiet: real.length === 0, items: real.map(shown) });
   }
   return { live, weeks };
 }
-/** PURE. GET /api/impact/check: the oldest finished week with a row not checked yet, all its rows (checked ones keep their mark). */
+/** PURE. GET /api/impact/check: last week's rows while its check is open (the whole of this week); dropped rows keep their mark for Undo.
+ *  looked: the card was shown already this week, so the row under Mentions goes; the card stays Home's chat intro until the week ends. */
 function checkView(F, o) {
   const thisWeek = weekOf(o.today, o.start), W = itemsByWeek(F, o.start);
   const gate = gateOf(F, thisWeek, o.start).state;
-  const open = [...W.keys()].filter((w) => w < thisWeek && W.get(w).some((x) => x.real === null)).sort();
-  if (!open.length) return { due: false, week: null, label: '', items: [], gate };
-  const week = open[0];
-  return { due: true, week, label: labelOf(week, thisWeek), items: W.get(week).sort(byNewest).map(shown), gate };
+  const week = addDays(thisWeek, -7), list = W.get(week) || [];
+  if (!list.length) return { due: false, week: null, label: '', items: [], gate, looked: false };
+  return { due: true, week, label: labelOf(week, thisWeek), items: list.sort(byNewest).map(shown), gate, looked: (F.looked || new Set()).has(week) };
 }
 
 module.exports = { LEDGER, KINDS, SOURCE_TYPES, GROW, GATE_ITEMS, GATE_WEEKS, COUNT_RE, dirOf, ledgerFile, readLines, read, append, clean, fold,

package/workspace/lib/initiative-cli.js

@@ -35,6 +35,18 @@ const triage = require('./triage.js');
 const lifecycle = require('./lifecycle-stage.js');
 const { parseArgs } = require('./schedule-cli');
 
+/** Batch 24 item 3: the new initiative starts on this repository's default workflow (routes-boards startOnDefault), as a page create does. */
+function startOnDefault(root, r, actor) {
+  try {
+    const D = require('./driver.js');
+    const dir = D.stateDirOf(root);
+    if (!dir) return;
+    const w = { id: D.wsIdOf(root), name: path.basename(root), root };
+    const ctx = { getWs: () => w, workspaceList: () => [w], stateDirFor: () => dir, selfRoot: path.resolve(__dirname, '..', '..') };
+    require('./routes-boards.js').startOnDefault(ctx, w, r.id, actor, { recordPath: r.path });
+  } catch { /* the initiative is made; it runs Product feature */ }
+}
+
 const COMMANDS = { initiative: ['new', 'top', 'up', 'down', 'bottom', 'after', 'check-by', 'adopt', 'drop', 'list', 'export'] };
 /** The horizon verbs D105 retired: they answer with what to use instead. */
 const RETIRED = Object.freeze(['now', 'next', 'later']);
@@ -121,8 +133,10 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     }
     if (flags.title) input.title = flags.title;
     for (const k of ['lane', 'anchor', 'intent', 'id']) if (flags[k]) input[k] = flags[k];
-    const r = writer.createInitiative(root, input, { actor: actorLib.fromCli(who), now });
+    const actor = actorLib.fromCli(who);
+    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.`);
   }
 

package/workspace/lib/open-mission.js

@@ -0,0 +1,14 @@
+'use strict';
+/* open-mission: a browser-test helper. The initiative mission (the telemetry card, the way to finish, About) starts hidden in its
+ * banner (batch 24 item 1). Suites that read the open card wrap their context with this, as a PM who unfolded it: any initiative
+ * with no fold of its own in the browser reads as open. A suite that checks the banner default does not use it. */
+async function openMission(ctx) {
+  await ctx.addInitScript(() => {
+    try {
+      const g = Storage.prototype.getItem;
+      Storage.prototype.getItem = function (k) { const v = g.call(this, k); return v == null && /^pmos\.iv\.mc\./.test(String(k)) ? '{"mc":true}' : v; };
+    } catch { /* no storage: the default holds */ }
+  });
+  return ctx;
+}
+module.exports = { openMission };

package/workspace/lib/page-warm.js

@@ -0,0 +1,68 @@
+'use strict';
+/* page-warm.js — the first page after a start opens as fast as a later one (page-open-speed).
+ *
+ *   warm({ host, port, paths, env, get }) → Promise<{ ran, ok } | { skipped }>
+ *
+ * Nothing is read until a page asks, so the first Home after PMOS starts made the server read every record cold: about 3 s against
+ * about 1.5 s for a later open (bench on the PM's data, 2026-11-02). A few seconds after the start, the server asks itself for the
+ * heaviest answers Home and the Board read, ONE AT A TIME over loopback, exactly as a page asks for them, so their read caches are
+ * filled before the PM opens a page. Only GET routes that write no "seen" or "read" mark are on the list: a warm-up is not the PM
+ * looking. PMOS_WARM=off stops it; a state folder under the system temp folder (a suite's) does not warm unless PMOS_WARM=on. */
+const PATHS = [
+  '/api/board-premium',
+  '/api/my-work-premium',
+  '/api/news-for-you',
+  '/api/briefing-premium/products',
+  '/api/programs',
+  '/api/sources',
+  '/api/notes',
+  '/api/live',
+  '/api/insights-premium',
+];
+
+function httpGet(host, port, p) {
+  return new Promise((resolve) => {
+    const req = require('http').get({ host, port, path: p, headers: { accept: 'application/json' }, timeout: 30000 }, (res) => {
+      res.resume(); res.on('end', () => resolve(res.statusCode)); res.on('error', () => resolve(0));
+    });
+    req.on('timeout', () => { req.destroy(); resolve(0); });
+    req.on('error', () => resolve(0));
+  });
+}
+
+async function warm({ host, port, paths = PATHS, env = process.env, get = httpGet } = {}) {
+  if (String(env.PMOS_WARM || '').toLowerCase() === 'off') return { skipped: 'off' };
+  if (!host || !port) return { skipped: 'no loopback address' };
+  let ok = 0;
+  for (const p of paths) { const code = await get(host, port, p); if (code >= 200 && code < 300) ok++; }
+  return { ran: paths.length, ok };
+}
+
+/** The loopback address among the server's binds, or null when it listens on none (a tailnet-only bind is not asked). */
+function loopbackOf(binds) {
+  const b = (binds || []).find((a) => a === '127.0.0.1' || a === 'localhost' || a === '::1' || a === '0.0.0.0' || a === '::');
+  if (!b) return null;
+  return b === '::1' || b === '::' ? '::1' : '127.0.0.1';
+}
+
+/** The server's wiring: when `start`, one warm-up DELAY_MS after the boot (the server is listening by then; a request that finds it not
+ *  yet up just fails and the page reads as before). The timer is unref'd, so it never holds a process open. */
+const DELAY_MS = 5000;
+/** Whether a start warms: PMOS_WARM=on or off decides; unset, a state folder under the system temp folder (every suite's, test-run.js)
+ *  does not warm, so no suite's server reads, or writes a forecast line, while the suite does. The PM's own state folder warms. */
+function shouldWarm(env, stateDir) {
+  const v = String(env.PMOS_WARM || '').toLowerCase();
+  if (v === 'off') return false;
+  if (v === 'on') return true;
+  if (!stateDir) return true;
+  const os = require('os'), path = require('path');
+  const rel = path.relative(path.resolve(os.tmpdir()), path.resolve(stateDir));
+  return !(rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+function create({ binds, port, stateDir = null, start = true, env = process.env, delayMs = DELAY_MS } = {}) {
+  const run = () => warm({ host: loopbackOf(binds), port: typeof port === 'function' ? port() : port, env }).catch(() => ({ failed: true }));
+  if (start && shouldWarm(env, stateDir)) { const t = setTimeout(run, delayMs); if (t.unref) t.unref(); }
+  return { run };
+}
+
+module.exports = { create, warm, shouldWarm, loopbackOf, PATHS };

package/workspace/lib/report-design.js

@@ -28,6 +28,8 @@
  *   version       { n, format, turn, answer, from }        a job (or an adopted cycle) landed D<n>
  *   accept        { n, rules }                             "This is it": D<n> is the design; brief.md is written
  *   revert        { n }                                    the next turn builds on D<n>
+ *   unsave        {}                                       Go back to a template version with the standard look: no design is saved
+ *                                                            (lib/routes-report-flow.js restore; brief.md is removed, cycles keep their look)
  *   error         { text, mode, slot?, sha? }              a job failed, timed out or wrote nothing usable
  *   cycle-decision { path, slot, diff, choice }            keep | adopt | match on a cycle that differs
  *
@@ -48,7 +50,7 @@ const zlib = require('zlib');
 const RD = require('./report-draft.js');
 const issues = require('./issues.js');
 
-const EVENTS = Object.freeze(['describe', 'sample', 'unsample', 'fetched', 'took', 'turn', 'version', 'accept', 'revert', 'error', 'cycle-decision']);
+const EVENTS = Object.freeze(['describe', 'sample', 'unsample', 'fetched', 'took', 'turn', 'version', 'accept', 'revert', 'unsave', 'error', 'cycle-decision']);
 const FORMATS = Object.freeze(['deck', 'doc']);
 const SAMPLE_KINDS = Object.freeze(['pdf', 'pptx', 'docx', 'image', 'pictures', 'link', 'pmos-doc']);
 const MAX_PICTURES = 12;
@@ -149,6 +151,9 @@ function fold(events) {
     } else if (l.ev === 'revert') {
       if (st.versions.has(l.n)) st.current = l.n;
       st.log.push({ at: l.at, who: 'you', kind: 'revert', text: `Back to D${l.n}. The next turn builds on it.`, version: l.n });
+    } else if (l.ev === 'unsave') {
+      st.saved = null; st.rules = null;
+      st.log.push({ at: l.at, who: whoOf(l), kind: 'unsave', text: 'Back to the standard look (a template went back).' });
     } else if (l.ev === 'error') {
       st.errors.push({ at: l.at, text: str(l.text), mode: l.mode || null, slot: l.slot || null, sha: l.sha || null });
       st.log.push({ at: l.at, who: 'pmos', kind: 'error', text: str(l.text) });