create-pmos 0.242.0 → 0.244.0

package/workspace/lib/report-structure.js

@@ -36,7 +36,7 @@ const crypto = require('crypto');
 const RD = require('./report-draft.js');
 const CS = require('./charts-store.js');
 
-const EVENTS = Object.freeze(['describe', 'turn', 'version', 'accept', 'revert', 'source', 'remove', 'dry', 'check', 'error']);
+const EVENTS = Object.freeze(['describe', 'turn', 'version', 'accept', 'revert', 'source', 'remove', 'dry', 'pull', 'check', 'error']);
 const PMOS_KINDS = Object.freeze(['pmos-level', 'dashboard', 'chart', 'document', 'past-report']);
 const OUTSIDE_KINDS = Object.freeze(['connector', 'link', 'upload', 'person', 'chrome', 'computer']);
 const KINDS = Object.freeze([...PMOS_KINDS, ...OUTSIDE_KINDS]);
@@ -79,7 +79,7 @@ function paths(root, id) {
   const folder = path.join(abs, rel);
   const dir = path.join(folder, 'structure');
   return { abs, rel, folder, dir, relDir: `${rel}/structure`, events: path.join(dir, 'structure.jsonl'), versions: path.join(dir, 'versions'), pending: path.join(dir, 'pending'),
-    dry: path.join(dir, 'dry'), checks: path.join(dir, 'checks'), checksPending: path.join(dir, 'checks', 'pending'), brief: path.join(dir, 'brief.md'), briefRel: `${rel}/structure/brief.md` };
+    dry: path.join(dir, 'dry'), pull: path.join(dir, 'pull'), pullPending: path.join(dir, 'pull', 'pending'), checks: path.join(dir, 'checks'), checksPending: path.join(dir, 'checks', 'pending'), brief: path.join(dir, 'brief.md'), briefRel: `${rel}/structure/brief.md` };
 }
 
 // ── the one writer and the fold ───────────────────────────────────────────────────────────────────────────
@@ -440,6 +440,50 @@ function landVersion(root, id, plan, { turn, answer, questions, options, from, b
   return { ok: true, n, plan: v.plan };
 }
 
+// ── test pull (report-structure-gaps): ONE source read for the last complete period ──────────────────────────
+/** What a pull job wrote for one source of a plan. → { ok, pull } | refusal. `reached` false is a valid answer: the source returned nothing. */
+function validatePull(data, plan, sourceId) {
+  if (!isObj(data)) return refuse(422, 'the pull result must be a JSON object');
+  const src = listOf(plan && plan.sources).find((s) => s.id === sourceId);
+  if (!src) return refuse(422, 'the source is not in the plan');
+  const chartIds = new Set(listOf(plan.charts).filter((c) => c.source === sourceId).map((c) => c.id));
+  if (str(data.source) !== sourceId) return refuse(422, 'source must be the source that was pulled');
+  if (!Number.isInteger(data.n) || data.n < 1) return refuse(422, 'n must be the version number');
+  const per = badText(data.period, 'period', { max: 40 });
+  if (per || !data.period.trim()) return refuse(422, per || 'period is required');
+  if (typeof data.reached !== 'boolean') return refuse(422, 'reached must be true or false');
+  const rs = badText(data.reason === undefined ? '' : data.reason, 'reason', { max: 300, allowEmpty: true });
+  if (rs) return refuse(422, rs);
+  const values = data.values === undefined ? [] : data.values;
+  if (!Array.isArray(values) || values.length > LIMITS.charts) return refuse(422, `values is a list of at most ${LIMITS.charts}`);
+  const out = [];
+  for (const [i, v] of values.entries()) {
+    const w = `values[${i}]`;
+    if (!isObj(v)) return refuse(422, `${w} must be an object`);
+    if (!chartIds.has(str(v.chart))) return refuse(422, `${w}.chart ${JSON.stringify(str(v.chart)).slice(0, 40)} is not a chart of the plan that uses this source`);
+    const c = {};
+    for (const k of ['value', 'was', 'delta', 'note']) { const r = textField(v, k, w); if (r.error) return refuse(422, r.error); c[k] = r.v; }
+    if (v.flag !== undefined && typeof v.flag !== 'boolean') return refuse(422, `${w}.flag must be true or false`);
+    out.push({ chart: v.chart, value: c.value, was: c.was, delta: c.delta, flag: v.flag === true, note: c.note });
+  }
+  const reached = data.reached === true;
+  if (!reached && out.length) return refuse(422, 'a source that was not reached has no values');
+  const got = out.filter((v) => v.value).length;
+  const reason = str(data.reason).trim() || (reached && !got ? 'The source answered, but no chart returned a number.' : '');
+  return { ok: true, pull: { source: sourceId, n: data.n, period: data.period.trim(), reached, ok: reached && got > 0, reason, values: out, charts: chartIds.size, got } };
+}
+function writePull(root, id, pull) {
+  if (!SLUG_RE.test(String(pull.source))) throw new Error('report-structure: bad source id');
+  writeAtomic(path.join(paths(root, id).pull, `${pull.source}.json`), JSON.stringify(pull, null, 2) + '\n');
+}
+function readPull(root, id, source) { return SLUG_RE.test(String(source)) ? readJson(path.join(paths(root, id).pull, `${source}.json`)) : null; }
+function readPulls(root, id) {
+  const out = {};
+  let names = []; try { names = fs.readdirSync(paths(root, id).pull); } catch { return out; }
+  for (const f of names) { const m = /^([a-z0-9][a-z0-9-]*)\.json$/.exec(f); if (m && SLUG_RE.test(m[1])) { const o = readPull(root, id, m[1]); if (o) out[m[1]] = o; } }
+  return out;
+}
+
 // ── the GET answer ────────────────────────────────────────────────────────────────────────────────────────
 /** Chrome and computer sources show what their last check found: a passing check is Reached, a failing one Needs you. */
 function overlay(plan, checks) {
@@ -450,7 +494,7 @@ function overlay(plan, checks) {
     return { ...s, state: c.ok ? 'reached' : 'needs-you' };
   }) };
 }
-function structureAnswer(root, id, { running } = {}) {
+function structureAnswer(root, id, { running, pulling } = {}) {
   const st = stateOf(root, id);
   const checks = readChecks(root, id);
   const versions = [...st.versions.values()].sort((a, b) => a.n - b.n).map((v) => ({ n: v.n, at: v.at, turn: v.turn }));
@@ -458,7 +502,7 @@ function structureAnswer(root, id, { running } = {}) {
     running: !!running, job: running ? { since: running.since, turn: running.turn, kind: running.kind } : null,
     current: st.current, saved: st.saved ? st.saved.n : null, versions, log: st.log,
     plan: st.current != null ? overlay(readVersion(root, id, st.current), checks) : null,
-    dry: st.dry, checks, errors: st.errors.map((e) => ({ text: e.text, at: e.at })),
+    dry: st.dry, checks, pulls: readPulls(root, id), pulling: Array.isArray(pulling) ? pulling : [], errors: st.errors.map((e) => ({ text: e.text, at: e.at })),
   };
 }
 /** What the setups GET carries for one report: { saved, at, charts, sections } of the accepted version, else null. */
@@ -512,4 +556,4 @@ function writeBrief(root, id, setup, { now } = {}) {
 
 module.exports = { EVENTS, KINDS, PMOS_KINDS, OUTSIDE_KINDS, STATES, FIXED, LIMITS, CHECK_STEPS, CHECK_STATES, CADENCE_RE, SLUG_RE, RUN_RE,
   paths, append, readEvents, fold, stateOf, nextN, badText, validatePlan, validateSource, validateDry, validateCheck, cleanQuestions, cleanOptions, addSourceTo, removeFrom,
-  landVersion, readVersion, rewriteVersion, writeDry, readDry, writeCheck, readCheck, readChecks, writeBrief, structureAnswer, savedOf, overlay, defaultState, newRun };
+  landVersion, readVersion, rewriteVersion, writeDry, readDry, validatePull, writePull, readPull, readPulls, writeCheck, readCheck, readChecks, writeBrief, structureAnswer, savedOf, overlay, defaultState, newRun };

package/workspace/lib/routes-meeting-focus.js

@@ -129,6 +129,7 @@ function settleRun(ctx, key, done, now) {
   const res = done && done.result;
   if (done && done.stopped) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The run was stopped before it answered.' });
   if (done && done.timedOut) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion took too long and was stopped.' });
+  if (res && headless.signedOut(res.text)) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, auth: true, error: headless.SIGNED_OUT_WHY });
   if (!res || !res.ok || res.isError) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion did not answer (' + ((done && done.note) || 'no result') + ').' });
   const parsed = F.parseCompanion(res.text);
   // a malformed answer is dropped, not shown

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.244.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.242.0",
+      "version": "0.244.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.244.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); }