create-pmos 0.71.1 → 0.72.0

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

@@ -0,0 +1,122 @@
+'use strict';
+/* routes-my-work.js — the My work destination's routes (initiative my-work, PRD R1 to R5, R11).
+ *
+ *   GET  /api/my-work                    → { ok, today, read_at, items, counts, banner }   every item assigned to the PM,
+ *                                          ranked (lib/my-work.js fold), across every registered repository
+ *   POST /api/my-work/read  { items }    → { ok, read_at, count }   the my-work-read skill's submission (`pmos my-work submit`)
+ *   POST /api/my-work/act   { action: brief|handle|reopen, item, instruction?, ws }
+ *                                        → { ok, item, task? }      the PM's press; a brief adds one day task (R5)
+ *   POST /api/my-work/refresh { ws }     → { ok, session }          Read again: starts the my-work-read skill
+ *
+ * STATE. The latest read is <runtime>/my-work/read.json and the presses are <runtime>/my-work/actions.jsonl, append-only.
+ * Both stay in the per-user runtime state and never land in a repository: they hold paraphrases of Jira comments. The
+ * WBS items are folded from each repository's Board (lib/board-fold.js, filter mine) on every GET, and nothing is
+ * written to a plan ledger (D88).
+ *
+ * THE SERVER NEVER READS JIRA (D53, D71). An agent session reads it with the PM's own connection and posts the read.
+ * The two presses that start a session (act brief, refresh) pass pm-guard requirePagePress first: an agent session
+ * cannot brief itself or another agent.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const myWork = require('./my-work.js');
+const boardFold = require('./board-fold.js');
+const { localDate } = require('./brief.js');
+
+const dirOf = (ctx) => path.join(ctx.runtimeDir, 'my-work');
+const readFile = (ctx) => path.join(dirOf(ctx), 'read.json');
+const actionsFile = (ctx) => path.join(dirOf(ctx), 'actions.jsonl');
+
+function loadRead(ctx) {
+  try { const r = JSON.parse(fs.readFileSync(readFile(ctx), 'utf8')); return r && Array.isArray(r.items) ? r : null; } catch { return null; }
+}
+function loadActions(ctx) {
+  try { return myWork.parseActions(fs.readFileSync(actionsFile(ctx), 'utf8')); } catch { return []; }
+}
+
+/** The whole list, as GET answers it. */
+function listFor(ctx, now) {
+  const today = localDate(now);
+  const banner = [];
+  const boards = [];
+  const all = typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : [];
+  for (const w of all) {
+    try {
+      const b = boardFold.boardFor({ id: w.id, root: w.root }, { filter: 'mine', now });
+      if (b.ok) boards.push({ ws: w.id, repo: w.name || path.basename(w.root), board: b });
+      else banner.push({ source: 'wbs:' + w.id, error: b.error });
+    } catch (e) { banner.push({ source: 'wbs:' + w.id, error: String((e && e.message) || e).slice(0, 160) }); }
+  }
+  const read = loadRead(ctx);
+  const actions = loadActions(ctx);
+  const runs = {};
+  for (const d of new Set(actions.filter((a) => a.action === 'brief').map((a) => String(a.at).slice(0, 10)).concat([today]))) {
+    try { const r = ctx.readDayRun ? ctx.readDayRun(d) : null; if (r) runs[d] = r; } catch { /* a run that cannot be read is no run */ }
+  }
+  // a run of a later day can hold a task too: today's covers every brief made today
+  const out = myWork.fold({ read, wbs: myWork.wbsItems(boards), actions, runs, today });
+  return { ok: true, today, read_at: read ? read.read_at || null : null, items: out.items, counts: out.counts, banner };
+}
+
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, file);
+}
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const now = Date.now();
+  if (p === '/api/my-work') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    ctx.json(res, listFor(ctx, now));
+    return true;
+  }
+  if (!['/api/my-work/read', '/api/my-work/act', '/api/my-work/refresh'].includes(p)) return false;
+  if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+  const got = await ctx.readJson(req);
+  if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
+  const body = got.body;
+
+  if (p === '/api/my-work/read') {
+    const c = myWork.checkRead(body, now);
+    if (!c.ok) { ctx.json(res, { ok: false, error: c.error }, 400); return true; }
+    try { writeAtomic(readFile(ctx), JSON.stringify(c.read) + '\n'); }
+    catch { ctx.json(res, { ok: false, error: 'could not save the read — nothing changed' }, 500); return true; }
+    ctx.json(res, { ok: true, read_at: c.read.read_at, count: c.read.items.length });
+    return true;
+  }
+
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+
+  if (p === '/api/my-work/refresh') {
+    const r = ctx.myWorkRead(String(body.ws || ''));
+    ctx.json(res, r.ok ? { ok: true, session: r.session } : { ok: false, error: r.error }, r.ok ? 200 : r.status || 500);
+    return true;
+  }
+
+  // act
+  const c = myWork.checkAct(body, now);
+  if (!c.ok) { ctx.json(res, { ok: false, error: c.error }, 400); return true; }
+  const list = listFor(ctx, now);
+  const item = list.items.find((x) => x.id === c.record.item);
+  if (!item) { ctx.json(res, { ok: false, error: `no item ${c.record.item} is assigned to you` }, 404); return true; }
+  const why = myWork.refusal(item, c.record.action);
+  if (why) { ctx.json(res, { ok: false, error: why }, 409); return true; }
+  let task = null;
+  if (c.record.action === 'brief') {
+    const b = ctx.myWorkBrief(myWork.taskSpec(item, c.record), String(body.ws || ''));
+    if (!b.ok) { ctx.json(res, { ok: false, error: b.error }, b.status || 500); return true; }
+    task = b.task;
+  }
+  try { fs.mkdirSync(dirOf(ctx), { recursive: true }); fs.appendFileSync(actionsFile(ctx), JSON.stringify(c.record) + '\n'); }
+  catch { ctx.json(res, { ok: false, error: 'could not save your press' }, 500); return true; }
+  const after = listFor(ctx, Date.now()).items.find((x) => x.id === item.id) || null;
+  ctx.json(res, { ok: true, item: after, task });
+  return true;
+}
+
+module.exports = { prefixes: ['/api/my-work'], handle, listFor };

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.71.1",
+  "version": "0.72.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

package/workspace/public/pm/app.js

@@ -406,7 +406,7 @@ function render() {
 
 const FRAME = !FIXTURE && !LEGACY_LAYOUT_FLAG;
 const FRAME_KEY = 'pmos.workspace.pm.frame';
-const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
+const FRAME_DESTS = Object.freeze(['today', 'mywork', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
 
 function readFrame() {
   if (!FRAME) return {};
@@ -654,7 +654,7 @@ function pressIn(r, key) {
   if (b && !b.disabled) { b.click(); return true; }
   return false;
 }
-const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people' };
+const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people', w: 'mywork' };
 
 function frameKey(e) {
   const mod = e.metaKey || e.ctrlKey;

package/workspace/public/pm/components.css

@@ -5653,6 +5653,123 @@
   }
 }
 
+/* My work (my-work): the work assigned to the PM, ranked, beside the chosen item's context card and brief. */
+.rp-mywork {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-mywork-top {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+}
+.rp-mywork-top > .rp-head__title {
+  margin-right: auto;
+}
+.rp-mywork-body {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-mywork-grid {
+  display: grid;
+  grid-template-columns: minmax(280px, 3fr) 2fr;
+  gap: 24px;
+  align-items: start;
+}
+.rp-mywork-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+}
+.rp-mywork-views {
+  border-bottom: 1px solid var(--border);
+}
+.rp-mywork-row {
+  border-top: 1px solid var(--border);
+}
+.rp-mywork-row:last-child {
+  border-bottom: 1px solid var(--border);
+}
+.rp-mywork-row--open {
+  box-shadow: inset 2px 0 0 var(--foreground);
+}
+.rp-mywork-state {
+  display: inline-flex;
+  align-items: center;
+  color: var(--muted-foreground);
+}
+.rp-mywork-page {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-width: 0;
+}
+.rp-mywork-who {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.rp-mywork-who__title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 500;
+}
+.rp-mywork-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 12px;
+  color: var(--foreground);
+}
+.rp-mywork-sec,
+.rp-mywork-brief,
+.rp-mywork-status {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.rp-mywork-sec__title,
+.rp-mywork-sub {
+  margin: 0;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--muted-foreground);
+}
+.rp-mywork-hint {
+  margin: 0;
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-mywork-text {
+  margin: 0;
+  font-size: 14px;
+  overflow-wrap: anywhere;
+}
+.rp-mywork-quote {
+  padding-left: 8px;
+  border-left: 2px solid var(--border);
+  white-space: pre-wrap;
+}
+.rp-mywork-open {
+  margin: 0;
+  padding-left: 16px;
+  font-size: 14px;
+}
+.rp-mywork-acts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+@media (max-width: 760px) {
+  .rp-mywork-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
 /* -- layouts · .nt- Notes: one meeting on one screen — notes and what was caught beside a quiet transcript (meeting-notes Runs 1 and 2) -- */
 .nt-wrap {
   display: flex;

package/workspace/public/pm/dest-mywork.js

@@ -0,0 +1,242 @@
+/* pm/dest-mywork.js — the My work destination: every Jira ticket and WBS item assigned to the PM, ranked, briefed to an
+ * agent, approved in Agenda (initiative my-work, PRD R3 to R5, R7, R10).
+ *
+ * A DESTINATION MODULE (registry.js): mountDestination(host, ctx) on every render with the same host, disposeDestination(host).
+ * It keeps ONE persistent root per host and rebuilds the body only when its own data or a choice changed.
+ *
+ * What it shows:
+ *   - the tabs To brief (the default) · Agents · Ready · All, each with its count, and Read again;
+ *   - the list, in WSJF order: the tier, the title, a meta line (Jira or WBS, the key, who asked, the due date) and a
+ *     state icon;
+ *   - the chosen item: What the agent found (the ask, the thread, the open questions), the instruction box prefilled
+ *     with the agent's suggestion, Run agent and I'll handle it; Back to brief when the item is the PM's or an agent's;
+ *     Open Agenda when its draft waits there; Details with each part of the score.
+ * Every press is a page press to POST /api/my-work/act or /api/my-work/refresh. Approve, revise and retry are Agenda's
+ * (R7): there is no approve button here. In fixture mode it reads nothing.
+ */
+
+import { el } from './dom.js';
+import { button, row, field, toast, empty, tabs, badge, ensureComponentsCss } from './primitives.js';
+import { icon, ensureSprite } from './icons.js';
+import { pmPost } from './http.js';
+import { wsOf } from './data.js';
+import { registerCommand, openDestination } from './registry.js';
+import { myWork, loadMyWork, onMyWork } from './my-work-data.js';
+
+export const COPY = Object.freeze({
+  title: 'My work',
+  fixture: 'My work shows the work assigned to you in a real session.',
+  loading: 'Reading…',
+  readError: 'My work could not be read.',
+  readAgain: 'Read again',
+  readStarted: 'The read started in a session. My work updates when it submits.',
+  readAt: (t) => (t ? 'Jira read ' + t : 'Jira not read yet. Press Read again.'),
+  tabs: { brief: 'To brief', agents: 'Agents', ready: 'Ready', all: 'All' },
+  none: { brief: 'Nothing waits for a brief.', agents: 'No agent is working on your items.', ready: 'No draft waits for you.', all: 'Nothing is assigned to you.' },
+  pick: 'Choose an item to see what the agent found.',
+  found: 'What the agent found',
+  ask: 'Ask', thread: 'Thread', open: 'Still open',
+  noCard: 'No context card yet. Read again to have an agent read this ticket.',
+  decide: 'This looks like a decision only you can make. An agent can still prepare it.',
+  instruction: 'Instruction for the agent',
+  placeholder: 'Tell the agent what to do. It drafts, and sends nothing until you approve it in Agenda.',
+  run: 'Run agent',
+  handle: "I'll handle it",
+  back: 'Back to brief',
+  agenda: 'Open Agenda',
+  source: 'Open the source',
+  details: 'Details', hide: 'Hide details',
+  score: (w) => `${w.tier} · score ${w.score} = (value ${w.value} + urgency ${w.urgency} + unblocks ${w.unblocks}) / size ${w.size}`,
+  yourInstruction: 'Your instruction',
+  started: 'The agent is on it. Its draft will wait for you in Agenda.',
+  taken: 'It is yours.',
+  reopened: 'Back to brief.',
+  state: {
+    brief: 'Needs your brief', yours: 'You handle it', ready: 'Draft ready in Agenda', done: 'Done',
+    agent: { waiting: 'Agent queued', working: 'Agent working', sending: 'Agent sending', failed: 'Agent stopped' },
+  },
+  due: (d) => 'due ' + d,
+  from: (f) => 'from ' + f,
+});
+
+registerCommand({ id: 'my-work-open', label: 'My work', hint: 'Every Jira ticket and WBS item assigned to you, ranked', cli: 'pmos my-work list', run: () => openDestination('mywork') });
+
+const TAB_STATES = { brief: ['brief'], agents: ['agent'], ready: ['ready'], all: ['brief', 'yours', 'agent', 'ready'] };
+const STATE_ICON = { brief: 'circle-alert', yours: 'flag', ready: 'check', done: 'square-check-big' };
+const AGENT_ICON = { waiting: 'clock', working: 'bot', sending: 'bot', failed: 'circle-alert' };
+
+const stateWord = (x) => (x.state === 'agent' ? COPY.state.agent[x.sub] || COPY.state.agent.waiting : COPY.state[x.state]);
+const stateIcon = (x) => {
+  const node = icon(x.state === 'agent' ? AGENT_ICON[x.sub] || 'clock' : STATE_ICON[x.state] || 'circle-alert');
+  return el('span', { class: 'rp-mywork-state', role: 'img', 'aria-label': stateWord(x), title: stateWord(x), 'data-my-work-state': x.state }, node);
+};
+
+/* ── mount ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const insts = new WeakMap();
+
+export function mountDestination(host, ctx) {
+  let inst = insts.get(host);
+  if (!inst) {
+    inst = { host, root: el('div', { class: 'rp-page rp-mywork', 'data-my-work': '' }), body: el('div', { class: 'rp-mywork-body' }),
+      head: null, tab: 'brief', open: null, drafts: new Map(), details: false, busy: false, last: '', ws: null, off: null };
+    insts.set(host, inst);
+    const held = inst;
+    inst.off = onMyWork(() => draw(held));
+    held.body.addEventListener('focusout', () => setTimeout(() => { if (!held.last) draw(held); }, 0));
+  }
+  ensureComponentsCss();
+  if (!inst.root.isConnected || inst.root.parentNode !== host) host.replaceChildren(inst.root);
+  if (ctx && ctx.FIXTURE) { inst.root.replaceChildren(empty({ text: COPY.fixture })); return; }
+  const repo = (ctx && ctx.tab && ctx.tab.repo) || (ctx && ctx.state && ctx.state.product) || null;
+  inst.ws = repo ? wsOf(repo) : null;
+  ensureSprite();
+  loadMyWork();
+  draw(inst);
+}
+
+export function disposeDestination(host) {
+  const inst = insts.get(host);
+  if (!inst) return;
+  if (inst.off) inst.off();
+  inst.root.remove();
+  insts.delete(host);
+}
+
+/* ── presses ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+async function act(inst, body, done) {
+  if (inst.busy) return null;
+  inst.busy = true; inst.last = ''; draw(inst);
+  const r = await pmPost('/api/my-work/act', { ...body, ws: inst.ws });
+  inst.busy = false;
+  if (!r || !r.ok) toast({ text: (r && r.error) || 'Nothing was saved.', tone: 'error' });
+  else if (done) toast({ text: done, timeout: 4000 });
+  await loadMyWork(true);
+  return r && r.ok ? r : null;
+}
+
+async function readAgain(inst) {
+  const r = await pmPost('/api/my-work/refresh', { ws: inst.ws });
+  toast(r && r.ok ? { text: COPY.readStarted, timeout: 5000 } : { text: (r && r.error) || 'The read did not start.', tone: 'error' });
+}
+
+/* ── the list ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function itemRow(inst, x) {
+  const open = inst.open === x.id;
+  const meta = [x.source === 'jira' ? 'Jira ' + x.key : 'WBS ' + (x.repo ? x.repo + ' · ' : '') + x.key];
+  if (x.from) meta.push(COPY.from(x.from));
+  if (x.due) meta.push(COPY.due(x.due));
+  return el('div', { class: 'rp-mywork-row' + (open ? ' rp-mywork-row--open' : ''), role: 'listitem', 'data-my-work-item': x.id },
+    row({
+      title: x.title,
+      meta,
+      lead: [badge({ text: x.wsjf.tier, tone: x.wsjf.tier === 'P1' ? 'warning' : 'outline', attrs: { 'data-my-work-tier': x.wsjf.tier, title: COPY.score(x.wsjf) } })],
+      trail: [x.kind === 'decide' && x.state === 'brief' ? el('span', { class: 'rp-mywork-state', role: 'img', 'aria-label': COPY.decide, title: COPY.decide }, icon('diamond')) : null, stateIcon(x)].filter(Boolean),
+      onOpen: () => { inst.open = x.id; inst.details = false; inst.last = ''; draw(inst); },
+      openLabel: `${x.title}, ${x.wsjf.tier}, ${stateWord(x)}`,
+      openAttrs: { 'aria-current': open ? 'true' : null, 'data-my-work-open': x.id },
+    }));
+}
+
+function listPane(inst, d) {
+  const shown = d.items.filter((x) => TAB_STATES[inst.tab].includes(x.state));
+  const counts = { brief: d.counts.brief, agents: d.counts.agents, ready: d.counts.ready, all: d.counts.all };
+  const controls = el('div', { class: 'rp-mywork-views' },
+    tabs({ variant: 'line', value: inst.tab, ariaLabel: 'Show', attrs: { 'data-my-work-tabs': '' },
+      items: Object.keys(COPY.tabs).map((id) => ({ id, label: COPY.tabs[id], count: counts[id] })),
+      onChange: (v) => { inst.tab = v; inst.open = null; inst.last = ''; draw(inst); } }));
+  const rows = shown.length
+    ? el('div', { role: 'list', 'data-my-work-list': inst.tab }, shown.map((x) => itemRow(inst, x)))
+    : el('p', { class: 'rp-section__empty' }, COPY.none[inst.tab]);
+  return el('div', { class: 'rp-mywork-list' }, controls, rows);
+}
+
+/* ── the item ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function section(title, kids, attrs) {
+  return el('section', { class: 'rp-mywork-sec', ...(attrs || {}) }, el('h4', { class: 'rp-mywork-sec__title' }, title), ...kids);
+}
+
+function foundSec(x) {
+  const kids = [];
+  if (!x.ask && !x.thread && !(x.open || []).length) kids.push(el('p', { class: 'rp-mywork-hint' }, x.source === 'jira' ? COPY.noCard : x.status || ''));
+  if (x.ask) kids.push(el('p', { class: 'rp-mywork-text', 'data-my-work-ask': '' }, el('strong', null, COPY.ask + ': '), x.ask));
+  if (x.thread) kids.push(el('p', { class: 'rp-mywork-text' }, el('strong', null, COPY.thread + ': '), x.thread));
+  if ((x.open || []).length) kids.push(el('p', { class: 'rp-mywork-sub' }, COPY.open), el('ul', { class: 'rp-mywork-open' }, x.open.map((o) => el('li', null, o))));
+  if (x.kind === 'decide') kids.push(el('p', { class: 'rp-mywork-hint', 'data-my-work-decide': '' }, COPY.decide));
+  return section(COPY.found, kids, { 'data-my-work-sec': 'found' });
+}
+
+function briefSec(inst, x) {
+  const f = field({ label: COPY.instruction, kind: 'textarea', hideLabel: true, placeholder: COPY.placeholder, value: inst.drafts.has(x.id) ? inst.drafts.get(x.id) : (x.suggest || ''), attrs: { 'data-my-work-field': 'instruction' } });
+  f.control.addEventListener('input', () => inst.drafts.set(x.id, f.control.value));
+  const run = button({ label: COPY.run, variant: 'primary', size: 'sm', icon: 'bot', disabled: inst.busy, attrs: { 'data-my-work-act': 'brief' },
+    onClick: async () => {
+      const instruction = f.control.value.trim();
+      const r = await act(inst, { action: 'brief', item: x.id, instruction }, COPY.started);
+      if (r) inst.drafts.delete(x.id);
+    } });
+  const mine = button({ label: COPY.handle, variant: 'outline', size: 'sm', disabled: inst.busy, attrs: { 'data-my-work-act': 'handle' },
+    onClick: () => act(inst, { action: 'handle', item: x.id }, COPY.taken) });
+  return el('div', { class: 'rp-mywork-brief' }, f, el('div', { class: 'rp-mywork-acts' }, run, mine));
+}
+
+function statusSec(inst, x) {
+  const kids = [el('p', { class: 'rp-mywork-text', 'data-my-work-status': x.state + (x.sub ? ':' + x.sub : '') }, stateIcon(x), ' ', stateWord(x))];
+  if (x.task && x.task.error) kids.push(el('p', { class: 'rp-mywork-hint' }, x.task.error));
+  if (x.task && x.task.draft) kids.push(el('p', { class: 'rp-mywork-hint' }, x.task.draft));
+  if (x.instruction) kids.push(el('p', { class: 'rp-mywork-sub' }, COPY.yourInstruction), el('p', { class: 'rp-mywork-text rp-mywork-quote' }, x.instruction));
+  const acts = [];
+  if (x.state === 'ready' || (x.state === 'agent' && x.sub === 'failed')) acts.push(button({ label: COPY.agenda, variant: 'primary', size: 'sm', attrs: { 'data-my-work-act': 'agenda' }, onClick: () => openDestination('today') }));
+  const busyAgent = x.state === 'agent' && (x.sub === 'working' || x.sub === 'sending');
+  if (x.state !== 'done' && !busyAgent) acts.push(button({ label: COPY.back, variant: 'ghost', size: 'sm', icon: 'undo-2', disabled: inst.busy, attrs: { 'data-my-work-act': 'reopen' }, onClick: () => act(inst, { action: 'reopen', item: x.id }, COPY.reopened) }));
+  if (acts.length) kids.push(el('div', { class: 'rp-mywork-acts' }, acts));
+  return el('div', { class: 'rp-mywork-status' }, kids);
+}
+
+function itemPane(inst, d) {
+  const x = d.items.find((y) => y.id === inst.open);
+  if (!x) return el('div', { class: 'rp-mywork-page' }, el('p', { class: 'rp-section__empty' }, COPY.pick));
+  const head = el('header', { class: 'rp-mywork-who' },
+    el('h3', { class: 'rp-mywork-who__title' }, x.title),
+    el('p', { class: 'rp-mywork-hint' }, [x.source === 'jira' ? 'Jira' : 'WBS', x.key, x.repo, x.status, x.due ? COPY.due(x.due) : null, x.from ? COPY.from(x.from) : null].filter(Boolean).join(' · ')),
+    x.url ? el('a', { class: 'rp-mywork-link', href: x.url, target: '_blank', rel: 'noopener noreferrer' }, icon('link'), ' ', COPY.source) : null);
+  const details = button({ label: inst.details ? COPY.hide : COPY.details, variant: 'ghost', size: 'sm', iconEnd: inst.details ? 'chevron-down' : 'chevron-right',
+    attrs: { 'aria-expanded': inst.details ? 'true' : 'false', 'data-my-work-details': '' }, onClick: () => { inst.details = !inst.details; inst.last = ''; draw(inst); } });
+  return el('article', { class: 'rp-mywork-page', 'data-my-work-page': x.id },
+    head, foundSec(x),
+    x.state === 'brief' ? section(COPY.instruction, [briefSec(inst, x)], { 'data-my-work-sec': 'brief' }) : statusSec(inst, x),
+    el('div', { class: 'rp-mywork-acts' }, details), inst.details ? el('p', { class: 'rp-mywork-hint', 'data-my-work-score': '' }, COPY.score(x.wsjf)) : null);
+}
+
+/* ── the page ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function header(inst) {
+  if (inst.head) return inst.head;
+  inst.readLine = el('p', { class: 'rp-mywork-hint', 'data-my-work-read': '' });
+  inst.head = el('div', { class: 'rp-mywork-top' }, el('h2', { class: 'rp-head__title' }, COPY.title), inst.readLine,
+    button({ label: COPY.readAgain, variant: 'outline', size: 'sm', icon: 'refresh-cw', attrs: { 'data-my-work-act': 'refresh' }, onClick: () => readAgain(inst) }));
+  return inst.head;
+}
+
+function draw(inst) {
+  const root = inst.root;
+  const d = myWork();
+  const head = header(inst);
+  if (head.parentNode !== root || inst.body.parentNode !== root) root.replaceChildren(head, inst.body);
+  const fp = JSON.stringify([d, inst.tab, inst.open, inst.details, inst.busy]);
+  if (fp === inst.last) return;
+  // Focus stays in an instruction being typed: the redraw waits until the field is left.
+  const typing = document.activeElement && inst.body.contains(document.activeElement) && document.activeElement.matches('textarea');
+  if (typing) { inst.last = ''; return; }
+  inst.last = fp;
+  if (!d) { inst.body.replaceChildren(el('p', { class: 'rp-section__empty' }, COPY.loading)); return; }
+  if (!d.ok) { inst.body.replaceChildren(el('p', { class: 'rp-section__empty rp-section__empty--bad', role: 'alert' }, d.error || COPY.readError)); return; }
+  inst.readLine.textContent = COPY.readAt(d.read_at ? new Date(d.read_at).toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : null);
+  const shown = d.items.filter((x) => TAB_STATES[inst.tab].includes(x.state));
+  if (!shown.some((x) => x.id === inst.open)) inst.open = shown.length ? shown[0].id : null;
+  const banner = (d.banner || []).length ? el('p', { class: 'rp-mywork-hint', role: 'status', 'data-my-work-banner': '' }, d.banner.map((b) => b.source + ': ' + b.error).join(' · ')) : null;
+  inst.body.replaceChildren(...[banner, el('div', { class: 'rp-mywork-grid' }, listPane(inst, d), itemPane(inst, d))].filter(Boolean));
+}

package/workspace/public/pm/frame-copy.js

@@ -23,6 +23,7 @@ export const COPY = {
   nav: {
     label: 'Destinations',
     today: 'Agenda',
+    mywork: 'My work',
     initiatives: 'Initiatives',
     board: 'Board',
     reports: 'Reports',
@@ -33,6 +34,8 @@ export const COPY = {
   },
   /** The Today count on the top bar and on the phone tab, for a screen reader. */
   needs: (n) => (n === 1 ? '1 needs you' : n + ' need you'),
+  /** My work's count on the top bar, for a screen reader (initiative my-work). */
+  toBrief: (n) => (n === 1 ? '1 item to brief' : n + ' items to brief'),
   search: 'Search or capture',
   searchKey: '⌘K',
   sync: {

package/workspace/public/pm/my-work-card.js

@@ -0,0 +1,51 @@
+/* pm/my-work-card.js — Agenda's one card for the items that wait for a brief (initiative my-work, PRD R8).
+ *
+ * One record, two lenses (the PM's choice, 2026-10-07): My work owns the assigned backlog and the brief, and Agenda
+ * shows ONE card, "N items need your brief", when N is 1 or more. Its button opens My work. The card counts once in
+ * Agenda's count, whichever repositories Agenda shows: the list is the PM's, not a repository's.
+ *
+ * Loaded at boot by registry.js loadExtensions. It reads the list once, then again every 30 seconds and whenever the
+ * window gets the focus back, so the bar's count and this card stay current.
+ */
+
+import { registerTodaySource, openDestination } from './registry.js';
+import { setState } from './state.js';
+import { todayCard } from './today-cards.js';
+import { myWork, loadMyWork, onMyWork } from './my-work-data.js';
+
+export const COPY = Object.freeze({
+  cause: (n) => (n === 1 ? '1 item needs your brief' : `${n} items need your brief`),
+  evidence: (titles) => 'Top: ' + titles.join(' · '),
+  act: 'Open My work',
+  cli: 'pmos my-work list',
+});
+
+const brief = () => { const d = myWork(); return d && d.ok ? d.counts.brief : 0; };
+
+registerTodaySource({
+  id: 'my-work-brief',
+  kind: 6,   // capture: the agent read new assigned work and the PM triages it. It ranks after the gates, sessions and Keep cards
+  rank: 40,
+  count: () => (brief() > 0 ? 1 : 0),
+  cards: () => {
+    const n = brief();
+    if (!n) return [];
+    const top = myWork().items.filter((x) => x.state === 'brief').slice(0, 2).map((x) => x.key + ' ' + x.title);
+    return [todayCard({
+      kind: 6, id: 'my-work|brief', cause: COPY.cause(n), evidence: COPY.evidence(top), act: { label: COPY.act, cli: COPY.cli },
+      onAct: () => openDestination('mywork'), attrs: { 'data-my-work-card': String(n) },
+    })];
+  },
+});
+
+if (typeof window !== 'undefined') {
+  // re-render Agenda only when the card would change: a re-render on every read would take the focus off a card the PM is on
+  let shown = '';
+  onMyWork((d) => {
+    const sig = d && d.ok ? d.counts.brief + '|' + d.items.filter((x) => x.state === 'brief').slice(0, 2).map((x) => x.id).join(',') : '0';
+    if (sig !== shown) { shown = sig; setState({}); }
+  });
+  loadMyWork(true);
+  setInterval(() => loadMyWork(), 30000);
+  window.addEventListener('focus', () => loadMyWork());
+}

package/workspace/public/pm/my-work-data.js

@@ -0,0 +1,36 @@
+/* pm/my-work-data.js — the one read of GET /api/my-work that the page shares (initiative my-work, PRD R8, R10).
+ *
+ * My work, the Agenda card and the top bar's count all read the same list, once: a second reader inside READ_MS gets
+ * the answer already held. Every reader is told when a new answer arrives (onMyWork), and the top bar hears it as the
+ * window event `pmos:mywork` with { brief } (the count of items to brief), so the bar needs no import of this module.
+ * In fixture mode nothing loads it.
+ */
+
+import { pmGet } from './http.js';
+
+const READ_MS = 30000;
+let data = null;
+let at = 0;
+let loading = null;
+const subs = new Set();
+
+/** The last answer, or null before the first one. */
+export const myWork = () => data;
+
+/** Read the list again when the last answer is older than READ_MS, or always with `force`. Resolves to the answer. */
+export function loadMyWork(force) {
+  if (loading) return loading;
+  if (!force && data && Date.now() - at < READ_MS) return Promise.resolve(data);
+  loading = pmGet('/api/my-work').then((j) => {
+    loading = null;
+    at = Date.now();
+    data = j && j.ok ? j : { ok: false, error: (j && j.error) || 'My work could not be read.', items: [], counts: { brief: 0, agents: 0, ready: 0, yours: 0, done: 0, all: 0 }, banner: [] };
+    for (const fn of subs) { try { fn(data); } catch (e) { console.error('[pm] my-work reader failed:', e); } }
+    if (typeof window !== 'undefined') window.dispatchEvent(new CustomEvent('pmos:mywork', { detail: { brief: data.ok ? data.counts.brief : 0 } }));
+    return data;
+  });
+  return loading;
+}
+
+/** Call `fn(answer)` on each new answer. Returns the function that stops it. */
+export function onMyWork(fn) { subs.add(fn); return () => subs.delete(fn); }

package/workspace/public/pm/registry.js

@@ -45,6 +45,8 @@ import { empty, ensureComponentsCss } from './primitives.js';
 
 export const DESTINATIONS = Object.freeze([
   Object.freeze({ id: 'today', label: 'Agenda', key: 'g t', module: 'dest-today.js', run: 3 }),
+  // Not a pm-os-absorb run (run: null): initiative my-work added it — the work assigned to the PM, ranked and briefed.
+  Object.freeze({ id: 'mywork', label: 'My work', key: 'g w', module: 'dest-mywork.js', run: null }),
   Object.freeze({ id: 'initiatives', label: 'Initiatives', key: 'g i', module: 'dest-initiatives.js', run: 2 }),
   Object.freeze({ id: 'board', label: 'Board', key: 'g b', module: 'dest-board.js', run: 4 }),
   Object.freeze({ id: 'reports', label: 'Reports', key: 'g r', module: 'dest-reports.js', run: 5 }),
@@ -58,6 +60,7 @@ export const EXTENSIONS = Object.freeze([
   'provider-cards.js',         // the base: every needs provider's rows as Today cards (Run 3, 3B, owns it after)
   'bd-timeline.js',            // Run 4 (4B): Breakdown › Timeline
   'initiatives-timeline.js',   // Run 4 (4C): Initiatives › Timeline
+  'my-work-card.js',           // initiative my-work: Agenda's one card for the items that need a brief
 ]);
 
 const loaded = {};        // module file name -> the module