create-pmos 0.493.0 → 0.495.0

package/workspace/lib/report-templates.js

@@ -3,9 +3,12 @@
  *
  *   ledgerOf(root, id)                         <state>/reports/<id>/template.jsonl
  *   readLines(root, id) · fold(lines)          → { current, versions: [{ n, settings, at, why, current }], chat, log }
- *   settingsOf(setup)                          → { output, audience, schedule }   the three settings a template is
- *   sameSettings(a, b) · diffWords(a, b)       "Format: Slides → Document"
- *   ensureFirst(root, id, setup, { chat, now }) → T1 from the setup, once. `chat` is the conversation key the report was proposed in
+ *   settingsOf(setup, refs?)                   → { output, audience, schedule, structure?, design? }   what a template is
+ *   liveRefs(root, id)                         → { structure: S<n> | null, design: D<n> | null }   the saved sections and look now
+ *   namesOf(root, id)                          → { sections(n) → [title] | null, look(n) → words }   for the words below
+ *   sameSettings(a, b) · diffWords(a, b, names) "Format: Slides → Document", "Sections: + Customers", "Look: Standard PMOS look → D3 · warmer"
+ *   sectionsDiff(was, now)                     → "+ Customers, − Risk watch" | "new order" | ''
+ *   ensureFirst(root, id, setup, { chat, refs, now }) → T1 from the setup, once. `chat` is the conversation key the report was proposed in
  *   addVersion(root, id, settings, { why, now }) → { ok, n }   the PM's ✓ on a changed template: T<n+1> becomes the current one
  *   restore(root, id, n, { now })              → { ok, n }   Go back to T<n>: that version is the current one again. Nothing is deleted
  *   cyclesOf(folded, issued)                   → Map n → issued cycles while that version was the current one
@@ -15,7 +18,10 @@
  * THE LINES. { v: 1, ev, …, at }:
  *   version  { n, settings, why, chat? }   T<n>; the newest version line is the current template until a restore line
  *   restore  { n }                         Go back to T<n>
- * A template is its settings: the format (output), who reads it (audience) and when it goes out (schedule). A change to any of them is a new
+ * A template is its settings: the format (output), who reads it (audience), when it goes out (schedule), its sections (structure: the saved
+ * structure version S<n> of lib/report-structure.js, or null = the standard sections) and its look (design: the saved design version D<n> of
+ * lib/report-design.js, or null = the standard look) (canvas TplA, brief 3). A T line written before TplA has no structure or design key: it is
+ * read as "not recorded", never as a change, and Go back to it leaves the sections and look as they are. A change to any of them is a new
  * version (the agreed note: "Changing any setting makes a different template"); the drafts and issued cycles stay with the version they were made
  * under. The setup line in report-setups.jsonl keeps the live values: the route applies a version there with report-setups change and reschedule.
  *
@@ -50,13 +56,33 @@ function append(root, id, line, now) {
   return rec;
 }
 
-/** The three settings of a template, as report-setups keeps them. */
-function settingsOf(s) {
+/** A template's settings: the three report-setups keeps, and the saved sections and look when `refs` names them. */
+function settingsOf(s, refs) {
   const x = isObj(s) ? s : {};
   const sc = isObj(x.schedule) ? x.schedule : null;
   const paused = x.status === 'paused';
-  return { output: String(x.output || ''), audience: String(x.audience || ''), schedule: !sc || paused || sc.cadence === 'off' ? 'off' : { cadence: sc.cadence, ...(sc.day ? { day: sc.day } : {}), ...(sc.dayOfMonth ? { dayOfMonth: sc.dayOfMonth } : {}), time: sc.time || '09:00' } };
+  const out = { output: String(x.output || ''), audience: String(x.audience || ''), schedule: !sc || paused || sc.cadence === 'off' ? 'off' : { cadence: sc.cadence, ...(sc.day ? { day: sc.day } : {}), ...(sc.dayOfMonth ? { dayOfMonth: sc.dayOfMonth } : {}), time: sc.time || '09:00' } };
+  if (isObj(refs)) { if (refs.structure !== undefined) out.structure = refN(refs.structure); if (refs.design !== undefined) out.design = refN(refs.design); }
+  return out;
+}
+/** A saved version number, or null (the standard sections or look). */
+const refN = (v) => (Number.isInteger(v) && v >= 1 ? v : null);
+/** The sections and look saved now: the structure's and the design's accept lines. */
+function liveRefs(root, id) {
+  let structure = null, design = null;
+  try { const st = require('./report-structure.js').stateOf(root, id); structure = st.saved ? refN(st.saved.n) : null; } catch { structure = null; }
+  try { const st = require('./report-design.js').stateOf(root, id); design = st.saved ? refN(st.saved.version) : null; } catch { design = null; }
+  return { structure, design };
+}
+/** The words of a version's sections and look, read from their stores. */
+function namesOf(root, id) {
+  const S = require('./report-structure.js'), D = require('./report-design.js');
+  return {
+    sections: (n) => { if (n == null) return null; try { const p = S.readVersion(root, id, n); return p && Array.isArray(p.outline) ? p.outline.map((o) => String(o.title || o.id)) : null; } catch { return null; } },
+    look: (n) => { if (n == null) return STANDARD_LOOK; let m = null; try { m = D.versionMeta(root, id, n); } catch { m = null; } const t = m && String(m.turn || '').replace(/\s+/g, ' ').trim(); return 'D' + n + (t ? ' · ' + (t.length > 40 ? t.slice(0, 39) + '…' : t) : ''); },
+  };
 }
+const STANDARD_LOOK = 'Standard PMOS look';
 function cleanSettings(s) {
   if (!isObj(s)) return null;
   const out = {};
@@ -64,10 +90,22 @@ function cleanSettings(s) {
   if (typeof s.audience === 'string' && s.audience.trim()) out.audience = s.audience.replace(/\s+/g, ' ').trim().slice(0, 120);
   if (s.schedule === 'off' || (isObj(s.schedule) && s.schedule.cadence === 'off')) out.schedule = 'off';
   else if (isObj(s.schedule) && typeof s.schedule.cadence === 'string') out.schedule = { cadence: s.schedule.cadence, ...(s.schedule.day ? { day: String(s.schedule.day) } : {}), ...(s.schedule.dayOfMonth ? { dayOfMonth: +s.schedule.dayOfMonth } : {}), time: /^\d{1,2}:\d{2}$/.test(String(s.schedule.time || '')) ? String(s.schedule.time) : '09:00' };
+  for (const k of ['structure', 'design']) if (s[k] === null || (Number.isInteger(s[k]) && s[k] >= 1)) out[k] = s[k];
   return Object.keys(out).length ? out : null;
 }
 const key = (sc) => JSON.stringify(sc === 'off' || !sc ? 'off' : { c: sc.cadence, d: sc.day || null, m: sc.dayOfMonth || null, t: sc.time || '09:00' });
-function sameSettings(a, b) { return !!a && !!b && a.output === b.output && a.audience === b.audience && key(a.schedule) === key(b.schedule); }
+/** A sections or look ref differs only when both sides recorded one: an old T line (no key) is "not recorded", never a change. */
+const refDiffers = (a, b, k) => a[k] !== undefined && b[k] !== undefined && a[k] !== b[k];
+function sameSettings(a, b) { return !!a && !!b && a.output === b.output && a.audience === b.audience && key(a.schedule) === key(b.schedule) && !refDiffers(a, b, 'structure') && !refDiffers(a, b, 'design'); }
+/** What changed between two section lists, in words: "+ Customers, − Risk watch", or "new order" when only the order moved. */
+function sectionsDiff(was, now) {
+  const A = Array.isArray(was) ? was : [], B = Array.isArray(now) ? now : [];
+  const low = (L) => L.map((t) => String(t).toLowerCase());
+  const a = low(A), b = low(B);
+  const out = B.filter((t, i) => !a.includes(b[i])).map((t) => '+ ' + t).concat(A.filter((t, i) => !b.includes(a[i])).map((t) => '− ' + t));
+  if (out.length) return out.join(', ');
+  return a.join('\n') !== b.join('\n') ? 'new order' : '';
+}
 
 const FORMAT = { 'google-slides': 'Slides', 'google-doc': 'Document', pdf: 'PDF', 'google-sheets': 'Sheets', confluence: 'Confluence page' };
 const DAYS = { Mon: 'Monday', Tue: 'Tuesday', Wed: 'Wednesday', Thu: 'Thursday', Fri: 'Friday', Sat: 'Saturday', Sun: 'Sunday' };
@@ -78,19 +116,31 @@ function goesWords(sc) {
   if (sc.cadence === 'monthly') return 'every month on day ' + (sc.dayOfMonth || 1) + ' ' + t;
   return (sc.cadence === 'bi-weekly' ? 'every two weeks, ' : 'every week, ') + (DAYS[sc.day] || 'Monday') + ' ' + t;
 }
-/** What changed between two templates, in words: ["Format: Slides → Document", …]. */
-function diffWords(a, b) {
+const lookOf = (names, n) => (n == null ? STANDARD_LOOK : names && typeof names.look === 'function' ? names.look(n) : 'D' + n);
+const titlesOf = (names, n) => (n == null ? null : names && typeof names.sections === 'function' ? names.sections(n) : null);
+/** What changed between two templates, in words: ["Format: Slides → Document", "Sections: + Customers", "Look: D2 → D3 · warmer"]. `names`
+ * (namesOf) reads the section titles and look words; without it a sections change is said by its version ("Sections: S2 → S3"). */
+function diffWords(a, b, names) {
   const out = [];
   if (!a || !b) return out;
   if (a.output !== b.output) out.push('Format: ' + (FORMAT[a.output] || a.output || 'none') + ' → ' + (FORMAT[b.output] || b.output || 'none'));
   if (a.audience !== b.audience) out.push('Readers: ' + (a.audience || 'none') + ' → ' + (b.audience || 'none'));
   if (key(a.schedule) !== key(b.schedule)) out.push('Goes out: ' + goesWords(a.schedule) + ' → ' + goesWords(b.schedule));
+  if (refDiffers(a, b, 'structure')) {
+    const A = titlesOf(names, a.structure), B = titlesOf(names, b.structure);
+    const d = A && B ? sectionsDiff(A, B) : '';
+    out.push('Sections: ' + (d || (a.structure == null ? 'standard' : 'S' + a.structure) + ' → ' + (b.structure == null ? 'standard' : 'S' + b.structure)));
+  }
+  if (refDiffers(a, b, 'design')) out.push('Look: ' + lookOf(names, a.design) + ' → ' + lookOf(names, b.design));
   return out;
 }
-/** One line naming a template's settings: "Format: Slides · readers: The team · goes out once". */
-function settingsWords(s) {
+/** One line naming a template's settings: "Format: Slides · readers: The team · goes out once · 6 sections · Standard PMOS look". */
+function settingsWords(s, names) {
   if (!s) return '';
-  return 'Format: ' + (FORMAT[s.output] || s.output || 'none') + ' · readers: ' + (s.audience || 'none') + ' · goes out ' + goesWords(s.schedule);
+  const T = s.structure !== undefined ? titlesOf(names, s.structure) : null;
+  const sec = s.structure === undefined ? '' : s.structure == null ? ' · standard sections' : ' · ' + (T ? T.length + (T.length === 1 ? ' section' : ' sections') : 'sections S' + s.structure);
+  const look = s.design === undefined ? '' : ' · ' + lookOf(names, s.design) + (s.design == null ? '' : ' look');
+  return 'Format: ' + (FORMAT[s.output] || s.output || 'none') + ' · readers: ' + (s.audience || 'none') + ' · goes out ' + goesWords(s.schedule) + sec + look;
 }
 
 function fold(lines) {
@@ -107,26 +157,58 @@ function fold(lines) {
 }
 
 /** T1, from the setup as it is now. Once: a report with a version already keeps it. `chat` names the conversation it came from. */
-function ensureFirst(root, id, setup, { chat, now } = {}) {
+function ensureFirst(root, id, setup, { chat, refs, why, now } = {}) {
   if (!ID_RE.test(String(id || ''))) return refuse(400, 'id must be a report id');
   const f = fold(readLines(root, id));
   if (f.current != null) return { ok: true, n: f.current, existing: true };
-  const line = { ev: 'version', n: 1, settings: settingsOf(setup), why: 'First shape, from your chat.' };
+  const line = { ev: 'version', n: 1, settings: settingsOf(setup, refs || liveRefs(root, id)), why: typeof why === 'string' && why ? why.slice(0, 200) : 'First shape, from your chat.' };
   if (typeof chat === 'string' && CHAT_RE.test(chat)) line.chat = chat;
   append(root, id, line, now);
   return { ok: true, n: 1 };
 }
 /** The PM's ✓ on a changed template: T<n+1> with these settings is the current one. Unchanged settings write nothing. */
-function addVersion(root, id, settings, { why, now } = {}) {
+function addVersion(root, id, settings, { why, names, fill, now } = {}) {
   if (!ID_RE.test(String(id || ''))) return refuse(400, 'id must be a report id');
   const f = fold(readLines(root, id));
   const cur = f.versions.find((v) => v.current);
-  const next = { ...(cur ? cur.settings : {}), ...(cleanSettings(settings) || {}) };
-  if (cur && sameSettings(cur.settings, next)) return { ok: true, n: cur.n, unchanged: true };
+  // `fill`: the sections and look saved before this change, for a current T line that did not record them (written before TplA)
+  const was = cur ? { ...(isObj(fill) ? fill : {}), ...cur.settings } : null;
+  const next = { ...(was || {}), ...(cleanSettings(settings) || {}) };
+  if (cur && sameSettings(was, next)) return { ok: true, n: cur.n, unchanged: true };
   const n = f.versions.reduce((m, v) => Math.max(m, v.n), 0) + 1;
-  append(root, id, { ev: 'version', n, settings: next, why: typeof why === 'string' && why.trim() ? why.trim().slice(0, 200) : diffWords(cur && cur.settings, next).join('; ') }, now);
+  append(root, id, { ev: 'version', n, settings: next, why: typeof why === 'string' && why.trim() ? why.trim().slice(0, 200) : diffWords(was, next, names).join('; ').slice(0, 200) }, now);
   return { ok: true, n, settings: next };
 }
+/** The saved version (accept n, unsave null) of one store's events at a time; undefined when the store has no event at or before it. */
+function savedAt(events, t) {
+  let out;
+  for (const e of Array.isArray(events) ? events : []) {
+    const at = Date.parse((e && e.at) || '');
+    if (!Number.isFinite(at) || at > t) continue;
+    if (e.ev === 'accept') out = refN(e.n); else if (e.ev === 'unsave') out = null;
+  }
+  return out;
+}
+/** Backfill on read (live check of 0.494.0, brief 4 item 10): a T line written before TplA has no sections or look. Each such version takes the
+ * S<n> and D<n> that were saved at its time (no saved one then = the standard ones); the current version takes the ones saved now. Nothing is
+ * written. `filled` names the keys that were backfilled. Pure apart from reading the two stores' events. */
+function backfill(root, id, folded) {
+  if (!folded || !Array.isArray(folded.versions) || !folded.versions.some((v) => v.settings.structure === undefined || v.settings.design === undefined)) return folded;
+  let sEv = [], dEv = [];
+  try { sEv = require('./report-structure.js').readEvents(root, id); } catch { sEv = []; }
+  try { dEv = require('./report-design.js').readEvents(root, id); } catch { dEv = []; }
+  const live = liveRefs(root, id);
+  const versions = folded.versions.map((v) => {
+    const fill = {}; const t = Date.parse(v.at || '');
+    for (const [k, ev] of [['structure', sEv], ['design', dEv]]) {
+      if (v.settings[k] !== undefined) continue;
+      const then = Number.isFinite(t) ? savedAt(ev, t) : undefined;
+      fill[k] = v.current || !Number.isFinite(t) ? live[k] : then === undefined ? null : then;
+    }
+    return Object.keys(fill).length ? { ...v, settings: { ...v.settings, ...fill }, filled: Object.keys(fill) } : v;
+  });
+  return { ...folded, versions };
+}
 /** Go back to T<n>: that version is the current one again. Nothing is deleted. */
 function restore(root, id, n, { now } = {}) {
   const f = fold(readLines(root, id));
@@ -169,4 +251,13 @@ function review(markdown, { slot = '', now = Date.now(), listed = [] } = {}) {
   return { fix, passed };
 }
 
-module.exports = { ID_RE, CHAT_RE, FORMAT, ledgerOf, readLines, fold, settingsOf, cleanSettings, sameSettings, diffWords, settingsWords, goesWords, ensureFirst, addVersion, restore, cyclesOf, chatOf, review };
+/**
+ * A sections or look change saved in its own studio (Structure "Use this", Design "Use it") is the PM's ✓ too: the template follows it as
+ * T<n+1>. Call `followBefore(root, id, setup)` BEFORE the studio's accept line (T1 then records the sections and look as they were; it answers
+ * them), and `followAfter(root, id, { structure | design }, was)` after it, with that answer.
+ */
+function followBefore(root, id, setup) { try { const was = liveRefs(root, id); ensureFirst(root, id, setup, { refs: was }); return was; } catch { return null; } }
+function followAfter(root, id, patch, was) { try { return addVersion(root, id, patch, { names: namesOf(root, id), fill: was }); } catch { return null; } }
+
+module.exports = { ID_RE, CHAT_RE, FORMAT, STANDARD_LOOK, ledgerOf, readLines, fold, settingsOf, cleanSettings, sameSettings, sectionsDiff, diffWords, settingsWords, goesWords,
+  liveRefs, namesOf, refN, ensureFirst, backfill, savedAt, addVersion, restore, cyclesOf, chatOf, review, followBefore, followAfter };

package/workspace/lib/routes-boards.js

@@ -207,10 +207,43 @@ function createAndPlace(ctx, w, boardId, input, actor, tie) {
   const stage = (ownWf || board.workflow)[0].name;
   tie({ file, board, initiative: r.id, stage });
   if (ownWf) append(file, actor, { kind: 'ini-workflow', board: board.id, id: r.id, template: tpl, stages: ownWf, moved: null });
+  const wfStart = startOnDefault(ctx, w, r.id, actor, { boardId: board.id });
   rowsLib.invalidate(w.root);
   rowCache.delete(w.root);
   if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id);
-  return { ok: true, initiative: { id: r.id, path: r.path }, stage, board: board.id };
+  return { ok: true, initiative: { id: r.id, path: r.path }, stage, board: board.id, ...(wfStart ? { wf: wfStart } : {}) };
+}
+
+/** Batch 24 item 3 (canvas DfA): a new initiative starts on the default workflow (Settings › Workflows, the star). It writes one ini-wf
+ * line on the initiative's board, the line a workflow switch writes, so every surface reads the workflow from it; with no `moved` the
+ * initiative stands in the first stage (Triage) and no move shows in its history. Product feature (the default when none is set, or when
+ * the default is archived) writes nothing. The workspace's own default first; a workspace that never set one reads the home workspace's
+ * (Settings opens on home), and that workflow is adopted into this workspace's library first, as a switch does. PMOS still reads the BRD
+ * and proposes a switch. Never throws: a new initiative is made even when this line cannot be written.
+ * boardId: the board the initiative is on; else its domain board (products/<domain>/) or the workspace board. → the workflow id | null */
+function startOnDefault(ctx, w, iniId, actor, { boardId = null, recordPath = null } = {}) {
+  try {
+    const file = ledgerFile(ctx, w);
+    const dir = ctx.stateDirFor ? ctx.stateDirFor(w) : null;
+    if (!file || !dir || isSelf(ctx, w)) return null;
+    let lib = WS.library(dir), from = null;
+    if (!lib.defaultId) {
+      const home = ctx.getWs ? ctx.getWs(null) : null;
+      const hd = home && home.id !== w.id && ctx.stateDirFor ? ctx.stateDirFor(home) : null;
+      const hl = hd ? WS.library(hd) : null;
+      if (hl && hl.defaultId) { lib = hl; from = home; }
+    }
+    const def = WF.defaultOf(lib);
+    if (def.id === WF.PRODUCT_FEATURE_ID) return null;
+    const fr = frameFor(ctx, w);
+    const dm = recordPath ? /^products\/([^/]+)\//.exec(recordPath) : null;
+    const bid = boardId || (dm && fr.boards.some((b) => b.id === dm[1] && b.kind === 'domain') ? dm[1] : w.id);
+    const board = fr.boards.find((b) => b.id === bid);
+    if (!board || board.self) return null;
+    if (from && !WS.library(dir).byId.has(def.id)) { const a = WS.adopt(dir, def, actor, from.id); if (!a.ok) return null; }
+    append(file, actor, { kind: 'ini-wf', board: board.id, id: iniId, wf: def.id, why: 'the default workflow for new initiatives', start: true });
+    return def.id;
+  } catch { return null; }
 }
 
 // ── boards of a workspace ─────────────────────────────────────────────────────────────────────────
@@ -225,7 +258,7 @@ function domainsOf(root) {
 
 function boardsOf(ctx, w, folded) {
   const self = isSelf(ctx, w);
-  const base = [{ id: w.id, name: w.name || path.basename(w.root), domain: null, kind: 'default' }];
+  const base = [{ id: w.id, name: w.label || w.name || path.basename(w.root), domain: null, kind: 'default' }];
   for (const d of domainsOf(w.root)) if (d !== w.id) base.push({ id: d, name: d, domain: d, kind: 'domain' });
   const known = new Set(base.map((b) => b.id));
   for (const [id, b] of folded.boards) if (!known.has(id) && b.created) { base.push({ id, name: b.name || id, domain: b.domain || null, kind: 'created' }); known.add(id); }
@@ -1784,4 +1817,4 @@ function meetingBoards(ctx) {
   return { list, detail };
 }
 
-module.exports = { prefixes: ['/api/boards'], handle, tasksOfIni, postFrame, needRows, itemsOf, readLedger, foldOf, epicsOf, rowsOfBoard, invalidateRows: (w) => { rowsLib.invalidate(w.root); rowCache.delete(w.root); }, move, switchWorkflow, taskState, taskAdd, taskEdit, writeAs, taskDelete, taskRestore, initiativeWorkflow, seedInitiative, stageTasks, boardIndex, appendScanAsk, scanDeclineSignal, createAndPlace, ledgerFile, append, frameFor, boardIdOf, meetingBoards, boardsOf, baseRows, boardRow, taskSpanOf, workflowRowOf, foldOf, portfolio, SELF_REFUSAL, NO_STATE };
+module.exports = { prefixes: ['/api/boards'], handle, tasksOfIni, postFrame, needRows, itemsOf, readLedger, foldOf, epicsOf, rowsOfBoard, invalidateRows: (w) => { rowsLib.invalidate(w.root); rowCache.delete(w.root); }, move, switchWorkflow, taskState, taskAdd, taskEdit, writeAs, taskDelete, taskRestore, initiativeWorkflow, seedInitiative, stageTasks, boardIndex, appendScanAsk, scanDeclineSignal, createAndPlace, startOnDefault, ledgerFile, append, frameFor, boardIdOf, meetingBoards, boardsOf, baseRows, boardRow, taskSpanOf, workflowRowOf, foldOf, portfolio, SELF_REFUSAL, NO_STATE };

package/workspace/lib/routes-brief-page.js

@@ -28,6 +28,7 @@
  * has it. A deferred item ('Not yet') is left out until its defer date or time. Writes go through the existing pm-items routes; a mention's
  * read mark goes through POST /api/mentions/read (routes-mentions.js). */
 const path = require('path');
+const fs = require('fs');
 const pmItems = require('./pm-items.js');
 const { repoScript } = require('./repo-script.js');
 
@@ -233,12 +234,29 @@ function notesAdapter(runtimeDir) {
   };
 }
 
-/** The PM's first name for the greeting: the first word of `git config user.name` where PMOS runs. null when git holds none (the page then greets without a name). */
+/** The PM's first name for the greeting: the first word of `git config user.name` where PMOS runs. null when git holds none (the page then greets without a name).
+ *  Kept until one of git's config files changes (page-open-speed): Home asked `git` twice per open, about 35 ms each, on the thread every
+ *  other answer waits for. The key is the size and time of the files `git config` reads, so an edited name shows on the next open. */
+const nameCache = new Map();   // cwd -> { key, name }
+function gitConfigKey(cwd) {
+  const os = require('os');
+  const home = os.homedir();
+  const files = [path.join(home, '.gitconfig'), path.join(process.env.XDG_CONFIG_HOME || path.join(home, '.config'), 'git', 'config')];
+  if (cwd) files.push(path.join(cwd, '.git', 'config'));   // a caller with no folder (routes-mentions answer in a test) reads the global config only
+  if (process.env.GIT_CONFIG_GLOBAL) files.push(process.env.GIT_CONFIG_GLOBAL);
+  return files.map((f) => { try { const st = fs.statSync(f); return st.size + ':' + st.mtimeMs; } catch { return '-'; } }).join('|');
+}
 function firstName(cwd) {
+  const key = gitConfigKey(cwd);
+  const hit = nameCache.get(cwd);
+  if (hit && hit.key === key) return hit.name;
+  let name = null;
   try {
     const n = String(require('child_process').execFileSync('git', ['config', 'user.name'], { cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] })).trim().split(/\s+/)[0];
-    return n && n.length <= 40 ? n : null;
-  } catch { return null; }
+    name = n && n.length <= 40 ? n : null;
+  } catch { name = null; }
+  nameCache.set(cwd, { key, name });
+  return name;
 }
 
 module.exports = {

package/workspace/lib/routes-grill.js

@@ -7,7 +7,8 @@
  *       spent, left   this month, in US dollars (lib/grill.js spentIn: an open run counts its whole budget)
  *       paused        the cap held a run back this month
  *       runs          for each initiative asked for: its last ended run { ini, why, at, cost, n, turn? }; n = its open grill findings
- *       news          the newest ended run of this workspace in the last 7 days that left open findings (Home's one line); null is silence
+ *       news          the newest ended run of this workspace in the last 7 days that left open findings (Home's one line); null is silence.
+ *                     news.more: how many other initiatives were grilled this week with open findings; news.total: all their open findings
  *     run.turn: { scope, id, to } when the run started on a forecast turn (lib/forecast.js `turned` line, its key)
  *
  * Read-only: no run starts from a page (Claude grills by itself, lib/grill-runs.js), and the settings are written by /api/settings. */
@@ -44,13 +45,18 @@ function model(ctx, w, inis, now = Date.now()) {
   const shape = (r) => ({ ini: r.ini, why: r.why, at: r.endAt || r.at, cost: r.cost, n: P ? openFindings(P, r.ini) : 0, ...(r.why === 'forecast' ? { turn: turnOf(r, turned) } : {}) });
   const runs = {};
   for (const id of inis) { const r = ended.filter((x) => x.ini === id).pop(); if (r) runs[id] = shape(r); }
-  let news = null;
-  for (let i = ended.length - 1; i >= 0 && !news; i--) {
+  // news: the newest; more and total: the other initiatives grilled this week that left open findings, so Home says how many, not just one
+  let news = null; const others = new Set(); let total = 0;
+  for (let i = ended.length - 1; i >= 0; i--) {
     const r = ended[i];
     if (now - (Date.parse(r.endAt || r.at) || 0) > WEEK) break;
+    if ((news && r.ini === news.ini) || others.has(r.ini)) continue;
     const s = shape(r);
-    if (s.n > 0) news = s;
+    if (!(s.n > 0)) continue;
+    if (!news) news = s; else others.add(r.ini);
+    total += s.n;
   }
+  if (news) Object.assign(news, { more: others.size, total });
   return { ok: true, mode: G.modeOf(get, ctx.env || process.env), envOff: G.off(ctx.env || process.env), cap: Number.isFinite(cap) ? cap : null,
     spent, left: Number.isFinite(cap) ? Math.max(0, Math.round((cap - spent) * 100) / 100) : null, month, paused: F.paused.has(month), runs, news };
 }

package/workspace/lib/routes-impact.js

@@ -5,10 +5,11 @@
  *
  *   GET  /api/impact/week?week=YYYY-MM-DD   → { ok, on, live, first, week, from, to, label, grow, celebrate, quiet, items }   Home's Adler, the Viewer
  *   GET  /api/impact/weeks                  → { ok, on, live, weeks: [{ week, from, to, label, quiet, items }] }            the log, newest first
- *   GET  /api/impact/check                  → { ok, on, due, week, label, items, gate }                                       the weekly check in Home's chat
+ *   GET  /api/impact/check                  → { ok, on, due, week, label, items, gate, looked }                               the weekly check in Home's chat
  *   POST /api/impact/verdict      { id, real }   → { ok }     ✓ (true) or ✕ (false) one row
  *   POST /api/impact/verdict-all  { week }       → { ok }     ✓✓ every row of that week not checked yet
- *   POST /api/impact/undo         { id }         → { ok }     the row back to not checked
+ *   POST /api/impact/undo         { id }         → { ok }     the row back to not checked (a dropped row counts again)
+ *   POST /api/impact/looked       { week }       → { ok }     the check card was shown for last week (a closed week then counts for the gate)
  *   POST /api/impact/seen         { ids }        → { ok }     read on a Phase 2 surface; ends its one celebration
  * `ws` is accepted on every route and ignored: the ledger is per person, across products.
  *
@@ -50,7 +51,7 @@ async function handle(req, res, url, ctx) {
       : what === 'weeks' ? IM.weeksView(F, optsOf(ctx)) : IM.checkView(F, optsOf(ctx));
     return send({ status: 200, body: { ok: true, on: true, ...body } });
   }
-  if (!['verdict', 'verdict-all', 'undo', 'seen'].includes(what)) return send(bad(404, 'no such impact route'));
+  if (!['verdict', 'verdict-all', 'undo', 'seen', 'looked'].includes(what)) return send(bad(404, 'no such impact route'));
   if (req.method !== 'POST') return send(bad(405, 'POST only'));
   if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'Only you check your impact, from the page. Claude\'s run files items with pmos impact.'));
   const rd = await ctx.readJson(req);
@@ -63,10 +64,17 @@ async function handle(req, res, url, ctx) {
   const F = IM.read(dir), at = new Date(nowMs(ctx)).toISOString(), by = { by: 'pm' };
 
   if (what === 'seen') {
-    const ids = (Array.isArray(body.ids) ? body.ids : []).map(String).filter((id) => { const it = F.items.get(id); return it && it.real === true && !it.read; }).slice(0, 100);
+    const ids = (Array.isArray(body.ids) ? body.ids : []).map(String).filter((id) => { const it = F.items.get(id); return it && it.real !== false && !it.read; }).slice(0, 100);
     if (ids.length) IM.append(dir, by, { kind: 'seen', ids }, at);
     return send({ status: 200, body: { ok: true } });
   }
+  if (what === 'looked') {
+    const week = text(body.week), o = optsOf(ctx);
+    if (week !== IM.addDays(IM.weekOf(o.today, o.start), -7)) return send(bad(400, 'week is the first day of last week, YYYY-MM-DD: the week the check is open for'));
+    if (!F.looked.has(week)) IM.append(dir, by, { kind: 'looked', week }, at);
+    noteGate(ctx, dir);
+    return send({ status: 200, body: { ok: true } });
+  }
   if (what === 'verdict-all') {
     const week = text(body.week), o = optsOf(ctx);
     if (!/^\d{4}-\d{2}-\d{2}$/.test(week)) return send(bad(400, 'week is the first day of the week, YYYY-MM-DD'));

package/workspace/lib/routes-initiatives.js

@@ -666,6 +666,7 @@ async function handle(req, res, url, ctx) {
     const { ws: _ws, ...input } = body;
     const r = writer.createInitiative(w.root, input, { actor: g.actor });
     if (!r.ok) { ctx.json(res, { ok: false, status: r.status, error: r.error, field: r.field }, r.status); return true; }
+    require('./routes-boards.js').startOnDefault(ctx, w, r.id, g.actor, { recordPath: r.path });   // batch 24 item 3: the default workflow
     rowsLib.invalidate(w.root);
     if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id);
     ctx.json(res, { ok: true, id: r.id, path: r.path, written: r.written, sig: sigOf(w.root) });

package/workspace/lib/routes-programs.js

@@ -33,6 +33,7 @@ const guard = require('./pm-guard.js');
 const pmItems = require('./pm-items.js');
 const P = require('./programs.js');
 const MS = require('./milestone-suggest.js');
+const gitShape = require('./git-shape.js');
 const gitInfo = require('./git-info.js');
 const deletedIds = require('./ini-deleted.js');
 
@@ -54,17 +55,18 @@ const read = (f) => { try { return f ? pmItems.readLines(f).filter(Boolean) : []
  *  such, a charter saved from the worktree puts the program under the worktree product while its members sit under the main one, and a
  *  member line that both hold shows twice. So the ledgers of a repo's trees are read as ONE product, the main tree's. Null when the
  *  workspace is not a linked worktree, or its main tree is not registered (nothing to fold into). Memoised: all() runs on every poll. */
-const MAIN_TTL_MS = 15000;
-const mainCache = new Map();   // root -> { at, main: root of the repo's main tree | null }
+// Kept while the folder's git shape stamp is unchanged (page-open-speed): a 15 s clock re-ran `git` on every Board open after a break.
+const mainCache = new Map();   // root -> { stamp, main: root of the repo's main tree | null }
 function mainTreeRoot(w) {
   const hit = mainCache.get(w.root);
-  if (hit && Date.now() - hit.at < MAIN_TTL_MS) return hit.main;
+  const stamp = gitShape.shapeStamp(w.root);
+  if (hit && hit.stamp === stamp) return hit.main;
   let main = null;
   try {
     const top = gitInfo.repoRoot(w.root), trees = top ? gitInfo.worktrees(w.root) : [];
     if (top && trees.length && trees[0].dir && path.resolve(trees[0].dir) !== path.resolve(top)) main = path.join(path.resolve(trees[0].dir), path.relative(path.resolve(top), path.resolve(w.root)));
   } catch { main = null; }
-  mainCache.set(w.root, { at: Date.now(), main });
+  mainCache.set(w.root, { stamp, main });
   return main;
 }
 function foldedInto(list, w) {

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

@@ -14,6 +14,7 @@
  *   POST /api/report-design/revert   { ws, id, n }   → { ok, design }
  *   GET  /api/report-design/cycle?ws&path         → { ok, designed, design_version, format, outline, differences, decisions, matches, rendering, previous }
  *   GET  /api/report-design/cycle-html?ws&path    → text/html, the sanitized cycle render
+ *   GET  /api/report-design/pyramid?ws&path       → text/html, the finished slides of a cadence draft (lib/report-pyramid.js; 404 for another document)
  *   POST /api/report-design/cycle-decision { ws, path, diff, choice: keep | adopt | match }   → { ok, cycle }
  *   GET  /api/report-notes?ws&path                → { ok, speaker, suggestions, pins }
  *   POST /api/report-notes/speaker { ws, path, slide, text } | { ws, path, slide, keep: true }
@@ -43,9 +44,11 @@ const path = require('path');
 const crypto = require('crypto');
 const guard = require('./pm-guard.js');
 const D = require('./report-design.js');
+const RT = require('./report-templates.js');
 const RS = require('./report-setups.js');
 const RC = require('./report-checks.js');
 const RDraft = require('./report-draft.js');
+const RP = require('./report-pyramid.js');
 const headless = require('./headless.js');
 
 const text = (v) => (typeof v === 'string' ? v : '');
@@ -475,6 +478,14 @@ async function handle(req, res, url, ctx) {
       const setup = e ? setupOf(w.root, e.id) : null;
       return send({ status: 200, body: { ok: true, id: setup ? e.id : null, name: setup ? setup.name : null, at: setup ? e.at : null } });
     }
+    if (sub === 'pyramid') {
+      // The finished slides of a cadence draft (canvas RsA): the Pyramid deck in the report's saved look, else the standard PMOS look.
+      const d = reportDoc(w, text(url.searchParams.get('path'))); if (d.error) return send(d.error);
+      let md; try { md = fs.readFileSync(d.c.md, 'utf8'); } catch { return send(bad(404, 'no such report document')); }
+      const deck = RP.deckOf(md, RP.lookOf(w.root, d.c.cadence), { data: RP.dataOf(d.c.md) });
+      if (!deck) return send(bad(404, 'this document is not a cadence draft, so it has no Pyramid deck'));
+      return sendHtml(res, D.sanitize(RP.deckHtml(deck)));
+    }
     if (sub === 'cycle' || sub === 'cycle-html') {
       const d = reportDoc(w, text(url.searchParams.get('path'))); if (d.error) return send(d.error);
       if (sub === 'cycle') return send({ status: 200, body: cycleAnswer(w, d.c) });
@@ -532,7 +543,9 @@ async function handle(req, res, url, ctx) {
         rules: D.rulesFor(root, c.cadence, st.saved.version), from: 'adopt', actor: g.actor });
       if (!v.ok) return fail(v);
       newVersion = v.n;
+      const tw = RT.followBefore(root, c.cadence, setupOf(root, c.cadence));
       D.append(root, c.cadence, { ev: 'accept', n: v.n, rules: D.rulesFor(root, c.cadence, v.n) }, { actor: g.actor });
+      RT.followAfter(root, c.cadence, { design: v.n }, tw);   // the template follows the saved look as T<n+1> (canvas TplA)
       D.writeBrief(root, c.cadence, setupOf(root, c.cadence));
     }
     const r = D.decideCycle(root, c.rel, { diff: diff.id, choice, newVersion });
@@ -597,7 +610,9 @@ async function handle(req, res, url, ctx) {
     const n = body.n;
     if (!Number.isInteger(n) || !D.stateOf(root, id).versions.has(n)) return send(bad(404, 'no such version'));
     if (sub === 'revert') { D.append(root, id, { ev: 'revert', n }, { actor: g.actor }); return answer(); }
+    const tw = RT.followBefore(root, id, setup);
     D.append(root, id, { ev: 'accept', n, rules: D.rulesFor(root, id, n) }, { actor: g.actor });
+    RT.followAfter(root, id, { design: n }, tw);   // the template follows the saved look as T<n+1> (canvas TplA)
     const b = D.writeBrief(root, id, setup);
     if (!b.ok) return fail(b);
     // the current cycle is redrawn in the saved design at once (Wawan, 2026-10-13); older cycles, and a cycle already sent, keep their look