create-pmos 0.123.0 → 0.125.0

package/workspace/public/pm/lifecycle-lens-model.js

@@ -0,0 +1,228 @@
+/* pm/lifecycle-lens-model.js — the pure half of the Lifecycle lens (console3 wave B1). No DOM, so node can import it.
+ *
+ * Stage is DERIVED, never set. The lens reads each initiative's `nine_stages` (scripts/nine-stages.js: one of
+ * done | current | pending | no-signal | skipped per stage). The roadmap payload does not carry `nine_stages` yet, so
+ * `nineOf` falls back to a small MIRROR of scripts/nine-stages.js (STAGES, LANE_STAGES, SIGNALLED and the status rule),
+ * fed by the rung the row's `stage.id` names. The mirror is approximate: the row's stage is the plan-tree group, not the
+ * engine's raw rung, so an accepted initiative cannot be told apart from one in Evaluate. When the server sends
+ * `nine_stages`, that wins and the mirror is not used.
+ */
+
+export const STAGES = ['discover', 'ideate', 'strategize', 'prioritize', 'plan', 'build', 'deliver', 'monitor', 'evaluate'];
+export const LABELS = { discover: 'Discover', ideate: 'Ideate', strategize: 'Strategize', prioritize: 'Prioritize', plan: 'Plan', build: 'Build', deliver: 'Deliver', monitor: 'Monitor', evaluate: 'Evaluate' };
+// Mirror of scripts/nine-stages.js LANE_STAGES and SIGNALLED.
+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'],
+};
+const SIGNALLED = new Set(['discover', 'plan', 'build', 'evaluate']);
+// The plan-tree group id of a row's stage, as an engine rung rank (nine-stages.js RANK). Unknown groups read intake.
+const GROUP_RANK = { intake: 0, spec: 1, brief: 1, draft: 1, contract: 2, build: 3, evaluate: 4, handoff: 4 };
+
+/** The nine statuses of one row: its own `nine_stages` when the server sent them, else the mirror. */
+export function nineOf(row) {
+  if (row && Array.isArray(row.nine_stages) && row.nine_stages.length) return row.nine_stages;
+  const lane = row && row.lane;
+  const laneSet = new Set(LANE_STAGES[lane] || STAGES);
+  const gid = row && row.stage && row.stage.id;
+  const rank = GROUP_RANK[gid] ?? 0;
+  const done = { discover: rank >= 1, plan: rank >= 2, build: rank >= 3, evaluate: rank >= 4 };
+  let cur = false;
+  return STAGES.map((key) => {
+    let status;
+    if (!laneSet.has(key)) status = 'skipped';
+    else if (!SIGNALLED.has(key)) status = 'no-signal';
+    else if (done[key]) status = 'done';
+    else status = 'pending';
+    if (status === 'pending' && !cur) { status = 'current'; cur = true; }
+    return { key, label: LABELS[key], status };
+  });
+}
+
+/** The stage an initiative sits in: the first `current`; else the last `done`; else null (nothing shows a stage yet). */
+export function stageBucket(nine) {
+  const list = Array.isArray(nine) ? nine : [];
+  const cur = list.find((s) => s.status === 'current');
+  if (cur) return cur.key;
+  let last = null;
+  for (const s of list) if (s.status === 'done') last = s.key;
+  return last;
+}
+
+/** Group rows by stage: { buckets: { discover: [row…], … }, unplaced: [row…] }. `scope` is an initiative id or null for all. */
+export function bucketRows(rows, scope) {
+  const buckets = Object.fromEntries(STAGES.map((k) => [k, []]));
+  const unplaced = [];
+  for (const r of rows || []) {
+    if (scope && r.id !== scope) continue;
+    const k = stageBucket(nineOf(r));
+    if (k && buckets[k]) buckets[k].push(r); else unplaced.push(r);
+  }
+  return { buckets, unplaced };
+}
+
+/** How one stage reads across the scoped rows: 'no-signal' when every row that uses it has no signal, 'skipped' when every row skips it. */
+export function stageNote(key, rows, scope) {
+  const sts = (rows || []).filter((r) => !scope || r.id === scope).map((r) => (nineOf(r).find((s) => s.key === key) || {}).status);
+  if (!sts.length) return null;
+  if (sts.every((s) => s === 'skipped')) return 'skipped';
+  if (sts.every((s) => s === 'skipped' || s === 'no-signal')) return 'no-signal';
+  return null;
+}
+
+/* ── what each stage needs (console3.html C3.REQ, line 4687): the requirement rows of the lens, each with who does it ── */
+export const REQ = {
+  discover: [['brief', 'Discovery brief with a stop rule', 'agent'], ['evidence', 'Evidence from 3 or more sources', 'agent'], ['cont', 'Continue or park', 'pm']],
+  ideate: [['opts', 'Two or more options, one recommended', 'agent']],
+  strategize: [['bet', 'Bet statement tied to the anchor', 'agent']],
+  prioritize: [['commit', 'Commit: it fits Now capacity', 'pm']],
+  plan: [['prd', 'PRD with done criteria', 'agent'], ['rub', 'Rubric and pre-run contract', 'agent'], ['plan', 'Breakdown reviewed', 'pm']],
+  build: [['tix', 'Build tickets merged, required CI green', 'factory'], ['rev', 'Review against the rubric', 'agent']],
+  deliver: [['rel', 'Release shipped', 'pm']],
+  monitor: [['out', 'Outcome check after 2 weeks', 'agent']],
+  evaluate: [['verd', 'Verdict: what we learned, next bet seeded', 'pm']],
+};
+/** Who does a requirement: [icon, word]. */
+export const reqWho = (w) => (w === 'pm' ? ['user', 'you'] : w === 'factory' ? ['branch', 'factory'] : ['spark', 'agent']);
+/** The agent's or factory's requirements of the same stage that are not done yet: a PM decision waits for them (c3prevPending). `isDone(key)` says what is done. */
+export const prevPending = (stage, key, isDone) => (REQ[stage] || []).filter((r) => r[2] !== 'pm' && r[0] !== key && !isDone(r[0]));
+/** What the agent is asked to draft, per requirement: [the offer, what it is]. */
+export const DRAFT_TEXT = {
+  brief: ['Draft the discovery brief', 'A one-page brief with a stop rule'], evidence: ['Gather the evidence', 'Three or more sources, each cited'], opts: ['Draft the options', 'Two or more, one recommended, with the cost of each'],
+  bet: ['Draft the bet statement', 'Tied to the anchor'], prd: ['Draft the PRD', 'Done criteria first'], rub: ['Draft the rubric and pre-run contract', 'The rubric is the spec; the contract is agreed before any build'],
+  rev: ['Review the build against the rubric', 'Outcome only, weighted, against the threshold'], out: ['Run the outcome check', 'Two weeks after release, from the data'],
+};
+/** The PM's decision per requirement: [yes label, yes effect], [no label, no effect], the sentence. */
+export const DECIDE_TEXT = {
+  cont: [['Continue to the next stage', 'The stop rule stays in force'], ['Park it, reason recorded', 'Frees the discovery slot'], 'The stop rule is the test. Read the evidence and decide: a close call is a reason to ask for more, not to guess.'],
+  commit: [['Commit it to Now', 'It fits Now capacity'], ['Keep it in Prioritize', 'Waits for capacity'], 'Now has a limit. The least sure bet goes back if it fills.'],
+  plan: [['Approve the plan', 'Breakdown, owners and dates are agreed'], ['Send the breakdown back', 'The agent revises it'], 'Check that every work item has an owner before you approve.'],
+  rel: [['Release it', 'The release is recorded as shipped by your slide'], ['Hold it', 'The date moves; promises are re-told'], 'Release needs its readiness checks and an outside change in Jira, which needs its own slide.'],
+  verd: [['Record the verdict: iterate', 'The next bet is seeded from the lesson'], ['Record the verdict: stop', 'Frees the capacity'], 'The verdict is a human judgement; the agent only drafts the evidence.'],
+};
+/** The stages a lane uses, in order (the lane's own list). */
+export const laneStages = (lane) => LANE_STAGES[lane] || STAGES;
+
+/* ── the derived panels of the lens (console3 wave L1). Ports of scripts/trust/reader.js (the PM's sample), sections 11 to 16:
+ *    11 PRIORITIZE  score = impact x confidence / effort, capacity in bets
+ *    12 DISCOVER    hypothesis status from weighted evidence; evidence whose source is not a known file is untraced
+ *    14 GATE LADDER the six gates in order, the next gate, order violations
+ *    15 RUBRIC      the weighted score against the threshold, the weakest dimension, the watermelon guard
+ *    16 NORTH STAR  corrections per agent run, lower is better
+ *  Pure: no DOM, no fetch. Real records feed them; nothing here invents a number. ── */
+const isNum = (v) => typeof v === 'number' && Number.isFinite(v);
+
+/** The score of an idea (reader.js section 11: impact x confidence / effort, two decimals). null when a figure is missing. */
+export function ideaScore(x) {
+  if (!x || !isNum(x.imp) || !isNum(x.conf) || !isNum(x.eff) || x.eff <= 0) return null;
+  return Math.round(x.imp * x.conf / x.eff * 100) / 100;
+}
+/** An ideas record (scripts/records: title, impact, effort, confidence; optional initiative, source, status, why) as the lens draws it. */
+export function normIdea(r) {
+  const o = r || {};
+  const st = ['new', 'short', 'committed', 'parked'].includes(o.status) ? o.status : o.status === 'shortlisted' ? 'short' : 'new';
+  return { id: String(o.rid || o.id || ''), n: String(o.title || ''), init: String(o.initiative || ''), imp: Number(o.impact), eff: Number(o.effort), conf: Number(o.confidence),
+    src: ['agent', 'customer', 'you'].includes(o.source) ? o.source : 'you', st, why: String(o.why || '') };
+}
+/** The ideas that are ranked: not parked, best score first (reader.js 11). */
+export const rankIdeas = (ideas) => (ideas || []).filter((x) => x.st !== 'parked' && ideaScore(x) != null).sort((a, b) => ideaScore(b) - ideaScore(a));
+/** Capacity: the effort the PM holds (shortlisted and committed) against the capacity figure. cap = null when none is recorded. */
+export function capacityUsed(ideas, cap) {
+  const used = (ideas || []).filter((x) => x.st === 'short' || x.st === 'committed').reduce((a, x) => a + (isNum(x.eff) ? x.eff : 0), 0);
+  return { used, cap: isNum(cap) ? cap : null, over: isNum(cap) ? Math.max(0, used - cap) : null };
+}
+
+/** A hypotheses record as the lens draws it. `evidence` is [{ src, dir: 'supports'|'refutes', w }]. */
+export function normHyp(r) {
+  const o = r || {};
+  const ev = (Array.isArray(o.evidence) ? o.evidence : []).filter((e) => e && typeof e === 'object').map((e) => ({ src: String(e.src || ''), dir: e.dir === 'refutes' ? 'refutes' : 'supports', w: isNum(Number(e.w)) ? Number(e.w) : 1, at: e.at ? String(e.at) : '' }));
+  return { id: String(o.rid || o.id || ''), t: String(o.title || ''), init: String(o.initiative || ''), falsifier: String(o.falsifier || ''), review_by: String(o.review_by || ''), ev };
+}
+/** The status of a hypothesis, as reader.js section 12 derives it: net = sum of the weights (supports plus, refutes minus); net >= 3 is supported,
+ *  net <= -2 is refuted, anything between is open. `known` is a Set (or object) of the sources that exist; a source outside it is untraced.
+ *  The reader has three statuses. The page splits "open" for display only, so the PM can tell an empty hypothesis from a contested one:
+ *  `shown` is untested (no evidence), mixed (evidence both ways), or open (one-sided but below the bar). `status` stays the reader's. */
+export function hypStatus(h, known) {
+  const ev = (h && h.ev) || [];
+  const net = ev.reduce((a, e) => a + (e.dir === 'supports' ? e.w : -e.w), 0);
+  const status = net >= 3 ? 'supported' : net <= -2 ? 'refuted' : 'open';
+  const has = known instanceof Set ? (s) => known.has(s) : known ? (s) => !!known[s] : () => false;
+  const untraced = ev.filter((e) => !has(e.src)).map((e) => e.src || '(no source)');
+  const sup = ev.filter((e) => e.dir === 'supports').length; const ref = ev.length - sup;
+  const shown = status !== 'open' ? status : !ev.length ? 'untested' : sup && ref ? 'mixed' : 'open';
+  return { status, shown, net, untraced, supports: sup, refutes: ref };
+}
+export const HYP_LABEL = { supported: 'Supported', refuted: 'Refuted', mixed: 'Mixed', untested: 'Untested', open: 'Open' };
+
+/** The six gates the mockup draws, and the engine step each reads (scripts/workflow-state.js steps; the rule text of each step is its `basis.rule`):
+ *  Spec = spec, Rubric = contract (done criteria and test method agreed, D13), Build = build, Quality = quality, Review = review, Acceptance = accept. */
+export const GATES = [['Spec', 'spec'], ['Rubric', 'contract'], ['Build', 'build'], ['Quality', 'quality'], ['Review', 'review'], ['Acceptance', 'accept']];
+const dayOf = (v) => { const m = /^(\d{4}-\d{2}-\d{2})/.exec(String(v || '')); return m ? m[1] : ''; };
+/** The gate ladder from one initiative's ladder row (the steps of `GET /api/console?name=ladder`). Each gate: { name, key, state, evidence, rule, date }.
+ *  state is done | next (the first gate not done, the one in progress) | open (not yet) | na (cut by the PM or not required) | unknown (the engine does not claim it, e.g. CI decides).
+ *  A violation is a gate done before an earlier gate that is not done (reader.js 14 `viol`): "Build before Rubric"; with first-seen dates, also a gate done on an earlier day than the gate before it. */
+export function gateLadder(row) {
+  const steps = (row && Array.isArray(row.steps)) ? row.steps : [];
+  const by = Object.fromEntries(steps.map((s) => [s.key, s]));
+  let nextAt = -1;
+  const gates = GATES.map(([name, key], i) => {
+    const s = by[key] || null;
+    let state = !s ? 'unknown' : s.status === 'done' ? 'done' : s.status === 'na' ? 'na' : s.status === 'unknown' ? 'unknown' : 'open';
+    if (state === 'open' && nextAt < 0) { nextAt = i; state = 'next'; }
+    return { name, key, state, evidence: s ? String(s.evidence || '') : 'the engine returned no step for this gate', rule: s && s.basis ? String(s.basis.rule || '') : '', date: s && s.basis ? dayOf(s.basis.first_seen) : '', blocking: !!(s && s.blocking) };
+  });
+  const viol = [];
+  gates.forEach((g, i) => {
+    if (g.state !== 'done') return;
+    gates.slice(0, i).forEach((p) => {
+      if (p.state === 'na' || p.state === 'unknown') return;
+      if (p.state !== 'done') viol.push(g.name + ' before ' + p.name);
+      else if (g.date && p.date && g.date < p.date) viol.push(g.name + ' before ' + p.name + ' (' + g.date + ' against ' + p.date + ')');
+    });
+  });
+  const next = gates.find((g) => g.state === 'next') || null;
+  return { gates, next, violations: viol, done: gates.filter((g) => g.state === 'done').length, counted: gates.filter((g) => g.state !== 'na').length, nextAction: row && row.next ? row.next : null, blockers: (row && row.blockers) || [], failures: (row && row.gate_failures) || [] };
+}
+/** The cells of the mockup's `.gt` bar: 'd' done, 'h' next (half), '' open, 'na', 'u' (unknown). */
+export const gateCell = (g) => (g.state === 'done' ? 'd' : g.state === 'next' ? 'h' : g.state === 'na' ? 'na' : g.state === 'unknown' ? 'u' : '');
+
+/** An evaluation row (planning/runs/evals.jsonl: score, threshold or pass_threshold, dimensions as { name: score }, verdict, evaluator_model) as the scorecard.
+ *  The recorded score is shown as recorded. A weight is used only when a row carries one (`dims` as [{ dim, w, score }], the sample's form); otherwise the
+ *  dimensions are unweighted and the page says so. Dimensions that are not numbers are dropped. */
+export function normEval(e) {
+  if (!e || typeof e !== 'object') return null;
+  let dims = [];
+  if (Array.isArray(e.dims)) dims = e.dims.filter((d) => d && isNum(d.score)).map((d) => ({ name: String(d.dim || d.name || ''), w: isNum(d.w) ? d.w : null, score: d.score }));
+  else if (e.dimensions && typeof e.dimensions === 'object') dims = Object.entries(e.dimensions).filter(([, v]) => isNum(v)).map(([k, v]) => ({ name: k, w: null, score: v }));
+  const weighted = dims.length && dims.every((d) => d.w != null);
+  const computed = weighted ? dims.reduce((a, d) => a + d.w * d.score, 0) : dims.length ? dims.reduce((a, d) => a + d.score, 0) / dims.length : null;
+  const score = isNum(e.score) ? e.score : computed;
+  const thr = isNum(e.threshold) ? e.threshold : isNum(e.pass_threshold) ? e.pass_threshold : null;
+  return { score, threshold: thr, dims, weighted: !!weighted, verdict: String(e.verdict || ''), model: String(e.evaluator_model || ''), at: String(e.recorded_at || e.at || ''), run: String(e.run_id || e.run || '') };
+}
+/** The verdict of a scorecard: passes (score at or over the threshold), the weakest dimension, and the watermelon guard (reader.js 15: a pass while a dimension scores under 0.6). */
+export function evalVerdict(ev) {
+  if (!ev || ev.score == null) return null;
+  const weakest = ev.dims.slice().sort((a, b) => a.score - b.score)[0] || null;
+  const passes = ev.threshold != null ? ev.score >= ev.threshold : null;
+  const watermelon = !!(passes && weakest && weakest.score < 0.6);
+  return { passes, weakest, watermelon, below: ev.threshold != null && !passes };
+}
+/** The newest evaluation per initiative from a list of rows (recorded_at, then file order). */
+export function latestEvals(rows) {
+  const out = {};
+  (rows || []).forEach((r, i) => { const id = r && r.initiative_id; if (!id) return; const at = String(r.recorded_at || r.at || ''); const p = out[id]; if (!p || at >= p.at) out[id] = { at, i, row: r }; });
+  return Object.fromEntries(Object.entries(out).map(([k, v]) => [k, v.row]));
+}
+/** Corrections per run (reader.js 16, lower is better), two decimals, for each bucket and the change from the first to the last. */
+export function correctionRate(series) {
+  const s = (series || []).filter((x) => x && x.runs > 0);
+  if (!s.length) return null;
+  const rate = (x) => Math.round(x.corrections / x.runs * 100) / 100;
+  const vals = s.map(rate);
+  return { now: vals[vals.length - 1], from: vals[0], vals, improved: vals[vals.length - 1] < vals[0] };
+}

package/workspace/public/pm/lifecycle-lens.js

@@ -0,0 +1,261 @@
+/* pm/lifecycle-lens.js — the Lifecycle lens of Initiatives (console3 wave B1; R4b: on the console3 mockup's own markup and CSS).
+ *
+ * The mockup (prototype/pmos-console-handoff/mockups/console3.html) is the UI. Lifted: the view bar `.calbar` with the nine stages
+ * as `.seg` buttons (icon, label, `.bdg.g` count) and the scope as `.chips2` pills (iniHead, line 3576); the lens header `.lh`
+ * (iniLensHead, line 3579); `.calwrap > .calbody > .brief.sbb > .bcols > .bcol.l/.r` (vIni, line 3600); the card deck `.cdeck >
+ * .deck > .fc` with the dots `.dk .dkd` (iniDeck, line 3580); the lifecycle line `.lc` for one initiative (lifecycle, line 3487;
+ * the mockup's seven columns are nine here, as the mockup's own override at c3:20 makes them); and the stage's list as
+ * `section.card.sect > .sh2 + ul.list > li.nrow` with a case file in `.xp > .xi` (c3needs, line 4714). Styles: pm/console3.css.
+ *
+ * What is real: the rows of the Initiatives view ctx (the roadmap horizons rows) and the nine stages derived from them
+ * (lifecycle-lens-model.js). Stage is derived, never set; a stage with no signal reads "no signal yet", never done or pending;
+ * a stage the lane skips reads skipped. Park (on hold) and Kill (cancelled) go through setLifecycle with a reason, as the sheet's
+ * lifecycle menu does. `nine_stages` is not in that payload yet, so the model mirrors scripts/nine-stages.js; the page says so.
+ * Not lifted: the mockup's invented cards (hypotheses, scores, ideas, charts, lines 3490 to 3562) and its right-column charts;
+ * the Build and Deliver lists of Jira tickets and releases (Releases is its own view).
+ * What a stage needs (c3needs, line 4713): one row per requirement of the stage (REQ in the model), for each initiative at it, each with a
+ * case file in place: an agent's requirement offers "Have the agent: draft it" and "Not yet"; the PM's decision offers its two answers;
+ * the factory's is read-only. This page cannot start an agent or record a stage decision, so in real mode those slides are drawn
+ * disabled with the reason; the demo (?demo=1) lets the slide mark it done. Park or Kill goes through the lifecycle route with the reason
+ * as the option. Swipe right or left and the keys e, n, j, k work on every row. A deck card per initiative at the stage (five at most; the rest are in
+ * the list) replaces the mockup's five invented cards.
+ * Self-registers as the 'lifecycle' Initiatives view, like Timeline and Releases.
+ */
+import { el } from './dom.js';
+import { ensureComponentsCss } from './primitives.js';
+import { registerInitiativesView } from './registry.js';
+import { setLifecycle } from './initiatives-api.js';
+import { STAGES, LABELS, bucketRows, stageNote, nineOf, REQ, reqWho, prevPending, DRAFT_TEXT, DECIDE_TEXT } from './lifecycle-lens-model.js';
+import { rowShell, caseNode, markDone, say } from './c3-init-extras.js';
+import { lensPanels } from './c3-lifecycle-panels.js';
+import { strategyPanel } from './c3-strategy-panels.js';
+import { ensureC3Css, c3ic, c3ring, c3Phone } from './pm-work-view.js';
+
+const views = new WeakMap();
+const PILLS = 7;     // the mockup's scope row has five initiatives; a repository has hundreds, so the row shows the first few and says so
+const LIST_MAX = 20;  // a stage's list shows this many rows, then "Show all"
+const ICON = { discover: 'search', ideate: 'spark', strategize: 'flag', prioritize: 'scale', plan: 'tree', build: 'branch', deliver: 'out', monitor: 'report', evaluate: 'check' };   // ILI, lines 3437 and 4686
+const short = (t, n) => { t = String(t || ''); return t.length > n ? t.slice(0, n - 1) + '…' : t; };
+
+/* ── the mockup's Strategize lens (console3.html nsChart line 2833, sigCard 2883, matCard 2894), drawn only when ctx.strategy is given. The
+ * roadmap route does not send one; the /c3.html demo mode does (the mockup's north star series, early signals and maturity table). ───── */
+const SVGNS = 'http://www.w3.org/2000/svg';
+const sv = (tag, attrs, ...kids) => { const n = document.createElementNS(SVGNS, tag); for (const k of Object.keys(attrs || {})) if (attrs[k] != null) n.setAttribute(k, attrs[k]); for (const c of kids) if (c) n.appendChild(c); return n; };
+const svt = (x, y, t, a) => { const n = sv('text', { x, y, ...(a || {}) }); n.textContent = t; return n; };
+const SEV = { watch: ['Watch', 'var(--acc)', 'eye'], drift: ['Drift', 'var(--warning)', 'clock'], pivot: ['Pivot', 'var(--destructive)', 'alert'], up: ['Upside', 'var(--success)', 'up'] };
+
+function miniSpark(a, c) {
+  const W = 64; const H = 26; const mn = Math.min(...a); const mx = Math.max(...a); const X = (i) => 3 + i * (W - 6) / (a.length - 1); const Y = (v) => H - 4 - (v - mn) / (mx - mn || 1) * (H - 8);
+  return sv('svg', { class: 'spk', viewBox: `0 0 ${W} ${H}`, 'aria-hidden': 'true', style: 'width:64px;height:26px' }, sv('polyline', { points: a.map((v, i) => X(i) + ',' + Y(v)).join(' '), fill: 'none', stroke: c, 'stroke-width': 2, 'stroke-linecap': 'round', 'stroke-linejoin': 'round' }), sv('circle', { cx: X(a.length - 1), cy: Y(a[a.length - 1]), r: 3, fill: c }));
+}
+function signalsCard(list) {
+  const order = ['pivot', 'drift', 'watch', 'up'];
+  return el('section', { class: 'card', 'data-lc-strategy': 'signals' }, el('h3', null, c3ic('alert'), 'Early signals ', el('span', { class: 'dim', style: 'text-transform:none;letter-spacing:0' }, 'before the numbers say it')),
+    el('ul', { class: 'sgl', style: 'list-style:none;margin:0;padding:0' }, list.slice().sort((a, b) => order.indexOf(a.sev) - order.indexOf(b.sev)).slice(0, 4).map((g) => { const V = SEV[g.sev];
+      return el('li', { class: 'sgr', style: '--c:' + V[1] }, el('span', { class: 'ki', style: 'color:' + V[1] }, c3ic(V[2])),
+        el('div', { style: 'min-width:0' }, el('div', { class: 'st1' }, g.t), el('div', { class: 'st2' }, g.ev), el('div', { class: 'st3' }, el('span', { class: 'sv' }, V[0]), el('span', null, c3ic('target', 'sm'), g.thr), el('span', null, c3ic('clock', 'sm'), g.ttt))), miniSpark(g.sp, V[1])); })));
+}
+/** The mockup's lifecycle(id) line: one cell per stage; done is `d`, the current one `n`. */
+function lcLine(row) {
+  const nine = nineOf(row);
+  return el('div', { class: 'lc', role: 'img', 'aria-label': 'Lifecycle' }, nine.map((s) => el('div', {
+    class: s.status === 'done' ? 'd' : s.status === 'current' ? 'n' : '', title: s.label + ': ' + (s.status === 'no-signal' ? 'no signal yet' : s.status),
+    'data-lc-cell': s.key, 'data-status': s.status, style: s.status === 'skipped' ? 'opacity:.4' : null,
+  }, el('i'), (s.label || s.key).slice(0, 5))));
+}
+
+/** One deck card for an initiative at the stage: the mockup's card (`.fc > .cf > .cfa + .cfh + .cff`) with real fields only. */
+function deckCard(V, row, i, n) {
+  const nine = nineOf(row);
+  const signalled = nine.filter((s) => s.status === 'done' || s.status === 'current' || s.status === 'pending');
+  const done = nine.filter((s) => s.status === 'done').length;
+  const cur = nine.find((s) => s.status === 'current');
+  const open = () => V.ctx.openInitiative(V.ctx.repo, row.id);
+  return el('article', { class: 'fc lnk' + (i === 0 ? ' on' : ''), tabindex: '0', role: 'button', 'aria-label': 'Open ' + row.title + ', card ' + (i + 1) + ' of ' + n,
+    'data-lc-deck': row.id, style: '--tc:var(--acc)', onClick: open, onKeydown: (e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); open(); } } },
+    el('div', { class: 'ff' },
+      el('div', null, el('span', { class: 'tg f', style: '--tc:var(--acc)' }, c3ic('init', 'sm'), row.lane || 'feature')),
+      el('div', { class: 'cf' },
+        el('div', { class: 'cfa' }, el('h2', null, row.title)),
+        el('div', { class: 'cfh' }, el('div', { class: 'hero', 'data-hero': 'ring' }, c3ring(done, Math.max(1, signalled.length), 64, done + '/' + signalled.length))),
+        el('div', { class: 'cff' },
+          el('div', { class: 'cfx' }, el('span', null, c3ic('clock', 'sm'), cur ? 'now: ' + cur.label : 'all signalled stages are done')),
+          el('span', { class: 'cfr n' }, 'Tap to open it ', c3ic('next', 'sm'))))));
+}
+
+/* ── what a stage needs: one row per requirement, each with a case file (console3.html c3needs, line 4713; C3.cases.rq line 4719) ── */
+const isDemo = () => !!window.__c3demo;
+/** Is a requirement done for an initiative at this stage? The nine-stage rule says a stage that is done has all its requirements; at the current stage nothing is
+ *  recorded per requirement, so none is shown done unless the PM's slide has just recorded it (the demo also carries the mockup's own table). */
+function reqDone(V, row, L, key) {
+  const st = (nineOf(row).find((x) => x.key === L) || {}).status;
+  if (st === 'done') return true;
+  if ((V.rq || {})[row.id + '|' + key]) return true;
+  const d = window.__c3reqDone && window.__c3reqDone[row.id]; return !!(d && d[key]);
+}
+const openIt = (V, row) => V.ctx.openInitiative(V.ctx.repo, row.id);
+
+function rqCase(V, row, L, r) {
+  const [key, text, who] = r; const nm = row.title; const stg = LABELS[L]; const demo = isDemo();
+  const done = reqDone(V, row, L, key);
+  const lane = nineOf(row); void lane;
+  const base = [['init', nm + ', ' + (row.lane || 'feature') + ' lane', 'Lane'], ['target', 'Anchor: ' + (row.anchor || 'none'), 'Anchor', row.anchor ? 'ok' : 'bad']];
+  const go = ['open', row.id, 'Open ' + nm];
+  if (done) return { sit: text + ' is done for ' + nm + '.', conf: 90, chg: [['check', 'Counted in the derived stage', '', 'ok']], opts: [], go };
+  if (who === 'factory') return { sit: 'The factory builds from the tickets and opens pull requests. Its progress fills this by itself. You cannot tick it.', conf: 88, chg: [['branch', 'Merged work is counted from Jira, read-only', 'Jira, CI', 'ok'], ['shield', 'The factory is propose-only: it never merges and never writes this record', 'D65']], opts: [], go };
+  if (who === 'agent') {
+    const t = DRAFT_TEXT[key] || ['Draft it', ''];
+    return { sit: 'Nothing has this yet. An agent drafts it and you read it before it counts. ' + nm + ' stays at ' + stg + ' until it exists.', conf: 82, chg: base, cta: 'Slide to start the draft', go,
+      outboxReason: 'An agent session does the drafting, and this page cannot start one. Ask it in your terminal; the draft comes back for you to read.',
+      opts: [{ id: 'go', l: 'Have the agent: ' + t[0].toLowerCase(), rec: 1, outward: !demo, fx: [['spark', t[1], 'ok'], ['shield', 'Inside the repo; nothing goes outside', 'ok']] }, { id: 'nt', l: 'Not yet', fx: [['clock', 'The stage stays at ' + stg, 'warn']] }] };
+  }
+  const pend = prevPending(L, key, (k) => reqDone(V, row, L, k));
+  if (pend.length) return { sit: 'This is your decision, and it comes after the agent’s drafts. Read them first: approving without reading is how errors go out.', conf: 70, chg: [['clock', 'Waiting for: ' + pend.map((q) => q[1]).join('; '), 'agent', 'warn']], opts: [], go };
+  const d = DECIDE_TEXT[key] || [['Decide yes', ''], ['Not yet', ''], 'This is your decision.'];
+  return { sit: d[2], conf: key === 'cont' ? 62 : 78, chg: [['init', nm + ' · ' + stg, 'Stage'], base[1]], cta: 'Slide to decide', unsure: key === 'cont' ? 'It is a close call.' : '', ign: 'The initiative stays at ' + stg + '.', go,
+    outboxReason: 'This page has no route to record that decision yet, so it stays a proposal. Nothing is written.',
+    opts: [{ id: 'ok', l: d[0][0], rec: 1, outward: !demo, fx: [['check', d[0][1], 'ok']] }, { id: 'no', l: d[1][0], fx: [['clock', d[1][1], 'warn']] }] };
+}
+
+/** A requirement row. Swipe right starts the draft (the agent's requirements only); swipe left leaves it. Both say what they did; a draft only starts where the page can start one. */
+function rqRow(V, row, L, r) {
+  const key = row.id + '|' + r[0]; const w = reqWho(r[2]); const done = reqDone(V, row, L, r[0]); const scope = V.scope;
+  const decide = (o) => {
+    if (o.id === 'go' || o.id === 'ok') { V.rq = V.rq || {}; V.rq[key] = 1; const m = o.id === 'go' ? 'Drafted. It waits in Review for you.' : o.l + '. Recorded as your decision.'; say(m, () => { delete V.rq[key]; V.render(); }); markDone(V, 'rq:' + key, m, () => { delete V.rq[key]; }); } else markDone(V, 'rq:' + key, 'Left as it is.');
+  };
+  const sw = { labelRight: r[2] === 'agent' ? 'start the draft' : 'open it first', labelLeft: 'leave it', iconRight: 'spark', iconLeft: 'moon',
+    onRight: () => say(r[2] === 'agent' && !done ? (isDemo() ? 'Open it, pick the draft, then slide: a draft starts only from its case file.' : 'An agent session does the drafting. This page cannot start one.') : done ? 'Already done.' : 'Open it first: a decision needs its case file.'),
+    onLeft: () => say('Left as it is.') };
+  const pend = !done && r[2] === 'pm' && prevPending(L, r[0], (k) => reqDone(V, row, L, k)).length;
+  return rowShell(V, { key: 'rq' + key, attrs: { 'data-rq': key, 'data-id': 'rq|' + key, 'data-lc-card': row.id }, icon: done ? 'check' : w[0], iconColor: done ? 'var(--success)' : null, sw,
+    titleNode: el('span', { class: 'tt', style: done ? 'text-decoration:line-through;color:var(--muted-foreground)' : '' }, r[1]),
+    xpContent: caseNode(V, 'rq:' + key, rqCase(V, row, L, r), { onConfirm: decide, onGo: () => openIt(V, row) }),
+    chips: [el('span', { class: 'tag' }, w[1]), scope ? null : el('span', { class: 'chip2' }, c3ic('init', 'sm'), row.title), pend ? el('span', { class: 'chip2' }, c3ic('clock', 'sm'), 'after the agent’s drafts') : null] });
+}
+
+/** Park it or kill it (console3.html C3.cases.ini, line 4745): the reason is the option, so a reason is always recorded. Both go through the same lifecycle route as the initiative sheet. */
+function parkRow(V, row) {
+  const key = 'par|' + row.id; const demo = isDemo();
+  const mk = (id, why, kill) => ({ id, l: (kill ? 'Kill it: ' : 'Park it: ') + why, fx: [['moon', kill ? 'Closed for good' : 'Comes back to the planning list', 'warn']], state: kill ? 'cancelled' : 'on-hold', why });
+  const opts = [{ id: 'keep', l: 'Keep it going', rec: 1, fx: [['check', 'Nothing changes', 'ok']] }, mk('p1', 'not now'), mk('p2', 'no evidence'), mk('p3', 'replaced'), mk('k1', 'out of scope', true)];
+  const decide = async (o) => {
+    if (o.id === 'keep') { markDone(V, 'rq:' + key, 'Kept going.'); return; }
+    const out = await setLifecycle(V.ctx.ws, row.id, o.state, o.why);
+    if (!out || !out.ok) { say((out && out.error) || 'Not recorded.'); return; }
+    try { window.dispatchEvent(new CustomEvent('pmos:initiatives-changed')); } catch { /* no window */ }
+    const undo = async () => { await setLifecycle(V.ctx.ws, row.id, 'active', 'Undone from the lifecycle lens'); try { window.dispatchEvent(new CustomEvent('pmos:initiatives-changed')); } catch { /* no window */ } };
+    say((o.state === 'cancelled' ? 'Killed: ' : 'Parked: ') + o.why + '.', undo); markDone(V, 'rq:' + key, (o.state === 'cancelled' ? 'Killed: ' : 'Parked: ') + o.why + '. Undo reopens it.', undo);
+  };
+  void demo;
+  return rowShell(V, { key: 'rq' + key, attrs: { 'data-lc-park-row': row.id, 'data-id': 'par|' + row.id }, icon: 'moon', hint: false,
+    titleNode: el('span', { class: 'tt' }, 'Park it or kill it'),
+    xpContent: caseNode(V, 'rq:' + key, { sit: 'Stopping is a decision too. Pick the reason; it is recorded and the agent reads it before suggesting the idea again.', conf: 74, chg: [['init', row.title, 'Initiative']], opts, cta: 'Slide to record it', go: ['open', row.id, 'Open ' + row.title] }, { onConfirm: decide, onGo: () => openIt(V, row) }),
+    chips: [el('span', { class: 'tag' }, 'you'), el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, 'a reason is always recorded'), V.scope ? null : el('span', { class: 'chip2' }, c3ic('init', 'sm'), row.title)] });
+}
+
+function render(V) {
+  const rows = V.ctx.rows || [];
+  const scope = V.scope;
+  const { buckets, unplaced } = bucketRows(rows, scope);
+  const ST = V.ctx.strategy || null;   // optional (demo): the mockup's Strategize lens content; the lens opens on it
+  if (!V.lens) V.lens = ST ? 'strategize' : STAGES.find((k) => buckets[k].length) || 'discover';
+  const lens = V.lens;
+  const stratOn = lens === 'strategize';   // the Calendar's strategy panels (c3-strategy-panels.js), as the mockup draws them under Strategize (iniLeft 3586, iniRight 3595)
+  const list = buckets[lens];
+  const note = stageNote(lens, rows, scope);
+
+  const seg = el('div', { class: 'seg', role: 'group', 'aria-label': 'Initiative lifecycle', style: 'overflow-x:auto;max-width:100%' }, STAGES.map((k) => {
+    const n = buckets[k].length;
+    return el('button', { type: 'button', 'aria-pressed': String(lens === k), 'data-lc-stage': k, 'data-lc-note': stageNote(k, rows, scope) || '', onClick: () => { V.lens = k; render(V); } },
+      c3ic(ICON[k], 'sm'), LABELS[k], n ? [' ', el('span', { class: 'bdg g' }, String(n))] : null);
+  }));
+  const pills = el('div', { class: 'chips2', 'data-lc-scope': '' },
+    el('button', { type: 'button', class: 'pill', 'aria-pressed': String(!scope), onClick: () => { V.scope = null; V.lens = null; render(V); } }, 'All'),
+    ...rows.slice(0, PILLS).map((r) => el('button', { type: 'button', class: 'pill', 'aria-pressed': String(scope === r.id), 'data-lc-pill': r.id, title: r.title, onClick: () => { V.scope = r.id; V.lens = null; render(V); } }, short(r.title, 14))),
+    rows.length > PILLS ? el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)', 'data-lc-more': '' }, '+' + (rows.length - PILLS) + ' more in the list') : null);
+
+  const placed = STAGES.reduce((n, k) => n + buckets[k].length, 0);
+  const PN = stratOn ? null : lensPanels(V, lens, scope);   // the panels the mockup draws for this stage (c3-lifecycle-panels.js)
+  const HD = PN && PN.head;
+  const head = stratOn && ST ? el('div', { class: 'lh', 'data-lc-derived': '' }, el('span', { class: 'ki' }, c3ic('flag')), el('div', { style: 'min-width:0' }, el('b', null, ST.head.h), el('div', { class: 'dim' }, ST.head.s)), c3ring(ST.head.ring[0], ST.head.ring[1], 44, ST.head.ring[0] + '/' + ST.head.ring[1]))
+    : HD ? el('div', { class: 'lh', 'data-lc-derived': '', 'data-lc-head': lens }, el('span', { class: 'ki' }, c3ic(HD.icon)), el('div', { style: 'min-width:0' }, el('b', null, HD.h), el('div', { class: 'dim' }, HD.s)), c3ring(HD.ring[0], Math.max(1, HD.ring[1]), 44, HD.ring[0] + '/' + HD.ring[1]))
+    : el('div', { class: 'lh', 'data-lc-derived': '' },
+    el('span', { class: 'ki' }, c3ic(ICON[lens])),
+    el('div', { style: 'min-width:0' },
+      el('b', null, note === 'skipped' ? LABELS[lens] + ': skipped by the lane' : note === 'no-signal' ? LABELS[lens] + ': no signal yet' : list.length + ' initiative' + (list.length === 1 ? '' : 's') + ' at ' + LABELS[lens]),
+      el('div', { class: 'dim' }, 'Stage is derived from the records; nothing here sets it.')),
+    c3ring(placed, Math.max(1, scope ? 1 : rows.length), 44, placed + '/' + (scope ? 1 : rows.length)));
+
+  const sctx = { goInit: (id) => V.ctx.openInitiative(V.ctx.repo, id) };
+  const deckCards = list.slice(0, 5);
+  const deck = deckCards.length ? el('section', { class: 'cdeck', 'data-n': '1' },
+    el('div', { class: 'deck', tabindex: '-1', role: 'group', 'aria-label': 'Initiatives at ' + LABELS[lens] }, deckCards.map((r, i) => deckCard(V, r, i, deckCards.length))),
+    deckCards.length > 1 ? el('div', { class: 'dk', role: 'group', 'aria-label': 'Cards' }, deckCards.map((r, i) => el('button', { type: 'button', class: 'dkd', 'aria-label': 'Card ' + (i + 1), 'aria-current': String(i === 0) }))) : null) : null;
+  if (deck) {
+    const d = deck.querySelector('.deck');
+    d.addEventListener('scroll', () => {
+      const f = d.children[0]; if (!f) return;
+      const i = Math.max(0, Math.min(d.children.length - 1, Math.round(d.scrollLeft / (f.offsetWidth + 12))));
+      [].forEach.call(d.children, (c, j) => c.classList.toggle('on', j === i));
+      deck.querySelectorAll('.dkd').forEach((x, j) => x.setAttribute('aria-current', String(j === i)));
+    });
+    deck.querySelectorAll('.dkd').forEach((b, j) => b.addEventListener('click', () => { const c = d.children[j]; if (c) d.scrollTo({ left: c.offsetLeft - d.children[0].offsetLeft, behavior: 'smooth' }); }));
+  }
+
+  const scoped = scope ? rows.find((r) => r.id === scope) : null;
+  const lcCard = scoped ? el('section', { class: 'card' }, el('h3', null, c3ic('init'), scoped.title + ' ', el('span', { class: 'dim', style: 'text-transform:none;letter-spacing:0' }, 'lifecycle')), lcLine(scoped)) : null;
+  const reqRows = [];
+  const needRows = scope ? rows.filter((r) => r.id === scope && (nineOf(r).find((x) => x.key === lens) || {}).status !== 'skipped') : list;   // the mockup (c3needs, line 4715): a chosen initiative shows its rows for any stage its lane uses
+  for (const row of needRows) { REQ[lens].forEach((r) => reqRows.push(() => rqRow(V, row, lens, r))); reqRows.push(() => parkRow(V, row)); }
+  const shown = V.all ? reqRows : reqRows.slice(0, LIST_MAX);
+  const needs = el('section', { class: 'card sect', 'data-lc-list': lens },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('check', 'sm'), 'What ' + LABELS[lens] + ' needs'), el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, 'stage is derived, not chosen')),
+    el('ul', { class: 'list' }, needRows.length ? [...shown.map((f) => f()),
+      reqRows.length > LIST_MAX && !V.all ? el('li', { class: 'fold' }, el('button', { type: 'button', class: 'pill', 'data-lc-showall': '', onClick: () => { V.all = true; render(V); } }, 'Show all ' + reqRows.length)) : null]
+      : el('li', { class: 'fold', 'data-lc-empty': '' }, c3ic(note === 'skipped' ? 'moon' : 'check', 'sm'),
+        note === 'skipped' || scope ? 'The ' + ((rows.find((r) => r.id === scope) || {}).lane || 'feature') + ' lane skips ' + LABELS[lens] + '.' : note === 'no-signal' ? 'No signal yet for ' + LABELS[lens] + '. Nothing is done or pending until a record shows it.' : 'No initiative is at ' + LABELS[lens] + ' now.')));
+  const right = [
+    ...(PN && PN.right.length ? [...PN.right, ...(lens === 'monitor' && ST && ST.signals ? [signalsCard(ST.signals.slice(0, 3))] : [])] : lens === 'monitor' && ST && ST.signals ? [signalsCard(ST.signals.slice(0, 3))] : [el('section', { class: 'card' }, el('h3', null, c3ic('info'), 'How the stage is derived'),
+      el('ul', { class: 'chgl' },
+        el('li', null, c3ic('check', 'sm'), el('span', null, 'Discover, Plan, Build and Evaluate read from the records.')),
+        el('li', null, c3ic('clock', 'sm'), el('span', null, 'The other stages have no signal yet, so none is shown done or pending.')),
+        el('li', null, c3ic('moon', 'sm'), el('span', null, 'A stage the lane skips reads skipped.'))))]),
+    unplaced.length ? el('section', { class: 'card', 'data-lc-unplaced': '' }, el('h3', null, c3ic('alert'), 'No stage shown yet'),
+      el('ul', { class: 'chgl' }, unplaced.map((r) => el('li', null, c3ic('init', 'sm'), el('span', null, r.title))))) : null,
+  ];
+
+  V.root.replaceChildren(el('div', { class: 'calwrap' },
+    el('div', { class: 'calbar' }, pills),
+    el('div', { class: 'calbar', style: 'flex-wrap:wrap;gap:8px' }, seg),
+    el('div', { class: 'calbody' },
+      head, V.ctx.links || null,
+      V.notice ? el('div', { class: 'fold w', role: 'alert' }, c3ic('alert', 'sm'), V.notice) : null,
+      stratOn && rows.length
+        ? el('div', { class: 'brief sbb' }, el('div', { class: 'bcols' }, el('div', { class: 'bcol l' }, V.ctx.plan || deck, lcCard, strategyPanel('maturity', sctx), strategyPanel('bets', sctx), needs), el('div', { class: 'bcol r' }, strategyPanel('north', sctx, { view: 'year', plain: true }), strategyPanel('signals', sctx, { n: 4 }), strategyPanel('synergy', sctx))))
+      : rows.length
+        ? el('div', { class: 'brief sbb' }, el('div', { class: 'bcols' }, el('div', { class: 'bcol l' }, V.ctx.plan || deck, lcCard, ...(PN ? PN.left : []), needs, ...(PN ? PN.after : [])), el('div', { class: 'bcol r' }, right)))
+        : el('div', { class: 'brief sbb' }, el('div', { class: 'bcols' }, el('div', { class: 'bcol l' }, V.ctx.plan || null, el('div', { class: 'fold' }, c3ic('check', 'sm'), 'No initiatives yet.')))))));
+}
+
+export function mountLifecycle(host, ctx) {
+  let V = views.get(host);
+  if (V) { V.ctx = ctx; render(V); if (host.firstChild !== V.root) host.replaceChildren(V.root); return; }
+  ensureComponentsCss();
+  ensureC3Css();
+  V = { ctx, scope: null, lens: null, open: {}, notice: null, root: el('div', { class: 'c3', 'data-in-view': 'lifecycle' }) };
+  V.render = () => render(V);
+  V.stopPhone = c3Phone(V.root);
+  views.set(host, V);
+  host.replaceChildren(V.root);
+  render(V);
+}
+
+export function disposeLifecycle(host) {
+  const V = views.get(host);
+  if (!V) return;
+  views.delete(host);
+  if (V.stopPhone) V.stopPhone();
+  if (V.root.parentNode === host) V.root.remove();
+}
+
+registerInitiativesView('lifecycle', { label: 'Lifecycle', mount: mountLifecycle, dispose: disposeLifecycle });