create-pmos 0.249.0 → 0.251.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.249.0",
+  "version": "0.251.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@381bd87
-assembled: 2026-10-15
+kernel-source: pmos@0657606
+assembled: 2026-10-16
 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-15T09:38:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T03:26:16Z"}
 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-15T09:38:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T03:26:16Z"}
 status: stable
 ---
 

package/payload/scripts/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

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-15T09:38:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-16T03:26:16Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-15
+## 2026-10-16
 
 - Adopted OKF v0.2 (D73).

package/workspace/c3-light-load-test.js

@@ -49,7 +49,8 @@ process.on('unhandledRejection', (e) => { console.error(e); fail++; finish(); })
   const paths = first.map((g) => g.path);
 
   /* R1: the code of the other tabs is not loaded */
-  ok('R1: the desktop console loads at most 55 script files on open', scripts.size <= 55, scripts.size + ' files');
+  /* 55 before briefing-prioritization; its one pure module (priority-model.js, the ranking Needs you, the deck, Mentions and Work all share) makes 56 */
+  ok('R1: the desktop console loads at most 56 script files on open', scripts.size <= 56, scripts.size + ' files');
   for (const m of ['calendar-views.js', 'c3-initiatives.js', 'c3-reports.js', 'c3-settings.js', 'c3-phone.js', 'c3-doc-sheet.js', 'view-notes.js'])
     ok('R1: ' + m + ' is not loaded on open', !scripts.has(m));
   /* R2: the folded dock reads only the runs */

package/workspace/guide/briefing.md

@@ -1,8 +1,8 @@
 ---
 type: Guide
 title: "The Briefing: today's brief"
-description: "The Briefing page of the console (/): The brief, the headline cards, Today, Needs you, Mentions, Portfolio pulse, and what Done, Not yet and Drop do to an item."
-timestamp: 2026-10-14
+description: "The Briefing page of the console (/): The brief, the headline cards, Today, Needs you and how it is ranked, Mentions, Portfolio pulse, and what Done, Not yet and Drop do to an item."
+timestamp: 2026-10-15
 ---
 
 # The Briefing: today's brief
@@ -31,7 +31,7 @@ The cards come from two places:
   - 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.
+The cards take the same order as Needs you (see Needs you, The order): a pinned Critical card first, then the cards that cannot wait, then the rest by score. 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.
 
@@ -64,12 +64,47 @@ A Today row is a reference. It has no button that changes anything.
 
 ## Needs you
 
-Needs you lists what only you can do. Its header says how many decisions, how many items are yours, and how many are overdue. A decision row has a **decision** tag. When it cannot be undone it also says **hard to undo**. An item of yours has a **Work** chip: Work is where the item lives. The rows come in this order:
+Needs you lists what only you can do. Its header says how many decisions, how many items are yours, how many come from the agent, and how many are overdue. A decision row has a **decision** tag. When it cannot be undone it also says **hard to undo**. An item of yours has a **Work** chip: Work is where the item lives.
 
-1. Your own items that are overdue. The most late is first. The row says how late.
-2. Your own items due today.
-3. Items outside PMOS that wait for you to confirm: talk to someone, meet, call, ask.
-4. Decisions that only you can make.
+### The order
+
+Every source goes into one list, and PMOS puts the rows in one order. PMOS does not call a model to do this. The same rows always give the same order.
+
+**Do these first** shows the three rows to do first. A row can be here for one of two reasons:
+
+- It cannot wait. A signal engine card that is Critical, and a promise to someone outside PMOS that is due or overdue, always come first. Every such row shows, even when there are more than three. The header says how many cannot wait.
+- It scores highest of the rest.
+
+**Next up** shows the other rows in score order. It shows five rows. The others are in the fold "below the line".
+
+Each row has a line of reasons under its title, for example "Frees 3 agent runs · 2 days old · about 2 min". Every reason is a part of that row's score. A reason that is not true for the row does not show. The last reason is the effort. PMOS estimates the effort from the kind of row, so it always says "about". An agent draft takes about 2 minutes. An item outside PMOS or a card with a suggested move takes about 15 minutes. A title that names a review, a spec or a PRD takes an hour or more.
+
+The score uses:
+
+- How much the item matters. This is its priority, or the signal engine's number for a card. An initiative that is off track adds to it.
+- How soon it is due. An overdue item is the most urgent.
+- Whether you can undo it.
+- How many agent runs and people wait for it. An agent that waits on your drafts counts here.
+- How long it has waited. After a week the item counts 1.5 times as much, so no row waits for ever.
+- Your flag. A flagged item counts 1.5 times as much.
+- The effort. A short task ranks above a long task of the same score.
+
+Three or more rows of one kind on one initiative show as one row that opens to its members.
+
+### What is not on the list
+
+PMOS does not rank an item that you cannot act on now. A line above the list counts them: "Not on this list: 4 waiting on others · 3 later · 2 someday". The items are not deleted. Press the line to open Work. A flagged item and a Critical card stay on the list when they are waiting or set to later. An item you finished, and a mention you marked read, are gone.
+
+A line also says when items have been untouched for a week. Press it to open the Work page, where you can review them.
+
+### The rows
+
+The rows come from these sources:
+
+1. Your own items that are overdue or due today.
+2. Items outside PMOS that wait for you to confirm: talk to someone, meet, call, ask.
+3. Decisions that only you can make.
+4. Drafts and blocks from the agent.
 
 The decisions come from these records:
 
@@ -77,7 +112,9 @@ The decisions come from these records:
 - 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.
+An item that is in your own items 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.
+
+An agent row says how old its oldest draft is and how many runs it holds. When the agent states how sure it is, whether you can undo the move, or how long it takes, the ranking uses that. A fact the agent did not state reads "Not known yet" and counts as neutral.
 
 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.
 
@@ -87,9 +124,11 @@ Press a row to open it in place. A row of your own item has three actions. Each
 
 PMOS can see evidence that an outside item is done. For example, a meeting with the person is on the calendar. Then the row says "Looks done: a meeting with Ana is booked Tue 10:00. Confirm?" PMOS never marks the item done itself. The item changes only when you press **Done** or **Yes, it is done**.
 
+The headline cards, the Mentions list and the Today view of the Work page use the same order.
+
 ## Mentions
 
-Mentions lists the places where someone mentioned you today: Slack, Jira, Confluence and mail. The list comes from today's morning brief. When there is no morning brief for today, Mentions says so.
+Mentions lists the places where someone mentioned you today: Slack, Jira, Confluence and mail. The list comes from today's morning brief. A mention that needs your reply comes before one for your information. Among the replies, the one that has waited longest comes first. When there is no morning brief for today, Mentions says so.
 
 The section is quiet. It shows one line that names who waits for your reply, for example "Priya in Slack and Dara in Jira are waiting on your reply." The header says how many need a reply. Press **Show all** to open the list. A tab for each source filters the list. Each row shows the person, the text they wrote, the source and the place, the time, and **needs your reply** or **for your information**. Each row has these actions:
 

package/workspace/guide/initiative-driver.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "The Initiative Driver: drafts the agent files for you"
 description: "What the Initiative Driver does when an initiative is created or moved, what stops it, how it files proposals you keep, send back or drop, the board modes, and the pmos driver commands."
-timestamp: 2026-10-13
+timestamp: 2026-10-15
 ---
 
 # The Initiative Driver: drafts the agent files for you
@@ -84,6 +84,8 @@ The agent uses `pmos driver propose` to file a proposal and `pmos driver status`
 - `pmos driver pause <initiative|work> <id>` and `pmos driver resume <initiative|work> <id>` stop and restart the runs for one target.
 - `pmos driver mode <off|shadow|approve> [--board <id>]` sets the board mode. Without `--board` it sets every board.
 
+When the agent files a proposal, it can also state what it knows, so that the Briefing can rank the row: `--confidence 0..1` (how sure it is), `--recommended "<what it suggests you do>"`, `--reversible true|false` (whether you can undo the move) and `--effort S|M|L` (about 2 minutes, about 15 minutes, an hour or more). Each one is optional. The Briefing shows a missing one as "Not known yet" and does not guess it. The agent states a fact only when it knows it.
+
 The ledger is `driver.jsonl` in the state folder of the repository (`pmos/state`, `state` or `.pmos`). Each action adds one line. Nothing is changed or removed.
 
 ## Related

package/workspace/lib/driver-cli.js

@@ -30,7 +30,7 @@ const stateRoot = require('./state-root.js');
 const COMMANDS = { driver: ['propose', 'status', 'keep', 'return', 'drop', 'pause', 'resume', 'mode'] };
 const USAGE = [
   'usage: pmos driver propose|status|keep|return|drop|pause|resume|mode — the Initiative Driver',
-  '  pmos driver propose <initiative|work> <id> --what <what> (--file <json|md> | --data "<text>") --why "<one line>" [--source label=ref …]',
+  '  pmos driver propose <initiative|work> <id> --what <what> (--file <json|md> | --data "<text>") --why "<one line>" [--source label=ref …] [--confidence 0..1] [--recommended "<what you suggest>"] [--reversible true|false] [--effort S|M|L]',
   '      what: problem, evidence, sizing, assumption, stakeholders, move, note, doc (initiative) · next-step, follow-up, note (Work task)',
   '  pmos driver status <initiative|work> <id>',
   '  pmos driver keep <proposal>                                  PM only',
@@ -42,7 +42,7 @@ const USAGE = [
   'Every claim in a proposal carries a pointer (--source label=ref). The driver sends nothing and edits no record: Keep is the PM\'s.',
 ];
 const BOOL = new Set(['json', 'help']);
-const VALUE = new Set(['what', 'file', 'data', 'why', 'source', 'ws', 'note', 'board', 'root']);
+const VALUE = new Set(['what', 'file', 'data', 'why', 'source', 'ws', 'note', 'board', 'root', 'confidence', 'recommended', 'reversible', 'effort']);
 
 function parse(argv) {
   const pos = []; const flags = {}; const sources = [];
@@ -127,7 +127,12 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     if (d.error) return fail(d.error, 2);
     const s = sourcesFrom(sources);
     if (s.error) return fail(s.error, 2);
-    const c = D.checkProposal({ ...target(), what: flags.what, data: d.data, why: flags.why, sources: s.sources });
+    const asked = {};
+    if (flags.confidence !== undefined) { const n = Number(flags.confidence); asked.confidence = flags.confidence === '' || !Number.isFinite(n) ? NaN : n; }
+    if (flags.recommended !== undefined) asked.recommended = flags.recommended;
+    if (flags.reversible !== undefined) { if (!/^(true|false)$/i.test(flags.reversible)) return fail('--reversible is true or false', 2); asked.reversible = /^true$/i.test(flags.reversible); }
+    if (flags.effort !== undefined) asked.effort = String(flags.effort).toUpperCase();
+    const c = D.checkProposal({ ...target(), what: flags.what, data: d.data, why: flags.why, sources: s.sources, ...asked });
     if (!c.ok) return fail(c.error);
     const actor = actorLib.fromCli(who);
     const state = D.fold(D.readLines(file));

package/workspace/lib/driver-needs.js

@@ -36,6 +36,27 @@ function titlesOf(w) {
   return out;
 }
 
+/** What the Briefing's ranking needs of one target's open drafts (briefing-prioritization): how old the oldest is, how many wakes the
+ *  agent could not start while the PM held them, and the facts the agent stated when it asked. A fact nobody stated is absent. */
+function rankFacts(state, g, now) {
+  const stamps = g.list.map((p) => Date.parse(p.at)).filter(Number.isFinite);
+  const oldest = stamps.length ? Math.min(...stamps) : null;
+  const key = D.targetKey(g.target);
+  const held = state.wakes.filter((w) => w.target && D.targetKey(w.target) === key && (w.state === 'queued' || w.state === 'refused') && (oldest === null || Date.parse(w.at) >= oldest)).length
+    + state.refusals.filter((r) => r.target && D.targetKey(r.target) === key && (oldest === null || Date.parse(r.at) >= oldest)).reduce((a, r) => a + Math.max(1, (r.wakes || []).length), 0);
+  const fs = g.list.map((p) => p.facts).filter(Boolean);
+  const facts = {};
+  const conf = fs.map((f) => f.confidence).filter((v) => typeof v === 'number');
+  if (conf.length) facts.confidence = Math.min(...conf);
+  const rec = fs.map((f) => f.recommended).filter(Boolean);
+  if (rec.length) facts.recommended = rec[0];
+  if (fs.some((f) => f.reversible === false)) facts.reversible = false;
+  else if (fs.length && fs.every((f) => f.reversible === true)) facts.reversible = true;
+  const eff = fs.map((f) => f.effort).filter((v) => v === 'S' || v === 'M' || v === 'L');
+  if (eff.length) facts.effort = ['S', 'M', 'L'][Math.max(...eff.map((e) => ['S', 'M', 'L'].indexOf(e)))];
+  return { age_days: oldest === null ? null : Math.max(0, Math.floor((now - oldest) / D.DAY)), blocked_runs: held, drafts: g.list.length, facts: Object.keys(facts).length ? facts : null };
+}
+
 function rowsOf(state, { titleOf = () => null, now = Date.now(), ledgerRel = 'pmos/state/driver.jsonl' } = {}) {
   const rows = [];
   const open = new Map();
@@ -57,7 +78,7 @@ function rowsOf(state, { titleOf = () => null, now = Date.now(), ledgerRel = 'pm
     const title = titleOf(g.target) || g.target.id;
     const whats = [...new Set(g.list.map((p) => p.what))].join(', ');
     rows.push({
-      run_id: `${NAME}:drafts:${k}`, kind: 'driver-drafts', initiative_id: g.target.kind === 'initiative' ? g.target.id : null,
+      run_id: `${NAME}:drafts:${k}`, kind: 'driver-drafts', initiative_id: g.target.kind === 'initiative' ? g.target.id : null, rank: rankFacts(state, g, now),
       question: `Agent has ${plural(g.list.length, 'draft', 'drafts')} on ${title}`, doc: null,
       today: { kind: 7, source: NAME, cause: `The agent filed ${plural(g.list.length, 'draft', 'drafts')} for ${KIND_WORD[g.target.kind]}: ${whats}`, evidence: ledgerRel, act: { label: 'Review', cli: null } },
     });
@@ -75,7 +96,7 @@ function rowsOf(state, { titleOf = () => null, now = Date.now(), ledgerRel = 'pm
     const days = Math.max(1, Math.floor((now - oldest) / D.DAY));
     const title = titleOf(g.target) || g.target.id;
     rows.push({
-      run_id: `${NAME}:blocked:${k}`, kind: 'driver-blocked', initiative_id: g.target.kind === 'initiative' ? g.target.id : null,
+      run_id: `${NAME}:blocked:${k}`, kind: 'driver-blocked', initiative_id: g.target.kind === 'initiative' ? g.target.id : null, rank: rankFacts(state, g, now),
       question: `${title} is waiting on you: the drafts are ${plural(days, 'day', 'days')} old`, doc: null,
       today: { kind: 7, source: NAME, cause: 'The agent starts no new run on this until you keep, send back or drop its drafts', evidence: ledgerRel, act: { label: 'Review', cli: null } },
     });

package/workspace/lib/driver.js

@@ -59,6 +59,7 @@ const DEFAULT_MODE = 'approve';
 const WAKES = Object.freeze(['created', 'moved', 'answered', 'stuck']);
 const EVENTS = Object.freeze(['proposal', 'keep', 'return', 'drop', 'correction', 'pause', 'resume', 'mode', 'wake', 'run-start', 'run-end', 'refused', 'blocker', 'epoch']);
 const BUDGET = Object.freeze({ concurrent: 3 });
+const EFFORTS = Object.freeze(['S', 'M', 'L']);
 const DAY = 86400000;
 const PM_WAIT_MS = DAY;                 // an open proposal older than this makes the PM the blocker
 const SWEEP_EVERY_MS = 30 * 60 * 1000;  // the sweep's cadence inside the day-check window
@@ -177,7 +178,25 @@ function checkProposal(input) {
     if (data.due != null && !(typeof data.due === 'string' && DATE_RE.test(data.due))) return { ok: false, error: 'data.due is YYYY-MM-DD' };
     data = { text: data.text.trim(), ...(data.due ? { due: data.due } : {}) };
   }
-  return { ok: true, proposal: { target: t.target, what: i.what, data, why: i.why.trim(), sources } };
+  /* Optional facts the agent knows when it asks and the Briefing's ranking needs (briefing-prioritization). A value that is present must be well-formed; one that is absent stays absent. */
+  const facts = {};
+  if (i.confidence !== undefined && i.confidence !== null) {
+    if (typeof i.confidence !== 'number' || !(i.confidence >= 0 && i.confidence <= 1)) return { ok: false, error: 'confidence is a number from 0 to 1' };
+    facts.confidence = i.confidence;
+  }
+  if (i.recommended !== undefined && i.recommended !== null) {
+    if (!oneLine(i.recommended, 200)) return { ok: false, error: 'recommended is one line of 1 to 200 characters: what you suggest the PM does' };
+    facts.recommended = i.recommended.trim();
+  }
+  if (i.reversible !== undefined && i.reversible !== null) {
+    if (typeof i.reversible !== 'boolean') return { ok: false, error: 'reversible is true or false' };
+    facts.reversible = i.reversible;
+  }
+  if (i.effort !== undefined && i.effort !== null) {
+    if (!EFFORTS.includes(i.effort)) return { ok: false, error: `effort is one of ${EFFORTS.join(', ')}: S about 2 minutes, M about 15, L an hour or more` };
+    facts.effort = i.effort;
+  }
+  return { ok: true, proposal: { target: t.target, what: i.what, data, why: i.why.trim(), sources, ...(Object.keys(facts).length ? { facts } : {}) } };
 }
 
 // ── the fold ─────────────────────────────────────────────────────────────────────────────────────────
@@ -197,7 +216,7 @@ function fold(lines) {
       case 'proposal': {
         if (!PROPOSAL_RE.test(String(l.id)) || s.proposals.has(l.id) || !checkTarget(l.target).ok) break;
         s.proposals.set(l.id, { id: l.id, target: { kind: l.target.kind, ws: l.target.ws, id: l.target.id }, what: l.what, data: l.data, why: l.why,
-          sources: Array.isArray(l.sources) ? l.sources : [], run: l.run || null, by: l.by || null, at: l.at || null, state: 'open', note: null, decided_at: null, decided_by: null });
+          sources: Array.isArray(l.sources) ? l.sources : [], facts: isObj(l.facts) ? l.facts : null, run: l.run || null, by: l.by || null, at: l.at || null, state: 'open', note: null, decided_at: null, decided_by: null });
         s.order.push(l.id);
         break;
       }

package/workspace/lib/engine/signals/facts.js

@@ -92,7 +92,7 @@ function readRepoFacts(root, opts) {
   const inis = [];
   for (const id of ws.listInitiatives(base)) {
     let w;
-    try { w = ws.computeWorkflow(id, range ? { root: base, range } : { root: base }); } catch { continue; }
+    try { w = ws.computeWorkflow(id, range ? { root: base, range, skipLastActivity: true } : { root: base, skipLastActivity: true }); } catch { continue; }
     if (!w || !w.ok) continue;
     const fm = readFrontmatter(path.join(base, w.record || `planning/initiatives/${id}.md`));
     inis.push({

package/workspace/lib/engine/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

package/workspace/lib/routes-brief-page.js

@@ -110,6 +110,20 @@ function evidenceFor(item, events, now) {
   return null;
 }
 
+/** The items the PM cannot act on now, counted by why (briefing-prioritization, stage 1): waiting on someone, set to a later day, parked as Someday.
+ *  The ranking leaves them out of Needs you and the header says how many there are. Done items are not counted. */
+function heldOf(items, now) {
+  const todayIso = localDate(now);
+  const out = { waiting: 0, later: 0, someday: 0 };
+  for (const i of items || []) {
+    if (!i || i.done) continue;
+    if (i.parked) out.someday += 1;
+    else if (i.waiting_on) out.waiting += 1;
+    else if (i.list_override === 'later' || (i.defer && i.defer > todayIso)) out.later += 1;
+  }
+  return out;
+}
+
 function needsOf(items, events, cards, now, deps = {}) {
   const todayIso = localDate(now);
   const todayDate = new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()));
@@ -117,7 +131,8 @@ function needsOf(items, events, cards, now, deps = {}) {
   const late = []; const dueToday = []; const offline = [];
   for (const i of items) {
     if (!i || i.done || deferred(i, now, todayIso)) continue;
-    const base = { id: i.id, headline: i.title, due: i.due || null, priority: i.priority || null, person: i.person || null };
+    const base = { id: i.id, headline: i.title, due: i.due || null, priority: i.priority || null, person: i.person || null, flagged: !!i.flagged,
+      days_to_due: i.due && /^\d{4}-\d{2}-\d{2}$/.test(String(i.due)) ? Math.round((Date.parse(i.due + 'T00:00:00Z') - Date.parse(todayIso + 'T00:00:00Z')) / DAY) : null };
     if (i.kind === 'offline') {
       const late0 = i.due && i.due < todayIso ? daysBetween(i.due, todayIso) : 0;
       offline.push({ key: 'item:' + i.id, kind: 'offline', ...base, days_late: late0, offline: true, evidence: evidenceFor(i, events, now) });
@@ -181,7 +196,7 @@ function build(query, deps = {}) {
   let now = q.now ? new Date(q.now) : (deps.now ? new Date(deps.now) : new Date());
   if (Number.isNaN(now.getTime())) now = new Date();
   const events = deps.events || []; const items = deps.items || [];
-  const body = { ok: true, date: localDate(now), today: todayAgenda(events, items, now, deps.notes || {}), needs: needsOf(items, events, deps.cards || [], now, deps),
+  const body = { ok: true, date: localDate(now), today: todayAgenda(events, items, now, deps.notes || {}), needs: needsOf(items, events, deps.cards || [], now, deps), held: heldOf(items, now), review: typeof pmItems.reviewQueue === 'function' ? pmItems.reviewQueue(items, now).length : 0,
     mentions: mentionsOf(deps.brief || null, deps.itemLines || [], readMarks(deps.readLines), localDate(now)) };
   if (deps.decisionsError) body.decisions_error = deps.decisionsError;
   return { status: 200, body };
@@ -212,7 +227,7 @@ function firstName(cwd) {
 module.exports = {
   prefixes: ['/api/brief-page'],
   MENTION_ID,
-  build, todayAgenda, needsOf, evidenceFor, deferred, firstName, notesAdapter, mentionsOf, readMarks,
+  build, todayAgenda, needsOf, heldOf, evidenceFor, deferred, firstName, notesAdapter, mentionsOf, readMarks,
   handle: async (req, res, url, ctx) => {
     if (url.pathname !== '/api/brief-page') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }

package/workspace/lib/vendor/scripts/workflow-state.js

@@ -716,6 +716,9 @@ function computeWorkflowDerived(id, opts) {
       }
       return best;
     }
+    // A caller that never reads `last_activity` (the facts reader) says so, and the subprocess is not started: one per
+    // initiative was 9.5 of the 12 seconds a cold facts read took on this repository.
+    if (opts && opts.skipLastActivity) return null;
     const out = git(root, ['log', '-1', '--format=%ct', '--', ...paths]);
     const t = out && parseInt(out.trim(), 10);
     return Number.isFinite(t) ? t : null;

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.249.0",
+  "version": "0.251.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

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

@@ -13,6 +13,7 @@
 import { el } from './dom.js';
 import { createIdleGate, watchIdle, applyDayPart } from './c3-daypart.js';
 import { TAG_STYLE, PART_STYLE, partByKey, partFor, cardView, nextCards, swipeDir, sizeFor, caseModelOf, rawOption } from './briefing-model.js';
+import { rankCards } from './priority-model.js';
 import { BX, caseFile, toast } from './c3-brief.js';
 import { ensureC3Css, c3ic, c3ring, c3Phone } from './pm-work-view.js';
 import { listenButton } from './shell-readaloud.js';
@@ -333,7 +334,9 @@ function readLens(lens, zoom, scope) {
 async function load(S, lens) {
   if (S.data[lens] !== undefined) return;
   S.data[lens] = null;
-  S.data[lens] = await readLens(lens, S.zoom, S.ctx && S.ctx.scope);
+  const got = await readLens(lens, S.zoom, S.ctx && S.ctx.scope);
+  /* the deck takes the order the Needs you rows take (priority-model.js): the pinned Critical card, the hard lane, then by score */
+  S.data[lens] = got && got.ok && Array.isArray(got.cards) ? { ...got, cards: rankCards(got.cards) } : got;
   if (S.dead) return;   // a deck built before its host is attached still draws: it only touches its own root
   if (lens === S.lens) draw(S);   // a lens the clock has since left stays read for later, undrawn
 }

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

@@ -17,6 +17,7 @@ import { onBriefPage, loadBriefPage } from './c3-brief-data.js';
 import { button, tabs, SEL, ensureComponentsCss } from './primitives.js';
 import { ensureSprite } from './icons.js';
 import { srcName, waitingMentions } from './c3-brief-summary.js';
+import { rankMentions } from './priority-model.js';
 
 const p2 = (n) => String(n).padStart(2, '0');
 const first = (s) => String(s || '').trim().split(/\s+/)[0];
@@ -124,7 +125,7 @@ export function mentionsSection(S) {
 
   st.list = undefined;
   onBriefPage((j) => {
-    st.list = j && j.ok !== false ? (Array.isArray(j.mentions) ? j.mentions : null) : null;
+    st.list = j && j.ok !== false ? (Array.isArray(j.mentions) ? rankMentions(j.mentions) : null) : null;   // a reply that is needed first, then the one who has waited longest (priority-model.js)
     st.local.clear();
     draw();
     if (S.tagNeeds) S.tagNeeds(S.needsBox);

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

@@ -10,7 +10,12 @@
  *                       Drop        POST /api/pm-items/remove { id }   (Undo: POST /api/pm-items/undo)
  *                     An outside-PMOS item (talk to, meet, call, ask) takes an optional one-line outcome. When PMOS holds evidence ("a meeting with Ana is
  *                     booked Tue 10:00") it asks "Looks done: ... Confirm?". It never marks the item done itself: only a press on Done or Confirm does.
- * The own-item rows are built again only when their keys change, so a re-read does not close an open row. An open row is kept in BX.open. */
+ * The own-item rows are built again only when their keys change, so a re-read does not close an open row. An open row is kept in BX.open.
+ *
+ * ONE RANKING (initiative briefing-prioritization). The four sources above no longer sit in four lists. Each builds its rows into a pool; paint() asks
+ * priority-model.js to rank them together: "Do these first" holds the hard lane (a Critical card, a promise to someone outside that is due) and the
+ * best rows up to three, each with the reasons it ranks there; "Next up" holds the rest, folded after five; a line counts what the PM cannot act on now
+ * (waiting, later, someday). The ranking reads the rows and writes nothing. */
 import { el } from './dom.js';
 import { c3ic } from './pm-work-view.js';
 import { pmPost } from './http.js';
@@ -19,9 +24,10 @@ import { needRow, belowLine, BX, toast, hooks } from './c3-brief.js';
 import { onBriefing, loadBriefing } from './shell-ticker.js';
 import { cardView, TAG_STYLE } from './briefing-model.js';
 import { onBriefPage } from './c3-brief-data.js';
-import { button, ensureComponentsCss } from './primitives.js';
+import { button, SEL, ensureComponentsCss } from './primitives.js';
 import { loadDriverNeeds, needsRow as driverRow } from './c3-driver.js';
 import { needsLoc } from './c3-core-docs.js';
+import { rank, fromOwn, fromDecision, fromAgent, heldLine, FIRST_N } from './priority-model.js';
 
 const reduced = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
 const post = (path, body) => pmPost(path, body).catch(() => ({ ok: false }));
@@ -104,64 +110,128 @@ export function needsSection(S) {
   const count = el('span', { class: 'bdg g' }, '0');
   const quick = el('span', { class: 'chips2 dim mono c3s2', 'data-needs-summary': '' });
   const sumState = { dec: 0, own: 0, late: 0, quick: 0 };
-  const own = el('ul', { class: 'list', role: 'list', 'data-needs-own': '' });
+  /* the pools: each source builds its rows here; paint() ranks them together and places them */
+  const pool = { own: [], agent: [], dec: [] };
   const ownNote = el('div');
-  const agent = el('ul', { class: 'list', role: 'list', 'data-needs-agent': '' });   // the Initiative Driver's rows (c3-driver.js)
-  const list = el('ul', { class: 'list', role: 'list' });
+  const toWork = () => { if (hooks.go) hooks.go({ action: 'gowork' }); };
+  const heldBtn = button({ label: '', variant: 'ghost', size: 'sm', onClick: toWork, attrs: { hidden: '', 'data-needs-held': '', title: 'Open Work to see them' } });
+  const reviewBtn = button({ label: '', variant: 'ghost', size: 'sm', onClick: toWork, attrs: { hidden: '', 'data-needs-review': '', title: 'Open Work to review them' } });
+  const firstHead = el('div', { class: 'dim mono c3s2', hidden: '', 'data-needs-firsthead': '' });
+  const first = el('ul', { class: 'list', role: 'list', 'data-needs-first': '' });
+  const nextHead = el('div', { class: 'dim mono c3s2', hidden: '', 'data-needs-nexthead': '' }, 'Next up');
+  const list = el('ul', { class: 'list', role: 'list', 'data-needs-next': '' });
   const extra = el('div');
   const alertHost = el('div');
   const box = el('section', { class: 'card sect', 'data-c3pg': 'needs', 'aria-label': 'Needs you' },
-    el('div', { class: 'sh2' }, el('h2', null, c3ic('inbox', 'sm'), 'Needs you ', count)), alertHost, ownNote, own, agent, list, extra);
-  let sig = ''; let last = null; let ownSig = ''; let page = null;
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('inbox', 'sm'), 'Needs you ', count)), alertHost, ownNote, heldBtn, reviewBtn, firstHead, first, nextHead, list, extra);
+  let sig = ''; let last = null; let ownSig = ''; let page = null; let held = null; let kept = null; let review = 0;
   const nothing = () => el('li', { class: 'fold' }, c3ic('check', 'sm'), 'Nothing needs you right now.');
+  const setLabel = (b, t) => { const l = b.querySelector(SEL.btnLabel); if (l) l.textContent = t; };
+  const rows = (host) => [...host.querySelectorAll('.nrow[data-needs-row]')];
   /* the header line: "3 decisions · 4 of yours · 2 overdue", then how many take under 2 minutes */
   const summarise = () => {
-    const dec = list.querySelectorAll('.nrow[data-needs-row]').length + extra.querySelectorAll('.nrow[data-needs-row]').length;
-    const ownRows = [...own.querySelectorAll('.nrow[data-needs-row]')]; const late = ownRows.filter((r) => r.dataset.kind === 'overdue').length;
+    const all = rows(box);
+    const dec = all.filter((r) => r.dataset.needsSrc === 'decision').length;
+    const ownRows = all.filter((r) => r.dataset.needsSrc === 'own'); const late = ownRows.filter((r) => r.dataset.kind === 'overdue').length;
     if (!quick.isConnected) box.querySelector('.sh2').append(quick);
     quick.replaceChildren(document.createTextNode(dec + (dec === 1 ? ' decision' : ' decisions') + ' · ' + ownRows.length + ' of yours'));
     if (late) quick.append(' · ', el('span', { class: 'tag bad' }, late + ' overdue'));
-    const ag = agent.children.length;
+    const ag = all.filter((r) => r.dataset.needsSrc === 'agent').length;
     if (ag) quick.append(' · ' + ag + ' from the agent');
     if (sumState.quick) quick.append(' · ', c3ic('bolt', 'sm'), sumState.quick + ' under 2 min');
   };
   const recount = () => {
-    const n = box.querySelectorAll('.nrow[data-needs-row]').length;
+    const n = rows(box).length;
     summarise();
     count.textContent = String(n);
     if (S.setNeedsBdg) S.setNeedsBdg(n);
-    const f = list.querySelector('.fold');
-    if (!n && !f) list.replaceChildren(nothing());
-    else if (n && f && list.children.length === 1 && f.textContent.startsWith('Nothing needs')) f.remove();
     if (S.tagNeeds) S.tagNeeds(box);          // Mentions (c3-brief-mentions.js): the "mentioned you" tag on a worth-asking row
     if (S.briefRedraw) S.briefRedraw();      // The brief (c3-brief-summary.js) says what this section holds
   };
+
+  /* the reasons a row ranks where it does: a line of chips under its title, each one a term of its own score */
+  const chipLine = (x, info) => {
+    const old = x.el.querySelector(':scope > .nb > [data-rank-chips]');
+    if (old) old.remove();
+    if (!info) return;
+    const host = x.el.querySelector(':scope > .nb') || x.el;
+    host.append(el('div', { class: 'chips rk', 'data-rank-chips': '' }, ...info.chips.map((c) => el('span', { class: 'chip2', 'data-term': c.term }, c.text))));
+  };
+  /* a group of three or more rows of one kind on one initiative: one row that opens to its members */
+  const groupRow = (r, info, byKey) => {
+    const members = (info.members || []).map((k) => byKey.get(k)).filter(Boolean);
+    const body = el('ul', { class: 'list', role: 'list' }, ...members.map((m) => m.el));
+    const li = el('li', { class: 'nrow', 'data-needs-group': r.key, 'data-needs-row': r.key, 'data-needs-src': 'group' },
+      el('div', { class: 'nb' }, el('details', null, el('summary', { class: 'tt' }, r.title), body)));
+    return li;
+  };
+  const place = (host, items) => host.replaceChildren(...items);
+
+  /* rank every row together and place them: Do these first, then Next up (five shown, the rest folded) */
+  const paint = () => {
+    for (const k of Object.keys(pool)) pool[k] = pool[k].filter((x) => !(x.el.__placed && !x.el.isConnected));   // a row the PM finished is gone
+    const all = [...pool.own, ...pool.agent, ...pool.dec];
+    const byKey = new Map(all.map((x) => [x.rank.key, x]));
+    const R = rank(all.map((x) => x.rank), { held });
+    const draw = (r) => {
+      const info = R.byKey.get(r.key);
+      if (info && info.members) { const g = groupRow(r, info, byKey); g.__placed = true; return g; }
+      const x = byKey.get(r.key);
+      if (!x) return null;
+      x.el.__placed = true; x.el.dataset.needsSrc = x.src; chipLine(x, info);
+      return x.el;
+    };
+    const firstEls = R.first.map(draw).filter(Boolean);
+    let rest = R.rest.slice();
+    if (S.pinNeed) { const at = rest.findIndex((r) => r.key === S.pinNeed); if (at > 0) rest.unshift(...rest.splice(at, 1)); }
+    const shown = rest.slice(0, 5).map(draw).filter(Boolean);
+    const below = rest.slice(5).map(draw).filter(Boolean);
+    firstEls.forEach((e, i) => { e.dataset.rank = String(i + 1); });
+    shown.concat(below).forEach((e) => { delete e.dataset.rank; });
+    place(first, firstEls);
+    firstHead.hidden = !firstEls.length;
+    const hard = R.hard.length;
+    firstHead.textContent = 'Do these first' + (hard > FIRST_N ? ' · ' + hard + ' cannot wait' : '');
+    nextHead.hidden = !(shown.length || below.length);
+    place(list, shown);
+    extra.replaceChildren(...belowLine(below, (e) => e, kept));
+    const hl = heldLine(R.held);
+    heldBtn.hidden = !hl; setLabel(heldBtn, hl ? 'Not on this list: ' + hl : '');
+    reviewBtn.hidden = !(review > 0); setLabel(reviewBtn, review > 0 ? review + (review === 1 ? ' item' : ' items') + ' untouched for a week. Review them' : '');
+    if (!firstEls.length && !shown.length && !below.length) first.replaceChildren(nothing());
+    recount();
+  };
+
   /* What The brief reads of this section: the rows on the page now, with what each row's data says. null until both reads came back. */
   const meta = new Map();
   S.needsSnapshot = () => {
     if (!last || !page || page.ok === false) return null;
-    const rowsIn = (host) => [...host.querySelectorAll('.nrow[data-needs-row]')];
-    const decisions = [...rowsIn(list), ...rowsIn(extra)].map((r) => {
+    const ordered = rows(box);
+    const decisions = ordered.filter((r) => r.dataset.needsSrc === 'decision').map((r) => {
       const k = r.dataset.needsRow; const m = meta.get(k) || {}; const tt = r.querySelector('.tt');
       return { key: k, headline: tt ? tt.textContent : '', time: m.time || null, decide: !!m.decide, overdue: !!m.overdue, days_late: m.days_late || 0 };
     });
-    const own0 = rowsIn(own).map((r) => {
+    const own0 = ordered.filter((r) => r.dataset.needsSrc === 'own').map((r) => {
       const k = r.dataset.needsRow; const d = (page.needs || []).find((x) => x.key === k) || {}; const tt = r.querySelector('.tt');
       return { key: k, headline: tt ? tt.textContent : (d.headline || ''), kind: r.dataset.kind || d.kind, days_late: d.days_late || 0 };
     });
-    return { decisions, own: own0, agentN: agent.children.length };
+    return { decisions, own: own0, agentN: ordered.filter((r) => r.dataset.needsSrc === 'agent').length };
   };
-  const ctx = { changed: recount };
+  const ctx = { changed: paint };
 
   const fillOwn = (j) => {
     page = j;
     if (!j || j.ok === false) { ownNote.replaceChildren(el('p', { class: 'dim mono c3s2', role: 'status' }, 'Your own items could not be read: ' + ((j && j.error) || 'unreadable'))); return; }
     ownNote.replaceChildren();
-    const rows = (j.needs || []).filter((r) => r.kind !== 'decision');
-    const g = JSON.stringify(rows.map((r) => [r.key, r.headline, r.days_late, !!r.evidence]));
+    held = j.held && typeof j.held === 'object' ? j.held : null;
+    review = Number(j.review) > 0 ? Number(j.review) : 0;
+    const own = (j.needs || []).filter((r) => r.kind !== 'decision');
+    const g = JSON.stringify([own.map((r) => [r.key, r.headline, r.days_late, !!r.evidence, !!r.flagged, r.days_to_due]), held, review]);
     if (g === ownSig) return; ownSig = g;
-    own.replaceChildren(...rows.map((r) => itemRow(r, { ...ctx, reload: () => import('./c3-brief-data.js').then((m) => m.loadBriefPage()) })));
-    recount();
+    const have = new Map(pool.own.map((x) => [x.rank.key, x]));
+    const fresh = own.map((r) => { const old = have.get(r.key); return old && old.sig === JSON.stringify(r) ? old : { el: itemRow(r, { ...ctx, reload: () => import('./c3-brief-data.js').then((m) => m.loadBriefPage()) }), rank: fromOwn(r), src: 'own', sig: JSON.stringify(r) }; });
+    pool.own = fresh;
+    paint();
   };
 
   const fill = (b) => {
@@ -170,31 +240,30 @@ export function needsSection(S) {
     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 || '']);
     if (g === sig) return; sig = g;
+    kept = !inc && b && b.kept_out ? b.kept_out : null;
     alertHost.replaceChildren(...(inc ? [el('div', { class: 'incident', role: 'status', 'data-c3pg': 'incident' }, c3ic('alert', 'lg'), el('div', null, el('b', null, 'Card payments failing since 07:40'), el('div', { class: 'dim c3s3' }, '12% of checkouts. Sam on call. Only deadlines shown.')))] : []));
     meta.clear();
     /* a decision only the PM can make: an engine card, or an assigned item marked Decide; an assigned item past its date is overdue */
-    (needs || decide.map((c, i) => fromCard({ key: c.key || String(i), card: c }, i))).forEach((n) => {
+    const rowsIn = needs || decide.map((c, i) => fromCard({ key: c.key || String(i), card: c }, i));
+    rowsIn.forEach((n) => {
       const late = /^(\d+) days? overdue$/.exec(String(n.dueText || ''));
       meta.set(n.key, { time: n.time || null, decide: !!n.view || /^decide$/i.test(String(n.kind || '')), overdue: n.kind === 'Overdue', days_late: late ? Number(late[1]) : 0 });
     });
+    const have = new Map(pool.dec.map((x) => [x.rank.key, x]));
+    const make = (n, i) => { const old = have.get(String(n.key)); return old && old.sig === JSON.stringify([n.key, n.headline]) ? old : { el: needRow(n, i, ctx), rank: fromDecision(n), src: 'decision', sig: JSON.stringify([n.key, n.headline]) }; };
     if (needs) {
       sumState.quick = needs.filter((n) => n.quick).length;
-      list.replaceChildren(...needs.slice(0, 5).map((n, i) => needRow(n, i, ctx)));
-      extra.replaceChildren(...(inc ? [] : belowLine(needs.slice(5), (n, i) => needRow(n, i + 5, ctx), b.kept_out)));
-      recount();
-      return;
+      pool.dec = needs.map(make);
+    } else {
+      sumState.quick = 0;
+      pool.dec = decide.map(cardView).map((v, i) => {
+        const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
+        return make({ key: v.key || String(i), headline: v.headline, kind: v.tag, icon: T.icon, color: T.color, time: v.deadline && v.deadline.text ? v.deadline.text : null, src: v.tag, view: v }, i);
+      });
     }
-    const cards = decide.map(cardView);
-    sumState.quick = 0;
-    list.replaceChildren(...cards.map((v, i) => {
-      const T = TAG_STYLE[v.tag] || TAG_STYLE['Just in'];
-      return needRow({ key: v.key || String(i), headline: v.headline, kind: v.tag, icon: T.icon, color: T.color, time: v.deadline && v.deadline.text ? v.deadline.text : null, src: v.tag, view: v }, i, ctx);
-    }));
-    extra.replaceChildren();
-    recount();
+    paint();
   };
   /* the agent's rows: drafts waiting on the PM, a target the PM is blocking. A press opens the initiative (its Overview holds the strip) or Work. */
   let agentSig = '';
@@ -204,11 +273,11 @@ export function needsSection(S) {
     if (n.initiative_id) { try { const u = new URL(location.href); u.searchParams.set('init', 'ini:' + encodeURIComponent(n.ws) + ':' + encodeURIComponent(n.initiative_id) + ':overview'); history.replaceState(history.state, '', u); } catch { /* no history */ } }
     if (hooks.go) hooks.go({ action: n.initiative_id ? 'goinit' : 'gowork' });
   };
-  const fillAgent = () => loadDriverNeeds().then((rows) => {
-    const g = JSON.stringify(rows.map((r) => [r.run_id, r.question]));
+  const fillAgent = () => loadDriverNeeds().then((rs) => {
+    const g = JSON.stringify(rs.map((r) => [r.run_id, r.question, r.rank || null]));
     if (g === agentSig) return; agentSig = g;
-    agent.replaceChildren(...rows.map((r) => driverRow(r, goAgent)));
-    recount();
+    pool.agent = rs.map((r) => ({ el: driverRow(r, goAgent), rank: fromAgent(r), src: 'agent' }));
+    paint();
   }, () => {});
   S.refreshNeeds = () => { sig = ''; if (last) fill(last); };
   S.needsFill = fill;

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

@@ -0,0 +1,236 @@
+/* pm/priority-model.js — the one ranking for every list that asks for the PM's attention (initiative briefing-prioritization, PRD planning/prd/briefing-prioritization-prd.md).
+ * PURE. No DOM, no fetch, no clock (the caller passes what it needs), no model call, no write. Same rows in, same order out.
+ *
+ *   rank(rows, { held }) → { first, rest, hard, hidden, held, byKey }
+ *       rows   RankRows (below). `first` is the hard lane plus the best rows up to three; `rest` is the rest in score order;
+ *              `hidden` counts what stage 1 left out by reason; `held` is the counts the server supplied (waiting, later, someday).
+ *   rankCards(cards) → cards            the headline deck, in the same order the Needs you rows would take
+ *   rankMentions(list) → list           reply-needed first, then the one who has waited longest
+ *   fromOwn(r) · fromDecision(n) · fromAgent(r) · fromCard(c)    the adapters from the page's row shapes to a RankRow
+ *   effortOf(row) · scoreOf(row) · chipsOf(row, scored) · heldLine(counts)
+ *
+ * Stage 1 (availability): a row the PM cannot act on now is left out and counted. A Critical or flagged row is never left out for waiting,
+ * deferral or Someday; only done or read removes it.
+ * Stage 2: the hard lane (Critical; a promise to someone outside that is due or overdue) sits above every score. The rest take
+ *     priority = (0.45 impact + 0.35 urgency + 0.20 irreversibility) × (1 + blocking) × aging × flag boost ÷ effort
+ * The base is the signal engine's own (scripts/signals/score.js). The constants below are starting values; the replay
+ * (scripts/briefing-replay.js) compares them with the PM's own order before they are trusted.
+ *
+ * A RankRow: { key, title, source, kind, critical, promise, person, days_late (0 is due today, null when no date), days_to_due,
+ *   priority 'P1'..'P3', impact 0..1, urgency 0..1, irreversible, blocked_runs, people_waiting, age_days, flagged, off_track,
+ *   effort 'S'|'M'|'L', effort_hint, group, hidden }. A field the record does not hold is null, never guessed.
+ */
+
+export const W = Object.freeze({ impact: 0.45, urgency: 0.35, irreversible: 0.20 });
+export const EFFORT_DIV = Object.freeze({ S: 1.0, M: 1.4, L: 2.0 });
+export const EFFORT_WORD = Object.freeze({ S: 'about 2 min', M: 'about 15 min', L: 'an hour or more' });
+export const PRIORITY_IMPACT = Object.freeze({ P1: 1.0, P2: 0.7, P3: 0.5 });
+export const FIRST_N = 3;
+const BLOCK_STEP = 0.25; const BLOCK_CAP = 0.75; const AGING_DAYS = 7; const AGING_MAX = 0.5; const FLAG_BOOST = 1.5; const GROUP_MIN = 3;
+/* the kinds of row whose effort the table fixes (PRD, "Effort is inferred from the kind of row") */
+export const HINT_EFFORT = Object.freeze({ drafts: 'S', ask: 'S', quick: 'S', decision: 'S', reply: 'S', offline: 'M', 'card-move': 'M', 'blocked-or-overdue': 'M', plain: 'M' });
+const LONG_WORK = /\b(review|spec|prd|write-?up|proposal|strategy|roadmap)\b/i;
+const num = (v) => (typeof v === 'number' && isFinite(v) ? v : null);
+const clamp01 = (v) => Math.max(0, Math.min(1, v));
+const plural = (n, one, many) => n + ' ' + (n === 1 ? one : many);
+
+/** The engine's urgency step over the days left; overdue and due today are 1. */
+export function urgencyOf(row) {
+  if (num(row.urgency) !== null) return clamp01(row.urgency);
+  const late = num(row.days_late);
+  if (late !== null) return 1;
+  const d = num(row.days_to_due);
+  if (d === null) return 0.1;
+  return d <= 1 ? 1 : d <= 3 ? 0.8 : d <= 7 ? 0.5 : d <= 30 ? 0.3 : 0.1;
+}
+export function impactOf(row) {
+  let v = num(row.impact);
+  if (v === null) v = PRIORITY_IMPACT[row.priority] !== undefined ? PRIORITY_IMPACT[row.priority] : 0.5;
+  return clamp01(v + (row.off_track ? 0.2 : 0));
+}
+/** The effort bucket and where it came from: 'given' (the record held it), 'kind' (the table), 'title' (the L words) or 'unknown'. */
+export function effortOf(row) {
+  if (EFFORT_DIV[row.effort]) return { bucket: row.effort, from: 'given' };
+  const h = HINT_EFFORT[row.effort_hint];
+  if (h === 'S') return { bucket: 'S', from: 'kind' };
+  if (LONG_WORK.test(String(row.title || ''))) return { bucket: 'L', from: 'title' };
+  if (h) return { bucket: h, from: 'kind' };
+  return { bucket: 'M', from: 'unknown' };
+}
+export const blockingOf = (row) => Math.min(BLOCK_CAP, BLOCK_STEP * ((num(row.blocked_runs) || 0) + (num(row.people_waiting) || 0)));
+export const agingOf = (row) => 1 + AGING_MAX * Math.min(1, Math.max(0, num(row.age_days) || 0) / AGING_DAYS);
+/** A promise to someone outside, due today or overdue. The builder sets `promise`; the date test is here. */
+export const promiseDue = (row) => !!row.promise && num(row.days_late) !== null;
+export const isHard = (row) => !!row.critical || promiseDue(row);
+
+/** The terms of one row's score and the score. The chips and the card's "why" read these, so they cannot disagree with the order. */
+export function scoreOf(row) {
+  const impact = impactOf(row); const urgency = urgencyOf(row); const irreversible = row.irreversible === true ? 1 : 0.5;
+  const blocking = blockingOf(row); const aging = agingOf(row); const flag = row.flagged ? FLAG_BOOST : 1;
+  const eff = effortOf(row); const div = EFFORT_DIV[eff.bucket];
+  const base = W.impact * impact + W.urgency * urgency + W.irreversible * irreversible;
+  const score = +(base * (1 + blocking) * aging * flag / div).toFixed(4);
+  return { score, base: +base.toFixed(4), impact, urgency, irreversible, blocking, aging, flag, effort: eff.bucket, effort_from: eff.from, divisor: div };
+}
+
+/** Why a row is where it is, in plain words, each chip tied to a term of its own score. At most four. */
+export function chipsOf(row, s = scoreOf(row)) {
+  const out = [];
+  if (row.critical) out.push({ term: 'critical', text: 'Critical' });
+  if (promiseDue(row)) out.push({ term: 'promise', text: 'Promise' + (row.person ? ' to ' + row.person : '') + (row.days_late > 0 ? ', ' + plural(row.days_late, 'day', 'days') + ' late' : ', due today') });
+  else if (num(row.days_late) !== null) out.push({ term: 'urgency', text: row.days_late > 0 ? plural(row.days_late, 'day', 'days') + ' late' : 'Due today' });
+  else if (num(row.days_to_due) !== null && row.days_to_due <= 7) out.push({ term: 'urgency', text: row.days_to_due <= 0 ? 'Due today' : 'Due in ' + plural(row.days_to_due, 'day', 'days') });
+  const runs = num(row.blocked_runs) || 0; const ppl = num(row.people_waiting) || 0;
+  if (runs) out.push({ term: 'blocking', text: runs === 1 ? 'Frees 1 agent run' : 'Frees ' + runs + ' agent runs' });
+  if (ppl) out.push({ term: 'blocking', text: plural(ppl, 'person waits', 'people wait') });
+  if ((num(row.age_days) || 0) >= 2) out.push({ term: 'aging', text: plural(Math.floor(row.age_days), 'day', 'days') + ' old' });
+  if (row.irreversible === true) out.push({ term: 'irreversible', text: 'Hard to undo' });
+  if (row.flagged) out.push({ term: 'flag', text: 'Flagged' });
+  const lead = out.slice(0, 3);
+  lead.push({ term: 'effort', text: EFFORT_WORD[s.effort] });
+  return lead;
+}
+
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/* ties: more days late, then older, then title, then key; so the order never depends on input order */
+const tie = (a, b) => (num(b.row.days_late) || 0) - (num(a.row.days_late) || 0) || (num(b.row.age_days) || 0) - (num(a.row.age_days) || 0) || cmp(String(a.row.title || ''), String(b.row.title || '')) || cmp(String(a.row.key), String(b.row.key));
+const byScore = (a, b) => b.s.score - a.s.score || tie(a, b);
+
+const HIDE_WORD = { waiting: 'waiting', deferred: 'later', someday: 'someday' };
+/** Stage 1. A row is hidden when it carries a `hidden` reason, except that Critical and flagged rows stay unless done or read. */
+export function available(row) {
+  if (!row.hidden) return true;
+  if (row.hidden === 'done' || row.hidden === 'read') return false;
+  return isHard(row) || !!row.flagged;
+}
+
+/** Collapse three or more rows that share a `group` into one row. The group takes the best score and the summed blocking. */
+function collapse(items) {
+  const by = new Map();
+  for (const it of items) { const g = it.row.group; if (g) { if (!by.has(g)) by.set(g, []); by.get(g).push(it); } }
+  const out = []; const done = new Set();
+  for (const it of items) {
+    const g = it.row.group;
+    if (!g || by.get(g).length < GROUP_MIN) { out.push(it); continue; }
+    if (done.has(g)) continue;
+    done.add(g);
+    const m = by.get(g).slice().sort(byScore);
+    const head = m[0].row;
+    const runs = m.reduce((a, x) => a + (num(x.row.blocked_runs) || 0), 0); const ppl = m.reduce((a, x) => a + (num(x.row.people_waiting) || 0), 0);
+    const row = { ...head, key: 'group:' + g, title: m.length + ' ' + (head.kind ? String(head.kind).toLowerCase() + ' items' : 'items') + (head.group_label ? ' on ' + head.group_label : ''),
+      blocked_runs: runs, people_waiting: ppl, critical: m.some((x) => x.row.critical), promise: m.some((x) => promiseDue(x.row)), group_members: m.map((x) => x.row.key) };
+    out.push({ row, s: scoreOf(row), members: m });
+  }
+  return out;
+}
+
+export function rank(rows, opts = {}) {
+  const list = (Array.isArray(rows) ? rows : []).filter((r) => r && r.key != null);
+  const hidden = { waiting: 0, later: 0, someday: 0, done: 0, read: 0 };
+  const live = [];
+  for (const row of list) {
+    if (available(row)) live.push({ row, s: scoreOf(row) });
+    else if (row.hidden === 'done' || row.hidden === 'read') hidden[row.hidden] += 1;
+    else hidden[HIDE_WORD[row.hidden] || 'later'] += 1;
+  }
+  const items = collapse(live);
+  const hard = items.filter((x) => isHard(x.row)).sort(byScore);
+  const soft = items.filter((x) => !isHard(x.row)).sort(byScore);
+  const first = hard.length >= FIRST_N ? hard : [...hard, ...soft.slice(0, FIRST_N - hard.length)];
+  const rest = soft.slice(first.length - hard.length);
+  const held = { waiting: 0, later: 0, someday: 0, ...(opts.held || {}) };
+  const byKey = new Map();
+  for (const x of [...first, ...rest]) byKey.set(x.row.key, { score: x.s, chips: chipsOf(x.row, x.s), hard: isHard(x.row), members: x.members ? x.members.map((m) => m.row.key) : null });
+  return { first: first.map((x) => x.row), rest: rest.map((x) => x.row), hard: hard.map((x) => x.row), hidden, held, byKey };
+}
+
+/** "4 waiting on others · 3 later · 2 someday", or '' when nothing is held. */
+export function heldLine(c) {
+  const h = c || {};
+  const p = [];
+  if (h.waiting > 0) p.push(h.waiting + ' waiting on others');
+  if (h.later > 0) p.push(h.later + ' later');
+  if (h.someday > 0) p.push(h.someday + ' someday');
+  return p.join(' · ');
+}
+
+/* ── adapters: the page's row shapes → RankRow ─────────────────────────────────────────────────────────────── */
+const lateOf = (s) => { const m = /^(\d+) days? overdue$/.exec(String(s || '')); return m ? Number(m[1]) : /^due today$/i.test(String(s || '')) ? 0 : null; };
+
+/** An item of the PM's own Work list (GET /api/brief-page `needs`: kind overdue | due-today | offline). */
+export function fromOwn(r) {
+  const offline = !!r.offline || r.kind === 'offline';
+  /* the server sends `days_to_due` (negative when late, 0 today, null with no date); an outside item with no date has no lateness */
+  const toDue = num(r.days_to_due);
+  let late = null; let ahead = null;
+  if (r.kind === 'overdue') late = Math.max(1, Number(r.days_late) || 1);
+  else if (r.kind === 'due-today') late = 0;
+  else if (toDue !== null) { if (toDue < 0) late = -toDue; else if (toDue === 0) late = 0; else ahead = toDue; }
+  else if (Number(r.days_late) > 0) late = Number(r.days_late);
+  return {
+    key: String(r.key), title: r.headline || '', source: 'own', kind: r.kind, person: r.person || null,
+    days_late: late, days_to_due: ahead, age_days: late, priority: r.priority || null, flagged: !!r.flagged, promise: offline && !!r.person,
+    effort_hint: r.quick || r.evidence ? 'quick' : offline ? 'offline' : 'plain',   // a row that looks done only needs a confirm
+  };
+}
+
+/** A decision row of Needs you (a Jira or plan item, a brief ask, or an engine card drawn by fromCard in c3-brief-needs.js). */
+export function fromDecision(n) {
+  const v = n.view || null;
+  const late = lateOf(n.dueText);
+  const kind = String(n.kind || '');
+  const row = { key: String(n.key), title: n.headline || '', source: v ? 'engine' : n.origin || 'jira', kind, priority: /^P[1-3]$/.test(String(n.p || '')) ? n.p : null, days_late: late, age_days: late };
+  if (v) {
+    row.critical = v.tag === 'Critical';
+    const t = v.terms || {};
+    row.impact = num(t.impact); row.urgency = num(t.urgency); row.irreversible = t.irreversible === 1 ? true : t.irreversible === 0.5 ? false : null;
+    row.days_to_due = v.deadline && num(v.deadline.days) !== null && v.deadline.days >= 0 ? v.deadline.days : null;
+    row.days_late = v.deadline && num(v.deadline.days) !== null && v.deadline.days < 0 ? Math.ceil(-v.deadline.days) : null;
+    row.effort_hint = 'card-move';
+    return row;
+  }
+  row.effort_hint = /^decide$/i.test(kind) ? 'decision' : /^worth asking$/i.test(kind) ? 'ask' : /^(overdue|blocked)$/i.test(kind) ? 'blocked-or-overdue' : 'plain';
+  return row;
+}
+
+/** A row of the Initiative Driver (GET /api/needs: driver-drafts, driver-blocked, with the ledger's age and held runs). */
+export function fromAgent(r) {
+  const k = r.rank && typeof r.rank === 'object' ? r.rank : {};
+  const f = k.facts || {};
+  const eff = EFFORT_DIV[f.effort] ? f.effort : null;
+  return {
+    key: String(r.run_id), title: r.question || '', source: 'agent', kind: r.kind === 'driver-blocked' ? 'blocked' : 'drafts',
+    blocked_runs: num(k.blocked_runs) || 0, age_days: num(k.age_days), irreversible: f.reversible === false ? true : f.reversible === true ? false : null,
+    effort: eff, effort_hint: 'drafts', group: r.initiative_id ? 'agent:' + r.kind + ':' + r.initiative_id : null,
+    off_track: false,
+  };
+}
+
+/** A headline-deck card (engine or real) as a RankRow. */
+export function fromCard(c) {
+  const t = (c.why && typeof c.why === 'object') ? c.why : {};
+  const d = c.deadline && typeof c.deadline === 'object' ? c.deadline : null;
+  const days = d && num(d.days) !== null ? d.days : null;
+  return {
+    key: String(c.key || c.headline || ''), title: c.headline || '', source: c.origin || 'engine', kind: c.kind || c.tag || '',
+    critical: c.tag === 'Critical' && !c.origin, days_late: days !== null && days <= 0 && c.origin ? Math.ceil(-days) : null,
+    days_to_due: days !== null && days > 0 ? days : null, impact: num(t.impact), urgency: num(t.urgency), irreversible: t.irreversible === 1 ? true : t.irreversible === 0.5 ? false : null,
+    effort_hint: c.move ? 'card-move' : 'plain', pinned: !!c.pinned,
+  };
+}
+
+/** The deck in rank order: pinned Critical first, the hard lane, then by score. Cards the model cannot read keep their place at the end. */
+export function rankCards(cards) {
+  const list = Array.isArray(cards) ? cards : [];
+  const items = list.map((c, i) => { const row = fromCard(c); return { c, i, row, s: scoreOf(row) }; });
+  const grade = (x) => (x.row.pinned ? 0 : isHard(x.row) ? 1 : 2);
+  return items.sort((a, b) => grade(a) - grade(b) || b.s.score - a.s.score || a.i - b.i).map((x) => x.c);
+}
+
+/** Mentions: a reply that is needed comes before information; then the one who has waited longest; unread before read. */
+export function rankMentions(list) {
+  const items = (Array.isArray(list) ? list : []).map((m, i) => ({ m, i }));
+  const at = (m) => (m.at ? Date.parse(m.at) : NaN);
+  return items.sort((a, b) => (b.m.reply === true) - (a.m.reply === true) || (a.m.read === true) - (b.m.read === true)
+    || ((Number.isFinite(at(a.m)) ? at(a.m) : Infinity) - (Number.isFinite(at(b.m)) ? at(b.m) : Infinity)) || a.i - b.i).map((x) => x.m);
+}

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

@@ -7,6 +7,7 @@
  * The rule, in order: parked is Someday; waiting on someone is Waiting; a "not before" (defer) date after today is Upcoming;
  * flagged is Today; due today or earlier is Today; a later due date is Upcoming; no date is Inbox. Dates are YYYY-MM-DD strings.
  * Pure: no DOM, no fetch. */
+import { rank } from './priority-model.js';
 
 export const VIEWS = Object.freeze(['inbox', 'today', 'upcoming', 'waiting', 'someday']);
 export const REVIEW_DAYS = 7;
@@ -38,8 +39,17 @@ const byStr = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 export function sortView(view, list, today) {
   const l = list.slice();
   if (view === 'today') {
-    const rank = (i) => (i.due && day(i.due) < today ? 0 : i.flagged ? 1 : 2);
-    l.sort((a, b) => rank(a) - rank(b) || byStr(day(a.due) || '9999', day(b.due) || '9999') || byStr(String(a.time || ''), String(b.time || '')));
+    /* the one ranking (priority-model.js), the same as Needs you: an item the PM can act on today, by its lateness, priority, flag and kind.
+     * Ties keep the old order: due date, then time. */
+    const old = l.slice().sort((a, b) => byStr(day(a.due) || '9999', day(b.due) || '9999') || byStr(String(a.time || ''), String(b.time || '')));
+    const rows = old.map((i, n) => {
+      const late = i.due && day(i.due) <= today ? daysBetween(day(i.due), today) : null;
+      const offline = i.kind === 'offline';
+      return { key: String(n), title: i.title || '', source: 'work', kind: i.kind || '', person: i.person || null, days_late: late, age_days: late, priority: /^P[1-3]$/.test(String(i.priority || '')) ? i.priority : null,
+        flagged: !!i.flagged, promise: offline && !!i.person, effort_hint: offline ? 'offline' : 'plain' };
+    });
+    const r = rank(rows);
+    return [...r.first, ...r.rest].map((x) => old[Number(x.key)]);
   } else if (view === 'upcoming') l.sort((a, b) => byStr(arrives(a, today), arrives(b, today)));
   else if (view === 'inbox') l.sort((a, b) => byStr(String(b.created_at || ''), String(a.created_at || '')));
   return l;

package/workspace/server.js

@@ -5153,6 +5153,8 @@ function needsResult(w) {
     ...(n.ws ? { ws: n.ws } : {}), ...(n.batch ? { batch: n.batch } : {}), ...(n.item ? { item: n.item } : {}), ...(n.flag ? { flag: n.flag } : {}),
     // pm-os-absorb Runs 2–5 — a provider row's Today card (lib/needs-providers.js); absent on every other row.
     ...(n.today && typeof n.today === 'object' ? { today: n.today } : {}),
+    // briefing-prioritization — what the Briefing's ranking reads of an agent row (age, held runs, the agent's own facts); absent on every other row.
+    ...(n.rank && typeof n.rank === 'object' ? { rank: n.rank } : {}),
   }));
   // `all` is the RAW combined queue — what readNeeds(w) computes — carried so /api/needs can serve
   // both the strict state and the queue from one derivation instead of deriving twice per request.
@@ -5871,13 +5873,30 @@ const TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; ch
 const zlib = require('zlib');
 const GZIP_MIN_BYTES = 1024;
 const GZIP_TYPES = /^(?:text\/|application\/(?:json|javascript|manifest\+json)|image\/svg\+xml)/;
-const wantsGzip = (res) => { const q = res && res.req; return !!(q && q.headers && /\bgzip\b/i.test(String(q.headers['accept-encoding'] || ''))); };
+// Whether this client takes a gzip body: a `gzip` (or `*`) coding in Accept-Encoding whose q-value is not 0. `gzip;q=0` is a
+// refusal. PMOS_NO_COMPRESS=1 turns compression off, so a proxy or client that mishandles it can be ruled out in one restart.
+const NO_COMPRESS = process.env.PMOS_NO_COMPRESS === '1';
+function wantsGzip(res) {
+  if (NO_COMPRESS) return false;
+  const q = res && res.req;
+  const h = q && q.headers && q.headers['accept-encoding'];
+  if (!h) return false;
+  for (const part of String(h).split(',')) {
+    const [coding, ...params] = part.trim().toLowerCase().split(';');
+    if (coding !== 'gzip') continue;
+    const qv = params.map((x) => x.trim()).find((x) => x.startsWith('q='));
+    return !(qv && Number(qv.slice(2)) === 0);
+  }
+  return false;
+}
 const fileMemo = new Map();     // file -> { sig, buf, etag, gz }
 const FILE_MEMO_MAX = 400;
 function serveFile(res, file, type, noCache) {
   fs.stat(file, (serr, st) => {
     if (serr || !st.isFile()) { res.writeHead(404); res.end('not found'); return; }
-    const sig = `${st.size}:${st.mtimeMs}`;
+    // size, mtime, change time and inode: a package install stamps every file with one fixed mtime, so size and mtime alone
+    // would keep serving the old bytes after a same-size edit.
+    const sig = `${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.ino}`;
     const send = (m) => {
       const ctype = type || TYPES[path.extname(file)] || 'application/octet-stream';
       const headers = { 'Content-Type': ctype, 'ETag': m.etag };
@@ -5900,7 +5919,7 @@ function serveFile(res, file, type, noCache) {
     if (hit && hit.sig === sig) return send(hit);
     fs.readFile(file, (err, buf) => {
       if (err) { res.writeHead(404); res.end('not found'); return; }
-      const m = { sig, buf, etag: `W/"${st.size.toString(16)}-${Math.floor(st.mtimeMs).toString(16)}"`, gz: null };
+      const m = { sig, buf, etag: `"${require('crypto').createHash('sha1').update(buf).digest('hex').slice(0, 20)}"`, gz: null };
       const ctype = type || TYPES[path.extname(file)] || '';
       const finish = () => { if (fileMemo.size >= FILE_MEMO_MAX) fileMemo.clear(); fileMemo.set(file, m); send(m); };
       if (buf.length >= GZIP_MIN_BYTES && GZIP_TYPES.test(ctype)) zlib.gzip(buf, (e, gz) => { if (!e) m.gz = gz; finish(); });
@@ -6019,6 +6038,7 @@ function json(res, obj, code = 200) {
   if (body.length >= GZIP_MIN_BYTES && wantsGzip(res)) {
     // Async, so a 1 MB library answer costs the loop nothing beyond the stringify (workspace-event-loop-lag).
     return zlib.gzip(body, (e, gz) => {
+      if (res.headersSent || res.writableEnded || res.destroyed) return;   // the handler or the client got there first
       if (e) { res.writeHead(code, { 'Content-Type': 'application/json' }); res.end(body); return; }
       res.writeHead(code, { 'Content-Type': 'application/json', 'Content-Encoding': 'gzip', 'Vary': 'Accept-Encoding', 'Content-Length': gz.length });
       res.end(gz);

package/workspace/skills/initiative-drive.skill

@@ -42,6 +42,7 @@ Procedure:
 6. File each proposal like this, with one `--source` for each pointer:
    `pmos driver propose initiative <id> --what evidence --file /tmp/evidence.json --why "<one line: why the PM needs this>" --source "Jira DISC-12=https://…" --source "Meeting note=notes/2026-10-08.md"`
    Write the JSON or text file in the scratch folder of this session. If `pmos driver propose` refuses, read the reason, fix the proposal and file it once more. Do not work around a refusal.
+   State what you know, so that the Briefing can rank this for the PM: `--confidence <0 to 1>` (how sure you are), `--recommended "<what you suggest the PM does>"`, `--reversible true|false` (whether the PM can undo it) and `--effort S|M|L` (the PM's time: about 2 minutes, about 15 minutes, an hour or more). Add a flag only when you know its value. Never guess one.
 7. Finish with the output contract. Do not repeat the proposals in full.
 8. Core documents of this stage (due or stale, named in the prompt). For each one: read its sources (the record, the files it names, the Jira snapshot, the notes that name the initiative), write the document once with
    `pmos coredoc write --scope initiative:<id> --key <key> --file - <<'PMOS_DOC'` … `PMOS_DOC` (the document on standard input; every fact with its source in brackets; "not known" where no source says), then file it:

package/workspace/skills/work-unblock.skill

@@ -33,6 +33,7 @@ Procedure:
 3. File each proposal like this:
    `pmos driver propose work <id> --what follow-up --file /tmp/followup.json --why "<one line: why the PM needs this>" --source "Slack thread=https://…"`
    Write the JSON file in the scratch folder of this session. If `pmos driver propose` refuses, read the reason, fix the proposal and file it once more. Do not work around a refusal.
+   State what you know, so that the Briefing can rank this for the PM: `--confidence <0 to 1>` (how sure you are), `--recommended "<what you suggest the PM does>"`, `--reversible true|false` (whether the PM can undo it) and `--effort S|M|L` (the PM's time: about 2 minutes, about 15 minutes, an hour or more). Add a flag only when you know its value. Never guess one.
 4. If you found nothing to act on, file nothing. A run with nothing new is a correct run.
 5. Finish with the output contract.
 

package/workspace/test-files.json

@@ -89,7 +89,8 @@
     "needs-overdue.test.js",
     "briefing-scope.test.js",
     "settings-store.test.js",
-    "c3-phone-model.test.js"
+    "c3-phone-model.test.js",
+    "priority.test.js"
   ],
   "panels": [
     "pm-shell-test.js",