create-pmos 0.144.0 → 0.146.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.144.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@9f8623c
+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:54:19Z"}
+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:54:19Z"}
+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:54:19Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T02:35:41Z"}
 status: stable
 ---
 

package/workspace/c3-ib-triage-backlog-test.js

@@ -37,6 +37,7 @@ const { harness } = require('./c3-ini-harness');
   await page.fill('[data-ibt="f-more"]', 'Which trials need SSO first?');
   await page.click('[data-ibt="more-go"]');
   await until(() => store(() => window.__c3boards.asks.find((a) => a.id === 'ask-1').needMore === true));
+  await until(async () => /prompted for more detail/.test(await toast()));
   ok('T6 Ask for more records the question; the ask stays open', await store(() => { const a = window.__c3boards.asks.find((x) => x.id === 'ask-1'); return a.state === 'open' && a.moreNote === 'Which trials need SSO first?'; }) && /prompted for more detail/.test(await toast()));
 
   await page.click('[data-ibt-ask="ask-1"] .tt').catch(() => {});

package/workspace/c3-updates-test.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-updates-test.js — console3 Settings › Updates runs the app update itself, and the kit Update sends the checked version
+ * (initiative c3-app-update).
+ *
+ * The page used to say "run it from the main app" and link to /, and its kit Update posted no version, which the server
+ * refuses with "Check for updates first". Against a real server; the kit routes and /api/sessions are stood in by the
+ * page's route table, so nothing is installed and npm is never asked. Hooks only (data-c3set-*).
+ */
+const path = require('path');
+const { spawn } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-updates' });
+
+const BASE = T.BASE;
+const results = [];
+const ok = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + extra : ''}`); };
+let srv = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-updates assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+async function waitFor(page, fn, arg, ms = 8000) {
+  try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; }
+}
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the c3-updates suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-updates suite cannot run'); return finish(1); }
+
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  await T.waitForServer(BASE);
+  browser = await chromium.launch({ executablePath: exe });
+  const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
+  const page = await ctx.newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e && e.message || e)));
+
+  // The stand-ins: an installed app 0.1.0 and a kit 0.1.0 in every workspace, both behind 0.2.0.
+  const S = { app: '0.1.0', kit: '0.1.0', checkout: false, upgrade: { ok: true }, down: 0 };
+  const calls = [];
+  const body = (ws) => ({ ok: true, ws, app: { version: S.app, fromCheckout: S.checkout }, kit: { present: true, version: S.kit }, source: { kind: 'npm' } });
+  const wsOf = (route) => { try { return JSON.parse(route.request().postData() || '{}'); } catch { return {}; } };
+  await page.route((u) => u.pathname === '/api/kit/status', (route) => route.fulfill({ json: { ...body(new URL(route.request().url()).searchParams.get('ws')), busy: null } }));
+  await page.route((u) => u.pathname === '/api/kit/check', (route) => { const b = wsOf(route); calls.push(['check', b]); route.fulfill({ json: { ...body(b.ws), latest: '0.2.0', appBehind: S.app !== '0.2.0', kitBehind: S.kit !== '0.2.0' } }); });
+  await page.route((u) => u.pathname === '/api/kit/update', (route) => {
+    const b = wsOf(route); calls.push(['kit', b]);
+    if (b.version !== '0.2.0') return route.fulfill({ status: 502, json: { ok: false, error: 'Check for updates first' } });
+    route.fulfill({ json: { ...body(b.ws), kit: { present: true, version: '0.2.0' }, output: 'kit updated' } });
+  });
+  await page.route((u) => u.pathname === '/api/kit/upgrade-app', (route) => {
+    const b = wsOf(route); calls.push(['app', b]);
+    if (!S.upgrade.ok) return route.fulfill({ status: 403, json: S.upgrade });
+    S.down = 2;   // the server is away for two polls, then answers on the new version
+    route.fulfill({ json: { ok: true, ws: b.ws, from: '0.1.0', to: b.version, log: '/tmp/app-update.log' } });
+  });
+  let reloaded = false;
+  await page.route((u) => u.pathname === '/api/sessions', async (route) => {
+    if (!calls.some((c) => c[0] === 'app' && S.upgrade.ok)) return route.continue();
+    if (S.down > 0) { S.down -= 1; return route.abort('connectionrefused'); }
+    S.app = '0.2.0';
+    const r = await route.fetch(); const j = await r.json().catch(() => ({}));
+    return route.fulfill({ json: { ...j, version: S.app } });
+  });
+  page.on('framenavigated', (f) => { if (f === page.mainFrame() && calls.some((c) => c[0] === 'app')) reloaded = true; });
+  const named = (kind) => calls.filter((c) => c[0] === kind);
+
+  const open = async () => {
+    await page.goto(BASE + '/c3.html?tab=settings');
+    await waitFor(page, () => !!document.querySelector('[data-c3set-nav] [data-c3set-sec="updates"]'));
+    await page.click('[data-c3set-nav] [data-c3set-sec="updates"]');
+    return waitFor(page, () => !!document.querySelector('[data-c3set-section="updates"] [data-c3set-check]:not([disabled])'));
+  };
+
+  /* ── A: before a check, nothing is offered and npm is not asked ── */
+  ok('A1 Updates opens with Check now', await open());
+  ok('A2 no app Update and no Open the main app before a check', await page.evaluate(() => !document.querySelector('[data-c3set-app-update]') && !/Open the main app/.test(document.querySelector('[data-c3set-section="updates"]').textContent)));
+  ok('A3 nothing was asked of npm before the press', calls.length === 0, JSON.stringify(calls));
+
+  /* ── B: the kit Update sends the version the check found ── */
+  await page.click('[data-c3set-check]');
+  ok('B1 after the check, the app row offers Update to 0.2.0', await waitFor(page, () => { const b = document.querySelector('[data-c3set-app-update]'); return !!b && /Update to 0\.2\.0/.test(b.textContent); }));
+  ok('B2 the page no longer sends you to the main app', await page.evaluate(() => !/Open the main app/.test(document.querySelector('[data-c3set-section="updates"]').textContent)));
+  ok('B3 each workspace row offers a kit Update', await waitFor(page, () => !!document.querySelector('[data-c3set-kit-update]')));
+  const kitWs = await page.getAttribute('[data-c3set-kit-update]', 'data-c3set-kit-update');
+  await page.click(`[data-c3set-kit-update="${kitWs}"]`);
+  ok('B4 kit Update posts that workspace and the checked version', await waitFor(page, () => !!document.querySelector('[data-c3-toast]') && /Updated the kit/.test(document.querySelector('[data-c3-toast]').textContent)) && named('kit').length === 1 && named('kit')[0][1].ws === kitWs && named('kit')[0][1].version === '0.2.0', JSON.stringify(named('kit')));
+  ok('B5 that row no longer offers Update', await waitFor(page, (w) => !document.querySelector(`[data-c3set-kit-update="${w}"]`), kitWs));
+
+  /* ── C: the app update asks first, then runs, waits for the restart and reloads ── */
+  await page.click('[data-c3set-app-update]');
+  ok('C1 it asks first, and says PMOS stops while the new version installs', await waitFor(page, () => { const c = document.querySelector('[data-c3set-app-confirm]'); return !!c && /stops/.test(c.textContent) && !!document.querySelector('[data-c3set-app-go]'); }));
+  ok('C2 nothing runs before the answer', named('app').length === 0);
+  await page.click('[data-c3set-app-cancel]');
+  ok('C3 Cancel puts the Update button back', await waitFor(page, () => !document.querySelector('[data-c3set-app-confirm]') && !!document.querySelector('[data-c3set-app-update]')) && named('app').length === 0);
+  await page.click('[data-c3set-app-update]');
+  await page.click('[data-c3set-app-go]');
+  for (let i = 0; i < 40 && !named('app').length; i++) await new Promise((r) => setTimeout(r, 100));
+  ok('C4 the update posts the checked version', named('app').length === 1 && named('app')[0][1].version === '0.2.0', JSON.stringify(named('app')));
+  ok('C5 the row says it is updating and that the page reloads', await waitFor(page, () => { const b = document.querySelector('[data-c3set-app-busy]'); return !!b && /reloads/.test(b.textContent); }, null, 3000) || reloaded);
+  for (let i = 0; i < 200 && !reloaded; i++) await new Promise((r) => setTimeout(r, 100));
+  ok('C6 the page reloads by itself when the new version answers', reloaded);
+
+  /* ── D: a refusal is shown on the row ── */
+  S.app = '0.1.0'; S.upgrade = { ok: false, error: 'This page signed in with a token that changes when the workspace restarts' };
+  calls.length = 0; reloaded = false;
+  await open();
+  await page.click('[data-c3set-check]');
+  await waitFor(page, () => !!document.querySelector('[data-c3set-app-update]'));
+  await page.click('[data-c3set-app-update]');
+  await page.click('[data-c3set-app-go]');
+  ok('D1 a refused update says why, on the app row', await waitFor(page, () => { const r = document.querySelector('[data-c3set-row="upd.app"]'); return !!r && /token that changes/.test(r.textContent); }));
+  ok('D2 a refused update does not reload the page', !reloaded);
+
+  /* ── E: a checkout updates with git ── */
+  S.checkout = true; S.upgrade = { ok: true }; calls.length = 0;
+  await open();
+  await page.click('[data-c3set-check]');
+  ok('E1 a checkout says git pull and offers no app Update', await waitFor(page, () => /git pull/.test(document.querySelector('[data-c3set-row="upd.app"]').textContent)) && !(await page.$('[data-c3set-app-update]')));
+
+  ok('F1 the page throws no error', errors.length === 0, errors.slice(0, 3).join(' | '));
+  finish();
+})();

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/guide/settings.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Settings in console3: one home for each setting"
 description: "How to open Settings in console3, what each section holds, what the scope tags and the environment notes mean, and where the settings are kept."
-timestamp: 2026-10-11
+timestamp: 2026-10-12
 ---
 
 # Settings in console3: one home for each setting
@@ -55,6 +55,14 @@ When a section has changed settings, **Reset section** at the top of the section
 
 Some rows show a feature that PMOS does not have yet, such as choosing calendars, mapping Jira projects, pairing a phone, the device list, and export or reset of every setting. The control on these rows is off, and the row says why.
 
+## Update PMOS and the kit
+
+Open **Updates** and press **Check now**. PMOS asks the npm registry for the latest version only when you press it.
+
+- **Update to** a version on the **PMOS app** row updates the app. The row asks first: press **Restart and update**, or **Cancel**. PMOS stops, installs the new version, and starts again. Open terminals keep running. The page reloads when the new version starts. If the update is refused, or PMOS starts again on the old version, or PMOS does not come back, the row says so and names the update log.
+- When PMOS runs from a PMOS checkout, the row says to update it with `git pull`. There is no Update button.
+- **Update** on a workspace row updates the kit in that repository. It replaces the kit files in its `pmos/` folder (AGENTS.md, skills, scripts, templates, `okf/core`, the mod and KIT-VERSION). It does not change `state/`, `planning/` or `okf/product/`, and it does not commit. Review the change in the repository as a normal pull request.
+
 ## Where the settings are kept
 
 The settings that had a home before this page keep it. For example, the recording engine is kept by the notes engine, Validate consent by the validate route, and the theme and the new-session defaults in this browser.

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.144.0",
+  "version": "0.146.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.144.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.144.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/public/pm/c3-settings.js

@@ -15,7 +15,7 @@
  *   TypeSafe key      GET /api/typesafe (present or not; the key is never read)
  *   about you         GET and POST /api/proactive/settings {name, about:{role, work, duties}} (the Welcome page writes the same)
  *   running sessions  GET /api/sessions                         calendar import  POST /api/sources/refresh {source:'calendar'}
- *   versions          GET /api/kit/status · POST /api/kit/check, /api/kit/update
+ *   versions          GET /api/kit/status · POST /api/kit/check, /api/kit/update, /api/kit/upgrade-app (then GET /api/sessions until the new version)
  * Every other setting is in the settings store: GET /api/settings and POST /api/settings (lib/settings-store.js).
  * A board's own workflow is edited on the board; here are only the templates new boards start from.
  * Nothing here asks for or shows a key or a password. */
@@ -161,7 +161,7 @@ export function mountSettings(host, ctx = {}) {
   ensureCss();
   const M = {
     sec: SECTIONS.some((s) => s[0] === ctx.section) ? ctx.section : 'about', q: '', ws: ctx.ws || '', data: null, err: {},
-    engine: null, people: null, consent: null, online: null, profiles: null, typesafe: null, kits: {}, about: null, running: null,
+    engine: null, people: null, consent: null, online: null, profiles: null, typesafe: null, kits: {}, kitBusy: null, app: { phase: null, error: '' }, about: null, running: null,
     tplEdit: null, wsEdit: null, wsDrop: null, addPath: '',
   };
   const root = el('div', { class: 'brief c3set', 'data-c3set': '' });
@@ -607,6 +607,28 @@ export function mountSettings(host, ctx = {}) {
       lockedRow('look.icons', 'Card icons', 'Chosen from the built-in icon set by the card kind (D7).', 'Chosen by code rules', 'computer')], 'eye')];
   }
 
+  /* ── the app update (workspace-kit-update): the server stops, reinstalls and starts again, so the page waits for it ── */
+  const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+  async function updateApp(ws, from, to) {
+    M.app = { phase: 'busy', error: '', to }; draw();
+    const r = await pmPost('/api/kit/upgrade-app', { ws, version: to });
+    if (!r || r.ok === false) { M.app = { phase: null, error: (r && r.error) || 'The update did not start.' }; draw(); return; }
+    await waitForRestart(r.from || from, r.log || '');
+  }
+  /** Reload when the server is back on a new version; otherwise say what happened and name the log. */
+  async function waitForRestart(from, log) {
+    let sawDown = false;
+    const until = Date.now() + 5 * 60000;
+    while (Date.now() < until) {
+      await pause(2000);
+      const j = await pmGet('/api/sessions');
+      if (!j || j.ok === false || !j.version) { sawDown = true; continue; }
+      if (j.version !== from) { location.reload(); return; }
+      if (sawDown) { M.app = { phase: null, error: 'PMOS started again on ' + j.version + ', so the update did not finish. The update log is ' + log + '.' }; draw(); return; }
+    }
+    M.app = { phase: null, error: 'PMOS did not come back on this address. Type pmos in a terminal to open it. The update log is ' + log + '.' }; draw();
+  }
+
   function updatesSec() {
     const rows = (ctx.workspaces || []).map((w) => {
       const k = M.kits[w.id];
@@ -616,20 +638,31 @@ export function mountSettings(host, ctx = {}) {
           el('div', { class: 'chips' }, chip(!k ? 'Reading' : k.error ? k.error : kit && kit.present ? 'kit ' + (kit.version || 'vendored by hand') : 'no kit in this workspace', 'mono'),
             k && k.latest ? (behind ? tag(k.latest + ' available', 'warn') : tag('Up to date', 'ok')) : null),
           M.err['kit:' + w.id] ? fold('alert', M.err['kit:' + w.id], 'w') : null),
-        el('div', { class: 'acts' }, behind ? btn('Update', { variant: 'primary', onclick: async () => { const r = await pmPost('/api/kit/update', { ws: w.id }); if (r && r.ok) { M.kits[w.id] = { ...M.kits[w.id], ...r, kitBehind: false }; toast('Updated the kit in ' + (w.label || w.name || w.id)); } else M.err['kit:' + w.id] = (r && r.error) || 'Not updated.'; draw(); } }) : null));
+        el('div', { class: 'acts' }, behind ? btn('Update', { variant: 'primary', disabled: !!M.kitBusy, attrs: { 'data-c3set-kit-update': w.id }, onclick: async () => { M.kitBusy = w.id; delete M.err['kit:' + w.id]; draw(); const r = await pmPost('/api/kit/update', { ws: w.id, version: k.latest }); M.kitBusy = null; if (r && r.ok) { M.kits[w.id] = { ...M.kits[w.id], ...r, kitBehind: false }; toast('Updated the kit in ' + (w.label || w.name || w.id)); } else M.err['kit:' + w.id] = (r && r.error) || 'Not updated.'; draw(); } }) : null));
     });
     const first = (ctx.workspaces || [])[0];
     const st = first && M.kits[first.id];
     const app = st && st.app; const appBehind = st && st.appBehind;
-    const appRow = frame({ key: 'upd.app', label: 'PMOS app ' + ((app && app.version) || ''),
-      help: appBehind ? 'The app update restarts PMOS. Run it from the main app\'s Settings, Updates, which waits for the restart.' : 'Press Check now to ask the npm registry for the latest version.',
-      control: [st && st.latest ? tag(appBehind ? st.latest + ' available' : 'Up to date', appBehind ? 'acc' : 'ok') : null,
-        btn('Check now', { ic: 'undo', disabled: !first, attrs: { 'data-c3set-check': '' }, onclick: async () => {
+    // A checkout updates with git, unless PMOS_UPDATE_SOURCE names a local package (server.js /api/kit/upgrade-app).
+    const gitOnly = !!(app && app.fromCheckout && !(st.source && st.source.kind === 'local'));
+    const U = M.app; const busy = U.phase === 'busy';
+    const appHelp = !appBehind ? 'Press Check now to ask the npm registry for the latest version.'
+      : gitOnly ? 'This workspace runs from a PMOS checkout. Update it with git pull.'
+      : 'The update stops PMOS, installs ' + st.latest + ' in place of ' + ((app && app.version) || '?') + ', and starts it again. Sessions keep running in tmux. This page reloads when the new version starts.';
+    const asking = appBehind && !gitOnly && U.phase === 'confirm';
+    const appRow = frame({ key: 'upd.app', label: 'PMOS app ' + ((app && app.version) || ''), help: appHelp, err: U.error || null,
+      note: asking ? el('span', { 'data-c3set-app-confirm': '' }, fold('alert', 'PMOS stops for about a minute while ' + st.latest + ' installs. Open terminals keep running.', 'w'))
+        : busy ? el('span', { 'data-c3set-app-busy': '', role: 'status', 'aria-live': 'polite' }, fold('cloud', 'Updating PMOS to ' + U.to + '. This page reloads when the new version starts.')) : null,
+      control: asking ? [btn('Cancel', { variant: 'ghost', attrs: { 'data-c3set-app-cancel': '' }, onclick: () => { M.app = { phase: null, error: '' }; draw(); } }),
+        btn('Restart and update', { variant: 'primary', attrs: { 'data-c3set-app-go': '' }, onclick: () => updateApp(first.id, (app && app.version) || '', st.latest) })]
+      : [st && st.latest ? tag(appBehind ? st.latest + ' available' : 'Up to date', appBehind ? 'acc' : 'ok') : null,
+        btn('Check now', { ic: 'undo', disabled: !first || busy, attrs: { 'data-c3set-check': '' }, onclick: async () => {
+          M.app = { phase: null, error: '' };
           for (const w of ctx.workspaces || []) { const r = await pmPost('/api/kit/check', { ws: w.id }); M.kits[w.id] = r && r.ok ? r : { ...(M.kits[w.id] || {}), error: (r && r.error) || 'The check failed.' }; }
           const s2 = first && M.kits[first.id]; toast(s2 && s2.appBehind ? 'PMOS ' + s2.latest + ' is available' : 'Checked. PMOS is up to date'); draw();
         } }),
-        appBehind ? btn('Open the main app', { variant: 'primary', onclick: () => { location.href = '/'; } }) : null] });
-    return [sect('PMOS app', [list([appRow])], { ic: 'cloud' }), sect('Kit in each workspace', [list(rows)], { ic: 'repo', count: rows.length }), groupOf('updates', 'When', 'cloud')];
+        appBehind && !gitOnly && !busy ? btn('Update to ' + st.latest, { variant: 'primary', attrs: { 'data-c3set-app-update': '' }, onclick: () => { M.app = { phase: 'confirm', error: '' }; draw(); } }) : null] });
+    return [sect('PMOS app', [list([appRow])], { ic: 'cloud', attrs: { 'data-c3set-app': '' } }), sect('Kit in each workspace', [list(rows)], { ic: 'repo', count: rows.length }), groupOf('updates', 'When', 'cloud')];
   }
 
   const BUILD = { about: aboutSec, workspaces: workspacesSec, boards: boardsSec, connectors: connectorsSec, recording: recordingSec, time: timeSec, sharing: sharingSec, access: accessSec, sessions: sessionsSec, privacy: privacySec, appearance: appearanceSec, updates: updatesSec };

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",
@@ -133,7 +135,8 @@
     "pm-card-layout-test.js",
     "pm-portfolio-inline-test.js",
     "pm-brief-page-test.js",
-    "c3-settings-test.js"
+    "c3-settings-test.js",
+    "c3-updates-test.js"
   ],
   "ui": [
     "ui-test.js"
@@ -160,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,
@@ -263,7 +268,8 @@
     "pm-card-layout-test.js": 20,
     "pm-portfolio-inline-test.js": 15,
     "settings-store.test.js": 1,
-    "c3-settings-test.js": 25
+    "c3-settings-test.js": 25,
+    "c3-updates-test.js": 20
   },
   "_comment_seconds": "Measured wall time of each suite run alone (4-CPU sandbox, 2026-10-05). Only the ORDER uses it: the slowest suites start first, and --shard deals suites to the least-loaded shard so the shards finish together. A wrong or missing number never skips a suite; a missing one counts as 10."
 }