create-pmos 0.531.0 → 0.532.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.531.0",
+  "version": "0.532.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": {
@@ -32,6 +32,19 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.532.0",
+      "at": "2026-11-04T19:01:35.763Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1248,
+          "t": "Report templates T02–T08",
+          "s": "Report templates T02–T08",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.531.0",
       "at": "2026-11-04T18:44:50.726Z",
@@ -406,19 +419,6 @@
           "k": "new"
         }
       ]
-    },
-    {
-      "v": "0.512.0",
-      "at": "2026-11-03T15:33:10.629Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1204,
-          "t": "Suggest the next prompt and sharpen a rough one in the chat",
-          "s": "Suggest the next prompt and sharpen a rough one in the chat",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@add0a4c9
+kernel-source: pmos@c8e1d796
 assembled: 2026-11-04
 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-11-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 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-11-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 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-11-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "v": "0.532.0",
+  "at": "2026-11-04T19:01:35.763Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1248,
+    "t": "Report templates T02–T08",
+    "s": "Report templates T02–T08",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.531.0",
   "at": "2026-11-04T18:44:50.726Z",

package/workspace/guide/reports.md

@@ -92,6 +92,8 @@ pmos report issue biweekly 2026-10-16
 
 `pmos report library` writes one page with every slide layout of the report library, filled with placeholder words. Open it in a browser to see the layouts a report can use. Add `--out <file>` to choose the file.
 
+The library also has seven report templates: weekly-review, program-kickoff, meeting-recap, portfolio-snapshot, quarterly-review, decision-brief and incident-review. A template is a default order of slides, not a fixed structure. `pmos report library --template <id>` draws one template with placeholder words. `pmos report make <id> --template <id>` starts a report from it: the writer uses its order and adds or drops slides when the findings say so. A recurring report keeps the outline its readers agreed, so the template is used only for a report that has none.
+
 Every command accepts `--root <dir>` to name the repository. `draft` and `list` also accept `--json`.
 
 ## The window

package/workspace/lib/report-cli.js

@@ -40,7 +40,7 @@ const { parseArgs } = require('./schedule-cli');
 const COMMANDS = { report: ['make', 'read', 'find', 'write', 'check', 'rule', 'draft', 'issue', 'list', 'propose', 'definitions', 'setups', 'finder', 'library'] };
 const USAGE = [
   'usage: pmos report make|read|find|write|check|rule — the report engine: brief, read, find, answer, render (any report, any shape)',
-  '  pmos report make <id> [--ask "<the question>"] [--readers "<who>"] [--source <kind:ref>,…] [--slot <date>]',
+  '  pmos report make <id> [--ask "<the question>"] [--readers "<who>"] [--source <kind:ref>,…] [--template <id>] [--slot <date>]',
   '      Steps 1 to 3: derive the brief (readers, question, window, sources; no section list), read every source PMOS reaches,',
   '      and find what changed. An ad hoc report needs --ask. Sources: pmos · pack:<state file of readings> · connector:<name> · document:<path>.',
   '  pmos report read <id> [--slot <date>] --from <file|->',
@@ -54,8 +54,9 @@ const USAGE = [
   '  pmos report check <id> [--slot <date>]       the checks of the last write: substance first, then form',
   '  pmos report rule <id> list | add <voice|wording|off|keep> "<text or part>" | remove <n>',
   '      What the readers taught this report: a voice or wording rule, or a part beyond the ask turned off or kept.',
-  'usage: pmos report library [--out <file>] — the slide library: every layout in the report frame, with placeholder words',
+  'usage: pmos report library [--template <id>] [--out <file>] [--json] — the slide library: every layout in the report frame, with placeholder words',
   '      Writes one HTML page (default: report-library.html in the current folder). Open it in a browser to check the look.',
+  '      --template draws one report template (its card, then each part); --json lists the templates and the layouts.',
   'usage: pmos report draft|issue|list — cadence reports (for example the biweekly)',
   '  pmos report draft <cadence> [<slot>] [--now <time>] [--redraft]',
   '      Write the draft for a slot (default: today) with every number. Refuses a slot that has a draft;',
@@ -76,9 +77,9 @@ const USAGE = [
   '  every command: [--json] [--root <dir>]. The cadence is the report skill id without "report-", for example biweekly.',
 ];
 const BOOL = new Set(['json', 'redraft', 'help']);
-const VALUE = new Set(['now', 'root', 'ask', 'readers', 'source', 'slot', 'from', 'out']);
-const ALLOWED = { make: ['json', 'now', 'root', 'ask', 'readers', 'source', 'slot'], read: ['json', 'now', 'root', 'slot', 'from', 'source'], find: ['json', 'now', 'root', 'slot', 'from'],
-  write: ['json', 'now', 'root', 'slot', 'from'], check: ['json', 'root', 'slot'], rule: ['json', 'root'], draft: ['json', 'redraft', 'now', 'root'], issue: ['root'], list: ['json', 'root'], propose: ['json', 'root'], definitions: ['json', 'root'], setups: ['json', 'root'], finder: ['json', 'root'], library: ['json', 'out'] };
+const VALUE = new Set(['now', 'root', 'ask', 'readers', 'source', 'slot', 'from', 'out', 'template']);
+const ALLOWED = { make: ['json', 'now', 'root', 'ask', 'readers', 'source', 'slot', 'template'], read: ['json', 'now', 'root', 'slot', 'from', 'source'], find: ['json', 'now', 'root', 'slot', 'from'],
+  write: ['json', 'now', 'root', 'slot', 'from'], check: ['json', 'root', 'slot'], rule: ['json', 'root'], draft: ['json', 'redraft', 'now', 'root'], issue: ['root'], list: ['json', 'root'], propose: ['json', 'root'], definitions: ['json', 'root'], setups: ['json', 'root'], finder: ['json', 'root'], library: ['json', 'out', 'template'] };
 const CADENCE_RE = /^[a-z][a-z0-9-]{0,39}$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -151,9 +152,15 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     // the slide library as one page: sanitized as a report render is, with the workspace face inlined so the file shows it anywhere
     const out = path.resolve(cwd || process.cwd(), typeof flags.out === 'string' && flags.out ? flags.out : 'report-library.html');
     const D = require('./report-design.js');
+    const LB = require('./report-library.js');
+    if (flags.template !== undefined && !LB.templateOf(String(flags.template))) return fail(`there is no report template ${flags.template}. The templates: ${LB.TEMPLATES.map((t) => t.id).join(', ')}`, 2);
+    if (json && flags.out === undefined && flags.template === undefined) {
+      say(JSON.stringify({ ok: true, layouts: require('./report-slides.js').LAYOUTS.filter((x) => x !== 'blocks'), templates: LB.TEMPLATES.map((t) => ({ id: t.id, name: t.name, use: t.use, readers: t.readers, cadence: t.cadence, outline: t.outline })) }));
+      return 0;
+    }
     let face = '';
     try { face = `<style>@font-face{font-family:"Plus Jakarta Sans";font-weight:200 800;src:url(data:font/woff2;base64,${fs.readFileSync(path.join(__dirname, '..', 'public', 'vendor', 'plus-jakarta-sans-var.woff2')).toString('base64')}) format("woff2")}body{margin:0;background:#888}.pmos-slide{margin:0 auto 12px}</style>`; } catch { face = ''; }
-    const html = D.sanitize(require('./report-library.js').libraryHtml());
+    const html = D.sanitize(LB.libraryHtml(flags.template ? { template: String(flags.template) } : {}));
     try { fs.writeFileSync(out, html.replace('<style>', face + '<style>')); } catch (e) { return fail(`could not write ${out}: ${String((e && e.message) || e).slice(0, 160)}`); }
     if (json) say(JSON.stringify({ ok: true, path: out })); else say(`Wrote ${out}`);
     return 0;
@@ -232,7 +239,7 @@ function engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin
     return 0;
   };
   if (verb === 'make') {
-    const m = RE.make(root, id, { slot: day, ask: flags.ask, readers: flags.readers, sources, now: clock });
+    const m = RE.make(root, id, { slot: day, ask: flags.ask, readers: flags.readers, sources, template: flags.template, now: clock });
     if (!m.ok) return fail(m.error);
     return summary(m);
   }

package/workspace/lib/report-engine.js

@@ -205,7 +205,7 @@ function issuedSlots(root, id) {
 /** The headings of a document the engine did not write: the agreed outline of an older issue. */
 const headingsOf = (md) => str(md).replace(/^---[\s\S]*?\n---\n?/, '').split('\n').filter((l) => /^## /.test(l)).map((l) => l.slice(3).trim()).filter(Boolean);
 
-function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {}) {
+function briefOf(root, id, { slot, ask, readers, sources, template, now = Date.now() } = {}) {
   if (!ID_RE.test(str(id))) return refuse(400, 'the report id is lower case letters, digits and dashes, at most 40, starting with a letter');
   const today = slot || dayOf(now);
   if (!isDate(today)) return refuse(400, 'the slot is a date, YYYY-MM-DD');
@@ -213,7 +213,7 @@ function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {
   const P = paths(abs, id, today);
   const from = [];
   const brief = { v: 1, id, slot: today, title: null, readers: null, question: null, questions: [], decision: null, window: null, sources: [], recurring: false,
-    cycle_days: null, agreed_outline: [], earlier_outline: [], last_issue: null, carried_asks: [], rules: [], voice: VOICE.slice(), from };
+    cycle_days: null, agreed_outline: [], earlier_outline: [], template: null, last_issue: null, carried_asks: [], rules: [], voice: VOICE.slice(), from };
 
   // the definition: readers, the question (its purpose), the sources, the cadence
   let def = null; let defText = '';
@@ -280,6 +280,12 @@ function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {
     }
     from.push(LP.md.rel);
   }
+  // a report template (lib/report-library.js) is a default order of slide layouts for a report with no agreed outline; the agreed one wins
+  if (template) {
+    const t = require('./report-library.js').templateOf(str(template));
+    if (!t) return refuse(400, `there is no report template ${template}. The templates: ${require('./report-library.js').TEMPLATES.map((x) => x.id).join(', ')}`);
+    if (!brief.agreed_outline.length) { from.push(`template:${t.id}`); brief.template = { id: t.id, name: t.name, outline: t.outline.map((o) => ({ part: o.part, layout: o.layout })) }; }
+  }
   brief.rules = rulesOf(abs, id);
   for (const r of brief.rules) if (r.kind === 'voice' || r.kind === 'wording') brief.voice.push(r.text);
   return { ok: true, brief };
@@ -763,7 +769,7 @@ function drawBlock(b, r, byId) {
 // ── the steps, written ──────────────────────────────────────────────────────────────────────────────────────────────
 function isIssued(root, id, slot) { return issuedSlots(root, id).includes(slot); }
 /** Steps 1–3: the brief, the readings, the findings, written next to the draft. Filed readings and findings are kept across a re-read. */
-function make(root, id, { slot, ask, readers, sources, add, gaps, addFindings, now = Date.now() } = {}) {
+function make(root, id, { slot, ask, readers, sources, template, add, gaps, addFindings, now = Date.now() } = {}) {
   const abs = path.resolve(String(root));
   const day = slot || dayOf(now);
   let P; try { P = paths(abs, id, day); } catch (e) { return refuse(400, e.message); }
@@ -771,6 +777,7 @@ function make(root, id, { slot, ask, readers, sources, add, gaps, addFindings, n
   const old = readJson(P.brief.abs);
   // a re-read keeps the brief's chat question and named sources unless new ones are given
   const b = briefOf(abs, id, { slot: day, now, ask: ask || (old && old.from && old.from.includes('chat') ? old.question : undefined), readers: readers || (old && old.from && old.from.includes('readers') ? old.readers : undefined),
+    template: template || (old && old.template ? old.template.id : undefined),
     sources: [...(old ? old.sources.filter((s) => s.kind === 'pack' || s.kind === 'connector' || s.kind === 'document') : []), ...(sources || [])] });
   if (!b.ok) return b;
   const rd = readingsOf(abs, b.brief, { add, gaps, keep: readJson(P.readings.abs), now });

package/workspace/lib/report-library.js

@@ -4,7 +4,9 @@
  * look can be checked against the boards in a browser, and what the tests draw.
  *
  *   sampleDeck({ today }) → { name, today, slides }   (pure; today = YYYY-MM-DD, default 2026-11-04, the canvas's day)
- *   libraryHtml(o)        → the sample deck as one page (lib/report-slides.js deckHtml)
+ *   libraryHtml(o)        → the sample deck as one page (lib/report-slides.js deckHtml); o.template = one template's deck instead
+ *   TEMPLATES · templateOf(id) → the 7 report templates (boards T02–T08): a default order of layouts, never a fixed structure
+ *   templateDeck(id, o)   → that template with placeholder words: its card, then each part in its layout
  *
  * Placeholder words only: nothing here is a reading, so it never goes into a report.
  */
@@ -69,8 +71,64 @@ function sampleDeck({ today = '2026-11-04' } = {}) {
       { date: '2026-11-10', time: '10:00', items: [{ length: '5 min', text: 'Item' }, { length: '15 min', text: 'Item' }, { length: '10 min', text: 'Item' }] }, 'How the agenda is built'),
   ];
   slides.forEach((s, i) => { s.n = i + 1; });
+  // the footer names the layout and the templates that use it (boards L01–L23)
+  for (const sl of slides) {
+    const uses = TEMPLATES.filter((t) => t.outline.some((o) => o.layout === sl.layout)).map((t) => t.name);
+    sl.source = ['Layout: ' + (NAMES[sl.layout] || sl.layout), uses.length ? uses.join(', ') : 'no template yet', 'placeholder data'].join(' · ');
+  }
   return { name: 'Slide layouts', today, slides };
 }
-const libraryHtml = (o) => RS.deckHtml(sampleDeck(o));
+/* THE TEMPLATES (canvas boards T02–T08). A template is a DEFAULT ORDER of layouts, never a fixed structure: the writer keeps what is true and
+ * adds or drops a slide when the findings say so (Wawan, 2026-11-03: no fixed structure). Each part: { part, layout }. A recurring report keeps
+ * the outline its readers agreed; a template only starts a report that has none. */
+const T = (id, name, title, sub, use, readers, cadence, parts) => Object.freeze({ id, name, title, sub, use, readers, cadence,
+  outline: Object.freeze(parts.map(([part, layout]) => Object.freeze({ part, layout }))) });
+const TEMPLATES = Object.freeze([
+  T('weekly-review', 'Weekly Review', 'Weekly Review: what moved, what slipped, what waits on you', 'Eight slides. Read in five minutes.', 'Every Monday for a team lead or sponsor.', 'team lead, sponsor', 'weekly',
+    [['Title with agenda', 'overview'], ['This week', 'tiles'], ['Key results', 'ledger'], ['What changed', 'compare'], ['The week', 'schedule'], ['Asks', 'decisions'], ['Next week', 'agenda'], ['Sources', 'sources']]),
+  T('program-kickoff', 'Program Kick-off', 'Program Kick-off: why, who, when, risks, first thirty days', 'Ten slides. Presented once, then kept as the charter.', 'At the start of a program or initiative.', 'sponsor, leads, partners', 'once per program',
+    [['Title', 'overview'], ['Why', 'statement'], ['Scope', 'lists'], ['People', 'people'], ['Milestones', 'timeline'], ['Risks', 'risks'], ['Ways of working', 'agenda'], ['Success', 'tiles'], ['First 30 days', 'focus'], ['Decisions', 'decisions']]),
+  T('meeting-recap', 'Meeting Recap', 'Meeting Recap: decisions, actions, open questions', 'Seven slides. The two-minute read for people who were not there.', 'Within an hour of a meeting.', 'attendees and absentees', 'after each meeting',
+    [['Title', 'overview'], ['The short version', 'agenda'], ['Decisions', 'quotes'], ['Action items', 'actions'], ['Discussion', 'minutes'], ['Open and parked', 'lists'], ['Next', 'next']]),
+  T('portfolio-snapshot', 'Portfolio Snapshot', 'Portfolio Snapshot: health, money, dependencies, decisions', 'Nine slides. One sitting.', 'For leadership who own several programs.', 'leadership', 'every two weeks',
+    [['Title', 'overview'], ['Health', 'donut'], ['Heatmap', 'heatmap'], ['Timeline', 'timeline'], ['Money and outcome', 'bubbles'], ['Top risks', 'risks'], ['Dependencies', 'network'], ['Spotlight', 'compare'], ['Decisions', 'decisions']]),
+  T('quarterly-review', 'Quarterly Review', 'Quarterly Review: answer first, then goals, bets, decisions', 'Nine slides. Leads with the answer, ends with sources.', 'At the end of each quarter.', 'leadership, board', 'quarterly',
+    [['Title', 'overview'], ['Answer', 'statement'], ['Scorecard', 'tiles'], ['Timeline', 'timeline'], ['Wins and misses', 'lists'], ['Risks', 'risks'], ['Bets', 'ranked'], ['Decisions', 'decisions'], ['Sources', 'sources']]),
+  T('decision-brief', 'Decision Brief', 'Decision Brief: the question, the options, the pick', 'Six slides. For a single call that needs a yes.', 'When one person must decide and needs the facts.', 'the decider', 'ad hoc',
+    [['The question', 'statement'], ['Options', 'compare'], ['Ranked by impact', 'ranked'], ['Risks of the pick', 'risks'], ['The ask', 'decisions'], ['Sources', 'sources']]),
+  T('incident-review', 'Incident Review', 'Incident Review: what happened, why, what we change', 'Six slides. Blameless and short.', 'Within a week of an incident.', 'engineering, support, leadership', 'after incident',
+    [['What happened', 'statement'], ['Timeline of the day', 'timeline'], ['Causes ranked', 'ranked'], ['What went well and not', 'lists'], ['Actions', 'actions'], ['Sources', 'sources']]),
+]);
+const templateOf = (id) => TEMPLATES.find((t) => t.id === id) || null;
+const NAMES = { overview: 'Overview', tiles: 'Tiles', ledger: 'Ledger', timeline: 'Timeline', compare: 'Compare', lists: 'Two lists', risks: 'Risk table', ranked: 'Ranked list',
+  decisions: 'Decisions', quotes: 'Quotes', actions: 'Actions', agenda: 'Agenda', heatmap: 'Heatmap', network: 'Network', schedule: 'Schedule', donut: 'Donut', bubbles: 'Bubbles',
+  people: 'People', statement: 'Statement', sources: 'Sources', minutes: 'Minutes', focus: 'Focus', next: 'Next' };
+/* One row per part (the agenda numbers them); past eight parts, two parts share a row ("Title · Why"), as the canvas cards pair them. */
+function cardRows(outline) {
+  const one = outline.map((o) => ({ title: o.part, text: NAMES[o.layout] || o.layout }));
+  if (one.length <= 8) return one;
+  const rows = [];
+  for (let i = 0; i < one.length; i += 2) rows.push(one[i + 1] ? { title: `${one[i].title} · ${one[i + 1].title}`, text: `${one[i].text} · ${one[i + 1].text}` } : one[i]);
+  return rows;
+}
+/** The template's card (boards T02–T08): its default order as numbered rows, and when to use it in the insight column. */
+function templateCard(t) {
+  return { layout: 'agenda', eyebrow: `${t.name} · Report template`, title: t.title, sub: t.sub,
+    data: { rows: cardRows(t.outline) },
+    insight: { head: 'When to use it', text: t.use, points: [{ tone: 'ok', text: `Readers: ${t.readers}` }, { tone: 'ok', text: `Cadence: ${t.cadence}` }, { tone: 'watch', text: 'Add or drop slides when the findings say so' }],
+      note: 'Order is the default; the writer may change it per report.' },
+    source: 'Template library · sample data' };
+}
+/** A template drawn with placeholder words: its card, then each part in its layout (the sample of that layout, titled by the part). */
+function templateDeck(id, o = {}) {
+  const t = templateOf(id);
+  if (!t) return null;
+  const lib = sampleDeck(o).slides;
+  const slides = [templateCard(t)].concat(t.outline.map((p) => { const s = lib.find((x) => x.layout === p.layout); return { ...s, eyebrow: `${t.name} · ${p.part}`, title: p.part, sub: s.title, source: 'Template library · placeholder data' }; }));
+  slides.forEach((s, i) => { s.n = i + 1; });
+  return { name: t.name, today: o.today || '2026-11-04', slides };
+}
+/** The library page: every layout, or one template (o.template). */
+const libraryHtml = (o = {}) => RS.deckHtml(o.template ? templateDeck(o.template, o) : sampleDeck(o));
 
-module.exports = { sampleDeck, libraryHtml };
+module.exports = { sampleDeck, libraryHtml, TEMPLATES, templateOf, templateCard, templateDeck };

package/workspace/lib/report-slides.js

@@ -78,7 +78,7 @@ const SPEC = {
   decisions: { rows: { max: 3, min: 1, item: { question: 't', pick: 't', who: 't', by: 'date' } } },
   quotes: { agreed: 't', quotes: { max: 3, min: 1, item: { text: 't', who: 't', at: 't' } } },
   actions: { rows: { max: 6, min: 1, item: { text: 't', who: 't', due: 'date' } } },
-  agenda: { rows: { max: 5, min: 1, item: { title: 't', text: 't' } } },
+  agenda: { rows: { max: 8, min: 1, item: { title: 't', text: 't' } } },
   heatmap: { cols: { max: 6, min: 1, text: true }, total: 't', rows: { max: 6, min: 1, item: { name: 't', total: 't', cells: { max: 6, min: 1, item: { text: 't', tone: 'tone' } } } } },
   network: { nodes: { max: 8, min: 2, item: { id: 'id', label: 't', tone: 'tone' } }, edges: { max: 12, min: 1, pair: true } },
   schedule: { cols: { max: 7, min: 1, text: true }, rows: { max: 6, min: 1, item: { name: 't', from: 'i', to: 'i', text: 't', tone: 'tone' } } },

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.531.0",
+  "version": "0.532.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.531.0",
+      "version": "0.532.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

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

package/workspace/skills/report-write.skill

@@ -26,12 +26,14 @@ Procedure:
 1. Run `pmos report make <id>`. For an ad hoc report add `--ask "<the question>"`, and `--readers "<who>"` when you know them. Name sources the brief must read with `--source`, comma-separated: `connector:<name>=<what it is>` (Jira, BigQuery for GA4, Confluence, …), `document:<path>`, `pack:<state file of readings>`, `pmos` (the PMOS ledgers). It writes `<slot>.brief.json`, `<slot>.readings.json` and `<slot>.findings.json` next to the draft, and prints the gaps.
    - If it refuses because the slot is issued, stop: an issued report is frozen.
    - If it says there is no report with that id, it needs a question: ask the PM once for the question, or take it from the chat line.
+   - When the PM names a kind of report that a template fits (a weekly review, a kick-off, a meeting recap, a portfolio snapshot, a quarterly review, a decision brief, an incident review), add `--template <id>`.
 2. Read `<slot>.brief.json`: the readers, the questions, the window, the sources, the last issue, the agreed outline, the carried asks, the voice and the rules.
 3. Read each source that the gaps name, through its connector or the file, read-only. Write what you read as readings in one JSON file: `{"readings":[{"id":"web-login-rate","value":81,"unit":"%","n":597,"of":733,"at":"2026-10-19","source":"ga4","how":"events_20261019, sessions with a password start","label":"Web password login, recorded success"}],"gaps":[{"source":"native-app","reason":"read only on the device"}]}`. Give `target` and `better` ("higher" or "lower") when the reading has a target. Give `flag` when the reading is off what the readers expect. Run `pmos report read <id> --from <file>`. A parameter of a method (a 5-second match window) is a reading too.
 4. Find what answers the readers. Write the findings that answer each question, each citing the readings it rests on, and run `pmos report find <id> --from <file>` with `{"findings":[{"text":"…","readings":["…"],"kind":"answers-question","question":"…"}]}`. The engine adds its own findings: changes since the last issue, misses against a target, initiatives off plan, items due within 14 days, the asks carried over. If `<slot>.findings.json` says `"none": true`, there is nothing to report: stop and say so in one line. Do not write a report about nothing.
 5. Choose the outline for these readers and this question. Any sections, any titles, any order.
    - A recurring report keeps `agreed_outline`, the sections of its last issued issue. Add a section only when a finding needs one, drop one only when it would be empty, and say so in `outline_note` (one line).
    - `earlier_outline` is the shape of an issue written before the engine (the old fixed frame). It is an example, not an agreement: keep what served the readers.
+   - `template` is set when the PM started the report from a report template (`pmos report make <id> --template <name>`; `pmos report library --json` lists them). Its `outline` is a default order of parts, each with its slide layout: use it as the starting outline, retitle each part as a finding, and add or drop a part when the findings say so. An agreed outline wins over a template.
    - Each section title is a finding, not a label: "Sign-up stalls before submit", not "Sign-up". Reading only the titles tells the story.
    - Shapes other reports took, as examples and never a menu: a decision (the lean · the options and what each costs · what could reverse it · your call); a watch (today against yesterday and the week · the drop that moved most · why); a stakeholder update (are the dates on track · what each team needs and by when · open decisions · what could stop it); a review (the summary for decision · the outcomes by segment · the challenges and answers · method); did-it-work (what was promised · what we got · the verdict).
 6. Write `<slot>.report.json` (in a scratch file, then `pmos report write <id> --from <file>`):