create-pmos 0.125.0 → 0.126.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.125.0",
+  "version": "0.126.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@d18afe7
+kernel-source: pmos@ef9256d
 assembled: 2026-10-11
 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-11T02:26:05Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T02:44:29Z"}
 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-11T02:26:05Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T02:44:29Z"}
 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-11T02:26:05Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T02:44:29Z"}
 status: stable
 ---
 

package/workspace/guide/briefing-cards.md

@@ -0,0 +1,40 @@
+---
+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
+---
+
+# Briefing: cards, time of day, Needs you and Portfolio pulse
+
+## Cards
+
+Every card in a deck has the same height. Text that does not fit is cut short. Press a card to turn it over. The card turns in place in about a third of a second. No other card moves, and nothing below the deck moves. The back has the same size as the front and scrolls inside when it is long. With reduced motion on, the card changes at once.
+
+The icon of a card comes from fixed rules over the kind of the card. A kind the rules do not know gets a neutral icon.
+
+## Confirm an act
+
+On a screen with a mouse or trackpad, an act shows a compact button.
+
+- An act that sends something out, or that cannot be undone, asks you to press and hold. A ring fills for 0.6 seconds, and the act runs when it is full.
+- Any other act runs on one click.
+- With the keyboard, press Enter or Space on the button, then choose **Confirm** or **Cancel**. Escape closes the step.
+
+On a touch screen the slide stays. It is at most 320 pixels wide.
+
+## Time of day
+
+There is no selector for the part of the day. The Briefing reads the clock and checks it every five minutes. When the part of the day changes, the cards are ranked again only after you have not touched the page for a minute and no card is open, or the next time the page loads. A thin strip in the top bar shows the sun or the moon on the day's arc, with sunrise and sunset. It is worked out on this machine from the date and the time zone. It makes no network request.
+
+## Portfolio pulse
+
+Press a row of the Portfolio pulse to see it open under the row, on the Briefing. The tab does not change. The open row shows the promised date, the forecast and the slip. Press **Open initiative** inside it to go to the Initiatives tab.
+
+## Needs you
+
+Needs you also lists your own items that are overdue or due today. Overdue items come first, the most overdue first, then items due today. A row says how many days overdue it is. Done items, parked items, items waiting on someone and items without a date are not listed. At most five show.
+
+## Work
+
+The Work page no longer shows **Flow today**. **Jobs to be done** stays.

package/workspace/guide/index.md

@@ -26,6 +26,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 | The initiatives of a repository, or of every repository | Initiatives. Choose **All repositories** in Repository ▾ for every repository. |
 | The sessions of a repository, by initiative | The agent dock. ⌘K → **Branches and sessions** lists the branches. |
 | The items of an initiative | Board, or Breakdown in the initiative detail |
+| How the Briefing cards, day part, Portfolio pulse and overdue items work | [Briefing](briefing-cards.md) |
 | Run reports | Reports |
 | Whether a document is the same as its Google Docs or Confluence copy | Docs: ⌘K → **Docs**, or press `g d` |
 | The people you work with: who they are, your interactions, their tone, your notes and shared work | People: ⌘K → **People**, or press `g p` |

package/workspace/lib/needs-overdue.js

@@ -0,0 +1,41 @@
+'use strict';
+/* needs-overdue.js — the PM's own work items that belong in "Needs you" because their date has come: overdue first, then due today.
+ *
+ * Pure. Input: the folded items of lib/pm-items.js and today as YYYY-MM-DD. Output: needs rows in the shape the Briefing's row builder
+ * (public/pm/c3-brief.js needRow) takes, so the route can send them beside the engine's cards without touching the engine.
+ *
+ * Left out: done items, parked items, items waiting on someone else, and items the PM already moved to Later (that is the answer to a row).
+ * Order: most days overdue first, then due today; ties by title. Each row says "overdue" or "due today" in plain words.
+ */
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const dayNo = (s) => Math.round(Date.parse(s + 'T00:00:00Z') / 864e5);
+
+function daysOverdue(due, today) { return dayNo(today) - dayNo(due); }
+
+function wording(n) {
+  if (n > 0) return { time: 'overdue', ago: n === 1 ? '1 day overdue' : n + ' days overdue' };
+  return { time: 'due today', ago: 'due today' };
+}
+
+function overdueNeeds(items, today, opts = {}) {
+  if (!Array.isArray(items) || !DATE_RE.test(String(today || ''))) return [];
+  const limit = opts.limit > 0 ? opts.limit : 5;
+  const rows = [];
+  for (const it of items) {
+    if (!it || it.done || it.parked || it.waiting_on) continue;
+    if (it.list_override === 'later') continue;
+    if (!it.due || !DATE_RE.test(String(it.due))) continue;
+    const n = daysOverdue(it.due, today);
+    if (n < 0) continue;
+    const w = wording(n);
+    rows.push({
+      key: 'od-' + it.id, itemId: it.id, headline: it.title || '(untitled)', kind: n > 0 ? 'Overdue' : 'Due today', icon: 'clock',
+      color: n > 0 ? 'var(--destructive)' : 'var(--warning)', time: w.time, dueText: w.ago, src: 'my work', p: it.priority || null,
+      overdue: n > 0, days_overdue: Math.max(0, n), due: it.due,
+    });
+  }
+  rows.sort((a, b) => b.days_overdue - a.days_overdue || String(a.headline).localeCompare(String(b.headline)));
+  return rows.slice(0, limit);
+}
+
+module.exports = { overdueNeeds, daysOverdue };

package/workspace/lib/routes-briefing.js

@@ -1,7 +1,8 @@
 'use strict';
 /* routes-briefing.js — GET /api/briefing?lens=Plan|Unblock|Close|Reflect&zoom=day|week|month[&now=ISO] (console3 wave C1).
  *
- *   { ok, lens, zoom, cards, ticker, banner }
+ *   { ok, lens, zoom, cards, ticker, banner, own_needs }
+ *   own_needs: the PM's own items overdue or due today, as needs rows (lib/needs-overdue.js), overdue first. Additive; the page shows them above the cards.
  *
  * `cards` are the engine's selected cards (scripts/signals present() over readRepoFacts of the repo root), with the card
  * anatomy untouched. `ticker` is one line per top card, built from the card's own headline and deadline. `banner` is the
@@ -94,6 +95,14 @@ module.exports = {
     catch (e) { ctx.json(res, { ok: false, error: 'the signal engine failed: ' + (e && e.message ? e.message : String(e)) }, 500); return true; }
     const eng = loadEngine();
     const out = briefing(q, { root: useRoot, load: () => ({ present: eng.present, readRepoFacts: () => facts }) });
+    // additive: the PM's own overdue and due-today items, as needs rows beside the engine's cards (lib/needs-overdue.js); a read failure leaves the list empty
+    if (out.code === 200) {
+      try {
+        const pmItems = require('./pm-items.js');
+        const file = path.join(ctx.runtimeDir, 'pm-items', 'items.jsonl');
+        out.body.own_needs = require('./needs-overdue.js').overdueNeeds(pmItems.fold(pmItems.readLines(file)), iso);
+      } catch { out.body.own_needs = []; }
+    }
     ctx.json(res, out.body, out.code);
     return true;
   },

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.125.0",
+  "version": "0.126.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

@@ -1,6 +1,6 @@
 /* pm/briefing-deck.js — the Briefing view (console3 wave C1), built on the console3 mockup's own markup and CSS.
  * The mockup (prototype/pmos-console-handoff/mockups/console3.html) is the UI: the stance bar with the day-part switch (.stance,
- * .seg.dp), the running line (.tick, .tkt), the card deck (.deck, .fc, .cf, .hero, .dk, .dkd), the flip to the case file (.fb,
+ * the lens follows the clock, no switch), the running line (.tick, .tkt), the card deck (.deck, .fc, .cf, .hero, .dk, .dkd), the flip to the case file (.fb,
  * .case, .chgl, .opts, .slt, .cft), the tilt and the flip animation. The styles are pm/console3.css (see pm/console3-lift.md).
  * This file keeps the data call (GET /api/briefing, the signal engine's cards) and the model (briefing-model.js) and draws
  * what the engine sent: at most five cards, none invented. A field the engine does not supply is left out.
@@ -11,6 +11,7 @@
  * plot, so their facts are listed as text and the kind is named).
  * 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 { BX, caseFile, toast } from './c3-brief.js';
 import { ensureC3Css, c3ic, c3ring, c3Phone } from './pm-work-view.js';
@@ -154,7 +155,7 @@ 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(T.icon, 'sm'), v.tag);
+  const tg = el('span', { class: 'tg' + (T.filled ? ' f' : ''), title: T.q }, c3ic(v.icon || T.icon, 'sm'), v.tag);
   return v.pov ? [tg, el('span', { class: 'tag pov' }, v.pov)] : tg;
 }
 
@@ -226,7 +227,7 @@ function back(S, v) {
 function card(S, v, i, n) {
   const T = tagStyle(v); const bk = back(S, v);
   const c = el('article', {
-    class: 'fc' + (i === 0 ? ' on' : ''), tabindex: '0', role: 'button', 'aria-expanded': 'false', 'aria-description': 'card ' + (i + 1) + ' of ' + n,
+    class: 'fc flipcard' + (i === 0 ? ' on' : ''), tabindex: '0', role: 'button', 'aria-expanded': 'false', 'aria-description': 'card ' + (i + 1) + ' of ' + n,
     'data-a': 'cflip', 'data-bf': 'flip', 'data-bf-card': v.key || '', 'data-tag': T.key, 'data-tag-label': v.tag, style: '--tc:' + (v.eyebrow ? 'var(--muted-foreground)' : T.color),
   }, front(v), el('span', { class: 'flipg', 'aria-hidden': 'true' }, c3ic('undo', 'sm')), bk);
   bk.bind(c);
@@ -243,11 +244,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'); } });
-  const sw = () => { c.classList.toggle('back', toBack); c.setAttribute('aria-expanded', String(toBack)); if (toBack && c.scrollIntoView) c.scrollIntoView({ block: 'nearest', behavior: reduced() ? 'auto' : 'smooth' }); };
+  /* 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. */
+  c.classList.toggle('back', toBack); c.setAttribute('aria-expanded', String(toBack));
   S.flip = toBack ? c.dataset.bfCard || '1' : null;
-  if (reduced()) { sw(); return; }
-  c.classList.add('fl-out');
-  setTimeout(() => { c.classList.remove('fl-out'); sw(); c.classList.add('fl-in'); setTimeout(() => c.classList.remove('fl-in'), 320); }, 170);
 }
 
 function deckSync(S, deck) {
@@ -323,20 +323,13 @@ 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
 }
 
-const DAYPART = [['m', 'Morning', '08:12'], ['n', 'Midday', '12:30'], ['a', 'Afternoon', '16:05'], ['e', 'Evening', '18:30']];   // LENSES order: Plan, Unblock, Close, Reflect
-/* the mockup's stanceBar (line 2332): the lens icon, its name and line, and the day-part switch as .seg.dp icon buttons */
+/* 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). */
 function stance(S) {
   const P = PART_STYLE[S.lens] || PART_STYLE.Plan;
   return el('div', { class: 'stance', 'data-bf': 'lens-bar' },
     el('span', { class: 'ki' }, c3ic(P.icon)),
-    el('div', null, el('b', { title: S.lens === S.clock ? 'Follows the clock: this is the part of the day it is now.' : null }, S.lens), el('span', { class: 'dim' }, P.sub)),
-    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
-    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.' },
-      ...LENSES.map((l, qi) => {
-        const Q = PART_STYLE[l]; const N = DAYPART[qi];   // the mockup's PARTS (line 2206): the part is named by its time of day, the lens by what it does
-        return el('button', { type: 'button', 'aria-pressed': String(l === S.lens), 'data-bf-lens': l, 'data-a': 'tod', 'data-k': N[0], title: N[1] + ' · ' + N[2], 'aria-label': N[1],
-          onClick: () => { S.lens = l; S.i = 0; S.flip = null; load(S, l); draw(S); if (S.ctx && S.ctx.onLens) S.ctx.onLens(l); } }, c3ic(Q.icon, 'sm'));
-      })));
+    el('div', null, el('b', { title: 'Follows the clock.' }, S.lens), el('span', { class: 'dim' }, P.sub)),
+    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
 }
 
 /* the mockup's running line (.tick > .tkt, lines 539 to 545): the engine's ticker strings, twice so the marquee loops */
@@ -382,6 +375,11 @@ export function mountBriefing(host, ctx) {
   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); } });
+  S.idle = watchIdle(gate);
   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))));
@@ -410,6 +408,6 @@ export function flipBack(host) {
 
 export function disposeBriefing(host) {
   const S = roots.get(host);
-  if (S) { S.dead = true; if (S.stopPhone) S.stopPhone(); }
+  if (S) { S.dead = true; if (S.stopPhone) S.stopPhone(); if (S.idle) S.idle.dispose(); }
   roots.delete(host);
 }

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

@@ -22,6 +22,39 @@ export const PART_STYLE = {
   Close: { icon: 'check', sub: 'Send and finish before you leave' },
   Reflect: { icon: 'moon', sub: 'What moved, what carries over' },
 };
+/* R6: the icon of a card is chosen by code. Keyword rules run over the card's kind, then over its signal type; the first rule that
+ * matches wins, and a kind that matches no rule gets the neutral 'info' icon. Every name is a symbol of the vendored sprite
+ * (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'],
+  [/\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'],
+  [/\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'],
+  [/\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'],
+  [/\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. */
+export function iconFor(kind, signalType) {
+  for (const raw of [kind, signalType]) {
+    const t = String(raw === null || raw === undefined ? '' : raw).toLowerCase().replace(/[_-]+/g, ' ');
+    if (!t.trim()) continue;
+    const hit = ICON_RULES.find((r) => r[0].test(t));
+    if (hit) return hit[1];
+  }
+  return NEUTRAL_ICON;
+}
+
 export const HEROES = ['line', 'big-number', 'ring', 'bars', 'two-bars', 'rows', 'mini-graph'];
 
 /** 'L' at 500 and up, 'M' from 400 to 499, 'S' under 400. */
@@ -52,6 +85,8 @@ export function cardView(card) {
   const w = c.why || null;
   return {
     key: c.key || null,
+    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,
     headline: String(c.headline || ''),
     hero: { kind, points: Array.isArray(h.points) ? h.points.map(num).filter((x) => x !== null) : null },
@@ -136,7 +171,7 @@ export function needCaseOf(n) {
   if (n.view) return caseModelOf(n.view, { sim: !!n.sim });       // a real row is one engine card: its case is the card's own
   return {
     id: 'need:' + n.key, situation: n.headline,
-    evidence: [{ icon: 'clock', text: 'Due ' + (n.time || 'soon'), source: n.src || '' }],
+    evidence: [{ icon: 'clock', text: n.dueText ? n.dueText : 'Due ' + (n.time || 'soon'), source: n.src || '' }],
     options: [], outward: true, outboxReason: NO_ROUTE,
   };
 }

package/workspace/public/pm/c3-case.js

@@ -15,6 +15,9 @@
  *   options    `.opts`          buttons `.opt`, the recommended one first with `.rec`, its confidence ("Recommended · 82%") and a
  *                               `.conf` bar; each carries its effects (`.fx`: icon + text, tone). One is pressed (aria-pressed,
  *                               role=radio): the recommended one until the person picks another.
+ *   confirm    `.c3hold`        R3: where the main pointer is fine, the slide below is replaced by a compact button: press and hold 600 ms
+ *                               (a ring fills) for an act that cannot be undone, one click for one that can, Enter then Confirm from
+ *                               the keyboard (c3-swipe.js mountHold, holdMode). `opts.fine` forces the choice; the default asks matchMedia.
  *   slide      `.slt`           the slide-to-confirm (slide-confirm.js mountSlide). "Slide to choose this instead" and the grey
  *                               `.alt` look when the pick is not the recommended one. It is bound to the picked option: its
  *                               confirm hands back `hash` = `<case id>|<option id>`, the content the person saw.
@@ -26,6 +29,7 @@
 import { el } from './dom.js';
 import { c3ic } from './pm-work-view.js';
 import { mountSlide, disposeSlide } from './slide-confirm.js';
+import { mountHold, holdMode, finePointer } from './c3-swipe.js';
 
 /** The claim labels of the mockup (C3.LAB): [icon, tag, tone]. */
 export const LABELS = {
@@ -62,7 +66,7 @@ function effectOf(fx) {
 function optionOf(o, i) {
   const x = o || {};
   return { id: str(x.id !== undefined ? x.id : 'o' + i), label: str(x.l !== undefined ? x.l : x.label), rec: !!(x.rec || x.recommended),
-    effects: (x.fx || x.effects || []).map(effectOf), outward: !!x.outward, confidence: x.conf !== undefined || x.confidence !== undefined ? pct(x.conf !== undefined ? x.conf : x.confidence) : null };
+    effects: (x.fx || x.effects || []).map(effectOf), outward: !!x.outward, irreversible: !!x.irreversible, confidence: x.conf !== undefined || x.confidence !== undefined ? pct(x.conf !== undefined ? x.conf : x.confidence) : null };
 }
 
 /** The canonical case. Exactly one option is the recommended one: the first marked, else the first (the mockup's recId). */
@@ -127,12 +131,20 @@ export function renderCase(model, opts = {}) {
       o.rec ? el('div', { class: 'conf' }, el('i', { style: 'width:' + c.confidence + '%' })) : null);
     }));
   };
+  let disposeHold = null;
   const drawSlide = () => {
     disposeSlide(slideHost);
+    if (disposeHold) { disposeHold(); disposeHold = null; }
     slideHost.replaceChildren();
     const s = slideFor(c, picked, { outbox });
     if (s.none) return;
-    if (s.enabled) {
+    const fine = opts.fine !== undefined ? !!opts.fine : finePointer();
+    if (s.enabled && fine) {
+      const trk = el('div', { class: 'c3confirm', 'data-case-slt': c.id || null });
+      slideHost.append(trk);
+      disposeHold = mountHold(trk, { label: s.option.label || s.label, mode: holdMode(s.option, c), hash: c.id + '|' + s.option.id, alt: s.option.id !== c.recId,
+        onConfirm: (hash) => { if (opts.onConfirm) opts.onConfirm({ option: s.option, hash, case: c }); } });
+    } else if (s.enabled) {
       mountSlide(slideHost, { label: s.label, hash: c.id + '|' + s.option.id, onConfirm: (hash) => { if (opts.onConfirm) opts.onConfirm({ option: s.option, hash, case: c }); } });
       const trk = slideHost.querySelector('.slt');
       if (trk && s.option.id !== c.recId) trk.classList.add('alt');
@@ -168,6 +180,6 @@ export function renderCase(model, opts = {}) {
       goBtn));
   }
   /* a handle for the caller: read or set the pick, and tear the slide down when the case leaves the page */
-  root.c3case = { get picked() { return picked; }, pick, model: c, dispose() { if (slideHost) disposeSlide(slideHost); } };
+  root.c3case = { get picked() { return picked; }, pick, model: c, dispose() { if (slideHost) disposeSlide(slideHost); if (disposeHold) { disposeHold(); disposeHold = null; } } };
   return root;
 }

package/workspace/public/pm/c3-daypart.js

@@ -0,0 +1,176 @@
+/* pm/c3-daypart.js — the time of day for console3: the day part from the clock, the sun and moon on a daylight arc, and the gate that
+ * lets a new day part re-rank the Briefing only when the page is idle. No network and no geolocation prompt: the place is the browser's
+ * time zone (longitude, 15 degrees an hour) and one default latitude. The pure functions take the clock and the zone as arguments, so
+ * workspace/c3-daypart.test.js checks them without a browser. The DOM part (mountDaypart, applyDayPart) only runs in a page. */
+
+export const DAYPARTS = ['morning', 'midday', 'afternoon', 'evening', 'night'];
+/* Default latitude, degrees north, used when the page has no better idea. Mid-latitude, so day length is neither extreme. */
+export const DEFAULT_LATITUDE = 45;
+export const RECHECK_MS = 5 * 60 * 1000;
+export const IDLE_MS = 60 * 1000;
+
+/** The day part of a clock hour: morning 5 to 11, midday 11 to 14, afternoon 14 to 17, evening 17 to 21, night 21 to 5. */
+export function dayPartOf(date) {
+  const d = date instanceof Date ? date : new Date(date);
+  const h = d.getHours();
+  return h >= 5 && h < 11 ? 'morning' : h >= 11 && h < 14 ? 'midday' : h >= 14 && h < 17 ? 'afternoon' : h >= 17 && h < 21 ? 'evening' : 'night';
+}
+
+/** East longitude in degrees from a Date.getTimezoneOffset() value (minutes, positive west of UTC). Rough: a zone is 15 degrees wide. */
+export function longitudeFromOffset(offsetMinutes) {
+  const o = Number(offsetMinutes);
+  return isFinite(o) ? Math.max(-180, Math.min(180, -o / 4)) : 0;
+}
+
+const RAD = Math.PI / 180;
+const DAY_MS = 86400000;
+
+/** Local calendar day [y, m, d] of an instant in a zone given as getTimezoneOffset minutes. */
+function localYmd(ms, offsetMinutes) {
+  const d = new Date(ms - offsetMinutes * 60000);
+  return [d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()];
+}
+
+/** Sunrise and sunset (ms since epoch) of the local day that holds `ms`. `polar` is 'day' or 'night' when the sun never sets or rises. */
+export function sunTimes(ms, lat, lon, offsetMinutes) {
+  const [y, m, d] = localYmd(ms, offsetMinutes);
+  const jdNoon = Date.UTC(y, m, d, 12) / DAY_MS + 2440587.5;   // the sunrise equation (NOAA): n counts days from J2000
+  const n = Math.round(jdNoon - 2451545.0 + 0.0008);
+  const jStar = n - lon / 360;
+  const M = (357.5291 + 0.98560028 * jStar) % 360;
+  const C = 1.9148 * Math.sin(M * RAD) + 0.02 * Math.sin(2 * M * RAD) + 0.0003 * Math.sin(3 * M * RAD);
+  const lam = (M + C + 180 + 102.9372) % 360;
+  const jTransit = 2451545.0 + jStar + 0.0053 * Math.sin(M * RAD) - 0.0069 * Math.sin(2 * lam * RAD);
+  const sinDec = Math.sin(lam * RAD) * Math.sin(23.4397 * RAD);
+  const cosDec = Math.cos(Math.asin(sinDec));
+  const cosW = (Math.sin(-0.833 * RAD) - Math.sin(lat * RAD) * sinDec) / (Math.cos(lat * RAD) * cosDec);
+  const toMs = (jd) => Math.round((jd - 2440587.5) * DAY_MS);
+  if (cosW > 1) return { sunrise: null, sunset: null, polar: 'night', transit: toMs(jTransit) };
+  if (cosW < -1) return { sunrise: null, sunset: null, polar: 'day', transit: toMs(jTransit) };
+  const w = Math.acos(cosW) / RAD;
+  return { sunrise: toMs(jTransit - w / 360), sunset: toMs(jTransit + w / 360), polar: null, transit: toMs(jTransit) };
+}
+
+/** Where the sun or moon is now. body 'sun' while the sun is up, else 'moon'; t runs 0 to 1 along the arc of that body (sun: rise to set;
+ * moon: sunset to the next sunrise). In polar day or night t follows the clock around the transit. */
+export function arcState(ms, lat, lon, offsetMinutes) {
+  const today = sunTimes(ms, lat, lon, offsetMinutes);
+  const out = { sunrise: today.sunrise, sunset: today.sunset, polar: today.polar, body: 'sun', t: 0.5, up: true };
+  if (today.polar) {
+    out.up = today.polar === 'day'; out.body = out.up ? 'sun' : 'moon';
+    out.t = Math.max(0, Math.min(1, ((ms - today.transit) / DAY_MS) + 0.5));
+    return out;
+  }
+  if (ms >= today.sunrise && ms <= today.sunset) {
+    out.t = (ms - today.sunrise) / (today.sunset - today.sunrise);
+    return out;
+  }
+  out.body = 'moon'; out.up = false;
+  if (ms < today.sunrise) {
+    const prev = sunTimes(ms - DAY_MS, lat, lon, offsetMinutes);
+    const from = prev.sunset == null ? today.sunrise - 12 * 3600000 : prev.sunset;
+    out.t = Math.max(0, Math.min(1, (ms - from) / (today.sunrise - from)));
+  } else {
+    const next = sunTimes(ms + DAY_MS, lat, lon, offsetMinutes);
+    const to = next.sunrise == null ? today.sunset + 12 * 3600000 : next.sunrise;
+    out.t = Math.max(0, Math.min(1, (ms - today.sunset) / (to - today.sunset)));
+  }
+  return out;
+}
+
+/** Point on a half-ellipse arc from (pad, h - pad) over the top to (w - pad, h - pad). t 0 to 1. */
+export function arcPoint(t, w, h, pad) {
+  const p = pad == null ? 4 : pad;
+  const a = Math.PI * (1 - Math.max(0, Math.min(1, t)));
+  const rx = (w - 2 * p) / 2;
+  return { x: +(w / 2 + rx * Math.cos(a)).toFixed(2), y: +(h - p - (h - 2 * p) * Math.sin(a)).toFixed(2) };
+}
+
+/** "06:42" in the zone given as getTimezoneOffset minutes. */
+export function hhmm(ms, offsetMinutes) {
+  if (ms == null) return '--:--';
+  const d = new Date(ms - offsetMinutes * 60000);
+  return String(d.getUTCHours()).padStart(2, '0') + ':' + String(d.getUTCMinutes()).padStart(2, '0');
+}
+
+/** The words for the strip, short sentences. */
+export function stripLabel(st, offsetMinutes) {
+  if (st.polar === 'day') return 'The sun stays up all day.';
+  if (st.polar === 'night') return 'The sun stays down all day.';
+  return 'Sunrise ' + hhmm(st.sunrise, offsetMinutes) + '. Sunset ' + hhmm(st.sunset, offsetMinutes) + '.';
+}
+
+/* ── the idle gate: a new day part re-ranks the Briefing only when nobody is reading ── */
+
+/** Pure core. `part(ms)` gives the part for that time. `busy()` says a card is open. Call tick(ms) on a timer and touch(ms) on any
+ * pointer or key activity. `apply(part)` runs once per change, only when idle for idleMs and not busy. A part that arrives while
+ * busy waits (pending) and a later tick applies it. */
+export function createIdleGate({ current, part, busy, apply, idleMs = IDLE_MS }) {
+  let shown = current; let pending = null; let last = -Infinity;
+  return {
+    touch(ms) { last = ms; },
+    tick(ms) {
+      const p = part(ms);
+      pending = p !== shown ? p : null;
+      if (pending && !(busy && busy()) && ms - last >= idleMs) { shown = pending; pending = null; apply(shown); return true; }
+      return false;
+    },
+    get shown() { return shown; },
+    get pending() { return pending; },
+  };
+}
+
+/** Browser wiring of the gate: listens for activity on the document, checks every 5 minutes. Returns { dispose }. */
+export function watchIdle(gate) {
+  const touch = () => gate.touch(Date.now());
+  const evs = ['pointerdown', 'pointermove', 'keydown', 'wheel', 'touchstart'];
+  evs.forEach((e) => document.addEventListener(e, touch, { passive: true, capture: true }));
+  gate.touch(Date.now());
+  const timer = setInterval(() => gate.tick(Date.now()), RECHECK_MS);
+  return { dispose() { clearInterval(timer); evs.forEach((e) => document.removeEventListener(e, touch, { capture: true })); } };
+}
+
+/* ── DOM (browser only) ── */
+
+/** Set data-daypart on an element. */
+export function applyDayPart(elm, date) {
+  const p = dayPartOf(date || new Date());
+  if (elm && elm.getAttribute('data-daypart') !== p) elm.setAttribute('data-daypart', p);
+  return p;
+}
+
+const SVGNS = 'http://www.w3.org/2000/svg';
+const sv = (tag, attrs) => { const e = document.createElementNS(SVGNS, tag); for (const k in attrs) e.setAttribute(k, attrs[k]); return e; };
+
+/** The daylight strip: a small arc with the sun or moon and the sunrise and sunset times. About 22px tall. Appended to `host`.
+ * It sets data-daypart on `root` now and every 5 minutes. Returns { dispose }. */
+export function mountDaypart(root, host, opts) {
+  const o = opts || {};
+  const lat = o.lat == null ? DEFAULT_LATITUDE : o.lat;
+  const W = 56; const H = 18;
+  const arc = sv('path', { class: 'dl-arc', d: 'M4 14 A24 12 0 0 1 52 14', fill: 'none' });
+  const base = sv('line', { class: 'dl-base', x1: 2, y1: 14.5, x2: 54, y2: 14.5 });
+  const body = sv('circle', { class: 'dl-body', r: 3, cx: 4, cy: 14 });
+  const svg = sv('svg', { class: 'dl-svg', viewBox: '0 0 ' + W + ' ' + H, width: W, height: H, 'aria-hidden': 'true', focusable: 'false' });
+  svg.append(base, arc, body);
+  const txt = document.createElement('span'); txt.className = 'dl-txt';
+  const strip = document.createElement('div');
+  strip.className = 'c3pg-daylight'; strip.setAttribute('data-c3pg', 'daylight'); strip.setAttribute('role', 'img');
+  strip.append(svg, txt);
+  host.append(strip);
+  const draw = () => {
+    const now = new Date(); const off = now.getTimezoneOffset();
+    applyDayPart(root, now);
+    const st = arcState(now.getTime(), lat, longitudeFromOffset(off), off);
+    const pt = arcPoint(st.t, W, H - 2, 4);
+    body.setAttribute('cx', pt.x); body.setAttribute('cy', pt.y);
+    strip.setAttribute('data-body', st.body);
+    const label = stripLabel(st, off);
+    txt.textContent = label;
+    strip.setAttribute('aria-label', (st.up ? 'Day. ' : 'Night. ') + label);
+    strip.title = (st.up ? 'The sun is up. ' : 'The moon is up. ') + label + ' Worked out on this device from the date and the time zone.';
+  };
+  draw();
+  const timer = setInterval(draw, RECHECK_MS);
+  return { dispose() { clearInterval(timer); strip.remove(); } };
+}

package/workspace/public/pm/c3-shell.js

@@ -12,6 +12,7 @@
  * The workspace id is ?ws= (default: the first of GET /api/workspaces). The views read some routes without a ws, so a GET to /api/
  * that names none gets the page's ws added (see withWs). No dialog is used. Presses are the views' own. */
 import { el } from './dom.js';
+import { row } from './primitives.js';
 import { pmGet } from './http.js';
 import { ensureC3Css, c3ic, c3Phone, mountPmWork } from './pm-work-view.js';
 import { mountBriefing, showCard, flipBack } from './briefing-deck.js';
@@ -22,7 +23,8 @@ import { mountReleases } from './releases-view.js';
 import { mountReportFamilies } from './report-families-view.js';
 import { mountOutbox } from './outbox-panel.js';
 import { createDock } from './c3-dock.js';
-import { belowLine, reviewSection, handledRow, trustCard, footLine, needRow, rowApi, BX, toast, setNeedsTitle, hooks as briefHooks } from './c3-brief.js';
+import { belowLine, reviewSection, handledRow, trustCard, footLine, needRow, rowApi, BX, toast, setNeedsTitle, caseFile, hooks as briefHooks } from './c3-brief.js';
+import { makeXp, attachExpand } from './c3-expand.js';
 import { stopCard } from './c3-misc-panels.js';
 import { openSheet } from './c3-sheet.js';
 import { planNode, setPlanScope, dueCard, crossLinks, newInitLine, portfolioCard, readQuarter, mockPulse } from './c3-plan.js';
@@ -33,6 +35,7 @@ import { ic } from './c3-terminal-icons.js';
 import { mount as mountTickets, badge as ticketsBadge } from './c3-tickets.js';
 import { mount as mountDocs, badge as docsBadge } from './c3-docs.js';
 import { mount as mountSignals, badge as signalsBadge } from './c3-signals.js';
+import { mountDaypart } from './c3-daypart.js';
 import { mountTicker } from './shell-ticker.js';
 import { mountBell, openBellList } from './shell-bell.js';
 import { onBriefing, loadBriefing } from './shell-ticker.js';
@@ -143,7 +146,7 @@ const WHYS = [
   [10, 'Gestures', 'Drag a row right to finish it, left for later. The two glyphs at the edge show both; the bright one is what the agent suggests. At rest the page has almost no buttons. Keys: e, n, a, r, j, k.'],
   [11, 'Depth', 'Elevation means priority. Raised layers are things to act on. Flat layers are things to know. Glass floats above the page because it stays while you scroll.'],
   [12, 'Two columns', 'The left column is what you do. The right column is what you need to know. On a phone they merge, with the lens right after the cards.'],
-  [13, 'Part of the day', 'The page reads differently as the day goes: Plan, Unblock, Close, Reflect. It follows the clock, and the icons let you preview another part. The same signals are re-ranked, not replaced.'],
+  [13, 'Part of the day', 'The page reads differently as the day goes: Plan, Unblock, Close, Reflect. It follows the clock. A new part takes over only when you pause. The same signals are re-ranked, not replaced.'],
   [14, 'Phone: one screen', 'No scrolling on the phone. A running line and the bell carry what just arrived. The four tiles open popups for the lists, so the page itself stays still. Audio is optional: the speaker reads the top three cards aloud for when your hands are busy.'],
 ];
 const WHY_REGIONS = { 1: '[data-c3pg="deck-host"]', 13: '.stance', 3: '[data-c3pg="needs"]', 5: '[data-c3pg="review-host"] > *', 6: '[data-c3pg="handled-host"] > *', 7: '[data-c3pg="cal-host"]', 8: '[data-c3pg="pulse"]', 9: '[data-c3pg="trust-host"] > *' };
@@ -259,7 +262,8 @@ function needsList() {
     last = b;
     const inc = !!S.incident;
     const needs = b && Array.isArray(b.needs) && b.needs.length ? b.needs.filter((n) => !BX.gone[n.key] && (!inc || n.hard)) : null;
-    const key = needs ? needs.map((n) => n.key + n.headline) : ((b && b.cards) || []).map((c) => (c.key || '') + c.headline);
+    const own = !needs && b && Array.isArray(b.own_needs) ? b.own_needs.filter((n) => n && !BX.gone[n.key]) : [];   // the PM's own overdue and due-today items: overdue first, above the engine's cards
+    const key = needs ? needs.map((n) => n.key + n.headline) : own.map((n) => n.key + n.headline).concat(((b && b.cards) || []).map((c) => (c.key || '') + c.headline));
     if (needs && S.pinNeed) { const at = needs.findIndex((n) => n.key === S.pinNeed); if (at > 0) needs.unshift(...needs.splice(at, 1)); }   // a need the banner or the bell named rides to the top of the list: shown, not folded
     const g = JSON.stringify([key, inc, !!(b && b.kept_out), S.pinNeed || '']);
     if (g === sig) return; sig = g;
@@ -274,12 +278,15 @@ function needsList() {
     }
     const cards = ((b && b.cards) || []).map(cardView);
     quick.remove();
-    list.replaceChildren(...(cards.length ? cards.map((v, i) => {
+    const ownRows = (inc ? own.filter((n) => n.overdue) : own).map((n, i) => needRow(n, i, ctx));
+    const cardRows = cards.map((v, i) => {
       const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
-      return needRow({ key: v.key || String(i), headline: v.headline, kind: v.tag, icon: T.icon, color: T.color, time: v.deadline && v.deadline.text ? v.deadline.text : null, src: v.tag, view: v }, i, ctx);
-    }) : [el('li', { class: 'fold' }, c3ic('check', 'sm'), 'Nothing needs you.')]));
+      return needRow({ key: v.key || String(i), headline: v.headline, kind: v.tag, icon: T.icon, color: T.color, time: v.deadline && v.deadline.text ? v.deadline.text : null, src: v.tag, view: v }, i + ownRows.length, ctx);
+    });
+    const all = ownRows.concat(cardRows);
+    list.replaceChildren(...(all.length ? all : [el('li', { class: 'fold' }, c3ic('check', 'sm'), 'Nothing needs you.')]));
     extra.replaceChildren();
-    count.textContent = String(cards.length);
+    count.textContent = String(all.length);
   };
   S.refreshNeeds = () => { sig = ''; if (last) fill(last); };
   S.needsFill = fill;
@@ -290,6 +297,33 @@ function needsList() {
 
 /* portfolio pulse: the Calendar's own gantt rows (GET /api/calendar-views, quarter) as one status bar and a row per initiative */
 const PST = { 'on time': ['ok', 'On time', 'var(--success)'], 'at risk': ['warn', 'At risk', 'var(--warning)'], delayed: ['bad', 'Delayed', 'var(--destructive)'], overdue: ['bad', 'Overdue', 'var(--destructive)'], 'no plan': ['', 'No plan', 'var(--muted-foreground)'] };
+const PST_CLS = { 'on time': 'pst-ok', 'at risk': 'pst-warn', delayed: 'pst-bad', overdue: 'pst-bad', 'no plan': 'pst-none' };
+
+/* A pulse row opens in place, like a Needs you row: the same c3-expand panel and the same case component. It never changes the tab. "Open initiative" inside the case is the only way out. */
+const PULSE_OPEN = new Set();
+function pulseCase(g) {
+  const f = (g.forecast && (g.forecast.end || g.forecast.start)) || null; const p = g.promised || null;
+  const ev = [];
+  if (p) ev.push(['clock', 'Promised ' + p, '', 'ok']);
+  if (f) ev.push(['clock', 'Forecast ' + f, '', g.slip_days > 0 ? 'warn' : 'ok']);
+  if (g.slip_days > 0) ev.push(['alert', 'Slips ' + g.slip_days + ' d past the promise.', '', 'warn']);
+  const why = (g.pulse && g.pulse.why) || (p ? 'Forecast ' + (f || 'not set') + ' vs promised ' + p + '.' : 'No promised date' + (f ? '; forecast ' + f : '') + '.');
+  return caseFile({ id: 'pulse:' + g.id, sit: why, chg: ev, go: ['goinit', g.id, 'Open initiative'] });
+}
+function inlineRows(list, rows, watch) {
+  const byId = new Map(rows.map((g) => [String(g.id), g]));
+  const enhance = () => list.querySelectorAll('[data-c3pg-prow]').forEach((btn) => {
+    if (btn.hasAttribute('data-expand')) return;
+    const g = byId.get(btn.getAttribute('data-c3pg-prow')); if (!g) return;
+    const id = String(g.id); const xp = makeXp(); let built = false;
+    (btn.closest('.prow') || btn).after(xp); btn.setAttribute('data-a', 'pulsexp'); btn.setAttribute('aria-label', 'Show details: ' + (g.title || g.id));
+    attachExpand(btn, xp, { key: 'pulse-' + id, initial: PULSE_OPEN.has(id), onToggle: (on) => {
+      if (on) { PULSE_OPEN.add(id); if (!built) { built = true; xp.firstChild.append(pulseCase(g)); } } else PULSE_OPEN.delete(id);
+    } });
+  });
+  enhance();
+  if (watch) new MutationObserver(enhance).observe(list, { childList: true });
+}
 
 function pulse() {
   const body = el('div', null, el('p', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, 'Reading the initiatives.'));
@@ -299,7 +333,7 @@ function pulse() {
   const draw = (rows, err) => {
     if (err) { body.replaceChildren(el('p', { class: 'dim mono', style: 'font-size:var(--fs-2)', role: 'status' }, 'The initiatives could not be read: ' + err)); return; }
     if (!rows.length) { body.replaceChildren(el('div', { class: 'fold' }, c3ic('moon', 'sm'), 'No initiative has a promised date yet, so there is nothing to compare with the forecast.')); return; }
-    if (rows.some((g) => g.pulse)) { body.replaceChildren(...mockPulse(rows, S.today, () => showTab('init', true))); return; }   // demo: the mockup's pulse (its own colours, reasons and mini timelines)
+    if (rows.some((g) => g.pulse)) { const parts = mockPulse(rows, S.today, null); body.replaceChildren(...parts); inlineRows(parts[1], rows, true); return; }   // demo: the mockup's pulse (its own colours, reasons and mini timelines)
     const noPlan = rows.filter((g) => g.status === 'no plan').length;
     rows = rows.filter((g) => g.status !== 'no plan');
     if (!rows.length) { body.replaceChildren(el('div', { class: 'fold' }, c3ic('moon', 'sm'), 'No initiative has a promised date yet, so there is nothing to compare with the forecast.'), noPlan ? el('p', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, noPlan + ' initiatives have no plan date.') : null); return; }
@@ -311,12 +345,14 @@ function pulse() {
     const rowEl = (g) => {
       const k = PST[g.status] ? g.status : 'no plan'; const f = end(g.forecast); const p = g.promised || null;
       const why = p ? 'Forecast ' + (f || 'not set') + ' vs promised ' + p : 'No promised date' + (f ? '; forecast ' + f : '');
-      return el('button', { type: 'button', class: 'prow', 'data-c3pg-prow': g.id, 'data-a': 'goinit', 'aria-label': 'Open the initiatives: ' + (g.title || g.id), onclick: () => showTab('init', true) },
-        el('span', { class: 'dotc ' + PST[k][0] }),
-        el('span', { style: 'min-width:0' }, el('b', { style: 'font-size:var(--fs-3)' }, g.title || g.id), el('div', { class: 'dim', style: 'font-size:var(--fs-2);white-space:nowrap;overflow:hidden;text-overflow:ellipsis' }, why)),
-        el('span', { class: 'mono', style: 'font-size:var(--fs-2);color:' + PST[k][2] }, PST[k][1] + (g.slip_days > 0 ? ' +' + g.slip_days + ' d' : '')));
+      const label = 'Show details: ' + (g.title || g.id);
+      return row({ title: g.title || g.id, meta: [why], lead: [el('span', { class: 'dotc ' + PST[k][0] })],
+        trail: [el('span', { class: 'mono pst ' + PST_CLS[k] }, PST[k][1] + (g.slip_days > 0 ? ' +' + g.slip_days + ' d' : ''))],
+        onOpen: () => {}, openLabel: label, compact: true, attrs: { class: 'prow' },
+        openAttrs: { 'data-a': 'pulsexp', 'data-c3pg-prow': g.id, 'aria-label': label } });
     };
-    body.replaceChildren(bar, el('div', null, ...rows.slice(0, 8).map(rowEl)), rows.length > 8 ? el('div', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, '+' + (rows.length - 8) + ' more in the Calendar tab') : null, noPlan ? el('div', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, noPlan + ' more have no plan date.') : null);
+    const list = el('div', null, ...rows.slice(0, 8).map(rowEl)); inlineRows(list, rows, false);
+    body.replaceChildren(bar, list, rows.length > 8 ? el('div', { class: 'dim mono pnote' }, '+' + (rows.length - 8) + ' more in the Calendar tab') : null, noPlan ? el('div', { class: 'dim mono pnote' }, noPlan + ' more have no plan date.') : null);
   };
   readQuarter().then((j) => {
     if (!j || j.ok === false) draw([], (j && j.error) || 'unreadable'); else { S.today = j.today || ''; draw(j.gantt || []); }
@@ -617,6 +653,7 @@ async function boot() {
   const main = el('div', { class: 'c3main' }, header(), S.tickHost, tabBar(), S.pageView);
   S.grid = el('div', { class: 'c3grid' }, main, ...dock());
   root.replaceChildren(S.grid);
+  mountDaypart(root, root.querySelector('.c3top'));
 
   S.dock.setWorkspaces(S.workspaces, S.ws);
   mountBell(S.bellHost, { go: (_, t) => goTarget(t) });

package/workspace/public/pm/c3-swipe.js

@@ -15,7 +15,13 @@
  * threshold only. The row carries tabindex=0, data-swipe, and an aria-description naming both actions.
  *
  * Pure parts (Node-testable): swipeStep, swipeEnd, revealOf, keyAction, SWIPE.
+ *
+ * R3 (console3 quick fixes): the confirm control of a case file. On a fine pointer the long slide gives way to a compact button
+ * (mountHold): an act that cannot be undone needs a press and hold of 600 ms with a ring that fills; an act that can be undone is one
+ * click; from the keyboard, Enter opens a Confirm step for both. On touch the slide stays (slide-confirm.js).
+ * Pure parts: HOLD, holdMode, holdProgress, finePointer.
  */
+import { button } from './primitives.js';
 export const SWIPE = { threshold: 90, lock: 8, cancelY: 12, suppressMs: 80, tracking: 0.55 };
 
 /** One pointer-move. state: null | { x, y, on, dx }. Returns the next state (null = the gesture is cancelled: it is a scroll). */
@@ -136,3 +142,89 @@ export function attachSwipe(el, opts = {}) {
     el.removeAttribute('data-swipe'); el.removeAttribute('aria-description');
   };
 }
+
+/* ── R3: the compact confirm button for a fine pointer ──────────────────────────────────────────────────────────────────────── */
+export const HOLD = { ms: 600 };
+
+/** 'hold' for an act that cannot be undone (it sends something outside, or the option says so), 'click' for one the Undo toast reverses. */
+export function holdMode(option, caseModel) {
+  const o = option || {}; const c = caseModel || {};
+  return o.irreversible || o.outward || c.outward ? 'hold' : 'click';
+}
+
+/** How much of the ring is filled after `elapsed` ms of holding: 0 to 1. */
+export function holdProgress(elapsed, ms = HOLD.ms) {
+  const e = Number(elapsed);
+  if (!(e > 0)) return 0;
+  return Math.min(1, e / ms);
+}
+
+/** True where the main pointer is fine (a mouse or a trackpad): the compact button replaces the slide. */
+export function finePointer(mm) {
+  const f = mm || (typeof matchMedia === 'function' ? matchMedia : null);
+  try { return !!(f && f('(pointer: fine)').matches); } catch { return false; }
+}
+
+const SVGNS = 'http://www.w3.org/2000/svg';
+const node = (tag, attrs, ...kids) => {
+  const n = document.createElement(tag);
+  for (const k of Object.keys(attrs || {})) if (attrs[k] !== null && attrs[k] !== undefined) n.setAttribute(k, attrs[k]);
+  for (const c of kids) if (c) n.append(c);
+  return n;
+};
+function ringIcon(iconName) {
+  const svg = document.createElementNS(SVGNS, 'svg');
+  svg.setAttribute('class', 'hr'); svg.setAttribute('viewBox', '0 0 26 26'); svg.setAttribute('aria-hidden', 'true');
+  for (const cls of ['tk', 'fl']) {
+    const c = document.createElementNS(SVGNS, 'circle');
+    c.setAttribute('class', cls); c.setAttribute('cx', '13'); c.setAttribute('cy', '13'); c.setAttribute('r', '10');
+    svg.appendChild(c);
+  }
+  const g = document.createElementNS(SVGNS, 'svg');
+  g.setAttribute('class', 'ic'); g.setAttribute('x', '7'); g.setAttribute('y', '7'); g.setAttribute('width', '12'); g.setAttribute('height', '12');
+  const u = document.createElementNS(SVGNS, 'use'); u.setAttribute('href', '#c3i-' + iconName); g.appendChild(u);
+  svg.appendChild(g);
+  return svg;
+}
+
+/** Draw the compact confirm into host. opts: { label, mode: 'hold' | 'click', hash, alt, onConfirm(hash) }. Returns a dispose function.
+ *  onConfirm fires once. A pointer hold of HOLD.ms (mode hold) or a pointer click (mode click) confirms; Enter or Space opens a
+ *  Confirm step first, in both modes. Escape or Cancel closes the step. */
+export function mountHold(host, { label = 'Confirm', mode = 'click', hash = null, alt = false, onConfirm } = {}) {
+  host.replaceChildren();
+  const root = node('div', { class: 'c3hold', 'data-confirm-mode': mode });
+  const btn = button({ label, variant: 'outline', onClick: (e) => {
+    if (e.detail === 0) return;                  // a key made this click: the key path has its own step
+    if (mode === 'click') fire();
+  }, attrs: { class: 'hb' + (alt ? ' alt' : ''), 'data-hold': mode,
+    'aria-label': label + (mode === 'hold' ? '. Press and hold, or press Enter and confirm.' : '. Click, or press Enter and confirm.'),
+    onPointerDown: (e) => start(e), onPointerUp: () => stop(), onPointerLeave: () => stop(), onPointerCancel: () => stop() } });
+  btn.prepend(ringIcon(mode === 'hold' ? 'lock' : 'check'));
+  const hint = node('span', { class: 'hint', 'aria-live': 'polite' }, document.createTextNode(mode === 'hold' ? 'Hold to confirm.' : ''));
+  root.append(btn, hint);
+  host.appendChild(root);
+
+  let fired = false; let timer = null; let stepOpen = false;
+  const fire = () => { if (fired) return; fired = true; clearTimer(); root.classList.add('done'); btn.disabled = true; try { if (typeof onConfirm === 'function') onConfirm(hash); } catch { /* the caller reports its own errors */ } };
+  function clearTimer() { if (timer) { clearTimeout(timer); timer = null; } }
+  const stop = () => { clearTimer(); btn.classList.remove('holding'); };
+  const start = (e) => {
+    if (fired || stepOpen || (e.button !== undefined && e.button > 0)) return;
+    if (mode === 'hold') { btn.classList.add('holding'); timer = setTimeout(() => { btn.classList.remove('holding'); fire(); }, HOLD.ms); }
+  };
+  const openStep = () => {
+    if (fired || stepOpen) return;
+    stepOpen = true; stop();
+    const close = () => { stepOpen = false; q.remove(); btn.hidden = false; hint.hidden = false; btn.focus(); };
+    const yes = button({ label: 'Confirm', onClick: fire, attrs: { class: 'pill', 'data-confirm': 'yes' } });
+    const no = button({ label: 'Cancel', onClick: close, attrs: { class: 'pill', 'data-confirm': 'no' } });
+    const q = node('div', { class: 'cq', role: 'group', 'aria-label': 'Confirm ' + label }, document.createTextNode(label + '?'), yes, no);
+    btn.hidden = true; hint.hidden = true; root.appendChild(q);
+    q.addEventListener('keydown', (e) => { if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); } });
+    yes.focus();
+  };
+  btn.addEventListener('contextmenu', (e) => { if (mode === 'hold') e.preventDefault(); });
+  btn.addEventListener('keydown', (e) => { if ((e.key === 'Enter' || e.key === ' ') && !e.repeat) { e.preventDefault(); openStep(); } });
+  btn.addEventListener('keyup', (e) => { if (e.key === ' ') e.preventDefault(); });
+  return function dispose() { stop(); fired = true; host.replaceChildren(); };
+}

package/workspace/public/pm/calendar-views.js

@@ -697,7 +697,7 @@ function stageNode(host, r) {
 const PULSEK = { red: 'bad', delayed: 'bad', overdue: 'bad', amber: 'warn', 'at risk': 'warn', green: 'ok', 'on time': 'ok', park: '', 'no plan': '' };
 let pulseOn = false;
 function pulseA11y(root) {
-  root.querySelectorAll('[data-c3pg-prow]').forEach((p) => { if (!p.hasAttribute('role')) { p.setAttribute('role', 'button'); p.tabIndex = 0; p.title = 'Open the initiative'; } });
+  root.querySelectorAll('[data-c3pg-prow]').forEach((p) => { if (!p.hasAttribute('role')) { p.setAttribute('role', 'button'); p.tabIndex = 0; p.title = 'Show details'; } });
   root.querySelectorAll('.pbs > span').forEach((s) => { if (!s.hasAttribute('role')) { s.setAttribute('role', 'button'); s.tabIndex = 0; s.setAttribute('aria-pressed', 'false'); } });
 }
 function pulseFilter(seg) {
@@ -705,19 +705,18 @@ function pulseFilter(seg) {
   const on = seg.getAttribute('aria-pressed') !== 'true';
   bar.querySelectorAll(':scope > span').forEach((s) => { s.setAttribute('aria-pressed', String(on && s === seg)); s.style.opacity = on && s !== seg ? '.28' : ''; });
   const box = bar.closest('[data-c3pg="pulse"]');
-  box.querySelectorAll('[data-c3pg-prow]').forEach((p) => { const d = p.querySelector('.dotc'); const k = d ? (d.classList.contains('bad') ? 'bad' : d.classList.contains('warn') ? 'warn' : d.classList.contains('ok') ? 'ok' : '') : ''; p.hidden = on && want !== undefined && k !== want; });
+  box.querySelectorAll('[data-c3pg-prow]').forEach((p) => { const d = p.querySelector('.dotc'); const k = d ? (d.classList.contains('bad') ? 'bad' : d.classList.contains('warn') ? 'warn' : d.classList.contains('ok') ? 'ok' : '') : ''; p.hidden = on && want !== undefined && k !== want; const x = p.nextElementSibling; if (x && x.classList.contains('xp')) x.hidden = p.hidden; });
 }
 function installPulse(host) {
   const parent = host.parentElement; if (parent) { pulseA11y(parent); new MutationObserver(() => pulseA11y(parent)).observe(parent, { childList: true, subtree: true }); }
   if (pulseOn) return; pulseOn = true;
   const act = (t) => {
-    const row = t.closest && t.closest('[data-c3pg-prow]'); const seg = t.closest && t.closest('[data-c3pg="pulse"] .pbs > span');
-    if (row) { const r = [...live].find((x) => x.ctx && x.ctx.ribbon && x.data) || [...live].find((x) => x.data) || null; openInit(r && r.host, r, row.getAttribute('data-c3pg-prow'), (row.querySelector('b') || {}).textContent); return true; }
+    const seg = t.closest && t.closest('[data-c3pg="pulse"] .pbs > span');
     if (seg) { pulseFilter(seg); return true; }
     return false;
   };
   document.addEventListener('click', (e) => { if (act(e.target)) e.preventDefault(); });
-  document.addEventListener('keydown', (e) => { if ((e.key === 'Enter' || e.key === ' ') && e.target.matches && e.target.matches('[data-c3pg-prow],[data-c3pg="pulse"] .pbs > span') && act(e.target)) e.preventDefault(); });
+  document.addEventListener('keydown', (e) => { if ((e.key === 'Enter' || e.key === ' ') && e.target.matches && e.target.matches('[data-c3pg="pulse"] .pbs > span') && act(e.target)) e.preventDefault(); });
 }
 
 /* ── the Week page: "Progress and timing" and the time grid (console3 mockup progSVG line 2716, progCard 2739, weekView2 2604, weekListPh 2620) ── */

package/workspace/public/pm/console3.css

@@ -256,6 +256,12 @@
 @media (hover:hover){
 .c3 .prow:hover{background:color-mix(in oklab,var(--muted) 70%,transparent)}
 }
+.c3 .pnote{font-size:var(--fs-2)}
+.c3 .pst{font:var(--fs-2) var(--mono)}
+.c3 .pst-ok{color:var(--foreground)}
+.c3 .pst-warn{color:var(--warning)}
+.c3 .pst-bad{color:var(--destructive)}
+.c3 .pst-none{color:var(--muted-foreground)}
 .c3 .cmpill{border:1px solid var(--border);border-radius:16px;padding:2px 10px;font:var(--fs-2) var(--mono);white-space:nowrap}
 .c3 .cmpill.win{border-color:var(--acc);background:var(--accw)}
 .c3 .swap{animation:c3-swap .38s cubic-bezier(.2,.7,.2,1)}
@@ -1478,3 +1484,64 @@
 .c3 .psess:active{transform:scale(.93)}
 @media (max-width:760px){.c3 .psess{min-height:44px}}
 .c3 .psess .c{font:var(--fs-1) var(--mono)}
+
+/* Time of day (console3 quick fixes R5). data-daypart is set on the page root from the clock: morning, midday, afternoon, evening or night.
+ * Each part sets two tokens, both very faint: --dp-tint (a wash over the page background, alpha 6% or less) and --dp-warm (the colour of the
+ * sun and moon in the daylight strip). Neither reads --brand-mark. The values are built from theme tokens, so they follow the light and dark theme. */
+.c3[data-daypart="morning"]{--dp-tint:color-mix(in oklab,var(--warning) 4%,transparent);--dp-warm:var(--warning)}
+.c3[data-daypart="midday"]{--dp-tint:color-mix(in oklab,var(--warning) 3%,transparent);--dp-warm:var(--warning)}
+.c3[data-daypart="afternoon"]{--dp-tint:color-mix(in oklab,var(--warning) 4%,transparent);--dp-warm:var(--warning)}
+.c3[data-daypart="evening"]{--dp-tint:color-mix(in oklab,var(--destructive) 4%,transparent);--dp-warm:var(--destructive)}
+.c3[data-daypart="night"]{--dp-tint:color-mix(in oklab,var(--muted-foreground) 6%,transparent);--dp-warm:var(--foreground)}
+.c3pg[data-daypart]{background-image:linear-gradient(var(--dp-tint),var(--dp-tint))}
+/* The daylight strip in the top bar: an arc, a sun or a moon on it, and the two times. 22px tall, well under the 32px limit. */
+.c3 .c3top .c3pg-daylight{order:1;display:inline-flex;align-items:center;gap:8px;height:22px;max-height:32px;overflow:hidden;font:var(--fs-1)/1 var(--mono);color:var(--muted-foreground);white-space:nowrap}
+.c3 .c3top .tools{order:2}
+.c3 .c3pg-daylight .dl-svg{width:56px;height:18px;flex:none;overflow:visible}
+.c3 .c3pg-daylight .dl-arc{stroke:var(--border);stroke-width:1.2;stroke-dasharray:2 2}
+.c3 .c3pg-daylight .dl-base{stroke:var(--border);stroke-width:1}
+.c3 .c3pg-daylight .dl-body{fill:var(--dp-warm,var(--muted-foreground));transition:cx .8s ease,cy .8s ease}
+.c3 .c3pg-daylight[data-body="moon"] .dl-body{fill:none;stroke:var(--dp-warm,var(--muted-foreground));stroke-width:1.6}
+/* Reduced motion: the strip keeps its position and times; only the glide stops. */
+@media (prefers-reduced-motion:reduce){.c3 .c3pg-daylight .dl-body{transition:none}}
+/* ── R1 and R2: every briefing card has one fixed height; the flip turns it in place ─────────────────────────────────────────────
+ * The card is a fixed box (--fc-h). The front (.ff) and the back (.fb) fill it as two faces. The front clips and clamps its text;
+ * the back scrolls inside. The flip turns each face on rotateY, so the box never changes size and nothing around it moves. */
+.c3 .deck{--fc-h:312px}
+@media (max-width:520px){.c3 .deck{--fc-h:372px}}
+.c3 .fc.flipcard{display:block;height:var(--fc-h);min-height:0;padding:0;overflow:hidden}
+.c3 .fc.flipcard .ff,.c3 .fc.flipcard .fb{position:absolute;inset:0;box-sizing:border-box;padding:var(--sp-4) 20px 14px;min-height:0;backface-visibility:hidden;-webkit-backface-visibility:hidden;transition:transform .35s cubic-bezier(.2,.7,.2,1),visibility 0s linear .175s}
+.c3 .fc.flipcard .ff{display:grid;overflow:hidden;transform:perspective(900px) rotateY(0deg)}
+.c3 .fc.flipcard .fb{display:grid;align-content:start;gap:12px;overflow-y:auto;overscroll-behavior:contain;visibility:hidden;transform:perspective(900px) rotateY(180deg)}
+.c3 .fc.flipcard.back .ff{display:grid;visibility:hidden;transform:perspective(900px) rotateY(-180deg)}
+.c3 .fc.flipcard.back .fb{display:grid;visibility:visible;transform:perspective(900px) rotateY(0deg)}
+.c3 .fc.flipcard.back.on{transform:none;box-shadow:var(--sh2),var(--hi)}
+@media (hover:hover){
+.c3 .fc.flipcard.back.on:hover{transform:none;box-shadow:var(--sh2),var(--hi)}
+}
+.c3 .fc.flipcard .cf{min-height:0;overflow:hidden}
+.c3 .fc.flipcard .cf h2{display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}
+.c3 .fc.flipcard .cf .cfs{display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}
+.c3 .fc.flipcard .cf .cfx{max-height:calc(2 * 1.6em);overflow:hidden}
+.c3 .fc.flipcard .cf .cff{min-width:0}
+.c3 .fc.flipcard .cf .hero{max-height:176px;overflow:hidden}
+@media (prefers-reduced-motion:reduce){
+.c3 .fc.flipcard .ff,.c3 .fc.flipcard .fb{transition:none}
+}
+
+/* ── R3: with a fine pointer the slide gives way to a compact button ─────────────────────────────────────────────────────────────
+ * Press and hold for 600 ms fills the ring (an act that cannot be undone); one click does the act that can be undone; the keyboard
+ * path is Enter, then a Confirm button. On touch the slide stays, and it is at most 320 px wide. */
+.c3 .c3slide .slt,.c3 .c3slide .slt-hint{max-width:320px}
+.c3 .c3hold{display:flex;gap:var(--sp-2);align-items:center;flex-wrap:wrap}
+.c3 .c3hold .hb{--tc:var(--acc);position:relative;display:inline-flex;gap:8px;align-items:center;min-height:36px;padding:4px 14px 4px 6px;border-radius:6px;border:1px solid color-mix(in oklab,var(--tc) 40%,var(--border));background:color-mix(in oklab,var(--tc) 10%,var(--card));color:var(--foreground);font:500 var(--fs-2) var(--mono);cursor:pointer;user-select:none;touch-action:none}
+.c3 .c3hold .hb.alt{--tc:var(--muted-foreground)}
+.c3 .c3hold .hb:focus-visible{outline:2px solid var(--ring);outline-offset:2px}
+.c3 .c3hold .hb svg.hr{width:26px;height:26px;flex:none}
+.c3 .c3hold .hb svg.hr circle{fill:none;stroke-width:3}
+.c3 .c3hold .hb svg.hr .tk{stroke:var(--muted)}
+.c3 .c3hold .hb svg.hr .fl{stroke:var(--tc);stroke-linecap:round;stroke-dasharray:62.8;stroke-dashoffset:62.8;transform:rotate(-90deg);transform-origin:50% 50%;transition:stroke-dashoffset .2s ease-out}
+.c3 .c3hold .hb.holding svg.hr .fl{stroke-dashoffset:0;transition:stroke-dashoffset 600ms linear}
+.c3 .c3hold .hb.off{opacity:.55;cursor:not-allowed}
+.c3 .c3hold .hint{font:var(--fs-1) var(--mono);color:var(--muted-foreground)}
+.c3 .c3hold .cq{display:flex;gap:var(--sp-2);align-items:center;flex-wrap:wrap;font:var(--fs-2) var(--mono)}

package/workspace/public/pm/pm-work-view.js

@@ -15,7 +15,7 @@
  * would send something to a person is an outward option: its slide is drawn disabled ("no channel connected"); nothing is sent.
  * In demo mode (/c3.html?demo=1, window.__c3demo) the answers of the writes are laid over the fixtures in memory (`applyOv`); the
  * agent run of a row with a suggested move is a mock that only walks the steps and shows a labelled draft.
- * Drawn from the items: the flow card (counts) and the lens ring (done of total). The deck is ctx.plan, a node the page builds. The
+ * Drawn from the items: the lens ring (done of total). The deck is ctx.plan, a node the page builds. The
  * microphone is drawn disabled.
  *
  * The helpers c3ic, c3ring, ensureC3Css and c3Phone are shared with briefing-deck.js and calendar-views.js. */
@@ -110,7 +110,6 @@ export const COPY = Object.freeze({
   addJob: 'Add a job', addJobPlaceholder: 'when I plan a release, I want honest dates, so Dana can trust them',
   groupJob: 'Group by job to be done', groupTime: 'Group by time', loading: 'Reading…',
   micOff: 'Speak is off on this line: on-device dictation runs in Notes, in the main app. Type the item here.',
-  flow: 'Flow today', flowSub: 'capture, clarify, commit, do', flowNote: 'The counts are your own items: added today, given a date, a list or a job, in Today, done today.',
   jobsNote: 'The count is every item in the job, across all lists. Tap a job to edit or delete it.',
   legend: ['open', 'done', 'migrated', 'scheduled'], readError: 'Your items could not be read.', saveError: 'Nothing was saved.',
   removed: 'Removed.', undo: 'Undo', restored: 'Restored.', tooLate: 'Too late to undo.', drop: 'Drop it',
@@ -169,7 +168,6 @@ function applyOv(base, ov) {
     j.total = (j.total || 0) + ov.added.filter((a) => a.item.job === j.id).length;
   });
   d.jobs = jobs;
-  if (d.flow) d.flow = d.flow.map((r) => (r[0] === 'Done' ? [r[0], r[1] + ov.done.size, r[2]] : r[0] === 'Captured' ? [r[0], r[1] + ov.added.length, r[2]] : r));
   return d;
 }
 
@@ -839,28 +837,6 @@ function lensBar(inst) {
   return [seg, el('div', { class: 'chips2' }, grp)];
 }
 
-/* The mockup's flowCard() (line 3340): four bars, each a count of the PM's own items. Captured = added today, Clarified = has a date, a
- * list or a job, Committed = in Today, Done = done today. The server's `today` is a UTC date and the stamps are UTC, so they compare. */
-function flowCounts(d) {
-  const items = d.items || []; const t = d.today;
-  const open = items.filter((i) => !i.done);
-  return [
-    ['Captured', items.filter((i) => String(i.created_at || '').slice(0, 10) === t).length, 'var(--muted-foreground)'],
-    ['Clarified', open.filter((i) => i.due || i.job || i.list_override).length, 'var(--acc)'],
-    ['Committed', ((d.lists || {}).today || []).filter((i) => !i.done).length, 'var(--warning)'],
-    ['Done', items.filter((i) => i.done && String(i.done_at || '').slice(0, 10) === t).length, 'var(--success)'],
-  ];
-}
-function flowCard(d) {
-  const rows = d.flow ? d.flow.map((r) => [r[0], r[1], r[2]]) : flowCounts(d);   // d.flow is optional (demo): the mockup's own four counts
-  const mx = Math.max(1, ...rows.map((r) => r[1]));
-  return el('section', { class: 'card', 'data-pm-flow': '' },
-    el('h3', null, c3ic('inbox'), COPY.flow + ' ', el('span', { class: 'dim', style: 'text-transform:none;letter-spacing:0' }, COPY.flowSub)),
-    el('div', { class: 'flow' }, rows.map((r, i) => el('div', { style: '--c:' + r[2], 'data-pm-flow-row': r[0].toLowerCase() },
-      el('span', null, r[0]), el('span', { class: 'b' }, el('i', { style: 'width:' + Math.max(4, r[1] / mx * 100) + '%;animation-delay:' + (i * 90) + 'ms' })), el('b', { class: 'mono' }, String(r[1]))))),
-    el('div', { class: 'dim', style: small }, d.flow_note || COPY.flowNote));
-}
-
 /* The ring at the right of the lens header: done of total, over the items in the lens (the lists keep done items; the rows hide them). */
 function lensRing(inst) {
   const all = lists(inst)[inst.lens] || [];
@@ -914,6 +890,6 @@ function draw(inst) {
       el('ul', { class: 'list', role: 'list' }, nz.map((n) => itemRow(inst, n, 'triage')))));
   }
   /* The mockup's vWork() body: .calbody > .lh + .brief.sbb > .bcols > .bcol.l (the list) and .bcol.r (the jobs card). */
-  inst.body.replaceChildren(lh, el('div', { class: 'brief sbb' }, el('div', { class: 'bcols' }, el('div', { class: 'bcol l' }, inst.ctx.plan || null, ...main), el('div', { class: 'bcol r' }, flowCard(d), jobsCard(inst)))));
+  inst.body.replaceChildren(lh, el('div', { class: 'brief sbb' }, el('div', { class: 'bcols' }, el('div', { class: 'bcol l' }, inst.ctx.plan || null, ...main), el('div', { class: 'bcol r' }, jobsCard(inst)))));
   if (keep) { const n = inst.root.querySelector(keep.sel); if (n && n.focus) { try { n.focus({ preventScroll: true }); } catch { /* not focusable */ } } }
 }

package/workspace/test-files.json

@@ -59,7 +59,10 @@
     "plan-tree.test.js",
     "item-cli.test.js",
     "plan-routes.test.js",
-    "glossary.test.js"
+    "glossary.test.js",
+    "c3-daypart.test.js",
+    "briefing-icons.test.js",
+    "needs-overdue.test.js"
   ],
   "panels": [
     "pm-shell-test.js",
@@ -116,7 +119,9 @@
     "pm-r30-test.js",
     "pm-breakdown-test.js",
     "pm-breakdown-phone-test.js",
-    "first-paint-count.test.js"
+    "first-paint-count.test.js",
+    "pm-card-layout-test.js",
+    "pm-portfolio-inline-test.js"
   ],
   "ui": [
     "ui-test.js"
@@ -230,7 +235,12 @@
     "glossary.test.js": 1,
     "pm-breakdown-test.js": 62,
     "pm-breakdown-phone-test.js": 19,
-    "first-paint-count.test.js": 15
+    "first-paint-count.test.js": 15,
+    "c3-daypart.test.js": 1,
+    "briefing-icons.test.js": 1,
+    "needs-overdue.test.js": 1,
+    "pm-card-layout-test.js": 20,
+    "pm-portfolio-inline-test.js": 15
   },
   "_comment_seconds": "Measured wall time of each suite run alone (4-CPU sandbox, 2026-10-05). Only the ORDER uses it: the slowest suites start first, and --shard deals suites to the least-loaded shard so the shards finish together. A wrong or missing number never skips a suite; a missing one counts as 10."
 }