create-pmos 0.493.0 → 0.495.0

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

@@ -3,12 +3,23 @@
  *
  *   GET  /api/report-flow?ws&id            → { ok, id, name, audience, output, schedule, status, template: { current, versions: [{ n, settings, words,
  *                                             why, at, current, cycles }] }, cycles: [{ path, slot, state }] (newest first), latest, drafting, session,
- *                                             review }   the report's current state: what the chat chip opens
+ *                                             review, sections, look }   the report's current state: what the chat chip opens.
+ *                                             sections: { saved: S<n> | null, titles }   the sections the next cycle follows
+ *                                             look: { saved: D<n> | null, words, follows: [sample], newer: { n, words } | null }   the look, and a newer
+ *                                             design version not saved yet (made in Design): the template panel offers it as a change
  *   GET  /api/report-flow/review?ws&path   → { ok, review: { fix: [{ id, title, why }], passed: [label] } }   Claude's review of one draft
  *   POST /api/report-flow/start   { ws, id, chat? }                  → { ok, n }    T1 of a report just set up, and the conversation it came from
- *   POST /api/report-flow/template { ws, id, settings }              → { ok, n }    the PM's ✓ on a changed template: applied, and T<n+1>
- *   POST /api/report-flow/restore  { ws, id, n }                     → { ok, n }    Go back to T<n>: applied; nothing is deleted
- *   POST /api/report-flow/ask      { ws, id, text, path? }           → { ok, session, passed | started }   a change for the report's own session
+ *   POST /api/report-flow/template { ws, id, settings?, sections?, design? } → { ok, n }  the PM's ✓ on a changed template (canvas TplA): applied,
+ *                                             and ONE T<n+1> holding all of it. sections: the titles in order (a new S version, saved); design: a D
+ *                                             version made in Design (saved), or null for the standard look. The open draft is not written again.
+ *   POST /api/report-flow/restore  { ws, id, n }                     → { ok, n, restored }   Go back to T<n>: its format, readers and schedule,
+ *                                             and its sections and look when it recorded them, are applied; nothing is deleted. Cycles keep
+ *                                             the look they were made with; the open draft stays as it is
+ *   POST /api/report-flow/ask      { ws, id, text, path? }           → { ok, session, path, passed | started }   a change for the report's own session
+ *                                     Without a path the change goes to the report's latest draft; an issued latest cycle (or path) is refused
+ *                                     409, as an issued report is frozen. The session always gets the file and its slot, and "do not draft a new
+ *                                     slot", so a change edits the draft that exists (report-building brief 1). A change to the words edits only
+ *                                     the named notes and keeps every caveat; it redrafts only when the PM asks for fresh numbers (brief 4).
  *
  * THE REPORT'S OWN SESSION. Each template drafts in a session of its own, never in the PM's chat (the agreed note). A report with a saved
  * structure drafts in the session its schedule starts (lib/routes-report-structure.js draftNow, origin schedule:<id>). A change the PM asks for
@@ -25,6 +36,8 @@ const guard = require('./pm-guard.js');
 const RT = require('./report-templates.js');
 const RS = require('./report-setups.js');
 const RN = require('./report-needs.js');
+const RSt = require('./report-structure.js');
+const RD = require('./report-design.js');
 const issues = require('./issues.js');
 
 const prefixes = ['/api/report-flow'];
@@ -50,8 +63,14 @@ function draftingOf(ctx, w, id) { try { return typeof ctx.structureDraftState ==
 function stateOf(ctx, w, id, now = Date.now()) {
   const root = w.root, s = setupOf(root, id);
   const cycles = cyclesOf(root, id);
-  const f = RT.fold(RT.readLines(root, id));
+  // a report set up before the template flow, with a saved look or sections, gets its T1 now (brief 4 item 10): its template is what is saved
+  const live0 = RT.liveRefs(root, id);
+  if (s && s.status !== 'removed' && (live0.design != null || live0.structure != null) && RT.fold(RT.readLines(root, id)).current == null) {
+    try { RT.ensureFirst(root, id, s, { refs: live0, why: 'The template as it was set up, with its saved look and sections.' }); } catch { /* shown with no versions */ }
+  }
+  const f = RT.backfill(root, id, RT.fold(RT.readLines(root, id)));
   const counts = RT.cyclesOf(f, cycles.filter((c) => c.issued_at).map((c) => ({ at: c.issued_at })));
+  const names = RT.namesOf(root, id), live = RT.liveRefs(root, id);
   const sess = readSession(root, id);
   const drafting = draftingOf(ctx, w, id);
   const latest = cycles[0] || null;
@@ -59,12 +78,59 @@ function stateOf(ctx, w, id, now = Date.now()) {
   if (latest && latest.state === 'draft') { const t = readText(root, latest.path); if (t != null) review = RT.review(t, { slot: latest.slot, now, listed: s && Array.isArray(s.sections) ? s.sections : [] }); }
   return {
     ok: true, id, name: s ? s.name : id, audience: s ? s.audience : '', output: s ? s.output : '', schedule: s ? s.schedule : null, status: s ? s.status : 'removed',
-    template: { current: f.current, versions: f.versions.map((v) => ({ ...v, words: RT.settingsWords(v.settings), cycles: counts.get(v.n) || 0 })) },
+    template: { current: f.current, versions: f.versions.map((v) => ({ ...v, words: RT.settingsWords(v.settings, names), cycles: counts.get(v.n) || 0 })) },
     cycles, latest, drafting,
     session: sess ? { id: sess.session, alive: alive(ctx, sess.session), since: sess.since || null } : null,
     review,
+    sections: { saved: live.structure, titles: names.sections(live.structure) || (s && Array.isArray(s.sections) ? s.sections.slice() : []) },
+    look: lookOf(root, id, live.design, names),
   };
 }
+/** The look the next cycle follows, the samples it follows, and the newest design version made after it and not saved yet. */
+function lookOf(root, id, saved, names) {
+  let st = null; try { st = RD.stateOf(root, id); } catch { st = null; }
+  const follows = st ? [...st.samples.values()].map((x) => x.name).filter(Boolean).slice(0, 3) : [];
+  const top = st && st.versions.size ? Math.max(...st.versions.keys()) : null;
+  const newer = top != null && top !== saved && (saved == null || top > saved) ? { n: top, words: names.look(top) } : null;
+  return { saved, words: names.look(saved), follows, newer };
+}
+
+/** Save a template's sections and look in their own stores, as the studios' accept does, when they differ from what is saved now. A ref that is
+ * undefined (a T line from before TplA) is left as it is. */
+function applyRefs(root, id, setup, want, actor) {
+  const live = RT.liveRefs(root, id), done = {};
+  if (want.structure !== undefined && want.structure !== live.structure) {
+    if (want.structure == null) { RSt.append(root, id, { ev: 'unsave' }, { actor }); try { fs.unlinkSync(RSt.paths(root, id).brief); } catch { /* none written */ } }
+    else {
+      if (!RSt.stateOf(root, id).versions.has(want.structure) || !RSt.readVersion(root, id, want.structure)) return { ok: false, status: 409, error: `S${want.structure} is not on disk, so its sections cannot come back` };
+      RSt.append(root, id, { ev: 'accept', n: want.structure, charts: [] }, { actor });
+      RSt.writeBrief(root, id, setup);
+    }
+    done.structure = true;
+  }
+  if (want.design !== undefined && want.design !== live.design) {
+    if (want.design == null) { RD.append(root, id, { ev: 'unsave' }, { actor }); try { fs.unlinkSync(RD.paths(root, id).brief); } catch { /* none written */ } }
+    else {
+      if (!RD.stateOf(root, id).versions.has(want.design)) return { ok: false, status: 409, error: `D${want.design} is not on disk, so its look cannot come back` };
+      RD.append(root, id, { ev: 'accept', n: want.design, rules: RD.rulesFor(root, id, want.design) }, { actor });
+      RD.writeBrief(root, id, setup);
+    }
+    done.design = true;
+  }
+  return { ok: true, done };
+}
+/** The sections the PM named, as a new S version (planFromSections keeps the saved plan's purpose, sources and charts). → { ok, n } | refusal.
+ * The same titles as saved write nothing (n is the saved one). */
+function sectionsVersion(root, id, setup, titles, actor) {
+  const live = RT.liveRefs(root, id);
+  const was = live.structure != null ? RSt.readVersion(root, id, live.structure) : null;
+  const shaped = RSt.planFromSections(titles, { readers: (setup && setup.audience) || '', decision: (setup && setup.purpose) || '', base: was });
+  if (!shaped.ok) return shaped;
+  const same = was && Array.isArray(was.outline) && was.outline.map((o) => o.title).join('\n') === shaped.plan.outline.map((o) => o.title).join('\n');
+  if (same) return { ok: true, n: live.structure, same: true };
+  const v = RSt.landVersion(root, id, shaped.plan, { turn: 'The sections named in the chat.', answer: `Made the sections you named, for the next template.`, from: 'template', actor });
+  return v.ok ? { ok: true, n: v.n } : v;
+}
 
 /** Apply a template's settings to the setup line (report-setups change and reschedule): the live values follow the current version. */
 function apply(root, id, settings, opts) {
@@ -79,10 +145,17 @@ function apply(root, id, settings, opts) {
   return { ok: true };
 }
 
+const slotOfRel = (rel) => { const m = /(\d{4}-\d{2}-\d{2})\.md$/.exec(String(rel || '')); return m ? m[1] : null; };
+/** The line that names the draft a change is for: its file, its slot, and the rule that no new slot is drafted. */
+function draftWords(id, rel) {
+  const slot = slotOfRel(rel);
+  return rel && slot ? `The draft: ${rel} (slot ${slot}). Change that file in place: edit only the note or notes the change is about, and keep every caveat. `
+    + `Do not redraft for a change to the words. Only when the PM asks for fresh numbers, run \`pmos report draft ${id} ${slot} --redraft\`; never \`pmos report draft ${id}\` without the slot, and do not draft a new slot.` : '';
+}
 /** The words the report's session gets for one change. */
 function askPrompt(skill, id, rel, change) {
   return `${skill}\n\nThe PM's request for this run, given when it was scheduled (do not ask again): ${id}\n\n`
-    + `This is the report's own drafting session (the PMOS report flow), not the PM's chat. ${rel ? `Change the draft ${rel} in place. ` : ''}`
+    + `This is the report's own drafting session (the PMOS report flow), not the PM's chat. ${rel ? draftWords(id, rel) + ' ' : ''}`
     + `The change the PM asked for: ${change}\nChange only the draft. Never issue, send or share it: the PM issues it on the page.`;
 }
 function ask(ctx, w, id, change, rel) {
@@ -90,10 +163,10 @@ function ask(ctx, w, id, change, rel) {
   const d = draftingOf(ctx, w, id);
   const sess = readSession(root, id);
   const target = d && d.state === 'drafting' && alive(ctx, d.session) ? d.session : sess && alive(ctx, sess.session) ? sess.session : null;
-  const msg = `[PMOS report change] ${rel ? `Draft ${rel}: ` : ''}${change}. Change only the draft; never issue, send or share it.`;
+  const msg = `[PMOS report change] ${rel ? draftWords(id, rel) + ' ' : ''}The change: ${change}. Change only the draft; never issue, send or share it.`;
   if (target) {
     const sent = typeof ctx.sendToSession === 'function' && ctx.sendToSession(target, msg);
-    if (sent) return { ok: true, session: target, passed: true };
+    if (sent) return { ok: true, session: target, path: rel, passed: true };
   }
   if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'This workspace cannot start a session for the report.' };
   const skill = typeof ctx.skillPrompt === 'function' ? ctx.skillPrompt('report-template', w) : null;
@@ -104,7 +177,7 @@ function ask(ctx, w, id, change, rel) {
   const sp = ctx.spawnSession({ name: 'Report · ' + ((s && s.name) || id), agent: 'claude', ws: w.id, origin, initialInput: askPrompt(skill, id, rel, change) + '\r' });
   if (!sp || sp.state === 'exited' || !sp.id) return { ok: false, status: 409, error: 'The report\'s session did not start: ' + ((sp && sp.note) || 'no session') };
   try { fs.mkdirSync(path.dirname(sessionFile(root, id)), { recursive: true }); fs.writeFileSync(sessionFile(root, id), JSON.stringify({ session: sp.id, since: new Date().toISOString() }) + '\n'); } catch { /* shown as no session */ }
-  return { ok: true, session: sp.id, started: true };
+  return { ok: true, session: sp.id, path: rel, started: true };
 }
 
 async function handle(req, res, url, ctx) {
@@ -152,33 +225,56 @@ async function handle(req, res, url, ctx) {
     return r.ok ? send({ status: 200, body: { ok: true, n: r.n } }) : fail(r);
   }
   if (sub === 'template') {
-    const want = RT.cleanSettings(body.settings);
-    if (!want) return send(bad(400, 'say what changes: the format, who reads it or when it goes out'));
+    const want = { ...(RT.cleanSettings(body.settings) || {}) };
+    delete want.structure; delete want.design;   // these come only as sections (titles) and design (a D version), checked below
+    const titles = Array.isArray(body.sections) ? body.sections : null;
+    const hasDesign = body.design === null || Number.isInteger(body.design);
+    if (!Object.keys(want).length && !titles && !hasDesign) return send(bad(400, 'say what changes: the format, who reads it, when it goes out, its sections or its look'));
+    if (Number.isInteger(body.design) && !RD.stateOf(w.root, id).versions.has(body.design)) return send(bad(404, 'no such design version'));
     RT.ensureFirst(w.root, id, s);
+    const live = RT.liveRefs(w.root, id);
     const f = RT.fold(RT.readLines(w.root, id)), cur = f.versions.find((v) => v.current);
-    const next = { ...(cur ? cur.settings : RT.settingsOf(s)), ...want };
-    if (cur && RT.sameSettings(cur.settings, next)) return send({ status: 200, body: { ok: true, n: cur.n, unchanged: true } });
+    // a T line from before TplA did not record its sections or look: it is compared as the ones saved now
+    const was = { ...live, ...(cur ? cur.settings : RT.settingsOf(s)) };
+    if (titles) {
+      const sv = sectionsVersion(w.root, id, s, titles, g.actor);
+      if (!sv.ok) return fail(sv);
+      want.structure = sv.n;
+    }
+    if (hasDesign) want.design = body.design;
+    const next = { ...was, ...want };
+    if (cur && RT.sameSettings(was, next)) return send({ status: 200, body: { ok: true, n: cur.n, unchanged: true } });
     const a = apply(w.root, id, next, opts);
     if (!a.ok) return fail(a);
-    const v = RT.addVersion(w.root, id, next);
+    const ar = applyRefs(w.root, id, s, next, g.actor);
+    if (!ar.ok) return fail(ar);
+    const names = RT.namesOf(w.root, id);
+    const v = RT.addVersion(w.root, id, next, { names, why: RT.diffWords(was, next, names).join('; ').slice(0, 200) });
     return v.ok ? send({ status: 200, body: { ok: true, n: v.n, state: stateOf(ctx, w, id) } }) : fail(v);
   }
   if (sub === 'restore') {
-    const f = RT.fold(RT.readLines(w.root, id)), v = f.versions.find((x) => x.n === +body.n);
+    const f = RT.backfill(w.root, id, RT.fold(RT.readLines(w.root, id))), v = f.versions.find((x) => x.n === +body.n);
     if (!v) return send(bad(404, 'no such template version'));
     const a = apply(w.root, id, v.settings, opts);
     if (!a.ok) return fail(a);
+    const ar = applyRefs(w.root, id, s, v.settings, g.actor);
+    if (!ar.ok) return fail(ar);
     const r = RT.restore(w.root, id, v.n);
-    return r.ok ? send({ status: 200, body: { ok: true, n: r.n, state: stateOf(ctx, w, id) } }) : fail(r);
+    return r.ok ? send({ status: 200, body: { ok: true, n: r.n, restored: RT.settingsWords(v.settings, RT.namesOf(w.root, id)), state: stateOf(ctx, w, id) } }) : fail(r);
   }
   // ask
   const change = text(body.text).replace(/\s+/g, ' ').trim();
   if (!change) return send(bad(400, 'say the change'));
   if (change.length > MAX_ASK) return send(bad(413, 'a change is at most ' + MAX_ASK + ' characters'));
-  const rel = text(body.path);
+  let rel = text(body.path);
   if (rel && !(new RegExp('(?:^|/)reports/' + id + '/\\d{4}-\\d{2}-\\d{2}\\.md$').test(rel) && !rel.split('/').includes('..'))) return send(bad(400, 'path must be a draft of this report'));
+  // The change goes to a draft that exists: the one named, else the latest cycle. An issued cycle is frozen, so its change is refused.
+  const cycles = cyclesOf(w.root, id);
+  const named = rel ? cycles.find((c) => c.slot === slotOfRel(rel)) : cycles[0];
+  if (named && named.state === 'issued') return send(bad(409, `the ${named.slot} report is issued, so it is frozen. Change the template for the next cycle instead`));
+  if (!rel && named) rel = named.path;
   const r = ask(ctx, w, id, change, rel || null);
   return r.ok ? send({ status: 200, body: r }) : fail(r);
 }
 
-module.exports = { prefixes, handle, stateOf, askPrompt };
+module.exports = { prefixes, handle, stateOf, askPrompt, draftWords };

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

@@ -276,7 +276,7 @@ async function tick(ctx, now = new Date()) {
 function exportAnswer(ctx, res, w, url) {
   const rel = text(url.searchParams.get('path'));
   const fmt = text(url.searchParams.get('fmt'));
-  if (fmt === 'pdf') return bad(400, 'PDF is printed by the browser. Use Print in the document.');
+  if (fmt === 'pdf') return bad(400, 'PDF is printed by the browser, so there is no PDF file to download here. Open the report, press Download › PDF, and choose Save as PDF in the print window: you get the same slides, one on each page.');
   if (!Object.prototype.hasOwnProperty.call(RX.FORMATS, fmt)) return bad(400, `fmt must be one of ${Object.keys(RX.FORMATS).join(', ')}`);
   if (!RC.isReportPath(rel)) return bad(400, 'path must be a report document: <state>/reports/<cadence>/<slot>.md');
   const abs = path.resolve(w.root);
@@ -288,7 +288,9 @@ function exportAnswer(ctx, res, w, url) {
     if (!real.startsWith(fs.realpathSync(abs) + path.sep)) return bad(404, 'outside workspace');
     md = fs.readFileSync(real, 'utf8');
   } catch { return bad(404, 'no such document'); }
-  const out = RX.exportOf(md, fmt);
+  const cyc = /(?:^|\/)reports\/([a-z][a-z0-9-]{0,39})\/\d{4}-\d{2}-\d{2}\.md$/.exec(rel);
+  const RPy = require('./report-pyramid.js');
+  const out = RX.exportOf(md, fmt, fmt === 'pptx' && cyc ? { look: RPy.lookOf(abs, cyc[1]), data: RPy.dataOf(full) } : {});
   if (!out.ok) return bad(500, out.error);
   return { status: 200, file: out };
 }

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

@@ -42,6 +42,7 @@ const path = require('path');
 const os = require('os');
 const guard = require('./pm-guard.js');
 const S = require('./report-structure.js');
+const RT = require('./report-templates.js');
 const CS = require('./charts-store.js');
 const RS = require('./report-setups.js');
 const RDraft = require('./report-draft.js');
@@ -775,7 +776,9 @@ async function handle(req, res, url, ctx) {
       c.chart = r.chart.id; written.push(r.chart.id);
     }
     if (written.length) S.rewriteVersion(root, id, n, next);
+    const tw = RT.followBefore(root, id, setup);
     S.append(root, id, { ev: 'accept', n, charts: written }, { actor: g.actor });
+    RT.followAfter(root, id, { structure: n }, tw);   // the template follows the saved sections as T<n+1> (canvas TplA)
     const b = S.writeBrief(root, id, setup);
     if (!b.ok) return fail(b);
     return send({ status: 200, body: { ok: true, structure: answerOf(root, id), brief: b.path, charts: written } });

package/workspace/lib/routes-workflows.js

@@ -6,6 +6,7 @@
  *   POST /api/workflows/save    { ws, wf, moveRemoved? }   → { ok, workflow, moved } | 409 { ok:false, error, inUse }
  *   POST /api/workflows/copy    { ws, id, name? }          → { ok, workflow }
  *   POST /api/workflows/archive { ws, id, archived }       → { ok } | 409 { inUse }
+ *   POST /api/workflows/default { ws, id }                 → { ok, id }   the star: the workflow a new initiative starts on (batch 24 item 3, DfA)
  *   POST /api/workflows/draft   { ws, draft | null, note? } → { ok, draft }   (the page relays the chat's draft; the agent writes through `pmos workflow draft`)
  *   GET  /api/workflows/proposals                → { ok, items }   Claude's ✦: move the initiatives of a replaced workflow (batch 20 item 3, lib/wf-bridge.js)
  *   POST /api/workflows/bridge  { ws, id, from, map }       → { ok, workflow }   the bridge saved with the new workflow (WmB, Settings)
@@ -68,7 +69,7 @@ async function handle(req, res, url, ctx) {
   if (!read.ok) return send(bad(400, 'the body is not JSON'));
   const body = read.body;
   if (!isObj(body)) return send(bad(400, 'the body must be a JSON object'));
-  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'an agent session cannot save, copy or archive a workflow. It drafts one with `pmos workflow draft`, and the PM presses Create'));
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'an agent session cannot save, copy, archive or star a workflow. It drafts one with `pmos workflow draft`, and the PM presses Create'));
   const g = guard.requirePagePress(req, body);
   if (!g.ok) return send(bad(g.status, g.error));
   const w = wsOf(ctx, typeof body.ws === 'string' ? body.ws : null);
@@ -101,6 +102,10 @@ async function handle(req, res, url, ctx) {
     const r = WS.archive(dir, body.id, body.archived, g.actor, { inUse });
     return send(r.ok ? { body: { ok: true } } : bad(r.status || 400, r.error, r.inUse ? { inUse: r.inUse } : null));
   }
+  if (p === '/api/workflows/default') {
+    const r = WS.setDefault(dir, body.id, g.actor);
+    return send(r.ok ? { body: { ok: true, id: r.id } } : bad(r.status || 400, r.error));
+  }
   if (p === '/api/workflows/bridge' || p === '/api/workflows/switch-all' || p === '/api/workflows/switch-all/undo') {
     if (p !== '/api/workflows/switch-all/undo' && (typeof body.id !== 'string' || !body.id || typeof body.from !== 'string' || !body.from)) return send(bad(400, 'id (the new workflow) and from (the one it replaces) are required'));
     const r = p === '/api/workflows/bridge' ? Bridge.saveBridge(ctx, w, body, g.actor) : p === '/api/workflows/switch-all' ? Bridge.switchAll(ctx, w, body, g) : Bridge.undoAll(ctx, w, body, g);

package/workspace/lib/wf-bridge.js

@@ -69,12 +69,14 @@ function proposals(ctx) {
   const dir = home && ctx.stateDirFor ? ctx.stateDirFor(home) : null;
   if (!dir) return [];
   const lib = WS.library(dir);
+  // Most libraries replace nothing: then no workspace's initiatives are read at all (page-open-speed: New for you read every workspace's
+  // board frame on each Home open, ~100 ms on the thread every answer waits for, to find there was no ✦ to show).
+  const pairs = [...lib.byId.values()].map((wf) => [wf, replacesOf(lib, wf)]).filter(([, from]) => from);
+  if (!pairs.length) return [];
   const all = [];
   for (const w of workspaces(ctx)) { const st = standing(ctx, w); if (st) all.push(...st); }
   const out = [];
-  for (const wf of lib.byId.values()) {
-    const from = replacesOf(lib, wf);
-    if (!from) continue;
+  for (const [wf, from] of pairs) {
     const mine = all.filter((x) => movable(x, from.id));
     if (!mine.length) continue;
     const map = WF.mapOf(from, wf);

package/workspace/lib/workflow-cli.js

@@ -105,8 +105,8 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
 
   if (verb === 'list') {
     const all = WF.list(WS.library(stateDir));
-    if (json) { say(JSON.stringify({ ok: true, workflows: all.map((w) => ({ id: w.id, name: w.name, stages: w.stages.length, archived: !!w.archived })) })); return 0; }
-    for (const w of all) say(`${w.id} · ${w.name} · ${w.stages.length} stage${w.stages.length === 1 ? '' : 's'}${w.archived ? ' · archived' : ''}`);
+    if (json) { say(JSON.stringify({ ok: true, workflows: all.map((w) => ({ id: w.id, name: w.name, stages: w.stages.length, archived: !!w.archived, default: !!w.default })) })); return 0; }
+    for (const w of all) say(`${w.id} · ${w.name} · ${w.stages.length} stage${w.stages.length === 1 ? '' : 's'}${w.archived ? ' · archived' : ''}${w.default ? ' · default for new initiatives' : ''}`);
     return 0;
   }
   if (verb === 'show') {

package/workspace/lib/workflows-store.js

@@ -6,6 +6,7 @@
  *   copy(stateDir, id, name, actor)                     → { ok, workflow }
  *   adopt(stateDir, wf, actor, fromWs)                  → { ok, workflow }   another workspace's workflow written into this library
  *   archive(stateDir, id, archived, actor, { inUse })   → { ok }
+ *   setDefault(stateDir, id, actor)                     → { ok, id }          the workflow a new initiative starts on (one wf-default line)
  *   saveDraft(stateDir, { draft, note }, actor)         → { ok, draft }       (the chat's draft; null clears it)
  *   readDraft(stateDir)                                 → { draft, note, at } | null
  *   judge(stateDir, { board, id, stage, runs, why, cite, undo }, actor) → { ok }   one stage-judge line in boards.jsonl
@@ -89,9 +90,22 @@ function archive(stateDir, id, archived, actor, { inUse = [] } = {}) {
   if (!lib.byId.has(id)) return { ok: false, status: 404, error: 'That workflow could not be found. It may have been removed.' };
   if (archived && inUse.length) return { ok: false, status: 409, error: `${inUse.length} ${inUse.length === 1 ? 'initiative runs' : 'initiatives run'} this workflow. Move ${inUse.length === 1 ? 'it' : 'them'} to another workflow first.`, inUse };
   append(fileOf(stateDir), actor, { kind: 'wf-archive', id, archived: !!archived });
+  // Archiving the default puts Product feature back as the default, so a later Restore does not bring the old default back silently
+  if (archived && lib.defaultId === id) append(fileOf(stateDir), actor, { kind: 'wf-default', id: W.PRODUCT_FEATURE_ID });
   return { ok: true };
 }
 
+/** The default workflow for new initiatives in this workspace (batch 24 item 3, canvas DfA). Product feature can be the default. */
+function setDefault(stateDir, id, actor) {
+  if (!stateDir) return { ok: false, status: 409, error: NO_STATE };
+  const lib = library(stateDir);
+  const wf = typeof id === 'string' && id ? lib.byId.get(id) : null;
+  if (!wf) return { ok: false, status: 404, error: 'That workflow could not be found. It may have been removed.' };
+  if (wf.archived) return { ok: false, status: 409, error: `${wf.name} is archived. Restore it first.` };
+  append(fileOf(stateDir), actor, { kind: 'wf-default', id });
+  return { ok: true, id };
+}
+
 /** The chat's draft. It is checked like a save (so the Viewer never shows a draft Create would refuse); null clears it. */
 function saveDraft(stateDir, { draft, note } = {}, actor) {
   if (!stateDir) return { ok: false, status: 409, error: NO_STATE };
@@ -116,4 +130,4 @@ function judge(stateDir, { board, id, stage, runs, why, cite, undo } = {}, actor
   return { ok: true };
 }
 
-module.exports = { FILE, library, save, copy, adopt, archive, saveDraft, readDraft, judge, fileOf };
+module.exports = { FILE, library, save, copy, adopt, archive, setDefault, saveDraft, readDraft, judge, fileOf };

package/workspace/metric-drafts-ui-test.js

@@ -12,6 +12,7 @@ const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'metric-drafts-ui' });
 const BP = require('./lib/board-premium.js');
 const F = require('./fixtures/board-premium-facts.js');
@@ -68,7 +69,7 @@ const INITIATIVE = () => ({
   const shot = async (p, name) => { if (SHOTS) { await sleep(450); await p.screenshot({ path: path.join(SHOTS, name + '.png') }); } };
 
   const open = async ({ w = 1440, h = 900, drafts = { program: PROGRAM(), initiative: INITIATIVE() }, dark = false } = {}) => {
-    const c = await browser.newContext({ viewport: { width: w, height: h }, colorScheme: dark ? 'dark' : 'light' });
+    const c = await openMission(await browser.newContext({ viewport: { width: w, height: h }, colorScheme: dark ? 'dark' : 'light' }));
     const page = await c.newPage();
     const errors = [], posts = [], gets = [];
     page.on('pageerror', (e) => errors.push(String((e && e.stack) || e)));

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/premium-board-actions-test.js

@@ -10,6 +10,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'premium-board-actions' });
 const { makeRepos, codeRepo, write, git } = require('./plan-test-repos');
 const BP = require('./lib/board-premium.js');
@@ -71,7 +72,7 @@ const ALLOWED = /^\/api\/(?:boards\/(?:asks\/(?:add|accept|decline)|move|archive
 
   browser = await chromium.launch({ executablePath: exe });
   const open = async (url, { w = 1280, h = 900 } = {}) => {
-    const ctx = await browser.newContext({ viewport: { width: w, height: h } });
+    const ctx = await openMission(await browser.newContext({ viewport: { width: w, height: h } }));
     await ctx.addInitScript(() => { try { localStorage.setItem('pmos.premium.openAs', 'popup'); } catch { /* none */ } });
     const page = await ctx.newPage(), errors = [], posts = [];
     page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));

package/workspace/premium-chat-report-tab-test.js

@@ -46,7 +46,7 @@ const ANSWER = { role: 'assistant', text: 'Signups from the lightbox rose to 1,2
 const look = () => {
   const vw = document.querySelector('#czViewer:not([hidden])'), pane = vw ? vw.querySelector('.vz[data-vw^="report:"]') : null;
   return { shut: !pane, title: vw ? ((vw.querySelector('.cz-vw-title') || {}).textContent || '') : '', reader: !!(vw && vw.querySelector('.vz-rp0')), review: vw && vw.querySelector('.rf-rv') ? vw.querySelector('.rf-rv').textContent : null,
-    tpl: !!(vw && vw.querySelector('[data-cz-vw-p="template"]')), layer: false, chip: (document.querySelector('#hmLog [data-report-open]') || {}).textContent || null,
+    tpl: !!(vw && vw.querySelector('[data-cz-vw-p="template"]')) && !!(vw && vw.querySelector('[data-cz-vw-p="chat"]')), layer: false, chip: (document.querySelector('#hmLog [data-report-open]') || {}).textContent || null,
     json: /pmos-report|"kind"/.test((document.querySelector('#hmLog') || {}).textContent || ''), user: [...document.querySelectorAll('#hmLog .hm-u .hm-bub')].map((u) => u.textContent.trim()),
     tabs: pane ? [(vw.querySelector('.cz-vw-kind') || {}).textContent || ''] : [], pane: pane ? pane.textContent.replace(/\s+/g, ' ').trim() : null,
     secs: pane ? (pane.querySelector('.vz-dkt') ? pane.querySelectorAll('.vz-dkt button').length - 1 : pane.querySelectorAll('.vz-secs li').length) : 0,
@@ -100,6 +100,10 @@ const look = () => {
     ok('R4 Draft it records the report, pauses it (Once) and records T1', !!setup && setup.output === 'google-slides' && setup.audience === 'Growth leads' && L.some((l) => l.ev === 'pause' && l.id === setup.id) && T1 && T1.current === 1, JSON.stringify([L.map((l) => l.ev), T1]));
     ok('R4 the report\'s current state opens: its first draft in the reader, Claude\'s review under it (RfH2), the template icon in the header', s3.reader && /I read it as your readers would/.test(s3.review || '') && s3.tpl, JSON.stringify(s3).slice(0, 600));
     if (shots) await p.screenshot({ path: `${shots}/draft-1280-light.png` });
+    // the chat icon (Wawan, 2026-11-02): the report's own conversation opens in Home's chat, the report stays beside it
+    await p.click('#czViewer [data-cz-vw-p="chat"]');
+    const ch = await until(() => p.evaluate(() => { const i = document.getElementById('hmIn'); return i && i.placeholder === 'Change the report' ? { ph: i.placeholder, log: (document.getElementById('hmLog') || {}).textContent || '', reader: !!document.querySelector('#czViewer .vz-slide, #czViewer .vz-rp0') } : null; }), 8000);
+    ok('R4 the chat icon opens the report\'s own conversation beside it: Claude asks what to change, the report stays open', !!ch && /Tell me what to change in/.test(ch.log) && ch.reader, JSON.stringify(ch));
     await p.click('#czViewer [data-cz-vw-p="template"]');
     await until(() => p.evaluate(() => !!document.querySelector('#czViewer .vz[data-panel="template"] [data-rt="fmt|google-doc"]')));
     await p.click('#czViewer [data-rt="fmt|google-doc"]');

package/workspace/premium-vw-backlog-test.js

@@ -7,6 +7,7 @@
 const path = require('path');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'premium-vw-backlog' });
 const BP = require('./lib/board-premium.js');
 const F = require('./fixtures/board-premium-facts.js');
@@ -46,7 +47,7 @@ const SPRINTS = { ok: true, source: 'jira', readAt: '2026-10-19T09:00:00Z', velo
   browser = await chromium.launch({ executablePath: exe });
 
   const open = async ({ w = 1280, h = 900, theme = 'light', sprints = SPRINTS } = {}) => {
-    const ctx = await browser.newContext({ viewport: { width: w, height: h } });
+    const ctx = await openMission(await browser.newContext({ viewport: { width: w, height: h } }));
     const page = await ctx.newPage();
     const S = { errors: [], reads: [] };
     page.on('pageerror', (e) => S.errors.push(String((e && e.message) || e)));
@@ -120,7 +121,7 @@ const SPRINTS = { ok: true, source: 'jira', readAt: '2026-10-19T09:00:00Z', velo
 
   /* the Board (premium-uncovered-features, BdSprint) carries no Sprint card and no dialog; its sprint chip opens the Sprints and releases popover, whose Backlog row opens the backlog in the side panel */
   {
-    const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } }), page = await ctx.newPage(), errs = [];
+    const ctx = await openMission(await browser.newContext({ viewport: { width: 1280, height: 900 } })), page = await ctx.newPage(), errs = [];
     page.on('pageerror', (e) => errs.push(String((e && e.message) || e)));
     const model = BP.build(F.facts({ sprints: { source: 'jira', readAt: SPRINTS.readAt, sprints: [SPRINT] } }));
     await page.route('**/api/board-premium*', (r) => r.fulfill({ contentType: 'application/json', body: JSON.stringify({ ok: true, state: 'ready', model, as_of: Date.now() }) }));

package/workspace/premium-vw-item-test.js

@@ -8,6 +8,7 @@
 const path = require('path');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'premium-vw-item' });
 const IP = require('./lib/initiative-premium.js');
 const F = require('./fixtures/initiative-premium-facts.js');
@@ -41,7 +42,7 @@ process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
   const MODEL = IP.build(F.facts());
 
   const open = async ({ w = 1280, h = 900, theme = 'light', answer = null } = {}) => {
-    const ctx = await browser.newContext({ viewport: { width: w, height: h } });
+    const ctx = await openMission(await browser.newContext({ viewport: { width: w, height: h } }));
     const page = await ctx.newPage();
     const S = { errors: [], gets: [], vgets: [] };   // vgets: the Viewer's own reads (no page headers), apart from Home's
     page.on('pageerror', (e) => S.errors.push(String((e && e.message) || e)));
@@ -106,7 +107,7 @@ const openCard = async (pg, uid, V = '#czViewer') => {
   /* R9 the Board (premium-agreed-design): the Agreed Board opens an initiative in its side panel and never the dialog; its expand leads to the
    * initiative (Home's initiative layout), where the record is. R7 floors at 390 in dark: the same record, opened from Home's Overview. */
   {
-    const ctx = await browser.newContext({ viewport: { width: 390, height: 844 } });
+    const ctx = await openMission(await browser.newContext({ viewport: { width: 390, height: 844 } }));
     const page = await ctx.newPage(); const errors = [];
     page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
     await page.route('**/api/board-premium*', (r) => r.fulfill({ contentType: 'application/json', body: JSON.stringify({ ok: true, state: 'ready', model: BP.build(BF.facts()), as_of: Date.now() }) }));

package/workspace/premium-vw-jira-test.js

@@ -10,6 +10,7 @@
 const path = require('path');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'premium-vw-jira' });
 const BP = require('./lib/board-premium.js');
 const F = require('./fixtures/board-premium-facts.js');
@@ -75,7 +76,7 @@ const TICKETS = {
   const overview = async (pg) => { await (async (g) => { const P = '#czViewer:not([hidden]) [data-hi-v="page"]', r = '#hmList [data-hm-sel^="i:"][aria-current="true"]'; for (let i = 0; i < 4 && !(await g.$(P)) && (await g.$('#czViewer:not([hidden]) [data-cz-vw="back"]')); i++) { await g.click('#czViewer [data-cz-vw="back"]'); await g.waitForTimeout(150); } if (await g.$(P)) return; if (await g.$(r)) await g.click(r); else await g.reload(); await g.waitForSelector(P + ' .iv', { timeout: 30000 }); })(pg);   /* ← back to the initiative's page, else its row, else the address again (an initiative the list does not show) */ /* the page holds the Tasks (batch 11 item 20) */ return until(() => pg.evaluate(() => !!document.querySelector('#czViewer:not([hidden]) [data-hi-v]'))); };
   const openSprint = async (pg) => { if (!(await pg.$('#czViewer:not([hidden]) [data-hi-v]'))) await overview(pg);   /* open() already showed the Overview */ await viaMore(pg, 'Sprint'); };
   const open = async ({ w = 1280, h = 900, theme = 'light', sprints = SPRINTS, tickets = TICKETS } = {}) => {
-    const ctx = await browser.newContext({ viewport: { width: w, height: h }, colorScheme: theme });
+    const ctx = await openMission(await browser.newContext({ viewport: { width: w, height: h }, colorScheme: theme }));
     await ctx.addInitScript((t) => { try { localStorage.setItem('pmos.c3.theme', t); } catch { /* none */ } }, theme);
     const page = await ctx.newPage(), errors = [], posts = [], reads = [];
     page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
@@ -193,7 +194,7 @@ const TICKETS = {
 
   /* A the Board (premium-uncovered-features, BdSprint): its sprint chip names the sprint and opens the Sprints and releases popover; it opens no dialog */
   {
-    const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } }), pg = await ctx.newPage(), errs = [];
+    const ctx = await openMission(await browser.newContext({ viewport: { width: 1280, height: 900 } })), pg = await ctx.newPage(), errs = [];
     pg.on('pageerror', (e) => errs.push(String((e && e.message) || e)));
     await pg.route('**/api/board-premium*', (r) => r.fulfill({ contentType: 'application/json', body: JSON.stringify({ ok: true, state: 'ready', model: model({ source: 'jira', readAt: new Date().toISOString(), sprints: [{ name: 'Sprint 14', state: 'active', start: '2026-10-07', end: '2026-10-21', counts: { todo: 2, doing: 1, done: 1 }, issues: [] }] }), as_of: Date.now() }) }));
     await pg.goto(BASE + '/premium-board.html');

package/workspace/program-panel-test.js

@@ -15,6 +15,7 @@
 const path = require('path');
 const { spawn } = require('child_process');
 const { findBrowser } = require('./lib/find-browser');
+const { openMission } = require('./lib/open-mission');
 const T = require('./test-run').configure({ name: 'program-panel' });
 const BP = require('./lib/board-premium.js');
 const F = require('./fixtures/board-premium-facts.js');
@@ -46,7 +47,7 @@ process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
   browser = await chromium.launch({ executablePath: exe });
 
   const open = async ({ w = 1440, h = 900, qs = '?ws=idpf&program=project-ascent', ctx = null, programs = F.programs() } = {}) => {
-    const c = ctx || await browser.newContext({ viewport: { width: w, height: h } });
+    const c = ctx || await openMission(await browser.newContext({ viewport: { width: w, height: h } }));
     const page = await c.newPage();
     const errors = [], posts = [];
     page.on('pageerror', (e) => errors.push(String((e && e.stack) || e)));

package/workspace/public/pm/cozy-home.css

@@ -232,6 +232,7 @@ body.cz-home { min-height: 100vh; overflow: hidden; }
 .hm-u { display: flex; flex-direction: column; align-items: flex-end; gap: 4px; }
 .hm-bub { max-width: 80%; padding: 10px 16px; border-radius: 18px 18px 8px 18px; background: var(--cz-bubble); font-size: var(--fs-3); line-height: 1.5; color: var(--cz-ink); }
 .hm-you { font-size: var(--fs-1); color: var(--cz-ink3); }
+.hm-pend.sending .hm-bub { opacity: .72; }   /* batch 24 item 2: the bubble shows at once, a touch lighter until PMOS takes it */
 .hm-worked { padding-left: 38px; }
 .hm-wk { display: flex; align-items: center; gap: 8px; max-width: 100%; min-height: 32px; padding: 0 4px; border: 0; border-radius: 8px; background: none; color: var(--cz-ink3); font-size: var(--fs-2); cursor: pointer; text-align: left; }   /* a plain grey line (AgChatAsk) */
 .hm-wk:hover { color: var(--cz-ink2); }

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

@@ -298,3 +298,15 @@ button.rp-cc { cursor: pointer; }
 .rp-rfh .rp-bar { justify-content: flex-end; }
 .rp-foot { display: flex; justify-content: flex-end; gap: 8px; margin-top: auto; padding-top: 4px; }
 .rp-foot .rp-pri { width: 40px; height: 40px; margin: 0; }
+
+/* a template's sections and look (canvas TplA, brief 3; public/pm/report-flow.js): chips in order, a small title slide and one line */
+.rf-cps { display: flex; flex-wrap: wrap; gap: 6px; }
+.rf-cp { display: inline-flex; align-items: center; padding: 3px 10px; border-radius: 99px; border: 1px solid var(--cz-hair); background: var(--cz-card); color: var(--cz-ink2); font-size: var(--fs-2); }
+.rf-cp[data-k="new"] { border-color: color-mix(in oklab, var(--cz-blue) 55%, transparent); background: var(--cz-bluebg); color: var(--cz-blueink); }
+.rf-cp[data-k="gone"] { border-style: dashed; color: var(--cz-ink3); }
+.rf-lk { display: flex; align-items: center; gap: 12px; }
+.rf-mini { width: 96px; height: 54px; flex: none; border-radius: 7px; display: flex; align-items: flex-end; padding: 6px 7px; box-sizing: border-box; background: linear-gradient(135deg, var(--cz-c-2546b8), var(--cz-c-1b3a9e)); color: var(--cz-c-ffffff); font-size: var(--fs-1); line-height: 1.2; overflow: hidden; }
+.rf-mini[data-k="own"] { background: var(--cz-well2); color: var(--cz-ink); border: 1px solid var(--cz-hair); }
+.rf-lk .rf-fix small { color: var(--cz-ink3); font-size: var(--fs-2); }
+.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); }

package/workspace/public/pm/fetch-share.js

@@ -0,0 +1,38 @@
+/* pm/fetch-share.js — one request for the same answer while it is on its way (page-open-speed).
+ *
+ * Imported FIRST by the page entries (home-app.js, premium-board.js, premium-insights.js). Parts of a page ask for the same GET on their
+ * own, so Home asked for /api/notes three times and /api/settings twice in its opening burst, and the Board asked for /api/board-premium,
+ * /api/board-publish, /api/sources and /api/settings twice each (bench 2026-11-02). Every one of them waits on the server's one thread.
+ *
+ * The rule: a GET to /api/ with the same address as one that is still on its way gets a copy of that one's answer instead of a second
+ * request. Nothing is kept once the answer is in, so a later read always asks the server again. Any other method (a press) first drops
+ * what is on its way, so a read made after a write never gets an answer that was asked for before it. Only plain same-origin GETs with no
+ * body, signal or cache option are shared; everything else goes to fetch as before. */
+const KEY = '__pmosFetchShare';
+if (typeof window !== 'undefined' && typeof window.fetch === 'function' && !window[KEY]) {
+  const real = window.fetch.bind(window);
+  const flying = new Map();   // url → Promise<Response>
+  window[KEY] = { flying };
+  window.fetch = function shared(input, init) {
+    let url = null, method = 'GET';
+    try {
+      url = typeof input === 'string' ? input : (typeof URL !== 'undefined' && input instanceof URL ? input.href : null);
+      method = String((init && init.method) || (input && typeof input === 'object' && input.method) || 'GET').toUpperCase();
+    } catch { url = null; }
+    if (method !== 'GET' && method !== 'HEAD') { flying.clear(); return real(input, init); }
+    if (!url || method !== 'GET') return real(input, init);   // a Request object or a HEAD goes to fetch as before
+    if (init && (init.body != null || init.signal || init.cache || init.keepalive)) return real(input, init);
+    let abs;
+    try { abs = new URL(url, location.href); } catch { return real(input, init); }
+    if (abs.origin !== location.origin || !abs.pathname.startsWith('/api/')) return real(input, init);
+    const key = abs.href;
+    const hit = flying.get(key);
+    if (hit) return hit.then((r) => r.clone());
+    const p = real(input, init);
+    flying.set(key, p);
+    const done = () => { if (flying.get(key) === p) flying.delete(key); };
+    p.then(done, done);
+    return p.then((r) => r.clone());
+  };
+}
+export {};