create-pmos 0.145.0 → 0.147.0

package/workspace/lib/calendar-layers.js

@@ -36,6 +36,9 @@ const SUGGEST_DAYS = 7;
 const WINDOW_MS = 48 * 3600000;
 const PER_KIND = { decision: 6, action: 6, moved: 8, prepared: 8, todo: 8 };
 const LIGHT_VIEWS = ['quarter', 'year'];
+/* a report cadence that recurs more often than monthly is routine: the Calendar counts it instead of naming it (calendar-highlights) */
+const ROUTINE_CADENCE = /\b(daily|weekly|bi-?weekly|fortnightly|stand-?up)\b/i;
+const routineCadence = (c) => ROUTINE_CADENCE.test(String(c || ''));
 
 const pad = (n) => String(n).padStart(2, '0');
 const isDay = (s) => typeof s === 'string' && /^\d{4}-\d{2}-\d{2}/.test(s) && !Number.isNaN(Date.parse(s.slice(0, 10) + 'T00:00:00Z'));
@@ -130,7 +133,7 @@ function layersFrom(dated, range, today) {
       const date = r.issued && isDay(r.issued.at) ? day10(r.issued.at) : day10(r.slot);
       n++;
       put('reports', { id: `report:${r.cadence}:${day10(r.slot)}`, date, kind: 'report', layer: 'reports', title: `${r.cadence} report${r.issued ? '' : ' (not issued)'}`,
-        tone: r.issued ? 'ok' : null, ref: { type: 'report', id: `${r.cadence}/${day10(r.slot)}` } });
+        tone: r.issued ? 'ok' : null, cadence: r.cadence, routine: routineCadence(r.cadence), ref: { type: 'report', id: `${r.cadence}/${day10(r.slot)}` } });
     }
     for (const s of d.reportSchedules || []) {
       if (!s || !s.id) continue;
@@ -138,7 +141,7 @@ function layersFrom(dated, range, today) {
         if (!isDay(dt)) continue;
         n++;
         put('reports', { id: `report-sched:${s.id}:${day10(dt)}`, date: day10(dt), kind: 'report', layer: 'reports', title: `${str(s.name) || s.cadence || s.id} (scheduled)`, tone: null,
-          ref: { type: 'report', id: s.cadence || s.id } });
+          ...(s.cadence ? { cadence: s.cadence } : {}), routine: routineCadence(s.cadence) || routineCadence(s.name), ref: { type: 'report', id: s.cadence || s.id } });
       }
     }
     if (!n) why('reports', 'no report file and no report schedule gives an issue date');

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/routes-runs.js

@@ -23,7 +23,10 @@ const { appendOutbox } = require(repoScript('outbox.js'));
 const prefixes = ['/api/runs'];
 const RUN_RE = /^sess-\d+$/;
 
-function sessionsOf(sessDir) {
+// `live` (optional): the server's own session list (ctx.sessionList()), by id. The meta file on disk is not rewritten when a
+// restart finds a session's process gone, so a file can still say it runs days later. When the list is given it decides:
+// a session it calls exited, or does not hold at all, has ended. Its presented state and label ride along for the panel.
+function sessionsOf(sessDir, live) {
   let names = [];
   try { names = fs.readdirSync(sessDir).filter((n) => /^sess-\d+\.json$/.test(n)); } catch { return []; }
   const out = [];
@@ -31,9 +34,12 @@ function sessionsOf(sessDir) {
     let meta; let st;
     try { const f = path.join(sessDir, n); meta = JSON.parse(fs.readFileSync(f, 'utf8')); st = fs.statSync(f); } catch { continue; }
     if (!meta || !meta.id) continue;
-    const exited = meta.state === 'exited';
+    const row = live ? live.get(meta.id) : null;
+    const exited = meta.state === 'exited' || (live ? !row || row.state === 'exited' : false);
+    const exitedAt = Date.parse(meta.exitedAt);
     out.push({ id: meta.id, plan_item: meta.plan_item || null, name: meta.name || meta.id, origin: meta.origin || 'manual', cardId: meta.plan_item || null,
-      startedAt: meta.created || null, endedAt: exited ? st.mtimeMs : null });
+      startedAt: meta.created || null, endedAt: exited ? (Number.isFinite(exitedAt) ? exitedAt : st.mtimeMs) : null,
+      shown: row ? row.shown || null : null, label: row ? row.label || null : null });
   }
   return out;
 }
@@ -61,7 +67,9 @@ function lastAtOf(lines) {
 }
 
 function view(ctx, now = Date.now()) {
-  const sessions = sessionsOf(ctx.sessDir || path.join(ctx.runtimeDir, 'sessions'));
+  let live = null;
+  if (typeof ctx.sessionList === 'function') { try { live = new Map(ctx.sessionList().map((r) => [r.id, r])); } catch { live = null; } }
+  const sessions = sessionsOf(ctx.sessDir || path.join(ctx.runtimeDir, 'sessions'), live);
   const answers = runAnswers.readAnswers(runAnswers.answersFile(ctx.runtimeDir));
   const groups = groupSessions(sessions, now);
   const cards = {};

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.147.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.145.0",
+      "version": "0.147.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.147.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);
     };