create-pmos 0.134.0 → 0.135.0

package/workspace/lib/stage-tools.js

@@ -0,0 +1,208 @@
+'use strict';
+/* stage-tools.js — the records the PM edits per initiative and stage (problem statement, RICE, launch checklist, kill
+ * conditions, learnings), and the sprint burndown from the Jira snapshot (initiative stage-tools-records, PRD R1, R2, R4, R6).
+ *
+ *   TOOLS · LEDGER = 'initiative-tools.jsonl'
+ *   checkData(tool, data)            → { ok: true, data } | { ok: false, error }   the shape of one save; unknown fields dropped
+ *   readLedger(file)                 → Map<initiative, Map<tool, { data, at, by }>>  the last valid line per initiative and tool
+ *   recordsOf(folded, initiative)    → { problem, rice, launch, kill, learnings }     each { data, at, by } or null; rice adds score
+ *   appendTool(file, { initiative, tool, data }, actor, { now }) → the line written
+ *   riceScore(data)                  → reach × impact × confidence/100 ÷ effort, one decimal
+ *   riceRank(folded, ids)            → [{ id, score, rank, reach, impact, confidence, effort, at }]   highest score first
+ *   buildDeliverOn(boardsFile, board) → false only when the board's own line says buildDeliver: false
+ *   burndown(tickets, { sprint, today }) → { available: true, sprint, committed, done, left, ... } | { available: false, reason }
+ *
+ * THE LEDGER is one append-only file per repository, in that repository's state folder (the PM's choice, 2026-10-11): a
+ * save appends { v: 1, at, by, ev: 'tool', initiative, tool, data }. Nothing is rewritten. `by` is the guard's actor, never
+ * a field of the body. A line that does not parse, or whose data fails the shape check, is skipped by the read.
+ * The factory never writes this file (D65): the only writer is the page route, behind pm-guard requirePagePress.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const LEDGER = 'initiative-tools.jsonl';
+const TOOLS = Object.freeze(['problem', 'rice', 'launch', 'kill', 'learnings']);
+const IMPACTS = Object.freeze([0.25, 0.5, 1, 2, 3]);
+const KILL_STATES = Object.freeze(['watching', 'tripped', 'cleared']);
+const LIMITS = Object.freeze({ launch: 40, kill: 20, learnings: 60 });
+const TEXT_MAX = { problem: 4000, item: 500 };
+const ITEM_ID = /^[A-Za-z0-9][\w-]{0,39}$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const num = (v) => typeof v === 'number' && Number.isFinite(v);
+const textOk = (v, max) => typeof v === 'string' && v.trim().length >= 1 && v.length <= max && !/[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(v);
+
+function checkItems(tool, items, one) {
+  if (!Array.isArray(items)) return { ok: false, error: `${tool} needs items: a list` };
+  if (items.length > LIMITS[tool]) return { ok: false, error: `${tool} holds at most ${LIMITS[tool]} items` };
+  const out = []; const seen = new Set();
+  for (let i = 0; i < items.length; i++) {
+    const it = items[i];
+    if (!isObj(it)) return { ok: false, error: `${tool} item ${i + 1} is not an object` };
+    if (!ITEM_ID.test(String(it.id || ''))) return { ok: false, error: `${tool} item ${i + 1} needs an id (letters, digits, - or _)` };
+    if (seen.has(it.id)) return { ok: false, error: `${tool} item id ${it.id} is used twice` };
+    seen.add(it.id);
+    if (!textOk(it.text, TEXT_MAX.item)) return { ok: false, error: `${tool} item ${i + 1} needs text of 1 to ${TEXT_MAX.item} characters on one line` };
+    if (/[\r\n]/.test(it.text)) return { ok: false, error: `${tool} item ${i + 1} text must be one line` };
+    const r = one(it, i);
+    if (typeof r === 'string') return { ok: false, error: r };
+    out.push({ id: it.id, text: it.text.trim(), ...r });
+  }
+  return { ok: true, data: { items: out } };
+}
+
+/** The shape of one save. Unknown fields are dropped, so a record carries only what the read promises. */
+function checkData(tool, data) {
+  if (!TOOLS.includes(tool)) return { ok: false, error: `tool must be one of ${TOOLS.join(', ')}` };
+  if (!isObj(data)) return { ok: false, error: 'data must be an object' };
+  if (tool === 'problem') {
+    if (!textOk(data.text, TEXT_MAX.problem)) return { ok: false, error: `problem needs text of 1 to ${TEXT_MAX.problem} characters` };
+    return { ok: true, data: { text: data.text.trim() } };
+  }
+  if (tool === 'rice') {
+    const { reach, impact, confidence, effort } = data;
+    if (!num(reach) || reach < 0) return { ok: false, error: 'rice reach must be a number of 0 or more' };
+    if (!IMPACTS.includes(impact)) return { ok: false, error: `rice impact must be one of ${IMPACTS.join(', ')}` };
+    if (!num(confidence) || confidence < 0 || confidence > 100) return { ok: false, error: 'rice confidence must be a percentage from 0 to 100' };
+    if (!num(effort) || effort <= 0) return { ok: false, error: 'rice effort must be a number above 0 (person-months)' };
+    return { ok: true, data: { reach, impact, confidence, effort } };
+  }
+  if (tool === 'launch') return checkItems(tool, data.items, (it, i) => (typeof it.done === 'boolean' ? { done: it.done } : `launch item ${i + 1} needs done: true or false`));
+  if (tool === 'kill') return checkItems(tool, data.items, (it, i) => (KILL_STATES.includes(it.status) ? { status: it.status } : `kill item ${i + 1} needs status: ${KILL_STATES.join(', ')}`));
+  return checkItems(tool, data.items, (it, i) => (typeof it.date === 'string' && DATE_RE.test(it.date) ? { date: it.date } : `learnings item ${i + 1} needs date: YYYY-MM-DD`));
+}
+
+function readLedger(file) {
+  const out = new Map();
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return out; }
+  for (const raw of text.split('\n')) {
+    if (!raw.trim()) continue;
+    let e;
+    try { e = JSON.parse(raw); } catch { continue; }
+    if (!isObj(e) || e.ev !== 'tool' || typeof e.initiative !== 'string' || !e.initiative) continue;
+    const c = checkData(e.tool, e.data);
+    if (!c.ok) continue;
+    if (!out.has(e.initiative)) out.set(e.initiative, new Map());
+    out.get(e.initiative).set(e.tool, { data: c.data, at: typeof e.at === 'string' ? e.at : null, by: typeof e.by === 'string' ? e.by : null });
+  }
+  return out;
+}
+
+function riceScore(d) {
+  if (!d || !num(d.effort) || d.effort <= 0) return null;
+  return Math.round((d.reach * d.impact * (d.confidence / 100) / d.effort) * 10) / 10;
+}
+
+function recordsOf(folded, initiative) {
+  const mine = folded.get(initiative) || new Map();
+  const out = {};
+  for (const t of TOOLS) {
+    const r = mine.get(t);
+    out[t] = r ? { ...r, data: t === 'rice' ? { ...r.data, score: riceScore(r.data) } : r.data } : null;
+  }
+  return out;
+}
+
+function appendTool(file, { initiative, tool, data }, actor, { now } = {}) {
+  const line = { v: 1, at: new Date(now == null ? Date.now() : now).toISOString(), by: (actor && actor.by) || 'pm:unknown', ev: 'tool', initiative, tool, data };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, JSON.stringify(line) + '\n');
+  return line;
+}
+
+function riceRank(folded, ids) {
+  const want = Array.isArray(ids) && ids.length ? new Set(ids) : null;
+  const rows = [];
+  for (const [id, tools] of folded) {
+    if (want && !want.has(id)) continue;
+    const r = tools.get('rice');
+    if (!r) continue;
+    rows.push({ id, score: riceScore(r.data), ...r.data, at: r.at });
+  }
+  rows.sort((a, b) => (b.score - a.score) || a.id.localeCompare(b.id));
+  let rank = 0; let last = null;
+  rows.forEach((r, i) => { if (r.score !== last) { rank = i + 1; last = r.score; } r.rank = rank; });
+  return rows;
+}
+
+/** The per-board "Build and deliver" switch, from the board's own lines in boards.jsonl (kind 'board'). The last line that
+ * names it wins. Missing file, missing board or a board that never set it: on. */
+function buildDeliverOn(boardsFile, board) {
+  if (!boardsFile || !board) return true;
+  let text = '';
+  try { text = fs.readFileSync(boardsFile, 'utf8'); } catch { return true; }
+  let on = true;
+  for (const raw of text.split('\n')) {
+    if (!raw.trim()) continue;
+    let e;
+    try { e = JSON.parse(raw); } catch { continue; }
+    if (isObj(e) && e.kind === 'board' && e.board === board && typeof e.buildDeliver === 'boolean') on = e.buildDeliver;
+  }
+  return on;
+}
+
+// ── burndown ──────────────────────────────────────────────────────────────────────────────────────
+const DAY = 86400000;
+const dayNum = (d) => Date.UTC(+d.slice(0, 4), +d.slice(5, 7) - 1, +d.slice(8, 10)) / DAY;
+const dayStr = (n) => new Date(n * DAY).toISOString().slice(0, 10);
+const r1 = (x) => Math.round(x * 10) / 10;
+
+/** The sprint to draw: the named one, else the active one, else the latest that has dates. Sprints are keyed by id when
+ * Jira gave one, else by name. */
+function pickSprint(tickets, name) {
+  const by = new Map();
+  for (const t of tickets) {
+    const s = t && t.sprint;
+    if (!s || !s.name) continue;
+    const k = s.id || s.name;
+    const cur = by.get(k) || { name: s.name, state: s.state, id: s.id || null, start: null, end: null, completed: null };
+    for (const f of ['start', 'end', 'completed']) if (s[f] && !cur[f]) cur[f] = s[f];
+    by.set(k, cur);
+  }
+  const all = [...by.values()];
+  if (name) return all.find((s) => s.name === name) || null;
+  return all.find((s) => s.state === 'active') || all.filter((s) => s.start).sort((a, b) => (b.start > a.start ? 1 : -1))[0] || all[0] || null;
+}
+
+/**
+ * Remaining points per day over the sprint, from the tickets' current sprint membership. Committed is the points of every
+ * ticket in the sprint; a ticket counts as burned on its resolved date (or, when Done with no date, on the sprint's
+ * completion date for a closed sprint). Scope added or removed mid-sprint is not visible: the snapshot has no history.
+ */
+function burndown(tickets, { sprint: name, today } = {}) {
+  const list = Array.isArray(tickets) ? tickets : [];
+  const s = pickSprint(list, name);
+  if (!s) return { available: false, reason: name ? `no ticket is in the sprint ${name}` : 'no ticket is in a sprint' };
+  if (!s.start || !s.end) return { available: false, reason: `the Jira read has no dates for ${s.name}: the next Jira status check adds them`, sprint: s };
+  const inSprint = list.filter((t) => t.sprint && (s.id ? t.sprint.id === s.id : t.sprint.name === s.name));
+  const pointed = inSprint.filter((t) => num(t.points));
+  if (!pointed.length) return { available: false, reason: `no ticket in ${s.name} has story points`, sprint: s, tickets: inSprint.length, unpointed: inSprint.length };
+  const t0 = dayNum(s.start); const t1 = dayNum(s.end);
+  if (t1 < t0) return { available: false, reason: `${s.name} ends before it starts`, sprint: s };
+  const now = dayNum(today || new Date().toISOString().slice(0, 10));
+  const burnDay = (t) => {
+    if (t.category !== 'done') return null;
+    if (t.resolved) return dayNum(t.resolved);
+    return s.completed ? dayNum(s.completed) : now;
+  };
+  const committed = pointed.reduce((a, t) => a + t.points, 0);
+  const span = Math.max(1, t1 - t0);
+  const last = Math.min(t1, now);
+  const series = [];
+  for (let d = t0; d <= t1; d++) {
+    const ideal = r1(committed * (1 - (d - t0) / span));
+    if (d > last) { series.push({ date: dayStr(d), remaining: null, ideal }); continue; }
+    const burned = pointed.reduce((a, t) => { const b = burnDay(t); return b != null && b <= d ? a + t.points : a; }, 0);
+    series.push({ date: dayStr(d), remaining: r1(committed - burned), ideal });
+  }
+  const done = pointed.filter((t) => t.category === 'done').reduce((a, t) => a + t.points, 0);
+  const left = r1(committed - done);
+  const daysLeft = Math.max(0, t1 - now);
+  return {
+    available: true, sprint: s, committed: r1(committed), done: r1(done), left, daysLeft,
+    needPerDay: daysLeft > 0 ? r1(left / daysLeft) : null, series, tickets: inSprint.length, unpointed: inSprint.length - pointed.length,
+  };
+}
+
+module.exports = { LEDGER, TOOLS, IMPACTS, KILL_STATES, LIMITS, checkData, readLedger, recordsOf, appendTool, riceScore, riceRank, buildDeliverOn, burndown, pickSprint };

package/workspace/lib/vendor/scripts/signals/layout-paths.js

@@ -3,6 +3,7 @@
 // The workflow engine already decides which layout a repo has (scripts/workflow-state.js layout()): the PMOS repo keeps its
 // ledgers under planning/runs, a kit tenant keeps them under pmos/state. Readers must ask here and never hard-code planning/.
 const path = require('path');
+const { workspaceLib } = require('../workspace-lib.js');
 
 function pathsFor(root) {
   const base = path.resolve(root || process.cwd());
@@ -33,7 +34,7 @@ function planItemToFact(it) {
 }
 
 function planItemFacts(text) {
-  const P = require('../../workspace/lib/plan-items.js');
+  const P = require(workspaceLib('plan-items.js'));   // a checkout's workspace/lib, or the package's own lib
   const parsed = P.parseText(text);
   const folded = P.fold(parsed.lines || parsed);
   const list = Array.isArray(folded.items) ? folded.items : Object.values(folded.items || {});

package/workspace/lib/vendor/scripts/workspace-lib.js

@@ -0,0 +1,24 @@
+'use strict';
+/* workspace-lib.js — where a workspace/lib/ module is, for a script that runs in a checkout AND as a copy in a workspace
+ * package (incident workspace-package-script-closure).
+ *
+ *   require(workspaceLib('plan-items.js'))
+ *
+ * Some scripts share a fold with the workspace (the plan items, the item steps). In a checkout that module is at
+ * workspace/lib/<name>. In a package the script is a copy that scripts/vendor-workspace-engine.js put in lib/engine/,
+ * and this file is lib/engine/workspace-lib.js, so the module is the bundle's own lib/<name>, one folder up. A plain relative
+ * require of ../workspace/lib/x.js resolves in the first place only, and the vendor step refuses it.
+ *
+ * Both places are tried, the checkout first. When neither exists the checkout path is returned, and require() names it.
+ */
+const fs = require('fs');
+const path = require('path');
+
+function workspaceLib(name) {
+  const n = String(name || '');
+  if (!/^[a-z0-9][a-z0-9-]*\.js$/.test(n)) throw new Error(`workspaceLib: '${n}' must be a file name in workspace/lib/, such as 'plan-items.js'`);
+  const candidates = [path.join(__dirname, '..', 'workspace', 'lib', n), path.join(__dirname, '..', n)];
+  return candidates.find((p) => fs.existsSync(p)) || candidates[0];
+}
+
+module.exports = { workspaceLib };

package/workspace/lib/work-evidence.js

@@ -0,0 +1,73 @@
+'use strict';
+/* lib/work-evidence.js — "Looks done?" proof for work done outside PMOS (initiative console3-looks-done).
+ *
+ *   evidenceFor(item, { events, notes, now }) → string | null   one sentence, at most 240 characters
+ *   withEvidence(items, { events, notes, now }) → items         offline items gain `evidence` when they have none
+ *
+ * Pure: no I/O, no model. An offline item has a `person`. Proof is a calendar event that has ended and names the person, or
+ * a note that is not private and names the person (its title, meeting title or summary lines; the body is never read), both
+ * after the item was created. The PM confirms; nothing closes the item. */
+
+const MAX = 240;
+const MIN_FIRST = 3;
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const day = (t) => new Date(t).toISOString().slice(0, 10);
+const clip = (s) => (s.length > MAX ? s.slice(0, MAX - 1).trimEnd() + '…' : s);
+
+/** A matcher for a person: the full name, or the first name as a whole word (3 letters or more). */
+function matcher(person) {
+  const name = String(person || '').trim().replace(/\s+/g, ' ');
+  if (!name) return null;
+  const parts = [esc(name)];
+  const first = name.split(' ')[0];
+  if (first.length >= MIN_FIRST) parts.push(esc(first));
+  return new RegExp(`(^|[^\\p{L}\\p{N}])(?:${parts.join('|')})(?![\\p{L}\\p{N}])`, 'iu');
+}
+
+const ms = (t) => { const v = Date.parse(t || ''); return Number.isNaN(v) ? null : v; };
+
+function calendarProof(re, since, now, events) {
+  let best = null;
+  for (const e of events || []) {
+    const start = ms(e.at || e.start);
+    if (start === null || start < since) continue;
+    const end = ms(e.end) === null ? start : ms(e.end);
+    if (end > now) continue;
+    if (!re.test([e.title, ...(e.attendees || [])].join('\n'))) continue;
+    if (!best || start > best.start) best = { start, title: String(e.title || '').trim() };
+  }
+  return best && best.title ? `You had "${best.title}" on ${day(best.start)}.` : null;
+}
+
+function noteProof(re, since, now, notes) {
+  let best = null;
+  for (const n of notes || []) {
+    if (!n || n.private) continue;
+    const at = ms(n.updated_at) === null ? ms(n.created_at) : ms(n.updated_at);
+    if (at === null || at < since || at > now) continue;
+    const hay = [n.title, n.meeting && n.meeting.title, ...(n.summary_lines || [])].filter(Boolean).join('\n');
+    if (!re.test(hay)) continue;
+    if (!best || at > best.at) best = { at, title: String(n.title || (n.meeting && n.meeting.title) || 'Untitled note').trim() };
+  }
+  return best ? `Your note "${best.title}" from ${day(best.at)} mentions them.` : null;
+}
+
+function evidenceFor(item, { events = [], notes = [], now = Date.now() } = {}) {
+  if (!item || item.kind !== 'offline' || item.done) return null;
+  if (typeof item.evidence === 'string' && item.evidence.trim()) return item.evidence;
+  const re = matcher(item.person);
+  if (!re) return null;
+  const since = ms(item.created_at) === null ? 0 : ms(item.created_at);
+  const parts = [calendarProof(re, since, now, events), noteProof(re, since, now, notes)].filter(Boolean);
+  return parts.length ? clip(parts.join(' ')) : null;
+}
+
+function withEvidence(items, ctx = {}) {
+  return (items || []).map((it) => {
+    if (!it || it.kind !== 'offline') return it;
+    const ev = evidenceFor(it, ctx);
+    return ev && ev !== it.evidence ? { ...it, evidence: ev } : it;
+  });
+}
+
+module.exports = { evidenceFor, withEvidence, matcher, MAX };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.134.0",
+  "version": "0.135.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.134.0",
+      "version": "0.135.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/briefing-deck.js

@@ -12,10 +12,12 @@
  * Not registered with the registry (Today has no view registry): dest-today.js imports mountBriefing/disposeBriefing. */
 import { el } from './dom.js';
 import { createIdleGate, watchIdle, applyDayPart } from './c3-daypart.js';
-import { LENSES, TAG_STYLE, PART_STYLE, cardView, dayPartFor, nextCards, swipeDir, sizeFor, caseModelOf, rawOption } from './briefing-model.js';
+import { LENSES, TAG_STYLE, PART_STYLE, PARTS, partByKey, partFor, cardView, nextCards, swipeDir, sizeFor, caseModelOf, rawOption } from './briefing-model.js';
 import { BX, caseFile, toast } from './c3-brief.js';
 import { ensureC3Css, c3ic, c3ring, c3Phone } from './pm-work-view.js';
 import { listenButton } from './shell-readaloud.js';
+import { onBriefPage } from './c3-brief-data.js';
+import { button } from './primitives.js';
 
 const NS = 'http://www.w3.org/2000/svg';
 const roots = new WeakMap();   // host -> state
@@ -149,16 +151,23 @@ function hero(v) {
 
 /* ── one card: the mockup's cardHtml (line 2324): .fc > .ff (.tg + .cf) and .fb (.fh + .case) ──────────────────────── */
 
-const tagStyle = (v) => TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
+/* the tag's style, coloured by the card's tone when the engine sends one (briefing-model.js TONE_COLOR) */
+const tagStyle = (v) => { const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in']; return v.toneColor ? { ...T, color: v.toneColor } : T; };
 const pct = (x) => Math.round(Math.max(0, Math.min(1, x)) * 100);
 
 function eyebrow(v) {
   const T = tagStyle(v);
   if (v.eyebrow) return [el('span', { class: 'tg', style: '--tc:var(--muted-foreground)' }, c3ic(v.eyebrow.icon, 'sm'), v.eyebrow.label), v.pov ? el('span', { class: 'tag pov' }, v.pov) : null];
-  const tg = el('span', { class: 'tg' + (T.filled ? ' f' : ''), title: T.q }, c3ic(v.icon || T.icon, 'sm'), v.tag);
+  const tg = el('span', { class: 'tg' + (T.filled ? ' f' : ''), title: T.q }, c3ic(v.icon || T.icon, 'sm'), v.kind || v.tag);
   return v.pov ? [tg, el('span', { class: 'tag pov' }, v.pov)] : tg;
 }
 
+/* One number tile. Its colour is a token name ('var(--warning)' gives class k-warning), set by console3.css, so no inline style is needed. */
+const kpTile = (v, l, c) => {
+  const m = /^var\(--([a-z-]+)\)$/.exec(String(c || '')); const tone = m ? ({ success: 'foreground', purple: 'acc' }[m[1]] || m[1]) : 'acc';   // the colour vocabulary has no green or purple tile: success reads neutral, purple takes the accent
+  return el('div', { class: 'kp k-' + tone }, el('b', null, v), el('span', null, l));
+};
+
 /* the mockup's .kp tiles (line 765): numbers the card carries, only the ones it carries */
 function kpis(v) {
   const t = v.terms || {};
@@ -166,7 +175,15 @@ function kpis(v) {
   if (t.impact != null) a.push([pct(t.impact) + '%', 'impact', 'var(--acc)']);
   if (t.urgency != null) a.push([pct(t.urgency) + '%', 'urgency', 'var(--warning)']);
   if (t.score != null) a.push([String(Math.round(t.score * 100) / 100), 'score', 'var(--success)']);
-  return a.slice(0, 3).map((k) => el('div', { class: 'kp', style: '--c:' + k[2] }, el('b', null, k[0]), el('span', null, k[1])));
+  return a.slice(0, 3).map((k) => kpTile(k[0], k[1], k[2]));
+}
+
+/* The front's right side (the mockup's UI.deck): the number tiles the card carries (.kp). A card that carries no number keeps its picture (.hero), so the
+ * front is never empty. The tiles are a row of their own, not a second slot, so a card draws one or the other. */
+function cfh(v) {
+  const tiles = v.kpisX ? v.kpisX.map((k) => kpTile(k.v, k.l, k.c)) : kpis(v);
+  if (tiles.length) return el('div', { class: 'cfh', 'data-kp': String(tiles.length) }, el('div', { class: 'chips2 kps' }, ...tiles));
+  return el('div', { class: 'cfh' }, el('div', { class: 'hero', 'data-hero': v.hero.kind }, hero(v)));
 }
 
 function front(v) {
@@ -179,8 +196,7 @@ function front(v) {
     el('div', null, eyebrow(v)),
     el('div', { class: 'cf' },
       el('div', { class: 'cfa' }, el('h2', null, v.headline), v.sub ? el('div', { class: 'cfs' }, v.sub) : v.why ? el('div', { class: 'cfs', 'data-bf-why': '' }, 'why shown: ' + v.why) : null),
-      el('div', { class: 'cfh' }, el('div', { class: 'hero', 'data-hero': v.hero.kind }, hero(v))),
-      el('div', { class: 'cfk' }, ...(v.kpisX ? v.kpisX.map((k) => el('div', { class: 'kp', style: '--c:' + (k.c || 'var(--acc)') }, el('b', null, k.v), el('span', null, k.l))) : kpis(v))),
+      cfh(v),
       el('div', { class: 'cff' }, el('div', { class: 'cfx' }, ...facts), rec)));
 }
 
@@ -232,7 +248,7 @@ function card(S, v, i, n) {
   }, front(v), el('span', { class: 'flipg', 'aria-hidden': 'true' }, c3ic('undo', 'sm')), bk);
   bk.bind(c);
   /* named by its own headline (aria-labelledby) rather than a long aria-label: the card's name is its text, and the position is its description */
-  const hd = c.querySelector('h2'); if (hd) { hd.id = 'fc-h-' + String(v.key || i).replace(/\W+/g, '-') + '-' + i; c.setAttribute('aria-labelledby', hd.id); } else c.setAttribute('aria-label', v.tag + ': ' + v.headline);
+  const hd = c.querySelector('h2'); if (hd) { hd.id = 'fc-h-' + String(v.key || i).replace(/\W+/g, '-') + '-' + i; c.setAttribute('aria-labelledby', hd.id); } else c.setAttribute('aria-label', (v.kind || v.tag) + ': ' + v.headline);
   return c;
 }
 
@@ -244,9 +260,10 @@ function flipTo(S, c, force) {
   if (!c.classList.contains('on') && !c.classList.contains('back')) { deck.scrollTo({ left: c.offsetLeft - deck.children[0].offsetLeft, behavior: reduced() ? 'auto' : 'smooth' }); return; }
   const toBack = force !== undefined ? force : !c.classList.contains('back');
   deck.querySelectorAll('.fc.back').forEach((o) => { if (o !== c) { o.classList.remove('back'); o.setAttribute('aria-expanded', 'false'); } });
-  /* R2: the card has one fixed size and both faces are in it, so the flip is a CSS transition of rotateY (console3.css .flipcard, about 350 ms).
-   * Nothing is measured and nothing scrolls: no sibling and nothing below the deck moves. prefers-reduced-motion turns the transition off. */
+  /* The flip is a CSS transition of rotateY (console3.css .flipcard, about 350 ms). The front has a fixed size; the back grows to fit its content (console3 foundation),
+   * so the options and the slide are never clipped. Sibling cards keep their boxes. prefers-reduced-motion turns the transition off. */
   c.classList.toggle('back', toBack); c.setAttribute('aria-expanded', String(toBack));
+  if (toBack && c.scrollIntoView) c.scrollIntoView({ block: 'nearest', behavior: reduced() ? 'auto' : 'smooth' });   // the back grows to its content: bring its foot into view
   S.flip = toBack ? c.dataset.bfCard || '1' : null;
 }
 
@@ -323,15 +340,37 @@ async function load(S, lens) {
   else { const old = S.root.querySelector('.stance'); if (old) old.replaceWith(stance(S)); }   // another lens arrived: update the switch, keep the open card
 }
 
-/* the stance bar (the mockup's stanceBar, line 2332): the lens icon and its name and line. The lens follows the clock; there is no switch (console3 R4). */
+/* the stance bar (the mockup's stanceBar): the greeting for the part of the day, the lens and its line, the five-part day switch and the read-aloud
+ * button. The part follows the clock; a tap on the switch previews another part (its lens, its cards) and the preview drops when the clock moves
+ * to another part. The name is the PM's first name when PMOS holds one (GET /api/brief-page `me`); without one the greeting stands alone. */
 function stance(S) {
   const P = PART_STYLE[S.lens] || PART_STYLE.Plan;
+  const part = partByKey(S.preview || S.clockPart);
+  const seg = el('div', { class: 'seg dp', role: 'group', 'aria-label': 'Part of the day', title: 'Follows the clock. Tap to preview another part of the day.' },
+    ...PARTS.map((x) => {
+      const b = button({ label: x.label, variant: 'ghost', size: 'sm', onClick: () => setPart(S, x.k), attrs: { 'aria-pressed': String(x.k === part.k), 'data-pg-dp': x.k, title: x.label + ' · ' + x.at + (x.k === S.clockPart ? ' (now)' : ''), 'aria-label': x.label } });
+      b.replaceChildren(c3ic(x.icon, 'sm'));   // the icon alone; the label is the aria-label
+      return b;
+    }));
   return el('div', { class: 'stance', 'data-bf': 'lens-bar' },
-    el('span', { class: 'ki' }, c3ic(P.icon)),
-    el('div', null, el('b', { title: 'Follows the clock.' }, S.lens), el('span', { class: 'dim' }, P.sub)),
+    el('span', { class: 'ki' }, c3ic(part.icon)),
+    el('div', null, el('b', { title: 'Follows the clock: this is the part of the day it is now.' }, part.greet + (S.me ? ', ' + S.me : '')), el('span', { class: 'dim' }, S.lens + ': ' + P.sub)),
+    seg,
     listenButton(() => { const x = S.data[S.lens]; return x && x.ok ? x.cards[S.i] || x.cards[0] : null; }));   // the mockup's speaker (data-a=listen) reads the card on top
 }
 
+/* Preview one part of the day: its lens, its cards. Nothing is saved; the clock's own part comes back by tapping it, or when the clock moves on. */
+function setPart(S, k) {
+  const part = partByKey(k);
+  S.preview = k === S.clockPart ? null : k;
+  const lens = part.lens;
+  const changed = lens !== S.lens;
+  S.lens = lens; S.i = 0; S.flip = null;
+  if (changed) load(S, lens);
+  draw(S);
+  if (S.ctx.onLens) S.ctx.onLens(lens);
+}
+
 /* the mockup's running line (.tick > .tkt, lines 539 to 545): the engine's ticker strings, twice so the marquee loops */
 function ticker(items) {
   const one = (hide) => items.map((t) => el('span', { class: 'tki', 'aria-hidden': hide ? 'true' : null }, el('b', { style: 'color:var(--acc)' }, c3ic('bolt', 'sm')), String(t)));
@@ -340,7 +379,12 @@ function ticker(items) {
 
 function draw(S) {
   const d = S.data[S.lens];
-  const kids = [stance(S)];
+  /* a page's headline deck (ctx.bare, the Calendar tab): no lens row, and nothing at all until cards of its own scope arrive. ctx.scope
+   * is then required of the answer, so a server that does not know the scope never fills the page with another page's cards. */
+  const bare = !!(S.ctx && S.ctx.bare);
+  if (bare && (!d || !d.ok || d.scope !== S.ctx.scope || !(d.cards || []).length)) { S.root.replaceChildren(); S.root.hidden = true; S.flip = null; return; }
+  if (bare) S.root.hidden = false;
+  const kids = bare ? [] : [stance(S)];
   if (!d) kids.push(el('p', { class: 'dim mono', style: small, role: 'status' }, 'Reading the repository'));
   else if (!d.ok) kids.push(el('p', { class: 'dim mono', style: small, role: 'status', 'data-bf': 'error' }, 'The briefing could not be read: ' + d.error));
   else {
@@ -370,16 +414,18 @@ export function mountBriefing(host, ctx) {
   ensureC3Css();
   const root = el('section', { class: 'c3 brief', 'data-board': 'briefing', 'aria-label': 'Briefing' });
   host.replaceChildren(root);
-  const clock = dayPartFor(new Date());
-  S = { host, root, ctx: ctx || {}, lens: clock, clock, zoom: 'week', i: 0, flip: null, data: {}, dead: false };
+  const clockPart = partFor(new Date()).k;
+  const clock = partByKey(clockPart).lens;
+  S = { host, root, ctx: ctx || {}, lens: clock, clock, clockPart, preview: null, me: null, zoom: 'week', i: 0, flip: null, data: {}, dead: false };
   S.stopPhone = c3Phone(root);
   roots.set(host, S);
   draw(S);
   if (!host.closest('[data-daypart]')) applyDayPart(root);   // a page without the console3 shell still gets the day part tokens
   /* The clock moves the lens, but never under the reader: a new part waits for 60 s without pointer or key activity and for every card to be turned back. */
-  const gate = createIdleGate({ current: S.lens, part: (ms) => dayPartFor(new Date(ms)), busy: () => !!S.flip || !!S.root.querySelector('.fc.back'),
-    apply: (l) => { if (S.dead) return; S.clock = l; S.lens = l; S.i = 0; S.flip = null; load(S, l); draw(S); if (S.ctx.onLens) S.ctx.onLens(l); } });
+  const gate = createIdleGate({ current: S.clockPart, part: (ms) => partFor(new Date(ms)).k, busy: () => !!S.flip || !!S.root.querySelector('.fc.back'),
+    apply: (k) => { if (S.dead) return; const l = partByKey(k).lens; S.clockPart = k; S.preview = null; S.clock = l; S.lens = l; S.i = 0; S.flip = null; load(S, l); draw(S); if (S.ctx.onLens) S.ctx.onLens(l); } });
   S.idle = watchIdle(gate);
+  if (!(S.ctx && S.ctx.bare)) onBriefPage((j) => { const me = j && j.ok !== false && j.me ? String(j.me) : null; if (me === S.me || S.dead) return; S.me = me; const old = S.root.querySelector('.stance'); if (old) old.replaceWith(stance(S)); });   // the greeting's name
   if (S.ctx.onLens) S.ctx.onLens(S.lens);   // the page may follow the lens from the start (Reflect: "Carries over", "What I could stop")
   // the shown lens first, then the others for their preview line
   load(S, S.lens).then(() => Promise.all(LENSES.filter((l) => l !== S.lens).map((l) => load(S, l))));

package/workspace/public/pm/briefing-model.js

@@ -15,6 +15,26 @@ export const TAG_STYLE = {
   'Small win': { key: 'small', icon: 'up', color: 'var(--success)', filled: false, q: 'Small win: progress you can bank in one gesture.' },
   'Big win': { key: 'big', icon: 'flag', color: 'var(--success)', filled: true, q: 'Big win: a milestone worth telling others.' },
 };
+/* A card's tone (scripts/signals/kinds.js) colours it: the engine names open kinds ("Deadline moved", "Blocked", "Risk"), so the
+ * colour comes from the tone, not from the kind. Only health tones have a colour of their own (the colour vocabulary); a positive
+ * or neutral card, or one without a tone, keeps its tag's colour. */
+export const TONES = ['critical', 'warning', 'positive', 'neutral'];
+export const TONE_COLOR = { critical: 'var(--destructive)', warning: 'var(--warning)' };
+
+/* The five parts of the day (console3 Briefing stance switch). The lens is the part's signal ranking: evening and night both read Reflect. */
+export const PARTS = [
+  { k: 'morning', lens: 'Plan', icon: 'sun', label: 'Morning', at: '08:00', greet: 'Good morning' },
+  { k: 'midday', lens: 'Unblock', icon: 'bolt', label: 'Midday', at: '12:30', greet: 'Good afternoon' },
+  { k: 'afternoon', lens: 'Close', icon: 'check', label: 'Afternoon', at: '16:00', greet: 'Good afternoon' },
+  { k: 'evening', lens: 'Reflect', icon: 'moon', label: 'Evening', at: '18:30', greet: 'Good evening' },
+  { k: 'night', lens: 'Reflect', icon: 'star', label: 'Night', at: '22:00', greet: 'Good night' },
+];
+export const partByKey = (k) => PARTS.find((p) => p.k === k) || PARTS[0];
+/** The part of the day for a clock time (morning 5 to 11, midday 11 to 14, afternoon 14 to 17, evening 17 to 21, night 21 to 5). */
+export function partFor(date) {
+  const h = (date instanceof Date ? date : new Date(date)).getHours();
+  return partByKey(h >= 5 && h < 11 ? 'morning' : h >= 11 && h < 14 ? 'midday' : h >= 14 && h < 17 ? 'afternoon' : h >= 17 && h < 21 ? 'evening' : 'night');
+}
 /* The stance bar of each lens: icon and the line under its name (console3.html line 2206). */
 export const PART_STYLE = {
   Plan: { icon: 'sun', sub: 'Decide what gates the day' },
@@ -27,21 +47,24 @@ export const PART_STYLE = {
  * (pm-work-view.js SPRITE, `c3i-*`). The five starting tags map to the icons TAG_STYLE gives them. No model call, no network. */
 export const NEUTRAL_ICON = 'info';
 export const ICON_RULES = [
-  [/\bsmall win\b|\bprogress\b|\bimproved?\b/, 'up'],
+  [/\bsmall win\b|\bquick win\b|\bprogress\b|\bimproved?\b|\bcapacity\b|\bfree\b/, 'up'],
   [/\bbig win\b|\bwin\b|\bmilestone\b|\blaunch|\bship(ped)?\b|\brelease/, 'flag'],
   [/\bcritical\b|\brisks?\b|\bblock|\bincident|\boutage|\boverdue\b|\bescalat|\bregress|\bfail/, 'alert'],
   [/\bsecurity\b|\bcompliance\b|\bprivacy\b|\bpolicy\b/, 'shield'],
   [/\bdeadline|\bdue\b|\bmoved\b|\bslip|\bdelay|\bschedule|\bwaiting\b|\bwaits?\b/, 'clock'],
-  [/\bdecision|\bapprov|\btrade-?off|\bchoose|\bchoice/, 'scale'],
+  [/\bdecision|\bapprov|\btrade-?off|\bchoose|\bchoice|\bconflict|\bmismatch|\bdisagree/, 'scale'],
   [/\bopportunit|\bidea\b|\binsight|\bsuggest/, 'spark'],
   [/\bjira\b|\bticket|\bissue|\bnew from\b|\binbound\b/, 'inbox'],
   [/\bmeeting|\bcalendar|\bevent\b|\bagenda/, 'cal'],
-  [/\bmail|\bemail|\breply\b|\bmessage/, 'mail'],
-  [/\bperson|\bpeople|\bstakeholder|\bowner\b|\bteam\b|\bcustomer/, 'user'],
-  [/\bokr\b|\bgoal|\bobjective|\bkey result|\btarget\b/, 'target'],
+  [/\bmail|\bemail|\breply\b|\bmessage|\bpromise|\btold\b/, 'mail'],
+  [/\bperson|\bpeople|\bstakeholder|\bowner\b|\bowns?\b|\bnobody\b|\bteam\b|\bcustomer/, 'user'],
+  [/\bokr\b|\bgoal|\bobjective|\bkey result|\btarget\b|\banchor/, 'target'],
   [/\bmetric|\bkpi\b|\btrend|\breport|\bnumber|\bburn/, 'report'],
   [/\bpull request|\bpr\b|\bmerge|\bbranch|\bcommit|\bcode\b|\brepo/, 'branch'],
   [/\bdoc\b|\bdocs\b|\bspec\b|\bprd\b|\bnote/, 'doc'],
+  [/\bplan\b|\bplans\b|\broadmap|\bforecast|\btoo much\b|\boverload|\bload\b/, 'cal'],
+  [/\bquestion|\bunknown|\bhypothes|\bevidence|\bresearch/, 'search'],
+  [/\bsort\b|\btriage|\border\b|\brank/, 'filter'],
   [/\bjust in\b|\bnew\b|\bnews\b|\bupdate|\bsignal|\bchanged?\b/, 'bolt'],
 ];
 /** The icon name for a card of this kind and signal type. Pure. Unknown or empty gives the neutral icon. */
@@ -88,6 +111,10 @@ export function cardView(card) {
     kind: String(c.kind || c.tag || tag),
     icon: iconFor(c.kind || c.tag || tag, c.signal || c.signalType || c.type),
     tag, mark: TAG_MARK[tag], pinned: !!c.pinned,
+    tone: TONES.includes(c.tone) ? c.tone : null,
+    toneColor: TONE_COLOR[c.tone] || null,
+    /* what a card of this kind must say (the engine's template); null on cards that carry none */
+    template: c.template && typeof c.template === 'object' && c.template.text ? { text: String(c.template.text), gaps: Array.isArray(c.template.gaps) ? c.template.gaps.map(String) : [] } : null,
     headline: String(c.headline || ''),
     hero: { kind, points: Array.isArray(h.points) ? h.points.map(num).filter((x) => x !== null) : null },
     facts: (Array.isArray(c.facts) ? c.facts : []).filter(Boolean).map(String).slice(0, 3),
@@ -144,6 +171,7 @@ export const rawOption = (m, id) => ((m && (m.opts || m.options)) || []).find((o
 export const NO_ROUTE = 'No channel connected, and no route on this page carries it out. The suggestion stays text; nothing is sent or changed.';
 
 /** The case of one engine card (v = cardView(card)). Pure; every string comes from a card field. */
+const GAP_WORDS = { what: 'what happened', impact: 'the impact', when: 'by when', who: 'who it waits on', move: 'the move' };
 const OUTWARD = /\b(send|tell|warn|reply|replies|email|message|notify|invite|ask)\b/i;
 export function caseModelOf(v, o = {}) {
   const reg = v && v.key && registered('card', v.key);
@@ -156,9 +184,10 @@ export function caseModelOf(v, o = {}) {
   }));
   const dl = c.deadline;
   return {
-    id: 'card:' + (c.key || ''), tc: (TAG_STYLE[c.tag] || TAG_STYLE['Just in']).color,
+    id: 'card:' + (c.key || ''), tc: c.toneColor || (TAG_STYLE[c.tag] || TAG_STYLE['Just in']).color,
     situation: c.waitsFor ? 'Waiting on ' + c.waitsFor + '.' : c.sub || c.headline, evidence: ev, options: opts,
-    confidence: c.conf != null ? c.conf : null, unsure: c.unsure || '',
+    confidence: c.conf != null ? c.conf : null,
+    unsure: [c.unsure, c.template && c.template.gaps.length ? 'Not known yet: ' + c.template.gaps.map((g) => GAP_WORDS[g] || g).join(', ') + '.' : ''].filter(Boolean).join(' '),
     ifYouWait: dl ? (dl.days == null ? 'No deadline is known: ' + dl.text : dl.text) : '', why: c.why || '',
     outward: !sim, outboxReason: NO_ROUTE,
   };