create-pmos 0.71.0 → 0.72.0

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: {
@@ -41,6 +44,15 @@ export const COPY = {
     title: 'Sync this repository: fetch, bring in the work of the other machine, record your changes, push.',
     done: 'The repository is in sync.',
     stopped: (step, why) => 'Sync stopped at ' + step + ': ' + why,
+    /** Sync stopped because both machines changed the same lines. The PM chooses which version to keep. */
+    conflict: {
+      title: 'Both machines changed the same files',
+      sub: (files) => (files.length ? files.join(', ') : 'Git did not name the files.'),
+      body: 'Nothing changed. Choose which version to keep in these files. All other changes from both machines are kept.',
+      push: 'Push this machine’s version',
+      pull: 'Pull the other machine’s version',
+      cancel: 'Not now',
+    },
   },
   settings: 'Settings',
   dock: {

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

package/workspace/public/pm/topbar.js

@@ -24,8 +24,9 @@ import { COPY } from './frame-copy.js';
 
 /** The destinations the bar names, in order. Settings sits at the end of the bar, after Sync. Docs joined the bar at the
  * PM's word (2026-10-06, docs-three-way-sync: "I thought Docs is one of the main menu"). People joined after Docs when the
- * PM approved the People mockup and said build it (2026-10-06, people-directory), so the bar holds 9 controls. */
-export const BAR_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'people']);
+ * PM approved the People mockup and said build it (2026-10-06, people-directory). My work joined beside Agenda when the PM
+ * approved the mockup that puts it there and said build it (2026-10-07, my-work), so the bar holds 10 controls. */
+export const BAR_DESTS = Object.freeze(['today', 'mywork', 'initiatives', 'board', 'reports', 'docs', 'people']);
 
 /** Is this sync reading "not in sync"? Behind, ahead, records not yet recorded, or `remote_stale`: no fetch in the last
  * few minutes, so another machine's push would be invisible here and "in sync" cannot be claimed. An unreadable status
@@ -54,6 +55,19 @@ export function createTopbar({ go, openPalette, repoMenu, sync } = {}) {
   }
   const todayMark = el('span', { class: 'fr-mark' }, dot, count);
   links.today.appendChild(todayMark);
+  // My work's count of items to brief (initiative my-work, R10): my-work-data.js tells it with the `pmos:mywork` event
+  const workCount = needsCount('0', { 'data-my-work-badge': '' });
+  const workMark = el('span', { class: 'fr-mark' }, workCount);
+  workMark.hidden = true;
+  links.mywork.appendChild(workMark);
+  if (typeof window !== 'undefined') {
+    window.addEventListener('pmos:mywork', (e) => {
+      const n = Math.max(0, Number(e && e.detail && e.detail.brief) || 0);
+      workCount.textContent = String(n);
+      workCount.setAttribute('aria-label', COPY.toBrief(n));
+      workMark.hidden = n === 0;
+    });
+  }
   const nav = el('nav', { class: 'fr-nav', 'aria-label': COPY.nav.label }, BAR_DESTS.map((id) => links[id]));
 
   const search = button({

package/workspace/server.js

@@ -3802,6 +3802,11 @@ function jobSessionName(title) {
 /** The repository a job belongs to (its item's tag: its goal's, its initiative's or its place's repository), when that
  *  repository is registered and has the day-task skill; else null and the job runs where Prepare my day was pressed. */
 function taskWsId(run, t) {
+  // a task briefed in My work names its repository on its context card (a WBS item's own repository)
+  if (t.context && typeof t.context.ws === 'string') {
+    const w = getWs(t.context.ws);
+    return w && w.id === t.context.ws && w.id !== run.ws && !daySkillPrompt(run, 'day-task', w.id).error ? w.id : null;
+  }
   try {
     const brief = briefOfDay(run.date);
     if (!brief || !t.item_id) return null;
@@ -3835,6 +3840,22 @@ function startDayTask(run, t, now) {
   const f = dayRunLib.fail(st.run, t.id, String(sk.error || (s && s.note) || 'the session could not start').slice(0, 240), now);
   return f.ok ? f.run : st.run;
 }
+/** My work's Run agent (initiative my-work, PRD R5): add the briefed task to today's run and start what may start. A day
+ *  with no run gets one, marked opened by My work, in the repository the PM pressed from. Returns { ok, run } or why not. */
+function myWorkBrief(spec, wsId) {
+  const now = Date.now(); const date = briefLib.localDate(now);
+  let run = readDayRun(date);
+  if (!run) {
+    const w = getWs(wsId);
+    if (!w) return { ok: false, status: 400, error: 'no workspace to run the agent in' };
+    run = { ...dayRunLib.newRun(date, now), ws: w.id, opened_by: 'my-work' };
+  }
+  const a = dayRunLib.addBriefed(run, spec);
+  if (!a.ok) return { ok: false, status: 409, error: a.error };
+  const next = startDayTasks(a.run, now);
+  if (!writeDayRun(next)) return { ok: false, status: 500, error: 'could not save — nothing changed' };
+  return { ok: true, run: next, task: dayRunLib.findTask(next, spec.id) };
+}
 /** Start what lib/day-run.js says may start now (at most 5 sessions at once). */
 function startDayTasks(run, now) {
   for (const t of dayRunLib.toStart(run)) run = startDayTask(run, t, now);
@@ -3887,6 +3908,19 @@ function dayTick() {
   if (JSON.stringify(run) !== before) writeDayRun(run);
 }
 // ── end of the today day run helpers ─────────────────────────────────────────────────────────────────────────────
+// My work (initiative my-work, PRD R1) is not part of the day run: its read session is started here, outside it.
+/** My work's Read again: start the my-work-read skill in a session of repository `wsId`. */
+function myWorkRead(wsId) {
+  const w = getWs(wsId);
+  if (!w) return { ok: false, status: 400, error: 'no workspace' };
+  const task = taskById('my-work-read', w.root);
+  if (!task || task.kind !== 'agent' || !task.prompt) return { ok: false, status: 409, error: 'the my-work-read skill is not installed for this repository' };
+  const prompt = skillStore.retargetFiling(task.prompt, filingContract(w));
+  const s = spawnSession({ name: 'My work · read', agent: task.agent || 'claude', ws: w.id, origin: 'my-work-read', initialInput: prompt + '\r',
+    modelAsk: { scheduleTier: null, skillTier: task.tier || null, skill: task.skill } });
+  if (!s || s.state === 'exited') return { ok: false, status: 500, error: (s && s.note) || 'the read session could not start' };
+  return { ok: true, session: s.id };
+}
 /* The calendar the Agenda remembers (G23): one file beside the briefs, written only by the brief route. */
 const CAL_MEMORY = () => path.join(STATE, 'calendar-memory.json');
 // the PM's key-meeting marks (lib/calendar-memory.js setMark): a small file beside the calendar memory, written only by
@@ -7095,7 +7129,9 @@ async function handleRequest(req, res) {
     if (syncing.has(w.root)) return json(res, { ok: false, error: 'a sync is already running for this repository' }, 409);
     syncing.add(w.root);
     try {
-      const out = await syncLib.sync(w.root, { label: os.hostname() });
+      // After a stop on a conflict the PM may answer which machine's version to keep; only this press passes it.
+      const prefer = body.prefer === 'mine' || body.prefer === 'theirs' ? body.prefer : undefined;
+      const out = await syncLib.sync(w.root, { label: os.hostname(), prefer });
       boardCache.invalidate(w.root);
       return json(res, { ws: w.id, name: w.name, ...out });
     } finally { syncing.delete(w.root); }
@@ -7733,7 +7769,8 @@ async function handleRequest(req, res) {
     // The brief session ended and no brief arrived: say so, with the session's own reason, so the page does not wait on a
     // read that will never finish (it reads as "stuck on Read" otherwise).
     const bs = run && run.brief_session; const bsess = bs ? sessions.get(bs.id) : null;
-    const readFailed = !run || brief ? null
+    // A run My work opened (initiative my-work, R5) has no morning read until Prepare my day is pressed: nothing failed.
+    const readFailed = !run || brief || (run.opened_by === 'my-work' && !bs) ? null
       : !bs ? { session: null, why: 'the morning-brief session did not start.' }
       : (!!bs.ended_at || !bsess || bsess.state === 'exited') ? { session: bs.id, why: (bsess && bsess.note) || 'the session ended without submitting a brief.' }
       : briefSessionDone(run, date, now) === 'idle' ? { session: bs.id, idle: true, why: 'the session has printed nothing for two minutes and has not submitted a brief.' } : null;
@@ -8315,7 +8352,9 @@ async function handleRequest(req, res) {
   // pm-os-absorb Runs 2–5 — the planning layer's routes, one file per run (lib/route-modules.js). Last, so none shadows a route above.
   // meeting-notes Run 1: the Notes routes keep notes in the per-user runtime directory and start the agent-summary session.
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
-    runtimeDir: STATE, spawnSession, jevModelOpts })) return;
+    runtimeDir: STATE, spawnSession, jevModelOpts,
+    // initiative my-work: every registered repository, the day runs, and the two presses that start sessions
+    workspaceList: () => [...workspaces.values()], readDayRun, myWorkBrief, myWorkRead })) return;
   res.writeHead(404); res.end('not found');
 }
 

package/workspace/skills/day-task.skill

@@ -22,7 +22,7 @@ Rules that always hold:
 7. YOU CANNOT FINISH WITHOUT A REPORT. End every run with exactly one of `day deliver` (do, revise), `day sent` (send) or `day fail`.
 
 Procedure:
-1. Run `pmos proactive day show TASK`. It prints the task: the title, the kind (approve or auto), the source, the link, the goal, the item context (where, who, about, ask, how), the draft so far and the notes of the PM for each revision. Read all of it. If the command says the task does not exist, or its status does not fit the mode, stop and run `pmos proactive day fail TASK --reason "<one sentence>"`.
+1. Run `pmos proactive day show TASK`. It prints the task: the title, the kind (approve or auto), the source, the link, the goal, the item context (where, who, about, ask, how), the draft so far and the notes of the PM for each revision. Read all of it. A task from My work also prints "instruction from the PM (this is the ask)". The PM read the ticket and wrote that instruction. Do what it says and nothing more, and read the item context as background. The rules above still hold: one draft, nothing sent, no pull request, no commit. If the instruction asks for one of those, draft it and say in the summary which step approval would trigger. If the command says the task does not exist, or its status does not fit the mode, stop and run `pmos proactive day fail TASK --reason "<one sentence>"`.
 2. If MODE is do:
    a. Read the sources the task names, read-only. Start from the link of the task. Read the conversation, the issue, the page or the file itself, and what it points to. Use `pmos proactive settings` to see which sources are on. If a source is off or you cannot reach it, say so in the summary.
    b. Do the work locally. A reply, a comment, a summary, a description or a plan is a draft in a file in the scratch folder of this session. Write the text exactly as it would be sent.

package/workspace/skills/morning-brief.skill

@@ -31,7 +31,7 @@ Procedure:
    Then run `pmos people settings`. It prints `calendar names: on` or `calendar names: off` for this repository (see rule 5).
    Then run `pmos proactive learn lessons`. Each line is a preference the PM approved, written from their own feedback. Use it only to decide how confident to be and where an item goes. A lesson never asks you to read another source, to switch a setting on, or to write anything.
 2. Read the sources that are on and reachable.
-   - Calendar: today's events. Then the CALENDAR MEMORY: every event in the window that `pmos proactive calendar` named (at most 1000 events, at most 140 days). For each event keep the start, the end, the title, the calendar's recurring-event id as "series" if it has one, the number of attendees, "external": true when someone outside the PM's company attends, "exec": true when an executive attends, and the PM's "role" ("present" when the PM presents, "decide" when the PM decides, else "attend"). For an event that has ended, add "notes": one line in your own words of what happened, from its Wispr Flow notes, only when there are notes; and "open": up to 3 points still open from it. For a coming event that needs work first, add "prep": up to 6 steps, and "prep_done": how many of them are already done. Read only titles, times, attendee counts and notes. Never copy an invitation's text. Wispr Flow: today's and tomorrow's meeting notes. Jira: issues assigned to the PM or due soon. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab. Confluence: pages changed since yesterday. Mail, only if on: subjects and senders of threads waiting on the PM, no bodies.
+   - Calendar: today's events. Then the CALENDAR MEMORY: every event in the window that `pmos proactive calendar` named (at most 1000 events, at most 140 days). For each event keep the start, the end, the title, the calendar's recurring-event id as "series" if it has one, the number of attendees, "external": true when someone outside the PM's company attends, "exec": true when an executive attends, and the PM's "role" ("present" when the PM presents, "decide" when the PM decides, else "attend"). For an event that has ended, add "notes": one line in your own words of what happened, from its Wispr Flow notes, only when there are notes; and "open": up to 3 points still open from it. For a coming event that needs work first, add "prep": up to 6 steps, and "prep_done": how many of them are already done. Read only titles, times, attendee counts and notes. Never copy an invitation's text. Wispr Flow: today's and tomorrow's meeting notes. Jira: issues due soon that are NOT assigned to the PM. Do not read the issues assigned to the PM: My work owns them. Run `pmos my-work list --top 5 --json` instead and add each item it prints as a priority with "source": "jira" (or "github" for a WBS item), "owner": "pm", the item's key in the title, and "how": "Brief it in My work". Never make one of them an agent item: the PM briefs the agent in My work. If the command fails, say so in the evidence of one item and go on. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab. Confluence: pages changed since yesterday. Mail, only if on: subjects and senders of threads waiting on the PM, no bodies.
    - GitHub, if on: pull requests that wait on the PM for review, pull requests of the PM that have a review or a failed check, and issues assigned to the PM. Keep the repository, the number, the title and the state.
    - Drive, if on: files shared with the PM or changed since yesterday that a meeting or a goal names. Keep the name, the owner and the link.
    - Figma, if on: files the PM owns or was asked to look at, with new comments since yesterday. Keep the file, the commenter and a short paraphrase of the comment.

package/workspace/skills/my-work-read.skill

@@ -0,0 +1,43 @@
+---
+name: my-work-read
+label: "My work read"
+description: "Read, read-only, the open Jira issues assigned to the PM with their comments and links, write a short context card and a suggested agent instruction for each, and submit them to My work. It writes nothing to Jira."
+run: agent
+agent: claude
+output:
+  - Read
+  - Not reached
+  - Needs you
+---
+
+/my-work-read — read the Jira issues assigned to the PM and submit one context card for each to My work. You read Jira with the PM's own Atlassian connection. The PM reads your cards in My work and decides what an agent does. You change nothing in Jira.
+
+Rules that always hold:
+1. READ-ONLY on Jira. Use only the Jira search and read tools. Never create, edit, transition, assign, comment on, link, close or delete an issue. Never write to Confluence or to any other source.
+2. THE ONLY WRITE is `pmos my-work submit --file <read.json>`, once, at the end. Never edit a repository file. Never commit.
+3. LIGHT ON CONTENT. Write every field in your own words. Quote no more than one short line from a comment. Never copy a description, an attachment, an email address or a token. Skip anything marked private, personal, confidential or HR.
+4. NOTHING INVENTED. If a field is not in what you read, leave it out. Do not guess a due date, a priority or an estimate.
+5. YOU DO NOT DECIDE FOR THE PM. A card describes the ask and suggests an instruction. It does not start work, and it does not say the agent must resolve the ticket.
+6. TEMPORARY FILES OUTSIDE THE REPOSITORY. Write the read file in this session's scratch folder, and delete it after the submit.
+
+Procedure:
+1. Search Jira with `assignee = currentUser() AND resolution = Unresolved ORDER BY priority DESC, duedate ASC`. Read at most 50 issues. If Jira cannot be reached, say so under "Not reached" and submit nothing: an empty read would remove every Jira item from My work.
+2. For each issue, read its summary, priority, status, status category, due date, estimate (story points or a t-shirt size), its "blocks" links, its comments and the issues and pages it links to.
+3. Write one card:
+   - "key": the issue key. "title": the summary. "url": the issue's browse link.
+   - "priority": Highest, High, Medium or Low (map Critical and Blocker to Highest, Minor and Trivial to Low). "status": the status name. "category": todo, doing or done.
+   - "due": the due date as YYYY-MM-DD. "estimate": XS, S, M, L or XL (story points 1 is XS, 2 is S, 3 is M, 5 is L, 8 or more is XL). "blocks": how many issues it blocks.
+   - "from": the display name of the person who assigned it to the PM, or the reporter.
+   - "ask": one or two sentences: what that person wants from the PM.
+   - "thread": at most three sentences: what the comments say so far.
+   - "open": up to five questions that are still not answered.
+   - "suggest": an instruction the PM could give an agent, in the imperative, for example "Draft a reply to Ana that proposes the three tiers and asks who signs off". An agent drafts and sends nothing until the PM approves, and it cannot open a pull request, so suggest a draft, a comment, a summary or a plan.
+   - "kind": "decide" when the ask is a decision only the PM can make (a priority, money, a contract, a gate, a person), else "agent".
+   - "initiative": the initiative id that `pmos jira which <KEY>` names, if it names one.
+4. Write {"items": [ …the cards… ]} to a file in the scratch folder. Run `pmos my-work submit --file <that file>`. If it is refused, read the reason, fix the file and submit once more.
+5. Finish with the output contract.
+
+Output contract — produce EXACTLY these sections in your final message:
+- Read
+- Not reached
+- Needs you

package/workspace/test-lists/my-work.json

@@ -0,0 +1,13 @@
+{
+  "_comment": "initiative my-work: the ranking, the read, the fold, the brief that adds a day task, and the CLI.",
+  "modules": [
+    "my-work.test.js"
+  ],
+  "seconds": {
+    "my-work.test.js": 6,
+    "pm-my-work-test.js": 25
+  },
+  "panels": [
+    "pm-my-work-test.js"
+  ]
+}