create-pmos 0.204.0 → 0.206.0

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

@@ -1,18 +1,43 @@
-/* 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: jira|none|broad|partial, text, jira, unchecked? } | null, 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 from Jira, or written from the tickets and saying why; 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 WHY = { none: 'Jira has no goal for this sprint.', broad: 'The goal in Jira is too broad to tell what this sprint delivers.', partial: 'The goal in Jira leaves out part of the sprint.' };
+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: Jira's when it says what the sprint delivers; else written from the tickets, with why and Jira's own text underneath. */
+function goalBlock(g) {
+  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.')));
+  const derived = g.from !== 'jira';
+  return el('div', { class: 'lh', 'data-inb': 'sprint-goal', 'data-inb-goal': g.from }, el('span', { class: 'ki' }, icon('target')),
+    el('div', { class: 'ini-sp-goal' }, lbl(derived ? 'SPRINT GOAL · written from the tickets' : 'SPRINT GOAL · from Jira'), el('b', null, g.text),
+      derived ? el('div', { class: 'dim ini-sp-note', 'data-inb': 'sprint-goal-why' }, (WHY[g.from] || '') + (g.jira ? ' In Jira: “' + g.jira + '”' : '')) : null));
+}
+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.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 +56,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.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', 'From Jira when it says what the sprint delivers, otherwise written from the tickets'], ['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/public/pm/c3-shell.js

@@ -624,6 +624,8 @@ async function boot() {
   const saved = DEMO ? null : await pmGet('/api/settings' + (S.ws ? '?ws=' + encodeURIComponent(S.ws) : '')).catch(() => null);   // demo mode's workspace is not registered
   if (saved && saved.ok) { applyLook(root, saved.settings); if (!start) { const s = (saved.settings || []).find((x) => x.key === 'look.start'); if (s && BUILD[s.value]) start = s.value; } }
   if (q.get('focus') || q.get('fdate')) import('./c3-focus.js').then((m) => m.openFocus({ event: { id: q.get('focus') || '', ...(q.get('fat') ? { at: q.get('fat'), title: q.get('ftitle') || '' } : {}) }, date: q.get('fdate') || '', pop: q.get('pop') === '1', meet: q.get('meet') || '', mtitle: q.get('mtitle') || '' })).catch(() => { /* the focus page is not available */ });   // a reload keeps the Meeting focus page open; ?pop=1 is its compact form for the Chrome extension (focus=now asks which meeting the Meet call is)
+  /* ?studio=<report id> opens that report's design studio over the Reports tab (the PMOS Chrome extension's Open the studio). */
+  if (q.get('studio') && /^[a-z][a-z0-9-]{0,39}$/.test(q.get('studio'))) { if (!start) start = 'rep'; import('./c3-design-studio.js').then((m) => m.openStudio({ ws: S.ws, id: q.get('studio'), name: '' })).catch(() => { /* the studio is not available */ }); }
   if (!S.userNav) showTab(start || 'brief', false);   // a press during the read above (the gear, a tab) wins over the start page
   new ResizeObserver(moveInd).observe(S.tabNav);
   workCount(); briefCount(); askCount(); S.dock.start();

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`: `{"from": "jira", "text": "<Jira's goal>"}` when Jira's goal says what the sprint delivers. Otherwise write the goal from the sprint's tickets in one sentence (at most 240 characters), and say why: `"from": "none"` when Jira has no goal, `"broad"` when Jira's goal is too broad to tell what the sprint delivers (for example "Q4 delivery"), `"partial"` when it leaves out a large part of the sprint's tickets. With `broad` or `partial`, put Jira's own goal in `"jira"`.
+   - `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.
 

package/workspace/skills/report-design.skill

@@ -38,6 +38,7 @@ The modes:
 
 How to read a sample:
 - A PDF or an image: read the file with Read and look at every page. Follow its look closely: the grid and the place of each part, the colours, the header and footer bands, the type sizes, how dense each slide or page is, and the slide kinds and their order. Say in "took" what you followed.
+- Pictures of a web page (a sample the PM added from Chrome): the lines name every picture file, in order, top to bottom. Read every one with Read, as you would the pages of a PDF, and follow the look closely in the same way. They are one long page cut into screens, so do not read them as separate slides. Say in "took" what you followed.
 - A .pptx or a .docx: read its words in the .txt file named for it. You cannot see its look, only its words and order.
 - A report document: read the .md file named for it.
 - A link: when the lines name a .txt copy for it, read that file. It holds the words and the structure of the linked file (slide titles, order, sections, tables), copied through the PM's connectors. It does not show the look, so take the look from a PDF or an image sample, and say so in "took". When the lines name no copy, you have no web tool: say so with "readable": false.

package/workspace/test-lists/report-design-studio-ui.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "report-design-studio UI slice: the design studio, the deck of a cycle in the Read tab, Present, speaker notes and notes on the slide, Print / PDF, the document design and the Slide deck output, in demo mode; and the same flows against the real backend with a stub claude (c3-report-design-real-test.js).",
-  "panels": ["c3-report-design-test.js", "c3-report-design-real-test.js"],
-  "seconds": { "c3-report-design-test.js": 75, "c3-report-design-real-test.js": 40 }
+  "_comment": "report-design-studio UI slice: the design studio, the deck of a cycle in the Read tab, Present, speaker notes and notes on the slide, Print / PDF, the document design and the Slide deck output, in demo mode; and the same flows against the real backend with a stub claude (c3-report-design-real-test.js); and the PMOS Chrome extension's popup page against the real backend, with a parent page that plays the extension (c3-capture-test.js).",
+  "panels": ["c3-report-design-test.js", "c3-report-design-real-test.js", "c3-capture-test.js"],
+  "seconds": { "c3-report-design-test.js": 75, "c3-report-design-real-test.js": 40, "c3-capture-test.js": 40 }
 }