create-pmos 0.57.0 → 0.58.0

package/workspace/public/pm/sheet-jira.js

@@ -0,0 +1,353 @@
+/* pm/sheet-jira.js — the initiative sheet's Jira tickets tab (initiative jira-wbs, PRD J3 to J12, proposed D88).
+ *
+ * mountJira(panel, { ws, slug }) draws the tab into the sheet's panel; unmountJira(panel) stops its polling. It follows
+ * the mockup the PM reviewed (version 9):
+ *   locked     until the handoff is done in a document repository that hands off (the server decides: gate.open)
+ *   list       the epic, "n of m in Jira · Checked … · Check now", then ONE list: a row per ticket with its summary,
+ *              "TD-01 · ATL-491 · Task · High · S", its status and sprint in Jira, subtasks n of m and one flag. A
+ *              checkbox on each ticket that can be pushed; one primary button, Push N to Jira.
+ *   detail     any row opens the ticket: its fields (selects), its Jira status with Open in Jira, the PRD's version
+ *              beside the ticket's when the PRD changed, and the full text. Edit text edits the summary and sections.
+ * Everything it shows comes from GET /api/jira/tickets; every write is a POST under /api/jira/. Push is a PM-only press
+ * on the server (pm-guard act `push`): it records the selection and starts one agent session. Nothing here talks to
+ * Jira: that session does, with the PM's own connection.
+ */
+
+import { el } from './dom.js';
+import { button, row, field, toast, empty, signal, ensureComponentsCss } from './primitives.js';
+import { ensureSprite } from './icons.js';
+import { pmGet, pmPost } from './http.js';
+import { mdRender } from './markdown.js';
+
+export const COPY = Object.freeze({
+  reading: 'Reading…',
+  readError: (why) => `The Jira tickets could not be read: ${why}`,
+  locked: 'Jira tickets open when the handoff is done. Mark the Handoff item done in the Breakdown.',
+  noItems: 'The PRD has no ticket items yet. Add a "User stories" or "Tickets" section to it, one heading per ticket, such as "### TD-01 · Title".',
+  noDraft: (n) => `No tickets yet. The PRD has ${n} ticket ${n === 1 ? 'item' : 'items'}.`,
+  draft: 'Draft tickets',
+  drafted: (n) => `Drafted ${n} ${n === 1 ? 'ticket' : 'tickets'}. Read them before you push.`,
+  newInPrd: (n) => `${n} new ${n === 1 ? 'item' : 'items'} in the PRD.`,
+  addNew: 'Add to tickets',
+  epic: 'Epic',
+  epicNew: (t) => `Create new: ${t}`,
+  epicExisting: 'Use an existing epic',
+  epicLink: 'Epic link or key',
+  epicPaste: 'Paste the epic link or key',
+  epicIs: (k) => `Epic ${k}`,
+  epicLater: 'Epic created at the first push',
+  inJira: (n, m) => `${n} of ${m} in Jira`,
+  checked: (iso) => 'Checked ' + ago(iso),
+  never: 'Not checked yet',
+  checkNow: 'Check now',
+  checking: 'Checking…',
+  checkStarted: 'Check started. It reads Jira and changes nothing there.',
+  push: (n) => `Push ${n} to Jira`,
+  pushing: 'Pushing…',
+  pushStarted: (n) => `Pushing ${n} ${n === 1 ? 'ticket' : 'tickets'}. An agent session creates them with your Jira connection.`,
+  pick: 'Push',
+  pickLabel: (id) => `Select ${id} for the push`,
+  notInJira: 'Not in Jira',
+  notChecked: 'Not checked yet',
+  backlog: 'Backlog',
+  sprint: { active: 'Active sprint', future: 'Next sprint', closed: 'Closed sprint' },
+  subtasks: (d, t) => `Subtasks ${d} of ${t}`,
+  stale: 'Not in the last check',
+  flag: {
+    'prd-changed': 'PRD changed', removed: 'Removed from PRD', blocked: 'Blocked', incomplete: 'Missing text',
+    pushing: 'Waiting for the push', edited: 'Edited, not in Jira yet',
+  },
+  newRow: 'New in PRD',
+  open: (s) => `Open ${s}`,
+  back: 'All tickets',
+  editText: 'Edit text',
+  save: 'Save',
+  cancel: 'Cancel',
+  saved: 'Saved.',
+  pushOne: 'Push to Jira',
+  updateOne: 'Update in Jira',
+  type: 'Type',
+  priority: 'Priority',
+  estimate: 'Estimate',
+  depends: 'Depends on',
+  none: 'None',
+  summary: 'Summary',
+  openJira: 'Open in Jira',
+  missing: (list) => `Missing: ${list.join(', ')}. Add it with Edit text before you push.`,
+  removedNote: 'This item is no longer in the PRD. Jira is not changed.',
+  prdTitle: 'The PRD changed since this ticket was drafted.',
+  thisTicket: 'This ticket',
+  prdNow: 'The PRD now',
+  usePrd: 'Use the PRD version',
+  keep: 'Keep the ticket as it is',
+  usedPrd: 'The ticket now matches the PRD.',
+  kept: 'The ticket is kept as it is.',
+  empty: '—',
+});
+
+function ago(iso) {
+  if (!iso) return 'never';
+  const m = Math.round((Date.now() - Date.parse(iso)) / 60000);
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m} min ago`;
+  if (m < 48 * 60) return `${Math.round(m / 60)} h ago`;
+  return `${Math.round(m / 1440)} days ago`;
+}
+const POLL_MS = 5000;
+const live = new WeakMap();   // panel → the mounted instance
+
+/** Where the ticket is in Jira, in words: "In Progress · Active sprint: Sprint 4". */
+function whereText(t) {
+  if (!t.inJira) return COPY.notInJira;
+  if (!t.jira) return COPY.notChecked;
+  const j = t.jira;
+  const sprint = j.category === 'done' ? null : (j.sprint ? `${COPY.sprint[j.sprint.state] || 'Sprint'}: ${j.sprint.name}` : COPY.backlog);
+  return [j.status, sprint].filter(Boolean).join(' · ');
+}
+function flagSignal(t) {
+  if (!t.flag) return null;
+  const tone = t.flag === 'blocked' || t.flag === 'prd-changed' ? 'destructive' : t.flag === 'pushing' ? 'muted' : 'warning';
+  const text = t.flag === 'blocked' && t.jira && t.jira.reason ? `${COPY.flag.blocked}: ${t.jira.reason}` : COPY.flag[t.flag];
+  return signal({ text, tone, attrs: { 'data-jira-flag': t.flag } });
+}
+
+export function unmountJira(panel) {
+  const inst = live.get(panel);
+  if (!inst) return;
+  inst.gone = true;
+  clearTimeout(inst.timer);
+  live.delete(panel);
+}
+
+export function mountJira(panel, { ws, slug }) {
+  unmountJira(panel);
+  ensureComponentsCss();
+  ensureSprite();
+  const inst = { gone: false, timer: null, data: null, picked: new Set(), open: null, editing: false };
+  live.set(panel, inst);
+  const root = el('div', { class: 'in-jira', 'data-jira': slug });
+  panel.replaceChildren(root);
+  root.replaceChildren(empty({ text: COPY.reading }));
+
+  const post = (verb, body) => pmPost('/api/jira/' + verb, { ws, initiative: slug, ...body });
+  const say = (out, okText) => {
+    if (out && out.ok) { if (okText) toast({ text: okText }); return true; }
+    toast({ text: (out && out.error) || 'That did not work.', tone: 'destructive' });
+    return false;
+  };
+
+  async function load() {
+    const out = await pmGet('/api/jira/tickets?ws=' + encodeURIComponent(ws || '') + '&initiative=' + encodeURIComponent(slug));
+    if (inst.gone) return;
+    if (!out || !out.ok) { root.replaceChildren(empty({ text: COPY.readError((out && out.error) || 'no answer') })); return; }
+    inst.data = out;
+    const can = new Set(out.tickets.filter((t) => t.selectable).map((t) => t.id));
+    for (const id of [...inst.picked]) if (!can.has(id)) inst.picked.delete(id);
+    draw();
+    clearTimeout(inst.timer);
+    if (out.pushing || out.checking) inst.timer = setTimeout(load, POLL_MS);
+  }
+
+  function draw() {
+    const d = inst.data;
+    if (!d) return;
+    if (!d.gate.open) { root.replaceChildren(empty({ text: COPY.locked, attrs: { 'data-jira-locked': '' } })); return; }
+    const t = inst.open && d.tickets.find((x) => x.id === inst.open);
+    if (t) { root.replaceChildren(...detail(t)); return; }
+    inst.open = null;
+    root.replaceChildren(...list());
+  }
+
+  /* ── the list ───────────────────────────────────────────────────────────────────────────────────────────────── */
+
+  function draftButton(label, variant) {
+    return button({ label, variant, size: 'sm', attrs: { 'data-jira-draft': '' }, onClick: async () => {
+      const out = await post('draft');
+      if (say(out, out && out.ok ? COPY.drafted(out.changes.filter((c) => c.what === 'added').length || out.tickets) : null)) load();
+    } });
+  }
+
+  function epicLine() {
+    const d = inst.data;
+    const e = d.epic;
+    if (e.locked) return el('span', { class: 'in-jira-epic__text', 'data-jira-epic': e.key || '' }, e.key ? COPY.epicIs(e.key) : COPY.epicLater);
+    const kids = [field({
+      label: COPY.epic, kind: 'select', value: e.mode, attrs: { 'data-jira-epic-mode': '' },
+      options: [{ value: 'new', label: COPY.epicNew(d.title) }, { value: 'existing', label: COPY.epicExisting }],
+      onCommit: async (v) => {
+        if (v === 'new') { if (say(await post('epic', { mode: 'new' }))) load(); return; }
+        inst.data.epic = { ...e, mode: 'existing' }; draw();
+      },
+    })];
+    if (e.mode === 'existing') {
+      kids.push(field({
+        label: COPY.epicLink, value: e.key || '', placeholder: COPY.epicPaste, attrs: { 'data-jira-epic-key': '' },
+        onCommit: async (v) => { if (say(await post('epic', { mode: 'existing', key: v }))) load(); },
+      }));
+    }
+    return el('div', { class: 'in-jira-epic' }, kids);
+  }
+
+  function checkLine() {
+    const d = inst.data;
+    const kids = [el('span', { class: 'in-jira-count', 'data-jira-count': '' }, COPY.inJira(d.inJira, d.tickets.length)),
+      el('span', { class: 'in-jira-when' }, d.checkedAt ? COPY.checked(d.checkedAt) : COPY.never)];
+    if (d.checking) kids.push(signal({ text: COPY.checking, attrs: { 'data-jira-checking': '' } }));
+    else if (d.inJira) {
+      kids.push(button({ label: COPY.checkNow, variant: 'ghost', size: 'sm', icon: 'refresh-cw', attrs: { 'data-jira-check': '' }, onClick: async () => {
+        if (say(await post('check'), COPY.checkStarted)) load();
+      } }));
+    }
+    return el('div', { class: 'in-jira-status-line' }, kids);
+  }
+
+  function ticketRow(t) {
+    const lead = [];
+    if (t.selectable) {
+      lead.push(field({
+        label: COPY.pick, kind: 'check', value: inst.picked.has(t.id),
+        attrs: { 'aria-label': COPY.pickLabel(t.id), 'data-jira-pick': t.id },
+        onCommit: (on) => { if (on) inst.picked.add(t.id); else inst.picked.delete(t.id); drawPush(); },
+      }));
+    } else lead.push(el('span', { class: 'in-jira-pick-gap', 'aria-hidden': 'true' }));
+    const meta = [t.id, t.key, t.type, t.priority, t.estimate].filter(Boolean);
+    const sub = t.jira && t.jira.subtasks && t.jira.subtasks.total ? COPY.subtasks(t.jira.subtasks.done, t.jira.subtasks.total) : null;
+    const trail = [el('span', { class: 'in-jira-where', 'data-jira-where': '' }, whereText(t))];
+    if (sub) trail.push(el('span', { class: 'in-jira-sub', 'data-jira-sub': '' }, sub));
+    return row({
+      title: t.summary, meta, signals: [flagSignal(t)], lead, trail,
+      onOpen: () => { inst.open = t.id; inst.editing = false; draw(); },
+      openLabel: COPY.open(t.summary), done: !!(t.jira && t.jira.category === 'done'),
+      attrs: { role: 'listitem', 'data-jira-ticket': t.id }, openAttrs: { 'data-jira-open': t.id },
+    });
+  }
+
+  let pushHost = null;
+  function drawPush() {
+    if (!pushHost) return;
+    const d = inst.data;
+    const n = inst.picked.size;
+    if (d.pushing) { pushHost.replaceChildren(signal({ text: COPY.pushing, attrs: { 'data-jira-pushing': '' } })); return; }
+    pushHost.replaceChildren(button({
+      label: COPY.push(n), variant: 'primary', disabled: n === 0, attrs: { 'data-jira-push': '' },
+      onClick: () => pushIds([...inst.picked]),
+    }));
+  }
+  async function pushIds(ids) {
+    if (!ids.length) return;
+    const out = await post('push', { ids });
+    if (say(out, COPY.pushStarted(ids.length))) { inst.picked.clear(); load(); }
+  }
+
+  function list() {
+    const d = inst.data;
+    if (!d.drafted) {
+      if (!d.items) return [empty({ text: COPY.noItems, attrs: { 'data-jira-empty': '' } })];
+      return [empty({ text: COPY.noDraft(d.items), attrs: { 'data-jira-empty': '' } }), el('div', { class: 'in-jira-actions' }, draftButton(COPY.draft, 'primary'))];
+    }
+    const out = [el('div', { class: 'in-jira-head' }, epicLine(), checkLine())];
+    if (d.newInPrd.length) {
+      out.push(el('div', { class: 'in-jira-note', 'data-jira-new': '' },
+        el('span', { class: 'in-jira-note__text' }, COPY.newInPrd(d.newInPrd.length) + ' ' + d.newInPrd.map((n) => n.id).join(', ')),
+        draftButton(COPY.addNew, 'outline')));
+    }
+    out.push(el('div', { class: 'in-jira-list', role: 'list' }, d.tickets.map(ticketRow)));
+    pushHost = el('div', { class: 'in-jira-actions' });
+    out.push(pushHost);
+    drawPush();
+    return out;
+  }
+
+  /* ── the detail ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+  const md = (text) => {
+    const s = String(text || '').trim();
+    if (!s) return [el('p', { class: 'in-jira-body__empty' }, COPY.empty)];
+    try { return mdRender(s, {}).blocks; } catch { return [el('p', null, s)]; }
+  };
+  const edit = async (id, patch) => { if (say(await post('edit', { id, patch }), COPY.saved)) load(); };
+
+  function fields(t) {
+    const d = inst.data;
+    const opts = (list, withNone) => [...(withNone ? [{ value: '', label: COPY.none }] : []), ...list.map((v) => ({ value: v, label: v }))];
+    return el('div', { class: 'in-jira-fields' },
+      field({ label: COPY.type, kind: 'select', value: t.type, options: opts(d.types), onCommit: (v) => edit(t.id, { type: v }), attrs: { 'data-jira-field': 'type' } }),
+      field({ label: COPY.priority, kind: 'select', value: t.priority, options: opts(d.priorities), onCommit: (v) => edit(t.id, { priority: v }), attrs: { 'data-jira-field': 'priority' } }),
+      field({ label: COPY.estimate, kind: 'select', value: t.estimate || '', options: opts(d.estimates, true), onCommit: (v) => edit(t.id, { estimate: v || null }), attrs: { 'data-jira-field': 'estimate' } }),
+      field({ label: COPY.depends, value: (t.depends || []).join(', '), placeholder: COPY.none, onCommit: (v) => edit(t.id, { depends: v }), attrs: { 'data-jira-field': 'depends' } }));
+  }
+
+  function jiraBox(t) {
+    if (!t.inJira) return null;
+    const j = t.jira;
+    const kids = [el('span', { class: 'in-jira-box__key' }, t.key), el('span', { class: 'in-jira-box__where' }, whereText(t))];
+    if (j && j.subtasks && j.subtasks.total) kids.push(el('span', { class: 'in-jira-box__sub' }, COPY.subtasks(j.subtasks.done, j.subtasks.total)));
+    if (j && j.stale) kids.push(el('span', { class: 'in-jira-box__sub' }, COPY.stale));
+    if (j && j.url) kids.push(el('a', { class: 'in-jira-box__link', href: j.url, target: '_blank', rel: 'noopener noreferrer', 'data-jira-link': '' }, COPY.openJira));
+    return el('div', { class: 'in-jira-box', 'data-jira-box': '' }, kids);
+  }
+
+  function prdBox(t) {
+    if (!t.prd) return null;
+    const d = inst.data;
+    const names = d.sectionNames;
+    const rows = [];
+    if (t.prd.summary !== t.summary) rows.push({ name: COPY.summary, mine: t.summary, theirs: t.prd.summary });
+    for (const s of names) {
+      const a = String(t.sections[s.key] || '').trim(); const b = String(t.prd.sections[s.key] || '').trim();
+      if (a !== b) rows.push({ name: s.name, mine: a, theirs: b });
+    }
+    const side = (label, key) => el('div', { class: 'in-jira-diff__side' },
+      el('span', { class: 'in-jira-diff__label' }, label),
+      ...rows.map((r) => el('div', { class: 'in-jira-diff__part' }, el('span', { class: 'in-jira-diff__name' }, r.name), ...md(r[key]))));
+    return el('div', { class: 'in-jira-diff', 'data-jira-prd': '' },
+      el('p', { class: 'in-jira-diff__title' }, COPY.prdTitle),
+      el('div', { class: 'in-jira-diff__sides' }, side(COPY.thisTicket, 'mine'), side(COPY.prdNow, 'theirs')),
+      el('div', { class: 'in-jira-actions' },
+        button({ label: COPY.usePrd, variant: 'outline', size: 'sm', attrs: { 'data-jira-use': 'prd' }, onClick: async () => { if (say(await post('prd', { id: t.id, use: 'prd' }), COPY.usedPrd)) load(); } }),
+        button({ label: COPY.keep, variant: 'ghost', size: 'sm', attrs: { 'data-jira-use': 'keep' }, onClick: async () => { if (say(await post('prd', { id: t.id, use: 'keep' }), COPY.kept)) load(); } })));
+  }
+
+  function body(t) {
+    const d = inst.data;
+    if (inst.editing) {
+      const summary = field({ label: COPY.summary, kind: 'title', value: t.summary, attrs: { 'data-jira-edit': 'summary' } });
+      const areas = d.sectionNames.map((s) => field({ label: s.name, kind: 'textarea', value: t.sections[s.key] || '', attrs: { 'data-jira-edit': s.key, class: 'in-jira-area' } }));
+      return el('div', { class: 'in-jira-edit' }, summary, ...areas,
+        el('div', { class: 'in-jira-actions' },
+          button({ label: COPY.save, variant: 'primary', attrs: { 'data-jira-save': '' }, onClick: async () => {
+            const sections = {};
+            d.sectionNames.forEach((s, i) => { sections[s.key] = areas[i].control.value; });
+            const out = await post('edit', { id: t.id, patch: { summary: summary.control.value, sections } });
+            if (say(out, COPY.saved)) { inst.editing = false; load(); }
+          } }),
+          button({ label: COPY.cancel, variant: 'ghost', onClick: () => { inst.editing = false; draw(); } })));
+    }
+    return el('div', { class: 'in-jira-body', 'data-jira-body': '' }, d.sectionNames.map((s) => el('section', { class: 'in-jira-body__part' },
+      el('h4', { class: 'in-jira-body__name' }, s.name), ...md(t.sections[s.key]))));
+  }
+
+  function detail(t) {
+    const d = inst.data;
+    const actions = [];
+    if (!inst.editing) actions.push(button({ label: COPY.editText, variant: 'outline', size: 'sm', attrs: { 'data-jira-edit-open': '' }, onClick: () => { inst.editing = true; draw(); } }));
+    if (t.selectable && !inst.editing && !d.pushing) {
+      actions.push(button({ label: t.inJira ? COPY.updateOne : COPY.pushOne, variant: 'primary', size: 'sm', attrs: { 'data-jira-push-one': t.id }, onClick: () => pushIds([t.id]) }));
+    }
+    const notes = [];
+    if (t.missing.length) notes.push(el('p', { class: 'in-jira-warn', 'data-jira-missing': '' }, COPY.missing(t.missing)));
+    if (t.removed) notes.push(el('p', { class: 'in-jira-warn' }, COPY.removedNote));
+    return [
+      el('div', { class: 'in-jira-detail-top' },
+        button({ label: COPY.back, variant: 'ghost', size: 'sm', icon: 'arrow-left', attrs: { 'data-jira-back': '' }, onClick: () => { inst.open = null; inst.editing = false; draw(); } }),
+        el('span', { class: 'in-jira-detail-top__gap' }), ...actions),
+      el('div', { class: 'in-jira-detail', 'data-jira-detail': t.id },
+        el('h3', { class: 'in-jira-detail__title' }, t.summary),
+        el('span', { class: 'in-jira-detail__meta' }, [t.id, t.key].filter(Boolean).join(' · ')),
+        ...notes, fields(t), jiraBox(t), prdBox(t), body(t)),
+    ];
+  }
+
+  load();
+  return { reload: load };
+}

package/workspace/public/pm/topbar.js

@@ -1,6 +1,6 @@
 /* pm/topbar.js — the frame's one top bar (pm-os-absorb Run 3, slice 3A; PRD R9, R10).
  *
- *   Repository ▾ · Today Initiatives Board Reports · ⌘K · Sync (only when unsynced) · Settings
+ *   Repository ▾ · Today Initiatives Board Reports Docs · ⌘K · Sync (only when unsynced) · Settings
  *
  * The bar is built once and updated on every render: app.js calls `bar.update(model)` and the bar changes only what
  * the model changed, so a focused control keeps its focus across a repaint. It holds no state of its own except the
@@ -8,7 +8,7 @@
  * runs `git status` against the remote-tracking ref the last fetch left).
  *
  *   createTopbar({ go, openPalette, repoMenu, sync }) → { node, update(model) }
- *     go(id)              open destination id (today, initiatives, board, reports, settings)
+ *     go(id)              open destination id (today, initiatives, board, reports, docs, settings)
  *     openPalette()       open ⌘K
  *     repoMenu(anchor)    open the Repository menu under `anchor`
  *     sync(repo)          run Sync for `repo`; resolves to the server's answer
@@ -22,8 +22,9 @@ import { el, setChildren } from './dom.js';
 import { button, needsDot, needsCount } from './primitives.js';
 import { COPY } from './frame-copy.js';
 
-/** The destinations the bar names, in order. Settings sits at the end of the bar, after Sync. */
-export const BAR_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports']);
+/** 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"), so the bar holds 8 controls. */
+export const BAR_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs']);
 
 /** 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

package/workspace/server.js

@@ -134,6 +134,12 @@ const docCheckSessions = new Map();
 // The session each Use … version press started (workspace id|path|kind → { session, use }), so the line says "Updating…"
 // before the session has opened its sync, and a second press on the same copy refuses.
 const docSyncSessions = new Map();
+const jiraTickets = require('./lib/jira-tickets.js');   // jira-wbs — the ticket draft, the PM's selection, the push plan
+const jiraStatus = require('./lib/jira-status.js');     // …and the status snapshot an agent's read writes
+// The session each Push or Check now press started (workspace id|initiative → { session, at }), so a second press
+// while it runs refuses and the tab says "Pushing…" or "Checking…".
+const jiraPushSessions = new Map();
+const jiraCheckSessions = new Map();
 const planItems = require('./lib/plan-items.js');      // pm-os-absorb Run 1 — the ONE writer and fold of plan-items.jsonl (control graph)
 const planTree = require('./lib/plan-tree.js');        // …and the Breakdown layout: derived stages, owed rows, the Board columns
 const routeModules = require('./lib/route-modules.js'); // pm-os-absorb Runs 2–5 — each run's routes in its own lib/routes-<name>.js
@@ -2287,6 +2293,9 @@ const SEED_SETS = {
   // bi-weekly draft (Friday 16:00) fires every other week from whichever Friday it was set up, and a weekly refresh is
   // never out of step with it. A refresh that finds no change writes no line.
   tracker: [{ name: 'Tracker refresh', skill: 'tracker-refresh', cadence: 'weekly', day: 'Fri', time: '15:30' }],
+  // jira-wbs (J14): the agent step that reads the status of every pushed Jira ticket into each initiative's snapshot,
+  // read-only. Daily at 06:30, so the morning brief (06:45) and every report read a status at most a day old.
+  jira: [{ name: 'Jira status check', skill: 'jira-sync', cadence: 'daily', time: '06:30' }],
 };
 function readSchedules() {
   try { const a = JSON.parse(fs.readFileSync(schedFile(), 'utf8')); return Array.isArray(a) ? a : []; } catch { return []; }
@@ -6550,6 +6559,66 @@ async function handleRequest(req, res) {
     if (started) docCheckSessions.set(w.id, s.id);
     return json(res, { ok: started, session: s.id, error: started ? undefined : (s.note || 'could not start the session') }, started ? 200 : 500);
   }
+  // ── Jira tickets: the initiative sheet's Jira tickets tab (jira-wbs, PRD J3 to J12, proposed D88) ─────────────────
+  // GET reads the ticket draft, the PRD it came from and the last status snapshot, and decides every flag in
+  // lib/jira-tickets.js. The POSTs write the draft file (draft, edit, epic, prd), or start ONE agent session: Push starts
+  // `jira-push` for the tickets the PM selected (a PM-only press, pm-guard act `push`, which first records the
+  // selection), and Check now starts `jira-sync` for this initiative. No route here reads or writes Jira: the session,
+  // holding the PM's own Atlassian connection, does (D53, D88).
+  if (p === '/api/jira/tickets' && req.method === 'GET') {
+    const w = getWs(url.searchParams.get('ws'));
+    const root = w ? w.root : SELF_ROOT;
+    const id = String(url.searchParams.get('initiative') || '');
+    if (!planItems.INIT_RE.test(id)) return json(res, { ok: false, error: 'name an initiative' }, 400);
+    let v;
+    try { v = jiraTickets.view(root, id, { snapshot: jiraStatus.readSnapshot(root, id) }); }
+    catch (e) { return json(res, { ok: false, error: String((e && e.message) || e).slice(0, 200) }, 500); }
+    if (!v.ok) return json(res, v, v.status || 400);
+    const key = `${w ? w.id : ''}|${id}`;
+    const running = (m) => { const x = m.get(key); return x && sessions.get(x.session) && sessions.get(x.session).state !== 'exited' ? x : null; };
+    return json(res, { ...v, ws: w ? w.id : null, pushing: running(jiraPushSessions), checking: running(jiraCheckSessions) });
+  }
+  if (/^\/api\/jira\/(draft|edit|epic|prd|push|check)$/.test(p) && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const act = p.slice('/api/jira/'.length);
+    const g = act === 'push' ? pmGuard.requirePmPress(req, body, { act: 'push' }) : pmGuard.requirePagePress(req, body);
+    if (!g.ok) return json(res, { ok: false, error: g.error }, g.status);
+    const w = body.ws ? workspaces.get(String(body.ws)) : getWs(null);
+    if (!w) return json(res, { ok: false, error: 'no such workspace' }, 404);
+    const id = String(body.initiative || '');
+    if (!planItems.INIT_RE.test(id) || !jiraTickets.recordFm(w.root, id)) return json(res, { ok: false, error: 'no such initiative' }, 404);
+    const answer = (r) => json(res, r, r.ok ? 200 : (r.status || 400));
+    const key = `${w.id}|${id}`;
+    const busy = (m) => { const x = m.get(key); return !!(x && sessions.get(x.session) && sessions.get(x.session).state !== 'exited'); };
+    try {
+      if (act === 'draft') return answer(jiraTickets.draft(w.root, id));
+      if (act === 'edit') return answer(jiraTickets.edit(w.root, id, String(body.id || ''), body.patch));
+      if (act === 'epic') return answer(jiraTickets.setEpic(w.root, id, { mode: body.mode, key: body.key }));
+      if (act === 'prd') return answer(jiraTickets.resolvePrd(w.root, id, String(body.id || ''), String(body.use || '')));
+      const start = (skill, name, origin, ask, map) => {
+        const task = taskById(skill, w.root);
+        if (!task || !task.prompt) return json(res, { ok: false, error: `the ${skill} skill is not installed` }, 500);
+        const s = spawnSession({ name, agent: task.agent || 'claude', ws: w.id, origin,
+          initialInput: task.prompt + ask + '\r', modelAsk: { skillTier: task.tier || null, skill: task.skill } });
+        const started = s.state !== 'exited';
+        if (started) map.set(key, { session: s.id, at: new Date().toISOString() });
+        return json(res, { ok: started, session: s.id, error: started ? undefined : (s.note || 'could not start the session') }, started ? 200 : 500);
+      };
+      if (act === 'push') {
+        if (busy(jiraPushSessions)) return json(res, { ok: false, error: 'a push is already running for this initiative' }, 409);
+        const ids = Array.isArray(body.ids) ? body.ids.map(String).slice(0, 200) : [];
+        const r = jiraTickets.approve(w.root, id, ids);
+        if (!r.ok) return answer(r);
+        return start('jira-push', 'Push to Jira', 'jira:push', `\n\nThis push:\n- initiative: ${id}\n- tickets: ${r.approved.join(', ')}`, jiraPushSessions);
+      }
+      if (busy(jiraCheckSessions)) return json(res, { ok: false, error: 'a check is already running for this initiative' }, 409);
+      const q = jiraStatus.queryFor(w.root, id);
+      if (!q.ok || !q.linked) return json(res, { ok: false, error: 'no ticket of this initiative is in Jira yet — push one first' }, 409);
+      return start('jira-sync', 'Jira status check', 'jira:check', `\n\nThis check:\n- initiative: ${id} (this one only)`, jiraCheckSessions);
+    } catch (e) {
+      return json(res, { ok: false, error: String((e && e.message) || e).slice(0, 200) }, 500);
+    }
+  }
   if (p === '/api/initiative/link' && req.method === 'POST') {
     // Recording that an artifact corresponds to an external page. This writes a DECLARATION and
     // makes no request: PMOS holds no credential, so it can state what the PM says the mapping is

package/workspace/skills/day-check.skill

@@ -25,7 +25,7 @@ Procedure:
 1. Run `pmos proactive day`. It shows the stage, the tasks, and the check state (when the last check was, and why this one runs). Run `pmos proactive brief` to read the stored brief: its items with their ids, its events with their ids, and its digests. Run `pmos proactive settings` for the sources, the scopes and the websites. Run `pmos proactive goals` for the goal ids.
 2. Read what changed, from the sources that are on and reachable:
    - Calendar: today's events. Note a new event, a moved one, a cancelled one, and a new link or agenda in one.
-   - Mentions of the PM since the last check, in Slack, Jira and Confluence, in every place that is not ignored. Keep where, who, the link to the conversation itself and a short paraphrase of what is asked.
+   - Mentions of the PM since the last check, in Slack, Jira and Confluence, in every place that is not ignored. Keep where, who, the link to the conversation itself and a short paraphrase of what is asked. 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.
    - Places with scope watch: read every message or comment since the last check. Update the digest of the place (decisions, open questions, what touches a goal). A digest you submit replaces the stored digest of that place, so carry over what still holds.
    - GitHub, Drive, Figma and websites, if on: only what changed since the last check and matters to a goal or a meeting.
    - Wispr Flow: notes for meetings that ended since the last check. Read the summary, the decisions and the actions. Read the related mail for the same meeting only if mail is on, and keep the subject, the sender and a gist.

package/workspace/skills/gather-requirements.skill

@@ -29,7 +29,7 @@ Procedure (each step ends with a check that shows it is done):
    Done when: the target path is named, and an existing file is still intact.
 2. Read the previous note in that folder to learn the cutoff. With no previous note, look back 3 days.
    Done when: you can state the cutoff as a date and time.
-3. Read the initiatives in `<state>/initiatives/` (or `planning/initiatives/`) so you can say which one an item touches. Match by what the item is about, not by keyword.
+3. Read the initiatives in `<state>/initiatives/` (or `planning/initiatives/`) so you can say which one an item touches. Match by what the item is about, not by keyword. For a Jira issue, run `pmos jira which <KEY>` first: when it names an initiative, use it. A status change of such an issue is not a requirement; the Jira status check records it.
    Done when: you have the list of initiative ids that an item can name.
 4. For each source you can reach, read what changed since the cutoff: mail, chat, Jira, Confluence, calendar events with their notes, meeting notes.
    Done when: each source kind is either read or marked not reached.

package/workspace/skills/jira-push.skill

@@ -0,0 +1,38 @@
+---
+name: jira-push
+label: "Push to Jira"
+description: "Create or update in Jira the tickets the PM selected on an initiative's Jira tickets tab, with the PM's own Atlassian connection, and record their keys in PMOS. Only selected tickets are sent."
+run: agent
+agent: claude
+output:
+  - Created
+  - Updated
+  - Not sent
+  - Needs you
+---
+
+/jira-push — send the tickets the PM selected to Jira. PMOS drafted them from the PRD in the PM's ticket template, and the PM selected the ones that are ready. You create or update exactly what `pmos jira pending` lists, with the PM's own Atlassian connection, and you tell PMOS the keys.
+
+Rules that always hold:
+1. SELECTED TICKETS ONLY. Send to Jira only what `pmos jira pending` lists. A ticket it does not list was not selected, or changed after it was selected: leave it. Never select a ticket yourself: only the PM selects, with Push on the tab or `pmos jira approve` in their own terminal.
+2. CREATE, UPDATE AND LINK ONLY. Create the epic and the tickets `pmos jira pending` lists under create, and update the summary, description, issue type and priority of the tickets it lists under update. Add an "is blocked by" link for each key in `blocked_by`. Never transition, assign, comment on, close or delete an issue.
+3. THE TEXT AS GIVEN. Use the summary, description, issue type, priority and labels exactly as `pmos jira pending <initiative> --json` gives them. The description is markdown: keep its headings and lists. Do not rewrite it.
+4. RECORD EVERY KEY. After each create, run `pmos jira record` with the key Jira returned, so a second run never creates the same ticket twice. After updates, record them with `--updated`.
+5. NO REPOSITORY EDITS. The only writes in PMOS are `pmos jira record` and, at the end, `pmos jira sync`. Never edit the ticket draft or any file by hand. Never commit.
+
+Procedure:
+1. Take the initiative from the task ("This push: initiative …"), else ask the PM. Run `pmos jira pending <initiative> --json`. If it lists nothing to create or update, say so under "Needs you" and stop.
+2. Find the Jira project: the project of the epic key when the plan names one. Otherwise ask the PM for the project key before you create anything.
+3. If the plan's epic has no key, create the epic from `epic.create`. Then run `pmos jira record <initiative> --epic <KEY>`.
+4. For each ticket under `create`: create it in that project with its summary, description, issue type, priority and labels, as a child of the epic (the parent field). If the project has no such issue type or priority, use the nearest one and say which under "Needs you". Then run `pmos jira record <initiative> <ticket>=<KEY>`, for example `pmos jira record checkout TD-01=ATL-491`.
+5. For each ticket under `update`: update its summary, description, issue type and priority in Jira. Then run `pmos jira record <initiative> --updated <ticket>[,<ticket>]`.
+6. For each pushed ticket with `blocked_by`: link it as "is blocked by" each key there. A `blocked_by` entry with no key is a ticket not in Jira yet: skip it and say so under "Not sent".
+7. Run `pmos jira pending <initiative>` again. It must list nothing to create or update. If it does, report what is left.
+8. Bring the status back now: run the steps of the Jira status check for this one initiative (`pmos jira query <initiative>`, the search, `pmos jira sync <initiative> --from <file>`).
+9. Finish with the four sections: Created (ticket, key, summary), Updated (ticket, key), Not sent (anything you skipped and why), Needs you (any refusal or choice you made).
+
+Output contract — produce EXACTLY these sections, the same shape every run:
+- Created
+- Updated
+- Not sent
+- Needs you

package/workspace/skills/jira-sync.skill

@@ -0,0 +1,42 @@
+---
+name: jira-sync
+label: "Jira status check"
+description: "Read, read-only, the status, sprint and subtasks of the Jira tickets each initiative pushed, and save them in PMOS for the initiative's Jira tickets tab. It writes nothing to Jira."
+run: agent
+agent: claude
+output:
+  - Checked
+  - Not reached
+  - Needs you
+---
+
+/jira-sync — bring the status of each initiative's Jira tickets up to date. You read Jira with the PM's own Atlassian connection. PMOS saves what you read and shows it on the initiative's Jira tickets tab. You change nothing in Jira.
+
+Rules that always hold:
+1. READ-ONLY on Jira. Use only the Jira search tool. 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 jira sync`. Never edit a repository file. Never run `pmos item`. Never write a ledger by hand. Never commit; the PM's Sync carries the files.
+3. LIGHT ON CONTENT. Ask Jira only for these fields: summary, status, the sprint field, subtasks and the Flagged field. Never ask for or copy a description, a comment, an attachment, a person or a token.
+4. TEMPORARY FILES OUTSIDE THE REPOSITORY. Save each search result in this session's scratch folder, never in the repository, and delete it after the sync.
+5. NOTHING INVENTED. Give `pmos jira sync` exactly what Jira returned. If Jira cannot be reached, list the initiative under "Not reached" and write nothing for it.
+
+Procedure:
+1. If the task names one initiative ("This check: initiative …"), check that one only: run `pmos jira query <initiative>`. Otherwise run `pmos jira query`: each line is an initiative id, a tab and the Jira search (JQL) to run for it. If no initiative has a ticket in Jira, say so in one line and stop.
+2. For each initiative, run its search with the Jira search tool and the fields in rule 3. The sprint is usually a custom field named "Sprint" (often `customfield_10020`); ask for it by name. Fetch every page.
+3. Save the result as JSON in the scratch folder, for example `<scratch>/jira-<initiative>.json`, as a list with one object per issue:
+   `{"key", "summary", "status", "category", "sprint", "subtasks", "flagged", "reason", "url"}`
+   - `category`: the status category, `new`, `indeterminate` or `done`.
+   - `sprint`: `{"name": "Sprint 42", "state": "active"}` for the active sprint, `"future"` for a planned one, or `null` when the issue is in the backlog.
+   - `subtasks`: `{"done": 2, "total": 5}`.
+   - `flagged`: `true` when the issue is flagged; `reason`: the flag's comment or the blocking status, in a few words.
+   - `url`: the issue's browse link, `https://<site>.atlassian.net/browse/<KEY>`.
+   The shape Jira returned (`{"issues": [{"key", "self", "fields": {...}}]}`) is also accepted.
+4. Run `pmos jira sync <initiative> --from <the file> --query "<the JQL>"`. Then delete the file.
+5. Finish with the three sections of the output contract, one short line each:
+   - Checked: the initiative, the number of tickets read, and each change (status, sprint, blocked). If nothing changed, say "no change".
+   - Not reached: each initiative whose search failed, with the reason.
+   - Needs you: tickets newly blocked, tickets the search did not return, and any refusal.
+
+Output contract — produce EXACTLY these sections, the same shape every run:
+- Checked
+- Not reached
+- Needs you

package/workspace/skills/morning-brief.skill

@@ -29,7 +29,7 @@ Procedure:
    Then run `pmos proactive goals`. It lists the PM's goals for today, each with its id (g-xxxxxxxx), its status and, if set, an initiative. The goals are what the PM wants done today: plan for them first.
    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. Wispr Flow: today's and tomorrow's meeting notes. Jira: issues assigned to the PM or due soon. Confluence: pages changed since yesterday. Mail, only if on: subjects and senders of threads waiting on the PM, no bodies.
+   - Calendar: today's events. 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.
    - 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/report-biweekly.skill

@@ -28,7 +28,7 @@ Procedure:
 2. Read the definition: `<state>/reports/definitions/biweekly.md`.
    - If it exists, write your notes to its purpose, audience, length and tone. The script applies its sections.
    - If it does NOT exist, do not stop. Look for earlier biweekly reports in the repository and under <state>/reports/ to learn the shape the PM already uses. Write a PROPOSED definition (purpose, sources, sections, length, tone) to `<state>/reports/definitions/biweekly.md` with this frontmatter, one key per line and nothing indented: `type: Reference`, `title`, `description`, `cadence: biweekly`, `sections: [headline, timeline, initiatives, new, decided, needs, sources]`, `generated: {by: claude-code/report-biweekly, at: "…"}`, `status: draft` — and then use it for this draft. Never set `status: stable` or add `verified` yourself: only the PM confirms a definition. Never set `audience`: only the PM names who reads the report, and the script writes no asks until the PM does.
-3. Do not read a tracker. Do not run `tracker-refresh`. That skill is scheduled before this one and writes its evidence into the plan items from local files. If it did not run, the script lists the tracker under "Sources reached and not reached". Repeat that line in your final message.
+3. Do not read a tracker. Do not run `tracker-refresh` or the Jira status check (`jira-sync`). Both are scheduled before this one and write their evidence in local files. If one did not run, the script lists its source under "Sources reached and not reached". Repeat that line in your final message.
 4. Run `pmos report draft biweekly`. The script has no model: it folds the ledgers since the last issued biweekly report and writes the whole draft to `<state>/reports/biweekly/YYYY-MM-DD.md` (the slot is today's date), with one empty note marker for each block. Read what it prints.
    - It prints the path: go on.
    - It refuses because a draft for the slot exists: do NOT overwrite it. Do not pass `--redraft` here, and do not pass `--now`. Write your notes into the file that exists.

package/workspace/skills/tracker-refresh.skill

@@ -25,6 +25,7 @@ Rules that always hold (D71):
 7. NEVER REOPEN, NEVER WITHDRAW. Never move an item that is Done or Withdrawn. Never withdraw an item: if a file says the tracker closed it as "won't do", list it under "Left as they are" and say why.
 8. A FILE THAT PMOS WRITES IS NEVER EVIDENCE. Never use a plan-items ledger, any `*.jsonl` file, anything under `<state>/runs/` or anything under `<state>/reports/` as evidence. Those files hold the state you are about to check, so they cannot confirm it.
 9. AN OLD FILE DOES NOT UNDO A NEWER MOVE. Move an item only when the file is dated later than the item's last move.
+10. JIRA TICKETS ARE NOT YOURS. The Jira tickets PMOS pushed are shown on each initiative's Jira tickets tab, from the snapshot the Jira status check writes in `<state>/tracker/jira/`. Do not read or move them, and never use a file in `<state>/tracker/jira/` as evidence for a plan item.
 
 Procedure:
 1. Find the state directory: `pmos/state/` if it exists, otherwise `planning/`. Call it <state>.

package/workspace/test-lists/jira-wbs.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "jira-wbs: `pmos jira` — Jira tickets drafted from the PRD in the PM's template, pushed by the PM's selection, their status read back (lib/jira-tickets.js, lib/jira-status.js, lib/jira-cli.js), and the initiative sheet's Jira tickets tab with its routes (public/pm/sheet-jira.js), on synthetic repositories with no network.",
+  "modules": ["jira-wbs.test.js"],
+  "panels": ["pm-jira-test.js"],
+  "seconds": { "jira-wbs.test.js": 3, "pm-jira-test.js": 40 }
+}