create-pmos 0.124.0 → 0.125.0

package/workspace/fixtures/initiatives-api/roadmap.json

@@ -66,7 +66,63 @@
           "label": "7 of 12"
         },
         "next_due": "2026-11-14",
-        "last_activity": "2026-10-04T09:00:00Z"
+        "last_activity": "2026-10-04T09:00:00Z",
+        "nine_stages": [
+          {
+            "key": "discover",
+            "label": "Discover",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "ideate",
+            "label": "Ideate",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "strategize",
+            "label": "Strategize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "prioritize",
+            "label": "Prioritize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "plan",
+            "label": "Plan",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "build",
+            "label": "Build",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "deliver",
+            "label": "Deliver",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "monitor",
+            "label": "Monitor",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "evaluate",
+            "label": "Evaluate",
+            "status": "pending",
+            "accepted": false
+          }
+        ]
       },
       {
         "id": "audit-log",
@@ -108,7 +164,63 @@
           "label": "3 of 5"
         },
         "next_due": "2026-10-20",
-        "last_activity": "2026-09-29T15:00:00Z"
+        "last_activity": "2026-09-29T15:00:00Z",
+        "nine_stages": [
+          {
+            "key": "discover",
+            "label": "Discover",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "ideate",
+            "label": "Ideate",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "strategize",
+            "label": "Strategize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "prioritize",
+            "label": "Prioritize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "plan",
+            "label": "Plan",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "build",
+            "label": "Build",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "deliver",
+            "label": "Deliver",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "monitor",
+            "label": "Monitor",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "evaluate",
+            "label": "Evaluate",
+            "status": "pending",
+            "accepted": false
+          }
+        ]
       }
     ],
     "next": [
@@ -145,7 +257,63 @@
           "label": "no breakdown"
         },
         "next_due": null,
-        "last_activity": "2026-09-20T10:00:00Z"
+        "last_activity": "2026-09-20T10:00:00Z",
+        "nine_stages": [
+          {
+            "key": "discover",
+            "label": "Discover",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "ideate",
+            "label": "Ideate",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "strategize",
+            "label": "Strategize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "prioritize",
+            "label": "Prioritize",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "plan",
+            "label": "Plan",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "build",
+            "label": "Build",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "deliver",
+            "label": "Deliver",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "monitor",
+            "label": "Monitor",
+            "status": "pending",
+            "accepted": false
+          },
+          {
+            "key": "evaluate",
+            "label": "Evaluate",
+            "status": "pending",
+            "accepted": false
+          }
+        ]
       }
     ],
     "later": []
@@ -191,7 +359,63 @@
         "label": "no breakdown"
       },
       "next_due": null,
-      "last_activity": "2026-07-01T10:00:00Z"
+      "last_activity": "2026-07-01T10:00:00Z",
+      "nine_stages": [
+        {
+          "key": "discover",
+          "label": "Discover",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "ideate",
+          "label": "Ideate",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "strategize",
+          "label": "Strategize",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "prioritize",
+          "label": "Prioritize",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "plan",
+          "label": "Plan",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "build",
+          "label": "Build",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "deliver",
+          "label": "Deliver",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "monitor",
+          "label": "Monitor",
+          "status": "pending",
+          "accepted": false
+        },
+        {
+          "key": "evaluate",
+          "label": "Evaluate",
+          "status": "pending",
+          "accepted": false
+        }
+      ]
     }
   ],
   "proposals": [

package/workspace/fixtures/initiatives-api/sheet.json

@@ -48,7 +48,63 @@
       "label": "7 of 12"
     },
     "next_due": "2026-11-14",
-    "last_activity": "2026-10-04T09:00:00Z"
+    "last_activity": "2026-10-04T09:00:00Z",
+    "nine_stages": [
+      {
+        "key": "discover",
+        "label": "Discover",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "ideate",
+        "label": "Ideate",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "strategize",
+        "label": "Strategize",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "prioritize",
+        "label": "Prioritize",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "plan",
+        "label": "Plan",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "build",
+        "label": "Build",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "deliver",
+        "label": "Deliver",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "monitor",
+        "label": "Monitor",
+        "status": "pending",
+        "accepted": false
+      },
+      {
+        "key": "evaluate",
+        "label": "Evaluate",
+        "status": "pending",
+        "accepted": false
+      }
+    ]
   },
   "stepper": [
     {

package/workspace/fixtures/one-home-baseline.json

@@ -0,0 +1,83 @@
+{
+  "_comment": "Items the console3 page makes actionable on more than one tab today (c3-one-home-test.js). Known-failing until the Phase 2 restructure of the console3 feedback plan; the suite fails only on a duplicate that is not listed here. Remove an entry when its duplicate is gone.",
+  "duplicates": [
+    {
+      "title": "accept the 15 oct interview invite",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "approve pricing-page copy before handoff",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "assign owners to 2 unowned workshop actions",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "confirm the 1 oct numbers before the 10:30 update",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "confirm the growth assumption in the q4 forecast",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "pick interview slots with 3 customers",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "review the 13:00 interview guide",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "say yes to sam: ship the logging change",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "self-serve onboarding: continue or park?",
+      "tabs": [
+        "brief",
+        "work"
+      ]
+    },
+    {
+      "title": "sso is live with 3 customers",
+      "tabs": [
+        "brief",
+        "init",
+        "rep"
+      ]
+    },
+    {
+      "title": "the board update is 70% ready",
+      "tabs": [
+        "init",
+        "rep"
+      ]
+    }
+  ]
+}

package/workspace/guide/layout.md

@@ -102,6 +102,8 @@ When the workspace needs an answer from you, for example the name for a rename o
 
 The workspace is neutral. A primary button is the text colour on the page colour, in both themes. The one brand colour marks the Agenda dot and the Agenda count, and nothing else. The bar, the dock and the bottom bar follow the theme; only a terminal stays dark. Corners are square. Controls are icons from one set, not text symbols. On a touch screen every field is 16 pixels, so the phone does not zoom when you tap it, and every control is at least 44 pixels high.
 
+On the console page (`/c3.html`), text on the blue accent and on a red badge is white in both themes. The page takes this colour from one token, so the colours stay the same when the theme changes.
+
 ## Keys
 
 | Key | What it does |

package/workspace/lib/engine/nine-stages.js

@@ -0,0 +1,81 @@
+'use strict';
+/*
+ * The nine stage names as a label layer over the workflow engine's derived stage (run 3).
+ *
+ * The engine derives one of six rungs (intake, spec, contract, build, eval, accepted) from the steps
+ * it found. This file names the nine stages the PM sees and says which of them each lane uses. It
+ * never decides a stage itself: a stage is `done` only when a derived signal shows it, and a stage
+ * no record can yet show is `no-signal`, not guessed.
+ *
+ * The lane sets below are a proposal for the PM to correct (see the run 3 contract in the PRD).
+ */
+
+const STAGES = ['discover', 'ideate', 'strategize', 'prioritize', 'plan', 'build', 'deliver', 'monitor', 'evaluate'];
+
+const LABELS = {
+  discover: 'Discover', ideate: 'Ideate', strategize: 'Strategize', prioritize: 'Prioritize', plan: 'Plan',
+  build: 'Build', deliver: 'Deliver', monitor: 'Monitor', evaluate: 'Evaluate',
+};
+
+// Which stages each product-code lane uses. Stages not listed read `skipped`.
+const LANE_STAGES = {
+  feature: STAGES,
+  discovery: ['discover', 'ideate', 'strategize', 'prioritize', 'evaluate'],
+  chore: ['plan', 'build', 'evaluate'],
+  incident: ['build', 'deliver', 'monitor', 'evaluate'],
+  content: ['ideate', 'plan', 'build', 'deliver'],
+  prototype: ['discover', 'ideate', 'evaluate'],
+};
+
+// Stages that have a derived signal today. Every other stage reads `no-signal` until its record exists.
+const SIGNALLED = new Set(['discover', 'plan', 'build', 'evaluate']);
+
+const RANK = { intake: 0, spec: 1, contract: 2, build: 3, eval: 4, accepted: 5 };
+
+// Stages that gain a signal only when the caller passes the records (scripts/records readAll plus optional `releases`).
+// With no records the output is exactly the older output, so the lifecycle-lens mirror stays equal.
+const RECORD_SIGNALLED = new Set(['ideate', 'strategize', 'prioritize', 'monitor', 'deliver']);
+
+// records: { initiative?, anchor?, ideas, hypotheses, decisions, bets, 'kr-metrics', releases } (every list optional).
+// The initiative id and anchor come from `derived` (id, anchor) or from records.initiative / records.anchor.
+function recordSignals(derived, records, buildDone) {
+  const id = (derived && derived.id) || records.initiative || null;
+  const anchor = (derived && derived.anchor) || records.anchor || null;
+  const mine = (list) => (list || []).filter((r) => id && r.initiative === id);
+  const kr = (records['kr-metrics'] || []).filter((m) => anchor && (m.rid === anchor || m.parent_kr === anchor || 'kr:' + m.rid === anchor));
+  return {
+    ideate: mine(records.ideas).length + mine(records.hypotheses).length > 0,
+    strategize: mine(records.decisions).length + mine(records.bets).length > 0,
+    prioritize: mine(records.bets).some((b) => ['now', 'next', 'later'].includes(b.horizon) && Number.isInteger(b.rank)),
+    monitor: !!buildDone && kr.some((m) => (m.readings || []).length > 0),
+    deliver: mine(records.releases).length > 0,
+  };
+}
+
+function nineStages(lane, derived, records) {
+  const laneSet = new Set(LANE_STAGES[lane] || STAGES);
+  const rank = RANK[derived && derived.stage] ?? 0;
+  const step = (key) => (derived && derived.steps || []).find((s) => s.key === key);
+  const done = {
+    discover: rank >= 1,
+    plan: rank >= 2,
+    build: rank >= 3 || (step('build') && step('build').status === 'done'),
+    evaluate: rank >= 4,
+  };
+  const accepted = rank >= 5;
+  const fromRecords = records && typeof records === 'object' ? recordSignals(derived, records, done.build) : null;
+  const out = [];
+  let currentSet = false;
+  for (const key of STAGES) {
+    let status;
+    if (!laneSet.has(key)) status = 'skipped';
+    else if (!SIGNALLED.has(key) && !(fromRecords && RECORD_SIGNALLED.has(key) && (key !== 'deliver' || fromRecords.deliver))) status = 'no-signal';
+    else if (done[key] || (fromRecords && fromRecords[key])) status = 'done';
+    else status = 'pending';
+    if (status === 'pending' && !currentSet) { status = 'current'; currentSet = true; }
+    out.push({ key, label: LABELS[key], status, accepted: key === 'evaluate' ? accepted : undefined });
+  }
+  return out;
+}
+
+module.exports = { STAGES, LABELS, LANE_STAGES, nineStages };

package/workspace/lib/engine/workflow-state.js

@@ -36,6 +36,7 @@
  * Zero dependencies, stock Node. It runs in CI, in a terminal, and inside the workspace server.
  */
 
+const { nineStages } = require('./nine-stages');
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
@@ -1178,6 +1179,7 @@ function computeWorkflowDerived(id, opts) {
     ok: true, id, lane, laneKnown: knownLane, legacy, in_change: inChange,
     last_activity: lastActivity, accepted: accepted.length > 0, stage, record: recRel,
     title: fm.title || id, anchor: fm.parent_kr || null, profile: 'product-code',
+    nine_stages: nineStages(effLane, { stage, steps }),
     ...facts,
     steps, blockers: blockers.map((s) => s.key), gate_failures: gateFailures.map((s) => s.rule || s.key),
     next: next ? { step: next.key, why: next.evidence, action: next.next || next.evidence } : null,

package/workspace/lib/facts-async.js

@@ -0,0 +1,51 @@
+'use strict';
+/* facts-async.js — the repo's initiative facts (scripts/signals/facts.js readRepoFacts) WITHOUT blocking the server.
+ *
+ * readRepoFacts derives every initiative's stage from git, once per initiative: minutes for ~300 records, and synchronous.
+ * Called inside the server process it stops every other request (the page sat "just loading"). This runs it in a child
+ * process (scripts/signals/facts-cli.js), keeps one result per root and day for five minutes, and shares one read in
+ * flight between callers, so a burst of requests starts one child, not one each. Once a result is older than five minutes it
+ * is still returned at once while a new read runs in the background (stale while revalidate), so only the first read waits.
+ */
+const { execFile } = require('child_process');
+const path = require('path');
+
+const CLI = path.resolve(__dirname, '..', '..', 'scripts', 'signals', 'facts-cli.js');
+const TTL_MS = 5 * 60 * 1000;
+const memo = new Map();       // root|today -> { at, facts }
+const inflight = new Map();   // root|today -> Promise
+
+function readFactsAsync(root, opts = {}) {
+  const today = opts.today || '';
+  const resolved = path.resolve(root || process.cwd());
+  const key = resolved + '|' + today;
+  const clock = opts.clock || Date.now;
+  const hit = memo.get(key);
+  const fresh = hit && clock() - hit.at < (opts.ttlMs == null ? TTL_MS : opts.ttlMs);
+  if (fresh) return Promise.resolve(hit.facts);
+
+  const start = () => {
+    if (inflight.has(key)) return inflight.get(key);
+    const run = opts.run || ((r, t) => new Promise((resolve, reject) => {
+      execFile(process.execPath, [CLI, r, t], { maxBuffer: 512 * 1024 * 1024, timeout: 15 * 60 * 1000 }, (err, out) => {
+        if (err) return reject(err);
+        try { resolve(JSON.parse(out)); } catch (e) { reject(e); }
+      });
+    }));
+    const p = Promise.resolve(run(resolved, today)).then((facts) => {
+      memo.set(key, { at: clock(), facts });
+      return facts;
+    }).finally(() => { inflight.delete(key); });
+    inflight.set(key, p);
+    return p;
+  };
+
+  // Stale while revalidate: an expired result is still the best answer for now. Return it at once and refresh in the
+  // background, so only the very first read of a repository ever waits (opts.stale === false turns this off).
+  if (hit && opts.stale !== false) { start().catch(() => {}); return Promise.resolve(hit.facts); }
+  return start();
+}
+
+function resetFactsCache() { memo.clear(); inflight.clear(); }
+
+module.exports = { readFactsAsync, resetFactsCache, TTL_MS };

package/workspace/lib/item-steps.js

@@ -0,0 +1,52 @@
+'use strict';
+/* item-steps.js — per-item steps for the PM's work items (console3 wave A1). Append-only JSONL, like pm-items.js.
+ *
+ * A step is { id, text, who }, who = 'you' | 'agent-drafts' | 'agent-does'. Events: step_added, who_set, step_removed.
+ * OUTWARD RULE: a step that sends something to a person (send, email, message, tell, post, reply to) is never
+ * 'agent-does'. It is forced to 'agent-drafts': the agent drafts and the PM's slide releases it. The outbox is
+ * scripts/outbox.js; it is deliberately not wired here.
+ * The writer is pm-items.appendEvent (same single-writer rule).
+ */
+const WHO = ['you', 'agent-drafts', 'agent-does'];
+const OUTWARD = /\b(send|sends|sending|email|emails|message|messages|tell|post|reply to)\b/i;
+
+const isOutward = (text) => OUTWARD.test(String(text || ''));
+
+// The who a step may hold: outward steps never go beyond 'agent-drafts'.
+function clampWho(text, who) {
+  if (!WHO.includes(who)) return null;
+  return who === 'agent-does' && isOutward(text) ? 'agent-drafts' : who;
+}
+
+function addStep(itemId, text, who, id) {
+  const t = String(text || '').trim();
+  if (!t) return { ok: false, error: 'the step needs text' };
+  const w = clampWho(t, who === undefined ? 'you' : who);
+  if (!w) return { ok: false, error: 'who must be you, agent-drafts or agent-does' };
+  return { ok: true, forced: w !== (who === undefined ? 'you' : who), event: { event: 'step_added', item_id: itemId, id, text: t, who: w } };
+}
+
+function setWho(lines, stepId, who) {
+  const step = foldSteps(lines).all.find((s) => s.id === stepId);
+  if (!step) return { ok: false, error: 'no such step' };
+  const w = clampWho(step.text, who);
+  if (!w) return { ok: false, error: 'who must be you, agent-drafts or agent-does' };
+  return { ok: true, who: w, forced: w !== who, event: { event: 'who_set', id: stepId, who: w } };
+}
+
+// Fold the lines into { byItem: { itemId: [step] }, all: [step] }, in the order added.
+function foldSteps(lines) {
+  const steps = new Map();
+  for (const ev of lines || []) {
+    if (!ev || !ev.id) continue;
+    if (ev.event === 'step_added') steps.set(ev.id, { id: ev.id, item_id: ev.item_id, text: ev.text, who: clampWho(ev.text, ev.who) || 'you' });
+    else if (ev.event === 'who_set' && steps.has(ev.id)) { const s = steps.get(ev.id); s.who = clampWho(s.text, ev.who) || s.who; }
+    else if (ev.event === 'step_removed') steps.delete(ev.id);
+  }
+  const all = [...steps.values()];
+  const byItem = {};
+  for (const s of all) (byItem[s.item_id] = byItem[s.item_id] || []).push({ id: s.id, text: s.text, who: s.who });
+  return { byItem, all };
+}
+
+module.exports = { WHO, isOutward, clampWho, addStep, setWho, foldSteps };

package/workspace/lib/jira-status.js

@@ -14,7 +14,7 @@
  *   which(root, key)                    → the initiative and ticket a key belongs to
  *
  * A READING is { key, summary, status, category: todo|doing|done, sprint: { name, state: active|future|closed } | null,
- * subtasks: { done, total }, flagged, reason, url }. A ticket the search did not return keeps its last reading, marked
+ * subtasks: { done, total }, fixVersion: [names], flagged, reason, url }. A ticket the search did not return keeps its last reading, marked
  * stale. Titles and statuses only: never a description, a comment or a person.
  *
  * BOUNDARY (J15). No network module, no child process. The only write is the snapshot file.
@@ -69,6 +69,11 @@ function flaggedIn(fields) {
   }
   return false;
 }
+/** fixVersions (Jira's release tags) as a list of names; the flat shape may say fixVersion or fixVersions, a name or a list. */
+function fixVersionsOf(v) {
+  const list = Array.isArray(v) ? v : v == null || v === '' ? [] : [v];
+  return [...new Set(list.map((x) => clip(nameOf(x), 80)).filter(Boolean))];
+}
 const SPRINT_STATES = ['active', 'future', 'closed'];
 /** One sprint, from an object { name, state } or a bare name. */
 function sprintOne(v) {
@@ -128,7 +133,7 @@ function normalizeIssue(x) {
     const st = f.status || {};
     const status = nameOf(st) || 'Unknown';
     const flagged = flaggedIn(f) || /block|impediment|on hold/i.test(status);
-    return { key, summary, status, category: categoryOf(status, st.statusCategory), sprint: sprintIn(f), subtasks: subtasksOf(f.subtasks),
+    return { key, summary, status, category: categoryOf(status, st.statusCategory), sprint: sprintIn(f), subtasks: subtasksOf(f.subtasks), fixVersion: fixVersionsOf(f.fixVersions),
       flagged, reason: flagged ? (flaggedIn(f) ? 'Flagged in Jira' : `Status: ${status}`) : null, url: urlOf(x, key) };
   }
   // The flat shape: what the skill tells the agent to write when it is unsure of the connector's shape.
@@ -136,7 +141,7 @@ function normalizeIssue(x) {
   if (!summary) return null;
   const status = oneLine(x.status) || 'Unknown';
   const flagged = x.flagged === true || /block|impediment|on hold/i.test(status);
-  return { key, summary, status, category: categoryOf(status, x.category), sprint: sprintOf(x.sprint), subtasks: subtasksOf(x.subtasks),
+  return { key, summary, status, category: categoryOf(status, x.category), sprint: sprintOf(x.sprint), subtasks: subtasksOf(x.subtasks), fixVersion: fixVersionsOf(x.fixVersions != null ? x.fixVersions : x.fixVersion),
     flagged, reason: flagged ? clip(oneLine(x.reason || x.flag_reason || (x.flagged === true ? 'Flagged in Jira' : `Status: ${status}`)), 160) : null,
     url: urlOf(x, key) };
 }