create-pmos 0.57.1 → 0.59.0

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

@@ -3,7 +3,8 @@
  * About 70% of the width on a desktop and the whole screen on a phone. Top to bottom:
  *   line 1  the title, the horizon, the health reason (only when not on track), and a meta line: lane · anchor · id
  *   line 2  the stage stepper, then "Waiting on you: approval [Open gate ▸]" or "Waiting on agent: build [Hand to agent ▸]"
- *   tabs    Breakdown (the Run 1 pane, embedded: Tree · Board, and Timeline once Run 4 registers it), Files, History
+ *   tabs    Breakdown (the Run 1 pane, embedded: Tree · Board, and Timeline once Run 4 registers it), Files, History,
+ *           Jira tickets (sheet-jira.js, initiative jira-wbs: the tickets drafted from the PRD and their status in Jira)
  *   ⋯       horizon, check-by, lifecycle and the anchor (both PM-only: the server's guard answers), Copy CLI, Export breakdown
  * Nothing on this sheet says "plan". Everything it shows is read from GET /api/initiatives/<id>; every write goes through
  * initiatives-api.js. The Breakdown tab mounts with a tab id of the form `initiative:<slug>`, so it never meets a panel-4
@@ -17,6 +18,7 @@ import { el } from './dom.js';
 import { sheet, button, iconButton, tabs, row, badge, menu, toast, empty, field, ensureComponentsCss } from './primitives.js';
 import { icon, ensureSprite } from './icons.js';
 import { mountBreakdown, unmountBreakdown } from './panel-breakdown.js';
+import { mountJira, unmountJira } from './sheet-jira.js';
 import { openDoc } from './panel-initiatives.js';
 import { openNewSession } from './panel-newsess.js';
 import { wsOf, readDoc, saveDoc } from './data.js';
@@ -73,7 +75,7 @@ export function openSheet(repo, slug) {
   const s = sheet({
     mode: 'auto', title: slug, sub: '', body: [crumb, stepperHost, waitingHost, tabsHost, panel],
     attrs: { class: 'in-sheet', 'data-in-sheet': 'initiative', 'data-in-id': slug },
-    onClose: () => { closed = true; unmountBreakdown(panel); if (current === s) current = null; },
+    onClose: () => { closed = true; unmountBreakdown(panel); unmountJira(panel); if (current === s) current = null; },
   });
   current = s;
 
@@ -219,10 +221,11 @@ export function openSheet(repo, slug) {
   function drawTabs() {
     tabsHost.replaceChildren(tabs({
       variant: 'segmented', full: true, ariaLabel: COPY.sheet.tabs, value: tab,
-      items: [{ id: 'breakdown', label: COPY.sheet.breakdown }, { id: 'files', label: COPY.sheet.files }, { id: 'history', label: COPY.sheet.history }],
+      items: [{ id: 'breakdown', label: COPY.sheet.breakdown }, { id: 'files', label: COPY.sheet.files }, { id: 'history', label: COPY.sheet.history }, { id: 'jira', label: COPY.sheet.jira }],
       onChange: (id) => {
         if (id === tab) return;
         if (tab === 'breakdown') unmountBreakdown(panel);
+        if (tab === 'jira') unmountJira(panel);
         tab = id;
         drawTabs(); drawPanel();
         const t = tabsHost.querySelector('[data-tab="' + id + '"]');
@@ -234,6 +237,7 @@ export function openSheet(repo, slug) {
   function drawPanel() {
     if (!data) return;
     if (tab === 'breakdown') { mountBreakdown(panel, { id: tabId, ws, slug }, { embedded: true }); return; }
+    if (tab === 'jira') { mountJira(panel, { ws, slug }); return; }
     if (tab === 'files') {
       const files = data.files || [];
       panel.replaceChildren(files.length ? el('div', { class: 'in-sheet__rows', role: 'list' }, files.map((f) => row({

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

@@ -120,6 +120,7 @@ export const COPY = {
     breakdown: 'Breakdown',
     files: 'Files',
     history: 'History',
+    jira: 'Jira tickets',
     waitingYou: (act) => `Waiting on you: ${act}`,
     waitingAgent: (act) => `Waiting on agent: ${act}`,
     nothingOwed: 'Nothing is owed.',

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/server.js

@@ -112,6 +112,7 @@ const modelLib = require('./lib/models');               // tier routing — one
 const memoryLib = require('./lib/memory');             // curated repository memory — one ledger code path, shared with the agents' CLI (D72)
 const audit = require('./lib/audit');                 // the workflow audit — the sweep the agents' CLI runs, read-only here (D77)
 const syncLib = require('./lib/sync');                 // press-only fetch / integrate / commit records / push (D70)
+const kitUpdate = require('./lib/kit-update.js');       // workspace-kit-update: press-only check and update of the kit and the app
 const gitInfo = require('./lib/git-info');             // read-mostly branch awareness + select/create at session start
 const startPolicy = require('./lib/start-policy');     // ONE stated rule for where a session starts (repo-first R1/R3)
 const treeShare = require('./lib/tree-share');         // who shares a working tree, and who is DECLARED to be driving it
@@ -134,6 +135,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
@@ -1862,6 +1869,7 @@ function readLedger(w, basename) {
 // D70 — the lifecycle ledger: the latest line for an initiative wins; `active` reopens. The same rule
 // as scripts/workflow-state.js#readLifecycle (a parity case in workspace/test.js keeps them in step).
 const syncing = new Set();   // repositories with a sync in flight — one at a time
+let kitBusy = null;          // workspace-kit-update: the one kit or app update in flight ('kit' | 'app'), or null
 // D70 as amended 2026-10-06: the same Sync, run without the press at startup and when work sits unpushed and quiet.
 // Every rule it must pass is in lib/auto-sync.js; a scratch server (its own PMOS_STATE_DIR) does not auto-sync.
 const autoSync = require('./lib/auto-sync').createAutoSync({
@@ -2287,6 +2295,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 +6561,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
@@ -6853,6 +6924,50 @@ async function handleRequest(req, res) {
       return json(res, { ws: w.id, name: w.name, ...out });
     } finally { syncing.delete(w.root); }
   }
+  /* ── workspace-kit-update: Settings › Updates. GET reads versions from disk only. Each POST is the PM's press, and is
+   *    the only way the workspace reaches the npm registry (lib/kit-update.js; no-network.test.js holds that). ── */
+  if (p === '/api/kit/status' && req.method === 'GET') {
+    const w = getWs(url.searchParams.get('ws'));
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    return json(res, { ok: true, ws: w.id, name: w.name, busy: kitBusy, ...kitUpdate.status({ root: w.root, appVersion: APP_VERSION, appDir: __dirname }) });
+  }
+  if ((p === '/api/kit/check' || p === '/api/kit/update' || p === '/api/kit/upgrade-app') && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const g = pmGuard.requirePagePress(req, body);
+    if (!g.ok) return json(res, { ok: false, error: g.error }, g.status);
+    // A named workspace only: getWs falls back to the home repository, and an update must never land on a repository
+    // the page did not show.
+    const w = body.ws ? workspaces.get(String(body.ws)) : null;
+    if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
+    const st = () => kitUpdate.status({ root: w.root, appVersion: APP_VERSION, appDir: __dirname });
+    if (p === '/api/kit/check') {
+      const r = await kitUpdate.latest();
+      const now = st();
+      if (!r.ok) return json(res, { ok: false, error: r.error, ws: w.id, ...now }, 502);
+      return json(res, { ok: true, ws: w.id, ...now, latest: r.version, ...kitUpdate.compare(now, r.version) });
+    }
+    if (kitBusy) return json(res, { ok: false, error: kitBusy === 'app' ? 'The workspace is already updating' : 'A kit update is already running' }, 409);
+    if (p === '/api/kit/update') {
+      kitBusy = 'kit';
+      try {
+        const r = await kitUpdate.updateKit(w.root, { version: body.version });
+        boardCache.invalidate(w.root);
+        return json(res, { ws: w.id, ...r, ...st() }, r.ok ? 200 : 502);
+      } finally { kitBusy = null; }
+    }
+    // The app update stops this server and starts a new one. It is refused from a phone: the new server starts on
+    // loopback only, so the phone that asked would lose the page. It is refused from a checkout, which git updates.
+    if (!remoteAccess.isLoopbackAddr(req.socket.remoteAddress) || remoteAccess.isProxied(req.headers, BIND.publicHost)) {
+      return json(res, { ok: false, error: 'Update the workspace from the computer it runs on' }, 403);
+    }
+    if (st().app.fromCheckout) return json(res, { ok: false, error: 'This workspace runs from a PMOS checkout. Update it with git pull' }, 409);
+    const r = kitUpdate.upgradeApp(w.root, { version: body.version, logFile: path.join(STATE, 'app-update.log') });
+    if (!r.ok) return json(res, { ok: false, error: r.error }, 400);
+    kitBusy = 'app';
+    return json(res, { ok: true, ws: w.id, from: APP_VERSION, to: body.version, log: r.log });
+  }
   /* ── next-step actions: prepare is read-only; go starts exactly what was shown; review records the PM's word ── */
   if (p === '/api/next-step/prepare' && req.method === 'POST') {
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }

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