create-pmos 0.145.0 → 0.146.0

package/package.json

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

package/payload/KIT-VERSION

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

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

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

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

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

package/payload/state/discoveries.md

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

package/workspace/guide/briefing-cards.md

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

package/workspace/guide/briefing.md

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

package/workspace/guide/data-freshness.md

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

package/workspace/lib/briefing-real.js

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

package/workspace/lib/freshness.js

@@ -26,6 +26,7 @@
 const fs = require('fs');
 const path = require('path');
 const repoWatch = require('./repo-watch.js');
+const trackerRead = require('./tracker-read.js');
 
 const H = 3600 * 1000;
 const SOURCES = Object.freeze([
@@ -153,8 +154,10 @@ function create(o) {
     out.push(row(S.jira, jiraAsOf(w.repoStateDir)));
     const mw = o.stateDir ? readJson(path.join(o.stateDir, 'my-work', 'read.json'), null) : null;
     out.push(row(S['my-work'], mw && mw.read_at ? Date.parse(mw.read_at) || 0 : 0));
+    // the read the skill stamped when it finished (a press of refresh or the schedule), else the schedule's last start
     const tr = scheduleOf('tracker-refresh');
-    out.push(row(S.tracker, tr && tr.last_run ? Date.parse(tr.last_run) || 0 : 0));
+    const trRead = o.stateDir ? trackerRead.readAtMs(o.stateDir, w.root) : 0;
+    out.push(row(S.tracker, Math.max(trRead, tr && tr.last_run ? Date.parse(tr.last_run) || 0 : 0)));
     return out;
   }
 

package/workspace/lib/pmos-verbs.js

@@ -50,6 +50,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): workspace-data-freshness added it through the same table.
   calendar: Object.freeze({ module: 'calendar-cli.js', run: null, guide: 'data-freshness.md',
     help: 'pmos calendar import|status — the calendar events an agent session read, saved for Briefing and Calendar (pmos calendar help)' }),
+  // Not a pm-os-absorb verb (run: null): tracker-read-freshness added it through the same table.
+  tracker: Object.freeze({ module: 'tracker-cli.js', run: null, guide: 'data-freshness.md',
+    help: 'pmos tracker done|status — record when the tracker-refresh skill finished a read of this repository (pmos tracker help)' }),
   launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
     help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });

package/workspace/lib/routes-briefing.js

@@ -4,6 +4,12 @@
  *   { ok, scope, lens, zoom, cards, ticker, banner, own_needs }
  *   scope: whose deck asks. brief (or none) runs the engine's briefing detectors, rep its reports detectors (console3-deck-flow-fixes).
  *          Any other scope answers no cards, so a page never shows another page's cards.
+ *   brief scope also adds the PM's own data (lib/briefing-real.js, initiative briefing-real-data): cards from today's morning brief
+ *          (worth asking, and the PM's priorities), from the assigned Jira and WBS items that are overdue, due today or blocked, and from
+ *          the Work items that are overdue or due today. Overdue cards lead, the engine's cards follow unchanged, the rest come after;
+ *          at most 5 are added. Each carries `origin` (brief, jira, wbs, work), and `url` when the record has a link.
+ *   needs: "Needs you" rows (brief scope): overdue, blocked, decision and due today assigned items, the engine's cards that carry a
+ *          move or are Critical (as { card }), and the brief's worth asking items. The PM's own Work items stay in own_needs.
  *   own_needs: the PM's own items overdue or due today, as needs rows (lib/needs-overdue.js), overdue first. Briefing scope only; the page shows them above the cards.
  *   notices: the drafts a dashboard schedule made in the last 7 days that are still in the outbox (lib/report-schedules.js noticesOf).
  *            Additive; the bell lists them after the cards, and each opens Reports > Drafts.
@@ -28,7 +34,8 @@ function lensFor(date) {
 
 function tickerOf(cards) {
   return cards.slice(0, 3).map((c) => {
-    const d = c.deadline && c.deadline.days != null ? ' (' + (c.deadline.days < 1 ? 'within a day' : Math.round(c.deadline.days) + 'd') + ')' : '';
+    // a negative deadline is past: its own text ("2 days overdue") says it
+    const d = c.deadline && c.deadline.days != null ? ' (' + (c.deadline.days < 0 && c.deadline.text ? c.deadline.text : c.deadline.days < 1 ? 'within a day' : Math.round(c.deadline.days) + 'd') + ')' : '';
     return c.tag + ': ' + c.headline + d;
   });
 }
@@ -43,6 +50,8 @@ function factsOnce(eng, root, iso) {
   return facts;
 }
 
+const realLib = () => require('./briefing-real.js');
+
 function loadEngine() {
   // the engine is this repo's; `root` only says which repo's initiatives it reads
   const { present } = require(repoScript('signals/index.js'));
@@ -50,7 +59,8 @@ function loadEngine() {
   return { present, readRepoFacts };
 }
 
-/** Pure handler: (query, { root, now, load }) -> { code, body }. `load` is injectable for tests. */
+/** Pure handler: (query, { root, now, load, real }) -> { code, body }. `load` is injectable for tests; `real` is lib/briefing-real.js
+ *  build()'s answer, merged around the engine's cards in brief scope. */
 function briefing(query, opts = {}) {
   const q = query || {};
   const root = opts.root || path.resolve(__dirname, '..', '..');
@@ -71,15 +81,20 @@ function briefing(query, opts = {}) {
     // this is usually all four empty: the briefing detectors read promised dates, forecasts, holders and the like, and no
     // initiative record carries them yet. The answer then stays empty and says so by fallback_lens being absent.
     let fallback = false;
-    if (!cards.length && !q.lens) {
+    const real = scope === 'brief' && opts.real ? opts.real : null;
+    const hasReal = !!(real && ((real.lead || []).length || (real.tail || []).length));
+    if (!cards.length && !q.lens && !hasReal) {
       for (const l of LENSES) {
         if (l === lens) continue;
         const c = eng.present(facts, { lens: l, zoom, today: iso, pages }).cards || [];
         if (c.length > cards.length) { cards = c; useLens = l; fallback = true; }
       }
     }
+    const engineCards = cards;
+    if (real) cards = realLib().merge(engineCards, real);
     const banner = cards.find((c) => c.pinned && c.tag === 'Critical') || null;
-    return { code: 200, body: { ok: true, scope, lens: useLens, zoom, cards, ticker: tickerOf(cards), banner, ...(fallback ? { fallback_lens: true } : {}) } };
+    const needs = real ? { needs: realLib().needsOf(real, engineCards) } : {};
+    return { code: 200, body: { ok: true, scope, lens: useLens, zoom, cards, ticker: tickerOf(cards), banner, ...needs, ...(fallback ? { fallback_lens: true } : {}) } };
   } catch (e) {
     return { code: 500, body: { ok: false, error: 'the signal engine failed: ' + (e && e.message ? e.message : String(e)) } };
   }
@@ -103,7 +118,12 @@ module.exports = {
     try { facts = await require('./facts-async.js').readFactsAsync(useRoot, { today: iso }); }
     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 }) });
+    // the PM's own data (briefing-real-data): today's brief, the assigned work and the Work ledger. A source that fails gives nothing.
+    let real = null;
+    if ((q.scope ? String(q.scope) : 'brief') === 'brief') {
+      try { const src = await realLib().readSources(ctx, now, iso); real = realLib().build({ ...src, today: iso }); } catch { real = null; }
+    }
+    const out = briefing(q, { root: useRoot, real, 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 && out.body.scope === 'brief') {
       try {

package/workspace/lib/routes-calendar-views.js

@@ -12,7 +12,11 @@
  *
  * EVENTS: lib/calendar-events.js readAll, the imported events joined with the calendar the morning brief remembers and today's
  * brief (the same meetings the Agenda and the Record menu show). With no reader, events = [] and events_source is 'none'. KRS: no KR metric series is stored in the repo, so the strategy lens
- * gets none and says so. */
+ * gets none and says so.
+ *
+ * JIRA (initiative briefing-real-data, R7): a gantt row whose initiative has a Jira status snapshot (<state>/tracker/jira/<id>.md, written
+ * by lib/jira-status.js) carries `jira`: { done, total, blocked, epics, as_of } (lib/briefing-real.js jiraProgress). The Briefing's pulse
+ * shows such a row even without a promised date. No snapshot, no field. */
 const path = require('path');
 const { repoScript } = require('./repo-script.js');
 const model = require(repoScript('calendar-model.js'));
@@ -22,7 +26,7 @@ const tidyLib = require('./calendar-tidy.js');
 const today = () => { const d = new Date(); const p = (n) => String(n).padStart(2, '0'); return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`; };
 
 /** The pure handler. deps: { readFacts(), readEvents?(range), readKrs?(), today, nowMs?, readDated?(range), readItems?(),
- *  readContextSources?() } so tests need no repo. A dep that is missing gives its source as empty, said in layers_note. */
+ *  readContextSources?(), readJira?() → Map<initiative, progress> } so tests need no repo. A dep that is missing gives its source as empty, said in layers_note. */
 function handle(query, deps = {}) {
   const view = (query && query.view) || 'month';
   const date = (query && query.date) || (deps.today || today());
@@ -38,6 +42,11 @@ function handle(query, deps = {}) {
     const b = model.bucketEvents(events, view, date);
     const nowDay = deps.today || today();
     const gantt = model.ganttRows(inis, view, date, { today: nowDay });
+    if (typeof deps.readJira === 'function') {
+      let jira = null;
+      try { jira = deps.readJira(); } catch { jira = null; }   // a snapshot folder that cannot be read adds nothing
+      if (jira && typeof jira.get === 'function') for (const g of gantt) { const p = jira.get(g.id); if (p) g.jira = p; }
+    }
     const strategy = view === 'quarter' || view === 'year' ? model.strategyLens(inis, krs, nowDay) : null;
     const dated = typeof deps.readDated === 'function' ? (deps.readDated(range) || {}) : {
       unavailable: { plan_items: 'no reader is wired', releases: 'no reader is wired', reports: 'no reader is wired', own: 'no reader is wired' } };
@@ -94,6 +103,19 @@ function readers(root, runtimeDir) {
       try { out.own = ownRows().map((o) => ({ id: o.id, title: o.title, due: o.due, done: !!o.done, priority: o.priority || null })); } catch { /* likewise */ }
       return out;
     },
+    /* each initiative's Jira epic progress, from the snapshots in the tracker folder (one file per initiative; the -tickets.md drafts are not snapshots) */
+    readJira() {
+      const fs = require('fs');
+      const status = require('./jira-status.js');
+      const out = new Map();
+      let names = [];
+      try { names = fs.readdirSync(require('./jira-tickets.js').jiraDir(root)).filter((n) => n.endsWith('.md') && !n.endsWith('-tickets.md')); } catch { return out; }
+      for (const n of names) {
+        const id = n.slice(0, -3);
+        try { const p = require('./briefing-real.js').jiraProgress(status.readSnapshot(root, id)); if (p) out.set(id, p); } catch { /* one unreadable snapshot is left out */ }
+      }
+      return out;
+    },
     readContextSources() {
       const src = { notes: [], planItems: [], ownItems: [] };
       try { src.planItems = planRows().map((p) => ({ id: p.id, initiative: p.initiative, title: p.title, createdAt: p.createdAt, doneAt: p.doneAt })); } catch { /* no plan ledger: no moved items */ }

package/workspace/lib/tracker-cli.js

@@ -0,0 +1,68 @@
+'use strict';
+/* tracker-cli.js — `pmos tracker …`: record that the tracker-refresh skill finished a read (initiative
+ * tracker-read-freshness).
+ *   pmos tracker done [--moved N] [--left N] [--not-found N] [--json]
+ *   pmos tracker status [--json]
+ * The repository is the one this terminal is in. The record is kept in the per-user runtime folder (lib/tracker-read.js),
+ * never in a repository. This command calls no tracker and moves no item.
+ */
+const { execFileSync } = require('child_process');
+const stateRoot = require('./state-root');
+const TR = require('./tracker-read.js');
+
+const COMMANDS = { tracker: ['done', 'status'] };
+const USAGE = [
+  'usage: pmos tracker done|status — when tracker items were last read for this repository',
+  '  pmos tracker done [--moved N] [--left N] [--not-found N]   the tracker-refresh skill runs this as its last step',
+  '  pmos tracker status                                        when the last read finished, and what it found',
+  '  every command: [--json]',
+  'This command never calls a tracker and moves no item.',
+];
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (!t.startsWith('--')) { out._.push(t); continue; }
+    const eq = t.indexOf('=');
+    const key = eq > 0 ? t.slice(2, eq) : t.slice(2);
+    if (key === 'json' || key === 'help') out[key] = true;
+    else if (eq > 0) out[key] = t.slice(eq + 1);
+    else if (argv[i + 1] !== undefined) out[key] = argv[++i];
+    else out[key] = '';
+  }
+  return out;
+}
+
+function repoRoot(cwd) {
+  try { return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || cwd; }
+  catch { return cwd; }
+}
+
+function run(argv, { say = console.log, env = process.env, stateDir, cwd = process.cwd(), now = () => new Date() } = {}) {
+  const a = parseArgs(argv.slice(1));
+  const sub = a._[0];
+  const out = (o, line) => { if (a.json) say(JSON.stringify(o)); else say(line); };
+  if (!sub || a.help || sub === 'help') { USAGE.forEach((l) => say(l)); return sub || a.help ? 0 : 2; }
+  if (!COMMANDS.tracker.includes(sub)) { say(`✗ pmos tracker ${sub} is not a command`); USAGE.forEach((l) => say(l)); return 2; }
+  const dir = stateDir || stateRoot.defaultRoot({ env });
+  const root = repoRoot(cwd);
+
+  if (sub === 'done') {
+    const counts = {};
+    for (const [flag, key] of [['moved', 'moved'], ['left', 'left'], ['not-found', 'not_found']]) {
+      if (a[flag] === undefined) continue;
+      const n = Number(a[flag]);
+      if (!Number.isInteger(n) || n < 0) { out({ ok: false, error: `--${flag} takes a whole number of 0 or more` }, `✗ --${flag} takes a whole number of 0 or more`); return 2; }
+      counts[key] = n;
+    }
+    const rec = TR.write(dir, root, counts, now());
+    out({ ok: true, ...rec }, `tracker items read at ${rec.read_at} for ${rec.root}. The freshness line shows it.`);
+    return 0;
+  }
+  const rec = TR.read(dir, root);
+  out({ ok: true, record: rec }, rec ? `tracker items last read at ${rec.read_at} (moved ${rec.moved ?? '?'}, left ${rec.left ?? '?'}, not found ${rec.not_found ?? '?'})` : 'tracker items not read yet for this repository');
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/tracker-read.js

@@ -0,0 +1,40 @@
+'use strict';
+/* tracker-read.js — when the tracker-refresh skill last finished a read of one repository (initiative
+ * tracker-read-freshness).
+ *
+ *   write(runtimeDir, root, { moved, left, not_found }, now) → the record   `pmos tracker done` runs this
+ *   read(runtimeDir, root)                                   → the record or null
+ *   readAtMs(runtimeDir, root)                               → ms, or 0
+ *
+ * The skill reads local files only and moves an item only when a file says so, so a read that changes nothing writes no
+ * ledger line. The freshness line needs to know the read happened all the same. Its last step stamps one small file per
+ * repository in the per-user runtime folder: <runtime>/tracker-read/<hash of the repository path>.json. It never goes into
+ * a repository, and the bi-weekly report does not read it.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const real = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+const fileOf = (runtimeDir, root) =>
+  path.join(runtimeDir, 'tracker-read', crypto.createHash('sha1').update(real(root)).digest('hex').slice(0, 16) + '.json');
+const count = (n) => (Number.isInteger(n) && n >= 0 ? n : null);
+
+function write(runtimeDir, root, counts = {}, now = new Date()) {
+  const rec = { root: real(root), read_at: now.toISOString(), moved: count(counts.moved), left: count(counts.left), not_found: count(counts.not_found) };
+  const f = fileOf(runtimeDir, root);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = `${f}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(rec) + '\n');
+  fs.renameSync(tmp, f);
+  return rec;
+}
+
+function read(runtimeDir, root) {
+  if (!runtimeDir || !root) return null;
+  try { return JSON.parse(fs.readFileSync(fileOf(runtimeDir, root), 'utf8')); } catch { return null; }
+}
+
+const readAtMs = (runtimeDir, root) => { const r = read(runtimeDir, root); return (r && Date.parse(r.read_at)) || 0; };
+
+module.exports = { write, read, readAtMs, fileOf };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.145.0",
+  "version": "0.146.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-model.js

@@ -95,6 +95,8 @@ export function dayPartFor(date) {
 }
 
 const num = (v) => (typeof v === 'number' && isFinite(v) ? v : null);
+/* a link a card or a need may open: https only, anything else is dropped (initiative briefing-real-data) */
+const httpsUrl = (v) => (typeof v === 'string' && /^https:\/\/\S+$/.test(v) && v.length <= 500 ? v : null);
 
 /** What the deck draws for one engine card. */
 export function cardView(card) {
@@ -134,6 +136,9 @@ export function cardView(card) {
     kpisX: Array.isArray(c.kpis) ? c.kpis.filter((k) => Array.isArray(k)).slice(0, 3).map((k) => ({ v: String(k[0]), l: String(k[1]), c: k[2] ? String(k[2]) : null })) : null,
     factsX: Array.isArray(c.factsX) ? c.factsX.filter((f) => Array.isArray(f)).slice(0, 3).map((f) => ({ icon: String(f[0]), text: String(f[1]) })) : null,
     rich: h.rich && typeof h.rich === 'object' ? h.rich : null,
+    /* where a card from the PM's own data came from (brief, jira, wbs, work) and the record's link, opened from the case file (briefing-real-data) */
+    origin: c.origin ? String(c.origin) : null,
+    url: httpsUrl(c.url), urlLabel: c.url_label ? String(c.url_label) : null,
     conf: rec ? num(rec.conf) : null,
     terms: w ? { impact: num(w.impact), urgency: num(w.urgency), irreversible: num(w.irreversible), score: num(w.score) } : null,
   };
@@ -190,6 +195,7 @@ export function caseModelOf(v, o = {}) {
     unsure: [c.unsure, c.template && c.template.gaps.length ? 'Not known yet: ' + c.template.gaps.map((g) => GAP_WORDS[g] || g).join(', ') + '.' : ''].filter(Boolean).join(' '),
     ifYouWait: dl ? (dl.days == null ? 'No deadline is known: ' + dl.text : dl.text) : '', why: c.why || '',
     outward: !sim, outboxReason: NO_ROUTE,
+    ...(c.url ? { go: { action: 'open', href: c.url, label: c.urlLabel || 'Open the record' } } : {}),
   };
 }
 
@@ -198,10 +204,15 @@ export function needCaseOf(n) {
   const reg = registered('need', n.key);
   if (reg) return reg;
   if (n.view) return caseModelOf(n.view, { sim: !!n.sim });       // a real row is one engine card: its case is the card's own
+  /* a row from the PM's own data (briefing-real-data) carries its facts, its reason and its link; every string is the row's own */
+  const facts = Array.isArray(n.facts) && n.facts.length ? n.facts.map((f) => ({ icon: f.icon || 'info', text: String(f.text || ''), source: f.source || '', tone: f.tone || '' })) : null;
+  const url = httpsUrl(n.url);
   return {
     id: 'need:' + n.key, situation: n.headline,
-    evidence: [{ icon: 'clock', text: n.dueText ? n.dueText : 'Due ' + (n.time || 'soon'), source: n.src || '' }],
+    evidence: facts || [{ icon: 'clock', text: n.dueText ? n.dueText : 'Due ' + (n.time || 'soon'), source: n.src || '' }],
     options: [], outward: true, outboxReason: NO_ROUTE,
+    ...(n.why ? { why: String(n.why) } : {}), ...(n.dueText && facts ? { ifYouWait: String(n.dueText) } : {}),
+    ...(url ? { go: { action: 'open', href: url, label: n.url_label ? String(n.url_label) : 'Open the record' } } : {}),
   };
 }
 

package/workspace/public/pm/c3-brief-needs.js

@@ -1,6 +1,9 @@
 /* pm/c3-brief-needs.js — the Briefing's "Needs you" (PRD briefing-brief R3, R4, R6).
  *   needsSection(S)   the section: own items first (overdue, most late first; then due today; then outside PMOS), then the decisions only the PM
- *                     can make (the briefing's needs in the demo, the engine cards that carry a move or are Critical in real mode: c3-brief.js needRow).
+ *                     can make (c3-brief.js needRow): the briefing's `needs`. In real mode GET /api/briefing builds them (initiative briefing-real-data):
+ *                     the assigned Jira and WBS items that are overdue, blocked, a decision or due today, the engine cards that carry a move or are
+ *                     Critical (a row with `card`, drawn from the card), and the morning brief's worth asking items. Without `needs` (an older
+ *                     server), the engine cards that carry a move or are Critical; the cards from the PM's own data (`origin`) are not decisions.
  *   itemRow(row, ctx) a row of an own item. It opens in place (c3-expand). Its actions write to the item's home record, through the pm-items routes:
  *                       Done        POST /api/pm-items/done   { id, outcome? }
  *                       Not yet     POST /api/pm-items/notyet { id, when: 'later-today' | 'tomorrow' | 'next-week' }   the item returns on that date
@@ -81,11 +84,20 @@ export function itemRow(r, ctx = {}) {
 /* The Needs you count for the Briefing tab's badge, read without the section: the decisions (the briefing's needs, or its engine cards that carry a move or are
  * Critical) plus the own items of the brief page. The section's own count (recount) takes over once it is on the page. */
 export function needsCount(b, page) {
-  const decide = b && Array.isArray(b.needs) && b.needs.length ? b.needs.filter((n) => !BX.gone[n.key]).length : ((b && b.cards) || []).filter((c) => c && (c.move || c.tag === 'Critical')).length;
+  const decide = b && Array.isArray(b.needs) && b.needs.length ? b.needs.filter((n) => !BX.gone[n.key]).length : ((b && b.cards) || []).filter(isDecision).length;
   const own = page && page.ok !== false ? (page.needs || []).filter((r) => r.kind !== 'decision').length : 0;
   return decide + own;
 }
 
+/* an engine card a PM decides on; a card from the PM's own data (origin) is a reminder, and its row comes in `needs` instead */
+const isDecision = (c) => !!c && !c.origin && !!(c.move || c.tag === 'Critical');
+/* a needs row that carries an engine card is drawn from the card, as the cards-only path draws it */
+function fromCard(n, i) {
+  if (!n || !n.card) return n;
+  const v = cardView(n.card); const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
+  return { key: n.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 };
+}
+
 export function needsSection(S) {
   const count = el('span', { class: 'bdg g' }, '0');
   const quick = el('span', { class: 'chips2 dim mono c3s2', 'data-needs-summary': '' });
@@ -133,8 +145,8 @@ export function needsSection(S) {
   const fill = (b) => {
     last = b;
     const inc = !!S.incident;
-    let needs = b && Array.isArray(b.needs) && b.needs.length ? b.needs.filter((n) => !BX.gone[n.key] && (!inc || n.hard)) : null;
-    const decide = ((b && b.cards) || []).filter((c) => c && (c.move || c.tag === 'Critical'));
+    let needs = b && Array.isArray(b.needs) && b.needs.length ? b.needs.map(fromCard).filter((n) => !BX.gone[n.key] && (!inc || n.hard)) : null;
+    const decide = ((b && b.cards) || []).filter(isDecision);
     const key = needs ? needs.map((n) => n.key + n.headline) : decide.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)); }
     const g = JSON.stringify([key, inc, !!(b && b.kept_out), S.pinNeed || '']);

package/workspace/public/pm/c3-brief-pulse.js

@@ -2,13 +2,15 @@
  * One status bar and a row per initiative (the Calendar's own gantt rows, GET /api/calendar-views quarter, c3-plan.js readQuarter; the demo's pulse rows
  * carry their own colour and reason). A row opens in place with the case component the Needs you rows use (c3-expand + c3-case): why it is where it
  * is, promised against forecast. A press on a row does NOT change the tab. "Open initiative" is an explicit link inside the opened row and is the only
- * thing here that does. Rows are references (data-ref-row): nothing in them changes a record. */
+ * thing here that does. Rows are references (data-ref-row): nothing in them changes a record.
+ * Jira (initiative briefing-real-data, R7): a gantt row with a `jira` field (its Jira epic's snapshot: done, total, blocked, as_of) shows even
+ * without a promised date, as "x of y done" with a bar; a row with a plan keeps its look and adds the Jira line to its case. */
 import { el } from './dom.js';
 import { c3ic } from './pm-work-view.js';
 import { makeXp, attachExpand } from './c3-expand.js';
 import { caseFile, hooks } from './c3-brief.js';
 import { readQuarter } from './c3-plan.js';
-import { row, signal, button, ensureComponentsCss } from './primitives.js';
+import { row, signal, button, meter, ensureComponentsCss } from './primitives.js';
 import { ensureSprite } from './icons.js';
 
 /* tone: ok is neutral, warn is the warning token, bad the destructive one (R28-12) */
@@ -17,8 +19,32 @@ const RAG = { red: ['bad', 'Off track'], amber: ['warn', 'At risk'], green: ['ok
 const SIG = { bad: 'destructive', warn: 'warning' };
 const end = (o) => (o && (o.end || o.start)) || null;
 
-/** One gantt row as the pulse draws it: { id, title, cls, word, color, why, evidence }. Pure. */
+/* a usable Jira progress: at least one ticket under the epic */
+const jiraOf = (g) => (g && g.jira && Number.isInteger(g.jira.total) && g.jira.total > 0 && Number.isInteger(g.jira.done) ? g.jira : null);
+const jiraLines = (j) => {
+  const ev = [['check', j.done + ' of ' + j.total + ' done in Jira' + (j.epics && j.epics.length ? ' (epic ' + j.epics.join(', ') + ')' : ''), 'Jira']];
+  if (j.blocked > 0) ev.push(['alert', j.blocked + ' blocked', 'Jira', 'warn']);
+  if (j.as_of) ev.push(['clock', 'Read from Jira ' + String(j.as_of).slice(0, 10), 'Jira']);
+  return ev;
+};
+
+/** One gantt row as the pulse draws it: { id, title, cls, word, color, why, evidence, progress? }. Pure. */
 export function pulseRow(g) {
+  const j = jiraOf(g);
+  if (j && !g.pulse && (!PST[g.status] || g.status === 'no plan')) {
+    /* no plan date: the row is the epic's progress (briefing-real-data R7) */
+    const all = j.done >= j.total;
+    const cls = j.blocked > 0 ? 'warn' : all ? 'ok' : '';
+    const word = j.blocked > 0 ? 'Blocked' : all ? 'Done in Jira' : 'In progress';
+    const why = j.done + ' of ' + j.total + ' done in Jira' + (j.blocked > 0 ? ', ' + j.blocked + ' blocked' : '') + '; no promised date';
+    return { id: g.id, title: g.title || g.id, cls, word, why, evidence: jiraLines(j), progress: { done: j.done, total: j.total } };
+  }
+  const r = planRow(g);
+  if (j) { r.evidence = r.evidence.concat(jiraLines(j)); r.progress = { done: j.done, total: j.total }; }
+  return r;
+}
+
+function planRow(g) {
   if (g.pulse && RAG[g.pulse.c]) {
     const [cls, word] = RAG[g.pulse.c];
     const ev = [];
@@ -53,9 +79,10 @@ export function pulse(S) {
   const draw = (rows, err) => {
     if (err) { body.replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status' }, 'The initiatives could not be read: ' + err)); return; }
     if (!rows.length) { body.replaceChildren(note('No initiative has a promised date yet, so there is nothing to compare with the forecast.')); return; }
-    const noPlan = rows.filter((g) => !g.pulse && g.status === 'no plan').length;
-    rows = rows.filter((g) => g.pulse || g.status !== 'no plan');
-    if (!rows.length) { body.replaceChildren(note('No initiative has a promised date yet, so there is nothing to compare with the forecast.'), ...(noPlan ? [el('p', { class: 'dim mono c3s2' }, noPlan + ' initiatives have no plan date.')] : [])); return; }
+    const shown = (g) => g.pulse || g.status !== 'no plan' || !!jiraOf(g);   // a row without a plan shows when its Jira epic has progress
+    const noPlan = rows.filter((g) => !shown(g)).length;
+    rows = rows.filter(shown);
+    if (!rows.length) { body.replaceChildren(note('No initiative has a promised date or a Jira epic read yet, so there is nothing to show.'), ...(noPlan ? [el('p', { class: 'dim mono c3s2' }, noPlan + ' initiatives have no plan date.')] : [])); return; }
     const pr = rows.map(pulseRow);
     const need = pr.filter((r) => r.cls === 'bad' || r.cls === 'warn').length;
     attn.textContent = need + ' need attention'; foot.hidden = false;
@@ -65,7 +92,8 @@ export function pulse(S) {
     const rowEl = (r) => {
       const xp = makeXp(caseFile(pulseCase(r)));
       let ex = null;
-      const head = row({ title: r.title, meta: [r.why], signals: [signal({ text: r.word, tone: SIG[r.cls] || 'muted' })], openLabel: r.title + ': ' + r.word, onOpen: () => ex.toggle(), openAttrs: { 'data-c3pg-prow': r.id } });
+      const bar = r.progress ? [el('span', { 'data-pulse-progress': r.progress.done + '/' + r.progress.total }, meter({ done: r.progress.done, total: r.progress.total, label: r.progress.done + ' of ' + r.progress.total + ' done' }))] : null;
+      const head = row({ title: r.title, meta: [r.why], signals: [signal({ text: r.word, tone: SIG[r.cls] || 'muted' })], trail: bar, openLabel: r.title + ': ' + r.word, onOpen: () => ex.toggle(), openAttrs: { 'data-c3pg-prow': r.id } });
       ex = attachExpand(head, xp, { key: 'pulse-' + r.id });
       return el('div', { class: 'pwrap', 'data-ref-row': '', 'data-pulse-row': r.id }, head, xp);
     };

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

@@ -171,13 +171,18 @@ export function renderCase(model, opts = {}) {
     root.append(el('ul', { class: 'chgl', role: 'list' }, ...c.evidence.map((r) => el('li', { class: r.tone }, c3ic(r.icon, 'sm'), el('span', null, r.text), r.tag ? el('span', { class: 'tag' }, r.tag) : null))));
   }
   if (optsHost) { drawOptions(); drawSlide(); root.append(optsHost, slideHost); }
+  /* a go with an https href is a link to the record outside PMOS (a Jira ticket, the brief's source): it opens in a new tab, changes nothing,
+   * and takes the place of the in-page go button */
+  const href = c.go && typeof c.go.href === 'string' && /^https:\/\//.test(c.go.href) ? c.go.href : null;
+  const goLink = href ? el('a', { class: 'chip2 lk', href, target: '_blank', rel: 'noopener noreferrer', 'data-case-link': '' }, c3ic('out', 'sm'), c.go.label) : null;
+  if (goLink) c.go = null;
   const goBtn = c.go ? el('button', { type: 'button', class: 'chip2 lk', onclick: () => { if (opts.onGo) opts.onGo(c.go); } }, c3ic('next', 'sm'), c.go.label) : null;
-  if (c.unsure || c.ifYouWait || c.why || goBtn) {
+  if (c.unsure || c.ifYouWait || c.why || goBtn || goLink) {
     root.append(el('div', { class: 'cft' },
       c.unsure ? el('span', null, c3ic('info', 'sm'), 'Unsure: ' + c.unsure) : null,
       c.ifYouWait ? el('span', null, c3ic('alert', 'sm'), 'If you wait: ' + c.ifYouWait) : null,
       c.why ? el('span', null, c3ic('eye', 'sm'), 'Why shown: ' + c.why) : null,
-      goBtn));
+      goLink || 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); if (disposeHold) { disposeHold(); disposeHold = null; } } };

package/workspace/skills/tracker-refresh.skill

@@ -18,7 +18,7 @@ This skill runs before the bi-weekly report (`report-biweekly`). The report scri
 Rules that always hold (D71):
 1. LOCAL FILES ONLY. Read files in this repository. Never call a tracker, a connector, a URL or any network tool. Never run `curl`, `wget`, `git fetch` or `git pull`. A tracker that no local file describes is "not reached".
 2. READ-ONLY on every source. Never send, reply, forward, post, comment, create, edit, transition, label, archive or delete anything in Jira, Confluence, mail, chat, calendar or any other source.
-3. THE ONLY WRITE is `pmos item move`. Never edit a repository file. Never run `pmos item add`, `set` or `withdraw`. Never write a ledger by hand. Never commit; the PM's Sync carries the ledger.
+3. THE ONLY WRITE is `pmos item move`, plus `pmos tracker done` as the last step, which writes no ledger line. Never edit a repository file. Never run `pmos item add`, `set` or `withdraw`. Never write a ledger by hand. Never commit; the PM's Sync carries the ledger.
 4. EVIDENCE FOR EVERY MOVE. Each move carries `--evidence file:<repository path>`: the local file that shows the tracker state. If you have no file to point at, do not move the item.
 5. NOTHING INVENTED. Move an item only to the state a file says. If the files disagree, use the newest one and say so. If no file says, leave the item and list it under "Not found".
 6. LIGHT ON CONTENT. Read titles, ids and statuses. Never copy a message body, an attachment, a token or a credential. Skip a file marked private, personal, confidential or HR, and count it.
@@ -43,6 +43,7 @@ Procedure:
 6. If the mapped state is the item's state, leave the item. Write nothing. List it under "Left as they are" with the file and its date.
 7. If the mapped state is different, run `pmos item move <item> <state> --evidence file:<path of the file>`. If the command is refused, read the reason and do not work around it. List the item under "Not found" with the reason.
 8. Finish with the four sections of the output contract, as short lines: one line for each item, with its id, the old and new state and the file. Under "Sources reached and not reached", give each tracker reference as reached (the file and its date) or not reached. If you moved nothing, say so in one line: a refresh that moves nothing writes no line, so the bi-weekly report can still list the tracker as not refreshed. Do not commit.
+9. Run `pmos tracker done --moved <n> --left <n> --not-found <n>` with the counts of the three sections. It writes no ledger line; it records in your runtime folder that this read finished, so the freshness line shows the time. Run it even when you moved nothing.
 
 Output contract — produce EXACTLY these sections, the same shape every run:
 - Moved

package/workspace/test-files.json

@@ -30,7 +30,9 @@
     "work-evidence.test.js",
     "brief-page.test.js",
     "work-assigned.test.js",
+    "briefing-real-data.test.js",
     "calendar-events.test.js",
+    "tracker-read.test.js",
     "item-steps.test.js",
     "status-facts-panel.test.js",
     "jev-claims.test.js",
@@ -161,7 +163,9 @@
     "work-evidence.test.js": 1,
     "brief-page.test.js": 1,
     "work-assigned.test.js": 1,
+    "briefing-real-data.test.js": 1,
     "calendar-events.test.js": 1,
+    "tracker-read.test.js": 1,
     "pm-brief-page-test.js": 30,
     "item-steps.test.js": 1,
     "status-facts-panel.test.js": 1,