create-pmos 0.534.0 → 0.536.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.534.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,32 @@
     "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",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1251,
+          "t": "Calmer Settings › Connectors, one list with trouble first",
+          "s": "Calmer Settings › Connectors, one list with trouble first",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.534.0",
       "at": "2026-11-05T00:29:39.663Z",
@@ -385,40 +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"
-        }
-      ]
-    },
-    {
-      "v": "0.515.0",
-      "at": "2026-11-03T23:11:51.264Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1206,
-          "t": "Intelligence reads the OKR file as its goal list (redesign A)",
-          "s": "Intelligence reads the OKR file as its goal list (redesign A)",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@c4ac9039
+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-05T00:29:36Z"}
+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-05T00:29:36Z"}
+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-05T00:29:36Z"}
+generated: {by: process:create-pmos, at: "2026-11-05T10:03:18Z"}
 status: stable
 ---
 

package/workspace/briefing-premium-sources-test.js

@@ -148,25 +148,23 @@ const sh = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
       const { ctx, page, errors } = await open({ theme, w: theme === 'dark' ? 390 : 1280, h: 844 });
       // premium-agreed-design (shared foundation): the design draws no Sources chip, so there is no dot on the page; the level is still read (GET /api/sources)
       const dot = await page.evaluate(() => (document.querySelector('#srcDot, #srcChip') ? 'drawn' : 'none'));
-      await moreItem(page, 'Sources', '#srcHealth');
-      if (theme === 'light') {
-        // briefing-source-flow, slice 5: Home names which reads each part shows and when, from the same Sources read (Home's Sources card)
-        const rd = await page.evaluate(() => ({ cal: ((document.querySelector('#evSettings [data-reads="Today"]') || {}).textContent || '').replace(/^Today:\s*/, ''), moves: ((document.querySelector('#evSettings [data-reads="Needs you"]') || {}).textContent || '').replace(/^Needs you:\s*/, '') }));
-        ok('H5 Settings › Connectors names the read Today shows, and the initiatives, My work and the brief that Needs you shows', /^Calendar (read|not read yet|failed)/.test(rd.cal) && /Initiatives/.test(rd.moves) && /My work/.test(rd.moves) && /Brief (built|not built yet|off)/.test(rd.moves), JSON.stringify(rd));
-        if (shot) await page.screenshot({ path: path.join(shot, 'cards-reads-light.png'), fullPage: true });
-      }
-      // the panel rises into place: measure the line once it has a width, not while it is still animating in (H4 read 0 px)
-      await page.waitForFunction(() => { const e = document.querySelector('#evSettings #srcHealth'); return !!e && e.getBoundingClientRect().width > 0; }, null, { timeout: 15000 });
-      // Home may draw the panel again after it opens (batch 22: the line read 0 px between two draws), so read it until it has its width
-      let line = null;
-      for (let k = 0; k < 25 && !(line && line.w > 0); k++) {
+      await moreItem(page, 'Sources', '.ev-reads');
+      // batch 28 item 1 (canvas CnA): one list, trouble first. The background issues are rows of the list (trouble rows, the amber dot);
+      // all well is silence: no background line, no Today/Needs you footer, no count on the Connectors tab
+      let list = null;
+      for (let k = 0; k < 25 && !(list && list.w > 0); k++) {
         if (k) await page.waitForTimeout(200);
-        line = await page.$eval('#evSettings #srcHealth', (e) => ({ text: e.textContent.trim(), dot: (e.querySelector('.ev-dot') || {}).className || '', w: Math.round(e.getBoundingClientRect().width), sw: document.documentElement.scrollWidth })).catch(() => null);
+        list = await page.evaluate(() => { const r = document.querySelector('#evSettings .ev-reads'); const rows = [...document.querySelectorAll('#evSettings .ev-reads .ev-fr')];
+          return r ? { w: Math.round(r.getBoundingClientRect().width), sw: document.documentElement.scrollWidth, rows: rows.length, trouble: rows.filter((x) => x.classList.contains('ev-fr-t')).length,
+            firstQuiet: rows.findIndex((x) => !x.classList.contains('ev-fr-t')), lastTrouble: rows.map((x) => x.classList.contains('ev-fr-t')).lastIndexOf(true),
+            line: !!document.querySelector('#evSettings #srcHealth'), footer: !!document.querySelector('#evSettings [data-reads]'), count: !!document.querySelector('#evSettings [data-ev-sec="connectors"] .ev-k') } : null; });
       }
       if (theme === 'light') {
-        ok('H2 Settings › Connectors opens with the background line on top, in the level\'s colour', line.text.startsWith(h.line.slice(0, 20)) && line.dot === 'ev-dot ' + (h.level === 'ok' ? 'ok' : 'risk'), JSON.stringify(line));
-        ok('H3 no Sources chip and no dot are drawn on the page; the line above carries the level (premium-agreed-design)', dot === 'none', dot);
-      } else ok('H4 on a phone the line fits: no sideways scroll', line.sw <= 390 && line.w > 0, JSON.stringify(line));
+        ok('H2 Settings › Connectors: background issues are trouble rows, before every quiet row; all well draws no background line', list && !list.line && (h.level === 'ok' ? true : list.trouble >= 1) && (list.lastTrouble < 0 || list.firstQuiet < 0 || list.lastTrouble < list.firstQuiet), JSON.stringify(list));
+        ok('H5 the Today/Needs you footer and the tab count are gone (CnA)', list && !list.footer && !list.count, JSON.stringify(list));
+        ok('H3 no Sources chip and no dot are drawn on the page (premium-agreed-design)', dot === 'none', dot);
+        if (shot) await page.screenshot({ path: path.join(shot, 'cards-reads-light.png'), fullPage: true });
+      } else ok('H4 on a phone the list fits: no sideways scroll', list && list.sw <= 390 && list.w > 0, JSON.stringify(list));
       if (shot) { await sleep(1200); await page.screenshot({ path: path.join(shot, 'sources-health-' + theme + '.png') }); }
       ok('H no page error (' + theme + ')', errors.length === 0, errors.join(' | '));
       await ctx.close();

package/workspace/changelog.json

@@ -1,4 +1,30 @@
 [
+ {
+  "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",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1251,
+    "t": "Calmer Settings › Connectors, one list with trouble first",
+    "s": "Calmer Settings › Connectors, one list with trouble first",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.534.0",
   "at": "2026-11-05T00:29:39.663Z",

package/workspace/ev-everywhere-test.js

@@ -131,8 +131,8 @@ const put = (root, rel, text) => { fs.mkdirSync(path.dirname(path.join(root, rel
     const stale = await pg.evaluate(() => !!document.querySelector('#czFdRisk:not([hidden]), #czMenu .ev-md.risk'));
     await pg.waitForSelector('#evSettings:not([hidden])');
     if (!stale) await pg.click('#evSettings [data-ev-sec="connectors"]');
-    const src = await until(() => pg.evaluate(() => { const d = document.querySelector('#evSettings:not([hidden])'); const r = d ? [...d.querySelectorAll('.ev-fr[data-src]')] : []; return r.length && /never posts/.test(d.textContent) ? { n: r.length, h: (d.querySelector('#evStTitle') || {}).textContent, all: !!d.querySelector('.ev-top [data-ev-readall]'), t: d.textContent } : null; }), 20000);
-    ok('R1 Settings › Connectors lists each source with when it was last read, and ↻ in its header reads all', !!src && src.h === 'Connectors' && src.n >= 3 && src.all && /never posts/.test(src.t), JSON.stringify(src).slice(0, 300));
+    const src = await until(() => pg.evaluate(() => { const d = document.querySelector('#evSettings:not([hidden])'); const r = d ? [...d.querySelectorAll('.ev-fr[data-src]')] : []; return r.length ? { n: r.length, h: (d.querySelector('#evStTitle') || {}).textContent, all: !!d.querySelector('.ev-top [data-ev-readall]'), info: !!d.querySelector('.ev-top [data-ev-info]'), t: d.textContent } : null; }), 20000);
+    ok('R1 Settings › Connectors lists each source with when it was last read, ↻ in its header reads all, and (i) says it never posts', !!src && src.h === 'Connectors' && src.n >= 3 && src.all && src.info, JSON.stringify(src).slice(0, 300));   // batch 28 item 1 (CnA): "never posts" moved into the (i) button
     await snap(pg, 'connectors-1440-light');
     await pg.keyboard.press('Escape');
     await until(() => pg.evaluate(() => !document.querySelector('#evSettings:not([hidden])')));

package/workspace/guide/data-freshness.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Data freshness: how the workspace keeps up to date, and how old each source is"
-timestamp: 2026-11-04
+timestamp: 2026-11-05
 ---
 
 # Data freshness
@@ -55,7 +55,13 @@ The Sources list shows them as one row, **Your tools**. Its time is the oldest r
 
 ## Refresh all: the sources first, then the Briefing
 
-On Home, the Board and Intelligence, the sources list is in **Settings › Connectors**. There is no Sources card in the place menu. Each source shows when PMOS last read it. A source that is old or failed has an amber dot and ↻: press ↻ to read it again. ↻ in the Connectors header is **Refresh all**. When a source needs you, an amber box at the top of Settings names it, and the place menu opens Settings at Connectors. Claude repairs the other problems by itself, so you do not see a box for them (see below).
+On Home, the Board and Intelligence, the sources list is in **Settings › Connectors**. There is no Sources card in the place menu. Settings › Connectors is one list, and the rows that need a look come first. Each source says its status one time, on its own row:
+
+- A row that needs a look has an amber dot, one reason and one icon action. For example: **Jira** · Not read for 4 days. Claude read it again 5 times since 08:48. The action is ↻ (read it again) or a link to the place where you fix it.
+- A row that is well shows its name and when PMOS last read it, for example **Initiatives** · 3 h ago. A source that is old shows ↻ too, while Claude reads it again by itself. When a read found nothing new, the row says **Checked 10:42 · same since 09:15**.
+- Claude's background work that failed, and Git sync when it fails, are rows of the same list. A failed read of a source is the reason on that source's row.
+
+When all is well, there is no other line. ↻ in the Connectors header is **Refresh all**. The (i) button says what PMOS reads and that it never posts. The switches for what PMOS reads on its own, and the other connectors of your Claude session, are folded into one row: open it to see them. When a source needs you, the Connectors tab has an amber dot, an amber box at the top of the other Settings sections names it, and the place menu opens Settings at Connectors. Claude repairs the other problems by itself, so you do not see a box for them (see below).
 
 ## When a source cannot be read: Claude repairs it first
 
@@ -65,9 +71,9 @@ You do not need to watch the sources. When a source that is on is past its limit
 2. After each try, Claude finds why the read failed: the sign-in of the connector expired, the connector is not connected or did not start, the network or the proxy did not answer, the tool asked to slow down (rate limit), Claude is signed out on this computer, or the skill stopped with an error. A read that ends but saves nothing new also counts as a failure.
 3. Each try is a line in the refresh log, with the trigger **repair** and a note such as "Repair 2 of 5: the last read failed because the network or the proxy did not answer".
 
-While Claude repairs a source, the source row says **Reading again** with its amber dot, because its data is still old. There is no amber box. When a read proves that the source is up to date, the row shows its new time. PMOS says a source is up to date only when a read proved it.
+While Claude repairs a source, the source row says **Reading again**. It has no amber dot, because you do not need to do anything, and there is no amber box. When a read proves that the source is up to date, the row shows its new time. PMOS says a source is up to date only when a read proved it.
 
-The amber box shows only when you must act. It names the one action, links to the place where you do it, and says what Claude already tried. For example: **Reconnect Jira.** Jira was last read 3 days ago because its sign-in has expired. Board and the Jira-linked initiatives may be out of date. Claude read it again 2 times since 07:02.
+The amber row on Settings › Connectors, and the amber box on the other sections, show only when you must act. It names the one action, links to the place where you do it, and says what Claude already tried. For example: **Reconnect Jira.** Jira was last read 3 days ago because its sign-in has expired. Board and the Jira-linked initiatives may be out of date. Claude read it again 2 times since 07:02.
 
 | Why | When the box shows | The action |
 |---|---|---|

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/refresh-run.js

@@ -27,7 +27,8 @@
  *
  * SMART REFRESH (steps 1 and 2). Each done read of a stored source gets a fingerprint of its facts (lib/read-fingerprint.js); the end
  * line says whether it brought anything new (`change`) and whether it was a full read or only asked the tool first (`how`). The
- * fingerprint and the time of the last full read are kept in the source's state (`fp`, `full_at`). When two or more tool sources are
+ * fingerprint and the time of the last full read are kept in the source's state (`fp`, `full_at`), and `seen` { at, since }: when the
+ * last read was measured and since when its facts are the same; scheduleOfSkill hands both to Settings › Connectors (checked_at, same_since). When two or more tool sources are
  * due at the same minute, one shared session reads them one after another (startSkill with a list), instead of one session each. A source of a
  * shared session is done when its stored read is newer than the session's start, and failed when it is not.
  * Nothing here calls out of this machine: a skill source's run is the PM's own agent session, with the PM's connections.
@@ -214,6 +215,8 @@ function create(host) {
         const change = FP.compare(st.fp, fp);
         const asked = P.askedSince(dirs.runtime || dir, id, o.at);
         if (fp) { next.fp = FP.keep(fp); measured = { change, how: asked ? 'asked' : 'full', fp: fp.hash }; }
+        // "Checked 10:42 · same since 09:15" (canvas SrSee R3, CnA): when this read was measured, and since when its facts are the same
+        if (fp) next.seen = { at: t, since: change === 'same' ? (st.seen && st.seen.since) || null : t };
         else measured = { how: asked ? 'asked' : 'full' };
         if (!asked) next.full_at = t;
       } catch (e) { warn('read fingerprint', e); }
@@ -584,7 +587,9 @@ function create(host) {
     const l = log().lastRun(id);
     const next = x.on ? R.nextSlot(x.s, now(), win()) : null;
     return { cadence: x.on ? R.textOf(x.s) : 'off', time: null, day: null, next_run: next ? new Date(next).toISOString() : null,
-      last_run: l ? l.start_at : null, last_status: l ? (l.result === 'failed' ? 'fail' : l.result === 'done' ? 'ok' : 'started') : st.last_result || null };
+      last_run: l ? l.start_at : null, last_status: l ? (l.result === 'failed' ? 'fail' : l.result === 'done' ? 'ok' : 'started') : st.last_result || null,
+      checked_at: st.seen && st.seen.at ? new Date(st.seen.at).toISOString() : null,
+      same_since: st.seen && st.seen.since && st.seen.at > st.seen.since ? new Date(st.seen.since).toISOString() : null };
   }
 
   return { heal: healView, tick, started, ended, briefDone, codeRun, jobGate, runNow, refreshAll, allState, derived, setSource, setRules, ensureOn, rows, settings, log, scheduleOfSkill, managedSkill: (skill) => R.SKILL_OF.get(skill) || null };

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 };