create-pmos 0.535.0 → 0.536.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.535.0",
+  "version": "0.536.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.536.0",
+      "at": "2026-11-05T10:03:22.177Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1252,
+          "t": "Apply an order to a report draft, and save my own",
+          "s": "Apply an order to a report draft, and save my own",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.535.0",
       "at": "2026-11-05T09:07:13.086Z",
@@ -398,27 +411,6 @@
           "k": "new"
         }
       ]
-    },
-    {
-      "v": "0.516.0",
-      "at": "2026-11-04T00:00:07.601Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1209,
-          "t": "Runbook of what Claude does behind the scenes, in the guide",
-          "s": "Runbook of what Claude does behind the scenes, in the guide",
-          "k": "x",
-          "h": "See what Claude does behind the scenes",
-          "d": "Claude's background jobs were explained one page at a time, and nothing listed them all together. One guide page lists every job Claude runs by itself: when it runs, what it reads, where you see the result, how to stop it, and what Claude fixes without asking."
-        },
-        {
-          "n": 1208,
-          "t": "Reports that need you come first, one ✓ each (redesign R)",
-          "s": "Reports that need you come first, one ✓ each (redesign R)",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@8d1f39b1
+kernel-source: pmos@6d70978e
 assembled: 2026-11-05
 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-05T09:07:09Z"}
+generated: {by: process:create-pmos, at: "2026-11-05T10:03:18Z"}
 status: stable
 ---
 

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-11-05T09:07:09Z"}
+generated: {by: process:create-pmos, at: "2026-11-05T10:03:18Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-11-05T09:07:09Z"}
+generated: {by: process:create-pmos, at: "2026-11-05T10:03:18Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "v": "0.536.0",
+  "at": "2026-11-05T10:03:22.177Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1252,
+    "t": "Apply an order to a report draft, and save my own",
+    "s": "Apply an order to a report draft, and save my own",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.535.0",
   "at": "2026-11-05T09:07:13.086Z",

package/workspace/guide/reports.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Reports: draft and issue a cadence report"
 description: "How pmos report drafts a cadence report with every number, how the notes are kept when you draft again, and how you issue and freeze a report."
-timestamp: 2026-11-04
+timestamp: 2026-11-05
 ---
 
 # Reports: draft and issue a cadence report
@@ -65,6 +65,16 @@ When you draft a slot again, every note stays as you wrote it, next to its initi
 
 When you ask Claude in a chat to change a report, the change goes to the latest draft of that report, in its own file. The report's session edits only the notes that the change is about, even when they have text, and keeps every other note and every number as it is. It keeps each caveat (a sentence that says something is provisional, not decided or unverified), also when you ask for shorter text, and it tells you which notes it changed and quotes any sentence it removed. It drafts the same slot again only when you ask for fresh numbers. It never drafts a new slot for today. A change to a number, a date, a section or a slide is not made in the draft: the session tells you which setting to change in the template or the studio. If the latest cycle is issued, it is frozen, and the change is not passed on.
 
+## Orders: the slide order of a draft
+
+An order is a default order of slides, for example the Weekly Review order. The writer keeps every reading, retitles each part as a finding, and adds or drops a part when the findings say so. PMOS has seven orders. You can also save your own.
+
+- **Claude's pick.** When an order fits the question of a draft better than its own order, a ✦ shows under the slides. It names the order and the parts that it adds (in blue) or drops (struck through). Press ✓ to write the draft again in that order. Press ✕ to hide the ✦. No ✦ shows on an issued report, on a draft that started from an order, or when your readers agreed the order.
+- **The orders.** The grid icon under the summary opens the orders: the draft as it is now, your orders, then the seven PMOS orders. Each card shows its first slides and its number of slides. Press a card to see all its slides, its parts and what it changes in your draft. Press ✓ to write the draft again in that order.
+- **Agreed order.** When the readers agreed the order of the last issued report, today's draft stays as agreed. ✓ then reads "Use from the next cycle": the next draft starts in the order that you picked.
+- **The name and Undo.** The order's name shows under the summary, from the draft to the issued report. For one day after a redraft, the Undo icon puts the draft back as it was. An issued report is frozen: it has no Undo.
+- **My orders.** The bookmark icon under the summary saves the draft's order as yours. When you change a draft that started from an order, a ✦ asks if you want to save it. The bookmark under the slide saves one slide's layout to My slides. Only the parts and the slide layouts are saved, never the numbers or the words. Your orders are private and show first, marked Mine. You can rename and delete only your own orders. To use a saved slide in a draft is not possible yet.
+
 ## The commands
 
 `pmos report draft <cadence> [<slot>]` writes the draft to `planning/reports/<cadence>/<slot>.md`. The slot is a date, YYYY-MM-DD. If you do not give a slot, the slot is today. If a draft for the slot exists, the command stops and writes nothing. To draft the slot again and keep every note, add `--redraft`. To fix the clock, add `--now <time>`: two drafts with the same inputs and the same `--now` are the same, byte for byte.

package/workspace/lib/report-engine.js

@@ -55,6 +55,7 @@ const READING_ID_RE = /^[a-z0-9][a-z0-9._-]{0,80}$/;
 const SOURCE_ID_RE = /^[a-z0-9][a-z0-9._-]{0,40}$/;
 const TOKEN_RE = /\{\{r:([a-z0-9][a-z0-9._-]{0,80})(?:\|(of|n|value|label))?\}\}/g;
 const DAY = 86400000;
+const NEXT_ORDER = 'order-next.json';   // the order the PM chose for the next cycle (lib/report-orders.js)
 const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
 const CYCLE_DAYS = { daily: 1, weekly: 7, biweekly: 14, 'bi-weekly': 14, monthly: 30, quarterly: 91 };
 const LIMITS = Object.freeze({ readings: 2000, findings: 60, sections: 30, blocks: 40, rows: 60, cols: 12, text: 2000, title: 240, rules: 60 });
@@ -205,6 +206,14 @@ 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);
 
+/** null when o is a usable order { id, name, outline: [{ part, layout }] } (1 to 30 parts, each layout one of lib/report-slides.js LAYOUTS), else why. */
+function orderError(o) {
+  if (!isObj(o) || !/^[a-z0-9][a-z0-9:-]{0,60}$/.test(str(o.id)) || !str(o.name).trim()) return 'an order has an id and a name';
+  if (!Array.isArray(o.outline) || !o.outline.length || o.outline.length > 30) return 'an order has 1 to 30 parts';
+  const L = require('./report-slides.js').LAYOUTS;
+  const bad = o.outline.find((p) => !isObj(p) || !str(p.part).trim() || !L.includes(str(p.layout)));
+  return bad ? `part ${JSON.stringify(bad && bad.part)} has no known layout` : null;
+}
 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);
@@ -281,10 +290,20 @@ function briefOf(root, id, { slot, ask, readers, sources, template, now = Date.n
     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
+  // template is an id of lib/report-library.js TEMPLATES, or an order already resolved ({ id, name, outline }: a saved "my order" or the brief's own,
+  // kept across a re-read). chosen: the PM pressed ✓ on it for this cycle, so it wins over the agreed outline (batch 27 item 16, lib/report-orders.js).
+  // an order the PM chose on an agreed outline "from the next cycle" (lib/report-orders.js setNext): a later slot starts from it
+  if (!template) { const nx = readJson(path.join(paths(abs, id).dir, NEXT_ORDER)); if (nx && isObj(nx.order) && isDate(nx.from) && today > nx.from) template = { ...nx.order, chosen: true }; }
   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 })) }; }
+    const t = isObj(template) ? orderError(template) ? null : template : require('./report-library.js').templateOf(str(template));
+    if (!t) return refuse(400, isObj(template) ? `the order is not usable: ${orderError(template)}` : `there is no report template ${template}. The templates: ${require('./report-library.js').TEMPLATES.map((x) => x.id).join(', ')}`);
+    const chosen = !!(isObj(template) && template.chosen);
+    if (!brief.agreed_outline.length || chosen) {
+      from.push(`template:${t.id}`);
+      brief.template = { id: str(t.id), name: str(t.name), outline: t.outline.map((o) => ({ part: str(o.part), layout: str(o.layout) })), ...(chosen ? { chosen: true } : {}) };
+      // the PM chose another order over the agreed one: the agreed outline is kept as an example only
+      if (chosen && brief.agreed_outline.length) { brief.earlier_outline = brief.agreed_outline; brief.agreed_outline = []; }
+    }
   }
   brief.rules = rulesOf(abs, id);
   for (const r of brief.rules) if (r.kind === 'voice' || r.kind === 'wording') brief.voice.push(r.text);
@@ -778,7 +797,7 @@ function make(root, id, { slot, ask, readers, sources, template, add, gaps, addF
   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),
+    template: template || (old && old.template ? (!old.template.chosen && require('./report-library.js').templateOf(old.template.id) ? old.template.id : old.template) : 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 });
@@ -790,6 +809,8 @@ function make(root, id, { slot, ask, readers, sources, template, add, gaps, addF
   const fd = findingsOf(b.brief, rd, { prior, add: keepFiled.concat(Array.isArray(addFindings) ? addFindings : []) });
   if (fd.ok === false) return fd;
   writeJson(P.brief.abs, b.brief);
+  // the order chosen for the next cycle is used once: this brief now carries it, so the record goes
+  if (b.brief.template && b.brief.template.chosen) { const nf = path.join(P.dir, NEXT_ORDER); const nx = readJson(nf); if (nx && isObj(nx.order) && nx.order.id === b.brief.template.id && day > nx.from) { try { fs.unlinkSync(nf); } catch { /* already gone */ } } }
   writeJson(P.readings.abs, { at: rd.at, readings: rd.readings, gaps: rd.gaps });
   writeJson(P.findings.abs, fd);
   return { ok: true, brief: b.brief, readings: { readings: rd.readings, gaps: rd.gaps }, findings: fd, paths: { brief: P.brief.rel, readings: P.readings.rel, findings: P.findings.rel, report: P.report.rel, md: P.md.rel } };
@@ -834,7 +855,7 @@ function engineDeckOf(absMd, look) {
 }
 
 module.exports = {
-  ID_RE, BEYOND, BEYOND_KEYS, VOICE, RULE_KINDS, BLOCK_KINDS, LIMITS,
-  paths, briefOf, readingsOf, findingsOf, resolve, tokensIn, bareFigures, checkReport, shapeError, renderMarkdown, deckOf, make, write,
+  ID_RE, NEXT_ORDER, BEYOND, BEYOND_KEYS, VOICE, RULE_KINDS, BLOCK_KINDS, LIMITS,
+  paths, briefOf, orderError, readingsOf, findingsOf, resolve, tokensIn, bareFigures, checkReport, shapeError, renderMarkdown, deckOf, make, write,
   engineReportOf, engineDeckOf, rulesOf, addRule, removeRule, closeAsk, parseSource, sourcesFromText, full, valueText,
 };

package/workspace/lib/report-library.js

@@ -131,4 +131,4 @@ function templateDeck(id, o = {}) {
 /** 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, TEMPLATES, templateOf, templateCard, templateDeck };
+module.exports = { sampleDeck, libraryHtml, TEMPLATES, templateOf, templateCard, templateDeck, NAMES };

package/workspace/lib/report-orders.js

@@ -0,0 +1,218 @@
+'use strict';
+/* report-orders.js — apply an order to a report draft, and keep my own orders (batch 27 item 16, agreed by Wawan 2026-11-05 00:53 "Build the
+ * recommendation"; main canvas boards TpA, TpD, TpE; brief /mnt/project-files/feedback-batch-27/item16/build-brief.md).
+ *
+ * The app says "order", never "template": T<n> already names a report's saved settings (lib/report-templates.js). An ORDER is a default order of
+ * slide layouts, { id, name, outline: [{ part, layout }] }: the seven of lib/report-library.js TEMPLATES, or one the PM saved ("Mine"). It is never
+ * a fixed structure: the writer retitles each part as a finding and adds or drops a part when the findings say so.
+ *
+ *   partsOf(report, brief)            → [{ part, layout }]   the draft's order: one per section, named by its order's part or its layout (pure)
+ *   diff(now, order)                  → { adds: [part], drops: [part] }   by layout; the title and sources slides every deck has are left out (pure)
+ *   nowOf(brief, report)              → { kind: 'agreed'|'order'|'standard', id, name, parts, mine, edited, changes }   the draft's order (pure)
+ *   pick(brief, report)               → { id, name, adds, drops } | null   the ✦: the order that fits the report's question, by plain rules (pure)
+ *   orderOf(id, mine)                 → an order by id: a TEMPLATES id or a saved "mine-<n>" (mine = fold(...).orders)
+ *   previewDeck(order)                → the order drawn with placeholder words, one slide per part (lib/report-slides.js deckHtml takes it)
+ *   snapshot / undoOf / undo          the draft as it was before a redraft, kept one day (Undo)
+ *   setNext / nextOf                  an order chosen on an agreed outline, used from the next cycle (lib/report-engine.js briefOf reads it)
+ *   MY ORDERS (person level, private): <runtimeDir>/report-orders.jsonl, append only
+ *     { ev: 'save', id: 'mine-<n>', kind: 'order'|'slide', name, outline, from: { report, slot }, at }  { ev: 'rename', id, name, at }  { ev: 'remove', id, at }
+ *   fold(lines) → { orders, slides } (newest first) · readLines(dir) · save(dir, o) · rename(dir, id, name) · remove(dir, id)
+ *
+ * WHAT IS SAVED. Parts and slide layouts only. Never a number, a sentence or a reading: those belong to one cycle and would be stale. A part's
+ * name is its order's part name, else its layout's name ("Ledger"); never the section's title, which is a finding.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const RL = require('./report-library.js');
+
+const DAY = 86400000;
+const UNDO_FOR = DAY;                 // the previous draft is kept one day (TpA 3)
+const DRAFTING_FOR = 30 * 60000;      // a redraft that has not landed after 30 minutes is no longer "redrafting"
+const ALWAYS = new Set(['overview', 'sources']);   // the engine draws the title and the sources slides on every deck
+const LEDGER = 'report-orders.jsonl';
+const MINE_RE = /^mine-[1-9][0-9]{0,5}$/;
+const FILES = ['.md', '.report.json', '.brief.json', '.checks.json', '.findings.json'];
+const str = (v) => (typeof v === 'string' ? v : v == null ? '' : String(v));
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const nameOfLayout = (l) => (RL.NAMES[l] || (l === 'component' ? 'PMOS component' : 'Text'));
+const RE = () => require('./report-engine.js');
+
+/* ── the draft's order (pure) ── */
+/** One part per section of the engine's report, in order. The name comes from the order the draft began with (the first unused part of the same
+ *  layout), else from the layout. A section's own title is a finding, so it is never a part name. */
+function partsOf(report, brief) {
+  const secs = isObj(report) && Array.isArray(report.sections) ? report.sections : [];
+  const pool = (brief && brief.template && Array.isArray(brief.template.outline) ? brief.template.outline : []).map((p) => ({ ...p, used: false }));
+  return secs.map((s) => {
+    const layout = str(s.layout) || 'blocks';
+    const m = pool.find((p) => !p.used && p.layout === layout);
+    if (m) m.used = true;
+    return { part: m ? m.part : nameOfLayout(layout), layout };
+  });
+}
+const core = (parts) => (parts || []).filter((p) => !ALWAYS.has(p.layout));
+/** What an order adds to the draft and what it drops, matched by layout (a layout used twice counts twice). */
+function diff(now, order) {
+  const left = core(now).map((p) => ({ ...p, hit: false }));
+  const adds = [];
+  for (const p of core(order)) { const m = left.find((x) => !x.hit && x.layout === p.layout); if (m) m.hit = true; else adds.push(p.part); }
+  return { adds, drops: left.filter((x) => !x.hit).map((x) => x.part) };
+}
+const same = (d) => !d.adds.length && !d.drops.length;
+const isMine = (id) => MINE_RE.test(str(id));
+/** The draft's order: agreed with its readers, an order (edited or not), or the standard one the writer chose. */
+function nowOf(brief, report) {
+  const parts = partsOf(report, brief);
+  const b = brief || {};
+  if (Array.isArray(b.agreed_outline) && b.agreed_outline.length) return { kind: 'agreed', id: 'agreed', name: 'Agreed order', parts, mine: false, edited: false, changes: { adds: [], drops: [] }, since: b.last_issue || null };
+  if (b.template && b.template.id) {
+    const ch = report ? diff(b.template.outline, parts) : { adds: [], drops: [] };   // what the draft added to its order (adds) and dropped (drops)
+    return { kind: 'order', id: str(b.template.id), name: str(b.template.name), parts, mine: isMine(b.template.id), edited: !!report && !same(ch), changes: { adds: ch.adds, drops: ch.drops } };
+  }
+  return { kind: 'standard', id: 'standard', name: 'Standard order', parts, mine: false, edited: false, changes: { adds: [], drops: [] } };
+}
+
+/* ── the ✦ pick (pure). Plain rules over the brief's words, first match wins; no model. Silent (null) when the outline is agreed, when the draft
+ *  already began from an order, or when the order would change nothing. Claude's own pick while drafting is not proven yet (owed: 5 real drafts). */
+const RULES = [
+  ['incident-review', /\b(incident|outage|post-?mortem|downtime|sev ?[0-4]|root cause)\b/],
+  ['meeting-recap', /\b(meeting|recap|minutes|stand-?up|retro(spective)?|workshop)\b/],
+  ['decision-brief', /\b(decide|decision|should we|go\/no-go|approve|approval)\b/],
+  ['program-kickoff', /\b(kick-?off|charter|new program(me)?|program(me)? start)\b/],
+  ['portfolio-snapshot', /\b(portfolio|programs|programmes|across products)\b/],
+  ['quarterly-review', /\b(quarter(ly)?|q[1-4]|okr review|qbr)\b/],
+  ['weekly-review', /\b(weekly|this week|week in review|last week)\b/],
+];
+function pick(brief, report) {
+  const b = brief || {};
+  if ((Array.isArray(b.agreed_outline) && b.agreed_outline.length) || (b.template && b.template.id)) return null;
+  const words = [b.title, b.question, ...(Array.isArray(b.questions) ? b.questions : []), b.readers].map(str).join(' \n ').toLowerCase();
+  let id = (RULES.find(([, re]) => re.test(words)) || [])[0] || null;
+  if (!id && b.recurring && b.cycle_days === 7) id = 'weekly-review';
+  if (!id && b.recurring && b.cycle_days >= 80) id = 'quarterly-review';
+  const t = id ? RL.templateOf(id) : null;
+  if (!t) return null;
+  const d = diff(partsOf(report, b), t.outline);
+  return report && same(d) ? null : { id: t.id, name: t.name, ...d };
+}
+
+/* ── orders by id, and their pictures ── */
+function asOrder(o) { return { id: o.id, name: o.name, outline: o.outline.map((p) => ({ part: p.part, layout: p.layout })) }; }
+function orderOf(id, mine = []) {
+  const t = RL.templateOf(str(id));
+  if (t) return asOrder(t);
+  const m = isMine(id) ? (mine || []).find((x) => x.id === id) : null;
+  return m ? asOrder(m) : null;
+}
+/** One line under a card: what the order is for (a PMOS order) or when it was saved (mine). */
+function subOf(id, mine) { const t = RL.templateOf(id); if (t) return t.use; const m = (mine || []).find((x) => x.id === id); return m ? 'Saved ' + str(m.at).slice(0, 10) : ''; }
+/** The order with placeholder words: one slide per part, in its layout (the library's sample of that layout, titled by the part). */
+function previewDeck(order, o = {}) {
+  if (!order) return null;
+  const lib = RL.sampleDeck(o).slides;
+  const slides = order.outline.map((p) => {
+    const s = lib.find((x) => x.layout === p.layout) || { ...lib.find((x) => x.layout === 'statement'), layout: 'statement' };
+    return { ...s, eyebrow: `${order.name} · ${p.part}`, title: p.part, sub: s.title, source: 'Order · placeholder words' };
+  });
+  slides.forEach((s, i) => { s.n = i + 1; });
+  return { name: order.name, today: o.today || '2026-11-04', slides };
+}
+
+/* ── Undo: the draft before a redraft, kept one day ── */
+const sha = (t) => crypto.createHash('sha256').update(String(t)).digest('hex').slice(0, 16);
+const undoDir = (P, slot) => path.join(P.dir, '.undo', slot);
+function readJson(f) { try { const o = JSON.parse(fs.readFileSync(f, 'utf8')); return isObj(o) ? o : null; } catch { return null; } }
+/** Copy the draft's files aside before a redraft. One snapshot per slot: Undo gives back the draft as it was before the NEWEST redraft. */
+function snapshot(root, id, slot, { order = null, now = Date.now() } = {}) {
+  const P = RE().paths(root, id, slot);
+  const dir = undoDir(P, slot);
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(dir, { recursive: true });
+  const had = [];
+  for (const ext of FILES) { const f = path.join(P.dir, slot + ext); if (fs.existsSync(f)) { fs.copyFileSync(f, path.join(dir, slot + ext)); had.push(ext); } }
+  let md = ''; try { md = fs.readFileSync(P.md.abs, 'utf8'); } catch { /* no document yet */ }
+  const meta = { at: new Date(now).toISOString(), order: order ? { id: order.id, name: order.name } : null, had, md: sha(md) };
+  fs.writeFileSync(path.join(dir, 'meta.json'), JSON.stringify(meta) + '\n');
+  return meta;
+}
+/** The Undo of a slot: { at, until, order, state: 'drafting'|'done'|'late' } while its day lasts and the slot is not issued, else null.
+ *  drafting = the document has not changed since the press (the session still writes); late = it has not changed after 30 minutes. */
+function undoOf(root, id, slot, { now = Date.now(), issued = false } = {}) {
+  if (issued) return null;
+  let P; try { P = RE().paths(root, id, slot); } catch { return null; }
+  const meta = readJson(path.join(undoDir(P, slot), 'meta.json'));
+  if (!meta || !Number.isFinite(Date.parse(meta.at))) return null;
+  const at = Date.parse(meta.at);
+  if (now - at > UNDO_FOR) return null;
+  let md = ''; try { md = fs.readFileSync(P.md.abs, 'utf8'); } catch { /* gone */ }
+  const changed = sha(md) !== meta.md;
+  return { at: meta.at, until: new Date(at + UNDO_FOR).toISOString(), order: meta.order, state: changed ? 'done' : now - at > DRAFTING_FOR ? 'late' : 'drafting' };
+}
+/** Put the draft back as it was before the redraft: the files it had come back, the files it did not have go. */
+function undo(root, id, slot, o = {}) {
+  const u = undoOf(root, id, slot, o);
+  if (!u) return { ok: false, status: 409, error: 'there is nothing to undo on this draft' };
+  const P = RE().paths(root, id, slot); const dir = undoDir(P, slot);
+  const meta = readJson(path.join(dir, 'meta.json'));
+  for (const ext of FILES) {
+    const to = path.join(P.dir, slot + ext);
+    if (meta.had.includes(ext)) fs.copyFileSync(path.join(dir, slot + ext), to);
+    else fs.rmSync(to, { force: true });
+  }
+  fs.rmSync(dir, { recursive: true, force: true });
+  return { ok: true, order: u.order };
+}
+const dropUndo = (root, id, slot) => { try { const P = RE().paths(root, id, slot); fs.rmSync(undoDir(P, slot), { recursive: true, force: true }); } catch { /* none */ } };
+
+/* ── an order for the next cycle (an agreed outline: today's draft stays as agreed) ── */
+function setNext(root, id, order, from, { now = Date.now(), by = 'pm' } = {}) {
+  const P = RE().paths(root, id);
+  fs.mkdirSync(P.dir, { recursive: true });
+  fs.writeFileSync(path.join(P.dir, RE().NEXT_ORDER), JSON.stringify({ order: asOrder(order), from, at: new Date(now).toISOString(), by }) + '\n');
+  return { ok: true };
+}
+function nextOf(root, id) { try { const x = readJson(path.join(RE().paths(root, id).dir, RE().NEXT_ORDER)); return x && isObj(x.order) ? { id: x.order.id, name: x.order.name, from: x.from } : null; } catch { return null; } }
+
+/* ── my orders: person level, private ── */
+const ledger = (dir) => path.join(path.resolve(String(dir)), LEDGER);
+function readLines(dir) {
+  let t; try { t = fs.readFileSync(ledger(dir), 'utf8'); } catch { return []; }
+  return t.split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(isObj);
+}
+function fold(lines) {
+  const m = new Map();
+  for (const e of lines || []) {
+    if (e.ev === 'save' && isMine(e.id) && Array.isArray(e.outline)) m.set(e.id, { id: e.id, kind: e.kind === 'slide' ? 'slide' : 'order', name: str(e.name), outline: e.outline, from: e.from || null, at: str(e.at) });
+    else if (e.ev === 'rename' && m.has(e.id)) m.get(e.id).name = str(e.name);
+    else if (e.ev === 'remove') m.delete(e.id);
+  }
+  const all = [...m.values()].reverse();
+  return { orders: all.filter((x) => x.kind === 'order'), slides: all.filter((x) => x.kind === 'slide') };
+}
+const cleanName = (n) => str(n).replace(/\{\{r:[^}]*\}\}/g, '').replace(/\s+/g, ' ').trim().slice(0, 80);
+/** Save an order (kind 'order', the whole deck's parts) or one slide (kind 'slide', one part). Only parts and layouts are kept. */
+function save(dir, { kind = 'order', name, outline, from = null }, { now = Date.now() } = {}) {
+  const nm = cleanName(name);
+  if (!nm) return { ok: false, status: 400, error: 'say its name' };
+  const parts = (Array.isArray(outline) ? outline : []).map((p) => ({ part: cleanName(p && p.part).slice(0, 60) || nameOfLayout(p && p.layout), layout: str(p && p.layout) }));
+  const err = RE().orderError({ id: 'mine-1', name: nm, outline: parts });
+  if (err) return { ok: false, status: 400, error: err };
+  if (kind === 'slide' && parts.length !== 1) return { ok: false, status: 400, error: 'a slide is one part' };
+  const lines = readLines(dir);
+  const n = lines.reduce((x, e) => Math.max(x, +(/^mine-(\d+)$/.exec(str(e.id)) || [0, 0])[1]), 0) + 1;
+  const e = { ev: 'save', id: 'mine-' + n, kind: kind === 'slide' ? 'slide' : 'order', name: nm, outline: parts, from: isObj(from) ? { report: str(from.report), slot: str(from.slot) } : null, at: new Date(now).toISOString() };
+  fs.mkdirSync(path.resolve(String(dir)), { recursive: true });
+  fs.appendFileSync(ledger(dir), JSON.stringify(e) + '\n');
+  return { ok: true, id: e.id, saved: fold(lines.concat(e)) };
+}
+function change(dir, ev, id, extra, now) {
+  if (!isMine(id) || ![...fold(readLines(dir)).orders, ...fold(readLines(dir)).slides].some((x) => x.id === id)) return { ok: false, status: 404, error: 'there is no saved order ' + id };
+  fs.appendFileSync(ledger(dir), JSON.stringify({ ev, id, ...extra, at: new Date(now).toISOString() }) + '\n');
+  return { ok: true };
+}
+function rename(dir, id, name, { now = Date.now() } = {}) { const nm = cleanName(name); if (!nm) return { ok: false, status: 400, error: 'say its name' }; return change(dir, 'rename', id, { name: nm }, now); }
+function remove(dir, id, { now = Date.now() } = {}) { return change(dir, 'remove', id, {}, now); }
+
+module.exports = { ALWAYS, LEDGER, UNDO_FOR, partsOf, diff, nowOf, pick, orderOf, subOf, previewDeck, isMine, nameOfLayout,
+  snapshot, undoOf, undo, dropUndo, setNext, nextOf, readLines, fold, save, rename, remove };

package/workspace/lib/route-modules.js

@@ -39,6 +39,7 @@ const MODULES = Object.freeze([
   'routes-capture',       // Run 3 (3C): ⌘K capture
   'routes-board',         // Run 4 (4D): the cross-initiative Board, Release
   'routes-reports',       // Run 5 (5C): drafts, Issue, notes
+  'routes-report-orders', // batch 27 item 16: apply an order to a report draft, Undo, my saved orders (canvas TpA, TpD, TpE)
   'routes-report-flow',   // batch 22 item 14: the report building flow (template versions, the report's own session, review)
   'routes-notes',         // meeting-notes Run 1: the Notes view (typed notes, dictation, transcripts, summaries)
   'routes-my-work',       // initiative my-work: the ranked list of work assigned to the PM, the brief, Read again

package/workspace/lib/routes-report-flow.js

@@ -307,4 +307,4 @@ async function handle(req, res, url, ctx) {
   return r.ok ? send({ status: 200, body: r }) : fail(r);
 }
 
-module.exports = { prefixes, handle, stateOf, askPrompt, draftWords };
+module.exports = { prefixes, handle, stateOf, askPrompt, draftWords, ask };

package/workspace/lib/routes-report-orders.js

@@ -0,0 +1,161 @@
+'use strict';
+/* routes-report-orders.js — apply an order to a report draft, Undo, and my saved orders (batch 27 item 16; main canvas TpA, TpD, TpE;
+ * lib/report-orders.js). The app says "order", never "template".
+ *
+ *   GET  /api/report-orders?ws&path          → { ok, id, slot, issued, engine, now, pick, next, orders, slides, undo }   what the draft's order is,
+ *                                               the ✦ (pick), every order with what it adds and drops, my orders first, my slides, and the Undo
+ *   GET  /api/report-orders/preview?ws&order → text/html, the order drawn with placeholder words (one slide per part), sanitized
+ *   POST /api/report-orders/apply  { ws, path, order }   → { ok, redraft: { session, started|passed } } | { ok, next: { id, name } }
+ *                                     A draft: the draft is copied aside (Undo, one day), the brief takes the order (lib/report-engine.js make),
+ *                                     and the report's own session is asked to write it again in that order, keeping its readings. An agreed outline:
+ *                                     nothing changes today; the order is used from the next cycle. An issued cycle is refused 409 (it is frozen).
+ *   POST /api/report-orders/undo   { ws, path }          → { ok }   the draft as it was before the redraft (its day only)
+ *   POST /api/report-orders/save   { ws, path, name? }   → { ok, id }   the draft's parts and layouts as my order (never its numbers or words)
+ *   POST /api/report-orders/slide  { ws, path, n }       → { ok, id, name }   slide n (from 0) of the draft's deck as my slide: its layout and part
+ *   POST /api/report-orders/rename { ws, id, name }      → { ok }
+ *   POST /api/report-orders/remove { ws, id }            → { ok }
+ *
+ * MY ORDERS are the PM's own: they live in the per-user runtime directory (ctx.runtimeDir), not in any repository, and no other person reads them.
+ * WHO WRITES. Every POST passes pm-guard requirePagePress; a request with an agent session header is refused first (403). Nothing here sends
+ * anything outward; the redraft runs in the report's own session (lib/routes-report-flow.js ask), which never issues.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const RO = require('./report-orders.js');
+const RE = require('./report-engine.js');
+const RL = require('./report-library.js');
+const issues = require('./issues.js');
+
+const prefixes = ['/api/report-orders'];
+const POSTS = ['apply', 'undo', 'save', 'slide', 'rename', 'remove'];
+const text = (v) => (typeof v === 'string' ? v : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const PATH_RE = /(?:^|\/)reports\/([a-z][a-z0-9-]{0,39})\/(\d{4}-\d{2}-\d{2})\.md$/;
+function wsOf(ctx, id) { const w = ctx.getWs(id || null); return w && (!id || w.id === id) ? w : null; }
+const mineDir = (ctx) => ctx.runtimeDir || require('./state-root.js').defaultRoot();
+const readJson = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+
+/** The draft a path names: { id, slot, P, issued } | { error }. The path must be a report document that exists. */
+function draftOf(w, rel) {
+  const m = PATH_RE.exec(text(rel));
+  if (!m || text(rel).split('/').includes('..')) return { error: bad(400, 'path must be a report draft') };
+  let P; try { P = RE.paths(w.root, m[1], m[2]); } catch (e) { return { error: bad(400, e.message) }; }
+  if (!fs.existsSync(P.md.abs)) return { error: bad(404, 'no such report') };
+  let iss = false; try { iss = issues.isIssued(issues.readIssues(w.root), m[1], m[2]); } catch { iss = false; }
+  return { id: m[1], slot: m[2], P, issued: iss };
+}
+function setupName(w, id) { try { const RS = require('./report-setups.js'); const s = RS.fold(RS.readLines(RS.ledgerFile(w.root))).setups.get(id); return (s && s.name) || ''; } catch { return ''; } }
+function reportName(w, id, brief) { return setupName(w, id) || (brief && brief.title) || id; }
+/** A saved order's first name: the recurring report's ("Product weekly order"), else the order it began as ("Weekly Review, my way"), else
+ *  "My order". Never an ad hoc report's title: that is its question, a sentence with dates in it. */
+function savedName(w, id, brief) { const s = setupName(w, id); if (s) return s + ' order'; return brief && brief.template && brief.template.name ? brief.template.name.replace(/, my way$/, '') + ', my way' : 'My order'; }
+const card = (o, now, mine, extra = {}) => ({ id: o.id, name: o.name, sub: RO.subOf(o.id, mine), n: o.outline.length, parts: o.outline, ...RO.diff(now.parts, o.outline), ...extra });
+/** The whole state of one draft's order. */
+function stateOf(ctx, w, d) {
+  const brief = readJson(d.P.brief.abs), report = readJson(d.P.report.abs);
+  const now = RO.nowOf(brief, report);
+  const my = RO.fold(RO.readLines(mineDir(ctx)));
+  const pk = d.issued ? null : RO.pick(brief, report);
+  const orders = my.orders.map((o) => card(o, now, my.orders, { mine: true }))
+    .concat(RL.TEMPLATES.map((t) => card({ id: t.id, name: t.name, outline: t.outline }, now, my.orders)));
+  return { ok: true, id: d.id, slot: d.slot, issued: d.issued, engine: !!report, name: reportName(w, d.id, brief),
+    now, pick: pk, next: RO.nextOf(w.root, d.id), orders, slides: my.slides.map((s) => ({ id: s.id, name: s.name, part: s.outline[0].part, layout: s.outline[0].layout, at: s.at })),
+    undo: RO.undoOf(w.root, d.id, d.slot, { issued: d.issued }) };
+}
+/** The words the report's session gets for a redraft in an order. */
+function redraftWords(id, slot, rel, order) {
+  return `Write this draft again in the "${order.name}" order (${rel}, slot ${slot}). This change IS a redraft, of this slot only. `
+    + `The brief (${slot}.brief.json) now carries the order as its template: follow skills/report-write.skill from step 3, with the order's parts as the starting outline, `
+    + `each part in its slide layout and retitled as a finding; add or drop a part when the findings say so. Keep every reading and every finding already filed: `
+    + `run \`pmos report make ${id} --slot ${slot}\` only when a source is missing. Then run \`pmos report write ${id} --slot ${slot} --from <file>\`.`;
+}
+/** The deck slide n as one saved part: its layout, and a part name that is never a finding. */
+function slidePart(d, n) {
+  const deck = RE.engineDeckOf(d.P.md.abs, null);
+  if (!deck) return { error: bad(409, 'this draft was written before the report engine: its slides have no layouts to save') };
+  const s = deck.slides[n];
+  if (!s) return { error: bad(404, 'no such slide') };
+  const fixed = { title: ['Title', 'overview'], answer: ['The answer', s.layout], beyond: ['Beyond the question', 'agenda'], ask: ['Asks', 'decisions'], sources: ['Sources', 'sources'] };
+  if (fixed[s.kind]) return { part: fixed[s.kind][0], layout: fixed[s.kind][1] || 'statement' };
+  const report = readJson(d.P.report.abs), brief = readJson(d.P.brief.abs);
+  const parts = RO.partsOf(report, brief);
+  // the section slides come after the title and answer slides, in the report's order (a long text section may take several slides)
+  const k = deck.slides.slice(0, n + 1).filter((x) => x.kind === 'section' && !/\(continued\)$/.test(x.title)).length - 1;
+  const p = parts[k] || { part: RO.nameOfLayout(s.layout), layout: s.layout };
+  return { part: p.part, layout: p.layout };
+}
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+  const sub = p.replace(/^\/api\/report-orders\/?/, '');
+  if (req.method === 'GET') {
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    if (sub === 'preview') {
+      const o = RO.orderOf(text(url.searchParams.get('order')), RO.fold(RO.readLines(mineDir(ctx))).orders);
+      if (!o) return send(bad(404, 'no such order'));
+      const html = require('./report-design.js').sanitize(require('./report-slides.js').deckHtml(RO.previewDeck(o)));
+      res.writeHead && res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+      if (res.end) res.end(html); else { res.status = 200; res.body = html; }
+      return true;
+    }
+    if (sub !== '') return send(bad(404, 'no such route'));
+    const d = draftOf(w, url.searchParams.get('path'));
+    if (d.error) return send(d.error);
+    return send({ status: 200, body: stateOf(ctx, w, d) });
+  }
+  if (!POSTS.includes(sub)) return send(bad(404, 'no such route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'a session cannot change a report: the PM presses on the page'));
+  const read = await ctx.readJson(req);
+  if (!read.ok) return send(bad(400, 'the body is not JSON'));
+  const body = read.body || {};
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return send(bad(g.status, g.error));
+  const w = wsOf(ctx, text(body.ws));
+  if (!w) return send(bad(404, 'no such workspace'));
+  const dir = mineDir(ctx);
+
+  if (sub === 'rename') { const r = RO.rename(dir, text(body.id), text(body.name)); return send(r.ok ? { status: 200, body: { ok: true } } : bad(r.status, r.error)); }
+  if (sub === 'remove') { const r = RO.remove(dir, text(body.id)); return send(r.ok ? { status: 200, body: { ok: true } } : bad(r.status, r.error)); }
+
+  const d = draftOf(w, body.path);
+  if (d.error) return send(d.error);
+  if (sub === 'save') {
+    const report = readJson(d.P.report.abs), brief = readJson(d.P.brief.abs);
+    if (!report) return send(bad(409, 'this draft was written before the report engine: its slides have no layouts to save'));
+    const outline = [{ part: 'Title', layout: 'overview' }].concat(RO.partsOf(report, brief), [{ part: 'Sources', layout: 'sources' }]);
+    const r = RO.save(dir, { kind: 'order', name: text(body.name) || savedName(w, d.id, brief), outline, from: { report: d.id, slot: d.slot } });
+    return send(r.ok ? { status: 200, body: { ok: true, id: r.id } } : bad(r.status, r.error));
+  }
+  if (sub === 'slide') {
+    const n = Number(body.n);
+    if (!Number.isInteger(n) || n < 0) return send(bad(400, 'n is the slide, from 0'));
+    const sp = slidePart(d, n);
+    if (sp.error) return send(sp.error);
+    const r = RO.save(dir, { kind: 'slide', name: sp.part, outline: [sp], from: { report: d.id, slot: d.slot } });
+    return send(r.ok ? { status: 200, body: { ok: true, id: r.id, name: sp.part, layout: sp.layout } } : bad(r.status, r.error));
+  }
+  if (d.issued) return send(bad(409, `the ${d.slot} report is issued, so it is frozen. The next cycle starts from its order`));
+  if (sub === 'undo') { const r = RO.undo(w.root, d.id, d.slot); return send(r.ok ? { status: 200, body: { ok: true, order: r.order } } : bad(r.status, r.error)); }
+
+  // apply
+  const order = RO.orderOf(text(body.order), RO.fold(RO.readLines(dir)).orders);
+  if (!order) return send(bad(404, 'no such order'));
+  const brief = readJson(d.P.brief.abs);
+  if (brief && Array.isArray(brief.agreed_outline) && brief.agreed_outline.length) {
+    RO.setNext(w.root, d.id, order, d.slot, { by: g.actor });
+    return send({ status: 200, body: { ok: true, next: { id: order.id, name: order.name } } });
+  }
+  RO.snapshot(w.root, d.id, d.slot, { order });
+  const m = RE.make(w.root, d.id, { slot: d.slot, template: RL.templateOf(order.id) ? order.id : order });
+  if (!m.ok) { RO.undo(w.root, d.id, d.slot); return send(bad(m.status || 400, m.error)); }
+  const rel = d.P.md.rel;
+  const r = require('./routes-report-flow.js').ask(ctx, w, d.id, redraftWords(d.id, d.slot, rel, order), rel);
+  if (!r.ok) { RO.undo(w.root, d.id, d.slot); return send(bad(r.status || 409, r.error)); }
+  return send({ status: 200, body: { ok: true, redraft: { session: r.session, started: !!r.started, passed: !!r.passed }, order: { id: order.id, name: order.name } } });
+}
+
+module.exports = { prefixes, handle, stateOf, redraftWords };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/cozy-vw-rp.css

@@ -310,3 +310,43 @@ button.rp-cc { cursor: pointer; }
 .rf-lk .rf-fix small { color: var(--cz-ink3); font-size: var(--fs-meta); line-height: var(--lh-meta); }
 .rf-tplx { padding: 10px 12px; border: 1px solid var(--cz-hair); border-radius: 14px; background: var(--cz-bluebg); }
 .rf-hv em.rf-rest { color: var(--cz-ink2); }
+
+/* ── the orders of a draft (batch 27 item 16; canvas TpA, TpD, TpE; report-orders-ui.js) ── */
+.ro-row { align-items: center; }
+.ro-row .ro-ib.rp-tl { width: 30px; height: 30px; }
+.ro-next { color: var(--cz-ink3); }
+.ro-ass { display: flex; flex-direction: column; gap: 6px; margin-top: 10px; padding: 10px 12px; border-radius: 14px; border: 1px solid var(--cz-blue); background: var(--cz-card); font-size: var(--fs-body); line-height: var(--lh-body); }
+.ro-ass p { margin: 0; }
+.ro-st { color: var(--cz-blueink); font-weight: var(--fw-strong); }
+.vz .ro-note { margin: 0; font-size: var(--fs-meta); line-height: var(--lh-meta); color: var(--cz-ink3); }
+.ro-pts { display: flex; flex-wrap: wrap; gap: 4px; margin: 0; }
+.ro-pt { display: inline-flex; padding: 2px 8px; border-radius: 8px; border: 1px solid var(--cz-hair); background: var(--cz-well); color: var(--cz-ink2); font-size: var(--fs-badge); line-height: var(--lh-badge); }
+.ro-pt.add, .ro-pt.on { border-color: var(--cz-blue); color: var(--cz-blueink); font-weight: var(--fw-strong); background: var(--cz-card); }
+.ro-pt.cut { border-style: dashed; color: var(--cz-ink3); text-decoration: line-through; background: none; }
+.ro-acts { display: flex; justify-content: flex-end; align-items: center; gap: 6px; }
+.ro-acts .rp-pri { margin: 0; width: 36px; height: 36px; }
+.ro-gal { display: flex; flex-direction: column; gap: 10px; }
+.ro-gh { display: flex; align-items: center; justify-content: space-between; gap: 10px; }
+.ro-gh small { display: block; color: var(--cz-ink3); font-size: var(--fs-meta); line-height: var(--lh-meta); }
+.ro-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(210px, 1fr)); gap: 10px; }
+.ro-card { display: flex; flex-direction: column; gap: 6px; text-align: left; padding: 10px; border-radius: 14px; border: 1px solid var(--cz-hair); background: var(--cz-card); color: var(--cz-ink); cursor: pointer; font: inherit; }
+.ro-card:hover { background: var(--cz-well); }
+.ro-card:focus-visible, .ro-sl:focus-visible { outline: 2px solid var(--cz-blue); outline-offset: 2px; }
+.ro-card.now { border-color: var(--cz-blue); }
+.ro-card small, .ro-sl small { color: var(--cz-ink3); font-size: var(--fs-meta); line-height: var(--lh-meta); }
+.ro-cn { display: flex; align-items: center; gap: 6px; font-size: var(--fs-row); line-height: var(--lh-row); }
+.ro-tag { display: inline-flex; padding: 1px 8px; border-radius: 999px; border: 1px solid var(--cz-hair); font-size: var(--fs-badge); line-height: var(--lh-badge); color: var(--cz-ink2); font-weight: var(--fw-strong); }
+.ro-tag.ro-star { color: var(--cz-blueink); border-color: var(--cz-blue); }
+.ro-pics { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 4px; }
+.ro-pic { display: block; position: relative; aspect-ratio: 16 / 9; border-radius: 4px; overflow: hidden; background: var(--cz-well); box-shadow: inset 0 0 0 1px var(--cz-hair); }
+.ro-slides { display: flex; flex-wrap: wrap; gap: 10px; }
+.ro-sl { display: flex; flex-direction: column; gap: 4px; width: 120px; padding: 0; border: 0; background: none; cursor: pointer; text-align: left; font: inherit; }
+.ro-sl .ro-pics { grid-template-columns: 1fr; }
+.ro-big { position: relative; aspect-ratio: 16 / 9; }
+.ro-big .ro-pic { position: absolute; inset: 0; }
+.ro-ren { display: flex; align-items: center; gap: 6px; }
+.ro-ren input { flex: 1; min-width: 0; height: 34px; padding: 0 10px; border-radius: 10px; border: 1px solid var(--cz-hair); background: var(--cz-card); color: var(--cz-ink); font: inherit; }
+.ro-ren .rp-pri { margin: 0; }
+@media (max-width: 560px) { .ro-grid { grid-template-columns: 1fr; } }
+.ro-ib.rp-pri { background: var(--cz-blue); color: var(--cz-onsolid); border-radius: 999px; }
+.ro-ib.rp-pri:hover { background: var(--cz-blue); filter: brightness(1.08); color: var(--cz-onsolid); }

package/workspace/public/pm/premium-report-read.js

@@ -57,6 +57,7 @@ import { presentInRecording } from './cozy-rec-bridge.js';   // while a meeting
 import { placeholderHtml } from './cozy-placeholder.js';
 import { vzStyle } from './premium-vw-open.js';
 import { reviewHtml, chatOf as rfChatOf, ICON as RF_ICON } from './report-flow.js';   // Claude's review and the template icon (batch 22 item 14, canvas RfH2, RfH6)
+import * as OU from './report-orders-ui.js';   // batch 27 item 16: the orders of a draft (canvas TpA, TpD, TpE)
 import { adler } from './cozy-adler.js';   // registers window.czViews; vzStyle adds the Viewer's sheet (cozy-vw.css)
 import { cycleGroups, cycleName, briefModel, briefGlanceHtml, briefConfirmHtml, briefWhyHtml, briefLooksHtml, paperModel, paperHtml, liveModel, liveHtml, presentHtml, dayMon, reportSummary,
   rpSumHtml, rpBarHtml, cadenceWords, goesOutWords, FORMATS, RP_ICONS } from './rp-parts.js';
@@ -73,7 +74,7 @@ const P = {
   warn: '<path d="M12 4l9 16H3zM12 10v4M12 17h.01"/>', bin: '<path d="M5 7h14M10 7V4h4v3M7 7l1 13h8l1-13"/>', box: '<path d="M4 5h16v4H4zM5 9v10h14V9M10 13h4"/>', lock: '<rect x="5" y="11" width="14" height="10" rx="2"/><path d="M8 11V8a4 4 0 0 1 8 0v3"/>',
   redo2: '<path d="M20 11a8 8 0 1 0-2.3 5.7M20 4v7h-7"/>', undo: '<path d="M9 14 4 9l5-5M4 9h11a5 5 0 0 1 0 10h-3"/>', redo: '<path d="m15 14 5-5-5-5M20 9H9a5 5 0 0 0 0 10h3"/>',
   people: '<path d="M9 11a3.5 3.5 0 1 0 0-7a3.5 3.5 0 1 0 0 7M2.5 20a6.5 6.5 0 0 1 13 0M16 4.5a3.5 3.5 0 0 1 0 6.5M18 14a6 6 0 0 1 3.5 6"/>', list: '<path d="M9 6h11M9 12h11M9 18h11M4.5 6h.01M4.5 12h.01M4.5 18h.01"/>',
-  plus: '<path d="M12 5v14M5 12h14"/>', dl: '<path d="M12 4v11M7 10l5 5 5-5M5 20h14"/>', live: '<path d="M3 17l5-5 4 4 8-8M16 8h4v4"/>', layout: '<rect x="4" y="4" width="16" height="16" rx="2"/><path d="M4 10h16M10 10v10"/>',
+  plus: '<path d="M12 5v14M5 12h14"/>', grid: '<rect x="4" y="4" width="7" height="7" rx="1"/><rect x="13" y="4" width="7" height="7" rx="1"/><rect x="4" y="13" width="7" height="7" rx="1"/><rect x="13" y="13" width="7" height="7" rx="1"/>', mark: '<path d="M7 4h10v16l-5-4-5 4z"/>', dl: '<path d="M12 4v11M7 10l5 5 5-5M5 20h14"/>', live: '<path d="M3 17l5-5 4 4 8-8M16 8h4v4"/>', layout: '<rect x="4" y="4" width="16" height="16" rx="2"/><path d="M4 10h16M10 10v10"/>',
   theme: '<path d="M12 3a9 9 0 1 0 0 18c1 0 1.5-.8 1.5-1.6 0-1-.8-1.4-.8-2.4 0-1 .8-1.6 1.8-1.6H17a4 4 0 0 0 4-4c0-4.6-4-8.4-9-8.4z"/><circle cx="7.5" cy="11" r="1"/><circle cx="10.5" cy="7.5" r="1"/><circle cx="15" cy="7.5" r="1"/>',
 };
 const ic = (k, n) => svg(P[k], n);
@@ -437,7 +438,7 @@ function deckHtml() {
   if (!L.length) return '<p class="vz-empty">This cycle has no slides. Read it as a page.</p>';
   const i = R.i = Math.max(0, Math.min(R.i, L.length - 1));
   return `<div class="vz-slide" tabindex="0" role="group" aria-roledescription="slide" aria-label="Slide ${i + 1} of ${L.length}: ${esc(L[i].h)}. Use the arrow keys to change slide." data-r="slide">${slideCard(L[i])}</div>`
-    + `<div class="rp-nav">${ib('prev', ic('prev', 15), 'Previous slide', { off: i === 0 })}<span class="rp-count" aria-live="polite">Slide ${i + 1} of ${L.length}</span>${ib('next', ic('next', 15), 'Next slide', { off: i === L.length - 1 })}</div>`
+    + `<div class="rp-nav">${ib('prev', ic('prev', 15), 'Previous slide', { off: i === 0 })}<span class="rp-count" aria-live="polite">Slide ${i + 1} of ${L.length}</span>${ib('next', ic('next', 15), 'Next slide', { off: i === L.length - 1 })}${R.pyr && !R.cyc && R.ord && R.ord.engine && !R.edit ? ib('ord|slide', ic('mark', 15), 'Save this slide\'s layout to My slides', { cls: ' ro-slmark', off: R.busy }) : ''}</div>`
     + `<div class="vz-thumbs rp-thumbs" role="group" aria-label="Slides">`
     + L.map((x, j) => `<button type="button" class="vz-th rp-th${x.k === 'title' ? ' rp-tt' : ''}" data-r="go|${j}"${j === i ? ' aria-current="true"' : ''} aria-label="Slide ${j + 1}: ${esc(x.h)}" title="${j + 1} · ${esc(x.h)}"><span>${slideCard(x, true)}</span></button>`).join('')
     + '</div>';
@@ -473,11 +474,11 @@ function rfhHtml() {
     R.archived ? null : { act: 'share', label: 'Share', icon: 'share', exp: R.pop === 'share', pop: 'dialog' },
     { act: 'dlm', label: 'Download', icon: 'dl', exp: R.pop === 'dl' }] });
   const view = R.err ? `<p class="vz-msg" data-tone="bad" role="alert">The document could not be read: ${esc(R.err)}</p>` : !R.W ? '<p class="vz-empty" role="status">Reading the report.</p>'
-    : R.view === 'doc' ? pageHtml() : deckHtml();
+    : R.gal ? galView() : (R.view === 'doc' ? pageHtml() : deckHtml()) + ordAssHtml();
   const conf = confirm && R.BF ? czSections([{ id: 'confirm', title: 'Please confirm', count: confirm, open: true, render: () => briefConfirmHtml(R.BF, { issued: R.issued, busy: R.busy }) + (R.bfMsg ? `<p class="vz-msg" role="status">${esc(R.bfMsg)}</p>` : '') }], { key: 'report' }) : '';
   const pri = R.archived ? { act: 'unarch|' + R.row.path, label: 'Bring back', icon: 'back' } : R.issued ? null : { act: 'issue', label: 'Issue it', icon: 'send' };
   const foot = pri ? `<div class="rp-foot"><button type="button" class="rp-pri" data-r="${esc(pri.act)}" aria-label="${esc(pri.label)}" title="${esc(pri.label)}"${R.busy ? ' disabled' : ''}><svg viewBox="0 0 24 24" width="18" height="18" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="${RP_ICONS[pri.icon]}"/></svg></button></div>` : '';
-  return `<div class="vz-rpb rp-rfh">${R.conf ? confHtml() : ''}${chips}${st}${R.W && !R.err ? tools : ''}${view}${R.W && !R.err && !R.issued ? rvHtml() : ''}${conf}${askHtml()}${foot}</div>`;
+  return `<div class="vz-rpb rp-rfh">${R.conf ? confHtml() : ''}${chips}${st}${R.W && !R.err ? ordRowHtml() + tools : ''}${view}${R.W && !R.err && !R.issued ? rvHtml() : ''}${conf}${askHtml()}${foot}</div>`;
 }
 function bodyHtml() {
   if (!R.edit && rfhOn()) return rfhHtml();
@@ -488,8 +489,85 @@ function bodyHtml() {
       + (R.view === 'deck' ? '' : `<div class="vz-r1">${WAIT('Page editor')}</div>`) + '<div class="vz-ed" data-vz-ed></div></div>';
   }
   const view = R.err ? `<p class="vz-msg" data-tone="bad" role="alert">The document could not be read: ${esc(R.err)}</p>` : !R.W ? '<p class="vz-empty" role="status">Reading the report.</p>'
-    : R.view === 'deck' ? deckHtml() : R.view === 'live' ? liveView() : pageHtml();
-  return `<div class="vz-rpb">${R.conf ? confHtml() : R.W ? sumHtml() : ''}${R.W && !R.err ? cutsHtml() : ''}${R.msg ? `<p class="vz-msg" role="status" data-tone="${R.msg.tone || ''}">${esc(R.msg.text)}</p>` : ''}${R.edit ? '' : waitHtml()}${R.W && !R.err ? barHtml() : ''}${view}${R.W && !R.err && !R.issued ? rvHtml() : ''}${R.W && !R.err ? foldsHtml() : ''}${askHtml()}</div>`;
+    : R.gal ? galView() : (R.view === 'deck' ? deckHtml() : R.view === 'live' ? liveView() : pageHtml()) + ordAssHtml();
+  return `<div class="vz-rpb">${R.conf ? confHtml() : R.W ? sumHtml() + ordRowHtml() : ''}${R.W && !R.err ? cutsHtml() : ''}${R.msg ? `<p class="vz-msg" role="status" data-tone="${R.msg.tone || ''}">${esc(R.msg.text)}</p>` : ''}${R.edit ? '' : waitHtml()}${R.W && !R.err ? barHtml() : ''}${view}${R.W && !R.err && !R.issued ? rvHtml() : ''}${R.W && !R.err ? foldsHtml() : ''}${askHtml()}</div>`;
+}
+/* ── the orders of a draft (batch 27 item 16; canvas TpA, TpD, TpE; report-orders-ui.js, GET /api/report-orders) ── */
+const ORD_HIDE = 'pmos-report-orders-hidden';
+function ordHidden() { try { return new Set(JSON.parse(localStorage.getItem(ORD_HIDE) || '[]')); } catch { return new Set(); } }
+const PICS = new Map();   // order id → its slides drawn small with placeholder words (GET /api/report-orders/preview), 'wait' while read
+function ordOpts() {
+  return { esc, ic, slideCard, busy: R.busy, issued: R.issued, hidden: R.ordHide, now: R.pyr || R.cyc ? slides() : null,
+    pics: (id) => { const x = PICS.get(R.ws + '|' + id); return Array.isArray(x) ? x : null; } };
+}
+const ordRowHtml = () => (R.ord ? OU.rowHtml(R.ord, ordOpts()) : '');
+const ordAssHtml = () => (R.ord && !R.edit ? OU.assHtml(R.ord, ordOpts()) : '');
+function galView() { readPics(); return OU.galHtml(R.ord, R.gal, ordOpts()); }
+/** The pictures of the orders the gallery shows, each read once and kept (they hold placeholder words only). */
+function readPics() {
+  const me = R, S = R.ord; if (!S || !S.ok) return;
+  const ids = R.gal && R.gal.sel ? [R.gal.sel] : S.orders.map((o) => o.id).concat((S.slides || []).map((x) => x.id));
+  for (const id of ids) {
+    const k = R.ws + '|' + id; if (id === 'now' || PICS.has(k)) continue;
+    PICS.set(k, 'wait');
+    textOf('/api/report-orders/preview?' + q({ ws: R.ws, order: id })).then((h) => { const x = splitRender(h); PICS.set(k, x.slides.map((y) => ({ k: 'frame', h: y.h, html: y.html, css: x.style }))); })
+      .catch(() => PICS.set(k, [])).then(() => { if (R === me && R.gal) draw(); });
+  }
+}
+const dropPics = () => { for (const k of [...PICS.keys()]) if (/\|mine-/.test(k)) PICS.delete(k); };
+let ordT = null;
+async function readOrders() {
+  const me = R; if (!R || !R.row.path) return;
+  const j = await Promise.resolve(pmGet('/api/report-orders?' + q({ ws: R.ws, path: R.row.path }))).catch(() => null);
+  if (R !== me) return;
+  R.ord = j && j.ok ? j : null;
+  if (R.gal && !R.ord) R.gal = null;
+  draw();
+  // while the report's session writes the draft again, read the state until it lands (the file watch redraws the slides)
+  clearTimeout(ordT);
+  if (R.ord && R.ord.undo && R.ord.undo.state === 'drafting') ordT = setTimeout(() => { if (R === me) readOrders(); }, 6000);
+}
+async function ordAct(k, v) {
+  const me = R, S = R.ord;
+  if (k === 'gal') { R.gal = { sel: null }; R.pop = null; return draw(); }
+  if (k === 'close') { R.gal = null; return draw(); }
+  if (k === 'back') { R.gal = { sel: null }; return draw(); }
+  if (k === 'open') { R.gal = { sel: v, i: 0 }; return draw(); }
+  if (k === 'at') { if (R.gal) R.gal.i = +v; return draw(); }
+  if (k === 'hide') { R.ordHide.add(OU.hideKey(S, v)); try { localStorage.setItem(ORD_HIDE, JSON.stringify([...R.ordHide].slice(-200))); } catch { /* kept for this visit */ } return draw(); }
+  if (k === 'ren') { const o = S && [...S.orders, ...(S.slides || [])].find((x) => x.id === v); if (R.gal && o) R.gal.ren = o.name; draw(); const f = bodyEl() && bodyEl().querySelector('#roName'); if (f) f.focus(); return; }
+  if (R.busy) return;
+  const post = async (sub, body) => { R.busy = true; draw(); const r = await pmPost('/api/report-orders/' + sub, { ws: R.ws, ...body }).catch(() => null); if (R !== me) return null; R.busy = false; return r || { ok: false, error: 'the page could not reach PMOS' }; };
+  if (k === 'apply') {
+    const r = await post('apply', { path: R.row.path, order: v }); if (!r) return;
+    if (!r.ok) return say('The order was not applied: ' + r.error + '.', 'bad');
+    R.gal = null;
+    await readOrders(); if (R !== me) return;
+    return say(r.next ? `From the next cycle this report starts in the ${r.next.name} order. Today's draft stays as agreed.` : `Claude is writing this draft again in the ${r.order.name} order. Undo puts this one back, for one day.`);
+  }
+  if (k === 'undo') {
+    const r = await post('undo', { path: R.row.path }); if (!r) return;
+    if (!r.ok) return say('Nothing was undone: ' + r.error + '.', 'bad');
+    await reread(); if (R !== me) return; await readOrders(); if (R !== me) return;
+    return say('The draft is back as it was before the redraft.');
+  }
+  if (k === 'save' || k === 'slide') {
+    const r = await post(k, k === 'save' ? { path: R.row.path } : { path: R.row.path, n: R.i }); if (!r) return;
+    if (!r.ok) return say('Nothing was saved: ' + r.error + '.', 'bad');
+    R.ordHide.add(OU.hideKey(S, 'edit')); dropPics(); await readOrders(); if (R !== me) return;
+    return say(k === 'save' ? 'Saved to My orders. It is first in the orders, marked Mine. Only its parts and slide layouts are kept.' : `Saved to My slides: ${r.name}, its layout only.`);
+  }
+  if (k === 'renok') {
+    const r = await post('rename', { id: v, name: (R.gal && R.gal.ren) || '' }); if (!r) return;
+    if (!r.ok) return say('The name did not change: ' + r.error + '.', 'bad');
+    if (R.gal) R.gal.ren = null; dropPics(); return readOrders();
+  }
+  if (k === 'del') {
+    const r = await post('remove', { id: v }); if (!r) return;
+    if (!r.ok) return say('It was not deleted: ' + r.error + '.', 'bad');
+    R.gal = { sel: null }; dropPics(); await readOrders(); if (R !== me) return;
+    return say('Deleted from your orders. No report changed.');
+  }
 }
 /* ── Claude's review (batch 22 item 14, canvas RfH2): the checks PMOS runs on the draft, as ✦ fixes the report's own session makes ── */
 function rvHtml() {
@@ -605,9 +683,10 @@ function wire(b) {
     e.preventDefault(); act(t.dataset.r.split('|'), t);
   };
   b.onchange = (e) => { if (e.target.dataset.r === 'stime') R.sch.time = e.target.value || '09:00'; };
-  b.oninput = (e) => { if (e.target.dataset.r === 'shpass') R.shr.pass = e.target.value; };
+  b.oninput = (e) => { if (e.target.dataset.r === 'shpass') R.shr.pass = e.target.value; if (e.target.dataset.r === 'ord-name' && R.gal) R.gal.ren = e.target.value; };
   b.onkeydown = (e) => {
     if (e.key === 'Escape' && R.pop) { e.preventDefault(); e.stopPropagation(); R.pop = null; draw(); return; }
+    if (e.key === 'Escape' && R.gal) { e.preventDefault(); e.stopPropagation(); R.gal = R.gal.sel ? { sel: null } : null; draw(); return; }
     if (!R.edit && R.view === 'deck' && /^Arrow(Left|Right)$/.test(e.key) && !e.target.closest('input')) { const L = slides().length, j = R.i + (e.key === 'ArrowRight' ? 1 : -1); if (j >= 0 && j < L) { e.preventDefault(); R.i = j; draw(); const s = bodyEl().querySelector('.vz-slide'); if (s) s.focus(); } }
   };
   /* a phone swipes the slide (RpPhone "swipe for the next") */
@@ -634,6 +713,7 @@ export function fit(root) { root.querySelectorAll('.vz-fr').forEach((c) => { if
 const say = (text, tone) => { R.msg = { text, tone }; draw(); const me = R, m = R.msg; if (tone !== 'bad') setTimeout(() => { if (R === me && R.msg === m) { R.msg = null; draw(); } }, 9000); };
 async function act([k, v], t) {
   if (k === 'rv-do' || k === 'rv-no' || k === 'rv-all') return rvAct(k, v);
+  if (k === 'ord') return ordAct(v, t.dataset.r.split('|').slice(2).join('|'));
   if (k === 'pop') { R.pop = v || null; return draw(); }
   if (k === 'cut') return cutTo(v);
   if (k === 'bf') return briefAct(v, t.dataset.r.split('|').slice(2).join('|'));
@@ -1030,7 +1110,7 @@ export async function openReport(row, hand = {}) {
   if (R) present(false);
   const me = R = { row, ws: hand.ws || '', id: c.cadence, name: hand.name || row.name || c.cadence || 'Report', audience: hand.audience || '', issued: row.state === 'issued', archived: !!row.archived,
     text: '', err: '', W: null, view: 'deck', BF: null, bfRaw: null, bfMsg: '', LV: null, blank: false, i: 0, cyc: null, pyr: null, setup: undefined, pop: null, conf: false, checks: null, issueErr: '', busy: false, ask: '', askErr: '', edit: false, msg: null,
-    sch: schedPick(null), schErr: '', shr: null, rv: null, rvHide: new Set(), rvSent: new Set(), shares: null, more: [], hand, cuts: hand.cuts ? { on: 'team', team: null, sponsors: null, err: '' } : null, cycles: (hand.cycles || []).slice(), onIssue: hand.onIssue || null, onChange: hand.onChange || null, vid: 'report:' + row.path };
+    sch: schedPick(null), schErr: '', shr: null, ord: null, gal: null, ordHide: ordHidden(), rv: null, rvHide: new Set(), rvSent: new Set(), shares: null, more: [], hand, cuts: hand.cuts ? { on: 'team', team: null, sponsors: null, err: '' } : null, cycles: (hand.cycles || []).slice(), onIssue: hand.onIssue || null, onChange: hand.onChange || null, vid: 'report:' + row.path };
   const head = me.head = () => ({ id: me.vid, kind: 'Report' + (me.audience ? ' · ' + me.audience : ''), title: me.name, icon: me.view === 'doc' ? 'doc' : 'report', full: true, url: viewUrl(row, me.ws), more: me.more,
     // the template behind one icon (batch 22 item 14, canvas RfH1): format, readers, when it goes out, and its history
     presses: me.setup ? [{ act: 'chat', label: 'Talk to Claude about this report', icon: RF_ICON.chat }, { act: 'template', label: 'Template: format, readers, look, sources', icon: RF_ICON.tune }] : [],
@@ -1048,6 +1128,7 @@ export async function openReport(row, hand = {}) {
   if (R !== me) return me;
   readBrief();   // the Brief tab's count shows at once
   readReview();
+  readOrders();
   if (hand.say) me.msg = { text: hand.say };
   if (vCur() && vCur().id === me.vid && (vCur().title !== me.name || me.audience || me.setup)) { me.reopen = true; vOpen(head()); me.reopen = false; }   // the name and audience are known now
   draw();
@@ -1067,7 +1148,7 @@ async function watchFile(me) {
     if (R !== me || !h) continue;
     // a session writes the draft in many steps: read it when the file has been still for one more check, so a burst of writes is one redraw
     if (seen && h !== seen) { seen = h; pending = true; continue; }
-    if (pending) { pending = false; await reread(); if (R === me && !me.edit && !me.pop) { me.fromFile = true; draw(); me.fromFile = false; readReview(); } }
+    if (pending) { pending = false; await reread(); if (R === me && !me.edit && !me.pop) { me.fromFile = true; draw(); me.fromFile = false; readReview(); readOrders(); } }
     seen = h;
   }
 }

package/workspace/public/pm/report-orders-ui.js

@@ -0,0 +1,115 @@
+/* pm/report-orders-ui.js — the orders of a report draft in the report Viewer (batch 27 item 16; main canvas TpA, TpD, TpE). Pure html builders;
+ * premium-report-read.js holds the state and the presses (data-r="ord|…") and reads GET /api/report-orders (lib/routes-report-orders.js).
+ * The app says "order", never "template".
+ *
+ *   rowHtml(S, o)       the order line in the summary: the order's name as a chip (zero is silence for the standard order), the grid icon that
+ *                       opens the gallery (a draft), the bookmark (save as my order), Undo while its day lasts, and the next cycle's order
+ *   assHtml(S, o)       the one ✦ under the slide: Claude's pick (✕ · grid · ✓ redraft) | "Redrafting in …" | after the PM edited an order,
+ *                       "You changed this order … Save it as yours?" (✕ · bookmark). Nothing to say → ''.
+ *   galHtml(S, G, o)    the gallery: Now, then Mine, then the seven PMOS orders, each with the pictures of its first four layouts and its slide
+ *                       count; My slides; a pressed card shows its slides, its parts, what it adds or drops, and ✓ (Redraft in this order, or
+ *                       Use from the next cycle on an agreed outline). Rename and Delete on Mine only.
+ *   S = the GET answer · G = { sel, i, ren } · o = { esc, ic, slideCard, pics(id) → [slide] | null, now: [slide], busy, hidden: Set, issued }
+ */
+
+const keyOf = (S, k) => k + ':' + (S && S.slot) + ':' + ((S && S.pick && S.pick.id) || (S && S.now && S.now.id) || '');
+export const hideKey = keyOf;
+const words = (L) => (L.length <= 1 ? L.join('') : L.slice(0, -1).join(', ') + ' and ' + L[L.length - 1]);
+const ALWAYS = new Set(['overview', 'sources']);
+/** "adds Why, Scope and People; drops The week" (pure). */
+export function diffWords(d) {
+  const a = (d && d.adds) || [], r = (d && d.drops) || [];
+  if (!a.length && !r.length) return 'Same parts as your draft.';
+  return 'Compared with your draft: ' + [a.length ? 'adds ' + words(a) : '', r.length ? 'drops ' + words(r) : ''].filter(Boolean).join('; ') + '.';
+}
+const btn = (o, act, icon, label, cls = '') => `<button type="button" class="rp-tl vz-hv ro-ib${cls}" data-r="${o.esc(act)}" aria-label="${o.esc(label)}" title="${o.esc(label)}"${o.busy ? ' disabled' : ''}>${o.ic(icon, 16)}</button>`;
+
+/** The order line under the summary. */
+export function rowHtml(S, o) {
+  if (!S || !S.ok) return '';
+  const e = o.esc, n = S.now || {}, out = [];
+  const named = n.kind !== 'standard';
+  if (!o.issued) out.push(`<button type="button" class="rp-mc ro-chip" data-r="ord|gal" aria-label="${e(named ? n.name + ': see the orders' : 'See the orders')}" title="See the orders">${o.ic('grid', 14)}${named ? e(n.name) + (n.edited ? ', edited' : '') : ''}</button>`);
+  else if (named) out.push(`<span class="rp-mc ro-chip">${o.ic('grid', 14)}${e(n.name)}</span>`);
+  if (S.next) out.push(`<span class="rp-mc ro-next">Next cycle: ${e(S.next.name)}</span>`);
+  if (S.engine) out.push(btn(o, 'ord|save', 'mark', 'Save as my order'));
+  if (S.undo && S.undo.state !== 'drafting' && !o.issued) out.push(btn(o, 'ord|undo', 'undo', 'Undo the redraft'));
+  return `<div class="rp-mcs ro-row">${out.join('')}</div>`;
+}
+
+const parts = (o, list, adds, cls) => list.filter((p) => !ALWAYS.has(p.layout)).map((p) => `<span class="ro-pt${adds && adds.includes(p.part) ? ' add' : ''}${cls || ''}">${o.esc(p.part)}</span>`).join('');
+/** The one ✦ under the slide. */
+export function assHtml(S, o) {
+  if (!S || !S.ok || o.issued) return '';
+  const e = o.esc, h = o.hidden || new Set();
+  const U = S.undo;
+  if (U && U.state !== 'done' && U.order) {
+    const late = U.state === 'late';
+    return `<div class="ro-ass" role="status"><p><b class="ro-st" aria-hidden="true">✦</b> ${late ? 'The redraft in the ' + e(U.order.name) + ' order has not landed yet.' : 'Redrafting in the ' + e(U.order.name) + ' order.'}</p>`
+      + `<p class="ro-note">${late ? 'Undo puts the draft back as it was.' : 'It takes a few minutes. Every reading stays; the new draft shows here when it lands.'}</p></div>`;
+  }
+  if (S.pick && !h.has(keyOf(S, 'pick'))) {
+    const ord = (S.orders || []).find((x) => x.id === S.pick.id);
+    if (!ord) return '';
+    return `<div class="ro-ass" role="group" aria-label="Claude's pick"><p><b class="ro-st" aria-hidden="true">✦</b> The ${e(ord.name)} order fits this report's question.</p>`
+      + `<p class="ro-pts">${parts(o, ord.parts, S.pick.adds)}${(S.pick.drops || []).map((x) => `<span class="ro-pt cut">${e(x)}</span>`).join('')}</p>`
+      + `<p class="ro-note">Blue is added${(S.pick.drops || []).length ? ', struck through is dropped' : ''}. Every reading stays.</p>`
+      + `<div class="ro-acts">${btn(o, 'ord|hide|pick', 'x', 'Not now')}${btn(o, 'ord|open|' + ord.id, 'grid', 'See it with the other orders')}${btn(o, 'ord|apply|' + ord.id, 'check', 'Redraft in this order', ' rp-pri')}</div></div>`;
+  }
+  const n = S.now || {};
+  if (S.engine && n.kind === 'order' && n.edited && !h.has(keyOf(S, 'edit'))) {
+    const c = n.changes || {}, said = [(c.drops || []).length ? 'dropped ' + words(c.drops.map((x) => '“' + x + '”')) : '', (c.adds || []).length ? 'added ' + words(c.adds.map((x) => '“' + x + '”')) : ''].filter(Boolean).join(', ');
+    return `<div class="ro-ass" role="group" aria-label="Save your order"><p><b class="ro-st" aria-hidden="true">✦</b> You changed the ${e(n.name)} order${said ? ': ' + e(said) : ''}. Save it as yours?</p>`
+      + `<p class="ro-pts">${parts(o, n.parts, c.adds)}</p><p class="ro-note">It saves the parts and their slide layouts. Not the numbers or the words.</p>`
+      + `<div class="ro-acts">${btn(o, 'ord|hide|edit', 'x', 'Not now')}${btn(o, 'ord|save', 'mark', 'Save as my order', ' rp-pri')}</div></div>`;
+  }
+  return '';
+}
+
+/** Up to four pictures of an order's layouts (real slides, drawn small). Until they are read: grey boxes. */
+function pics(o, L, n = 4) {
+  if (!L) return `<span class="ro-pics" aria-hidden="true">${'<span class="ro-pic ro-wait"></span>'.repeat(n)}</span>`;
+  return `<span class="ro-pics" aria-hidden="true">${L.slice(0, n).map((s) => `<span class="ro-pic">${o.slideCard(s, true)}</span>`).join('')}</span>`;
+}
+const more = (n) => n + (n === 1 ? ' slide' : ' slides') + (n > 4 ? ' · +' + (n - 4) + ' more' : '');
+function cardHtml(S, o, c) {
+  const e = o.esc, mark = c.now ? '<span class="ro-tag">Now</span>' : c.mine ? '<span class="ro-tag">Mine</span>' : S.pick && S.pick.id === c.id ? '<span class="ro-tag ro-star" aria-label="Claude\'s pick">✦</span>' : '';
+  return `<button type="button" class="ro-card${c.now ? ' now' : ''}" data-r="ord|open|${e(c.id)}"${c.now ? ' aria-current="true"' : ''}>${pics(o, c.now ? o.now : o.pics(c.id))}`
+    + `<span class="ro-cn">${mark}<b>${e(c.name)}</b></span><small>${more(c.n)}</small></button>`;
+}
+/** The gallery (TpD), or one order pressed open. */
+export function galHtml(S, G, o) {
+  if (!S || !S.ok) return '<p class="vz-empty" role="status">Reading the orders.</p>';
+  const e = o.esc;
+  const close = `<button type="button" class="rp-tl vz-hv ro-ib" data-r="ord|close" aria-label="Close the orders" title="Close">${o.ic('x', 16)}</button>`;
+  if (G.sel) return detailHtml(S, G, o);
+  const n = S.now || {};
+  const head = S.now.kind === 'agreed'
+    ? `<p class="ro-note">Your readers agreed this order${n.since ? ' when the ' + e(n.since) + ' report went out' : ''}. A pick here is used from the next cycle; today's draft stays as agreed.</p>`
+    : S.pick ? `<p class="ro-note"><b class="ro-st" aria-hidden="true">✦</b> The ${e((S.orders.find((x) => x.id === S.pick.id) || {}).name || '')} order fits this report's question. Press a card to see it, or pick another.</p>` : '';
+  const cards = [{ id: 'now', now: true, name: n.name, n: (o.now || []).length || n.parts.length }].concat(S.orders.filter((x) => x.mine), S.orders.filter((x) => !x.mine));
+  const sl = (S.slides || []).length ? `<p class="rp-lbl">My slides</p><div class="ro-slides">${S.slides.map((s) => `<button type="button" class="ro-sl" data-r="ord|open|${e(s.id)}">${pics(o, o.pics(s.id), 1)}<small>${e(s.name)}</small></button>`).join('')}</div>` : '';
+  return `<div class="ro-gal" role="region" aria-label="Orders"><div class="ro-gh"><b>Orders</b>${close}</div>${head}`
+    + `<div class="ro-grid">${cards.map((c) => cardHtml(S, o, c)).join('')}</div>${sl}`
+    + `<p class="ro-note">An order is a default order of slides. The writer keeps every reading and may add or drop a part.</p></div>`;
+}
+function detailHtml(S, G, o) {
+  const e = o.esc;
+  const isNow = G.sel === 'now';
+  const slide = (S.slides || []).find((x) => x.id === G.sel);
+  const ord = isNow ? { id: 'now', name: S.now.name, n: (o.now || []).length, parts: S.now.parts } : slide ? { id: slide.id, name: slide.name, n: 1, parts: [{ part: slide.part, layout: slide.layout }], mine: true, slide: true } : S.orders.find((x) => x.id === G.sel);
+  if (!ord) return '';
+  const L = isNow ? o.now : o.pics(ord.id);
+  const i = Math.max(0, Math.min(G.i || 0, L ? L.length - 1 : 0));
+  const big = L && L[i] ? `<div class="vz-slide ro-big">${o.slideCard(L[i], false)}</div>` : '<div class="vz-slide ro-big"><span class="ro-pic ro-wait"></span></div>';
+  const strip = L && L.length > 1 ? `<div class="vz-thumbs rp-thumbs ro-strip" role="group" aria-label="Slides">${L.map((s, j) => `<button type="button" class="vz-th rp-th" data-r="ord|at|${j}"${j === i ? ' aria-current="true"' : ''} aria-label="Slide ${j + 1}: ${e(s.h)}"><span>${o.slideCard(s, true)}</span></button>`).join('')}</div>` : '';
+  const agreed = S.now.kind === 'agreed';
+  const sub = isNow ? 'Now' : ord.slide ? 'My slide · its layout only' : (ord.mine ? 'Mine · ' : '') + more(ord.n).split(' · ')[0] + (ord.sub ? ' · ' + ord.sub : '');
+  const diff = isNow || ord.slide ? '' : `<p class="ro-note">${e(diffWords(ord))}${agreed ? ' From the next cycle: today\'s draft stays as agreed.' : ' Every reading stays.'}</p>`;
+  const ren = G.ren ? `<div class="ro-ren"><label class="vz-lab" for="roName">Name</label><input id="roName" data-r="ord-name" value="${e(G.ren)}" maxlength="80"><button type="button" class="rp-tl vz-hv ro-ib rp-pri" data-r="ord|renok|${e(ord.id)}" aria-label="Keep this name" title="Keep this name"${o.busy ? ' disabled' : ''}>${o.ic('check', 16)}</button></div>` : '';
+  const acts = [btn(o, 'ord|back', 'prev', 'Back to the orders')];
+  if (ord.mine) acts.push(btn(o, 'ord|del|' + ord.id, 'bin', 'Delete'), btn(o, 'ord|ren|' + ord.id, 'pen', 'Rename'));
+  if (!isNow && !ord.slide && !o.issued) acts.push(btn(o, 'ord|apply|' + ord.id, 'check', agreed ? 'Use from the next cycle' : 'Redraft in this order', ' rp-pri'));
+  return `<div class="ro-gal ro-one" role="region" aria-label="${e(ord.name)}"><div class="ro-gh"><span><b>${e(ord.name)}</b><small>${e(sub)}</small></span></div>${big}${strip}`
+    + `<p class="ro-pts">${ord.parts.map((p, j) => `<span class="ro-pt${!isNow && j === i ? ' on' : ''}">${e(p.part)}</span>`).join('')}</p>${diff}${ren}<div class="ro-acts">${acts.join('')}</div></div>`;
+}

package/workspace/skills/report-write.skill

@@ -33,7 +33,7 @@ Procedure:
 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.
+   - `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, except when `template.chosen` is true: the PM picked that order for this cycle, so use it, and read `earlier_outline` as an example only. The template can also be an order the PM saved (its id starts with `mine-`) or one the PM applied from the report's orders; it reads the same way.
    - 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>`):

package/workspace/test-lists/report-orders.json

@@ -0,0 +1,11 @@
+{
+  "_comment": "Batch 27 item 16: apply an order to a report draft (the ✦ pick, the orders gallery's state and pictures, the redraft in the report's own session, Undo for one day, the next cycle's order on an agreed outline) and my saved orders and slides (per-user ledger). Node only.",
+  "modules": [
+    "report-orders.test.js",
+    "report-orders-page.test.mjs"
+  ],
+  "seconds": {
+    "report-orders.test.js": 2,
+    "report-orders-page.test.mjs": 1
+  }
+}