create-pmos 0.240.0 → 0.242.0

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

@@ -2,7 +2,8 @@
 /* routes-report-setups.js — the Reports workspace's routes (initiative report-workspace, PRD sections 2 to 6).
  *
  *   GET  /api/report-setups?ws        → { setups: [{ id, name, purpose, audience, source, output, schedule, label, next_draft, last_issued, status, cycles,
- *                                                     copy: { kind, state: none|in-step|pmos-ahead|copy-changed|not-checked, url } }],
+ *                                                     copy: { kind, state: none|in-step|pmos-ahead|copy-changed|not-checked, url },
+ *                                                     structure: { saved, at, charts, sections } | null   the saved report structure (initiative report-structure) }],
  *                                         findings: [{ id, name, why, evidence: [{ kind, text }], confidence: likely|not-sure, proposal }],
  *                                         asks: [{ id, text, state: running|ready|failed, changed, proposal, error }],
  *                                         finder: { cadence, sources: { calendar, slack, mail, drive }, last_run, next_run } }
@@ -119,7 +120,10 @@ function documentsOf(ctx, w) {
   return { docs, reports: r.reports };
 }
 
-function setupOut(s, now, docsOf, idx) {
+/** 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) {
   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;
@@ -129,6 +133,7 @@ function setupOut(s, now, docsOf, idx) {
     id: s.id, name: s.name, purpose: s.purpose, audience: s.audience, source: s.source, output: s.output, schedule: s.schedule, label: RS.scheduleLabel(s.schedule),
     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),
   };
 }
 
@@ -157,7 +162,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)),
+    setups: [...st.setups.values()].map((s) => setupOut(s, new Date(now), docsOf, idx, w.root)),
     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),
@@ -341,7 +346,7 @@ async function handle(req, res, url, ctx) {
     // in place and says why; Draft it now on the row tries again.
     const drafted = firstDraft(root, r, g.actor);
     if (drafted.path) ctx.invalidateNeedsAgg && ctx.invalidateNeedsAgg();
-    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root)), first_draft: r.first_draft, drafted } });
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root), root), first_draft: r.first_draft, drafted } });
   }
   if (sub === 'dismiss') {
     const r = RS.dismissFinding(file, { id: text(body.finding), by: g.actor });
@@ -363,7 +368,7 @@ async function handle(req, res, url, ctx) {
   if (sub === 'pause' || sub === 'resume') {
     const r = RS[sub](root, text(body.id), opts);
     if (!r.ok) return fail(r);
-    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root)) } });
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), documentsOf(ctx, w), copyIndex(root), root) } });
   }
   if (sub === 'from-dashboard') {
     const key = text(body.key);
@@ -376,7 +381,7 @@ async function handle(req, res, url, ctx) {
       schedule: body.schedule, sources: [`The ${name} dashboard`], sections: RS.FRAME.slice(), learned_from: 'Set up from the dashboard.', fixes: [] };
     const r = RS.setUp(root, proposal, opts);
     if (!r.ok) return fail(r);
-    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), { reports: [] }, new Map()) } });
+    return send({ status: 200, body: { ok: true, setup: setupOut(r.setup, new Date(), { reports: [] }, new Map(), root) } });
   }
   if (sub === 'finder') {
     const r = RS.setFinder(file, { cadence: body.cadence, sources: body.sources, by: g.actor });