create-pmos 0.205.0 → 0.207.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.205.0",
+  "version": "0.207.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@3947135
-assembled: 2026-10-13
+kernel-source: pmos@b515557
+assembled: 2026-10-14
 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-13T13:16:48Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:10:19Z"}
 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-13T13:16:48Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:10:19Z"}
 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-13T13:16:48Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T01:10:19Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-13
+## 2026-10-14
 
 - Adopted OKF v0.2 (D73).

package/workspace/c3-ib-more-test.js

@@ -43,7 +43,13 @@ const { harness } = require('./c3-ini-harness');
   await open('board:idpf:sprints');
   await until(() => st(() => !!document.querySelector('[data-inb="sprints-source"]')));
   ok('SP1 the active sprint header says Jira, read-only, and there is no banner', /Jira, read-only/.test(await text('[data-inb="sprints-source"]')) && await st(() => !!document.querySelector('[data-inb-state="active"] [data-inb="sprints-source"]') && !document.querySelector('.fold [data-inb="sprints-source"], .fold[data-inb="sprints-source"]')));
-  ok('SP2 the active sprint is drawn with its counts; future and closed sprints are listed', await st(() => !!document.querySelector('[data-inb-state="active"]') && !!document.querySelector('[data-inb-state="future"]') && !!document.querySelector('[data-inb-state="closed"]') && ((m) => !!m && Number(m[1]) + Number(m[2]) + Number(m[3]) === 12)(/Done(\d+)Inprogress(\d+)Todo(\d+)/.exec(document.querySelector('[data-inb="sprint-counts"]').textContent.replace(/\s+/g, '')))));
+  ok('SP2 the active sprint is drawn with its counts; future and closed sprints are listed', await st(() => !!document.querySelector('[data-inb-state="active"]') && !!document.querySelector('[data-inb-state="future"]') && !!document.querySelector('[data-inb-state="closed"]') && ((m) => !!m && Number(m[1]) === 12 && Number(m[2]) + Number(m[3]) + Number(m[4]) === 12)(/Items(\d+):(\d+)done,(\d+)inprogress,(\d+)todo/.exec(document.querySelector('[data-inb="sprint-counts"]').textContent.replace(/\s+/g, '')))));
+  // sprint-goal-summary: the goal (from Jira, or written from the tickets and why), the team summary, closed sprints read once
+  ok('SP4 the sprint goal is written from the tickets, with Jira\'s goal only as a reference', await st(() => { const g = document.querySelector('[data-inb="sprint-summary"] [data-inb="sprint-goal"]'); return !!g && g.dataset.inbGoal === 'tickets' && /SPRINT GOAL · from the tickets/.test(g.textContent) && /In Jira: “Q4 delivery”/.test(g.textContent) && !/from Jira/.test(g.textContent); })
+    && /from the tickets/.test(await text('[data-inb-state="future"] [data-inb="sprint-goal"]')) && !(await text('[data-inb-state="future"] [data-inb="sprint-goal"]')).includes('In Jira') && /from the tickets/.test(await text('[data-inb-state="closed"] [data-inb="sprint-goal"]')));
+  ok('SP5 what the team is working on: a row per theme, one with no initiative', await st(() => document.querySelectorAll('[data-inb="sprint-themes"] [data-inb-theme]').length === 2 && !!document.querySelector('[data-inb-theme="none"]') && /No initiative/.test(document.querySelector('[data-inb-theme="none"]').textContent)));
+  ok('SP6 a closed sprint shows done of total, carried, and that it was read and summarised once', /5 of 7 done/.test(await text('[data-inb-state="closed"]')) && /2 carried to/.test(await text('[data-inb-state="closed"]'))
+    && /Read and summarised once on 29 Sep\. PMOS does not read a closed sprint again\./.test(await text('[data-inb-state="closed"] [data-inb="sprint-read-once"]')) && /Closed sprints/.test(await text('[data-inb="sprints-how"]')));
   ok('SP3 the sprint burndown card draws the ideal and actual lines', await until(() => st(() => !!document.querySelector('[data-ini-tool-card="burndown"] svg.ini-burn path.ideal') && !!document.querySelector('[data-ini-tool-card="burndown"] svg.ini-burn path.act'))));
 
   /* ── an initiative's six tabs ── */

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-13
+timestamp: 2026-10-14
 ---
 
 # Jira: tickets drafted from the PRD, and their status
@@ -119,6 +119,22 @@ pmos jira query --sprints
 pmos jira sync --sprints --from <file|-> [--query "<jql>"]
 ```
 
+## Each sprint's goal and summary
+
+The check then writes a goal and a short summary for each sprint, from the tickets it read. The Sprints tab shows them above the sprint's items, with one row for each group of related work.
+
+- The check always writes the goal from the sprint's tickets, because Jira's sprint goal is often empty, too broad (for example "Q4 delivery") or incomplete. The tab shows it as **from the tickets**.
+- When Jira has a sprint goal, the tab shows it under the goal as a reference: **In Jira: "…"**.
+- The active and the next sprint are summarised again at each check.
+- A closed sprint is read and summarised once. After that, the check does not search it again and keeps its first summary.
+
+The check writes `<state>/tracker/jira/_sprint-notes.md` with:
+
+```
+pmos jira summary
+pmos jira summary --from <file|-> [--dry-run]
+```
+
 ## 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.
@@ -163,6 +179,7 @@ The morning brief, the day check and requirement gathering use it to tie a Jira
 - `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 summary [--from <file|->] [--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, whole?)       → { source, readAt, sprints }
+ *   sprintsOf(snapshots, onBoard, whole?, notes?) → { source, readAt, sprints } (notes: each sprint's goal and summary, sprint-goal-summary)
  *   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 }
@@ -582,7 +582,7 @@ function counts(rows, workflow) {
  * 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, whole = null) {
+function sprintsOf(snapshots, onBoard = () => true, whole = null, notes = null) {
   const byName = new Map();
   let readAt = null;
   let any = false;
@@ -625,6 +625,50 @@ function sprintsOf(snapshots, onBoard = () => true, whole = null) {
     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
+  // The goal and summary the Jira status check wrote (sprint-goal-summary). A closed sprint is summarised once and not read again,
+  // so one the board's initiatives worked in is listed from its note even when none of the board's tickets is in it now.
+  const nl = notes && Array.isArray(notes.notes) ? notes.notes : [];
+  const same = (a, b) => ((a.id && b.id) ? String(a.id) === String(b.id) : String(a.name) === String(b.name));
+  if (any) {
+    const iniOf = new Map();
+    for (const s of snapshots || []) {
+      if (!s || !onBoard(s.initiative)) continue;
+      for (const t of s.tickets instanceof Map ? s.tickets.values() : Array.isArray(s.tickets) ? s.tickets : []) if (t && t.key) iniOf.set(t.key, s.initiative);
+    }
+    for (const n of nl) {
+      if (n.state !== 'closed' || byName.has(n.name)) continue;
+      if (!(n.themes || []).some((t) => t && t.initiative && onBoard(t.initiative))) continue;
+      const issues = wt.filter((t) => t && t.key && t.sprint && same(t.sprint, n)).map((t) => {
+        const category = ['todo', 'doing', 'done'].includes(t.category) ? t.category : 'todo';
+        return { key: t.key, summary: t.summary || '', status: t.status || '', category, initiative: iniOf.get(t.key) || null, flagged: !!t.flagged, reason: t.flagged && t.reason ? String(t.reason) : null };
+      });
+      const counts = { todo: 0, doing: 0, done: 0 };
+      for (const i of issues) counts[i.category]++;
+      byName.set(n.name, { name: n.name, state: 'closed', start: n.start || null, end: n.end || null, issues, counts });
+    }
+  }
+  const jiraGoal = (sp) => {
+    for (const t of wt) if (t && t.sprint && String(t.sprint.name) === sp.name && t.sprint.goal) return String(t.sprint.goal);
+    for (const s of snapshots || []) for (const t of s && s.tickets instanceof Map ? s.tickets.values() : s && Array.isArray(s.tickets) ? s.tickets : []) if (t && t.sprint && String(t.sprint.name) === sp.name && t.sprint.goal) return String(t.sprint.goal);
+    return null;
+  };
+  for (const sp of byName.values()) {
+    const n = nl.find((x) => x.name === sp.name);
+    const jg = jiraGoal(sp);
+    if (n) {
+      sp.goal = { from: 'tickets', text: n.goal.text, jira: n.goal.jira || jg || null };   // always from the tickets; Jira's goal is a reference
+      sp.summary = n.summary;
+      sp.themes = (n.themes || []).map((t) => ({ title: t.title, line: t.line || '', tickets: t.tickets || 0, done: t.done || 0, blocked: t.blocked || 0, people: t.people || '', initiative: t.initiative || null }));
+      sp.writtenAt = n.writtenAt || null;
+      sp.summarisedTickets = Number.isInteger(n.tickets) ? n.tickets : null;
+      sp.closed = sp.state === 'closed' && n.closed ? { ...n.closed } : null;
+      sp.frozen = sp.state === 'closed' && n.state === 'closed';
+    } else {
+      sp.goal = null;
+      sp.jiraGoal = jg;
+      sp.summary = null; sp.themes = []; sp.writtenAt = null; sp.summarisedTickets = null; sp.closed = null; sp.frozen = false;
+    }
+  }
   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

@@ -12,6 +12,7 @@
  *   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 summary [--from <file|->] [--dry-run]            the sprints to summarise, or save their goal and summary (sprint-goal-summary)
  *   pmos jira which <KEY>                                       the initiative a Jira key belongs to
  *   every command: [--json] [--root <dir>]
  *
@@ -27,9 +28,9 @@ const jiraTickets = require('./jira-tickets.js');
 const planItems = require('./plan-items.js');
 const guard = require('./pm-guard.js');
 
-const COMMANDS = { jira: ['draft', 'show', 'epic', 'approve', 'pending', 'record', 'query', 'sync', 'which'] };
+const COMMANDS = { jira: ['draft', 'show', 'epic', 'approve', 'pending', 'record', 'query', 'sync', 'summary', 'which'] };
 const USAGE = [
-  'usage: pmos jira draft|show|epic|approve|pending|record|query|sync|which — Jira tickets from the PRD, and their status',
+  'usage: pmos jira draft|show|epic|approve|pending|record|query|sync|summary|which — Jira tickets from the PRD, and their status',
   '  pmos jira draft <initiative> [--dry-run]           draft one ticket per PRD item, in the ticket template',
   '  pmos jira show <initiative>                        every ticket, what needs you, and its status in Jira',
   '  pmos jira epic <initiative> new|<KEY or link>      create a new epic at the first push, or use an existing one',
@@ -40,6 +41,8 @@ const USAGE = [
   '  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 summary                                  the sprints that need a goal and summary written',
+  '  pmos jira summary --from <file|-> [--dry-run]      save each sprint\'s goal, summary and themes (a closed sprint is kept once written)',
   '  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.',
@@ -99,7 +102,7 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     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']);
+      return out(q, [q.linked ? q.query : q.kept.length ? 'every sprint is closed and summarised once — nothing to read' : '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|->');
@@ -113,6 +116,26 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
       if (!r.dryRun) lines.push(`snapshot ${r.snapshot}`);
       return out(r, lines);
     }
+    if (verb === 'summary') {
+      if (!flags.from) {
+        const r = jiraStatus.sprintsToSummarise(root);
+        if (!r.read) return out(r, ['no whole-sprint read yet — run pmos jira query --sprints and sync --sprints first']);
+        const lines = r.sprints.map((s) => `${s.name}\t${s.state}\t${s.tickets} ${s.tickets === 1 ? 'issue' : 'issues'}\t${s.jiraGoal ? `goal in Jira: ${s.jiraGoal}` : 'no goal in Jira'}`);
+        if (!lines.length) lines.push('no sprint needs a summary');
+        for (const k of r.kept) lines.push(`${k}\tclosed\tkept, summarised once`);
+        return out(r, lines);
+      }
+      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.saveSprintNotes(root, raw, { dryRun: !!flags['dry-run'], now });
+      if (!r.ok) return fail(r.error);
+      const lines = [`sprint summaries · saved ${r.saved.length}${r.kept.length ? ` · kept ${r.kept.length} closed, summarised once` : ''}${r.dryRun ? ' · dry run, nothing written' : ''}`];
+      for (const n of r.saved) lines.push(`  saved ${n}`);
+      for (const n of r.kept) lines.push(`  kept  ${n} (closed; its first summary stays)`);
+      if (!r.dryRun && r.saved.length) lines.push(`file ${r.file}`);
+      return out(r, lines);
+    }
     if (verb === 'query') {
       if (initiative) {
         const q = jiraStatus.queryFor(root, initiative);

package/workspace/lib/jira-status.js

@@ -17,9 +17,12 @@
  *                                         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
+ *   sprintsToSummarise(root)            → { ok, sprints, kept } the sprints of the whole-sprint read that need a goal and summary
+ *   saveSprintNotes(root, raw, opts)    → each sprint's goal, summary and themes, written to <state>/tracker/jira/_sprint-notes.md
+ *   readSprintNotes(root)               → { writtenAt, notes: [note] } | null (sprint-goal-summary)
  *
  * 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,
+ * completed?, goal? } | null, subtasks: { done, total }, fixVersion: [names], points: number | null, resolved: YYYY-MM-DD | null,
  * flagged, reason, url }. The sprint's dates, `points` and `resolved` feed the sprint burndown (lib/stage-tools.js); a
  * reading saved before they were carried has none of them, and the burndown says it cannot be drawn. A ticket the search did not return keeps its last reading, marked
  * stale. Titles and statuses only: never a description, a comment or a person.
@@ -100,6 +103,8 @@ function sprintOne(v) {
     const d = dayOf(from.map((f) => v[f]).find((x) => x != null));
     if (d) out[k] = d;
   }
+  const goal = clip(oneLine(v.goal), 300);   // Jira's sprint goal, often empty or broad (sprint-goal-summary)
+  if (goal) out.goal = goal;
   return out;
 }
 /** An ISO date or date-time → YYYY-MM-DD (the date as written, never shifted by a zone), else null. */
@@ -286,7 +291,8 @@ function sync(root, initiative, raw, { query, dryRun = false, now } = {}) {
 const SPRINTS_FILE = '_sprints';
 const jqlName = (n) => `"${String(n).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 function sprintQuery(root) {
-  const seen = new Map();
+  const frozen = frozenNotes(root);
+  const seen = new Map(); const kept = new Set();
   for (const q of linkedInitiatives(root).filter((x) => x.linked)) {
     const snap = readSnapshot(root, q.initiative);
     if (!snap) continue;
@@ -294,20 +300,27 @@ function sprintQuery(root) {
       const sp = t && t.sprint;
       if (!sp || !sp.name) continue;
       const k = sp.id || sp.name;
+      if (frozen.some((f) => sameSprint(f, sp))) { kept.add(sp.name); continue; }   // a closed sprint is read once (sprint-goal-summary)
       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` };
+  if (!sprints.length) return { ok: true, linked: false, sprints, kept: [...kept], query: null };
+  return { ok: true, linked: true, sprints, kept: [...kept], 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. */
+/** Save a whole-sprint read. The read replaces the last one whole: an issue moved out of a sprint is gone from it. A closed
+ * sprint that has its summary is not searched again, so its issues are kept from the last read. */
 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 frozen = frozenNotes(root);
+  if (prev && frozen.length) {
+    const got = new Set(kept.map((i) => i.key));
+    for (const t of prev.tickets.values()) if (!got.has(t.key) && t.sprint && frozen.some((f) => sameSprint(f, t.sprint))) kept.push(t);
+  }
   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,
@@ -322,6 +335,117 @@ function syncSprints(root, raw, { query, dryRun = false, now } = {}) {
 }
 function readSprints(root) { return readSnapshot(root, SPRINTS_FILE); }
 
+// ── the goal and summary of each sprint (sprint-goal-summary) ─────────────────────────────────────────
+// The Jira status check writes them from the tickets it read. The goal is always written from the tickets: Jira's sprint goal is
+// often empty, too broad or incomplete (the PM, 2026-10-14), so it is kept only as a reference (goal.jira). A closed sprint's
+// note is written once and kept; its sprint is not searched again.
+const NOTES_FILE = '_sprint-notes';
+const INI_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
+const sameSprint = (a, b) => !!a && !!b && ((a.id && b.id) ? String(a.id) === String(b.id) : String(a.name) === String(b.name));
+function readSprintNotes(root) {
+  let text;
+  try { text = fs.readFileSync(snapshotPath(root, NOTES_FILE), 'utf8'); } catch { return null; }
+  const m = /```json\n([\s\S]*?)\n```/.exec(text);
+  if (!m) return null;
+  let data;
+  try { data = JSON.parse(m[1]); } catch { return null; }
+  const notes = (Array.isArray(data.sprints) ? data.sprints : []).filter((x) => x && isStr(x.name) && x.goal && isStr(x.summary));
+  return { writtenAt: isStr(data.written_at) ? data.written_at : null, notes };
+}
+function frozenNotes(root) { const r = readSprintNotes(root); return r ? r.notes.filter((x) => x.state === 'closed') : []; }
+const count = (v, max) => (Number.isInteger(v) && v >= 0 && v <= (max == null ? 100000 : max) ? v : null);
+const text = (v, n) => clip(oneLine(v), n);
+/** One sprint's note from the agent → { note } | { error }. Nothing is guessed: a missing required field refuses the note. */
+function noteOne(x) {
+  if (!x || typeof x !== 'object') return { error: 'a sprint note is not an object' };
+  const name = text(x.name, 80);
+  if (!name) return { error: 'a sprint note has no name' };
+  const state = String(x.state || '').toLowerCase();
+  if (!SPRINT_STATES.includes(state)) return { error: `${name}: state is active, future or closed` };
+  const g = x.goal && typeof x.goal === 'object' ? x.goal : null;
+  const gt = g ? text(g.text, 240) : '';
+  if (!gt) return { error: `${name}: the goal has no text — write it from the sprint's tickets` };
+  const goal = { from: 'tickets', text: gt };
+  const j = text(g.jira, 300);
+  if (j) goal.jira = j;   // Jira's own sprint goal, kept for reference only
+  const summary = text(x.summary, 900);
+  if (!summary) return { error: `${name}: the summary is empty` };
+  const themes = [];
+  for (const t of Array.isArray(x.themes) ? x.themes.slice(0, 8) : []) {
+    const title = t && text(t.title, 80);
+    if (!title) return { error: `${name}: a theme has no title` };
+    const tickets = count(t.tickets);
+    if (tickets == null) return { error: `${name}: theme "${title}" needs a ticket count` };
+    const ini = t.initiative == null || t.initiative === '' ? null : String(t.initiative).trim();
+    if (ini != null && !INI_RE.test(ini)) return { error: `${name}: theme "${title}" has a bad initiative id` };
+    themes.push({ title, line: text(t.line, 200), tickets, done: Math.min(count(t.done) || 0, tickets), blocked: Math.min(count(t.blocked) || 0, tickets), people: text(t.people, 80), initiative: ini });
+  }
+  const note = { name, state, goal, summary, themes };
+  const id = isStr(x.id) || Number.isInteger(x.id) ? String(x.id) : '';
+  if (/^\d{1,12}$/.test(id)) note.id = id;
+  if (state === 'closed' && x.closed && typeof x.closed === 'object') {
+    const c = x.closed;
+    note.closed = { done: count(c.done) || 0, total: count(c.total) || 0, carried: count(c.carried) || 0, carriedTo: text(c.carriedTo, 80) || null, points: text(c.points, 40) || null };
+  }
+  return { note };
+}
+/** The sprints of the whole-sprint read that need a note: every active and future one, and each closed one not yet noted. */
+function sprintsToSummarise(root) {
+  const whole = readSprints(root);
+  const frozen = frozenNotes(root);
+  const by = new Map();
+  for (const t of whole ? whole.tickets.values() : []) {
+    const sp = t.sprint;
+    if (!sp || !sp.name) continue;
+    if (!by.has(sp.name)) by.set(sp.name, { name: sp.name, ...(sp.id ? { id: sp.id } : {}), state: sp.state, tickets: 0, jiraGoal: null });
+    const o = by.get(sp.name);
+    o.tickets++;
+    if (!o.jiraGoal && sp.goal) o.jiraGoal = sp.goal;
+  }
+  const all = [...by.values()].sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+  const isKept = (s) => frozen.some((f) => sameSprint(f, s));   // the note was written when Jira said closed
+  return { ok: true, read: !!whole, sprints: all.filter((s) => !isKept(s)), kept: all.filter(isKept).map((s) => s.name) };
+}
+/** Save the notes the agent wrote. A closed sprint already noted keeps its first note. A bad note refuses the whole file. */
+function saveSprintNotes(root, raw, { dryRun = false, now } = {}) {
+  const list = Array.isArray(raw) ? raw : raw && Array.isArray(raw.sprints) ? raw.sprints : null;
+  if (!list) return { ok: false, error: 'the file holds no "sprints": [...] list' };
+  const got = [];
+  for (const x of list) { const r = noteOne(x); if (r.error) return { ok: false, error: r.error }; got.push(r.note); }
+  const prev = readSprintNotes(root);
+  const notes = prev ? prev.notes.slice() : [];
+  const whole = readSprints(root);
+  const wt = whole ? [...whole.tickets.values()] : [];
+  const writtenAt = nowIso(now);
+  const saved = []; const kept = [];
+  for (const n of got) {
+    const i = notes.findIndex((o) => sameSprint(o, n));
+    if (i >= 0 && notes[i].state === 'closed') { kept.push(n.name); continue; }
+    const mine = wt.filter((t) => t.sprint && sameSprint(t.sprint, n));
+    const sp = mine.length ? mine[0].sprint : {};
+    const out = { ...n, writtenAt, tickets: mine.length, ...(sp.start ? { start: sp.start } : {}), ...(sp.end ? { end: sp.end } : {}), ...(sp.completed ? { completed: sp.completed } : {}) };
+    if (!out.id && sp.id) out.id = sp.id;
+    if (i >= 0) notes[i] = out; else notes.push(out);
+    saved.push(n.name);
+  }
+  const result = { ok: true, saved, kept, file: snapshotRel(root, NOTES_FILE), dryRun: !!dryRun };
+  if (dryRun || !saved.length) return result;
+  const file = snapshotPath(root, NOTES_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const rows = notes.map((o) => `| ${cell(o.name)} | ${cell(o.state)} | ${cell(o.goal.text)} | ${o.goal.jira ? cell(o.goal.jira) : '—'} | ${cell(o.writtenAt)} |`);
+  const body = [
+    '---', 'type: Reference', 'title: "Jira sprints: goal and summary"', `timestamp: ${writtenAt}`, '---', '',
+    '# Jira sprints: goal and summary', '',
+    'Written by the Jira status check from the tickets it read, read-only. The Sprints tab of a board shows it. A closed sprint is written once and kept. Written by `pmos jira summary`; do not edit by hand.', '',
+    '| Sprint | State | Goal (from the tickets) | Goal in Jira | Written |', '|---|---|---|---|---|', ...rows, '',
+    '```json', JSON.stringify({ written_at: writtenAt, sprints: notes }, null, 0), '```', '',
+  ].join('\n');
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, body);
+  fs.renameSync(tmp, file);
+  return { ...result, writtenAt };
+}
+
 // ── J13 · which initiative ─────────────────────────────────────────────────────────────────────────
 function which(root, key) {
   const k = String(key || '').trim().toUpperCase();
@@ -335,4 +459,5 @@ function which(root, key) {
   return { ok: true, key: k, initiatives: hits };
 }
 
-module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel, sprintQuery, syncSprints, readSprints, SPRINTS_FILE };
+module.exports = { queryFor, linkedInitiatives, normalize, sync, readSnapshot, which, sprintLabel, snapshotPath, snapshotRel, sprintQuery, syncSprints, readSprints, SPRINTS_FILE,
+  sprintsToSummarise, saveSprintNotes, readSprintNotes, sameSprint, NOTES_FILE };

package/workspace/lib/routes-boards.js

@@ -9,7 +9,7 @@
  *   GET  /api/boards/columns?ws&board&q&owner&cap     → { ok, columns: [{ stage, cat, hint, count, rows }] }
  *   GET  /api/boards/initiative?ws&board&id           → { ok, row, board, history, tools }
  *   GET  /api/boards/asks?ws&board&state              → { ok, asks }                            state: open (default) | accepted | declined | all
- *   GET  /api/boards/sprints?ws&board                 → { ok, source: jira|none, readAt, sprints }
+ *   GET  /api/boards/sprints?ws&board                 → { ok, source: jira|none, readAt, sprints } (each with goal, summary, themes, frozen)
  *   GET  /api/boards/items?ws&board                   → { ok, build, jira, items, initiatives }   PMOS tasks + Jira items (Build and deliver only)
  *   GET  /api/boards/anchors?ws&board                 → { ok, anchors: [{ value, kind, group, label }], error }   the declared KRs,
  *                                                       health budgets and domains a new initiative can anchor to (D59)
@@ -548,7 +548,9 @@ const READS = {
     } catch { /* no snapshot yet */ }
     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) });
+    let notes = null;
+    try { notes = jiraStatus.readSprintNotes(r.w.root); } catch { notes = null; }
+    ctx.json(res, { ok: true, ws: r.w.id, board: r.board.id, ...B.sprintsOf(snaps, (id) => ids.has(id), whole, notes) });
   },
 };
 
@@ -1000,7 +1002,9 @@ function meetingBoards(ctx) {
       } catch { /* no snapshot yet */ }
       let whole = null;
       try { whole = jiraStatus.readSprints(w.root); } catch { whole = null; }
-      sprints = B.sprintsOf(snaps, (id) => ids.has(id), whole);
+      let notes = null;
+      try { notes = jiraStatus.readSprintNotes(w.root); } catch { notes = null; }
+      sprints = B.sprintsOf(snaps, (id) => ids.has(id), whole, notes);
     }
     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/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/c3-demo-boards.js

@@ -385,7 +385,17 @@ export function handle(S, method, path, p, body) {
       const counts = { todo: issues.filter((i) => i.category === 'todo').length, doing: issues.filter((i) => i.category === 'doing').length, done: issues.filter((i) => i.category === 'done').length };
       const num = key === 'IDPF' ? 42 : 19;
       const extra = (k, state, name, cat, n) => { const is = Array.from({ length: n }, (_, i) => ({ key: key + '-' + (1100 + k * 20 + i), summary: (own[i % Math.max(1, own.length)] || { title: 'Sprint work' }).title + ': part ' + (i + 1), status: cat === 'done' ? 'Done' : 'To Do', category: cat, initiative: (own[i % Math.max(1, own.length)] || {}).id || null })); return { name, state, issues: is, counts: { todo: cat === 'todo' ? n : 0, doing: 0, done: cat === 'done' ? n : 0 } }; };
-      return okb({ source: 'jira', readAt: TODAY + 'T08:10:00', sprints: [{ name: key + ' Sprint ' + num, state: 'active', issues, counts }, extra(1, 'future', key + ' Sprint ' + (num + 1), 'todo', 3), extra(0, 'closed', key + ' Sprint ' + (num - 1), 'done', 5)] });
+      // The goal and summary the Jira status check writes (sprint-goal-summary). The goal is always written from the tickets;
+      // Jira's goal, when it has one, is a reference. The closed sprint was summarised once.
+      const ini0 = own[0] ? own[0].id : null;
+      const themes = [{ title: own[0] ? own[0].title : 'Sprint work', line: 'Most items are in progress or in review.', tickets: issues.filter((i) => i.initiative === ini0).length || 1, done: issues.filter((i) => i.initiative === ini0 && i.category === 'done').length, blocked: 1, people: 'Ana, Budi', initiative: ini0 },
+        { title: 'Fixes and upkeep', line: 'Small fixes outside any initiative.', tickets: 2, done: 1, blocked: 0, people: 'Chen', initiative: null }];
+      const act = { name: key + ' Sprint ' + num, state: 'active', issues, counts, goal: { from: 'tickets', text: 'Get the first initiative ready for internal users and clear the blocked work.', jira: 'Q4 delivery' },
+        summary: 'Most of the sprint is on the first initiative. One item is blocked. Two small fixes sit outside any initiative.', themes, writtenAt: TODAY + 'T06:30:00Z', summarisedTickets: issues.length, closed: null, frozen: false };
+      const fut = { ...extra(1, 'future', key + ' Sprint ' + (num + 1), 'todo', 3), goal: { from: 'tickets', text: 'Finish the first initiative and start the beta.', jira: null }, summary: 'Planned so far: three follow-up items.', themes: [], writtenAt: TODAY + 'T06:30:00Z', closed: null, frozen: false };
+      const old = { ...extra(0, 'closed', key + ' Sprint ' + (num - 1), 'done', 5), goal: { from: 'tickets', text: 'Start the first initiative.', jira: null }, summary: 'Goal met. Five items shipped; two moved to the next sprint.', themes: [{ title: 'Sprint work', line: '', tickets: 5, done: 5, blocked: 0, people: '', initiative: ini0 }],
+        writtenAt: '2026-09-29T06:30:00Z', closed: { done: 5, total: 7, carried: 2, carriedTo: key + ' Sprint ' + num, points: '21 of 26' }, frozen: true };
+      return okb({ source: 'jira', readAt: TODAY + 'T08:10:00', sprints: [act, fut, old] });
     }
     return fail(404, 'No route ' + path);
   }

package/workspace/public/pm/c3-ib-sprints.js

@@ -1,18 +1,42 @@
-/* pm/c3-ib-sprints.js — the Sprints tab of a board with Build and deliver on (mockup v5, 34-initiatives.js tabSprints).
+/* pm/c3-ib-sprints.js — the Sprints tab of a board with Build and deliver on (mockup v5, 34-initiatives.js tabSprints; the sprint goal
+ * and team summary from mockup-c3-sprint-goal v3, initiative sprint-goal-summary).
  *   registerBoardTab('sprints', (host, ctx) => ...)
- * Reads GET /api/boards/sprints { source: jira|none, readAt, sprints: [{ name, state: active|future|closed, issues: [{ key, summary, status,
- * category: todo|doing|done, initiative }], counts }] }. READ-ONLY: the sprints mirror Jira, so there is no create, edit or move control.
- * Left: the active sprint's items, its header chip saying Jira, read-only and the read time (c3-board-declutter: no banner), as rows (a linked initiative opens its page), then the
- * future and closed sprints in place. Right: the active sprint's bars, and its burndown from GET /api/stage-tools/burndown (built by
- * the stage-records change; when that route is not on this server yet, the card says so quietly). source 'none' says there is no tracker. */
+ * Reads GET /api/boards/sprints { source: jira|none, readAt, sprints: [{ name, state: active|future|closed, start, end, issues: [{ key, summary,
+ * status, category: todo|doing|done, initiative }], counts, goal: { from: 'tickets', text, jira } | null, jiraGoal?, summary,
+ * themes: [{ title, line, tickets, done, blocked, people, initiative }], writtenAt, closed: { done, total, carried, carriedTo, points } | null,
+ * frozen }] }. READ-ONLY: the sprints mirror Jira, so there is no create, edit or move control.
+ * Left: the active sprint's goal and summary (the goal, always written from the tickets, with Jira's goal as a reference; what the team is working on,
+ * one row per theme), its items (header chip: Jira, read-only and the read time; c3-board-declutter: no banner), then the next sprint
+ * with its goal and summary, and each closed sprint with its goal, summary, done and carried counts and the read-once note. Right: the
+ * active sprint's card, its burndown from GET /api/stage-tools/burndown (when that route is not on this server yet, the card says so
+ * quietly), and how sprints are read. source 'none' says there is no tracker. */
 import { el } from './dom.js';
 import { registerBoardTab } from './c3-initiatives.js';
-import { icon, lk, chip, tag, st, note, sect, card, list, empty, nrow, cols, hbs, hbr, jiraLabel, day, put } from './c3-ini-ui.js';
+import { icon, lk, chip, tag, st, note, lbl, sect, card, list, empty, nrow, cols, kv, jiraLabel, day, put, plural } from './c3-ini-ui.js';
 import { loadItems } from './c3-ini-work.js';
 import { recordCards } from './c3-ini-records.js';
 
 const CAT = { todo: 'To do', doing: 'In progress', done: 'Done' };
 const readTime = (s) => { const m = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/.exec(String(s || '')); return m ? day(m[1]) + ', ' + m[2] : ''; };
+const timeOf = (s) => { const m = /T(\d{2}:\d{2})/.exec(String(s || '')); return m ? m[1] : ''; };
+/* Quiet pages (c3-quiet.css) hide .ini-note, .ini-lhm .dim and a row's third chip. The goal's reason, the theme chips and the
+ * read-once note are the content of this tab (mockup v3), so they use their own classes. */
+/* The goal is always written from the sprint's tickets: Jira's sprint goal is often empty, too broad or incomplete (the PM,
+ * 2026-10-14). Jira's own text shows underneath as a reference. */
+const jiraRef = (j) => (j ? el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-goal-jira' }, 'In Jira: “' + j + '”') : null);
+function goalBlock(g, jiraGoal) {
+  if (!g) return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': 'missing' }, el('span', { class: 'ki' }, icon('target')),
+    el('div', { class: 'ini-sp-goal' }, lbl('SPRINT GOAL'), el('div', { class: 'dim ini-sp-note' }, 'No goal yet. The Jira status check writes one from the tickets at its next check.'), jiraRef(jiraGoal)));
+  return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': 'tickets' }, el('span', { class: 'ki' }, icon('target')),
+    el('div', { class: 'ini-sp-goal' }, lbl('SPRINT GOAL · from the tickets'), el('b', null, g.text), jiraRef(g.jira)));
+}
+const themeRow = (t, ctx) => nrow({ ic: t.blocked ? 'alert' : t.tickets && t.done === t.tickets ? 'check' : t.initiative ? 'bolt' : 'task', hot: !t.blocked && t.done < t.tickets && !!t.initiative,
+  title: t.title, attrs: { 'data-inb-theme': t.initiative || 'none' },
+  after: el('div', null, t.line ? el('div', { class: 'dim ini-sp-note' }, t.line) : null, el('div', { class: 'chips ini-sp-chips' }, ...[chip(plural(t.tickets, 'ticket')), t.done ? st('ok', 'check', t.done + ' done') : null, t.blocked ? st('warn', 'alert', t.blocked + ' blocked') : null,
+    t.people ? chip(icon('user', 'sm'), t.people) : null,
+    t.initiative ? lk({ onclick: () => ctx.openInitiative(t.initiative), 'data-inb-theme-ini': t.initiative }, icon('init', 'sm'), t.initiative) : el('span', { class: 'chip2 dim' }, 'No initiative')].filter(Boolean))) });
+const summaryBody = (sp, ctx) => [goalBlock(sp.goal, sp.jiraGoal), sp.summary ? el('p', { class: 'ini-sp-sum' }, sp.summary) : null,
+  sp.themes && sp.themes.length ? [lbl('WHAT THE TEAM IS WORKING ON'), list(sp.themes.map((t) => themeRow(t, ctx)), { 'data-inb': 'sprint-themes' })] : null];
 const countsOf = (sp) => { const c = sp.counts || {}; const f = (k) => (c[k] != null ? Number(c[k]) : (sp.issues || []).filter((i) => i.category === k).length); return { todo: f('todo'), doing: f('doing'), done: f('done') }; };
 
 registerBoardTab('sprints', async (host, ctx) => {
@@ -31,21 +55,43 @@ registerBoardTab('sprints', async (host, ctx) => {
       i.initiative ? lk({ onclick: () => ctx.openInitiative(i.initiative), 'data-inb-issue-ini': i.initiative }, icon('init', 'sm'), i.initiative) : el('span', { class: 'dim' }, 'No initiative')],
     right: [el('span', { class: 'chip2', title: 'Status lives in Jira' }, icon('lock', 'sm'))], attrs: { 'data-inb-issue': i.key } });
   const t = readTime(r.readAt);
+  const dates = (s) => (s.start && s.end ? day(s.start) + ' to ' + day(s.end) : '');
+  const itemsRow = (s) => { const c = countsOf(s); return nrow({ ic: 'clock', title: c.done + ' done, ' + c.doing + ' in progress, ' + c.todo + ' to do', xp: (s.issues || []).length ? [list(s.issues.map(issueRow))] : [note('No items.')] }); };
+  const closedSect = (s) => {
+    const c = countsOf(s); const x = s.closed || {}; const n = x.total || (s.issues || []).length; const done = x.total ? x.done : c.done;
+    return sect({ ic: 'check', title: s.name, count: n, right: tag('closed'), attrs: { 'data-inb-sprint': s.name, 'data-inb-state': 'closed' } },
+      ...summaryBody({ ...s, themes: [] }, ctx),
+      el('div', { class: 'chips ini-sp-facts' }, dates(s) ? chip(icon('cal', 'sm'), dates(s)) : null, st('ok', 'check', done + ' of ' + n + ' done'),
+        x.points ? chip(x.points + ' points') : null, x.carried ? chip(icon('next', 'sm'), x.carried + ' carried' + (x.carriedTo ? ' to ' + x.carriedTo : '')) : null),
+      el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-read-once' }, icon('lock', 'sm'), s.frozen ? ' Closed. Read and summarised once on ' + day(String(s.writtenAt || '').slice(0, 10)) + '. PMOS does not read a closed sprint again.'
+        : ' Closed. The Jira status check summarises it once at its next check, then does not read it again.'),
+      itemsRow(s));
+  };
+  const n = active ? (active.issues || []).length : 0;
   const left = [
-    active ? sect({ ic: 'check', title: active.name + ' items', count: (active.issues || []).length, right: el('span', { class: 'chip2', 'data-inb': 'sprints-source', title: 'Mirrored from Jira ' + jiraLabel(b) + '. Change sprints in Jira.' }, icon('lock', 'sm'), 'Jira, read-only' + (t ? ' · read ' + t : '')), attrs: { 'data-inb-sprint': active.name, 'data-inb-state': 'active' } },
-      (active.issues || []).length ? list(active.issues.map(issueRow)) : empty('No items in this sprint yet.', { 'data-inb': 'sprint-no-issues' }))
+    active ? sect({ ic: 'clock', title: active.name + ' · goal and summary', right: st('ok', null, 'active'), attrs: { 'data-inb': 'sprint-summary' } },
+      ...summaryBody(active, ctx),
+      el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-written' }, active.summary ? 'Goal and summary written by the Jira status check' + (timeOf(active.writtenAt) ? ' at ' + timeOf(active.writtenAt) : '') + ' from all ' + plural(active.summarisedTickets != null ? active.summarisedTickets : n, 'ticket') + ' in the sprint. Read and summarised again at each check while the sprint is active.'
+        : 'No summary yet. The Jira status check writes one from the sprint\'s tickets at its next check.')) : null,
+    active ? sect({ ic: 'check', title: active.name + ' items', count: n, right: el('span', { class: 'chip2', 'data-inb': 'sprints-source', title: 'Mirrored from Jira ' + jiraLabel(b) + '. Every issue in the sprint, whoever it is assigned to. Change sprints in Jira.' }, icon('lock', 'sm'), 'Jira, read-only' + (t ? ' · read ' + t : '')), attrs: { 'data-inb-sprint': active.name, 'data-inb-state': 'active' } },
+      n ? list(active.issues.map(issueRow)) : empty('No items in this sprint yet.', { 'data-inb': 'sprint-no-issues' }))
       : empty(sprints.length ? 'No sprint is active.' : 'Jira has no sprints for this board.', { 'data-inb': sprints.length ? 'sprints-no-active' : 'sprints-empty' }),
-    ...others.map((s) => { const c = countsOf(s); return sect({ ic: s.state === 'closed' ? 'check' : 'clock', title: s.name, count: (s.issues || []).length, right: tag(s.state || 'sprint'), attrs: { 'data-inb-sprint': s.name, 'data-inb-state': s.state } },
-      nrow({ ic: 'clock', title: c.done + ' done, ' + c.doing + ' in progress, ' + c.todo + ' to do', xp: (s.issues || []).length ? [list(s.issues.map(issueRow))] : [note('No items.')] })); }),
+    ...others.filter((s) => s.state !== 'closed').map((s) => sect({ ic: 'cal', title: s.name, count: (s.issues || []).length, right: tag(s.state || 'sprint'), attrs: { 'data-inb-sprint': s.name, 'data-inb-state': s.state } },
+      goalBlock(s.goal, s.jiraGoal), s.summary ? el('p', { class: 'ini-sp-sum' }, s.summary) : null, itemsRow(s))),
+    ...others.filter((s) => s.state === 'closed').map(closedSect),
   ];
   const right = [];
   if (active) {
-    const c = countsOf(active); const tot = Math.max(1, c.todo + c.doing + c.done);
-    right.push(card({ ic: 'clock', title: active.name, attrs: { 'data-inb': 'sprint-counts' } }, hbs([hbr('Done', c.done, c.done / tot, 'ok'), hbr('In progress', c.doing, c.doing / tot, 'acc'), hbr('To do', c.todo, c.todo / tot, 'pm')])));
+    const c = countsOf(active);
+    right.push(card({ ic: 'clock', title: active.name, attrs: { 'data-inb': 'sprint-counts' } }, kv([dates(active) ? ['Dates', dates(active)] : null,
+      ['Items', n + ': ' + c.done + ' done, ' + c.doing + ' in progress, ' + c.todo + ' to do']])));
     const ids = items.ok ? items.initiatives.map((i) => i.id) : [];
     const pseudo = { ...ctx, row: { id: ids.join(','), title: '' } };
     right.push(...await recordCards(pseudo, ['burndown']));
   }
+  if (sprints.length) right.push(card({ ic: 'redo', title: 'How sprints are read', attrs: { 'data-inb': 'sprints-how' } }, kv([
+    ['Goal', 'Written from the sprint\'s tickets. Jira\'s goal is shown for reference'], ['Active sprint', 'Read and summarised at each Jira status check'],
+    ['Next sprint', 'Read at each check, until it starts'], ['Closed sprints', 'Read and summarised once, then kept'], ['Jira', 'Read-only. PMOS changes nothing there']])));
   if (dead) return () => {};
   put(host, cols(left, right));
   return () => { dead = true; };

package/workspace/public/pm/c3-initiatives.css

@@ -55,6 +55,11 @@
 .c3 .ini-kv{display:grid;grid-template-columns:max-content minmax(0,1fr);gap:6px 14px;margin:0;font-size:var(--fs-3)}
 .c3 .ini-kv dt{color:var(--muted-foreground);font:var(--fs-2) var(--mono)}
 .c3 .ini-kv dd{margin:0;min-width:0;overflow-wrap:anywhere}
+.c3 .ini-sp-sum{margin:var(--sp-3) 0;line-height:1.5}                                      /* a sprint's summary (sprint-goal-summary) */
+.c3 .ini-sp-facts{margin:0 0 var(--sp-2)}
+.c3 .ini-sp-goal{min-width:0}
+.c3 .ini-sp-note{font-size:var(--fs-2);line-height:1.45;margin-top:var(--sp-1)}
+.c3 .ini-sp-chips{margin-top:var(--sp-1)}
 .c3 .ini-num{width:84px;flex:none}
 .c3 .ini-up,.c3 .ini-down{display:inline-flex}
 .c3 .ini-up{transform:rotate(-90deg)}

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 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."
+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, write each sprint's goal and a summary of the team's work, 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:
@@ -14,7 +14,7 @@ output:
 
 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`, and `pmos people record` once at the end (step 5). Never edit a repository file. Never run `pmos item`. Never write a ledger by hand. Never commit; the PM's Sync carries the files.
+2. THE ONLY WRITE is `pmos jira sync`, `pmos jira summary` (step 4b), and `pmos people record` once at the end (step 5). 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 issue type, the parent, the sprint field, subtasks, the Flagged field, the story points field, the resolution date, and the display names of the assignee and the reporter. Never ask for or copy a description, a comment, an attachment, an email address, any other detail of 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.
@@ -27,7 +27,7 @@ Procedure:
    - `type`: the issue type's name, for example `Epic`, `Story`, `Task` or `Bug`.
    - `parent`: the parent issue's key (the epic of a story), or `null`.
    - `category`: the status category, `new`, `indeterminate` or `done`.
-   - `sprint`: `{"id": "42", "name": "Sprint 42", "state": "active", "start": "2026-10-01", "end": "2026-10-14"}` for the active sprint, `"future"` for a planned one, or `null` when the issue is in the backlog. Copy `id`, `start`, `end` and `completed` (a closed sprint's completion date) from Jira's sprint field; leave out any that Jira does not give.
+   - `sprint`: `{"id": "42", "name": "Sprint 42", "state": "active", "start": "2026-10-01", "end": "2026-10-14"}` for the active sprint, `"future"` for a planned one, or `null` when the issue is in the backlog. Copy `id`, `start`, `end`, `completed` (a closed sprint's completion date) and `goal` (the sprint goal, as Jira writes it) from Jira's sprint field; leave out any that Jira does not give.
    - `points`: the story points as a number, or `null` when none are set.
    - `resolved`: the resolution date as `YYYY-MM-DD`, or `null` when the issue is not resolved.
    - `subtasks`: `{"done": 2, "total": 5}`.
@@ -35,10 +35,16 @@ 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).
+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" or "every sprint is closed and summarised once", skip to step 4b. 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).
+4b. Write each sprint's goal and summary, after step 4a. Run `pmos jira summary`. Each line is a sprint that needs one: its name, its state, its number of issues and Jira's goal. A closed sprint that is already summarised is listed as kept: do not write it again. If it prints "no sprint needs a summary", skip this step. For each listed sprint, read its issues in the sprint search result of step 4a and write:
+   - `goal`: `{"text": "<the goal>", "jira": "<Jira's goal, or null>"}`. Always write the goal yourself from the sprint's tickets, in one sentence of at most 240 characters: what the sprint delivers when its tickets are done, naming the two or three largest outcomes. Do not copy Jira's sprint goal: it is often empty, too broad or incomplete. Put Jira's own goal in `"jira"` only as a reference, exactly as Jira writes it.
+   - `summary`: two to four plain sentences on what the team is working on: what is done, what is moving, what is blocked. For a closed sprint, say if the goal was met and what moved to the next sprint.
+   - `themes`: one entry per group of related tickets, at most 8, largest first: `{"title", "line", "tickets", "done", "blocked", "people", "initiative"}`. Group by initiative when the tickets belong to one (the initiative id from step 1); put tickets with no initiative in one theme such as "Fixes and upkeep" with `"initiative": null`. `line` is one sentence; `people` is the assignees' first names, comma-separated.
+   - For a closed sprint, also `closed`: `{"done", "total", "carried", "carriedTo", "points"}` (`points` as "31 of 38" when the tickets have points).
+   Use only what the tickets say. Never invent work, a date or a person. Save `{"sprints": [{"name", "id", "state", "goal", "summary", "themes", "closed"}]}` in the scratch folder, run `pmos jira summary --from <the file>`, and delete the file.
 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, and how many issues the sprint read saved per sprint.
+   - 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, how many issues the sprint read saved per sprint, and which sprints got a goal and summary (and whose goal you wrote from the tickets).
    - 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.