create-pmos 0.242.0 → 0.243.0

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

@@ -120,10 +120,16 @@ function documentsOf(ctx, w) {
   return { docs, reports: r.reports };
 }
 
+/** The state of a report's structure draft, else null (report-structure-gaps). */
+function draftStateOf(ctx, w, s) {
+  if (!ctx || typeof ctx.structureDraftState !== 'function' || s.source !== 'work') return null;
+  try { return ctx.structureDraftState(w, s.id) || null; } catch { return null; }
+}
+
 /** The saved structure of a report (initiative report-structure): { saved, at, charts, sections }, else null. */
 function structureOf(root, id) { try { return require('./report-structure.js').savedOf(root, id); } catch { return null; } }
 
-function setupOut(s, now, docsOf, idx, root) {
+function setupOut(s, now, docsOf, idx, root, draft) {
   const mine = (docsOf.reports || []).filter((x) => x.cadence === s.id);
   const issued = mine.filter((x) => x.issued).map((x) => x.slot).sort().pop() || null;
   const latest = mine.slice().sort((a, b) => (a.slot < b.slot ? 1 : -1))[0] || null;
@@ -134,6 +140,7 @@ function setupOut(s, now, docsOf, idx, root) {
     next_draft: next, last_issued: issued, status: s.status, cycles: mine.length,
     copy: copyOf(latest ? linkFor(idx, latest.path, s.output) : null, docSync.copyKindOf(s.output)),
     structure: structureOf(root, s.id),
+    draft: draft || null,   // report-structure-gaps: { state: 'drafting' | 'held' | 'ended', since, … } while a draft that follows the saved structure is being made
   };
 }
 
@@ -162,7 +169,7 @@ function listAnswer(ctx, w, now) {
   const docsOf = documentsOf(ctx, w);
   const idx = copyIndex(w.root);
   return {
-    setups: [...st.setups.values()].map((s) => setupOut(s, new Date(now), docsOf, idx, w.root)),
+    setups: [...st.setups.values()].map((s) => setupOut(s, new Date(now), docsOf, idx, w.root, draftStateOf(ctx, w, s))),
     findings: RS.openFindings(st).map((f) => ({ id: f.id, name: f.name, why: f.why, evidence: f.evidence, confidence: f.confidence, proposal: f.proposal })),
     asks: [...st.asks.values()].map((a) => ({ id: a.id, text: a.text, state: a.state, changed: !!a.changed, proposal: a.proposal, error: a.error })),
     finder: finderOut(ctx, st, now),
@@ -360,6 +367,13 @@ async function handle(req, res, url, ctx) {
     if (s.source !== 'work') return send(bad(400, 'a dashboard report is drafted from its dashboard on its day'));
     let next = null; try { next = RS.nextDraftAt(s.schedule, s.last_run, new Date()); } catch { next = null; }
     const day = next ? `${next.getFullYear()}-${String(next.getMonth() + 1).padStart(2, '0')}-${String(next.getDate()).padStart(2, '0')}` : null;   // the local day, as setUp names a slot
+    // A report with a saved structure is drafted by the session the schedule would start, so the draft follows the structure (report-structure-gaps).
+    // One with no saved structure keeps the instant draft below.
+    const sd = typeof ctx.structureDraft === 'function' ? ctx.structureDraft(w, s.id) : { structured: false };
+    if (sd.structured) {
+      if (sd.status) return send(bad(sd.status, sd.error));
+      return send({ status: 200, body: { ok: true, drafting: true, held: !!sd.held, state: sd.state || null, id: s.id } });
+    }
     const d = draftCycle(root, s.id, day, g.actor);
     if (d.error) return send(bad(500, 'the draft was not written: ' + d.error));
     if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg();

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.242.0",
+  "version": "0.243.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.242.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.242.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-material.js

@@ -18,6 +18,7 @@ import { ensureComponentsCss } from './primitives.js';
 import { icon, pbtn, sect, put, lk, ib, list, empty } from './c3-ini-ui.js';
 import { openSheet, closeSheet } from './c3-sheet.js';
 import { toast } from './c3-toast.js';
+import { openAudienceWindow } from './c3-audience-link.js';
 
 /** What each kind of item is called, and which icon it takes. `deck`: PMOS presents it itself. `present`: it can be presented at all. */
 export const KIND = {
@@ -145,7 +146,16 @@ export function presentItem(item) {
   if (item.kind === 'pmos-deck') return showDeck(item, 'pres');
   return openItem(item);
 }
-export function audienceItem(item) { if (item && item.kind === 'pmos-deck') return showDeck(item, 'aud'); return openItem(item); }
+/** Audience view: a PMOS deck opens in a window of its own, slides only (initiative meeting-material-replay-gaps). The window opens at once, on the press, because a browser
+ *  blocks a window that opens after a wait. When it is blocked a notice says so and offers the full-screen view in this window. */
+export function audienceItem(item) {
+  if (item && item.kind === 'pmos-deck') {
+    if (openAudienceWindow({ ws: item.ws || wsParam(), path: item.ref, name: item.title || 'Deck' })) return;
+    toast({ text: 'The audience window was blocked. Allow pop-ups for this page, or use the full-screen view here.', actionLabel: 'Full-screen view here', timeout: 10000, onAction: () => showDeck(item, 'aud') });
+    return;
+  }
+  return openItem(item);
+}
 
 /* ── the Material part of the meeting card ────────────────────────────────────────────────────────────────────────── */
 

package/workspace/public/pm/c3-replay.css

@@ -125,3 +125,9 @@
   .c3replay .rpl-lb { min-height: 44px; }
 }
 @media (prefers-reduced-motion: reduce) { .c3replay .rpl-now { transition: none; } }
+
+/* meeting-material-replay-gaps: where a recording was off between two starts */
+.c3replay .rpl-gap { position: absolute; top: 0; bottom: 0; left: var(--fc-left, 0%); width: var(--fc-width, 0%); min-width: 0; min-height: 0; height: auto; padding: 0; margin: 0; box-sizing: border-box; border: 0; border-left: 1px dashed var(--muted-foreground); border-right: 1px dashed var(--muted-foreground); background: repeating-linear-gradient(135deg, transparent 0 4px, var(--border) 4px 6px); cursor: pointer; }
+.c3replay .rpl-gap:focus-visible { outline: 2px solid color-mix(in oklab, var(--ring) 50%, var(--foreground)); outline-offset: 2px; }
+.c3replay .rpl-gapnote { display: flex; gap: 8px; align-items: center; font-size: var(--fs-2); }
+.c3replay .rpl-gapkey { display: inline-block; width: 22px; height: 10px; flex: none; border: 1px dashed var(--muted-foreground); background: repeating-linear-gradient(135deg, transparent 0 3px, var(--border) 3px 5px); }

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

@@ -27,6 +27,11 @@ const KIC = { decision: 'scale', action: 'todo', question: 'reply' };
 const KWORD = { decision: 'Decision', action: 'Next step', question: 'Question' };
 const KPLURAL = { decision: 'Decisions', action: 'Next steps', question: 'Questions' };
 const pad = (n) => String(n).padStart(2, '0');
+const NO_NOTE = 'That replay link does not match a note on this computer. It may be from another computer, or the note was deleted. Open it from Calendar, Notes.';
+/** A note id, as lib/notes-audio.js names it. The ?replay= link is checked against this before any request is made. Pure. */
+export const NOTE_ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
+/** The gap that holds time t (the recording was off), or null. Pure. */
+export const gapAt = (gaps, t) => (gaps || []).find((g) => t >= g.from_ms && t < g.to_ms) || null;
 
 /** 3:07, or 1:03:07 from an hour on. Pure. */
 export function mmss(ms) {
@@ -89,6 +94,7 @@ export function openReplay({ note, event, date } = {}) {
 }
 
 async function load(s) {
+  if (!s.note && !s.event) { fail(s, NO_NOTE); return; }   // a ?replay= link that is not a note id: no request is made
   const p = new URLSearchParams();
   if (s.note) p.set('note', s.note);
   if (s.event) p.set('event', s.event);
@@ -96,7 +102,7 @@ async function load(s) {
   let d = null;
   try { d = await pmGet('/api/meeting-replay?' + p.toString()); } catch (e) { d = { ok: false, error: String((e && e.message) || e) }; }
   if (S !== s) return;
-  if (!d || !d.ok) { fail(s, (d && d.error) || 'The replay could not be read.'); return; }
+  if (!d || !d.ok) { fail(s, d && d.error === 'no such note' ? NO_NOTE : (d && d.error) || 'The replay could not be read.'); return; }
   s.data = d;
   s.root.dataset.rplState = 'ok';
   if (d.audio) {
@@ -147,6 +153,8 @@ function tick(s) {
   if (s.play) {
     if (s.audio && !s.soundOff && !s.audio.paused) s.t = Math.round(s.audio.currentTime * 1000);
     else s.t = Math.min(len, s.t + TICK_MS * s.speed);   // no sound (none kept, or it cannot play): the page keeps the time
+    const gp = gapAt(s.data.gaps, s.t);
+    if (gp && s.t < len) { s.t = gp.to_ms; if (s.audio && !s.soundOff) { try { s.audio.currentTime = s.t / 1000; } catch { /* not ready */ } } }   // the recording was off: play on from where it began again
     if (s.t >= len) { s.t = len; s.play = false; if (s.audio) { try { s.audio.pause(); } catch { /* none */ } } paintTop(s); }
   }
   paintTime(s, false);
@@ -182,9 +190,13 @@ function chipsOf(s) {
     el('span', null, [day, d.start_ms != null ? wall(s, 0) + ' to ' + wall(s, lenOf(s)) : '', len + ' min'].filter(Boolean).join(' · ')),
     d.meeting.attendees.length ? el('span', null, d.meeting.attendees.length + (d.meeting.attendees.length === 1 ? ' person' : ' people')) : null,
     el('span', { title: 'Audio and screen shots are kept on this machine' }, icon('lock', 'sm'), (d.audio ? 'audio' : 'no audio') + (kept ? ' and ' + kept + (kept === 1 ? ' screen shot' : ' screen shots') : '')),
+    (d.recordings || 1) > 1 ? el('span', { class: 'tag warn', 'data-rpl': 'recordings', title: 'The recording was stopped and started again. The gap is marked on the track.' }, icon('alert', 'sm'), d.recordings + ' recordings') : null,
     d.aside_count ? lk({ 'data-rpl': 'aside', class: 'rpl-warnc', title: 'Shots that looked like another app. They are not in the replay.' }, d.aside_count + ' set aside') : null);
 }
 
+/** '7 min', or '40 s' under a minute. Pure. */
+export const gapText = (ms) => (ms < 60000 ? Math.max(1, Math.round(ms / 1000)) + ' s' : Math.round(ms / 60000) + ' min');
+
 function trackOf(s) {
   const d = s.data;
   const marks = d.keys.filter((k) => k.t != null).map((k) => {
@@ -198,11 +210,13 @@ function trackOf(s) {
     const b = btn({ class: 'rpl-run', 'data-rpl-seek': String(rn.from_ms), 'data-rpl-run': String(i), title: (rn.n ? rn.n + '. ' : '') + topicText(rn.topic) + ' · ' + wall(s, rn.from_ms) + ' · ' + Math.max(1, Math.round((rn.to_ms - rn.from_ms) / 60000)) + ' min' }, w >= 5 && rn.n ? String(rn.n) : '');
     return geo(b, { '--fc-left': pct(s, rn.from_ms) + '%', '--fc-width': Math.max(0.5, w) + '%' });
   });
+  const gaps = (d.gaps || []).map((g, i) => geo(btn({ class: 'rpl-gap', 'data-rpl-seek': String(g.to_ms), 'data-rpl-gap': String(i), title: 'Not recorded ' + wall(s, g.from_ms) + ' to ' + wall(s, g.to_ms) + ' (' + gapText(g.to_ms - g.from_ms) + '). A press plays from where the recording began again.', 'aria-label': 'Not recorded ' + wall(s, g.from_ms) + ' to ' + wall(s, g.to_ms) }),
+    { '--fc-left': pct(s, g.from_ms) + '%', '--fc-width': Math.max(0.6, (g.to_ms - g.from_ms) / lenOf(s) * 100) + '%' }));
   const head = geo(el('span', { class: 'rpl-now', 'data-rpl': 'head' }), { '--fc-left': '0%' });
   const ticks = [0, 15, 30, 45, 60, 75, 90].map((m) => m * 60000).filter((ms) => ms < lenOf(s) * 0.92)
     .map((ms) => geo(el('span', { class: 'rpl-tick' }, wall(s, ms)), { '--fc-left': pct(s, ms) + '%' }));
   return el('div', { class: 'rpl-track', role: 'group', 'aria-label': 'The meeting by topic, with decisions, questions and next steps. Press a stretch or a mark to play from there.' },
-    el('div', { class: 'rpl-rail', 'data-rpl': 'rail' }, el('div', { class: 'rpl-mks' }, ...marks), el('div', { class: 'rpl-runs', 'data-rpl': 'bar' }, ...runs), el('div', { class: 'rpl-pms' }, ...pms), head),
+    el('div', { class: 'rpl-rail', 'data-rpl': 'rail' }, el('div', { class: 'rpl-mks' }, ...marks), el('div', { class: 'rpl-runs', 'data-rpl': 'bar' }, ...runs, ...gaps), el('div', { class: 'rpl-pms' }, ...pms), head),
     el('div', { class: 'rpl-ticks dim mono' }, ...ticks, el('span', { class: 'end' }, wall(s, lenOf(s)))));
 }
 
@@ -218,7 +232,9 @@ function buildTop(s) {
     el('div', { class: 'rpl-clock' }, el('div', null, el('b', { class: 'mono', 'data-rpl': 't' }, mmss(s.t)),
       el('span', { class: 'dim mono' }, 'of ' + mmss(lenOf(s)) + ' · ', el('span', { 'data-rpl': 'clk' }, wall(s, s.t))))),
     el('div', { class: 'rpl-acts', 'data-rpl': 'acts' }),
-    trackOf(s), legend);
+    trackOf(s), legend,
+    (d.gaps || []).length ? el('div', { class: 'rpl-gapnote dim', 'data-rpl': 'gapnote' }, el('i', { class: 'rpl-gapkey', 'aria-hidden': 'true' }),
+      d.gaps.map((g) => 'Not recorded ' + wall(s, g.from_ms) + ' to ' + wall(s, g.to_ms) + ' (' + gapText(g.to_ms - g.from_ms) + ').').join(' ') + ' You stopped the recording and started it again. Playing across a gap skips it.') : null);
   paintTop(s);
 }
 

package/workspace/public/pm/c3-report-deck.css

@@ -156,3 +156,8 @@
   .c3 .rd-dks-chat { position: static; max-height: none; }
   .c3 .rd-dks-log { max-height: 420px; }
 }
+
+/* meeting-material-replay-gaps: the audience window shows the slides only, so the toolbar is hidden; a window with no deck says why in one line */
+body.c3-aud-win { margin: 0; }
+body.c3-aud-win .rd-ov .rp-deck__bar { display: none; }
+.c3.aud-msg { display: grid; place-items: center; min-height: 100vh; padding: var(--sp-3); text-align: center; }