create-pmos 0.241.0 → 0.242.0

package/workspace/lib/notes-screen.js

@@ -8,6 +8,10 @@
  *   getOn(runtimeDir) · setOn(runtimeDir, bool)   "Capture the shared screen", on by default, for this machine
  *   ocrDetect({ env? }) → { bin } | null      the tesseract the PM installed
  *   ocrIdle() → Promise                       resolves when the text queue is empty (tests)
+ *   classifyShot(text, { hints? }) → { aside, app, call }   does the text of a shot look like another app and not like the call? Pure.
+ *   listAside(runtimeDir, id) · asideCount(runtimeDir, id)   the shots set aside for review
+ *   keep(runtimeDir, id, t) · discard(runtimeDir, id, t) · discardAll(runtimeDir, id)   the PM's answer to a set-aside shot
+ *   sweepAside(runtimeDir, { now?, days? }) → n   delete the shots set aside for more than 7 days
  *
  * WHAT IT KEEPS. A folder next to the note's audio, `<runtime>/notes/recordings/<id>.screen/`: one image file per shot, named by
  * its meeting time in milliseconds (`000123456.jpg`), and `index.json`, an array of { t, file, w, h, bytes, why?, text? } sorted by t,
@@ -22,6 +26,13 @@
  * kept shot is read for its text, one at a time and in the background, and the text is added to that shot's row in the index.
  * A failed or timed-out read leaves the shot with no text and is not an error. Without tesseract nothing is read.
  *
+ * SET ASIDE. When the picture is the whole screen (the shot's `surface` is 'monitor'), every app the PM switches to is on it. After the
+ * text is read, a shot whose text looks like another app (Slack, a mailbox, a chat) and not like the call (Zoom's or Meet's controls) or
+ * what is shared in it is marked `aside: true` in the index. A set-aside shot is not listed and not served by default, so the note, the
+ * replay and the agent never see it. The PM reviews them (listAside) and answers each one: Keep it (the shot joins the note), Delete
+ * (file and row go) or Delete all. sweepAside deletes the shots set aside for more than 7 days. A shot with no text, a shot from a
+ * window or a tab, and every shot on a machine with no tesseract are kept, as before.
+ *
  * WHAT IT NEVER DOES. It sends nothing and opens no network module. The only program it runs is the tesseract the PM installed,
  * on a file in the note's own folder, with no shell and a time limit. The routes (lib/routes-notes.js) keep no shot for a private
  * note, for a note that is not listening, or when the PM switched capturing off, and delete the folder when a note is made
@@ -37,6 +48,8 @@ const MAX_BYTES = 500 * 1024 * 1024;
 const MAX_T = 999999999;                    // the file name holds nine digits of milliseconds
 const OCR_TIMEOUT_MS = 30000;
 const OCR_MAX_CHARS = 4000;
+const ASIDE_DAYS = 7;
+const SURFACES = ['window', 'browser', 'monitor'];
 const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
 const FILE_RE = /^\d{9}\.(jpg|png|webp)$/;
 const TYPES = { jpg: 'image/jpeg', png: 'image/png', webp: 'image/webp' };
@@ -80,7 +93,7 @@ const writeIndex = (runtimeDir, id, rows) => writeAtomic(indexOf(runtimeDir, id)
 const dimension = (n) => (Number.isFinite(Number(n)) && Number(n) > 0 ? Math.min(20000, Math.round(Number(n))) : 0);
 
 /** Keep one shot. `t` is the meeting time in ms, `buf` the image bytes, `w` and `h` its size in pixels. */
-function add(runtimeDir, { id, t, buf, w, h, why } = {}) {
+function add(runtimeDir, { id, t, buf, w, h, why, surface } = {}) {
   if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
   const time = typeof t === 'number' ? t : NaN;
   if (!Number.isFinite(time) || time < 0 || time > MAX_T) return { ok: false, status: 400, error: 'a screenshot needs its meeting time' };
@@ -106,27 +119,36 @@ function add(runtimeDir, { id, t, buf, w, h, why } = {}) {
   // why the page kept it (the screen changed, a line pointed at it, a highlight): plain words, kept short
   const reason = typeof why === 'string' ? why.replace(/\s+/g, ' ').trim().slice(0, 120) : '';
   if (reason) frame.why = reason;
+  // what the picture shows: the meeting's window, a browser tab or the whole screen; only the whole screen is checked for other apps
+  if (SURFACES.includes(surface)) frame.surface = surface;
   writeIndex(runtimeDir, id, others.concat([frame]).sort((x, y) => x.t - y.t));
   queueOcr(runtimeDir, id, frame);
   return { ok: true, frame };
 }
 
-function list(runtimeDir, id) {
+/** The note's shots, by meeting time. A set-aside shot is not in this list. */
+function list(runtimeDir, id, { aside = false } = {}) {
+  if (!ID_RE.test(String(id || ''))) return [];
+  return readIndex(runtimeDir, id).filter((f) => !!f.aside === !!aside);   // { aside: true } lists the set-aside shots instead
+}
+/** The shots set aside for review, by meeting time. */
+function listAside(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return [];
-  return readIndex(runtimeDir, id);
+  return readIndex(runtimeDir, id).filter((f) => f.aside);
 }
+const asideCount = (runtimeDir, id) => listAside(runtimeDir, id).length;
 
 /** The shot at meeting time `t` as its image. A shot is never changed once kept, so the browser may keep it for good. */
-function serve(req, res, runtimeDir, id, t) {
+function serve(req, res, runtimeDir, id, t, { aside = false } = {}) {
   const miss = () => { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: 'this note has no screenshot at that time' })); };
   if (!ID_RE.test(String(id || '')) || t === null || t === undefined || t === '' || !Number.isFinite(Number(t))) return miss();
   const at = Math.round(Number(t));
-  const f = readIndex(runtimeDir, id).find((x) => x.t === at);
+  const f = readIndex(runtimeDir, id).find((x) => x.t === at && !!x.aside === !!aside);   // a set-aside shot is served only for the review
   if (!f) return miss();
   const file = path.join(dirOf(runtimeDir, id), f.file);
   let size;
   try { size = fs.statSync(file).size; } catch { return miss(); }
-  res.writeHead(200, { 'Content-Type': TYPES[path.extname(f.file).slice(1)] || 'application/octet-stream', 'Content-Length': size, 'Cache-Control': 'private, max-age=31536000, immutable' });
+  res.writeHead(200, { 'Content-Type': TYPES[path.extname(f.file).slice(1)] || 'application/octet-stream', 'Content-Length': size, 'Cache-Control': aside ? 'private, no-store' : 'private, max-age=31536000, immutable' });
   if (req.method === 'HEAD') { res.end(); return; }
   fs.createReadStream(file).on('error', () => res.end()).pipe(res);
 }
@@ -140,6 +162,95 @@ function remove(runtimeDir, id) {
   return had;
 }
 
+/* ── set aside: the PM's answer ──────────────────────────────────────────────────────────────────── */
+const rmFile = (runtimeDir, id, f) => { try { fs.unlinkSync(path.join(dirOf(runtimeDir, id), f.file)); } catch { /* none */ } };
+const asideRow = (rows, t) => rows.find((f) => f.t === Math.round(Number(t)) && f.aside);
+/** Keep it: the shot joins the note, and it is not checked again. */
+function keep(runtimeDir, id, t) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const row = asideRow(rows, t);
+  if (!row) return { ok: false, status: 404, error: 'that shot is not set aside' };
+  delete row.aside; delete row.asideApp; delete row.asideAt;
+  row.kept = true;
+  writeIndex(runtimeDir, id, rows);
+  return { ok: true, frame: row };
+}
+/** Delete: the file and its row go. Only a set-aside shot can be deleted here. */
+function discard(runtimeDir, id, t) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const row = asideRow(rows, t);
+  if (!row) return { ok: false, status: 404, error: 'that shot is not set aside' };
+  rmFile(runtimeDir, id, row);
+  writeIndex(runtimeDir, id, rows.filter((f) => f !== row));
+  return { ok: true, deleted: 1 };
+}
+/** Delete all: every set-aside shot of the note. The kept shots stay. */
+function discardAll(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const gone = rows.filter((f) => f.aside);
+  if (!gone.length) return { ok: true, deleted: 0 };
+  for (const f of gone) rmFile(runtimeDir, id, f);
+  writeIndex(runtimeDir, id, rows.filter((f) => !f.aside));
+  return { ok: true, deleted: gone.length };
+}
+/** Delete every shot set aside for more than `days` days, in every note. Returns how many went. */
+function sweepAside(runtimeDir, { now = Date.now(), days = ASIDE_DAYS } = {}) {
+  let names = [];
+  try { names = fs.readdirSync(path.join(runtimeDir, 'notes', 'recordings')); } catch { return 0; }
+  let n = 0;
+  for (const name of names) {
+    if (!name.endsWith('.screen')) continue;
+    const id = name.slice(0, -'.screen'.length);
+    if (!ID_RE.test(id)) continue;
+    const rows = readIndex(runtimeDir, id);
+    if (!rows.some((f) => f.aside)) continue;
+    const left = rows.filter((f) => {
+      if (!f.aside || !Number.isFinite(f.asideAt) || now - f.asideAt < days * 864e5) return true;
+      rmFile(runtimeDir, id, f); n++; return false;
+    });
+    if (left.length !== rows.length) { try { writeIndex(runtimeDir, id, left); } catch { /* the folder went away */ } }
+  }
+  return n;
+}
+
+/* ── what looks like another app ─────────────────────────────────────────────────────────────────── */
+// The call: the controls of Zoom, Meet and Teams, and what each says while someone shares. Any one of these keeps the shot.
+const CALL = /\b(unmute|mute|stop video|start video|participants?|share screen|stop share(?:ing)?|new share|you are screen sharing|you are viewing|you'?re presenting|stop presenting|present now|presenting|raise hand|lower hand|breakout rooms?|leave meeting|leave call|end meeting|meeting controls|zoom meeting|zoom workplace|meet\.google\.com|google meet|turn (?:on|off) camera|turn (?:on|off) microphone|live captions|waiting room|in this meeting|hide self view|gallery view|speaker view)\b/i;
+// Another app. `strong`: one is enough. `weak`: two different ones are needed.
+const OTHER = [
+  { app: 'Slack', strong: [/\bslack\b/i], weak: [/\bdirect messages\b/i, /\bchannels\b/i, /\bthreads\b/i, /\bhuddles?\b/i, /\bmentions (?:&|and) reactions\b/i, /\bmessage #[a-z0-9_-]+/i] },
+  { app: 'Gmail', strong: [/\bgmail\b/i, /\binbox\b/i], weak: [/\bcompose\b/i, /\bstarred\b/i, /\bsnoozed\b/i, /\bsent mail\b/i, /\bdrafts\b/i, /\bprimary\b/i, /\bpromotions\b/i] },
+  { app: 'Outlook', strong: [/\boutlook\b/i], weak: [/\bnew mail\b/i, /\bjunk email\b/i, /\bsent items\b/i, /\bfocused\b/i] },
+  { app: 'WhatsApp', strong: [/\bwhatsapp\b/i], weak: [] },
+  { app: 'Telegram', strong: [/\btelegram\b/i], weak: [] },
+  { app: 'Discord', strong: [/\bdiscord\b/i], weak: [] },
+  { app: 'Messages', strong: [/\bimessage\b/i, /\bmessenger\b/i], weak: [] },
+  { app: 'Social media', strong: [/\bfacebook\b/i, /\binstagram\b/i, /\btwitter\b/i, /\blinkedin\b/i, /\btiktok\b/i], weak: [] },
+  { app: 'Video or music', strong: [/\byoutube\b/i, /\bnetflix\b/i, /\bspotify\b/i], weak: [] },
+];
+
+/** Does the text of a shot look like another app and not like the call? Pure.
+ *  → { aside, app, call }. `hints` are words from what is shared in the meeting (a deck's title, say): a shot that names one is kept.
+ *  Text that is empty, or that names no app, is never set aside. */
+function classifyShot(text, { hints = [] } = {}) {
+  const t = String(text || '');
+  if (!t.trim()) return { aside: false, app: null, call: false };
+  if (CALL.test(t)) return { aside: false, app: null, call: true };
+  const low = t.toLowerCase();
+  for (const h of hints || []) { const w = String(h || '').trim().toLowerCase(); if (w.length >= 4 && low.includes(w)) return { aside: false, app: null, call: false }; }
+  for (const o of OTHER) {
+    if (o.strong.some((re) => re.test(t)) || o.weak.filter((re) => re.test(t)).length >= 2) return { aside: true, app: o.app, call: false };
+  }
+  return { aside: false, app: null, call: false };
+}
+// the words of what is shared in the meeting, for classifyShot: set by whoever knows them (the material of the meeting), else none
+let hintsOf = null;
+/** fn(runtimeDir, id) → [word]: what is shared in this note's meeting. Optional. */
+function setHints(fn) { hintsOf = typeof fn === 'function' ? fn : null; }
+
 /* ── on-screen text ──────────────────────────────────────────────────────────────────────────────── */
 const isExec = (f) => { try { fs.accessSync(f, fs.constants.X_OK); return fs.statSync(f).isFile(); } catch { return false; } };
 /** The tesseract on this machine: PMOS_TESSERACT, else the PATH, else where Homebrew puts it. */
@@ -168,7 +279,16 @@ function readText(bin, runtimeDir, id, frame) {
         // patch the row only if the same shot is still there (it may have been replaced or deleted while it was read)
         const rows = readIndex(runtimeDir, id);
         const row = rows.find((f) => f.t === frame.t && f.file === frame.file && f.bytes === frame.bytes);
-        if (row) { row.text = text; try { writeIndex(runtimeDir, id, rows); } catch { /* the folder went away */ } }
+        if (row) {
+          row.text = text;
+          // the whole screen was the picture: a shot that looks like another app is set aside, for the PM to keep or delete
+          if (row.surface === 'monitor' && !row.kept) {
+            let hints = []; try { hints = hintsOf ? hintsOf(runtimeDir, id) || [] : []; } catch { hints = []; }
+            const c = classifyShot(text, { hints });
+            if (c.aside) { row.aside = true; row.asideApp = c.app; row.asideAt = Date.now(); }
+          }
+          try { writeIndex(runtimeDir, id, rows); } catch { /* the folder went away */ }
+        }
       }
       resolve();
     });
@@ -177,4 +297,4 @@ function readText(bin, runtimeDir, id, frame) {
 /** Resolves when every text read queued so far has ended. */
 function ocrIdle() { return queue.then(() => (waiting > 0 ? ocrIdle() : undefined)); }
 
-module.exports = { add, list, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };
+module.exports = { add, list, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };

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/package-lock.json

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

package/workspace/package.json

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