create-pmos 0.525.0 → 0.527.0

package/workspace/lib/routes-boards.js

@@ -90,6 +90,8 @@ const rowsLib = require('./initiative-rows.js');
 const writer = require('./initiative-writer.js');
 const itemSpans = require('./item-spans.js');
 const jiraStatus = require('./jira-status.js');
+const SS = require('./status-signal.js');
+const jiraOf = (root, id) => { try { return jiraStatus.readSnapshot(root, id); } catch { return null; } };
 const routesInit = require('./routes-initiatives.js');
 const jiraTickets = require('./jira-tickets.js');
 const { repoScript } = require('./repo-script.js');
@@ -101,6 +103,7 @@ const TS = require('./task-store.js');
 const holdSpans = require('./hold-spans.js');
 const ledgers = require('./plan-ledgers.js');
 const intake = require(repoScript('intake.js'));
+const OS = require('./one-stage.js');
 
 const LEDGER = 'boards.jsonl';
 const SELF_REFUSAL = 'PMOS keeps its derived ladder: its stages come from scripts/workflow-state.js, so a move or a workflow edit is refused here';
@@ -302,14 +305,11 @@ function frontmatter(root, rel) {
   return out;
 }
 
-function statusOf(rec, healthLevel, end, day) {
-  if (rec.accepted || (rec.stopped && rec.stopped.state === 'closed')) return 'done';
-  if (rec.stopped && rec.stopped.state === 'cancelled') return 'cancelled';
-  if (rec.stopped && rec.stopped.state === 'on-hold') return 'on hold';   // no health while paused: it never turns late
-  if (healthLevel === 'off' || (end && end < day)) return 'late';
-  if (healthLevel === 'at-risk') return 'at risk';
-  return 'on track';
-}
+/* workspace grill W2: the status says only what PMOS knows (lib/status-signal.js decides it; this keeps the inputs). */
+const statusIn = (rec, health, end, day, jira) => ({ accepted: !!rec.accepted, stopped: rec.stopped ? { state: rec.stopped.state } : null,
+  reasons: health && Array.isArray(health.reasons) ? health.reasons.map((x) => ({ level: x.level, code: x.code, text: x.text, source: x.source })) : [],
+  end: end || null, day, jira: jira ? { fetchedAt: jira.fetchedAt, tickets: [...jira.tickets.values()].map((t) => ({ key: t.key, status: t.status, category: t.category, sprint: t.sprint, flagged: !!t.flagged })) } : null });
+function statusOf(rec, health, end, day, jira) { return SS.statusOf(statusIn(rec, health, end, day, jira)).status; }
 
 /** The board-independent part of every work row of a repository, cached by the read signature. */
 /* A READ PASS (ctx.boardsPass, a Map): a page that asks several of these routes for one answer (GET /api/board-premium asks ten)
@@ -333,6 +333,7 @@ function baseRowsRead(w) {
   // every lifecycle line, not only the latest: a hold is a gap on the timeline (feedback batch 9 item 8)
   let lcFile = null;
   try { lcFile = path.join(ledgers.runsDir(w.root), 'lifecycle.jsonl'); const st = fs.statSync(lcFile); sig.lifecycle = st.size + ':' + st.mtimeMs; } catch { sig.lifecycle = 'none'; }
+  try { const jd = jiraTickets.jiraDir(w.root); sig.jira = fs.readdirSync(jd).filter((n) => n.endsWith('.md')).map((n) => { const st = fs.statSync(path.join(jd, n)); return n + ':' + st.mtimeMs; }).join(','); } catch { sig.jira = 'none'; }
   const cacheKey = JSON.stringify(sig) + day;
   const hit = rowCache.get(w.root);
   if (hit && hit.key === cacheKey) return { ok: true, rows: hit.rows };
@@ -365,7 +366,8 @@ function baseRowsRead(w) {
       id, title: r.title, lane: r.lane || null,
       owner: fm.owner ? String(fm.owner) : null,
       anchor: r.anchor || null, rank: Number.isInteger(r.rank) ? r.rank : null, dormant: !!r.dormant,
-      status: statusOf(rec, r.health && r.health.level, end, day),
+      status: statusOf(rec, r.health, end, day, jiraOf(w.root, id)),
+      statusIn: statusIn(rec, r.health, end, day, jiraOf(w.root, id)),
       health: r.health ? r.health.level : null,
       start: span ? span.start || null : null, end,
       progress: r.progress && r.progress.total ? Math.round((r.progress.done / r.progress.total) * 100) / 100 : null,   // a fraction 0..1, as the PRD row reads
@@ -377,6 +379,7 @@ function baseRowsRead(w) {
       hasSpec, record: relRec || null, domainFolder: dm ? dm[1] : null,
       recordEpic: jiraTickets.anchorOf(fm),
       holds: holds.get(id) || [], workSpans: work.map((x) => ({ start: x.start, due: x.due, stage: x.stage || null })),
+      accepted: !!rec.accepted, root: w.root,   // W1: what lib/one-stage.js reads besides the row (the sign-off, the Jira snapshot's repository)
     });
   }
   rowCache.set(w.root, { key: cacheKey, rows });
@@ -499,7 +502,33 @@ function closedOf(row, wx) {
   // the last stage, not counting the ones after it that only end work
   return wf.length > 1 && wf.slice(i + 1).every((x) => END_RE.test(String(x && x.name || '')));
 }
+/** W1: the one stage of a row (lib/one-stage.js): the PM's word, then Jira, then dated plan items, then the files (base.reading).
+ *  A Board move is the PM's word while it is newer than the last Jira read. → the stageOf answer, with `moveDropped` (a mapped move older than the Jira read). */
+function oneStageOf(board, base, folded, epics) {
+  const k = B.key(board.id, base.id);
+  const movedName = folded && folded.stages ? folded.stages.get(k) : null;
+  let move = null;
+  if (movedName && !(board && board.self)) {
+    const last = [...((folded && folded.moves) || [])].reverse().find((m) => m.board === board.id && m.id === base.id);
+    const pf = WF.resolve(libOf(folded), null);
+    const st = WF.stageByRef(pf, movedName) || mergedStage(pf, movedName, null);
+    if (st) move = { key: st.key, at: last ? last.at : null };
+  }
+  const jira = base.root ? OS.factsOf(base.root, base.id, epics) : null;
+  const one = OS.stageOf({ files: base.reading, life: base.lifecycle ? { ...(base.stopped || {}), state: base.lifecycle } : null, move, jira, plan: { dated: (base.workSpans || []).length }, accepted: !!base.accepted });
+  const under = one.under || one;
+  // a move to a board stage the eight steps do not name (Execute, Doing) stays the board's: only a mapped move older than Jira's read gives way
+  return { ...one, moveDropped: !!(move && under.setBy !== 'pm') };
+}
 function boardRow(board, base, folded, lib) {
+  const ep = epicsOf(base, folded);
+  const one = oneStageOf(board, base, folded, ep.epics);
+  // the board's stage name follows the one stage: a move the one stage did not keep (an older move, Jira read since) no longer places it
+  if (one.moveDropped && folded && folded.stages && folded.stages.has(B.key(board.id, base.id))) {
+    const own = folded.iniWf && folded.iniWf.get(B.key(board.id, base.id));
+    if (!own) { const st = new Map(folded.stages); st.delete(B.key(board.id, base.id)); folded = Object.assign(Object.create(Object.getPrototypeOf(folded)), folded, { stages: st }); }
+  }
+  if (one.setBy !== 'files' || !folded || !folded.stages || !folded.stages.has(B.key(board.id, base.id)) || one.moveDropped) base = { ...base, reading: one.step };
   const s = B.stageOf(board, base.id, base.reading, folded);
   const ts = taskSpanOf(folded, base.id);   // the bar covers the breakdown items and the tasks
   const wf = B.workflowOf(board, base.id, folded);
@@ -513,15 +542,28 @@ function boardRow(board, base, folded, lib) {
     // item 13); stageSpans: where the dated work of each stage runs, so a skipped stage between two of them is marked » (XgapAGrill)
     holds: base.holds || [], ...gapFields((base.workSpans || []).concat(taskSpansOf(folded, base.id))),
     template: B.templateOf(board, base.id, folded), workflow: wf.map((x) => ({ name: x.name, cat: x.cat })),
-    ...epicsOf(base, folded),
+    ...ep,
+    // W1: the one stage every surface draws (public/pm/stage-chip.js), and what set it
+    oneStage: { stage: one.stage, step: one.step, label: one.label, setBy: one.setBy, source: one.source, readAt: one.readAt },
   };
   const wx = workflowRowOf(board, base, folded, lib || libOf(folded), s.stage);
   Object.assign(row, wfRowFields(wx));
+  // a board whose columns merge or leave out a step ("Discover" holds Triage) shows the step its column names: the chip says the same
+  if (!['shipped', 'on-hold', 'cancelled'].includes(one.stage) && row.wfStage && OS.STEPS.includes(row.wfStage.key) && row.wfStage.key !== one.step && !wx.own) {
+    row.oneStage = { ...row.oneStage, stage: row.wfStage.key, step: row.wfStage.key, label: OS.labelOf(row.wfStage.key) };
+  }
   if (wx.own) { row.stage = (wx.stages.find((x) => x.key === wx.stage) || {}).name || row.stage; row.cat = null; row.stageSource = 'move'; }
   // batch 26 item 5: an initiative in its workflow's terminal stage is finished, so it is never late or at risk. Every surface (the Board's
   // tone, dot, late line and edge tabs, Home, Kanban, the program rollups) reads the status this leaves and row.closed.
+  // workspace grill W2: the status from what PMOS read, a passed date, or a risk the PM confirmed on a program milestone; else No signal.
+  // W1's one stage (row.oneStage, lib/one-stage.js stageOf) is read when it is there: a stage the PM set to shipped is done, a Jira-set stage a read
+  if (base.statusIn) {
+    const sig = SS.statusOf({ ...base.statusIn, stage: row.oneStage || null, confirmed: (folded && folded.risks && folded.risks.get(base.id)) || null });
+    row.status = sig.status; row.signal = { from: sig.from, why: sig.why, source: sig.source, readAt: sig.readAt };
+  }
   row.closed = closedOf(row, wx);
-  if (row.closed && (row.status === 'late' || row.status === 'at risk')) row.status = 'on track';
+  // a finished initiative is never late, at risk or without a signal: its last stage is the PM's own move (batch 26 item 5)
+  if (row.closed && ['late', 'at risk', 'no signal'].includes(row.status)) { row.status = 'on track'; row.signal = { from: 'pm', why: 'In its last stage', source: 'the workflow', readAt: null }; }
   const w = [];
   if (s.source === 'move') {
     const last = [...folded.moves].reverse().find((m) => m.board === board.id && m.id === base.id);
@@ -539,10 +581,17 @@ function frameRead(ctx, w) {
   const boards = boardsOf(ctx, w, folded);
   const d = ctx.stateDirFor ? ctx.stateDirFor(w) : null;
   folded.wfLib = WS.library(d);   // D99: the workflow library rides on the fold, so every boardRow call reads one copy
+  folded.risks = risksOf(ctx, w);   // workspace grill W2: the risks the PM confirmed on a program milestone
   return { w, folded, boards };
 }
 /** A fresh fold with the workflow library on it (frameFor's, without the boards). Inside a read pass, the pass's own fold. */
-function foldOf(ctx, w) { if (ctx && ctx.boardsPass instanceof Map) return frameFor(ctx, w).folded; const f = B.fold(readLedger(ctx, w)); const d = ctx.stateDirFor ? ctx.stateDirFor(w) : null; f.wfLib = WS.library(d); return f; }
+function foldOf(ctx, w) { if (ctx && ctx.boardsPass instanceof Map) return frameFor(ctx, w).folded; const f = B.fold(readLedger(ctx, w)); const d = ctx.stateDirFor ? ctx.stateDirFor(w) : null; f.wfLib = WS.library(d); f.risks = risksOf(ctx, w); return f; }
+/** The initiatives of workspace w that a program milestone the PM kept "at risk" waits on (lib/status-signal.js confirmedRisks). Every
+ *  program of every workspace is read once per read pass; a program ledger that cannot be read confirms nothing. */
+function risksOf(ctx, w) {
+  if (!ctx || !ctx.workspaceList) return new Map();
+  try { return SS.confirmedRisks(inPass(ctx, 'programs', () => require('./routes-programs.js').all(ctx)), w.id); } catch { return new Map(); }
+}
 const libOf = (folded) => (folded && folded.wfLib) || WS.library(null);
 /** A workflow by id for workspace w: its own library first, then the home workspace's, then any other open workspace's (not archived there).
  *  → { wf, ws: null } | { wf, ws: <the workspace it came from> } | null */

package/workspace/lib/routes-briefing-premium.js

@@ -83,6 +83,23 @@ function iniInfoOf(ctx, key, wsId) {
   return null;
 }
 
+/** The set-up report open beside this chat, for lib/report-chat.js wrap: { id, name, draft } | null. Wawan, 2026-11-04: feedback in the chat,
+ *  in any words, is about the draft beside it. The page names the report (pm/premium-report-tab.js reportBeside); it counts only while it is set
+ *  up, read in the chat's own workspace, then the others. */
+function reportInfoOf(ctx, wsId, rid) {
+  const id = String(rid || ''); if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(id)) return null;
+  const RS = require('./report-setups.js');
+  const list = ctx.workspaceList ? ctx.workspaceList() : [];
+  const first = wsId && ctx.getWs ? ctx.getWs(wsId) : null;
+  for (const w of [first, ...list.filter((x) => !first || x.id !== first.id)].filter((x) => x && x.root)) {
+    let st; try { st = RS.stateOf(w.root); } catch { continue; }
+    const s = st.setups.get(id); if (!s) continue;
+    const last = (s.drafted || []).filter((d) => d && d.path).slice(-1)[0];
+    return { id, name: s.name || id, draft: last ? last.path : null };
+  }
+  return null;
+}
+
 async function post(req, res, url, ctx) {
   const act = url.pathname.slice('/api/briefing-premium/'.length);
   const got = await ctx.readJson(req);
@@ -125,7 +142,7 @@ async function post(req, res, url, ctx) {
     if (!att.ok) { ctx.json(res, { ok: false, error: att.error }, att.status); return true; }
     // batch 20 item 13: the PM can start a grill any time by asking for it in an initiative's chat; it also runs by itself
     const g2 = grillAsk(ctx, b.key, b.text, wsId);
-    const a = (ctx.chatSessions ? Ag.chat : Ag.ask)({ runtimeDir, key: b.key, text: Files.withFiles(g2 ? g2.text : b.text, att.paths), context: b.context, sessions: ctx.chatSessions, model: /^work:/.test(String(b.key || '')) ? WP.peekModel() : /^board:/.test(String(b.key || '')) ? BoardP.peekModel() : /^ins:/.test(String(b.key || '')) ? InsP.peekModel() : /^(init|doc):/.test(String(b.key || '')) ? InitP.peekModel() : sk || (/^src:/.test(String(b.key || '')) && !(b.key === 'src:this-page' && url.searchParams.get('ws'))) ? Prod.peekModel() : BP.peekModel(root), spawnSession: ctx.spawnSession, wsId, iniInfo: () => iniInfoOf(ctx, b.key, wsId) });
+    const a = (ctx.chatSessions ? Ag.chat : Ag.ask)({ runtimeDir, key: b.key, text: Files.withFiles(g2 ? g2.text : b.text, att.paths), context: b.context, sessions: ctx.chatSessions, reportInfo: () => reportInfoOf(ctx, wsId, b.report), model: /^work:/.test(String(b.key || '')) ? WP.peekModel() : /^board:/.test(String(b.key || '')) ? BoardP.peekModel() : /^ins:/.test(String(b.key || '')) ? InsP.peekModel() : /^(init|doc):/.test(String(b.key || '')) ? InitP.peekModel() : sk || (/^src:/.test(String(b.key || '')) && !(b.key === 'src:this-page' && url.searchParams.get('ws'))) ? Prod.peekModel() : BP.peekModel(root), spawnSession: ctx.spawnSession, wsId, iniInfo: () => iniInfoOf(ctx, b.key, wsId) });
     ctx.json(res, a.body, a.status);
     return true;
   }

package/workspace/lib/routes-notes.js

@@ -373,7 +373,7 @@ function openInitiativesOf(w) {
         if (rec && (rec.stopped || rec.accepted)) return;
         const isTop = !dormant && top < PICKER_TOP;
         if (isTop) top++;
-        ranked.push({ id: r.id, title: r.title, anchor: r.anchor, intent: '', stage: lifecycle.labelOf(rec), dormant, top: isTop });
+        ranked.push({ id: r.id, title: r.title, anchor: r.anchor, intent: '', stage: lifecycle.labelOf(rec, w.root), dormant, top: isTop });
       };
       for (const r of rm.rows) add(r, false);
       for (const r of rm.dormant) add(r, true);

package/workspace/lib/routes-your-move.js

@@ -0,0 +1,64 @@
+'use strict';
+/* routes-your-move.js — what Your move reads from a product beside its Board rows (workspace grill W3, frame WgW3Move).
+ *
+ *   GET /api/your-move?ws=<id>   → { ok, ws, today, verdicts: [lib/your-move.js verdict + board], kr: lib/your-move.js krOf | null }
+ *
+ * verdicts: the outcome checks past their date with no verdict (lib/outcomes.js scan, less Intelligence's verdicts in
+ * lib/insights-records.js), each with Claude's draft from the board's Jira tickets and the board it is on (the ✓ records it there through
+ * POST /api/insights-records/verdict). kr: the first key result of the OKR file that waits on a source (lib/okr-goals.js, the kr-metrics records
+ * as its readers). Read only: nothing is written. A part that cannot be read is left out, never guessed. */
+const YM = require('./your-move.js');
+
+const localDay = (ms = Date.now()) => { const d = new Date(ms); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); };
+
+/** The board items of every board of the workspace, and the board each initiative is on. */
+function itemsOf(ctx, w) {
+  const RB = require('./routes-boards.js'), TLR = require('./routes-task-links.js');
+  const items = [], boardOf = new Map();
+  let fr = null;
+  try { fr = RB.frameFor(ctx, w); } catch { fr = null; }
+  for (const b of (fr && fr.boards) || []) {
+    let f = null;
+    try { f = TLR.frame(ctx, w, b); } catch { f = null; }
+    if (!f) continue;
+    for (const r of f.rows || []) if (r && r.id && !boardOf.has(r.id)) boardOf.set(r.id, b.id);
+    items.push(...(f.items || []));
+  }
+  return { items, boardOf };
+}
+
+function verdicts(ctx, w, today) {
+  const S = require('./outcomes.js').scan(w.root, { today });
+  if (!S.due.length) return [];
+  const have = new Set();
+  try { const V = require('./insights-records.js').read(w.root).verdicts || {}; for (const b of Object.values(V)) for (const id of Object.keys(b || {})) have.add(id); } catch { /* none recorded */ }
+  const { items, boardOf } = itemsOf(ctx, w);
+  return YM.verdictsOf({ due: S.due, verdicts: have, items, today }).map((v) => ({ ...v, board: boardOf.get(v.ini) || null }));
+}
+
+function kr(ctx, w, today) {
+  const OG = require('./okr-goals.js');
+  const okr = OG.read(w.root);
+  if (!okr.ok) return null;
+  let recs = [];
+  try { recs = require(require('./repo-script.js').repoScript('records/index.js')).list(require('./records-dir.js').recordsDirFor(ctx, w.id), 'kr-metrics').filter((k) => k.retired !== true); } catch { recs = []; }
+  const goals = recs.map((k) => ({ id: k.rid, title: k.title || '', kr: k.kr || null, readings: Array.isArray(k.readings) ? k.readings.length : 0, recipe: k.recipe || null }));
+  return YM.krOf(OG.build({ okr, goals, initiatives: [], records: {}, today }));
+}
+
+module.exports = {
+  prefixes: ['/api/your-move'],
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/your-move') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    let w = null;
+    try { w = ctx.getWs(url.searchParams.get('ws') || null); } catch { w = null; }
+    if (!w || !w.root) { ctx.json(res, { ok: false, error: 'no such workspace' }, 404); return true; }
+    const today = localDay();
+    let V = [], K = null;
+    try { V = verdicts(ctx, w, today); } catch { V = []; }
+    try { K = kr(ctx, w, today); } catch { K = null; }
+    ctx.json(res, { ok: true, ws: w.id, today, verdicts: V, kr: K });
+    return true;
+  },
+};

package/workspace/lib/status-signal.js

@@ -0,0 +1,123 @@
+'use strict';
+/* status-signal.js — an initiative's status says only what PMOS knows (workspace grill W2, "Status says what it knows"; canvas In
+ * development, frame WgW2Status). THE ONE place a row's status is decided. Every surface (the Board's rows and header, Home's product row and
+ * card, the weekly update, the program rollups) reads the status this decides; none decides one of its own.
+ *
+ *   statusOf(x)          → { status, from, why, source, readAt }
+ *   wordsOf(c)           → '3 late · 1 at risk · 5 no signal'        the pill's words from THE count (scripts/boards.js counts, whose
+ *                                                                    byStatus holds 'no signal' apart: it is never counted as on track); ''
+ *                                                                    when nothing is open
+ *   confirmedRisks(programs, ws) → Map initiative → { why, program, milestone, name }   the PM's ✓ on a "Mark … at risk" ✦
+ *   openRisks(programs, ws)      → [{ key, program, title, milestone, name, why, src, inis }]   the same ✦ before the PM's ✓
+ *   READ_DAYS · STATUSES
+ *
+ * THE RULES (the agreed W2 frame):
+ *   done · cancelled · on hold   the PM's word on the record (accepted, closed, cancelled, on-hold in lifecycle.jsonl); a stage the PM set to
+ *                                shipped (W1's stageOf, setBy 'pm') reads on track: it stays open for Monitor and Evaluate
+ *   late        only from a date that passed: the planned finish of the dated plan items, or an overdue milestone
+ *   at risk     only from a read (an overdue plan item, an idle initiative under way, a passed check-by date, a failed factory item, an
+ *               open Jira ticket past its due date or its sprint's end, a ticket flagged blocked) or from a risk the PM confirmed (✓ on Claude's "Mark … at risk")
+ *   on track    only from a read: a Jira reading of the initiative's tickets in the last READ_DAYS with none past its due date, or dated
+ *               plan items whose finish is still ahead
+ *   no signal   everything else: grey, and never counted as on track anywhere
+ * A health reason the spec ladder gives (a PM step owed: files, not a read) and an `unknown` reason (a source PMOS could not read) say
+ * nothing about status. A stale Jira reading (older than READ_DAYS) is not a read.
+ *
+ * x = { accepted, stopped: { state }, reasons: [{ level, code, text, source }] (lib/health.js), end ('YYYY-MM-DD', the planned finish),
+ *       day (today, 'YYYY-MM-DD'), now (ms), jira: { fetchedAt, tickets: Map|[] of { key, status, category, due } } | null,
+ *       stage: W1's { stage, setBy, source, readAt } | null, confirmed: { why, name } | null }
+ * Pure: no I/O, no clock beyond x.now.
+ */
+const STATUSES = Object.freeze(['on track', 'at risk', 'late', 'no signal', 'on hold', 'done', 'cancelled']);
+const READ_DAYS = 14;
+const DAY = 864e5;
+const DATE_CODES = new Set(['milestone-overdue']);   // a passed date: late
+const NOT_READS = new Set(['pm-step-owed']);         // the spec ladder (files): not a read
+const DONE_CAT = /^done$/i;
+
+const ticketsOf = (j) => (!j || !j.tickets ? [] : typeof j.tickets.values === 'function' && !Array.isArray(j.tickets) ? [...j.tickets.values()] : Array.isArray(j.tickets) ? j.tickets : []);
+const doneTicket = (t) => DONE_CAT.test(String(t.category || '')) || /^(done|closed|resolved|won't do)$/i.test(String(t.status || ''));
+/** When an open ticket was meant to be done: its own due date, else the end of the sprint it sits in (a closed sprint, or the active one). */
+const dueOf = (t) => {
+  const sp = t.sprint && (t.sprint.state === 'active' || t.sprint.state === 'closed') ? t.sprint.end : null;
+  const m = /^\d{4}-\d{2}-\d{2}/.exec(String(t.due || t.duedate || sp || ''));
+  return m ? m[0] : null;
+};
+
+/** The Jira reading, when it is a read: fresh, with tickets. → { at, open, late: [ticket] } | null */
+function jiraRead(j, now) {
+  if (!j || !j.fetchedAt) return null;
+  const at = Date.parse(j.fetchedAt);
+  if (!Number.isFinite(at) || now - at > READ_DAYS * DAY) return null;
+  const T = ticketsOf(j);
+  if (!T.length) return null;
+  const day = new Date(now).toISOString().slice(0, 10);
+  const open = T.filter((t) => !doneTicket(t));
+  return { at: j.fetchedAt, n: T.length, open: open.length, late: open.filter((t) => { const d = dueOf(t); return d && d < day; }), blocked: open.filter((t) => t.flagged) };
+}
+
+function statusOf(x = {}) {
+  const now = typeof x.now === 'number' ? x.now : Date.now();
+  const day = x.day || new Date(now).toISOString().slice(0, 10);
+  const out = (status, from, why, source, readAt) => ({ status, from, why: why || '', source: source || '', readAt: readAt || null });
+  const st = x.stopped && x.stopped.state;
+  const S = x.stage || null;
+  // the PM's word
+  if (x.accepted || st === 'closed') return out('done', 'pm', '', 'the record');
+  if (st === 'cancelled') return out('cancelled', 'pm', '', 'lifecycle.jsonl');
+  if (st === 'on-hold') return out('on hold', 'pm', '', 'lifecycle.jsonl');
+  // shipped by the PM's word: never late or at risk, but still open on the Board (Monitor and Evaluate follow), so on track, not done
+  if (S && S.setBy === 'pm' && S.stage === 'shipped') return out('on track', 'pm', 'Shipped', S.source || 'lifecycle.jsonl', S.readAt);
+  const reasons = (Array.isArray(x.reasons) ? x.reasons : []).filter((r) => r && (r.level === 'off' || r.level === 'at-risk') && !NOT_READS.has(r.code));
+  // a passed date
+  if (x.end && x.end < day) return out('late', 'date', 'Planned finish ' + x.end + ' passed', 'planning/runs/plan-items.jsonl');
+  const dated = reasons.find((r) => DATE_CODES.has(r.code));
+  if (dated) return out('late', 'date', dated.text, dated.source);
+  // a risk the PM confirmed
+  if (x.confirmed) return out('at risk', 'confirmed', x.confirmed.why || 'You marked it at risk', x.confirmed.name ? 'Program milestone ' + x.confirmed.name : 'the program charter');
+  // a read
+  if (reasons.length) return out('at risk', 'read', reasons[0].text, reasons[0].source);
+  const J = jiraRead(x.jira, now) || (S && S.setBy === 'jira' && S.readAt && now - Date.parse(S.readAt) <= READ_DAYS * DAY ? { at: S.readAt, n: 0, open: 0, late: [], stage: S } : null);
+  if (J && J.late.length) return out('at risk', 'read', J.late.length === 1 ? (J.late[0].key || 'A ticket') + ' is past its due date' : J.late.length + ' tickets are past their due dates', 'Jira', J.at);
+  if (J && J.blocked && J.blocked.length) return out('at risk', 'read', (J.blocked[0].key || 'A ticket') + ' is blocked in Jira' + (J.blocked.length > 1 ? ', and ' + (J.blocked.length - 1) + ' more' : ''), 'Jira', J.at);
+  if (J) return out('on track', 'read', J.n ? (J.n - J.open) + ' of ' + J.n + ' tickets done' : (J.stage.source || 'Jira'), 'Jira', J.at);
+  if (x.end && x.end >= day) return out('on track', 'read', 'Plan items on dates, finish ' + x.end, 'planning/runs/plan-items.jsonl');
+  return out('no signal', null, 'Nothing read says how it is going', '');
+}
+
+function wordsOf(c) {
+  if (!c || !c.open) return '';
+  const p = [c.late && c.late + ' late', c.risk && c.risk + ' at risk', c.on && c.on + ' on track', c.none && c.none + ' no signal', c.hold && c.hold + ' on hold'].filter(Boolean);
+  return p.join(' · ');
+}
+
+/* ── the PM-confirmed risks: a program milestone the PM kept "at risk", on the initiatives it waits on ── */
+const memberOf = (p, ws, ini) => (p.members || []).some((m) => m && m.initiative === ini && (!ws || !m.ws || m.ws === ws));
+function confirmedRisks(programs, ws) {
+  const out = new Map();
+  for (const p of programs || []) {
+    if (!p || p.archived) continue;
+    for (const m of p.milestones || []) {
+      if (!m || !m.risk || m.done || m.fixed) continue;
+      for (const ini of m.waits || []) if (memberOf(p, ws, ini) && !out.has(ini)) out.set(ini, { why: String(m.risk), program: p.id, milestone: m.id, name: m.name || '' });
+    }
+  }
+  return out;
+}
+/** Claude's "Mark … at risk" ✦ the PM has not answered, for the initiatives of workspace `ws`. */
+function openRisks(programs, ws) {
+  const out = [];
+  for (const p of programs || []) {
+    if (!p || p.archived) continue;
+    for (const i of (p.review && p.review.open) || []) {
+      if (!i || i.op !== 'risk') continue;
+      const m = (p.milestones || []).find((x) => x.id === i.milestone) || {};
+      const inis = (m.waits || []).filter((ini) => memberOf(p, ws, ini));
+      if (ws && !inis.length && !(p.members || []).some((x) => x && x.ws === ws)) continue;
+      out.push({ key: i.key, program: p.id, programTitle: p.title || p.id, title: 'Mark ' + (m.name || 'a milestone') + ' at risk', milestone: i.milestone, name: m.name || '', why: i.why, src: i.src || null, at: i.at || '', inis });
+    }
+  }
+  return out;
+}
+
+module.exports = { STATUSES, READ_DAYS, statusOf, wordsOf, confirmedRisks, openRisks, jiraRead };

package/workspace/lib/workflow-cli.js

@@ -233,11 +233,13 @@ function ofLines(r) {
   const row = r.row, st = row.wfStage || {};
   const out = [`${row.title} (${row.id}) runs ${row.wf.name} (${row.wf.id}) on the board ${r.board.name}.`];
   out.push(row.ended ? `It ended: ${row.ended.as === 'wontdo' ? "Won't do" : 'Archived'}.` : `Stage ${st.n} of ${st.of}: ${st.name} [${st.key}]`);
+  const one = row.oneStage;   // W1: the one stage the pages show, and what set it
+  if (one && one.label) out.push(`The pages show: ${one.label} · set by ${one.source}${one.readAt ? ' · read ' + one.readAt : ''}`);
   (row.wfStages || []).forEach((s, i) => out.push(`  ${MARK[s.status] || ' '} ${String(i + 1).padStart(2)}. ${s.milestone ? '◆ ' : ''}${s.name} [${s.key}]${s.status === 'current' ? ' · current' : s.status === 'skipped' ? ' · skipped' : ''}`));
   out.push(`Move it: pmos workflow move ${row.id} --stage <key>. Moving the initiative changes no task; a task's group (pmos task set --stage) is its place in the breakdown, not its state.`);
   return out;
 }
-const ofJson = (r) => ({ initiative: { id: r.row.id, title: r.row.title }, board: { id: r.board.id, name: r.board.name }, wf: r.row.wf, stage: r.row.wfStage, stages: r.row.wfStages, ended: r.row.ended });
+const ofJson = (r) => ({ initiative: { id: r.row.id, title: r.row.title }, board: { id: r.board.id, name: r.board.name }, wf: r.row.wf, stage: r.row.wfStage, stages: r.row.wfStages, ended: r.row.ended, oneStage: r.row.oneStage || null });
 
 function onInitiative(verb, { pos, flags, json, say, fail, root, stateDir, actor, others }) {
   const id = pos[0];

package/workspace/lib/your-move.js

@@ -0,0 +1,61 @@
+'use strict';
+/* your-move.js — what Your move needs from a product that its Board rows do not carry (workspace grill W3, frame WgW3Move; brief
+ * /mnt/project-files/workspace-grill/brief-W1-W4.md). Pure: lib/routes-your-move.js reads the files and passes them in.
+ *
+ *   verdictsOf({ due, verdicts, items, today }) → [verdict]   the outcome checks past their date with no verdict yet, oldest first
+ *   krOf(okrFile)                                → { waiting, first: { token, title, need } } | null   the first key result with no reading
+ *
+ * A VERDICT ROW. An outcome check is due (lib/outcomes.js scan: `due` = a metric, a check date on or before today, no disposition in
+ * outcome_checks.jsonl) and Intelligence holds no verdict for it (lib/insights-records.js). Claude drafts Keep, Iterate or Stop only from what
+ * it read, and the PM's ✓ records it (POST /api/insights-records/verdict, drafted: true). What it reads today is the initiative's Jira tickets on
+ * the board (each item carries the time Jira was read):
+ *   - a ticket of type Bug still open       → Iterate, naming the bugs
+ *   - tickets read and no Bug open          → Keep, and it says the metric itself was not read (the mood is never happier than the data)
+ *   - no ticket read                        → no draft: "I could not read enough to judge", and ✎ opens the full verdict on Intelligence
+ * Stop is never drafted: it is the PM's call. Each draft carries its sources.
+ *
+ * A KEY RESULT ROW. lib/okr-goals.js build() lists the OKR file's key results with what each needs when nothing reads it. The row names the
+ * first one that waits on a source and how many wait; a file where every key result has a reading draws nothing (zero is silence). */
+
+const DAY = 864e5;
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const dn = (iso) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(iso || '')); return m ? Math.round(Date.UTC(+m[1], +m[2] - 1, +m[3]) / DAY) : null; };
+const md = (iso, today) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(iso || '')); if (!m) return ''; const y = String(today || '').slice(0, 4); return +m[3] + ' ' + MON[+m[2] - 1] + (y && m[1] !== y ? ' ' + m[1] : ''); };
+const plural = (n, a, b) => n + ' ' + (n === 1 ? a : b);
+const list = (a) => (a.length < 2 ? a.join('') : a.slice(0, -1).join(', ') + ' and ' + a[a.length - 1]);
+const OPEN = (s) => !/^(done|closed|resolved|released|won't do|archived)$/i.test(String(s || ''));
+
+/** The drafted verdict for one initiative from its Jira tickets on the board, or null when nothing was read. */
+function draftOf(ini, items, today) {
+  const tk = (items || []).filter((x) => x && x.src === 'jira' && x.ini === ini && x.kind !== 'Epic' && x.readAt);
+  if (!tk.length) return null;
+  const at = tk.map((x) => String(x.readAt).slice(0, 10)).sort().pop();
+  const src = [{ label: 'Jira, read ' + md(at, today), ref: tk.map((x) => x.key).slice(0, 6).join(', ') }];
+  const bugs = tk.filter((x) => x.kind === 'Bug' && OPEN(x.status));
+  if (bugs.length) {
+    const keys = bugs.map((x) => x.key);
+    return { verdict: 'Iterate', text: plural(bugs.length, 'bug is', 'bugs are') + ' still open in Jira: ' + list(keys.slice(0, 3)) + (keys.length > 3 ? ' and ' + (keys.length - 3) + ' more' : '') + '.', sources: src };
+  }
+  return { verdict: 'Keep', text: 'No bug is open among its ' + plural(tk.length, 'Jira ticket', 'Jira tickets') + ' (read ' + md(at, today) + '). I could not read the metric itself.', sources: src };
+}
+
+/** The checks past their date with no verdict: [{ ini, title, metric, horizon, days, draft }] oldest first. PURE.
+ *  due: lib/outcomes.js scan().due; verdicts: Set of initiative ids Intelligence holds a verdict for; items: the board's work items. */
+function verdictsOf({ due, verdicts, items, today }) {
+  const t = dn(today), have = verdicts instanceof Set ? verdicts : new Set(verdicts || []);
+  return (due || []).filter((it) => it && it.id && it.horizon && !have.has(it.id)).map((it) => ({
+    ini: it.id, title: it.title || it.id, metric: it.metric || '', horizon: it.horizon, days: t != null && dn(it.horizon) != null ? Math.max(0, t - dn(it.horizon)) : 0,
+    draft: draftOf(it.id, items, today),
+  })).sort((a, b) => b.days - a.days || a.ini.localeCompare(b.ini));
+}
+
+/** The first key result that waits on a source, and how many wait. PURE. okrFile: lib/okr-goals.js build(). */
+function krOf(F) {
+  if (!F || !Array.isArray(F.objectives)) return null;
+  const wait = F.objectives.flatMap((o) => o.krs || []).filter((k) => k && !k.read && k.need && !k.proposed);
+  if (!wait.length) return null;
+  const k = wait[0];
+  return { waiting: wait.length, total: F.total || wait.length, read: F.read || 0, first: { token: k.token, title: k.title, need: k.need, goal: k.goal || null } };
+}
+
+module.exports = { verdictsOf, krOf, draftOf };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/bd-acts.js

@@ -26,6 +26,7 @@ import * as Asks from './bd-asks.js';
 import * as WF from './bd-wf.js';
 import * as Pins from './bd-pin-card.js';
 import { holdSpans, holdWords, holdRange, md } from './bd-span.js';
+import { stageName } from './stage-chip.js';   // W1: the one stage
 
 const SV = (d) => `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="${d}"/></svg>`;
 const I = {
@@ -174,7 +175,7 @@ function findList() {
   const h = findHits(findQ), all = [...h.ini.map((r) => ({ r })), ...h.tk];
   findAt = Math.max(0, Math.min(findAt, all.length - 1));
   let i = -1;
-  const ini = h.ini.map((r) => { i++; const s = V.statusLine(r); return `<button type="button" class="bd-mi${i === findAt ? ' hl' : ''}" data-findini="${esc(r.key)}"><i class="cz-dot ${s.tone}"></i><span class="tx"><span>${mark(r.title, findQ)}</span><span class="bd-amut">${esc([(r.track && r.track.label) || r.stage, s.text].filter(Boolean).join(' · '))}</span></span>${i === findAt ? '<span class="k">Enter</span>' : ''}</button>`; }).join('');
+  const ini = h.ini.map((r) => { i++; const s = V.statusLine(r); return `<button type="button" class="bd-mi${i === findAt ? ' hl' : ''}" data-findini="${esc(r.key)}"><i class="cz-dot ${s.tone}"></i><span class="tx"><span>${mark(r.title, findQ)}</span><span class="bd-amut">${esc([stageName(r) || r.stage, s.text].filter(Boolean).join(' · '))}</span></span>${i === findAt ? '<span class="k">Enter</span>' : ''}</button>`; }).join('');
   const tk = h.tk.map(({ k, r }) => { i++; return `<button type="button" class="bd-mi${i === findAt ? ' hl' : ''}" data-findtk="${esc(k.key)}" data-ini="${esc(r.key)}"><span class="bd-pill">${mark(k.key, findQ)}</span><span class="tx"><span>${mark(k.title, findQ)}</span><span class="bd-amut">${esc([k.blocked ? 'Blocked' : k.status, k.assignee].filter(Boolean).join(' · '))}</span></span>${i === findAt ? '<span class="k">Enter</span>' : ''}</button>`; }).join('');
   return (ini ? '<p class="bd-mlbl">Initiatives</p>' + ini : '') + (tk ? '<p class="bd-mlbl">Work-items in Jira</p>' + tk : '') + (findQ.trim() && !ini && !tk ? `<p class="bd-amut bd-mnote">Nothing on this Board matches “${esc(findQ.trim())}”.</p>` : '');
 }

package/workspace/public/pm/bd-cols.js

@@ -13,6 +13,7 @@ import { esc, store } from './premium-shell.js';
 import { endStage } from './bd-pins.js';
 import { stageOfRow, wfOf, wfIcon, catOfRow, catLabel, CAT_ORDER } from './bd-wf.js';
 import { offTone, md, dy } from './bd-span.js';
+import { stageName as oneStageName } from './stage-chip.js';
 
 /** Every column in its place, left to right: key, title, width in px. Initiative takes what the others leave of its 250 px. */
 export const COLS = [
@@ -73,15 +74,17 @@ export function nextMs(r, now = new Date()) {
   // a closed initiative (batch 26 item 5) is never late: its next milestone keeps its date and drops the days late
   return r.closed ? { ...x, late: false, over: 0 } : { ...x, late: over > 0, over: Math.max(0, over) };
 }
-const STATUS = { late: 'Late', risk: 'At risk', q: 'On hold' };
+const STATUS = { late: 'Late', risk: 'At risk', q: 'On hold', none: 'No signal' };
+/* workspace grill W2: a row with nothing read says No signal, grey; on track stays empty (zero is silence) */
+const stTone = (r, now) => offTone(r, now) || (r.status === 'no signal' ? 'none' : null);
 const nextText = (r) => { const t = r.track || {}; if (typeof t.next === 'string') return t.next; if (t.next && t.next.text) return t.next.text; const l = (t.line || [])[0]; return l ? l.text || '' : ''; };
-const stageName = (r) => { const s = stageOfRow(r); return (s && s.name) || (r.track && r.track.label) || r.stage || ''; };
+const stageName = (r) => oneStageName(r) || ((s) => (s && s.name) || '')(stageOfRow(r));   // W1: the one stage
 
 /** One cell's markup (never a <b>: the name is the row's only one). o: { now, avatar(name) } */
 function cell(r, k, o) {
   const now = o.now;
   if (k === 'stage') return `<span class="tg-c">${esc(stageName(r))}</span>`;
-  if (k === 'status') { const t = offTone(r, now); return t ? `<span class="tg-c tg-cst ${t}"><i class="cz-dot ${t}" aria-hidden="true"></i>${STATUS[t]}</span>` : '<span class="tg-c"></span>'; }
+  if (k === 'status') { const t = stTone(r, now); return t ? `<span class="tg-c tg-cst ${t === 'none' ? 'q' : t}"><i class="cz-dot ${t === 'none' ? 'q' : t}" aria-hidden="true"></i>${STATUS[t]}</span>` : '<span class="tg-c"></span>'; }
   if (k === 'start') { const d = day(r.start); return `<span class="tg-c">${d ? esc(dy(d, now)) : ''}</span>`; }
   if (k === 'ms') {
     const m = nextMs(r, now);
@@ -99,7 +102,7 @@ function cell(r, k, o) {
 function words(r, keys, now) {
   return keys.map((k) => {
     if (k === 'stage') return stageName(r);
-    if (k === 'status') { const t = offTone(r, now); return t ? STATUS[t] : ''; }
+    if (k === 'status') { const t = stTone(r, now); return t ? STATUS[t] : ''; }
     if (k === 'start') return day(r.start) ? 'starts ' + md(day(r.start)) : '';
     if (k === 'ms') { const m = nextMs(r, now); return m ? 'next ' + m.name + ' ' + md(m.d) + (m.late ? ', ' + m.over + (m.over === 1 ? ' day' : ' days') + ' late' : '') : ''; }
     if (k === 'wf') return wfOf(r).name;
@@ -111,7 +114,7 @@ function words(r, keys, now) {
   }).filter(Boolean).join(', ');
 }
 
-const tone = (r, now) => ({ late: 0, risk: 1, q: 2 })[offTone(r, now)] ?? 3;
+const tone = (r, now) => ({ late: 0, risk: 1, q: 2, none: 3 })[stTone(r, now)] ?? 4;
 const str = (v) => String(v || '~');
 const SORTS = {
   title: (a, b) => String(a.title).localeCompare(String(b.title)),

package/workspace/public/pm/bd-prog-panel.js

@@ -39,6 +39,7 @@ import { openCharter as charterForm, renamed as charterRenamed } from './program
 import * as MSG from './ms-suggest.js';
 import * as MD from './metric-drafts.js';   // the goal Claude drafts when the charter has none (batch 15 item 1, canvas Iq9Program)
 import * as DB from './dash-view.js';   // the page model's parts: the reports and the proposals (batch 17 item 1)
+import { stageName } from './stage-chip.js';   // W1: the one stage
 import * as PV from './prog-page.js';   // the one program page: the top and four tabs (batch 21 item 2, canvas RdProgL–RdProgP)
 
 const SV = (d, w) => `<svg viewBox="0 0 24 24" width="${w || 18}" height="${w || 18}" aria-hidden="true"><path d="${d}"/></svg>`;
@@ -225,7 +226,7 @@ const TREE_TASKS = 3;   // an initiative shows its first 3 open tasks in the tre
 function iniNode(p, st, i, tasks) {
   const k = 'i:' + p.id + ':' + i.id, r = i.row, t = r.track || {}, here = rowsOf(i.ws) && rowsOf(i.ws).here;
   const name = here ? `<button type="button" class="x pp-open" data-pp="ini" data-ini="${esc(i.id)}" aria-haspopup="dialog">${esc(i.title)}</button>` : `<a class="x pp-open" href="${esc(boardHref(i.ws, i.id))}" title="Opens on its product's board">${esc(i.title)}</a>`;
-  const stg = t.label || (STEPS[i.at] && STEPS[i.at].label) || i.stage;
+  const stg = stageName(r) || t.label || (STEPS[i.at] && STEPS[i.at].label) || i.stage;   // W1: the one stage
   let kids = '';
   if (!fold.has(k)) {
     const you = youOf(i);
@@ -448,7 +449,7 @@ function textOf(p) {
   const st = programState(p, rowsOf), s = summaryOf(p, st);
   const lines = [p.title + (p.goal ? ' · ' + p.goal : ''), [s.line, s.meta].filter(Boolean).join(' · ')];
   for (const m of st.milestones) lines.push('Milestone: ' + m.name + ' · ' + m.day + (m.done ? ' · done' : ''));
-  for (const i of st.inis) lines.push('- ' + i.title + ' · ' + ((i.row.track && i.row.track.label) || i.stage || ''));
+  for (const i of st.inis) lines.push('- ' + i.title + ' · ' + (stageName(i.row) || (i.row.track && i.row.track.label) || i.stage || ''));
   return lines.join('\n');
 }
 const titleOf = (p) => p.title + (p.goal ? ' · ' + p.goal : '');

package/workspace/public/pm/bd-span.js

@@ -47,6 +47,7 @@ import { esc } from './premium-shell.js';
 import { mergeClose } from './program-model.js';
 import { stagesOfRow } from './bd-wf.js';
 import { shownMs, endStage } from './bd-pins.js';
+import { stageName } from './stage-chip.js';   // W1: the one stage
 
 const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const day = (v) => { const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(v || '')); return m ? new Date(+m[1], +m[2] - 1, +m[3]) : null; };
@@ -566,7 +567,7 @@ function scaled(rows, M, o) {
   }
   const head = `<div class="tg-r tg-h"><div class="tg-n">${C ? C.head(back) : `<b>Initiative</b>${back}`}</div><div class="tg-p">${ticks}${pill}</div></div>`;
   // one line per initiative (PgTimeline): its status dot and its name; the owner and the step stay in the row's title for a pointer and a reader
-  const one = (r, cls) => { const s = o.status(r), sub = [r.owner, r.track ? r.track.label : r.stage, s.text].filter(Boolean).join(' · ');
+  const one = (r, cls) => { const s = o.status(r), sub = [r.owner, stageName(r), s.text].filter(Boolean).join(' · ');
     // the dot keeps its place while it is silent, so every name starts at the same line (XcalmA1Desk)
     const dot = dotHtml(r, now) || '<i class="tg-nodot" aria-hidden="true"></i>', nm = `<b>${r.inProgram && o.memberIcon ? o.memberIcon(r.inProgram) : ''}${esc(r.title)}</b>`;
     // with columns, the Status cell carries the dot and the name has none (say it once)