create-pmos 0.183.0 → 0.184.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.183.0",
+  "version": "0.184.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@ab3a131
+kernel-source: pmos@14635e7
 assembled: 2026-10-13
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T04:43:18Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T04:43:18Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-13T03:53:55Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T04:43:18Z"}
 status: stable
 ---
 

package/workspace/guide/jira.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Jira: tickets drafted from the PRD, and their status"
 description: "How to draft Jira tickets from a PRD in your ticket template, push the ones that are ready, and see their status, sprint and progress on the initiative's Jira tickets tab."
-timestamp: 2026-10-12
+timestamp: 2026-10-13
 ---
 
 # Jira: tickets drafted from the PRD, and their status
@@ -110,6 +110,15 @@ pmos jira query [<initiative>]
 pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]
 ```
 
+## The board's Sprints tab shows the whole sprint
+
+After it reads the initiatives, the check reads every issue in the sprints their tickets are in. It reads every issue, not only the issues of an initiative and not only the issues assigned to you. The board's **Sprints** tab and the sprint burndown show all of them. An issue that is in no initiative of the board shows **No initiative**. The check writes `<state>/tracker/jira/_sprints.md` with:
+
+```
+pmos jira query --sprints
+pmos jira sync --sprints --from <file|-> [--query "<jql>"]
+```
+
 ## Link an initiative to its Jira epics
 
 Your team may already plan in Jira, with an epic for each piece of work. Then link the initiative to its epics. You do not have to draft or push tickets.
@@ -152,6 +161,8 @@ The morning brief, the day check and requirement gathering use it to tie a Jira
 - `pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]`
 - `pmos jira query [<initiative>]`
 - `pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]`
+- `pmos jira query --sprints`
+- `pmos jira sync --sprints --from <file|-> [--query "<jql>"] [--dry-run]`
 - `pmos jira which <KEY>`
 
 Every command takes `--json` and `--root <dir>`.

package/workspace/lib/engine/boards.js

@@ -15,7 +15,7 @@
  *   filterRows(rows, query)                     → { total, offset, limit, rows, facets }
  *   health(rows)                                → 'ok' | 'warn' | 'bad'
  *   counts(rows, workflow)                      → { total, open, byCat, byStage, byStatus, risk, late }
- *   sprintsOf(snapshots, onBoard)               → { source, readAt, sprints }
+ *   sprintsOf(snapshots, onBoard, whole?)       → { source, readAt, sprints }
  *   INI_TEMPLATES · isBuildStage · templateBuilds · boardSettings(board)   the per-initiative workflows (console3-initiatives-parity)
  *   workflowOf(board, id, folded)               → the stages an initiative runs: its own (ini-workflow), else the board's
  *   applyIniWorkflow(board, wfNow, stage, template, stages, moveTo) → { ok, template, workflow, moved } | { ok:false, status, error }
@@ -523,8 +523,11 @@ function counts(rows, workflow) {
  * The Jira sprints of a board from the cached status snapshots (lib/jira-status.js readSnapshot), read-only.
  * snapshots: [{ initiative, fetchedAt, tickets: Map|[] of readings }]; onBoard(initiativeId) → boolean.
  * A ticket with no sprint (the backlog) is in no sprint. source is 'none' when no snapshot of the board was read.
+ * whole: the whole-sprint read (lib/jira-status.js readSprints), { fetchedAt, tickets }. A sprint the board's tickets are in then
+ * lists EVERY issue Jira holds in it, whoever it is assigned to; an issue no initiative of the board holds has initiative null
+ * (jira-sprint-scope). Without it, a sprint lists only the board's own tickets.
  */
-function sprintsOf(snapshots, onBoard = () => true) {
+function sprintsOf(snapshots, onBoard = () => true, whole = null) {
   const byName = new Map();
   let readAt = null;
   let any = false;
@@ -545,6 +548,28 @@ function sprintsOf(snapshots, onBoard = () => true) {
       sp.counts[category]++;
     }
   }
+  const wt = whole && whole.tickets ? (whole.tickets instanceof Map ? [...whole.tickets.values()] : Array.isArray(whole.tickets) ? whole.tickets : []) : [];
+  let widened = false;
+  for (const sp of byName.values()) {
+    const all = wt.filter((t) => t && t.key && t.sprint && String(t.sprint.name) === sp.name);
+    if (!all.length) continue;
+    widened = true;
+    const own = new Map(sp.issues.map((i) => [i.key, i]));
+    const keys = new Set(all.map((t) => t.key));
+    if (!sp.start && typeof all[0].sprint.start === 'string' && all[0].sprint.start) sp.start = all[0].sprint.start;
+    if (!sp.end && typeof all[0].sprint.end === 'string' && all[0].sprint.end) sp.end = all[0].sprint.end;
+    sp.issues = [
+      ...all.map((t) => {
+        const category = ['todo', 'doing', 'done'].includes(t.category) ? t.category : 'todo';
+        const o = own.get(t.key);
+        return { key: t.key, summary: t.summary || '', status: t.status || '', category, initiative: o ? o.initiative : null, flagged: !!t.flagged, reason: t.flagged && t.reason ? String(t.reason) : null };
+      }),
+      ...sp.issues.filter((i) => !keys.has(i.key)),   // a board ticket the sprint read has not seen yet keeps its own reading
+    ];
+    sp.counts = { todo: 0, doing: 0, done: 0 };
+    for (const i of sp.issues) sp.counts[i.category]++;
+  }
+  if (widened && whole.fetchedAt && (!readAt || whole.fetchedAt < readAt)) readAt = whole.fetchedAt;   // the oldest read is the honest age
   const order = { active: 0, future: 1, closed: 2 };
   const sprints = [...byName.values()].sort((a, b) => ((order[a.state] ?? 3) - (order[b.state] ?? 3)) || a.name.localeCompare(b.name));
   for (const sp of sprints) sp.issues.sort((a, b) => a.key.localeCompare(b.key, undefined, { numeric: true }));

package/workspace/lib/jira-cli.js

@@ -10,6 +10,8 @@
  *   pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]   the keys the agent created
  *   pmos jira query [<initiative>]                              the Jira search for the tickets an initiative pushed
  *   pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]  a saved search → the status snapshot
+ *   pmos jira query --sprints                                   the Jira search for every issue in the sprints the tickets are in
+ *   pmos jira sync --sprints --from <file|-> [--query "<jql>"]  a saved whole-sprint search → the Sprints tab (jira-sprint-scope)
  *   pmos jira which <KEY>                                       the initiative a Jira key belongs to
  *   every command: [--json] [--root <dir>]
  *
@@ -36,11 +38,13 @@ const USAGE = [
   '  pmos jira record <initiative> [ID=KEY …] [--epic KEY] [--updated ID,ID]   the keys created in Jira',
   '  pmos jira query [<initiative>]                     the Jira search for the pushed tickets',
   '  pmos jira sync <initiative> --from <file|-> [--query "<jql>"] [--dry-run]   save the status read from Jira',
+  '  pmos jira query --sprints                          the Jira search for every issue in those tickets\' sprints',
+  '  pmos jira sync --sprints --from <file|-> [--query "<jql>"]   save every issue of the sprints, for the Sprints tab',
   '  pmos jira which <KEY>                              the initiative a Jira key belongs to',
   '  every command: [--json] [--root <dir>]',
   'This command never calls Jira. Your agent reads and writes Jira with your own connection.',
 ];
-const BOOL = new Set(['json', 'dry-run', 'help']);
+const BOOL = new Set(['json', 'dry-run', 'help', 'sprints']);
 const VALUE = new Set(['from', 'query', 'root', 'epic', 'updated']);
 const FLAG_TEXT = { 'prd-changed': 'PRD changed', removed: 'Removed from PRD', blocked: 'Blocked', incomplete: 'Missing text', pushing: 'Selected, waiting for the push', edited: 'Edited, not in Jira yet' };
 
@@ -92,6 +96,23 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
   const known = () => planItems.INIT_RE.test(initiative || '') && !!jiraTickets.recordFm(root, initiative);
 
   try {
+    if (flags.sprints && verb !== 'query' && verb !== 'sync') return fail('--sprints goes with query or sync', 2);
+    if (verb === 'query' && flags.sprints) {
+      const q = jiraStatus.sprintQuery(root);
+      return out(q, [q.linked ? q.query : 'no Jira reading has a sprint yet — run the initiatives\' searches first']);
+    }
+    if (verb === 'sync' && flags.sprints) {
+      if (!flags.from) return need('--sprints --from <file|->');
+      let raw;
+      try { raw = JSON.parse(readInput(flags.from, cwd, stdin)); }
+      catch (e) { return fail(`could not read ${flags.from} as JSON — ${String((e && e.message) || e).slice(0, 160)}`); }
+      const r = jiraStatus.syncSprints(root, raw, { query: flags.query || undefined, dryRun: !!flags['dry-run'], now });
+      if (!r.ok) return fail(r.error);
+      const lines = [`sprints · read ${r.read} ${r.read === 1 ? 'issue' : 'issues'}${r.ignored ? ` · ${r.ignored} in no sprint, ignored` : ''}${r.skipped ? ` · ${r.skipped} skipped (no key or summary)` : ''}${r.dryRun ? ' · dry run, nothing written' : ''}`];
+      for (const [name, n] of Object.entries(r.sprints)) lines.push(`  ${name} · ${n} ${n === 1 ? 'issue' : 'issues'}`);
+      if (!r.dryRun) lines.push(`snapshot ${r.snapshot}`);
+      return out(r, lines);
+    }
     if (verb === 'query') {
       if (initiative) {
         const q = jiraStatus.queryFor(root, initiative);

package/workspace/lib/jira-status.js

@@ -13,6 +13,10 @@
  *   sync(root, initiative, raw, opts)   → the snapshot, written to <state>/tracker/jira/<initiative>.md
  *   readSnapshot(root, initiative)      → { fetchedAt, query, tickets: Map<key, reading> } | null
  *   which(root, key)                    → the initiative and ticket a key belongs to
+ *   sprintQuery(root)                   → { linked, sprints, query } the JQL for EVERY issue in the sprints the initiatives' tickets
+ *                                         are in, whoever holds them (jira-sprint-scope); linked false when no reading has a sprint
+ *   syncSprints(root, raw, opts)        → the whole-sprint snapshot, written to <state>/tracker/jira/_sprints.md
+ *   readSprints(root)                   → { fetchedAt, query, tickets: Map<key, reading> } | null
  *
  * A READING is { key, summary, status, category: todo|doing|done, sprint: { name, state: active|future|closed, id?, start?, end?,
  * completed? } | null, subtasks: { done, total }, fixVersion: [names], points: number | null, resolved: YYYY-MM-DD | null,
@@ -206,12 +210,13 @@ function snapshotRel(root, initiative) { return jiraTickets.relOf(root, snapshot
 const cell = (s) => oneLine(s).replace(/\\/g, '\\\\').replace(/\|/g, '\\|') || '—';
 const SPRINT_WORD = { active: 'Active sprint', future: 'Next sprint', closed: 'Closed sprint' };
 function sprintLabel(s) { return s ? `${SPRINT_WORD[s.state] || 'Sprint'}: ${s.name}` : 'Backlog'; }
-function renderSnapshot({ initiative, fetchedAt, query, readings, ids }) {
+function renderSnapshot({ initiative, fetchedAt, query, readings, ids, title }) {
+  const name = title || initiative;
   const rows = readings.map((r) => `| ${cell(ids.get(r.key) || '')} | ${cell(r.key)} | ${cell(r.summary)} | ${cell(r.status)} | ${cell(r.category === 'done' ? 'Done' : sprintLabel(r.sprint))} | ${r.subtasks.total ? `${r.subtasks.done} of ${r.subtasks.total}` : '—'} | ${cell(r.flagged ? r.reason : '')} |${r.stale ? ' not in the last read |' : ''}`);
   return [
-    '---', 'type: Reference', `title: "Jira status: ${initiative}"`, `timestamp: ${fetchedAt}`, `initiative: ${initiative}`, '---', '',
-    `# Jira status: ${initiative}`, '',
-    `Read from Jira at ${fetchedAt} by the Jira status check, read-only. The Jira tickets tab of the initiative shows it. Written by \`pmos jira sync\`; do not edit by hand.`, '',
+    '---', 'type: Reference', `title: "Jira status: ${name}"`, `timestamp: ${fetchedAt}`, ...(title ? [] : [`initiative: ${initiative}`]), '---', '',
+    `# Jira status: ${name}`, '',
+    `Read from Jira at ${fetchedAt} by the Jira status check, read-only. ${title ? 'The Sprints tab and the sprint burndown of a board show it.' : 'The Jira tickets tab of the initiative shows it.'} Written by \`pmos jira sync\`; do not edit by hand.`, '',
     query ? `Search: \`${query.replace(/`/g, "'")}\`` : 'Search: not recorded', '',
     '| Ticket | Key | Summary | Status | Sprint | Subtasks | Blocked |', '|---|---|---|---|---|---|---|', ...rows, '',
     '```json', JSON.stringify({ fetched_at: fetchedAt, query: query || null, tickets: readings }, null, 0), '```', '',
@@ -275,6 +280,48 @@ function sync(root, initiative, raw, { query, dryRun = false, now } = {}) {
   return { ...result, fetchedAt };
 }
 
+// ── the whole sprint (jira-sprint-scope) ─────────────────────────────────────────────────────────────
+// An initiative's read holds only its own tickets, so a sprint drawn from those reads lists only the tickets PMOS knows,
+// not the sprint. This second read asks Jira for every issue in the sprints those tickets are in, whoever holds them.
+const SPRINTS_FILE = '_sprints';
+const jqlName = (n) => `"${String(n).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+function sprintQuery(root) {
+  const seen = new Map();
+  for (const q of linkedInitiatives(root).filter((x) => x.linked)) {
+    const snap = readSnapshot(root, q.initiative);
+    if (!snap) continue;
+    for (const t of snap.tickets.values()) {
+      const sp = t && t.sprint;
+      if (!sp || !sp.name) continue;
+      const k = sp.id || sp.name;
+      if (!seen.has(k)) seen.set(k, { name: sp.name, state: sp.state || null, ...(sp.id ? { id: sp.id } : {}) });
+    }
+  }
+  const sprints = [...seen.values()].sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+  if (!sprints.length) return { ok: true, linked: false, sprints, query: null };
+  return { ok: true, linked: true, sprints, query: `sprint in (${sprints.map((s) => s.id || jqlName(s.name)).join(', ')}) ORDER BY key` };
+}
+/** Save a whole-sprint read. The read replaces the last one whole: an issue moved out of a sprint is gone from it. */
+function syncSprints(root, raw, { query, dryRun = false, now } = {}) {
+  const n = normalize(raw);
+  if (n.error) return { ok: false, error: n.error };
+  const kept = n.issues.filter((i) => i.sprint && i.sprint.name);
+  const fetchedAt = nowIso(now);
+  const prev = readSprints(root);
+  const bySprint = {};
+  for (const i of kept) bySprint[i.sprint.name] = (bySprint[i.sprint.name] || 0) + 1;
+  const result = { ok: true, read: kept.length, ignored: n.issues.length - kept.length, skipped: n.skipped, sprints: bySprint,
+    was: prev ? prev.tickets.size : null, snapshot: snapshotRel(root, SPRINTS_FILE), dryRun: !!dryRun };
+  if (dryRun) return result;
+  const file = snapshotPath(root, SPRINTS_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, renderSnapshot({ initiative: SPRINTS_FILE, title: 'every issue in the sprints', fetchedAt, query: query || (prev && prev.query) || null, readings: kept, ids: new Map() }));
+  fs.renameSync(tmp, file);
+  return { ...result, fetchedAt };
+}
+function readSprints(root) { return readSnapshot(root, SPRINTS_FILE); }
+
 // ── J13 · which initiative ─────────────────────────────────────────────────────────────────────────
 function which(root, key) {
   const k = String(key || '').trim().toUpperCase();
@@ -288,4 +335,4 @@ function which(root, key) {
   return { ok: true, key: k, initiatives: hits };
 }
 
-module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel };
+module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel, sprintQuery, syncSprints, readSprints, SPRINTS_FILE };

package/workspace/lib/routes-boards.js

@@ -489,7 +489,9 @@ const READS = {
         if (s) snaps.push({ initiative: q.initiative, fetchedAt: s.fetchedAt, tickets: s.tickets });
       }
     } catch { /* no snapshot yet */ }
-    ctx.json(res, { ok: true, ws: r.w.id, board: r.board.id, ...B.sprintsOf(snaps, (id) => ids.has(id)) });
+    let whole = null;
+    try { whole = jiraStatus.readSprints(r.w.root); } catch { whole = null; }
+    ctx.json(res, { ok: true, ws: r.w.id, board: r.board.id, ...B.sprintsOf(snaps, (id) => ids.has(id), whole) });
   },
 };
 
@@ -866,7 +868,9 @@ function meetingBoards(ctx) {
           if (s) snaps.push({ initiative: q.initiative, fetchedAt: s.fetchedAt, tickets: s.tickets });
         }
       } catch { /* no snapshot yet */ }
-      sprints = B.sprintsOf(snaps, (id) => ids.has(id));
+      let whole = null;
+      try { whole = jiraStatus.readSprints(w.root); } catch { whole = null; }
+      sprints = B.sprintsOf(snaps, (id) => ids.has(id), whole);
     }
     return { ...head, health: B.health(rows), counts: { total: c.total, open: c.open, risk: c.risk, late: c.late },
       rows: rows.filter((r) => r.status === 'late' || r.status === 'at risk').map((r) => ({ id: r.id, title: r.title, status: r.status, end: r.end || null, owner: r.owner || null })),

package/workspace/lib/routes-calendar-views.js

@@ -122,13 +122,13 @@ function readers(root, runtimeDir) {
       try { out.own = ownRows().map((o) => ({ id: o.id, title: o.title, due: o.due, done: !!o.done, priority: o.priority || null })); } catch { /* likewise */ }
       return out;
     },
-    /* each initiative's Jira epic progress, from the snapshots in the tracker folder (one file per initiative; the -tickets.md drafts are not snapshots) */
+    /* each initiative's Jira epic progress, from the snapshots in the tracker folder (one file per initiative; the -tickets.md drafts and the _sprints.md whole-sprint read are not) */
     readJira() {
       const fs = require('fs');
       const status = require('./jira-status.js');
       const out = new Map();
       let names = [];
-      try { names = fs.readdirSync(require('./jira-tickets.js').jiraDir(root)).filter((n) => n.endsWith('.md') && !n.endsWith('-tickets.md')); } catch { return out; }
+      try { names = fs.readdirSync(require('./jira-tickets.js').jiraDir(root)).filter((n) => n.endsWith('.md') && !n.endsWith('-tickets.md') && !n.startsWith('_')); } catch { return out; }
       for (const n of names) {
         const id = n.slice(0, -3);
         try { const p = require('./briefing-real.js').jiraProgress(status.readSnapshot(root, id)); if (p) out.set(id, p); } catch { /* one unreadable snapshot is left out */ }

package/workspace/lib/routes-stage-tools.js

@@ -164,6 +164,21 @@ function burndownFor(ctx, w, ids, board, sprint) {
     if (snap.readAt && (!readAt || snap.readAt < readAt)) readAt = snap.readAt;   // the oldest read is the honest age
   }
   if (!tickets.length) return { ok: true, available: false, reason: 'no Jira read for these initiatives yet' };
+  // jira-sprint-scope: a sprint burns down every issue in it, not only the initiatives' own tickets.
+  let whole = null;
+  try { whole = require('./jira-status.js').readSprints(w.root); } catch { whole = null; }
+  if (whole && whole.tickets.size) {
+    const names = new Set(tickets.filter((t) => t.sprint && t.sprint.name).map((t) => t.sprint.name));
+    const own = new Map(tickets.map((t) => [t.key, t]));
+    const add = [...whole.tickets.values()].filter((t) => t.sprint && names.has(t.sprint.name));
+    if (add.length) {
+      const keys = new Set(add.map((t) => t.key));
+      const merged = [...add.map((t) => ({ ...t, initiative: own.has(t.key) ? own.get(t.key).initiative : null })), ...tickets.filter((t) => !keys.has(t.key))];
+      tickets.length = 0;
+      tickets.push(...merged);
+      if (whole.fetchedAt && (!readAt || whole.fetchedAt < readAt)) readAt = whole.fetchedAt;
+    }
+  }
   return { ok: true, ...S.burndown(tickets, { sprint: sprint || null }), readAt };
 }
 

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.183.0",
+  "version": "0.184.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.183.0",
+      "version": "0.184.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/skills/jira-sync.skill

@@ -1,7 +1,7 @@
 ---
 name: jira-sync
 label: "Jira status check"
-description: "Read, read-only, the status, sprint and subtasks of the Jira tickets each initiative pushed, or of its Jira epics and the issues under them, and save them in PMOS for the initiative's Jira tickets tab. It writes nothing to Jira."
+description: "Read, read-only, the status, sprint and subtasks of the Jira tickets each initiative pushed, or of its Jira epics and the issues under them, and every issue in the sprints those tickets are in, and save them in PMOS for the initiative's Jira tickets tab and the board's Sprints tab. It writes nothing to Jira."
 run: agent
 agent: claude
 output:
@@ -35,10 +35,11 @@ Procedure:
    - `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.
+4a. Read the whole sprints, after every initiative is synced. Run `pmos jira query --sprints`. It prints one Jira search for every issue in the sprints the tickets above are in, whoever the issue is assigned to. Do this even when the task names one initiative. If it prints "no Jira reading has a sprint yet", skip this step. Otherwise run that search with the same fields as step 2, fetch every page, save the result in the scratch folder in the same shape as step 3 (for example `<scratch>/jira-sprints.json`), run `pmos jira sync --sprints --from <the file> --query "<the JQL>"`, and delete the file. Do not record people from this search (step 5 is for the initiatives' own issues).
 5. Record the people in People. For each assignee and reporter other than the PM, write one sighting per issue (People adds each new person at once): {"source": "jira", "handle": {"kind": "jira", "value": "<their Jira display name>"}, "name": "<display name>", "interaction": {"date": "<the issue's last update, YYYY-MM-DD>", "kind": "Jira", "text": "<Assignee|Reporter> of <KEY>: <summary, at most 150 characters>", "pointer": "jira · <KEY> · <url>", "initiative": "<the initiative id>"}}. Put all of them in one file {"sightings": [...]} in the scratch folder, run `pmos people record --file <that file>` once, and delete the file. An issue with no assignee gives no assignee sighting.
 6. 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". Add how many people you recorded.
-   - Not reached: each initiative whose search failed, with the reason.
+   - Checked: the initiative, the number of tickets read, and each change (status, sprint, blocked). If nothing changed, say "no change". Add how many people you recorded, and how many issues the sprint read saved per sprint.
+   - Not reached: each initiative whose search failed, with the reason, and the sprint read if it failed.
    - 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: