create-pmos 0.125.0 → 0.127.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.125.0",
+  "version": "0.127.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@ad6b0f4
 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:52:51Z"}
 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:52:51Z"}
 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:52:51Z"}
 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/guide/layout.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: layout"
 description: "The frame: one top bar, the place on screen, the detail and the agent dock; the phone tabs and lists; the keys; and the older layout."
-timestamp: 2026-10-08
+timestamp: 2026-10-11
 ---
 
 # Guide: layout
@@ -51,7 +51,7 @@ The dock holds your terminals, documents, conversations, skills and web pages. I
 
 - Press ⌘J (Ctrl-J), or the button on the rail, to open the dock. Press ⌘J again, or the fold button in the dock, to fold it to the rail.
 - The dock never opens by itself. A tab that opens while the dock is a rail waits in the dock until you open it.
-- The dock lists the sessions of the repository by initiative. A session is in the group of the initiative it is recorded on, or of its `initiative/<id>` branch. Then come **Not linked** (no initiative) and **Automatic** (anything you did not start yourself, for example a schedule, the day run, a note's summary or bullets, or a Jira push). **Automatic** is hidden until you press **Show automatic** at the foot of the list (or beside the group select in the strip). A session in front, or one held on a permission question, is always shown. An agent that has finished and reads "needs you" is hidden like the rest. Finished automatic sessions remove themselves a minute after a clean exit, and one with no output for 60 minutes is ended and removed. A failed one stays. When a session has been removed, its terminal tab closes too, also when the workspace was stopped for an update, so the tab does not come back as a row under **Open**. The setting is in `state/session-policy.json`: `finish` (true or false) and `idleMinutes` (5 or more, or 0 for off). Then **Open** lists the tabs that are not sessions, for example documents and skills. Each one shows its title, what it is (for example PRD, Document or Web page) and its branch when it is not main. **✕** on an Open row closes the tab only. A terminal keeps running.
+- The dock lists the sessions of the repository by initiative. A session is in the group of the initiative it is recorded on, or of its `initiative/<id>` branch. Then come **Not linked** (no initiative) and **Automatic** (anything you did not start yourself, for example a schedule, the day run, a note's summary or bullets, or a Jira push). **Automatic** is hidden until you press **Show automatic** at the foot of the list (or beside the group select in the strip). A session in front, or one held on a permission question, is always shown. An agent that has finished and reads "needs you" is hidden like the rest. Finished automatic sessions remove themselves a minute after a clean exit, and one with no output for 60 minutes is ended and removed. A failed one stays for a day. When a schedule starts a new run, it ends its previous run first, unless that run is still working or waits for your answer. Any session that has ended, also one you started, is removed after 7 days. Its conversation is kept when it ends. A session you started is never ended for you. When a session has been removed, its terminal tab closes too, also when the workspace was stopped for an update, so the tab does not come back as a row under **Open**. The setting is in `state/session-policy.json`: `finish` (true or false), `idleMinutes` (5 or more, or 0 for off) and `keepExitedDays` (1 to 365, or 0 to keep ended sessions). Then **Open** lists the tabs that are not sessions, for example documents and skills. Each one shows its title, what it is (for example PRD, Document or Web page) and its branch when it is not main. **✕** on an Open row closes the tab only. A terminal keeps running.
 - Each session row starts with a mark for its state: ● working, ◼ quiet, ◆ needs you, ◇ maybe blocked, ○ ended. Under the name, the row shows the state when the session is not working, the type of work when one is set, and the branch when it is not main and not the initiative's own branch. Running sessions come first and ended sessions last. Press the row to bring the session to the front.
 - Press the name of a group to fold it or open it. The number beside it counts its sessions. **Automatic** is folded while none of its sessions is running, because each run leaves an ended session. The group of the session in front always stays open, and the workspace keeps your choice for each group.
 - **⋯** and **✕** show on the row in front, on the row under the pointer and on the row with the keyboard focus. On a touch screen they always show.

package/workspace/lib/git-info.js

@@ -251,6 +251,24 @@ function removeWorktree(root, dir) {
   return { ok: true, dir: target.dir, branch: target.branch, pruned: false };
 }
 
+// { ok, current, detached } — only the HEAD half of branchInfo, with the same failure codes. The
+// workspace list and the session heartbeat need the branch name and nothing else; branchInfo also
+// lists every branch, runs `git status --porcelain` and lists the worktrees, which on a large repo
+// is most of the cost and was paid for every workspace every 15 seconds. `top` may be passed when
+// the caller already resolved the repo root, saving one more shell-out.
+function headInfo(root, top) {
+  const t = top === undefined ? repoRoot(root) : top;
+  if (!t) {
+    if (!isRepo(root)) return { ok: false, code: 'no-git', error: 'not a git repository' };
+    return { ok: false, code: 'git-error', error: 'git not available' };
+  }
+  const head = git(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (head.failed) return { ok: false, code: 'git-error', error: 'git not available' };
+  if (head.code !== 0) return { ok: false, code: 'git-error', error: head.err || 'could not read HEAD' };
+  const detached = head.out === 'HEAD';
+  return { ok: true, current: detached ? null : head.out, detached };
+}
+
 // { ok, current, branches[], detached, dirty, repoRoot, subdir, linked, worktrees[] }. A non-repo
 // or a failed git returns ok:false with a reason — NEVER a fabricated branch (a wrong branch chip
 // is worse than none; anti-drift). `subdir` is the workspace's path INSIDE the repo ('' at the
@@ -284,5 +302,5 @@ function branchInfo(root) {
   };
 }
 
-module.exports = { isRepo, repoRoot, validBranchName, branchInfo, checkout, worktrees, worktreePath,
+module.exports = { isRepo, repoRoot, validBranchName, branchInfo, headInfo, checkout, worktrees, worktreePath,
   addWorktree, worktreeSafety, removeWorktree, originUrl, isGithubRemote };

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/lib/session-origin.js

@@ -7,6 +7,10 @@
  *
  * Next step, Hand to agent, a skill draft and an alignment are NOT automatic: the PM pressed those, and often talks on.
  * Any other origin is automatic.
+ *
+ * A live session the PM started is never ended here. Once ANY session has ended, it expires after the policy's
+ * keepExitedDays (default 7): its conversation was recorded when it exited, and a list that only grows costs memory,
+ * disk, a bigger push every 2 seconds, and blocks forgetting a workspace (workspace-session-lifecycle).
  */
 'use strict';
 
@@ -24,8 +28,12 @@ function isAutomatic(origin) {
   return !(MANUAL_EXACT.includes(o) || MANUAL_PREFIX.some((p) => o.startsWith(p)));
 }
 
-const DEFAULT_POLICY = Object.freeze({ finish: true, idleMinutes: 60 });
+const DEFAULT_POLICY = Object.freeze({ finish: true, idleMinutes: 60, keepExitedDays: 7 });
 const FINISH_GRACE_MS = 60 * 1000;   // a finished job stays this long, so a PM watching it sees it end
+// A job that FAILED stays long enough for the PM to see it on the next look at the workspace, then goes. Kept for ever,
+// a schedule firing at a moved repo added one dead row per fire, each with its scrollback in memory and on disk.
+const FAILED_KEEP_MS = 24 * 3600 * 1000;
+const KEEP_DAYS_MAX = 365;
 const IDLE_MIN = 5;
 const IDLE_MAX = 7 * 24 * 60;
 
@@ -38,7 +46,14 @@ function normalizePolicy(raw) {
   else if (typeof r.idleMinutes === 'number' && Number.isFinite(r.idleMinutes)) {
     idle = Math.min(IDLE_MAX, Math.max(IDLE_MIN, Math.round(r.idleMinutes)));
   }
-  return { finish, idleMinutes: idle };
+  // keepExitedDays: how long ANY ended session (the PM's too) stays in the list. Its conversation is recorded when it
+  // exits, so removing the row loses no work. 0 or null = keep for ever.
+  let keep = DEFAULT_POLICY.keepExitedDays;
+  if (r.keepExitedDays === null || r.keepExitedDays === 0) keep = null;
+  else if (typeof r.keepExitedDays === 'number' && Number.isFinite(r.keepExitedDays)) {
+    keep = Math.min(KEEP_DAYS_MAX, Math.max(1, Math.round(r.keepExitedDays)));
+  }
+  return { finish, idleMinutes: idle, keepExitedDays: keep };
 }
 
 /** Did the session end cleanly? The note the server writes on exit reads "exited (code 0)". Anything else is kept. */
@@ -49,23 +64,33 @@ function endedCleanly(s) {
 /**
  * What the sweep should do with one session row: 'remove' (it has ended and may go), 'end' (it is idle: stop it, and
  * it is removed on a later sweep), or null (leave it).
- * Row fields read: origin, state, shown, note, lastOutputAt, autoDelete ('never' opts one job out), autoEnded.
+ * Row fields read: origin, state, shown, note, lastOutputAt, exitedAt, autoDelete ('never' opts one out), autoEnded.
+ * `shown` is only read for a live automatic session past its idle limit; the caller may pass a function for it so the
+ * transcript lookup behind it runs only then (see needsShown).
  */
 function decide(s, policy, now) {
-  if (!s || !isAutomatic(s.origin) || s.autoDelete === 'never') return null;
+  if (!s || s.autoDelete === 'never') return null;
+  const exitedAt = Date.parse(s.exitedAt || '') || 0;
+  // Every ended session, whoever started it, expires after keepExitedDays. A live session the PM started is never ended.
+  if (s.state === 'exited' && policy.keepExitedDays && exitedAt && now - exitedAt >= policy.keepExitedDays * 86400000) return 'remove';
+  if (!isAutomatic(s.origin)) return null;
   const last = Number(s.lastOutputAt) || 0;
-  if (!last) return null;   // no clock for it (restored from disk): never guess an age
-  const age = now - last;
   if (s.state === 'exited') {
+    // The exit time is the better clock for an ended job; the output clock is the fallback for a row from before it.
+    const age = now - (exitedAt || last);
+    if (!exitedAt && !last) return null;   // no clock for it: never guess an age
     if (!policy.finish && !s.autoEnded) return null;
-    if (!s.autoEnded && !endedCleanly(s)) return null;   // a failed job needs the PM's eye
+    if (!s.autoEnded && !endedCleanly(s)) return age >= FAILED_KEEP_MS ? 'remove' : null;   // a failed job: the PM's eye first
     return age >= FINISH_GRACE_MS ? 'remove' : null;
   }
+  if (!last) return null;   // no clock for it (restored from disk): never guess an age
   if (!policy.idleMinutes) return null;
+  if (now - last < policy.idleMinutes * 60 * 1000) return null;
   // A call waiting for permission is a real ask. 'needs' (the agent's turn is over) is NOT: a finished agent always reads
   // 'needs you', so exempting it would keep every finished job for ever. The idle clock still gives a late question time.
-  if (s.shown === 'blocked') return null;
-  return age >= policy.idleMinutes * 60 * 1000 ? 'end' : null;
+  const shown = typeof s.shown === 'function' ? s.shown() : s.shown;
+  if (shown === 'blocked') return null;
+  return 'end';
 }
 
-module.exports = { isAutomatic, normalizePolicy, decide, endedCleanly, DEFAULT_POLICY, FINISH_GRACE_MS, MANUAL_EXACT, MANUAL_PREFIX };
+module.exports = { isAutomatic, normalizePolicy, decide, endedCleanly, DEFAULT_POLICY, FINISH_GRACE_MS, FAILED_KEEP_MS, MANUAL_EXACT, MANUAL_PREFIX };

package/workspace/lib/transcript-read.js

@@ -66,13 +66,21 @@ function slugFor(cwd) {
  * Default descendant lister: ONE `ps` snapshot → a ppid→children map → the direct children of
  * `pid`. Injected in tests so the walk is exercised without real processes. Returns [] on any
  * failure — a resolver miss must degrade to the refusal, never throw.
+ *
+ * The snapshot is shared for PS_SNAPSHOT_MS. The walk asks for the children of every pid it visits,
+ * and the server resolves every shell pane on each 2s heartbeat, so an uncached lister ran one
+ * synchronous `ps` per visited pid per pane per push: 10 `ps` runs per push with six shell panes,
+ * each one blocking the thread that carries keystrokes. One snapshot answers all of them.
  */
-function defaultChildren(pid) {
+const PS_SNAPSHOT_MS = 1000;
+let psSnap = null;   // { at, kids: Map<ppid, pid[]> }
+function psChildrenMap(now = Date.now()) {
+  if (psSnap && now - psSnap.at < PS_SNAPSHOT_MS) return psSnap.kids;
   let out;
   try {
     out = cp.execFileSync('ps', ['-Ao', 'pid=,ppid='], { encoding: 'utf8', timeout: 2000 });
   } catch {
-    return [];
+    return null;   // not cached: tmux or ps can be transiently busy, and the next call tries again
   }
   const kids = new Map();
   for (const line of out.split('\n')) {
@@ -83,7 +91,12 @@ function defaultChildren(pid) {
     if (!kids.has(pp)) kids.set(pp, []);
     kids.get(pp).push(p);
   }
-  return kids.get(Number(pid)) || [];
+  psSnap = { at: now, kids };
+  return kids;
+}
+function defaultChildren(pid) {
+  const kids = psChildrenMap();
+  return (kids && kids.get(Number(pid))) || [];
 }
 
 /** Breadth-first descendants of `pid`, bounded to `maxDepth` levels. `listChildren(pid)->pids`. */
@@ -303,4 +316,4 @@ function readHarness(file, clean = (x) => x) {
 }
 
 module.exports = { findTranscript, readHarness, prettyTool, slugFor, resolvePid, descendants,
-  MAX_BYTES, MAX_WALK_DEPTH };
+  MAX_BYTES, MAX_WALK_DEPTH, PS_SNAPSHOT_MS, defaultChildren };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.125.0",
+  "version": "0.127.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.125.0",
+      "version": "0.127.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.127.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;
 }