create-pmos 0.145.0 → 0.147.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.145.0",
+  "version": "0.147.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@e7517fc
+kernel-source: pmos@1f1a8b3
 assembled: 2026-10-12
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T02:42:43Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T02:42:43Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T02:42:43Z"}
 status: stable
 ---
 

package/workspace/c3-sessions-panel-test.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-sessions-panel-test.js — the console3 Sessions panel (Agent surfaces): ending a session and opening one (initiative sessions-panel-end-and-open).
+ *
+ * Starts a real server with its own state directory. Before it starts, a session record is written whose process does not exist and
+ * whose file still says it runs: the server restores it as exited, and GET /api/runs must say it ended (it read "starting · 4 d" before).
+ * Then one live shell is started, and the page checks: the live row reads the server's state, not "starting"; Open the session draws the
+ * session's real terminal in a sheet on /c3.html and the address does not change; End asks first, Keep it keeps it, End ends it.
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { WebSocket } = require('ws');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-sessions-panel' });
+
+const BASE = T.BASE;
+const results = [];
+const ok = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + extra : ''}`); };
+let srv = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-sessions-panel assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function until(fn, ms = 8000) { const end = Date.now() + ms; while (Date.now() < end) { const v = await fn(); if (v) return v; await sleep(150); } return null; }
+async function waitFor(page, fn, arg, ms = 15000) { try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; } }
+const get = (p) => fetch(BASE + p).then((r) => r.json());
+
+function startShell(name) {
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://${T.HOST}:${T.PORT}`); const inbox = [];
+    ws.on('message', (raw) => { try { inbox.push(JSON.parse(raw)); } catch { /* ignore */ } });
+    ws.on('error', () => resolve(null));
+    ws.on('open', async () => {
+      ws.send(JSON.stringify({ t: 'new', agent: 'shell', name }));
+      const m = await until(() => inbox.find((x) => x.t === 'created' || x.t === 'error'), 8000);
+      ws.close(); resolve(m && m.t === 'created' ? m.id : null);
+    });
+  });
+}
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the c3-sessions-panel suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-sessions-panel suite cannot run'); return finish(1); }
+
+  /* a record left by a server that stopped: the file says it runs, its process is gone (no tmux session by that name) */
+  const sessDir = path.join(T.STATE_DIR, 'sessions');
+  fs.mkdirSync(sessDir, { recursive: true });
+  const created = new Date(Date.now() - 4 * 864e5).toISOString();
+  fs.writeFileSync(path.join(sessDir, 'sess-900.json'), JSON.stringify({ id: 'sess-900', name: 'stale claude', agent: 'shell', state: 'working', created, tmux: 'pmos-gone-900', origin: 'manual', cwd: path.resolve(__dirname, '..'), root: path.resolve(__dirname, '..') }));
+  fs.writeFileSync(path.join(sessDir, 'sess-900.scrollback'), '');
+
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  await T.waitForServer(BASE);
+
+  /* ── A: /api/runs believes the server, not a stale file ── */
+  const r0 = await get('/api/runs');
+  const inGroup = (r, g, id) => ((r.groups && r.groups[g]) || []).some((s) => s.id === id);
+  ok('A1 a session whose process is gone is not listed as started by me', r0.ok && !inGroup(r0, 'startedByMe', 'sess-900'), JSON.stringify(r0.groups && r0.groups.startedByMe));
+  ok('A2 it is listed in Past', inGroup(r0, 'past', 'sess-900'));
+
+  const id = await startShell('panel shell');
+  ok('A3 a live shell starts', !!id);
+  const r1 = await until(async () => { const r = await get('/api/runs'); return inGroup(r, 'startedByMe', id) ? r : null; });
+  const row = r1 && r1.groups.startedByMe.find((s) => s.id === id);
+  ok('A4 the live shell is started by me and carries the server state', !!row && typeof row.label === 'string' && row.label.length > 0, JSON.stringify(row));
+
+  browser = await chromium.launch({ executablePath: exe });
+  const page = await (await browser.newContext({ viewport: { width: 1440, height: 1000 } })).newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e && e.message || e)));
+
+  /* ── B: the panel ── */
+  await page.goto(BASE + '/c3.html');
+  ok('B1 the header has the Sessions button', await waitFor(page, () => !!document.querySelector('[data-c3pg="agent-button"]'), null, 45000));
+  await page.click('[data-c3pg="agent-button"]');
+  const sel = `[data-c3t="mine"] [data-run="${id}"]`;
+  ok('B2 the live shell has a row under Started by me', await waitFor(page, (s) => !!document.querySelector(s), sel));
+  const sub = await page.evaluate((s) => (document.querySelector(s + ' .chips') || {}).textContent || '', sel);
+  ok('B3 the row does not say starting', !!sub && !/^starting/.test(sub.trim()), sub);
+  await page.click(sel + ' .nb');
+  ok('B3b a plain session draws no empty "Starting" card', await page.evaluate((s) => !document.querySelector(s + ' [data-run-host]'), sel));
+  ok('B4 the open row has End the session', await waitFor(page, (i) => !!document.querySelector(`[data-end-session="${i}"]`), id));
+
+  /* ── C: Open the session stays on this page ── */
+  const url0 = page.url();
+  await page.click(`[data-blank-panel="${id}"] [data-open-session]`);
+  ok('C1 the session opens in a terminal sheet', await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id));
+  ok('C2 the page stays on console3', page.url() === url0, page.url());
+  await sleep(800);
+  await page.click(`[data-c3-session-term="${id}"] .xterm`);
+  await page.keyboard.type('echo c3-typed-$((40+2))\n');
+  ok('C2b what is typed in the sheet reaches the shell', !!(await until(async () => /c3-typed-42/.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000)));
+  await page.keyboard.press('Escape');
+  await sleep(300);
+  ok('C3 Esc in the terminal goes to the shell, not the sheet', await page.evaluate((i) => !!document.querySelector(`[data-c3-session-term="${i}"]`), id));
+  await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  ok('C4 the close button closes the terminal sheet', await waitFor(page, () => !document.querySelector('[data-c3-session-term]')));
+  ok('C5 closing the sheet leaves the session running', await until(async () => ((await get('/api/sessions')).sessions || []).some((s) => s.id === id && s.state !== 'exited')));
+
+  /* ── D: End asks first, then ends ── */
+  await page.click('[data-c3pg="agent-button"]');
+  ok('D0 the panel opens again', await waitFor(page, (s) => !!document.querySelector(s), sel));
+  if (!(await page.isVisible(`[data-end-session="${id}"]`).catch(() => false))) await page.click(sel + ' .nb');
+  await page.click(`[data-end-session="${id}"]`);
+  ok('D1 End asks first', await waitFor(page, (i) => !!document.querySelector(`[data-end-confirm="${i}"]`), id));
+  await page.click(`[data-end-confirm="${id}"] button:not([data-end-yes])`);
+  ok('D2 Keep it keeps the session', await waitFor(page, (i) => !document.querySelector(`[data-end-confirm="${i}"]`), id) && ((await get('/api/sessions')).sessions || []).some((s) => s.id === id));
+  await page.click(`[data-end-session="${id}"]`);
+  await page.click(`[data-end-yes="${id}"]`);
+  const gone = async () => !((await get('/api/sessions')).sessions || []).some((s) => s.id === id);
+  if (!(await until(gone, 6000)) && await page.$(`[data-end-session="${id}"]`)) { await page.click(`[data-end-session="${id}"]`); await page.click(`[data-end-yes="${id}"]`); }   // "asked it to end": the second press removes it
+  ok('D3 End ends the session', !!(await until(gone, 8000)));
+  ok('D4 its row leaves Started by me', await waitFor(page, (s) => !document.querySelector(s), sel));
+
+  ok('E1 the page threw no error', errors.length === 0, errors.join(' | '));
+  return finish();
+})().catch((e) => { console.error(e); finish(1); });

package/workspace/guide/briefing-cards.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Briefing: cards, time of day, Needs you and Portfolio pulse"
 description: "How the Briefing cards keep one height and flip in place, how to confirm an act on a large screen, how the day part follows the clock, how a Portfolio pulse row opens inline, and how overdue items reach Needs you."
-timestamp: 2026-10-11
+timestamp: 2026-10-12
 ---
 
 # Briefing: cards, time of day, Needs you and Portfolio pulse
@@ -17,7 +17,7 @@ The tabs show counts: Briefing shows how many things need you, Work shows its in
 
 ### Kinds of card
 
-The label on a card says what kind of thing happened, for example **Deadline moved**, **Promise out of date**, **Blocked**, **Conflict**, **Risk**, **Waiting on someone** or **Report due**. A win keeps the label **Big win** or **Small win**. The colour of the card shows how serious it is: red is critical, amber is a warning, green is good news, and the accent colour is neutral.
+The label on a card says what kind of thing happened, for example **Deadline moved**, **Promise out of date**, **Blocked**, **Conflict**, **Risk**, **Waiting on someone** or **Report due**. A win keeps the label **Big win** or **Small win**. A card from your own data has the label **Overdue**, **Due today**, **Blocked**, **Worth asking** or **For you today** (see The Briefing: today's brief). The colour of the card shows how serious it is: red is critical, amber is a warning, green is good news, and the accent colour is neutral.
 
 Each kind has a short list of what its card must say. For example, a **Deadline moved** card says what moved, by how much, by when you must decide and the one move. When the card does not know a part, the back of the card says so under **Not known yet**. PMOS does not guess a missing part.
 

package/workspace/guide/briefing.md

@@ -17,6 +17,16 @@ The Briefing shows only what PMOS already holds. When PMOS holds nothing for a s
 
 The cards at the top are the signals that pass the relevance bar. Turn a card over to read its case.
 
+The cards come from two places:
+
+- **Your own data.** PMOS makes a card from each of these records:
+  - A Jira ticket or a plan (WBS) item assigned to you that is overdue, due today or blocked. "Blocked" means that the item is flagged, or that its status says blocked or on hold. The tickets come from the last My work read.
+  - An item in your Work list that is overdue or due today. An item that you parked, put on Waiting or moved to Later does not get a card.
+  - An item of today's morning brief that is worth asking, and an item of today's brief that is for you.
+- **The signal engine.** It reads the initiative records of the repository, for example a spec written after the build.
+
+Overdue cards come first, the most late first. The signal engine's cards come next. Then come the blocked, due today and brief cards. PMOS adds at most 5 cards from your own data. A card shows only the values that its record holds. When the record has a link, for example a Jira ticket, the case of the card has a link to it. The link opens in a new tab. When no record gives a card, the deck says that nothing needs you.
+
 Above the cards, the greeting names the part of the day, for example "Good morning, Wawan". The name is the first word of the git user name on the computer where PMOS runs. When git holds no name, the greeting has none. The part of the day follows the clock. There is no button to change it. When the clock moves to a new part, the line under the greeting and the order of the cards change after you stop using the page for a minute.
 
 ## Today
@@ -41,6 +51,14 @@ Needs you lists what only you can do. Its header says how many decisions, how ma
 3. Items outside PMOS that wait for you to confirm: talk to someone, meet, call, ask.
 4. Decisions that only you can make.
 
+The decisions come from these records:
+
+- A Jira ticket or a plan item assigned to you that is overdue, blocked, due today, or marked as your decision. Its row has the ticket key, and its case has a link to the ticket.
+- A signal engine card that has a suggested move, or is Critical.
+- An item of today's morning brief that is worth asking. The brief was not sure enough to act, so ask first.
+
+An item that is in your own items above does not show again as a decision. **Done** and **Later** on a ticket row change the item in your Work list. They do not change Jira.
+
 Press a row to open it in place. A row of your own item has three actions. Each one writes to the item itself, the same record the Work page shows.
 
 - **Done** marks the item done. For an item outside PMOS you can first type one line about what happened. The line is optional.
@@ -51,7 +69,7 @@ PMOS can see evidence that an outside item is done. For example, a meeting with
 
 ## Portfolio pulse
 
-Portfolio pulse says how many initiatives need attention, then shows one bar for the status of the initiatives and one row for each initiative. **All initiatives** at the bottom opens the Initiatives page. Press a row to open it in place. It shows why the initiative has that status, and the promised date against the forecast. The page does not change.
+Portfolio pulse says how many initiatives need attention, then shows one bar for the status of the initiatives and one row for each initiative. An initiative shows when it has a promised date, or when PMOS holds a read of its Jira epic. A row from a Jira epic shows "3 of 8 done" and a bar. "Done" counts the tickets under the epic that are done in Jira. A row with blocked tickets says **Blocked**. The Jira read is the last Jira status check; the opened row says its date. When no initiative has a promised date or a Jira read, the pulse says so. **All initiatives** at the bottom opens the Initiatives page. Press a row to open it in place. It shows why the initiative has that status, the promised date against the forecast, and the Jira progress when PMOS holds it. The page does not change.
 
 To go to the initiative, press **Open initiative** inside the opened row.
 

package/workspace/guide/console-calendar.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Guide: the Calendar tab of the console page"
-description: "The Calendar tab of the console page (/c3.html): Calendar and Notes, the five zooms, the layer chips, the markers, the context of a meeting, free time, the tidy-up suggestions and the empty states."
+description: "The Calendar tab of the console page (/c3.html): Calendar and Notes, the five zooms, the highlights, the layer chips, the markers, the context of a meeting, free time, the tidy-up suggestions and the empty states."
 timestamp: 2026-10-12
 ---
 
@@ -47,12 +47,27 @@ The chips under the zoom bar are the layers. Each chip shows the number of items
 
 All layers and Free time are on at the start. Tidy-up is off.
 
+On Month, Quarter and Year there is one more chip, **Routine**. It shows the number of routine items in the range: report drafts, reports that go out daily or weekly, recurring meetings, stand-ups, 1:1s and due items on track. These items are counted, not listed. Press **Routine** to show every item as a marker, and press it again to go back to the highlights.
+
+## Highlights
+
+Every zoom starts with a short summary above the grid, for example "October highlights". It names what matters in the range:
+
+- the releases, and the milestones that are on track
+- the key meetings, on Day, Week and Month only. A meeting is key when it is not routine. Month names the two biggest.
+- the reports that go out
+- **Watch:** the milestones and releases that are late or at risk, and the due items that are late
+
+Press a name to open the item in the detail column. When nothing significant falls in the range, the summary says so.
+
 ## The grid
 
 - **Day** shows the timeline of the day. The markers of the day are in a strip above it.
 - **Week** shows a timeline for each day. Each day name has the hours of meetings of that day and a small bar. The bar has three parts: time tied to a promise or a decision, routine time, and the rest of a 6 hour day. The markers of each day are in a strip under the day name. Press a day name to open that day.
-- **Month** shows a cell for each day. A cell shows the number of meetings and up to three markers. "+2" is a button. It opens the day with the other markers. Press the day number to open the day.
-- **Quarter** shows a row for each week. **Year** shows a card for each month. Each shows the number of meetings and dated items, and the most important markers. A "+N" button opens the week or the month that holds the rest.
+- **Month** shows a cell for each day. A cell shows the highlight of the day in one sentence, for example "SSO general release ships." Under it, a quiet line counts the rest, for example "1 due · 2 routine". Press that line or the day number to open the day. A line under the grid says what is counted and not named. With **Routine** on, a cell shows the number of meetings and up to three markers instead, and "+2" opens the day with the other markers.
+- **Quarter** shows a column for each month. **Year** shows a column for each quarter, with a button for each of its three months. Each column shows its highlight and a quiet line, for example "24 meetings · 3 due · 9 routine". Quarter and Year are stricter than Month: they name only milestones, releases, reports that go out and late items. Press a column's title to open that month or quarter. With **Routine** on, a column shows its markers instead.
+
+Titles wrap onto more lines. They are never cut.
 
 A marker has a symbol and a short title. A red edge means late or at risk of missing. An amber edge means at risk.
 

package/workspace/guide/console3-sessions.md

@@ -0,0 +1,35 @@
+---
+type: Guide
+title: "Sessions in console3: open, read and end your sessions"
+description: "How the Sessions panel in console3 groups your sessions, how to open a session's terminal without leaving console3, and how to end a session."
+timestamp: 2026-10-12
+---
+
+# Sessions in console3: open, read and end your sessions
+
+Press **Sessions** in the console3 header to open the panel. It shows your sessions in four groups: **On a card**, **Started by me**, **Past (7 days)** and **Automatic**.
+
+## Read a row
+
+Each row under **Started by me** shows the state of the session, how long ago it started, and its tree. The state comes from the workspace server, for example `working` or `quiet`.
+
+If the server finds that the process of a session stopped (for example, after a restart), the session moves to **Past**.
+
+## Open a session
+
+1. Press the row to open it.
+2. Press **Open the session**.
+
+The terminal of the session opens in a panel on the same page. You can type in it. When the terminal has focus, Esc and Tab go to the terminal. To close the panel, press its close button. The session continues to run.
+
+The **Open the session** link in the sessions dock opens the same panel.
+
+## End a session
+
+1. Press the row to open it.
+2. Press **End the session**.
+3. Press **End** to confirm, or press **Keep it** to cancel.
+
+When you end a session, its process stops and the session is removed. Any pending change stays a proposal. If the process does not stop immediately, press **End** again to remove it.
+
+A session that is on a card has the same **End the session** control below its card.

package/workspace/guide/data-freshness.md

@@ -35,6 +35,13 @@ The calendar-sync skill reads today and the next 14 days, read-only, and saves t
 
 The events are kept in your own runtime folder on this machine, never in a repository.
 
+The tracker-refresh skill reads tracker items from files already in your repository. It moves an item only when a file shows a new status, so a read can change nothing. Its last step records that the read finished, with this command:
+
+- `pmos tracker done [--moved N] [--left N] [--not-found N]` records the time of the read for this repository and the counts of what it found. It moves no item.
+- `pmos tracker status` says when tracker items were last read for this repository.
+
+The record is kept in your own runtime folder on this machine, never in a repository. Tracker items show the time of this record, or the time the schedule last started the skill if that is later.
+
 ## Where you see it
 
 Each page shows a short line under its title that says when each source was last read, for example **Initiatives read 08:02 · Calendar read 07:15 · Jira status read 06:31**. The line never says that the data is up to date, because the agents read these sources on a schedule and not live.

package/workspace/guide/index.md

@@ -69,4 +69,5 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [Integrated work](integrated-work.md): how `pmos verify-work` turns a merged commit into Done, and what "Done · your call · not merged" means.
 - [Report slides](report-slides.md): how the Reports page shows a report as the PM-OS biweekly slides, Present and Print / PDF, and how your notes become the words on the slides.
 - [Reports: dashboards of reports](reports-dashboards.md): the console Reports page, its dashboards at portfolio, board and initiative scope, how to edit and share one as a draft, and the Drafts tab.
+- [Sessions in console3](console3-sessions.md): the Sessions panel, how to open the terminal of a session on the same page, and how to end a session.
 - [Settings in console3](settings.md): how to open Settings, what each section holds, the scope tags, the environment notes, and where the settings are kept.

package/workspace/lib/briefing-real.js

@@ -0,0 +1,264 @@
+'use strict';
+/* lib/briefing-real.js — the Briefing's cards, "Needs you" rows and pulse progress from the PM's own data (initiative briefing-real-data).
+ *
+ *   build({ brief, myWork, itemLines, today })  → { lead, tail, needs }
+ *       lead   the overdue cards (most days late first); the route puts them before the engine's cards
+ *       tail   the blocked, due today, worth asking and brief priority cards, after the engine's cards
+ *              lead + tail hold at most MAX_CARDS cards together (R4)
+ *       needs  "Needs you" rows: overdue, blocked, decision and due today assigned items, then the brief's worth asking items (R6)
+ *   merge(engineCards, built)                   → cards   lead, then the engine's cards unchanged, then tail
+ *   engineNeeds(cards)                          → rows    the engine's cards that carry a move or are Critical, as needs rows ({ card })
+ *   jiraProgress(snapshot)                      → { done, total, blocked, epics, as_of } | null   one initiative's Jira epic progress (R7)
+ *   readSources(ctx, now, today)                → { brief, myWork, itemLines }   what the route reads; a source that fails gives nothing
+ *
+ * The sources: today's morning brief (<runtime>/briefs/<date>.json: `priorities` and `worth_asking`), GET /api/my-work items (Jira
+ * tickets and WBS items assigned to the PM), and the PM's Work ledger (<runtime>/pm-items/items.jsonl). A card or row is made only from
+ * a record, and a field is set only when the record holds its value. The ledger wins for an assigned item it holds: a done or dropped
+ * copy gives no card, and its due date, parking and waiting are the PM's. An assigned row carries its item id, so Done and Later work
+ * through the pm-items routes (they take a jira:, wbs: or brief: id on its first press).
+ *
+ * PURE except readSources. No network, no write.
+ */
+const path = require('path');
+const pmItems = require('./pm-items.js');
+
+const MAX_CARDS = 5;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const BLOCKED_RE = /block|flag|imped|on hold/i;
+const SOURCE_WORD = { calendar: 'Calendar', wispr: 'Wispr Flow', mail: 'Mail', slack: 'Slack', jira: 'Jira', confluence: 'Confluence', github: 'GitHub', drive: 'Drive', figma: 'Figma', website: 'Website', derived: 'PMOS' };
+const EFFORT_WORD = { minutes: 'minutes', 'an-hour': 'an hour', 'half-day': 'half a day', day: 'a day' };
+const COLOR = { bad: 'var(--destructive)', warn: 'var(--warning)', acc: 'var(--acc)', ink: 'var(--foreground)' };
+
+const dayNo = (s) => Math.round(Date.parse(s + 'T00:00:00Z') / 864e5);
+const isDate = (s) => DATE_RE.test(String(s || ''));
+const clip = (s, n) => { const t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n - 1).trimEnd() + '…' : t; };
+const httpsUrl = (v) => { const s = String(v || ''); try { return new URL(s).protocol === 'https:' && s.length <= 500 ? s : null; } catch { return null; } };
+const daysWord = (n) => (n === 1 ? '1 day' : n + ' days');
+const lateText = (n) => (n > 0 ? daysWord(n) + ' overdue' : 'due today');
+
+/** Blocked: the item carries `blocked`, or its status says blocked, flagged, impediment or on hold. */
+function blockedOf(x) {
+  if (x.blocked) return x.blocked && typeof x.blocked === 'object' && x.blocked.reason ? clip(x.blocked.reason, 120) : 'Blocked';
+  if (x.status && BLOCKED_RE.test(String(x.status))) return 'Status: ' + clip(x.status, 60);
+  return null;
+}
+
+/** An open item's place in time: days late (0 is due today), or null when it has no due date or is not due yet. */
+function lateBy(due, today) {
+  if (!isDate(due)) return null;
+  const n = dayNo(today) - dayNo(String(due).slice(0, 10));
+  return n >= 0 ? n : null;
+}
+/** The PM set it aside: parked, waiting on someone, moved to Later, or not before a later date. */
+const setAside = (i, today) => !!(i.parked || i.waiting_on || i.list_override === 'later' || (isDate(i.defer) && i.defer > today));
+
+/* ── the assigned items (GET /api/my-work), with the ledger's copy when it holds one ───────────────────────────── */
+function assignedOf(myWork, ledger, held, today) {
+  const out = [];
+  for (const x of Array.isArray(myWork) ? myWork : []) {
+    if (!x || !x.id || !x.title || x.state === 'done' || x.category === 'done') continue;
+    let a = x;
+    if (held.has(x.id)) {
+      const L = ledger.get(x.id);
+      if (!L || L.done) continue;                      // dropped or done in Work: the PM's answer stands
+      if (setAside(L, today)) continue;
+      a = { ...x, due: L.due !== undefined ? L.due : x.due };
+    }
+    const late = lateBy(a.due, today);
+    const blocked = blockedOf(a);
+    const decide = a.kind === 'decide' && (a.state === 'brief' || a.state === 'yours');
+    if (late === null && !blocked && !decide) continue;
+    out.push({ a, late, blocked, decide });
+  }
+  return out;
+}
+
+function assignedLabel(a) {
+  return a.source === 'wbs' ? 'WBS ' + a.key + (a.repo ? ' in ' + a.repo : '') : 'Jira ' + a.key;
+}
+
+function assignedCard(e, today) {
+  const { a, late, blocked } = e;
+  const jira = a.source !== 'wbs';
+  const reason = late > 0 ? 'overdue' : blocked ? 'blocked' : 'due';
+  const kpis = [];
+  if (late > 0) kpis.push([late + ' d', 'overdue', COLOR.bad]);
+  else if (late === 0) kpis.push(['today', 'due', COLOR.warn]);
+  if (blocked) kpis.push(['blocked', 'in ' + (jira ? 'Jira' : 'the plan'), COLOR.warn]);
+  if (a.wsjf && /^P[1-4]$/.test(String(a.wsjf.tier))) kpis.push([a.wsjf.tier, 'WSJF tier', COLOR.acc]);
+  if (a.blocks > 0) kpis.push([String(a.blocks), a.blocks === 1 ? 'item waits on it' : 'items wait on it', COLOR.warn]);
+  const facts = [[jira ? 'inbox' : 'repo', assignedLabel(a) + (a.status ? ' · ' + clip(a.status, 40) : '')]];
+  if (isDate(a.due)) facts.push(['clock', 'Due ' + String(a.due).slice(0, 10)]);
+  if (blocked) facts.push(['alert', blocked]);
+  else if (a.from) facts.push(['user', 'From ' + clip(a.from, 60)]);
+  const sug = a.suggest ? clip(a.suggest, 120) : null;
+  return {
+    key: 'real:' + a.id, origin: jira ? 'jira' : 'wbs', itemId: a.id,
+    tag: reason === 'due' ? 'Just in' : 'Critical', tone: reason === 'overdue' ? 'critical' : 'warning',
+    kind: reason === 'overdue' ? 'Overdue' : reason === 'blocked' ? 'Blocked' : 'Due today',
+    headline: clip(a.title, 140), sub: assignedLabel(a) + ' · assigned to you',
+    hero: { kind: 'big-number' }, kpis: kpis.slice(0, 3), factsX: facts.slice(0, 3), facts: [],
+    deadline: late !== null ? { days: -late, source: jira ? 'jira' : 'wbs', text: lateText(late) } : null,
+    why: { text: reason === 'overdue' ? 'Assigned to you and past its due date.' : reason === 'blocked' ? 'Assigned to you and blocked: ' + blocked + '.' : 'Assigned to you and due today.' },
+    ...(sug ? { move: { suggested: { id: 'suggest', label: sug }, options: [{ id: 'suggest', label: sug }] } } : {}),
+    ...(httpsUrl(a.url) ? { url: httpsUrl(a.url), url_label: 'Open ' + a.key + ' in Jira' } : {}),
+    _late: late, _rank: reason === 'overdue' ? 0 : reason === 'blocked' ? 1 : 2,
+  };
+}
+
+function workCard(i, late) {
+  const kpis = [late > 0 ? [late + ' d', 'overdue', COLOR.bad] : ['today', 'due', COLOR.warn]];
+  if (/^P[1-3]$/.test(String(i.priority || ''))) kpis.push([i.priority, 'priority', COLOR.acc]);
+  const facts = [['repo', 'In your Work list'], ['clock', 'Due ' + i.due]];
+  if (i.person) facts.push(['user', clip(i.person, 60)]);
+  return {
+    key: 'real:work:' + i.id, origin: 'work', itemId: i.id,
+    tag: late > 0 ? 'Critical' : 'Just in', tone: late > 0 ? 'critical' : 'warning', kind: late > 0 ? 'Overdue' : 'Due today',
+    headline: clip(i.title || '(untitled)', 140), sub: 'Your Work item',
+    hero: { kind: 'big-number' }, kpis, factsX: facts, facts: [],
+    deadline: { days: -late, source: 'work', text: lateText(late) },
+    why: { text: late > 0 ? 'Your own Work item, past its due date.' : 'Your own Work item, due today.' },
+    _late: late, _rank: late > 0 ? 0 : 2,
+  };
+}
+
+function briefCard(x, ask) {
+  const src = SOURCE_WORD[x.source] || null;
+  const kpis = [];
+  if (typeof x.confidence === 'number') kpis.push([Math.round(x.confidence * 100) + '%', 'confidence', ask ? COLOR.warn : COLOR.acc]);
+  if (EFFORT_WORD[x.effort]) kpis.push([EFFORT_WORD[x.effort], 'effort', COLOR.ink]);
+  const facts = [];
+  if (src) facts.push(['inbox', 'From ' + src]);
+  if (x.who) facts.push(['user', clip(x.who, 60)]);
+  if (x.ask) facts.push(['reply', clip(x.ask, 120)]);
+  else if (x.evidence) facts.push(['info', clip(x.evidence, 120)]);
+  const todo = x.todo ? clip(x.todo, 120) : null;
+  return {
+    key: 'real:brief:' + x.id, origin: 'brief', ...(ask ? {} : { itemId: 'brief:' + x.id }),
+    tag: 'Just in', kind: ask ? 'Worth asking' : 'For you today', signal: ask ? 'question' : 'suggest',
+    headline: clip(x.title, 140), sub: x.why_now ? clip(x.why_now, 240) : null,
+    hero: { kind: 'big-number' }, kpis: kpis.slice(0, 3), factsX: facts.slice(0, 3), facts: [],
+    deadline: null,
+    why: { text: ask ? 'In today\'s morning brief, below the confidence bar: worth asking before acting.' : 'In today\'s morning brief, for you.' },
+    ...(todo ? { move: { suggested: { id: 'todo', label: todo }, options: [{ id: 'todo', label: todo }] } } : {}),
+    ...(httpsUrl(x.link) ? { url: httpsUrl(x.link), url_label: 'Open the source' } : {}),
+    _late: null, _rank: ask ? 3 : 4,
+  };
+}
+
+/* ── the needs rows (the shape public/pm/c3-brief.js needRow takes) ──────────────────────────────────────────── */
+function assignedNeed(e) {
+  const { a, late, blocked, decide } = e;
+  const jira = a.source !== 'wbs';
+  const kind = late > 0 ? 'Overdue' : blocked ? 'Blocked' : decide ? 'Decide' : 'Due today';
+  const facts = [{ icon: jira ? 'inbox' : 'repo', text: assignedLabel(a) + (a.status ? ' · ' + clip(a.status, 40) : ''), source: jira ? 'Jira' : 'WBS' }];
+  if (isDate(a.due)) facts.push({ icon: 'clock', text: 'Due ' + String(a.due).slice(0, 10), source: jira ? 'Jira' : 'WBS' });
+  if (blocked) facts.push({ icon: 'alert', text: blocked, source: jira ? 'Jira' : 'WBS', tone: 'warn' });
+  if (a.ask) facts.push({ icon: 'reply', text: clip(a.ask, 160), source: a.from ? clip(a.from, 40) : (jira ? 'Jira' : 'WBS') });
+  return {
+    key: 'mw:' + a.id, itemId: a.id, origin: jira ? 'jira' : 'wbs', kind, headline: clip(a.title, 140),
+    icon: late > 0 || blocked ? 'alert' : decide ? 'scale' : 'clock', color: late > 0 ? COLOR.bad : blocked || late === 0 ? COLOR.warn : null,
+    time: late === null ? null : late > 0 ? 'overdue' : 'due today', dueText: late === null ? null : lateText(late),
+    src: jira ? a.key : 'WBS', p: a.wsjf && /^P[1-3]$/.test(String(a.wsjf.tier)) ? a.wsjf.tier : null,
+    why: late > 0 ? 'Assigned to you and past its due date.' : blocked ? 'Assigned to you and blocked.' : decide ? 'Assigned to you as a decision.' : 'Assigned to you and due today.',
+    facts, ...(httpsUrl(a.url) ? { url: httpsUrl(a.url), url_label: 'Open ' + a.key + ' in Jira' } : {}),
+    _rank: late > 0 ? 0 : blocked ? 1 : decide ? 2 : 3, _late: late,
+  };
+}
+
+function askNeed(x) {
+  const src = SOURCE_WORD[x.source] || null;
+  const facts = [];
+  if (x.evidence) facts.push({ icon: 'info', text: clip(x.evidence, 160), source: src || 'brief' });
+  if (x.ask) facts.push({ icon: 'reply', text: clip(x.ask, 160), source: x.who ? clip(x.who, 40) : (src || 'brief') });
+  if (typeof x.confidence === 'number') facts.push({ icon: 'search', text: 'Confidence ' + Math.round(x.confidence * 100) + '%: below the bar, so ask before acting', source: 'brief', tone: 'warn' });
+  return {
+    key: 'ask:' + x.id, origin: 'brief', kind: 'Worth asking', headline: clip(x.title, 140), icon: 'search', color: COLOR.acc,
+    time: null, src: src || 'Brief', why: x.why_now ? clip(x.why_now, 240) : null, facts,
+    ...(httpsUrl(x.link) ? { url: httpsUrl(x.link), url_label: 'Open the source' } : {}),
+    _rank: 4, _late: null,
+  };
+}
+
+const strip = (o) => { const { _late, _rank, ...rest } = o; return rest; };
+const byRank = (a, b) => a._rank - b._rank || (b._late || 0) - (a._late || 0);
+
+function build({ brief, myWork, itemLines, today } = {}) {
+  if (!isDate(today)) return { lead: [], tail: [], needs: [] };
+  const lines = Array.isArray(itemLines) ? itemLines : [];
+  const folded = pmItems.fold(lines);
+  const ledger = new Map(folded.map((i) => [i.id, i]));
+  const held = new Set(lines.filter((l) => l && l.id).map((l) => l.id));
+  const assigned = assignedOf(myWork, ledger, held, today);
+  const assignedIds = new Set((Array.isArray(myWork) ? myWork : []).map((x) => x && x.id).filter(Boolean));
+
+  const cards = [];
+  for (const e of assigned) if (e.late !== null || e.blocked) cards.push(assignedCard(e, today));
+  // the PM's own Work items (and ledger copies whose source no longer lists them); an assigned id was handled above
+  for (const i of folded) {
+    if (!i || i.done || assignedIds.has(i.id) || setAside(i, today)) continue;
+    const late = lateBy(i.due, today);
+    if (late !== null) cards.push(workCard(i, late));
+  }
+  const briefToday = brief && brief.date === today ? brief : null;
+  const fromBrief = (x) => x && x.id && x.title && !(held.has('brief:' + x.id) && (!ledger.get('brief:' + x.id) || ledger.get('brief:' + x.id).done));
+  const asks = briefToday && Array.isArray(briefToday.worth_asking) ? briefToday.worth_asking.filter(fromBrief) : [];
+  const mine = briefToday && Array.isArray(briefToday.priorities) ? briefToday.priorities.filter((x) => fromBrief(x) && x.owner === 'pm') : [];
+  for (const x of asks) cards.push(briefCard(x, true));
+  for (const x of mine) cards.push(briefCard(x, false));
+  cards.sort(byRank);
+  const kept = cards.slice(0, MAX_CARDS);
+
+  // Needs you: the assigned items the own half does not show (it shows the ledger's own items due by today), then the asks
+  const ownShown = (id) => { const L = ledger.get(id); return !!(L && !L.done && lateBy(L.due, today) !== null); };
+  const needs = [...assigned.filter((e) => !ownShown(e.a.id)).map(assignedNeed), ...asks.map(askNeed)].sort(byRank);
+
+  return { lead: kept.filter((c) => c._rank === 0).map(strip), tail: kept.filter((c) => c._rank !== 0).map(strip), needs: needs.map(strip) };
+}
+
+/** The engine's cards that carry a move or are Critical, as needs rows; the page shapes each from its card. Real cards (origin) are left out. */
+function engineNeeds(cards) {
+  return (Array.isArray(cards) ? cards : []).filter((c) => c && !c.origin && c.headline && (c.move || c.tag === 'Critical'))
+    .map((c) => ({ key: 'card:' + (c.key || c.headline), kind: 'decision', headline: String(c.headline), tag: c.tag, card: c }));
+}
+
+/** The deck: the overdue cards, the engine's cards unchanged, then the rest. */
+function merge(engineCards, built) {
+  const b = built || {};
+  return [...(b.lead || []), ...(Array.isArray(engineCards) ? engineCards : []), ...(b.tail || [])];
+}
+
+/** Needs you, in order: overdue and blocked assigned items, the engine's decisions, then decision, due today and worth asking rows. */
+function needsOf(built, engineCards) {
+  const rows = (built && built.needs) || [];
+  const head = rows.filter((n) => n.kind === 'Overdue' || n.kind === 'Blocked');
+  const rest = rows.filter((n) => !(n.kind === 'Overdue' || n.kind === 'Blocked'));
+  return [...head, ...engineNeeds(engineCards), ...rest];
+}
+
+/* ── R7 · Jira epic progress, from one status snapshot (lib/jira-status.js readSnapshot) ──────────────────────── */
+function jiraProgress(snap) {
+  if (!snap || !snap.tickets || typeof snap.tickets.values !== 'function') return null;
+  const all = [...snap.tickets.values()].filter((r) => r && r.key);
+  const parents = new Set(all.map((r) => r.parent).filter(Boolean));
+  const isEpic = (r) => /^epic$/i.test(String(r.type || '')) || parents.has(r.key);
+  const epics = all.filter(isEpic).map((r) => r.key);
+  const kids = all.filter((r) => !isEpic(r));
+  if (!kids.length) return null;
+  const done = kids.filter((r) => r.category === 'done').length;
+  const blocked = kids.filter((r) => r.category !== 'done' && r.flagged).length;
+  return { done, total: kids.length, blocked, epics, as_of: snap.fetchedAt || null };
+}
+
+/* ── the reads (the route's side) ─────────────────────────────────────────────────────────────────────────── */
+async function readSources(ctx, now, today) {
+  const out = { brief: null, myWork: [], itemLines: [] };
+  const dir = ctx && ctx.runtimeDir;
+  if (!dir) return out;
+  try { out.brief = JSON.parse(require('fs').readFileSync(path.join(dir, 'briefs', today + '.json'), 'utf8')); } catch { out.brief = null; }
+  try { out.itemLines = pmItems.readLines(path.join(dir, 'pm-items', 'items.jsonl')); } catch { out.itemLines = []; }
+  try { const mw = await require('./routes-my-work.js').listForAsync(ctx, now.getTime()); out.myWork = mw && mw.ok ? mw.items : []; } catch { out.myWork = []; }
+  return out;
+}
+
+module.exports = { MAX_CARDS, build, merge, needsOf, engineNeeds, jiraProgress, readSources, blockedOf };