create-pmos 0.71.1 → 0.72.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.71.1",
+  "version": "0.72.1",
   "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@5a5029e
+kernel-source: pmos@cf1223e
 assembled: 2026-10-07
 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-07T04:40:31Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
 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-07T04:40:31Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-07T04:40:31Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
 status: stable
 ---
 

package/workspace/first-paint-audit.js

@@ -20,11 +20,13 @@
 // The budgets start at specimen A's counts. reports: 14 → 15 in Run 6 for Present, the one control the PM asked to keep
 // with the slides (2026-10-06). Every place +1 for Docs in the top bar (the PM, 2026-10-06, docs-three-way-sync): the
 // budget is for the whole screen and the bar is on every screen. The calibration stays specimen A's own count: the
-// specimen did not change. Every place +1 again for People in the top bar (the PM, 2026-10-06, people-directory).
+// specimen did not change. Every place +1 again for People in the top bar (the PM, 2026-10-06, people-directory), and
+// +1 again for My work beside Agenda (the PM approved that mockup and said build it, 2026-10-07, my-work).
 const SPECIMEN_A = Object.freeze({ today: 17, initiatives: 24, board: 33, reports: 14 });
 const BAR_DOCS = 1;
 const BAR_PEOPLE = 1;
-const BAR = BAR_DOCS + BAR_PEOPLE;
+const BAR_MY_WORK = 1;
+const BAR = BAR_DOCS + BAR_PEOPLE + BAR_MY_WORK;
 // Agenda opens on the month (the PM's Agenda mockup v5, 2026-10-06): the month adds its own controls to Today's budget,
 // at most six week rows of a week button and seven days, the two month arrows and the five lenses.
 const AGENDA_MONTH = 6 * 8 + 2 + 5;

package/workspace/guide/index.md

@@ -22,6 +22,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 | You want | Go to |
 |---|---|
 | What is waiting for you now | Agenda |
+| Every Jira ticket and WBS item assigned to you, ranked, to brief an agent | My work, or press `g w` |
 | The initiatives of a repository, or of every repository | Initiatives. Choose **All repositories** in Repository ▾ for every repository. |
 | The sessions of a repository, by initiative | The agent dock. ⌘K → **Branches and sessions** lists the branches. |
 | The items of an initiative | Board, or Breakdown in the initiative detail |
@@ -38,6 +39,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 
 - [Start the workspace without a terminal](launcher.md): the PMOS app, the login item and `pmos launcher`.
 - [Jira tickets](jira.md): Jira tickets drafted from the PRD, pushed when you select them, and their status.
+- [My work](my-work.md): the work assigned to you, its order, the brief to an agent, and `pmos my-work`.
 - [People](people.md): the people you work with in a repository, how they get there, and `pmos people`.
 - [Docs](docs.md): whether each linked document is the same as, ahead of or behind its Google Docs and Confluence copy.
 - [Layout](layout.md): the frame, the keys and the rule for where a list or a detail opens.

package/workspace/guide/my-work.md

@@ -0,0 +1,64 @@
+---
+type: Guide
+title: "My work: every Jira ticket and WBS item assigned to you, ranked, briefed to an agent, approved in Agenda"
+timestamp: 2026-10-07
+---
+
+# My work
+
+Open My work from the top bar, from ⌘K (**My work**), or press `g w`.
+
+My work lists every Jira ticket and every breakdown (WBS) item assigned to you, in all your registered repositories. It ranks them, shows what each one asks, and lets you give an agent an instruction for it. The agent's draft then waits for you in Agenda.
+
+## Where the items come from
+
+- **Jira tickets.** The workspace does not read Jira. The **my-work-read** skill reads it in an agent session, with your own Atlassian connection. It reads the open issues assigned to you, with their comments and links, and writes a context card for each: who asked, what they ask, a short summary of the thread, the questions still open, and a suggested instruction for an agent. It does not copy the comments. Press **Read again** in My work to run it.
+- **WBS items.** The plan items whose owner is you, in every registered repository. They come from the same data as the Board's Mine filter. My work changes no plan item.
+
+The read is kept in your own runtime folder on this machine. It never goes into a repository.
+
+## The order
+
+Each item gets a WSJF score: the cost of waiting divided by the size.
+
+| Part | How it is counted |
+|---|---|
+| Value | Jira priority: Highest 10, High 8, Medium 5, Low 2. No priority counts as Medium. Add 3 when the item belongs to an initiative, else 1. |
+| Urgency | No due date 1. Overdue 10. Due in 2 days or less 8. Due in 7 days or less 5. Later 3. |
+| Unblocks | 3 for each item it blocks, at most 9. |
+| Size | XS 1, S 2, M 3, L 5, XL 8. No estimate counts as M. |
+
+The score is (value + urgency + unblocks) / size. P1 is 12 or more, P2 is 7 or more, P3 is 3 or more, and P4 is the rest. Open **Details** on an item to see each part.
+
+## Brief an agent
+
+Being assigned a ticket does not mean an agent must resolve it. Every new item starts in **To brief**.
+
+1. Open the item. Read **What the agent found**.
+2. Change the instruction. It starts as the agent's suggestion.
+3. Press **Run agent**. Or press **I'll handle it** to keep the item yourself.
+
+Run agent adds one job to today's day run, with your instruction. The job runs like every Agenda job: at most 5 at once, one draft, and nothing is sent. A hand icon marks an item that looks like a decision only you can make. An agent can still prepare it.
+
+**Back to brief** returns an item to To brief, unless an agent is working on it.
+
+## Approve in Agenda
+
+When the draft is ready, the item moves to **Ready** in My work, and the job waits in Agenda. Approve, revise or retry it there. My work has no approve button.
+
+Agenda shows one card, **N items need your brief**, when items wait in To brief. Its button opens My work. The morning brief lists today's top items from My work and does not brief them for you.
+
+## What My work does not do
+
+- It does not write to Jira.
+- It does not open a pull request. A job drafts a reply, a comment, a plan or a document.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `pmos my-work list [--top N] [--json]` | Every open item, in the order My work shows it. |
+| `pmos my-work show <ITEM> [--json]` | One item: what the agent found, the score and the state. ITEM is its key, its id or its number in the list. |
+| `pmos my-work submit --file <read.json>` | The my-work-read skill submits its read. |
+
+None of these briefs an agent or takes an item. Do that in My work.

package/workspace/lib/day-run.js

@@ -14,6 +14,7 @@
  *
  *   newRun(date, now) · readRun(raw, date)
  *   addTasks(run, brief)                       agent priorities (kind approve|auto) → waiting tasks
+ *   addBriefed(run, spec)                      one task the PM briefed in My work (initiative my-work, PRD R5)
  *   toStart(run, limit)                        the tasks to start now, each with its mode (do | revise | send)
  *   started · deliver · decide · sent · fail · sessionEnded · sessionStalled
  *   stage(run, brief)                          reading | working | review | done
@@ -111,6 +112,24 @@ function addTasks(run, brief) {
   return { ok: true, run: next, added };
 }
 
+/**
+ * One task the PM briefed in My work: kind approve, with the PM's instruction and the item's context card on it, so the
+ * day-task session reads the instruction as the ask (PRD R5, R6). `spec` is lib/my-work.js taskSpec. A run opened only
+ * for this (no Prepare my day yet) is marked `opened_by: 'my-work'`, so it does not read as a morning read that failed.
+ */
+function addBriefed(run, spec) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const s = spec && typeof spec === 'object' ? spec : {};
+  if (!TASK_RE.test(String(s.id || ''))) return { ok: false, error: 'a briefed task needs an id like t-0123456789ab' };
+  if (!text(s.instruction)) return { ok: false, error: 'a briefed task needs the PM\'s instruction' };
+  if (findTask(run, s.id)) return { ok: false, error: `task ${s.id} is already in today's run` };
+  const next = clone(run);
+  next.tasks.push({ id: s.id, item_id: null, title: text(s.title).slice(0, 250) || s.id, kind: 'approve', source: s.source || 'my-work', link: isUrl(s.link) ? s.link : null,
+    goal: null, my_work: s.my_work || null, brief_at: s.brief_at || null, instruction: text(s.instruction), context: s.context && typeof s.context === 'object' ? clone(s.context) : null,
+    status: 'waiting', session_id: null, started_at: null, attempts: 0, revisions: [], draft: null, decided: null, error: null });
+  return { ok: true, run: next, added: s.id };
+}
+
 /**
  * The tasks to start now, oldest first, so that the sessions running (working, and sending with a session) stay at
  * most `limit`. An approved task waiting for its send session comes first: the PM is waiting on it.
@@ -260,7 +279,8 @@ function sessionStalled(run, sessionId, why, now) {
 /** Where the run is: reading (no brief for the day yet), working, review (drafts wait for the PM) or done. */
 function stage(run, brief) {
   if (!run) return null;
-  if (!brief || brief.date !== run.date) return 'reading';
+  // a run My work opened (no Prepare my day pressed) has no morning read to wait for
+  if ((!brief || brief.date !== run.date) && !(run.opened_by === 'my-work' && !run.brief_session)) return 'reading';
   if (run.tasks.some((t) => t.status === 'waiting' || t.status === 'working' || t.status === 'sending')) return 'working';
   if (run.tasks.some((t) => t.status === 'review')) return 'review';
   return 'done';
@@ -330,5 +350,5 @@ function checkDone(run, { found = 0, resolved = 0 } = {}, now) {
 }
 
 module.exports = { MAX_PARALLEL, MAX_REVISIONS, MAX_CHECK_LOG, MAX_INTERVAL_MIN, STATUSES, KINDS, ACTIONS, TASK_RE,
-  newRun, readRun, findTask, modeOf, addTasks, toStart, started, deliver, decide, sent, fail, sessionEnded, sessionStalled, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, addBriefed, toStart, started, deliver, decide, sent, fail, sessionEnded, sessionStalled, stage, intervalMin,
   checkDue, checkStarted, checkDone };

package/workspace/lib/my-work-cli.js

@@ -0,0 +1,98 @@
+'use strict';
+/* my-work-cli.js — `pmos my-work`: the work assigned to the PM, ranked, from a terminal (initiative my-work, PRD R11).
+ *
+ *   pmos my-work [list] [--top N] [--json]     every item, in the order My work shows it, with its tier and state
+ *   pmos my-work show <ITEM> [--json]          one item: the context card, the WSJF parts, the state
+ *   pmos my-work submit --file <read.json>     (the my-work-read skill) submit the read of the PM's assigned Jira issues
+ *
+ * Every command goes through the running workspace server (GET /api/my-work, POST /api/my-work/read), so a terminal line
+ * and the page cannot disagree. Nothing here briefs an agent or takes an item: those are the PM's presses in My work.
+ * An ITEM is its id (jira:ATL-491, wbs:<ws>:<item>), its Jira key, or its position in the list.
+ *
+ * Exit codes: 0 done, 1 refused, 2 usage.
+ */
+const fs = require('fs');
+const path = require('path');
+const { parseArgs } = require('./schedule-cli');
+
+const COMMANDS = { 'my-work': ['list', 'show', 'submit'] };
+const USAGE = [
+  'usage: pmos my-work [list|show|submit] — the Jira tickets and WBS items assigned to you, ranked',
+  '  pmos my-work [list] [--top N] [--json]    every item, as My work orders it',
+  '  pmos my-work show <ITEM> [--json]         one item: what the agent found, the score, the state',
+  '  pmos my-work submit --file <read.json>    (agent session) submit the read of your assigned Jira issues',
+  'Nothing here briefs an agent or takes an item. Do that in My work.',
+];
+const BOOL = new Set(['json', 'help']);
+const STATE_WORD = { brief: 'to brief', yours: 'yours', agent: 'agent', ready: 'ready in Agenda', done: 'done' };
+
+function parse(argv) {
+  const rest = []; const bools = {};
+  for (const a of argv) {
+    if (a.startsWith('--') && BOOL.has(a.slice(2))) bools[a.slice(2)] = true;
+    else if (a === '-h') bools.help = true;
+    else rest.push(a);
+  }
+  const { pos, flags } = parseArgs(rest);
+  return { pos, flags: { ...flags, ...bools } };
+}
+
+const line = (x, i) => `${i + 1}. ${x.wsjf.tier} ${String(x.wsjf.score).padStart(4)}  ${x.key}  ${x.title}  · ${STATE_WORD[x.state]}${x.sub && x.state === 'agent' ? ' (' + x.sub + ')' : ''}${x.due ? ' · due ' + x.due : ''}${x.from ? ' · from ' + x.from : ''}`;
+
+async function run(argv, { say = console.log, call, cwd = process.cwd() } = {}) {
+  const { pos, flags } = parse(argv.slice(1));
+  const sub = pos[0] || 'list';
+  if (flags.help || sub === 'help') { USAGE.forEach((l) => say(l)); return 0; }
+  if (!COMMANDS['my-work'].includes(sub)) { USAGE.forEach((l) => say(l)); return 2; }
+  const json = !!flags.json;
+  const fail = (error, code = 1) => { if (json) say(JSON.stringify({ ok: false, error })); else say(`✗ ${error}`); return code; };
+  if (typeof call !== 'function') return fail('the workspace server is not reachable');
+
+  if (sub === 'submit') {
+    if (!flags.file) return fail('usage: pmos my-work submit --file <read.json>', 2);
+    let raw;
+    try { raw = JSON.parse(fs.readFileSync(path.resolve(cwd, String(flags.file)), 'utf8')); }
+    catch (e) { return fail(`could not read ${flags.file} — ${e.message}`); }
+    const r = await call('POST', '/api/my-work/read', raw);
+    if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the workspace server did not answer'}. Nothing changed.`);
+    if (json) say(JSON.stringify(r)); else say(`read saved — ${r.count} item${r.count === 1 ? '' : 's'} at ${r.read_at}. My work shows them to brief.`);
+    return 0;
+  }
+
+  const d = await call('GET', '/api/my-work');
+  if (!d || d.ok === false) return fail((d && d.error) || 'the workspace server did not answer');
+  if (sub === 'list') {
+    const top = flags.top === undefined ? null : Number(flags.top);
+    if (top !== null && (!Number.isInteger(top) || top < 1)) return fail('--top takes a whole number of 1 or more', 2);
+    const open = d.items.filter((x) => x.state !== 'done');
+    const items = top ? open.slice(0, top) : open;
+    if (json) { say(JSON.stringify({ ok: true, today: d.today, read_at: d.read_at, counts: d.counts, items })); return 0; }
+    say(`My work · ${d.counts.all} open · ${d.counts.brief} to brief · ${d.counts.agents} with agents · ${d.counts.ready} ready in Agenda · read ${d.read_at || 'never'}`);
+    for (const b of d.banner || []) say(`! ${b.source}: ${b.error}`);
+    if (!items.length) say('Nothing assigned to you. Read again in My work, or run the my-work-read skill.');
+    items.forEach((x, i) => say(line(x, i)));
+    return 0;
+  }
+  // show
+  const ref = String(pos[1] || '');
+  if (!ref) return fail('usage: pmos my-work show <ITEM>', 2);
+  const open = d.items.filter((x) => x.state !== 'done');
+  const x = /^\d+$/.test(ref) ? open[Number(ref) - 1] : d.items.find((y) => y.id === ref || y.key === ref.toUpperCase() || y.key === ref);
+  if (!x) return fail(`no item ${ref} — pmos my-work list shows them`);
+  if (json) { say(JSON.stringify({ ok: true, item: x })); return 0; }
+  say(`${x.key}  ${x.title}`);
+  say(`${x.source === 'jira' ? 'Jira' : 'WBS'}${x.repo ? ' · ' + x.repo : ''}${x.status ? ' · ' + x.status : ''}${x.url ? ' · ' + x.url : ''}`);
+  say(`state: ${STATE_WORD[x.state]}${x.sub ? ' (' + x.sub + ')' : ''}${x.task ? ' · task ' + x.task.id : ''}`);
+  const w = x.wsjf;
+  say(`${w.tier} · score ${w.score} = (value ${w.value} + urgency ${w.urgency} + unblocks ${w.unblocks}) / size ${w.size}`);
+  if (x.from) say(`from: ${x.from}`);
+  if (x.ask) say(`ask: ${x.ask}`);
+  if (x.thread) say(`thread: ${x.thread}`);
+  (x.open || []).forEach((o) => say(`open: ${o}`));
+  if (x.kind === 'decide') say('looks like a decision only you can make');
+  if (x.instruction) say(`your instruction: ${x.instruction}`);
+  else if (x.suggest) say(`suggested instruction: ${x.suggest}`);
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/my-work.js

@@ -0,0 +1,242 @@
+'use strict';
+/* my-work.js — every Jira ticket and WBS item assigned to the PM, ranked, with one state each (initiative my-work, PRD
+ * R1 to R5).
+ *
+ * PURE: no require at all — no file, process, network or clock of its own. The server reads the stored read
+ * (<state>/my-work/read.json), the PM's presses (<state>/my-work/actions.jsonl), the Board fold of each registered
+ * repository and the day runs, passes them in with `now`, and writes what an edit returns.
+ *
+ *   checkRead(raw, now)                  → { ok, read } | { ok:false, error }   R1: what the my-work-read skill submits
+ *   wbsItems(boards)                     → items                                R2: owner `you` plan items, every repository
+ *   score(item, today)                   → { value, urgency, unblocks, size, score, tier }   R3
+ *   parseActions(text) · checkAct(op)    → the press log, one press
+ *   fold({ read, wbs, actions, runs, today })  → { items, counts }             R4: ranked, one state each
+ *   taskSpec(item, instruction, seq)     → what lib/day-run.js addBriefed takes   R5
+ *
+ * An item is { id, source: jira|wbs, key, title, url, priority, status, category: todo|doing|done, due, estimate,
+ * blocks, from, ask, thread, open, suggest, kind: agent|decide, initiative, repo, ws }. Its id is `jira:<KEY>` or
+ * `wbs:<ws>:<item>`, so the same ticket read twice is the same item.
+ *
+ * States: brief (nobody decided) · yours (the PM takes it) · agent (a day task works on it; `sub` says how) ·
+ * ready (its draft waits in Agenda) · done. Derived on every read; no state is stored.
+ */
+
+const PRIORITY_VALUE = Object.freeze({ Highest: 10, High: 8, Medium: 5, Low: 2 });
+const SIZE = Object.freeze({ XS: 1, S: 2, M: 3, L: 5, XL: 8 });
+const TIERS = Object.freeze([[12, 'P1'], [7, 'P2'], [3, 'P3'], [-Infinity, 'P4']]);
+const STATES = Object.freeze(['brief', 'yours', 'agent', 'ready', 'done']);
+const ACTIONS = Object.freeze(['brief', 'handle', 'reopen']);
+const CATEGORIES = Object.freeze(['todo', 'doing', 'done']);
+const KEY_RE = /^[A-Z][A-Z0-9_]*-\d+$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ID_RE = /^(jira:[A-Z][A-Z0-9_]*-\d+|wbs:[\w.-]{1,80}:[\w.-]{1,80})$/;
+const MAX_ITEMS = 200;
+const MAX_INSTRUCTION = 2000;
+const DAY = 86400000;
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const oneLine = (s) => String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+const clip = (s, n) => (s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s);
+const str = (v, n) => clip(oneLine(v), n);
+const pick = (map, v) => Object.keys(map).find((k) => k.toLowerCase() === String(v || '').trim().toLowerCase()) || null;
+const httpsUrl = (v) => { const s = String(v || ''); try { return new URL(s).protocol === 'https:' && s.length <= 500 ? s : null; } catch { return null; } };
+const dateOf = (v) => { const s = String(v || '').slice(0, 10); return DATE_RE.test(s) && !Number.isNaN(Date.parse(s + 'T00:00:00Z')) ? s : null; };
+
+/** FNV-1a over the string, as 12 hex digits: a task id that is the same for the same item and brief, with no require. */
+function hex12(s) {
+  let h1 = 0x811c9dc5; let h2 = 0x01000193;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0;
+    h2 = Math.imul(h2 ^ c, 0x0100019d) >>> 0;
+  }
+  return (h1.toString(16).padStart(8, '0') + h2.toString(16).padStart(8, '0')).slice(0, 12);
+}
+
+/* ── R1 · the read ────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function checkItem(x, i) {
+  if (!isObj(x)) return { error: `item ${i + 1} is not an object` };
+  const key = oneLine(x.key).toUpperCase();
+  if (!KEY_RE.test(key)) return { error: `item ${i + 1}: key must be a Jira key like ATL-491` };
+  const title = str(x.title || x.summary, 250);
+  if (!title) return { error: `item ${key}: a title is required` };
+  if (x.priority != null && x.priority !== '' && !pick(PRIORITY_VALUE, x.priority)) return { error: `item ${key}: priority must be Highest, High, Medium or Low` };
+  if (x.estimate != null && x.estimate !== '' && !pick(SIZE, x.estimate)) return { error: `item ${key}: estimate must be XS, S, M, L or XL` };
+  if (x.due != null && x.due !== '' && !dateOf(x.due)) return { error: `item ${key}: due must be a date YYYY-MM-DD` };
+  const blocks = x.blocks == null ? 0 : Number(x.blocks);
+  if (!Number.isInteger(blocks) || blocks < 0 || blocks > 99) return { error: `item ${key}: blocks must be a whole number from 0 to 99` };
+  const open = Array.isArray(x.open) ? x.open.map((o) => str(o, 200)).filter(Boolean).slice(0, 5) : [];
+  const category = CATEGORIES.includes(x.category) ? x.category : 'todo';
+  const initiative = /^[a-z0-9][a-z0-9-]{0,79}$/.test(String(x.initiative || '')) ? x.initiative : null;
+  return {
+    item: {
+      id: 'jira:' + key, source: 'jira', key, title, url: httpsUrl(x.url), priority: pick(PRIORITY_VALUE, x.priority) || null,
+      status: str(x.status, 60) || null, category, due: dateOf(x.due), estimate: pick(SIZE, x.estimate) || null, blocks,
+      from: str(x.from, 80) || null, ask: str(x.ask, 400) || null, thread: str(x.thread, 600) || null, open,
+      suggest: str(x.suggest, MAX_INSTRUCTION) || null, kind: x.kind === 'decide' ? 'decide' : 'agent', initiative, repo: null, ws: null,
+    },
+  };
+}
+
+/** What the my-work-read skill submits: { items: [...] }. Refused whole on any bad item, so a read is never half-kept. */
+function checkRead(raw, now) {
+  if (!isObj(raw) || !Array.isArray(raw.items)) return { ok: false, error: 'the read must be an object with an items list' };
+  if (raw.items.length > MAX_ITEMS) return { ok: false, error: `at most ${MAX_ITEMS} items in one read` };
+  const items = []; const seen = new Set();
+  for (let i = 0; i < raw.items.length; i++) {
+    const c = checkItem(raw.items[i], i);
+    if (c.error) return { ok: false, error: c.error };
+    if (seen.has(c.item.id)) return { ok: false, error: `item ${c.item.key} is listed twice` };
+    seen.add(c.item.id);
+    items.push(c.item);
+  }
+  return { ok: true, read: { read_at: new Date(now).toISOString(), items } };
+}
+
+/* ── R2 · WBS items from the Board fold ───────────────────────────────────────────────────────────────────────── */
+
+const WBS_CATEGORY = { todo: 'todo', doing: 'doing', review: 'doing', done: 'done' };
+
+/**
+ * `boards` = [{ ws, repo, board }] where board is lib/board-fold.js boardFor(…, { filter: 'mine' }). Only items with
+ * owner `you` are kept. `blocks` counts the items of the same repository whose `after` names the item.
+ */
+function wbsItems(boards) {
+  const out = [];
+  for (const b of Array.isArray(boards) ? boards : []) {
+    if (!b || !isObj(b.board) || !isObj(b.board.items)) continue;
+    const all = Object.values(b.board.items);
+    const titles = new Map((b.board.initiatives || []).map((i) => [i.id, i.title]));
+    for (const it of all) {
+      if (!it || it.owner !== 'you' || typeof it.id !== 'string') continue;
+      const blocks = all.filter((o) => o && Array.isArray(o.after) && o.after.includes(it.id)).length;
+      const id = `wbs:${b.ws}:${it.id}`;
+      if (!ID_RE.test(id)) continue;
+      out.push({
+        id, source: 'wbs', key: it.id, title: str(it.title, 250) || it.id, url: null, priority: null,
+        status: str(it.stageLabel || it.stage, 60) || null, category: WBS_CATEGORY[it.state] || 'todo', due: dateOf(it.due), estimate: null,
+        blocks, from: titles.get(it.initiative) || it.initiative || null, ask: str(it.note, 400) || null, thread: null, open: [],
+        suggest: null, kind: 'agent', initiative: it.initiative || null, repo: b.repo || b.ws, ws: b.ws,
+      });
+    }
+  }
+  return out;
+}
+
+/* ── R3 · WSJF ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function urgencyOf(due, today) {
+  if (!due || !DATE_RE.test(String(today || ''))) return 1;
+  const days = Math.round((Date.parse(due + 'T00:00:00Z') - Date.parse(today + 'T00:00:00Z')) / DAY);
+  if (days < 0) return 10;
+  if (days <= 2) return 8;
+  if (days <= 7) return 5;
+  return 3;
+}
+const tierOf = (s) => TIERS.find(([min]) => s >= min)[1];
+
+/** The WSJF parts of one item on the local day `today` (YYYY-MM-DD). */
+function score(item, today) {
+  const value = PRIORITY_VALUE[item.priority || 'Medium'] + (item.initiative ? 3 : 1);
+  const urgency = urgencyOf(item.due, today);
+  const unblocks = Math.min(9, 3 * (Number(item.blocks) || 0));
+  const size = SIZE[item.estimate || 'M'];
+  const s = Math.round(((value + urgency + unblocks) / size) * 10) / 10;
+  return { value, urgency, unblocks, size, score: s, tier: tierOf(s) };
+}
+
+/* ── the press log ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** One press from the page: { action: brief|handle|reopen, item, instruction? }. Returns the record to append. */
+function checkAct(op, now) {
+  const o = isObj(op) ? op : {};
+  if (!ACTIONS.includes(o.action)) return { ok: false, error: `action must be one of ${ACTIONS.join(', ')}` };
+  const item = String(o.item || '');
+  if (!ID_RE.test(item)) return { ok: false, error: 'item must be an item id like jira:ATL-491' };
+  const rec = { action: o.action, item, at: new Date(now).toISOString() };
+  if (o.action === 'brief') {
+    const ins = typeof o.instruction === 'string' ? o.instruction.trim() : '';
+    if (!ins) return { ok: false, error: 'say what the agent should do: a brief needs an instruction' };
+    if (ins.length > MAX_INSTRUCTION) return { ok: false, error: `the instruction is over ${MAX_INSTRUCTION} characters` };
+    rec.instruction = ins;
+  }
+  return { ok: true, record: rec };
+}
+
+/** The append-only log as text → the presses, oldest first. A torn or unknown line is skipped. */
+function parseActions(text) {
+  const out = [];
+  for (const line of String(text || '').split('\n')) {
+    if (!line.trim()) continue;
+    let r; try { r = JSON.parse(line); } catch { continue; }
+    if (isObj(r) && ACTIONS.includes(r.action) && ID_RE.test(String(r.item || '')) && typeof r.at === 'string') out.push(r);
+  }
+  return out;
+}
+
+/* ── R4 · the fold ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const AGENT_SUBS = ['waiting', 'working', 'sending', 'failed'];
+
+/** The day task that works on `item` for its last brief, from the run of that brief's day. */
+function taskOf(runs, brief) {
+  const day = String(brief.at).slice(0, 10);
+  const pool = [];
+  for (const [d, run] of Object.entries(isObj(runs) ? runs : {})) if (run && Array.isArray(run.tasks) && (d >= day)) pool.push(...run.tasks);
+  return pool.filter((t) => t && t.my_work === brief.item && t.brief_at === brief.at).pop() || null;
+}
+
+/** The state of one item: { state, sub, task, instruction, decided_at }. */
+function stateOf(item, presses, runs) {
+  if (item.category === 'done') return { state: 'done', sub: 'source', task: null, instruction: null };
+  const last = presses[presses.length - 1] || null;
+  if (!last || last.action === 'reopen') return { state: 'brief', sub: null, task: null, instruction: null };
+  if (last.action === 'handle') return { state: 'yours', sub: null, task: null, instruction: null, decided_at: last.at };
+  const t = taskOf(runs, last);
+  const task = t ? { id: t.id, status: t.status, error: t.error || null, draft: t.draft ? t.draft.summary : null } : null;
+  const base = { task, instruction: last.instruction, decided_at: last.at };
+  if (!t) return { state: 'agent', sub: 'waiting', ...base };
+  if (t.status === 'review') return { state: 'ready', sub: 'review', ...base };
+  if (t.status === 'sent' || t.status === 'done') return { state: 'done', sub: t.status, ...base };
+  return { state: 'agent', sub: AGENT_SUBS.includes(t.status) ? t.status : 'waiting', ...base };
+}
+
+/** May the PM press `action` on an item in this state? Null when yes, else why not. */
+function refusal(st, action) {
+  if (action === 'brief' || action === 'handle') return st.state === 'brief' ? null : `the item is ${st.state}, not waiting for a brief — press Back to brief first`;
+  if (st.state === 'brief') return 'the item is already waiting for a brief';
+  if (st.state === 'done' && st.sub === 'source') return 'the item is done in its source';
+  if (st.state === 'agent' && (st.sub === 'working' || st.sub === 'sending')) return 'an agent is working on it — wait for its draft in Agenda';
+  return null;
+}
+
+/**
+ * Every item, ranked, with its state. `read` is the stored read or null; `wbs` is wbsItems(…); `actions` is
+ * parseActions(…); `runs` maps a date to that day's run. Counts: brief, agents, ready, yours, all (not done).
+ */
+function fold({ read, wbs, actions, runs, today } = {}) {
+  const by = new Map();
+  for (const it of (read && Array.isArray(read.items) ? read.items : [])) by.set(it.id, it);
+  for (const it of Array.isArray(wbs) ? wbs : []) if (!by.has(it.id)) by.set(it.id, it);
+  const presses = new Map();
+  for (const a of Array.isArray(actions) ? actions : []) { if (!presses.has(a.item)) presses.set(a.item, []); presses.get(a.item).push(a); }
+  const items = [...by.values()].map((it) => ({ ...it, wsjf: score(it, today), ...stateOf(it, presses.get(it.id) || [], runs) }));
+  items.sort((a, b) => (b.wsjf.score - a.wsjf.score) || String(a.due || '9999').localeCompare(String(b.due || '9999')) || a.id.localeCompare(b.id));
+  const n = (s) => items.filter((x) => x.state === s).length;
+  const counts = { brief: n('brief'), agents: n('agent'), ready: n('ready'), yours: n('yours'), done: n('done'), all: items.filter((x) => x.state !== 'done').length };
+  return { items, counts };
+}
+
+/* ── R5 · the day task a brief adds ───────────────────────────────────────────────────────────────────────────── */
+
+/** What lib/day-run.js addBriefed takes for a brief recorded as `rec` on `item`. */
+function taskSpec(item, rec) {
+  return {
+    id: 't-' + hex12(item.id + '|' + rec.at), my_work: item.id, brief_at: rec.at, title: item.key + ' · ' + item.title,
+    source: item.source, link: item.url, instruction: rec.instruction,
+    context: { key: item.key, from: item.from, ask: item.ask, thread: item.thread, open: item.open, repo: item.repo, ws: item.ws || null, initiative: item.initiative, due: item.due },
+  };
+}
+
+module.exports = { PRIORITY_VALUE, SIZE, STATES, ACTIONS, MAX_INSTRUCTION, ID_RE, checkRead, wbsItems, score, urgencyOf, checkAct, parseActions, stateOf, refusal, fold, taskSpec, hex12 };

package/workspace/lib/people-store.js

@@ -23,23 +23,45 @@ const crypto = require('crypto');
 const P = require('./people');
 const fourPanel = require('./four-panel');
 const consoleState = require('./console-state');
+const planTree = require('./plan-tree');
 
 const MAX_PER_RECORD = 500;
 const fs = require('fs');
 const path = require('path');
 
+/** One ledger per repository, whichever worktree is open: the main working tree, as plan items read theirs. */
+function repoRoot(root) { return planTree.mainTree(path.resolve(root)); }
 function stateDir(root) {
   const e = consoleState.loadEngine();
   if (!e.ok) return { ok: false, error: e.error };
-  const dir = fourPanel.storeDir(e.engine, root);
+  const dir = fourPanel.storeDir(e.engine, repoRoot(root));
   return dir ? { ok: true, dir } : { ok: false, error: 'this repository has no file-mode state directory' };
 }
+/**
+ * The other places an earlier version may have written this repository's ledger. The engine puts records in
+ * planning/runs/ until the repository has pmos/state/initiatives/, then in pmos/state/, so a repository that gained its
+ * first initiative after People was used reads a new, empty file. Before 0.72.1 a worktree also wrote its own ledger.
+ * Their rows are read first, so a later press in the ledger now written still wins.
+ */
+function olderLedgers(root, dir) {
+  const roots = [...new Set([repoRoot(root), path.resolve(root)])];
+  const dirs = roots.flatMap((r) => [path.join(r, 'planning', 'runs'), path.join(r, 'pmos', 'state')]);
+  return [...new Set(dirs)].filter((d) => path.resolve(d) !== path.resolve(dir) && fs.existsSync(path.join(d, P.LEDGER)));
+}
 function readRows(root) {
   const s = stateDir(root);
   if (!s.ok) return s;
   const r = fourPanel.readDeclarations(s.dir, P.LEDGER);
   if (!r.ok) return { ok: false, error: r.error };
-  return { ok: true, dir: s.dir, file: r.file, rows: r.rows };
+  const older = olderLedgers(root, s.dir);
+  if (!older.length) return { ok: true, dir: s.dir, file: r.file, rows: r.rows };
+  // A line already in a file read before (a worktree's copy of a committed ledger) counts once.
+  const rows = [];
+  for (const list of [...older.map((d) => fourPanel.readDeclarations(d, P.LEDGER)).filter((o) => o.ok).map((o) => o.rows), r.rows]) {
+    const before = new Set(rows.map((x) => JSON.stringify(x)));
+    for (const row of list) if (!before.has(JSON.stringify(row))) rows.push(row);
+  }
+  return { ok: true, dir: s.dir, file: r.file, rows, older: older.map((d) => path.join(d, P.LEDGER)) };
 }
 /** The plan items, for shared work (R10). A repository without a plan gives none. */
 function planItems(root) {

package/workspace/lib/pmos-verbs.js

@@ -44,6 +44,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): people-directory added it through the same table.
   people: Object.freeze({ module: 'people-cli.js', run: null, guide: 'people.md',
     help: 'pmos people list|show|record|settings … — the people you work with in this repository (pmos people help)' }),
+  // Not a pm-os-absorb verb (run: null): initiative my-work added it through the same table.
+  'my-work': Object.freeze({ module: 'my-work-cli.js', run: null, guide: 'my-work.md',
+    help: 'pmos my-work list|show|submit … — the Jira tickets and WBS items assigned to you, ranked (pmos my-work 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/proactive-cli.js

@@ -275,6 +275,16 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
         for (const k of ['where', 'who', 'about', 'ask', 'how']) if (it[k]) say(`${k}: ${it[k]}`);
         if (it.reply_needed !== undefined) say(`reply needed: ${it.reply_needed ? 'yes' : 'no'}`);
         if (it.initiative_id) say(`initiative: ${it.initiative_id}`);
+      } else if (t.my_work) {
+        // a job the PM briefed in My work (initiative my-work, R6): the PM's instruction is the ask
+        const c = t.context || {};
+        say(`from My work: ${t.my_work}${c.repo ? ' · repository ' + c.repo : ''}${c.due ? ' · due ' + c.due : ''}`);
+        if (c.from) say(`who: ${c.from}`);
+        if (c.ask) say(`about: ${c.ask}`);
+        if (c.thread) say(`thread: ${c.thread}`);
+        for (const o of Array.isArray(c.open) ? c.open : []) say(`open question: ${o}`);
+        if (c.initiative) say(`initiative: ${c.initiative}`);
+        say(`instruction from the PM (this is the ask): ${t.instruction}`);
       } else say('(the item is no longer in today\'s brief)');
       if (t.kind === 'approve') say('kind approve: deliver ONE draft; nothing goes out until the PM approves it.');
       else say('kind auto: deliver ONE draft; nothing leaves this machine.');

package/workspace/lib/route-modules.js

@@ -37,6 +37,7 @@ const MODULES = Object.freeze([
   'routes-board',         // Run 4 (4D): the cross-initiative Board, Release
   'routes-reports',       // Run 5 (5C): drafts, Issue, notes
   'routes-notes',         // meeting-notes Run 1: the Notes view (typed notes, dictation, transcripts, summaries)
+  'routes-my-work',       // initiative my-work: the ranked list of work assigned to the PM, the brief, Read again
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;