create-pmos 0.241.0 → 0.243.0

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

@@ -12,6 +12,8 @@
  *   GET  /api/report-structure/check?ws&id&source                  → { ok, check }
  *   POST /api/report-structure/dry    { ws, id, n? }               → { ok, running: true }   starts ONE report-structure-dry job
  *   GET  /api/report-structure/dry?ws&id&run                       → { ok, dry }
+ *   POST /api/report-structure/pull   { ws, id, source }           → { ok, running: true }   Test pull: ONE report-structure-pull job reads ONE source; never a turn, never a version
+ *   GET  /api/report-structure/pull?ws&id&source                   → { ok, pull, running }   the last pull of the source (structure/pull/<source>.json)
  *   GET  /api/charts?ws                                            → { ok, charts: [chart + { users }] }
  *   GET  /api/charts/one?ws&id                                     → { ok, chart }
  *
@@ -48,12 +50,15 @@ const headless = require('./headless.js');
 const text = (v) => (typeof v === 'string' ? v : '');
 const bad = (status, error) => ({ status, body: { ok: false, error } });
 const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-const POSTS = ['turn', 'accept', 'revert', 'source', 'remove', 'check', 'dry'];
+const POSTS = ['turn', 'accept', 'revert', 'source', 'remove', 'check', 'dry', 'pull'];
 const HOLD_MS = 4 * 3600 * 1000;
 const CHECK_MS = 10 * 60 * 1000;
+/** How long a check session may take. PMOS_REPORT_CHECK_MS shortens it for the suites. */
+const checkMs = () => (Number(process.env.PMOS_REPORT_CHECK_MS) > 0 ? Number(process.env.PMOS_REPORT_CHECK_MS) : CHECK_MS);
 const STEP_FLAGS_FALLBACK = [{ flag: '--chrome' }, { flag: '--allowedTools', value: 'mcp__claude-in-chrome' }];
 
 const jobs = new Map();       // `${root}\0${id}` → { id, kind, since, turn, pending, sessionId, base, n }
+const pullJobs = new Map();   // `${root}\0${id}\0${source}` → { run, since, pending, sessionId, n }   (a Test pull never blocks, and is never blocked by, a turn)
 const checkJobs = new Map();  // `${root}\0${id}\0${source}` → { run, since, pending, sessionId, kind }
 let lastCtx = null;
 const keyOf = (root, id) => `${path.resolve(String(root))}\u0000${id}`;
@@ -77,7 +82,7 @@ function runningOf(root, id) {
   const j = jobs.get(keyOf(root, id));
   return j ? { since: j.since, turn: j.turn, kind: j.kind } : null;
 }
-const answerOf = (root, id) => S.structureAnswer(root, id, { running: runningOf(root, id) });
+const answerOf = (root, id) => S.structureAnswer(root, id, { running: runningOf(root, id), pulling: pullingOf(root, id) });
 const storeIds = (root) => new Set(CS.stateOf(root).keys());
 
 // ── the job ─────────────────────────────────────────────────────────────────────────────────────────────────
@@ -184,6 +189,87 @@ function finish(w, id, job, r) {
   try { fs.unlinkSync(job.pending); } catch { /* not written */ }
 }
 
+
+// ── Test pull: one source, read straight into its row ─────────────────────────────────────────────────────
+// A pull is NOT a turn: no line in the conversation, no version, and a running turn does not block it. The only event is `pull`; the result is a file.
+const pullKey = (root, id, source) => `${keyOf(root, id)}\u0000${source}`;
+function pullingOf(root, id) {
+  const pre = `${keyOf(root, id)}\u0000`;
+  return [...pullJobs.keys()].filter((k) => k.startsWith(pre)).map((k) => k.slice(pre.length));
+}
+function pullPrompt(skill, { root, id, setup, src, n, pending }) {
+  const p = S.paths(root, id);
+  const lines = [`- Report: ${setup.name} (${id})`, `- Today: ${new Date().toISOString().slice(0, 10)}`, `- Schedule: ${setup.cadence}`, `- Repository: ${p.abs}`,
+    `- Source: ${src.id} (${src.kind}): ${String(src.name).replace(/\s+/g, ' ')}`, `- Version: S${n} (${path.join(p.versions, `S${n}.json`)})`, `- Chart store: ${CS.paths(root).file}`, `- Output path: ${pending}`];
+  return `${skill}\n\nThis job:\n${lines.join('\n')}\n\nWrite the JSON to the output path, then print the JSON result. Send nothing.\r`;
+}
+/** A source Test pull can read: not a PMOS source, and not a Chrome or computer source (those have Check it works). */
+const pullable = (src) => src.group === 'outside' && src.kind !== 'chrome' && src.kind !== 'computer';
+function startPull(ctx, w, id, sourceId) {
+  const root = w.root;
+  const st = S.stateOf(root, id);
+  const hit = sourceOf(root, id, sourceId);
+  if (!hit || st.current == null) return { ok: false, status: 404, error: 'no such source in this version' };
+  if (!pullable(hit.src)) return { ok: false, status: 400, error: 'Test pull reads connectors, links and uploads. PMOS sources open in PMOS, and a Chrome or computer source has Check it works.' };
+  if (hit.src.state !== 'reached') return { ok: false, status: 409, error: 'Connect this source first, then press Test pull.' };
+  const key = pullKey(root, id, sourceId);
+  if (pullJobs.has(key)) return { ok: false, status: 409, error: 'PMOS is already reading this source. Wait for the answer.' };
+  if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'this workspace cannot start background runs' };
+  const origin = `report-structure-pull:${id}:${sourceId}`;
+  if (headless.kindFor({ agent: 'claude', origin }) !== 'report-structure-pull') return { ok: false, status: 409, error: 'Background runs are switched off here (PMOS_HEADLESS=off), so PMOS cannot read the source.' };
+  const skill = typeof ctx.skillPrompt === 'function' ? ctx.skillPrompt('report-structure-pull', w) : null;
+  if (!skill) return { ok: false, status: 500, error: 'the report-structure-pull skill is not installed' };
+  const setup = setupOf(root, id) || { id, name: id, cadence: id };
+  const p = S.paths(root, id);
+  const run = S.newRun();
+  const pending = path.join(p.pullPending, `${run}.json`);
+  try { fs.mkdirSync(p.pullPending, { recursive: true }); } catch (e) { return { ok: false, status: 500, error: 'could not make the pending folder: ' + String((e && e.code) || e) }; }
+  const job = { id: run, since: new Date().toISOString(), pending, sessionId: null, n: st.current, source: sourceId };
+  pullJobs.set(key, job);
+  let s = null;
+  try {
+    s = ctx.spawnSession({ name: 'Report structure · test pull', agent: 'claude', ws: w.id, origin, cwd: p.rel,
+      initialInput: pullPrompt(skill, { root, id, setup, src: hit.src, n: st.current, pending }), writePaths: [pending], onDone: (r) => finishPull(w, id, job, r) });
+  } catch (e) { s = { state: 'exited', note: String((e && e.message) || e) }; }
+  if (!s || s.state === 'exited' || s.headless !== 'report-structure-pull') {
+    pullJobs.delete(key);
+    if (s && s.headless !== 'report-structure-pull' && s.state !== 'exited' && typeof ctx.stopSession === 'function') { try { ctx.stopSession(s.id); } catch { /* best effort */ } }
+    return { ok: false, status: 409, error: 'PMOS could not start the read: ' + ((s && s.note) || 'no background run') };
+  }
+  job.sessionId = s.id;
+  return { ok: true, running: true };
+}
+function finishPull(w, id, job, r) {
+  const root = w.root;
+  const key = pullKey(root, id, job.source);
+  if (pullJobs.get(key) === job) pullJobs.delete(key);
+  // Whatever happens, the source row gets an answer: a result file, or a "returned nothing" file with the reason. The plan and the conversation stay as they were.
+  const land = (pull) => {
+    try {
+      S.writePull(root, id, { ...pull, at: new Date().toISOString(), run: job.id });
+      S.append(root, id, { ev: 'pull', source: job.source, n: job.n, ok: !!pull.ok });
+    } catch { /* the folder is gone */ }
+  };
+  const nothing = (reason) => land({ source: job.source, n: job.n, period: '', reached: false, ok: false, reason, values: [], charts: 0, got: 0 });
+  try {
+    const res = (r && r.result) || {};
+    const ok = !!(r && !r.timedOut && !r.stopped && r.code === 0 && res.ok && !res.isError);
+    const out = resultJson(res.text);
+    let raw = null; try { raw = fs.readFileSync(job.pending, 'utf8'); } catch { raw = null; }
+    let data = null; if (raw) { try { data = JSON.parse(raw); } catch { data = null; } }
+    if (!data && out && isObj(out.pull)) data = out.pull;
+    if (!ok && !data) nothing(r && r.timedOut ? 'The read took too long and was stopped.' : r && r.stopped ? 'The read was stopped.' : 'The read failed' + (res.text ? ': ' + String(res.text).replace(/\s+/g, ' ').slice(0, 200) : '.'));
+    else if (!data) nothing('The read ended without a result.');
+    else {
+      const plan = S.readVersion(root, id, job.n);
+      const v = plan ? S.validatePull(data, plan, job.source) : { ok: false, error: 'the version is gone' };
+      if (!v.ok) nothing('The result could not be used: ' + v.error + '. Nothing was saved in the plan.');
+      else land(v.pull);
+    }
+  } catch (e) { nothing('The result could not be read: ' + String((e && e.message) || e).slice(0, 160)); }
+  try { fs.unlinkSync(job.pending); } catch { /* not written */ }
+}
+
 /** A turn that has no answer and no job in this server (the workspace restarted mid-run) gets an error line. */
 function settleStale(root, id) {
   if (jobs.has(keyOf(root, id))) return;
@@ -343,7 +429,7 @@ function settleChecks(ctx, w, id) {
         const steps = v.steps.map((s) => (s.id === 'mac' ? base.find((b) => b.id === 'mac') || s : s));   // the server's own step wins
         finishCheck(root, id, sourceId, job.kind, steps, { endSession: ctx && ctx.endSession, job });
       } else finishCheck(root, id, sourceId, job.kind, failSteps(job.kind, 'read', `The check answered something PMOS could not use: ${v.error}`, base), { endSession: ctx && ctx.endSession, job });
-    } else if (now - job.since > CHECK_MS) {
+    } else if (now - job.since > checkMs()) {
       finishCheck(root, id, sourceId, job.kind, failSteps(job.kind, 'session', 'The check session did not answer in 10 minutes. Check again.', base), { endSession: ctx && ctx.endSession, job });
     }
   }
@@ -456,6 +542,79 @@ function sweep(ctx) {
   return out;
 }
 
+// ── Draft it now, for a report with a saved structure ───────────────────────────────────────────────────
+// A press on Draft it now (or Draft now on the report) starts the session the schedule would start, through the same gate, so the draft follows the
+// structure. `drafting.json` marks a draft that was started; it ends when a draft file lands in the report's folder, or when the session is gone.
+const draftingFile = (root, id) => path.join(S.paths(root, id).dir, 'drafting.json');
+function readDrafting(root, id) { try { const o = JSON.parse(fs.readFileSync(draftingFile(root, id), 'utf8')); return isObj(o) ? o : null; } catch { return null; } }
+/** The schedule that drafts a report (skill report-template, args = the id), or null. */
+function draftScheduleOf(ctx, w, id) {
+  try { return ctx.scheduleStore.read().find((x) => x && x.skill === 'report-template' && x.args === id && (!x.ws || x.ws === w.id)) || null; } catch { return null; }
+}
+/** server.js calls this when the report-template session of a structured report starts. */
+function markDrafting(root, id, { sched, session, saved } = {}) {
+  try {
+    fs.mkdirSync(S.paths(root, id).dir, { recursive: true });
+    fs.writeFileSync(draftingFile(root, id), JSON.stringify({ since: new Date().toISOString(), sched: sched || null, session: session || null, saved: saved == null ? null : saved }) + '\n');
+  } catch { /* the row shows no state; the draft still runs */ }
+}
+/** A draft file (.md) in the report's folder written since `since`: { slot, path } | null. */
+function landedSince(root, id, since) {
+  try {
+    const p = S.paths(root, id);
+    const hit = fs.readdirSync(p.folder).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).map((f) => ({ f, t: fs.statSync(path.join(p.folder, f)).mtimeMs }))
+      .filter((x) => x.t >= Date.parse(since) - 1000).sort((a, b) => b.t - a.t)[0];
+    return hit ? { slot: hit.f.replace(/\.md$/, ''), path: `${p.rel}/${hit.f}` } : null;
+  } catch { return null; }
+}
+/**
+ * What a row shows for a report's draft: null, or { state: 'drafting' | 'held' | 'ended', since, saved, sources?, session?, reason? }.
+ * A held draft waits for a Chrome or computer check; an ended one lost its session before a draft landed.
+ */
+function draftState(ctx, w, id) {
+  try {
+    const root = w.root;
+    const hold = readHold(root, id);
+    if (hold) {
+      const sp = savedPlan(root, id);
+      const names = (Array.isArray(hold.sources) ? hold.sources : []).map((sid) => ((sp && sp.plan.sources.find((x) => x.id === sid)) || { name: sid }).name);
+      return { state: 'held', since: hold.since, saved: hold.saved == null ? null : hold.saved, sources: names, expires: new Date(Date.parse(hold.since) + holdMs()).toISOString() };
+    }
+    const m = readDrafting(root, id);
+    if (!m) return null;
+    if (m.ended) return { state: 'ended', since: m.since, saved: m.saved, reason: m.reason || 'The drafting session ended before a draft was written.' };
+    if (landedSince(root, id, m.since)) { try { fs.unlinkSync(draftingFile(root, id)); } catch { /* gone */ } return null; }
+    const alive = m.session && typeof ctx.sessionAlive === 'function' ? ctx.sessionAlive(m.session) : true;
+    if (!alive) {
+      const o = { ...m, ended: true, reason: 'The drafting session ended before a draft was written. Press Draft it now to try again.' };
+      try { fs.writeFileSync(draftingFile(root, id), JSON.stringify(o) + '\n'); } catch { /* shown again next time */ }
+      return { state: 'ended', since: m.since, saved: m.saved, reason: o.reason };
+    }
+    return { state: 'drafting', since: m.since, saved: m.saved, session: m.session || null };
+  } catch { return null; }
+}
+/**
+ * Draft it now. → { structured: false } for a report with no saved structure (the caller drafts as it always did),
+ * { structured: true, status, error } when it cannot start, or { structured: true, drafting: true, held, state }.
+ */
+function draftNow(ctx, w, id) {
+  const root = w.root;
+  const sp = savedPlan(root, id);
+  if (!sp) return { structured: false };
+  const sched = draftScheduleOf(ctx, w, id);
+  if (!sched) return { structured: true, status: 409, error: 'This report has no draft schedule. Set it up again, then press Draft it now.' };
+  const cur = draftState(ctx, w, id);
+  if (cur && (cur.state === 'drafting' || cur.state === 'held')) {
+    return { structured: true, status: 409, error: cur.state === 'held' ? 'A draft is waiting for a check of ' + (cur.sources || []).join(', ') + '.' : 'A draft is being made. Wait for it to land.' };
+  }
+  try { fs.unlinkSync(draftingFile(root, id)); } catch { /* none */ }
+  const gate = beforeDraft(ctx, w, id, sched);
+  if (gate.hold) return { structured: true, drafting: true, held: true, state: draftState(ctx, w, id) };
+  if (typeof ctx.fireDraft !== 'function') return { structured: true, status: 500, error: 'The server cannot start a draft.' };
+  try { ctx.fireDraft(sched.id, { id, ws: w.id }); } catch (e) { return { structured: true, status: 500, error: 'The draft did not start: ' + (e && e.message ? e.message : 'unknown') }; }
+  return { structured: true, drafting: true, held: false, state: draftState(ctx, w, id) };
+}
+
 // ── the handler ─────────────────────────────────────────────────────────────────────────────────────────────
 async function handle(req, res, url, ctx) {
   lastCtx = ctx;
@@ -497,6 +656,12 @@ async function handle(req, res, url, ctx) {
       const c = S.readCheck(w.root, id, sid);
       return send(c ? { status: 200, body: { ok: true, check: c } } : bad(404, 'this source has not been checked'));
     }
+    if (sub === 'pull') {
+      const sid = text(url.searchParams.get('source'));
+      if (!S.SLUG_RE.test(sid)) return send(bad(400, 'source must be a source id'));
+      const pl = S.readPull(w.root, id, sid);
+      return send(pl ? { status: 200, body: { ok: true, pull: pl, running: pullJobs.has(pullKey(w.root, id, sid)) } } : bad(404, 'this source has not been pulled'));
+    }
     if (sub === 'dry') {
       const run = text(url.searchParams.get('run'));
       if (!S.RUN_RE.test(run)) return send(bad(400, 'run must be a run id'));
@@ -537,6 +702,12 @@ async function handle(req, res, url, ctx) {
     if (!s.ok) { S.append(root, id, { ev: 'error', text: s.error, mode: 'turn' }); return fail(s); }
     return send({ status: 200, body: { ok: true, running: true } });
   }
+  if (sub === 'pull') {
+    const sid = text(body.source);
+    if (!S.SLUG_RE.test(sid)) return send(bad(400, 'source must be a source id'));
+    const r = startPull(ctx, w, id, sid);
+    return r.ok ? send({ status: 200, body: { ok: true, running: true } }) : fail(r);
+  }
   if (sub === 'dry') {
     if (busy()) return send(bad(409, BUSY));
     const st = S.stateOf(root, id);
@@ -615,5 +786,5 @@ async function handle(req, res, url, ctx) {
   return send(bad(404, 'no such route'));
 }
 
-module.exports = { prefixes: ['/api/report-structure', '/api/charts'], handle, sweep, beforeDraft, draftBlock, startCheck, settleChecks, readHold, savedPlan, computerRule, resultJson, promptFor,
-  _jobs: jobs, _checks: checkJobs };
+module.exports = { prefixes: ['/api/report-structure', '/api/charts'], handle, sweep, beforeDraft, draftBlock, draftNow, draftState, markDrafting, startCheck, settleChecks, readHold, savedPlan, computerRule, resultJson, promptFor,
+  _jobs: jobs, _checks: checkJobs, _pulls: pullJobs };

package/workspace/lib/routes-reports.js

@@ -118,6 +118,16 @@ async function handle(req, res, url, ctx) {
   const failed = (r) => { ctx.json(res, { ok: false, error: r.error || 'refused', index: r.index == null ? null : r.index }, r.status || 400); return true; };
 
   if (p === '/api/report/draft') {
+    // A first Draft now of a report with a saved structure is made by the session the schedule would start, so it follows the structure
+    // (report-structure-gaps). A Redraft, a draft at a named slot and a report with no saved structure keep the instant draft below.
+    if (body.redraft !== true && !cs.slot && typeof ctx.structureDraft === 'function') {
+      const sd = ctx.structureDraft(w, cs.cadence);
+      if (sd.structured) {
+        if (sd.status) return refuse(ctx, res, sd.status, sd.error);
+        ctx.json(res, { ok: true, ws: w.id, cadence: cs.cadence, drafting: true, held: !!sd.held, state: sd.state || null });
+        return true;
+      }
+    }
     // Draft now, or Redraft. A Redraft keeps every note, byte for byte, by the initiative id it was written under.
     const draft = RD.draftOf(root, { cadence: cs.cadence, slot: cs.slot || undefined });
     if (!draft || draft.ok === false) return failed(draft || { status: 500, error: 'the drafter answered nothing' });

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.241.0",
+  "version": "0.243.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.241.0",
+      "version": "0.243.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/c3-audience-link.js

@@ -0,0 +1,21 @@
+/* pm/c3-audience-link.js — the audience window of a PMOS deck (initiative meeting-material-replay-gaps).
+ *
+ *   audienceChannelName(ws, path)                  the BroadcastChannel both windows share
+ *   openAudienceWindow({ ws, path, name, start })  → { win, ch } | null (the browser blocked the window)
+ *
+ * The window is /c3.html?audience=1&…, which c3-boot.js hands to c3-audience.js. It shows the slides only. The presenter view and the window tell
+ * each other the slide through the channel: { t: 'slide', i } both ways, { t: 'hello' } from a window that has just opened, { t: 'close' } from
+ * the presenter view when it ends. The channel carries a slide number and nothing else, and it exists only between pages of this origin. */
+export const audienceChannelName = (ws, path) => 'pmos-audience:' + String(ws || '') + ':' + String(path || '');
+
+export function openAudienceWindow({ ws, path, name, start } = {}) {
+  if (typeof window === 'undefined' || typeof window.open !== 'function') return null;
+  const q = new URLSearchParams({ audience: '1', ws: String(ws || ''), path: String(path || ''), name: String(name || 'Deck').slice(0, 120), start: String(Math.max(0, Number(start) || 0)) });
+  try { if (new URLSearchParams(location.search).get('demo') === '1') q.set('demo', '1'); } catch { /* no location */ }
+  let win = null;
+  try { win = window.open('/c3.html?' + q.toString(), 'pmos-audience', 'popup=yes,width=1280,height=720'); } catch { win = null; }
+  if (!win || win.closed) return null;
+  let ch = null;
+  try { ch = typeof BroadcastChannel === 'function' ? new BroadcastChannel(audienceChannelName(ws, path)) : null; } catch { ch = null; }
+  return { win, ch };
+}

package/workspace/public/pm/c3-audience.js

@@ -0,0 +1,46 @@
+/* pm/c3-audience.js — the audience window of a PMOS deck (initiative meeting-material-replay-gaps). c3-boot.js loads it alone for
+ * /c3.html?audience=1&ws=…&path=…&name=…&start=N, opened by c3-audience-link.js.
+ *
+ * It reads the deck through the routes the presenter view already uses and shows the slides only, full window: no speaker notes, no toolbar. It
+ * follows the presenter's slide through a BroadcastChannel and tells the presenter when a key here moves it. Escape, or the presenter ending
+ * the session, closes the window. Nothing is written and nothing is sent. */
+import { el } from './dom.js';
+import { createDeck } from './c3-report-deck.js';
+import { audienceChannelName } from './c3-audience-link.js';
+import { ensureC3Css } from './pm-work-view.js';
+
+const q = new URLSearchParams(location.search);
+const WS = q.get('ws') || '';
+const PATH = q.get('path') || '';
+const NAME = (q.get('name') || 'Deck').slice(0, 120);
+const START = Math.max(0, parseInt(q.get('start') || '0', 10) || 0);
+
+function say(text) {
+  document.body.append(el('div', { class: 'c3 aud-msg', 'data-aud': 'message' }, el('p', null, text)));
+}
+
+export async function runAudiencePage() {
+  document.title = 'PMOS · Audience view · ' + NAME;
+  document.body.classList.add('c3-aud-win');
+  ensureC3Css();
+  // Demo mode (?demo=1, the mockup's sample content) answers the reads of this window as it does for the page that opened it.
+  if (q.get('demo') === '1') { try { const m = await import('./c3-demo.js'); m.installDemo(); if (window.__c3demoReady) await window.__c3demoReady; } catch { /* the reads then go to the server */ } }
+  if (!PATH) { say('This window needs a deck. Open Audience view from the deck again.'); return; }
+  let ch = null;
+  try { ch = typeof BroadcastChannel === 'function' ? new BroadcastChannel(audienceChannelName(WS, PATH)) : null; } catch { ch = null; }
+  const deck = createDeck({ ws: WS, path: PATH, name: NAME, cycle: '', standalone: true, onSlide: (i) => { if (ch) ch.postMessage({ t: 'slide', i }); } });
+  const t0 = Date.now();
+  while (!deck.state.loaded && Date.now() - t0 < 10000) await new Promise((r) => setTimeout(r, 60));
+  const S = deck.state;
+  if (!S.loaded || !S.cyc || !S.cyc.designed || !S.R || S.R.format !== 'deck') { say('This report has no designed deck yet, so there are no slides to show.'); return; }
+  deck.present('aud', START);
+  if (ch) {
+    ch.onmessage = (e) => {
+      const m = e && e.data;
+      if (!m || typeof m !== 'object') return;
+      if (m.t === 'slide' && Number.isInteger(m.i)) deck.goTo(m.i, { quiet: true });
+      else if (m.t === 'close') window.close();
+    };
+    ch.postMessage({ t: 'hello' });
+  }
+}

package/workspace/public/pm/c3-boot.js

@@ -6,6 +6,7 @@
 const narrow = typeof matchMedia === 'function' && matchMedia('(max-width:640px)').matches;
 let desk = false;
 try { desk = localStorage.getItem('pmos.c3.testDesk') === 'desk'; } catch { /* no storage */ }
-if (new URLSearchParams(location.search).get('capture') === '1') import('./c3-capture.js');   // the PMOS Chrome extension's popup page: a small page on its own, at any width
+if (new URLSearchParams(location.search).get('audience') === '1') import('./c3-audience.js').then((m) => m.runAudiencePage());   // the audience window of a PMOS deck: slides only, in a window of its own
+else if (new URLSearchParams(location.search).get('capture') === '1') import('./c3-capture.js');   // the PMOS Chrome extension's popup page: a small page on its own, at any width
 else if (narrow && !desk) import('./c3-phone-boot.js');
 else import('./c3-shell.js');

package/workspace/public/pm/c3-calendar.js

@@ -26,6 +26,7 @@ import { pmPost } from './http.js';
 import { notesView, openNote, noteOfEvent, primeNotes } from './c3-notes.js';   // Calendar › Notes (initiative c3-notes-place)
 import { onNotes } from './notes-links.js';
 import { openSheet } from './c3-sheet.js';
+import { materialSection } from './c3-material.js';   // Material on the meeting card (initiative meeting-material-replay)
 
 const LAYERS = [
   ['meetings', 'Meetings'],
@@ -669,6 +670,15 @@ const focusBtn = (e, date, ui) => button({ label: [c3ic('target', 'sm'), 'Focus'
   attrs: { 'data-cal3': 'focus', title: 'Open the meeting focus page: the clock, the topics, the material and PMOS beside the conversation' },
   onClick: () => { if (ui) { ui.st.sel = null; closeMeetingSheet(ui.r); ui.redraw(); } import('./c3-focus.js').then((m) => m.openFocus({ event: e, date })).catch(() => toast({ text: 'The focus page could not load.', tone: 'error' })); } });
 
+/* "Replay": the full-screen replay of a meeting that has ended and has a recorded note (c3-replay.js); it closes the popup first, as Focus does */
+const replayBtn = (e, ui) => {
+  const n = noteOfEvent(e);
+  if (!n || n.private || n.state === 'recording' || n.state === 'paused' || !(n.segments > 0 || (n.words || 0) > 0)) return null;
+  return button({ label: [c3ic('play', 'sm'), 'Replay'], variant: 'ghost', size: 'sm',
+    attrs: { 'data-cal3': 'replay', title: 'Open the meeting replay: the topics, the key points, the screen and the conversation along the audio' },
+    onClick: () => { if (ui) { ui.st.sel = null; closeMeetingSheet(ui.r); ui.redraw(); } import('./c3-replay.js').then((m) => m.openReplay({ note: n.id })).catch(() => toast({ text: 'The replay could not load.', tone: 'error' })); } });
+};
+
 function meetingDetail(ui, hit, inSheet) {
   const { M, h } = ui; const e = hit.e;
   const s = h.timeOf(e.at); const f = s === null ? null : h.endH(e);
@@ -692,7 +702,7 @@ function meetingDetail(ui, hit, inSheet) {
   if (!M.ctx) body = [fold('info', 'The calendar sent no meeting context, so PMOS shows nothing for this meeting.', { 'data-cal3': 'no-context' })];
   else if (past && (!rec || rec.held === false)) body = [fold('moon', 'Nothing held for this meeting: no note, decisions or linked items yet.', { 'data-cal3': 'nothing-held' })];
   else if (past) body = [list(['decision', 'action'], 'What came out of it', 'out', 'No decision or action is recorded.'), list(['moved'], 'What moved after it', 'moved', 'Nothing moved within 48 hours that refers to it.')];
-  else body = upcomingBody(ui, rec, items);
+  else body = upcomingBody(ui, rec, items, e, hit.date);
   const b = !past && rec && rec.brief ? rec.brief : null;
   const lv = !past && rec ? rec.level || null : null;
   const iniId = lv && lv.kind !== 'initiative' ? null : typeof e.initiative === 'string' && !(lv && lv.by === 'pm') ? e.initiative : b && b.initiative ? b.initiative.id : null;
@@ -707,7 +717,7 @@ function meetingDetail(ui, hit, inSheet) {
     // the popup: the sheet's header carries the title and Close; at Half and wider the note sits beside what came out of it
     const side = noteCard(ui, e);
     return [
-      el('div', { class: 'cal3-dt' }, el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'), !past && s !== null && hit.date === ui.d.today ? focusBtn(e, hit.date, ui) : null),
+      el('div', { class: 'cal3-dt' }, el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'), !past && s !== null && hit.date === ui.d.today ? focusBtn(e, hit.date, ui) : null, past ? replayBtn(e, ui) : null),
       el('div', { class: 'dim mono cal3-when' }, h.dayLabel(hit.date) + (s === null ? ', all day' : ' · ' + h.hhmm(s) + ' to ' + h.hhmm(f))),
       chipsRow(),
       past || !M.ctx ? null : levelRow(ui, e, lv),
@@ -827,7 +837,7 @@ function openBoardTab(ui, board, tab) {
   ui.h.gotoTab('init');
 }
 
-function upcomingBody(ui, rec, items) {
+function upcomingBody(ui, rec, items, e, date) {
   const { h } = ui;
   const b = rec && rec.brief ? rec.brief : null;
   const lv = rec && rec.level ? rec.level : null;
@@ -857,6 +867,8 @@ function upcomingBody(ui, rec, items) {
       el('span', { class: 'tag' + (x.done ? ' cal3-up' : '') }, CTXWORD[x.kind] || x.kind), el('span', { class: 'cal3-ct' }, x.text),
       x.at ? el('span', { class: 'dim mono cal3-at' }, h.dayLabel(x.at) + (h.timeOf(x.at) !== null ? ' ' + h.hhmm(h.timeOf(x.at)) : '')) : null,
       x.ref && REF[x.ref.type] ? refLink(ui, x.ref, { title: x.text }) : null))])));
+  if (e) out.push(materialSection({ event: e, date, level: lv, brief: b,
+    back: () => { if (!ui.st.sel) { ui.st.sel = { type: 'event', id: e.id }; ui.redraw(); } } }));
   if (b && ((b.links || []).length || (b.refs || []).length)) out.push(el('div', { class: 'chips2', 'data-cal3': 'meeting-links' },
     ...(b.links || []).map((l) => el('a', { class: 'chip2', href: l.url, target: '_blank', rel: 'noopener noreferrer' }, c3ic('out', 'sm'), l.label)),
     ...(b.refs || []).map((r) => r.link ? el('a', { class: 'chip2', href: r.link, target: '_blank', rel: 'noopener noreferrer' }, c3ic('out', 'sm'), r.label, r.source ? el('span', { class: 'dim' }, ' ' + r.source) : null)

package/workspace/public/pm/c3-demo-material.js

@@ -0,0 +1,58 @@
+/* pm/c3-demo-material.js — DEMO answers for the material of a meeting (initiative meeting-material-replay, part 1) on /c3.html?demo=1.
+ * c3-demo.js passes GET and POST /api/meeting-material and GET /api/meeting-material/suggest here, and adds the material of the meeting to the
+ * answer of GET /api/meeting-focus. The data is the approved mockup's: PMOS suggests the Partner API decision deck, the weekly report and a
+ * policy document; a search finds three more. The store lives in the page: a reload forgets it and nothing reaches the server. Real mode never loads this file. */
+
+const rows = [];   // { key, scope, event, item, topic, present, removed? } in the order they were added; the last of an item wins
+const TOPICS = ['Context and goal', 'Options: soft vs hard limits', 'Partner impact: top 20 traffic', 'Partner comms and timing', 'Decide and next steps']
+  .map((text) => ({ id: text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''), text }));
+const WS = '881665c933';
+const SUGGESTED = [
+  { kind: 'pmos-deck', ref: 'planning/reports/rs1/2026-10-21.md', title: 'Partner API rate limits: decision deck', meta: 'Reports · deck · draft', why: 'Your deck, edited Fri 9 Oct', present: true, ws: WS },
+  { kind: 'report', ref: 'planning/reports/rs3/2026-10-14.md', title: 'Partner API weekly report · cycle 41', meta: 'Reports · document · issued', why: 'The report this review reads each week', present: false, ws: WS },
+  { kind: 'pmos-doc', ref: 'planning/prd/partner-agreement-prd.md', title: 'Partner agreement v3: fair use (section 4.2)', meta: 'IDPF-07 documents', why: 'Named in the last note: "check the agreement"', present: false, ws: WS },
+];
+const FIND = [
+  { kind: 'pmos-deck', ref: 'planning/reports/rs1/2026-10-07.md', title: 'Payments 1.5 release review deck', meta: 'Reports · deck · issued', present: true, ws: WS },
+  { kind: 'report', ref: 'planning/reports/rs3/2026-10-02.md', title: 'Monthly product review · September', meta: 'Reports · document · issued', present: false, ws: WS },
+  { kind: 'pmos-doc', ref: 'planning/prd/idpf-07-charter.md', title: 'IDPF-07 charter', meta: 'IDPF-07 documents', present: false, ws: WS },
+];
+const norm = (t) => String(t || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+const keyOf = (e) => (e && e.series ? 's:' + e.series : 't:' + norm(e && e.title));
+const idOf = (r) => [r.key, r.scope === 'series' ? '' : r.event || '', r.item.kind, r.item.ref || r.item.url].join('|');
+const classify = (u) => {
+  const s = String(u || '').trim(); let x; try { x = new URL(/^[a-z][a-z0-9+.-]*:/i.test(s) ? s : 'https://' + s); } catch { return null; }
+  if (x.protocol !== 'https:') return null;
+  if (x.hostname === 'docs.google.com' && /^\/presentation\/d\//.test(x.pathname)) return { kind: 'slides', url: x.href };
+  if (x.hostname === 'docs.google.com' && /^\/document\/d\//.test(x.pathname)) return { kind: 'gdoc', url: x.href };
+  if (/\.atlassian\.net$/.test(x.hostname) && x.pathname.startsWith('/wiki')) return { kind: 'conf', url: x.href };
+  return { kind: 'link', url: x.href };
+};
+
+/** The items of one meeting, in the shape of GET /api/meeting-material. event: { id?, title, series? } */
+export function materialFor(event) {
+  const key = keyOf(event); const held = new Map();
+  for (const r of rows) { const id = idOf(r); if (r.removed) held.delete(id); else held.set(id, r); }
+  return [...held.values()].filter((r) => r.key === key && (r.scope === 'series' || r.event === String(event.id || ''))).map((r) => ({
+    id: Math.abs([...idOf(r)].reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 7)).toString(16), kind: r.item.kind, ref: r.item.ref || null, url: r.item.url || null, title: r.item.title,
+    ws: r.item.ws || null, topic: r.topic || null, present: r.present === true, scope: r.scope, from: 'you', by: 'pm:wawan', at: null }));
+}
+
+export function materialGet(path, url) {
+  const q = new URL(url, location.origin).searchParams;
+  if (path === '/api/meeting-material/suggest') {
+    const t = (q.get('q') || '').toLowerCase();
+    return { ok: true, suggested: SUGGESTED, found: t.length >= 2 ? FIND.filter((x) => x.title.toLowerCase().includes(t)) : [] };
+  }
+  const event = { id: q.get('event') || '', title: q.get('title') || '', series: q.get('series') || '' };
+  return { ok: true, key: keyOf(event), items: materialFor(event), ...(q.get('topics') ? { topics: TOPICS } : {}) };
+}
+
+export function materialPost(b) {
+  const e = b.event || {}; const it = b.item || {};
+  const item = it.ref ? { kind: it.kind, ref: it.ref, title: it.title || it.ref, ws: it.ws } : (() => { const c = classify(it.url); return c ? { ...c, title: it.title || c.url } : null; })();
+  if (!item) return { ok: false, error: 'a link must be an https address' };
+  const scope = b.scope === 'series' ? 'series' : 'meeting';
+  rows.push({ key: keyOf(e), scope, event: scope === 'meeting' ? String(e.id || '') : '', item, topic: b.topic || null, present: b.op !== 'remove' && b.present === true, removed: b.op === 'remove' });
+  return { ok: true, items: materialFor(e) };
+}

package/workspace/public/pm/c3-demo.js

@@ -12,6 +12,7 @@ import { el } from './dom.js';
 import * as D from './c3-demo-data.js';
 import { installInit } from './c3-demo-init.js';
 import { focusGet, focusPost } from './c3-demo-focus.js';   // Meeting focus: the mockup's Partner API review (GET /api/meeting-focus, its ask poll, and the topic and ask POSTs)
+import { materialGet, materialPost, materialFor } from './c3-demo-material.js';   // Meeting material: GET and POST /api/meeting-material, its suggestions, and the material in the Focus read
 import { installBoards } from './c3-demo-boards.js';   // Initiatives boards: answers every /api/boards GET and POST (installed outermost, in installDemo)
 import { installCoreDocs } from './c3-demo-coredocs.js';   // Core documents of each level: GET /api/core-docs and its POSTs (installed outermost, after installBoards)
 import './c3-demo-cal-ix.js';   // Calendar and the ribbon: sets window.__c3calix (calendar-views.js reads it in demo only)
@@ -53,7 +54,9 @@ function getRoute(path, url) {
   switch (path) {
     case '/api/briefing': return D.briefing(url);
     case '/api/calendar-views': return withCalendarPage(D.calendarViews(url));
-    case '/api/meeting-focus': case '/api/meeting-focus/ask': case '/api/meeting-focus/now': return focusGet(path, url);
+    case '/api/meeting-focus': { const o = focusGet(path, url); return o && o.ok ? { ...o, material: [...materialFor({ id: q.get('event') || '', title: q.get('title') || '' }), ...materialFor(o.event)] } : o; }   // what was asked for, and the sample meeting the demo answers with
+    case '/api/meeting-focus/ask': case '/api/meeting-focus/now': return focusGet(path, url);
+    case '/api/meeting-material': case '/api/meeting-material/suggest': return materialGet(path, url);
     case '/api/pm-items': return D.pmItems();
     case '/api/runs': return D.runs();
     case '/api/releases': return D.releases();
@@ -78,6 +81,7 @@ function postRoute(path, body) {
   let b = {};
   try { b = body ? JSON.parse(body) : {}; } catch { b = {}; }
   if (path.startsWith('/api/meeting-focus/')) return focusPost(path, body);
+  if (path === '/api/meeting-material') return materialPost(b);
   if (path === '/api/pm-items/add') return { ok: true, item: { id: 'item-demo-new' + (++added), title: String(b.line || '').trim() || 'New item', due: null, priority: null, waiting_on: null, job: null, steps: [], created_at: D.NOW_ISO + 'Z' } };
   if (path === '/api/pm-items/remove') return { ok: true, undo_ms: 8000 };
   if (path === '/api/calendar-links') return (window.__c3links = (window.__c3links || []).concat([b])), { ok: true, link: b.kind === 'none' ? null : { kind: b.kind, ws: b.ws || null, board: b.board || null, initiative: b.initiative || null, title: b.title || null, by: 'pm:wawan' } };   // nothing is saved