create-pmos 0.241.0 → 0.243.0

package/workspace/lib/route-modules.js

@@ -69,6 +69,8 @@ const MODULES = Object.freeze([
   'routes-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
   'routes-sources',       // workspace-data-freshness: how old each source is, Refresh now, the change detector switch
   'routes-meeting-focus', // console3 Meeting focus: the meeting, its note's talk, the companion's notes (GET); topic corrections and Ask PMOS quietly (page press)
+  'routes-meeting-replay', // meeting-material-replay: the note, the Focus state and the shots joined for the Replay page (GET, read-only)
+  'routes-meeting-material', // meeting-material-replay: the material the PM links to a meeting (GET list and suggest; page-press POST add and remove; meeting-material.jsonl)
   'routes-stage-tools',   // stage-tools-records: the records the PM edits per stage, what PMOS holds per stage, the sprint burndown
   'routes-driver',        // initiative-driver: the Agent strip's data, Keep, Send back, Drop, Pause and the board mode (driver.jsonl)
   'routes-scan',          // horizon-scan-portfolio: one scan for the workspace: the watch list and setting, Scan now and Stop, report documents and their proposals (approve, change, dismiss, undo), plus the first scan's per-board and Briefing reads (scan.jsonl)

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

@@ -2,7 +2,7 @@
 /* routes-meeting-focus.js — the Meeting focus page's server side (initiative c3-meeting-focus; lib/route-modules.js).
  *
  *   GET  /api/meeting-focus?event=<id>&date=YYYY-MM-DD[&ws=]
- *        → { ok, now_ms, event, brief, note, topics, current, runs, tail, captured, gist, chips, notes, asks, companion }
+ *        → { ok, now_ms, event, brief, material, note, topics, current, runs, tail, captured, gist, chips, notes, asks, companion }
  *        The meeting (the calendar read for that day), its brief (lib/calendar-layers.js briefOf), the note linked to it, the last
  *        minutes of that note's transcript with who said them, the decisions, actions and questions so far, and the companion's state.
  *        An unknown meeting is a 404. The read also starts the companion when lib/meeting-focus.js shouldRun says it may: the note
@@ -193,13 +193,15 @@ async function read(q, ctx) {
     const url = l && typeof l.url === 'string' && /^https?:\/\//i.test(l.url) ? l.url : ''; if (!url || seen.has(url)) continue;
     seen.add(url); links.push({ label: F.str(l.label, 120) || url, url });
   }
+  let material = []; try { material = require('./meeting-material.js').forMeeting(ctx.runtimeDir, { id: ev.id, title: ev.title, series: ev.series || null }); } catch { material = []; }
   const sessions = note && Array.isArray(note.sessions) && note.sessions.length ? note.sessions : [];
   return { status: 200, body: {
     ok: true, now_ms: nowMs, date: day,
     talk,
     event: { id: ev.id, title: ev.title, at: ev.at, end: ev.end, attendees: [].concat(ev.attendees || ev.people || []).map((p) => (p && typeof p === 'object' ? p.name || p.id : p)).filter(Boolean).map(String),
-      initiative: ev.initiative || null, purpose: ev.purpose || (brief && brief.purpose) || null, links },
+      initiative: ev.initiative || null, series: ev.series || null, purpose: ev.purpose || (brief && brief.purpose) || null, links },
     brief: brief || null,
+    material,
     note: note ? { id: note.id, title: note.title || ev.title, state: note.state, recorded_from: note.recorded_from || null, lines: (note.transcript || []).length, sessions } : null,
     topics: fresh.topics, current: fresh.current, runs: fresh.runs,
     tail: note ? F.tailOf(note, { now: nowMs }) : [], captured: F.capturedFrom(note),
@@ -317,7 +319,7 @@ const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true;
 
 module.exports = {
   prefixes: ['/api/meeting-focus'],
-  read, now: nowRoute, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf,
+  read, now: nowRoute, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf, linesOf, noteFor, noteEvent, realBrief,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     const wsId = url.searchParams.get('ws');

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

@@ -0,0 +1,143 @@
+'use strict';
+/* routes-meeting-material.js — the material of a meeting: what the PM linked to it (initiative meeting-material-replay, part 1; lib/route-modules.js).
+ *
+ *   GET  /api/meeting-material?event=<id>&series=&title=[&date=][&topics=1][&ws=]
+ *        → { ok, key, items: [item], topics? }   item: { id, kind, ref, url, title, ws, topic, present, scope: meeting|series, from: 'you', by, at }
+ *        The items of the meeting: the ones for every meeting of its series and the ones for this one. title is required (it names the series when
+ *        series is empty). With topics=1 the answer also lists the topics Focus starts the meeting with, for the Add material sheet.
+ *   POST /api/meeting-material { op?: 'add'|'remove', event: { id?, title, series? }, scope: 'meeting'|'series', item: { kind, ref|url, title?, ws? }, topic?, present? }
+ *        → { ok, items }   page press (lib/pm-guard.js requirePagePress). Appends one line to <runtime>/meeting-material.jsonl. The calendar is never written.
+ *   GET  /api/meeting-material/suggest?ws=&initiative=&board=&q=[&limit=]
+ *        → { ok, suggested: [pick], found: [pick] }   pick: { kind, ref, title, meta, why?, present, ws }
+ *        suggested: the documents of the meeting's level (the initiative's, newest first) and the newest report cycles. found: a search over the
+ *        titles and paths of PMOS documents and report cycles (two letters or more). Read-only.
+ *
+ * Handlers are pure over (req, body, ctx): ctx = { runtimeDir, getWs, stateDirFor?, initiativeIndex?, readEvents?, briefFor?, json } so a test needs no server. */
+const store = require('./meeting-material.js');
+const guard = require('./pm-guard.js');
+
+const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const str = (v, n) => String(v == null ? '' : v).trim().slice(0, n || 300);
+const eventOf = (q) => ({ id: str(q.event, 120), title: str(q.title, 300), series: str(q.series, 300) || null });
+
+/** The topics Focus starts the meeting with (lib/meeting-focus.js topicsFrom). Best effort: no calendar read, no topics. */
+async function topicsOf(q, ctx) {
+  try {
+    const F = require('./meeting-focus.js');
+    const R = require('./routes-meeting-focus.js');
+    const events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir, { now: Date.now() });
+    const date = q.date && DAY.test(String(q.date)) ? String(q.date) : '';
+    const ev = R.findEvent(events, str(q.event, 120), date);
+    if (!ev) return [];
+    const day = date || String(ev.at || '').slice(0, 10);
+    const w = ctx.getWs ? ctx.getWs(q.ws || null) : null;
+    const brief = typeof ctx.briefFor === 'function' ? await ctx.briefFor(ev, day) : await R.realBrief({ ...ctx, w }, ev, day);
+    return F.topicsFrom(ev, brief).map((t) => ({ id: t.id, text: t.text }));
+  } catch { return []; }
+}
+
+async function list(q, ctx) {
+  const e = eventOf(q);
+  if (!e.title) return fail(400, 'title is required');
+  if (!ctx.runtimeDir) return { status: 200, body: { ok: true, key: store.keyOf(e), items: [] } };
+  const body = { ok: true, key: store.keyOf(e), items: store.forMeeting(ctx.runtimeDir, e) };
+  if (q.topics === '1' || q.topics === 'true') body.topics = await topicsOf(q, ctx);
+  return { status: 200, body };
+}
+
+function post(req, body, ctx) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return fail(g.status, g.error);
+  if (!ctx.runtimeDir) return fail(409, 'this server has no runtime folder, so the material cannot be saved');
+  const out = store.append(ctx.runtimeDir, body, g.actor && g.actor.by ? g.actor.by : null);
+  return out.ok ? { status: 200, body: out } : fail(400, out.error);
+}
+
+/* ── what PMOS can offer ──────────────────────────────────────────────────────────────────────────────────────────── */
+
+const dayText = (d) => {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(d || '')); if (!m) return '';
+  const t = new Date(Date.UTC(+m[1], +m[2] - 1, +m[3]));
+  return ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][t.getUTCDay()] + ' ' + (+m[3]) + ' ' + ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][+m[2] - 1];
+};
+const isReportPath = (p) => /(^|\/)reports\//.test(p);
+
+/** Every document and report cycle PMOS holds for a workspace, as picks. Each read is best effort: a failing source adds nothing. */
+function candidates(ctx, w) {
+  const docs = []; const reports = [];
+  const root = w.root;
+  const owner = new Map();
+  try {
+    if (typeof ctx.initiativeIndex === 'function') {
+      for (const g of ctx.initiativeIndex(root).initiatives || []) for (const a of g.artifacts || []) { const rel = String(a.path).split('\\').join('/'); if (!a.shared && !owner.has(rel)) owner.set(rel, { id: g.id, title: g.title || g.id }); }
+    }
+  } catch { /* no attribution: a document has no initiative */ }
+  try {
+    const lib = require('./doc-library.js').library(root, { stateDir: typeof ctx.stateDirFor === 'function' ? ctx.stateDirFor(w) : undefined, owners: () => owner });
+    if (lib && lib.ok) {
+      const cat = new Map((lib.categories || []).map((c) => [c.key, c.name]));
+      for (const f of lib.files || []) {
+        if (f.node || isReportPath(f.path)) continue;
+        const o = owner.get(f.path) || (f.initiative ? { id: f.initiative } : null);
+        docs.push({ kind: 'pmos-doc', ref: f.path, title: f.title || f.path, date: f.date || '', ini: o ? o.id : null, ws: w.id,
+          meta: (o ? o.id + ' documents' : cat.get(f.category) || 'Documents') + (f.date ? ' · ' + dayText(f.date) : '') });
+      }
+    }
+  } catch { /* no library */ }
+  try {
+    const rs = require('./routes-report-setups.js');
+    for (const d of rs.documentsOf({ runtimeDir: ctx.runtimeDir, getWs: ctx.getWs }, w).docs || []) {
+      const deck = d.output === 'google-slides';
+      reports.push({ kind: deck ? 'pmos-deck' : 'report', ref: d.path, title: (d.name || d.id) + (d.slot ? ' · ' + d.slot : ''), date: String(d.slot || '').slice(0, 10), ini: null, ws: w.id,
+        meta: 'Reports · ' + (deck ? 'deck' : 'document') + (d.state === 'issued' ? ' · issued' : ' · draft'), present: deck });
+    }
+  } catch { /* no reports */ }
+  return { docs, reports };
+}
+
+const newest = (a, b) => String(b.date || '').localeCompare(String(a.date || ''));
+const pick = (c, why) => ({ kind: c.kind, ref: c.ref, title: c.title, meta: c.meta, ...(why ? { why } : {}), present: c.present === true, ws: c.ws });
+
+function suggest(q, ctx) {
+  const w = ctx.getWs ? ctx.getWs(q.ws || null) : null;
+  if (!w || !w.root) return fail(404, 'no such workspace');
+  const limit = Math.max(1, Math.min(20, Number(q.limit) || 6));
+  const ini = str(q.initiative, 120);
+  const c = candidates(ctx, w);
+  const suggested = [];
+  const seen = new Set();
+  const add = (x, why) => { if (suggested.length >= limit || seen.has(x.ref)) return; seen.add(x.ref); suggested.push(pick(x, why)); };
+  if (ini) {
+    for (const d of c.docs.filter((x) => x.ini === ini).sort(newest).slice(0, 4)) add(d, 'In ' + ini + (d.date ? ', edited ' + dayText(d.date) : ''));
+  }
+  for (const r of c.reports.slice().sort(newest).slice(0, 2)) add(r, 'A report PMOS keeps' + (r.date ? ', ' + dayText(r.date) : ''));
+  const text = str(q.q, 120).toLowerCase();
+  let found = [];
+  if (text.length >= 2) {
+    const hit = (x) => (x.title + ' ' + x.ref).toLowerCase().includes(text);
+    found = [...c.reports.filter(hit), ...c.docs.filter(hit)].sort(newest).slice(0, 8).map((x) => pick(x));
+  }
+  return { status: 200, body: { ok: true, suggested, found } };
+}
+
+const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true; };
+
+module.exports = {
+  prefixes: ['/api/meeting-material'],
+  list, post, suggest, candidates,
+  handle: async (req, res, url, ctx) => {
+    const p = url.pathname;
+    const q = Object.fromEntries(url.searchParams);
+    if (p === '/api/meeting-material/suggest') {
+      if (req.method !== 'GET') return respond(ctx, res, fail(405, 'GET only'));
+      return respond(ctx, res, suggest(q, ctx));
+    }
+    if (p !== '/api/meeting-material') return false;
+    if (req.method === 'GET') return respond(ctx, res, await list(q, ctx));
+    if (req.method !== 'POST') return respond(ctx, res, fail(405, 'GET or POST only'));
+    const got = await ctx.readJson(req);
+    if (!got.ok || !got.body || typeof got.body !== 'object' || Array.isArray(got.body)) return respond(ctx, res, fail(400, 'the body must be a JSON object'));
+    return respond(ctx, res, post(req, got.body, ctx));
+  },
+};

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

@@ -0,0 +1,75 @@
+'use strict';
+/* routes-meeting-replay.js — the meeting replay's server side (initiative meeting-material-replay, part 2; lib/route-modules.js).
+ *
+ *   GET /api/meeting-replay?note=<id>[&event=<id>&date=YYYY-MM-DD]
+ *   GET /api/meeting-replay?event=<id>[&date=YYYY-MM-DD]          the note linked to that meeting
+ *        → { ok, note, meeting, audio, start_ms, length_ms, lines, keys, topics, runs, notes, shots, aside_count }   (lib/meeting-replay.js)
+ *        The note (transcript, decisions, next steps, questions), the Focus state file (topics, stretches, PMOS's notes) and the
+ *        shots, joined. Read only: it writes nothing, starts no run and reaches nothing outside the machine. A private note is a
+ *        404 (it keeps no audio and no shots); an unknown note or a meeting with no note is a 404. A shot that was set aside
+ *        (`aside`) is not in `shots`; `aside_count` says how many there are.
+ * Handlers are pure over (query, ctx): ctx = { runtimeDir, readEvents?, now? }, so a test needs no server.
+ */
+const focus = require('./routes-meeting-focus.js');
+const notes = require('./notes.js');
+const notesAudio = require('./notes-audio.js');
+const notesScreen = require('./notes-screen.js');
+const F = require('./meeting-focus.js');
+const R = require('./meeting-replay.js');
+
+const fail = (status, error) => ({ status, body: { ok: false, error } });
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+/** The note's shots, the kept ones and the set-aside ones, so the join can count the set-aside ones and leave them out.
+ *  notesScreen.list(dir, id) lists the kept shots; { aside: true } lists only the set-aside ones. */
+function framesOf(dir, id) {
+  let all = [];
+  try { all = [...(notesScreen.list(dir, id) || []), ...(notesScreen.list(dir, id, { aside: true }) || [])]; } catch { all = []; }
+  return all.filter((f) => f && typeof f.t === 'number').sort((a, b) => a.t - b.t);
+}
+
+async function read(q, ctx) {
+  const dir = ctx.runtimeDir;
+  const noteId = String((q && q.note) || '').slice(0, 120);
+  const eventId = String((q && q.event) || '').slice(0, 120);
+  const date = q && q.date ? String(q.date) : '';
+  if (!noteId && !eventId) return fail(400, 'note or event is required');
+  if (date && !DAY.test(date)) return fail(400, 'date must be YYYY-MM-DD');
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(dir, { now: nowMs }); } catch { events = []; }
+  let note = null; let ev = null;
+  if (noteId) {
+    const r = notes.read(dir, noteId);
+    if (!r.ok) return fail(404, 'no such note');
+    note = r.note;
+    if (eventId) ev = focus.findEvent(events, eventId, date);
+    const m = note.meeting;
+    if (!ev && m && m.kind === 'event' && m.event_id) ev = focus.findEvent(events, String(m.event_id), date || String(m.start || '').slice(0, 10));
+  } else {
+    ev = focus.findEvent(events, eventId, date);
+    if (!ev) return fail(404, 'no such meeting on the calendar');
+    note = focus.noteFor(dir, ev, null);
+    if (!note) return fail(404, 'this meeting has no note to replay');
+  }
+  if (note.private) return fail(404, 'This note is private. It keeps no audio and no shots, so it has no replay.');
+  const talk = !ev;
+  if (!ev) ev = focus.noteEvent(note);
+  const keys = [focus.keyOf(ev.id), focus.keyOf(note.id)];
+  const rec = notesAudio.info(dir, note.id);
+  const audio = rec ? { url: '/api/notes/recording?id=' + encodeURIComponent(note.id) + '&b=' + rec.bytes + (notesAudio.hasClean(dir, note.id) ? '&c=1' : ''), ms: rec.ms } : null;
+  const body = R.build({ note, event: ev, stateLines: focus.linesOf(dir, keys), frames: framesOf(dir, note.id), audio, topics: talk ? [] : F.topicsFrom(ev, null), now: nowMs });
+  return { status: 200, body };
+}
+
+const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true; };
+
+module.exports = {
+  prefixes: ['/api/meeting-replay'],
+  read,
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/meeting-replay') return false;
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    return respond(ctx, res, await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json }));
+  },
+};

package/workspace/lib/routes-notes.js

@@ -40,6 +40,11 @@
  *                                             Refused: a private note (409), a note not listening (409), "Capture the shared screen" switched off (409),
  *                                             a token that is not the live capture's (409), a bad t or picture (400), a full note (409)
  *   GET  /api/notes/screen?id=…&t=…         → image/jpeg|png|webp    the shot kept at meeting time t; 404 for a private note or no such shot
+ *                                             (a shot set aside is not served, unless aside=1 is added: the review sheet's thumbnails)
+ *   POST /api/notes/screen also takes surface: 'window' | 'browser' | 'monitor', what the picture shows; a 'monitor' shot is checked for other apps
+ *   GET  /api/notes/screen-aside?id=…       → { ok, frames: [{ t, w, h, bytes, app, text? }], days }   the shots set aside as another app (meeting-material-replay)
+ *   POST /api/notes/screen-aside { id, action: 'keep' | 'delete' | 'delete-all', t? } → { ok, frame? , deleted?, aside }   the PM's answer; GET /api/notes/one
+ *                                             also carries screen.aside, the count. Set-aside shots older than 7 days are deleted on their own.
  *   POST /api/notes/screen-delete { id }    → { ok, deleted }    deletes the note's screenshots and keeps the rest
  *   POST /api/notes/clean-audio { id }      → { ok, started }    makes the cleaned copy of the replay now (Run 3 of notes-audio-quality; needs ffmpeg)
  *   GET  /api/notes/engine?ws=…             → { ok, whisper, jev }   is Whisper set up; which Jev gates hold (booleans only)
@@ -111,7 +116,7 @@ const VOCAB_TTL_MS = 60 * 1000;
 const prefixes = ['/api/notes'];
 const POSTS = new Set(['/api/notes/new', '/api/notes/save', '/api/notes/dictate', '/api/notes/record', '/api/notes/transcript',
   '/api/notes/private', '/api/notes/pause', '/api/notes/stop', '/api/notes/summarize', '/api/notes/summarize-agent', '/api/notes/delete', '/api/notes/audio', '/api/notes/label',
-  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/screen', '/api/notes/screen-delete', '/api/notes/clean-audio', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch', '/api/notes/series-done', '/api/notes/series-bring', '/api/notes/series-unbring', '/api/notes/series-member']);
+  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup', '/api/notes/final', '/api/notes/final-setup', '/api/notes/line', '/api/notes/recording-delete', '/api/notes/screen', '/api/notes/screen-delete', '/api/notes/screen-aside', '/api/notes/clean-audio', '/api/notes/link', '/api/notes/bullet', '/api/notes/highlight', '/api/notes/highlight-remove', '/api/notes/final-edit', '/api/notes/wispr-fetch', '/api/notes/series-done', '/api/notes/series-bring', '/api/notes/series-unbring', '/api/notes/series-member']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
 const chains = new Map();      // note id → the promise of its work so far (minute batches, imports, labels, checks)
@@ -674,6 +679,13 @@ function resumeStuck(ctx) {
 
 const send = (ctx, res, r) => ctx.json(res, r, r.ok ? 200 : (r.status || 400));
 
+/** Delete the shots set aside for more than 7 days. At most once in ten minutes unless `now` is true. */
+let asideSweptAt = 0;
+function sweepAsideSoon(dir, now = false) {
+  if (!now && Date.now() - asideSweptAt < 10 * 60000) return;
+  asideSweptAt = Date.now();
+  try { notesScreen.sweepAside(dir); } catch { /* a folder that cannot be read stays as it was */ }
+}
 async function handle(req, res, url, ctx) {
   const p = url.pathname;
   const dir = ctx.runtimeDir;
@@ -683,6 +695,7 @@ async function handle(req, res, url, ctx) {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
     if (p === '/api/notes') {
       const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) });
+      sweepAsideSoon(dir);
       if (l.ok) { sweepExpired(ctx, l.notes); try { l.series_open = notesSeries.openCounts(dir, l.notes); } catch { l.series_open = {}; } }
       send(ctx, res, l); return true;
     }
@@ -697,7 +710,7 @@ async function handle(req, res, url, ctx) {
     if (r.ok && mergeWispr(ctx, nid)) r = notes.read(dir, nid, { resumeMs: resumeMsOf(ctx) });
     if (r.ok) {
       r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid); if (r.recording) r.recording = { ...r.recording, cleaned: notesAudio.hasClean(dir, nid) };
-      r.screen = { frames: r.note.private ? [] : notesScreen.list(dir, nid) };
+      r.screen = { frames: r.note.private ? [] : notesScreen.list(dir, nid), aside: r.note.private ? 0 : notesScreen.asideCount(dir, nid) };
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
       r.bullets_state = bulletsState(ctx, r.note);
       // where the note sits in its meeting series, and what changed since the meeting before (c3-notes-series)
@@ -717,7 +730,16 @@ async function handle(req, res, url, ctx) {
     const r = notes.read(dir, nid);
     if (!r.ok) { send(ctx, res, r); return true; }
     if (r.note.private) { ctx.json(res, { ok: false, error: 'this note is private and keeps no screenshots' }, 404); return true; }
-    notesScreen.serve(req, res, dir, nid, url.searchParams.get('t'));
+    notesScreen.serve(req, res, dir, nid, url.searchParams.get('t'), { aside: url.searchParams.get('aside') === '1' });
+    return true;
+  }
+  if (p === '/api/notes/screen-aside' && req.method === 'GET') {
+    const nid = url.searchParams.get('id');
+    const r = notes.read(dir, nid);
+    if (!r.ok) { send(ctx, res, r); return true; }
+    if (r.note.private) { ctx.json(res, { ok: true, frames: [], days: notesScreen.ASIDE_DAYS }); return true; }
+    sweepAsideSoon(dir, true);
+    ctx.json(res, { ok: true, days: notesScreen.ASIDE_DAYS, frames: notesScreen.listAside(dir, nid).map((f) => ({ t: f.t, w: f.w, h: f.h, bytes: f.bytes, app: f.asideApp || '', text: f.text || '', at: f.asideAt || null })) });
     return true;
   }
   if (p === '/api/notes/recording' && (req.method === 'GET' || req.method === 'HEAD')) {
@@ -915,7 +937,18 @@ async function handle(req, res, url, ctx) {
     if (!own.ok) return done(own);
     if (typeof body.t !== 'number' || !Number.isFinite(body.t) || body.t < 0) return done({ ok: false, status: 400, error: 'a screenshot needs its meeting time' });
     if (typeof body.img !== 'string' || !body.img) return done({ ok: false, status: 400, error: 'there is no picture to keep' });
-    return done(notesScreen.add(dir, { id, t: body.t, buf: Buffer.from(body.img, 'base64'), w: body.w, h: body.h, why: body.why }));
+    return done(notesScreen.add(dir, { id, t: body.t, buf: Buffer.from(body.img, 'base64'), w: body.w, h: body.h, why: body.why, surface: body.surface }));
+  }
+  if (p === '/api/notes/screen-aside') {
+    const r = notes.read(dir, id);
+    if (!r.ok) return done(r);
+    const act = body.action;
+    let out;
+    if (act === 'keep') out = notesScreen.keep(dir, id, body.t);
+    else if (act === 'delete') out = notesScreen.discard(dir, id, body.t);
+    else if (act === 'delete-all') out = notesScreen.discardAll(dir, id);
+    else return done({ ok: false, status: 400, error: 'say action: keep, delete or delete-all' });
+    return done(out.ok ? { ...out, aside: notesScreen.asideCount(dir, id) } : out);
   }
   if (p === '/api/notes/screen-delete') {
     const r = notes.read(dir, id);

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();