create-pmos 0.133.0 → 0.135.0

package/workspace/lib/routes-notes.js

@@ -2,7 +2,7 @@
 /* routes-notes.js — the Notes view's routes (meeting-notes, Runs 1 to 4; lib/route-modules.js).
  *
  *   GET  /api/notes                         → { ok, notes: [row] }            newest first; a row never carries the body
- *   GET  /api/notes/one?id=…                → { ok, note, bullets_state, audio, recording }   imports an agent summary and the agent's
+ *   GET  /api/notes/one?id=…                → { ok, note, bullets_state, audio, recording, screen: { frames: [{ t, file, w, h, bytes, why?, text? }] } }   imports an agent summary and the agent's
  *                                                   minute bullets written since the last read (Run 8). note.bullets:
  *                                                   [{ id, t, minute, text, owner, cat, cat_by, by: 'agent', open?, check?, dropped? }];
  *                                                   an open bullet has cat null. bullets_state: { agent: 'on'|'off'|'failed',
@@ -15,7 +15,7 @@
  *   POST /api/notes/save       { id, title?, body? }      → { ok, updated_at, versions, added }   each new line of the notes is also
  *                                                   a transcript line, source 'typed' (`added`, Run 8)
  *   POST /api/notes/dictate    { text }     → { ok, ops }  one dictated phrase as insert operations (lib/notes.js dictation)
- *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from, clock_from, meeting_ms }    `ws` is the repository the note's lines are checked against;
+ *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from, clock_from, meeting_ms, capture: { token, base_ms } } `ws` is the repository the note's lines are checked against;
  *                                             clock_from is the first Listen moved on by the time listening was stopped
  *   POST /api/notes/pause      { id }       → { ok, meeting_ms, state, paused_at, resume_until, ended_at, ended_by, sessions }
  *                                             a resumable pause (Run 13, R51): the clock stops, the meeting stays open for one hour
@@ -28,17 +28,25 @@
  *   ended. A row and a note carry state ('idle'|'recording'|'paused'|'ended'), paused_at, resume_until, ended_at, ended_by, sessions
  *   and meeting.context (the snapshot of the meeting, lib/notes.js cleanContext; R59).
  *   POST /api/notes/transcript { id, text, source? } → { ok, added: [{ at, t, text, source, cat, index }] }
- *   POST /api/notes/audio      { id, source, pcm, final? } → { ok, cut }   16 kHz mono 16-bit samples, base64; local Whisper (D91)
+ *   POST /api/notes/audio      { id, source, pcm, final?, cap?, seq?, off? } → { ok, cut, dup? }   16 kHz mono 16-bit samples, base64; local Whisper (D91);
+ *                                             cap/seq/off name the chunk's capture, sequence number and sample offset (lib/notes-capture.js)
  *   POST /api/notes/label      { id, index, cat }           → { ok, segment }   the PM's own label for a line
  *   POST /api/notes/speaker    { id, source, name }         → { ok, speakers }
  *   POST /api/notes/line       { id, index, cat?, summary?, tags?, people?, text? } → { ok, segment, summary }   the PM's correction (Run 3)
  *   GET  /api/notes/recording?id=…          → audio/wav, with byte ranges    the note's kept audio (Run 3, D92)
  *   POST /api/notes/recording-delete { id } → { ok }    deletes the note's audio and keeps the rest
+ *   POST /api/notes/screen    { id, cap, t, img, w, h, why? } → { ok, frame }   one screenshot of the shared screen (notes-screen-capture): img is the
+ *                                             picture as base64 (JPEG, PNG or WebP, 2 MB at most), t its meeting time in ms, cap the capture's token.
+ *                                             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
+ *   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)
  *   POST /api/notes/switch     { ws, jev?, check? }         → { ok, jev }   the two D91 switches, default off
- *                              { language?, model?, accuracy?, keep_audio? } → { ok, whisper } the language, the model, the decoding
- *                                                   ('fast' | 'accurate') and keeping audio, for this machine
+ *                              { language?, model?, accuracy?, keep_audio?, screen? } → { ok, whisper } the language, the model, the decoding
+ *                                                   ('fast' | 'accurate'), keeping audio and capturing the shared screen, for this machine.
+ *                                                   whisper.screen is that switch; whisper.ocr says whether tesseract was found
  *   POST /api/notes/whisper-setup { ws? }   → { ok, started, session, command }   a terminal with the setup typed in, not run
  *   POST /api/notes/private    { id, private }            → { ok, private }
  *   POST /api/notes/summarize  { id, ws?, prefer? }  → { ok, summary, initiative, source, agent? }   the local summary; with ws and
@@ -74,8 +82,10 @@
 const guard = require('./pm-guard.js');
 const notes = require('./notes.js');
 const whisper = require('./notes-whisper.js');
+const notesCapture = require('./notes-capture.js');
 const notesRepo = require('./notes-repo.js');
 const notesAudio = require('./notes-audio.js');
+const notesScreen = require('./notes-screen.js');
 const notesEcho = require('./notes-echo.js');
 const notesPolish = require('./notes-polish.js');
 const notesFinal = require('./notes-final.js');
@@ -93,7 +103,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/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/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']);
 
 /* ── 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)
@@ -276,8 +286,12 @@ function handToAgent(ctx, id, note, b) {
   const h = notes.minuteHandoff(dir, { id, minute: b.minute, lines: b.lines, context: b.context, final: b.final, terms: repoTermsFor(ctx, note) });
   if (!h.ok) return false;
   if (m.agent === 'on' && m.session && typeof ctx.sendToSession === 'function' && ctx.sendToSession(m.session, notes.bulletsFollowUp(h))) return true;
+  // workspace-headless-jobs R6: a headless bullets run takes no follow-up. While one is still working, this minute waits
+  // for the next run, which writes every earlier minute that has no bullets yet. The last minute never waits.
+  if (m.agent === 'on' && m.session && !b.final && typeof ctx.headlessBusy === 'function' && ctx.headlessBusy(m.session)) return true;
   const w = note.ws ? ctx.getWs(note.ws) : null;
-  const s = ctx.spawnSession({ name: 'notes: bullets', agent: cmd, ws: w ? w.id : undefined, origin: 'notes-bullets:' + id, initialInput: notes.bulletsPrompt(h) + '\r' });
+  const s = ctx.spawnSession({ name: 'notes: bullets', agent: cmd, ws: w ? w.id : undefined, origin: 'notes-bullets:' + id, initialInput: notes.bulletsPrompt(h) + '\r',
+    addDirs: [h.folder] });
   const started = !!s && s.state !== 'exited';
   if (!started) {
     try { fs.unlinkSync(h.md); } catch { /* gone */ }
@@ -381,6 +395,7 @@ function liveRun(ctx, args) {
 }
 let transcriber = null; let transcriberDir = null;
 const audioErrors = new Map();   // note id → the last thing that went wrong, for the page
+const fedHere = new Set();       // `${id}|${source}|${token}` this process has had chunks of: the first one after a restart picks up what was lost
 function transcriberFor(ctx) {
   if (transcriber && transcriberDir === ctx.runtimeDir) return transcriber;
   transcriberDir = ctx.runtimeDir;
@@ -389,11 +404,27 @@ function transcriberFor(ctx) {
     detect: () => liveDetect(ctx),
     run: (args) => liveRun(ctx, args),
     vocab: ({ id }) => vocabFor(ctx, id),
+    // the note's meeting lines of the last minute, for the live echo check
+    recent: (id) => {
+      const r = notes.read(ctx.runtimeDir, id);
+      if (!r.ok) return [];
+      const tr = r.note.transcript || []; const last = tr.length ? tr[tr.length - 1].t || 0 : 0;
+      return tr.filter((x) => x && x.source === 'meeting' && (x.t || 0) >= last - 60000).map((x) => ({ source: 'meeting', t: x.t || 0, end: Number.isFinite(x.t_end) ? x.t_end : (x.t || 0), text: x.text }));
+    },
+    // the last line of a source, for the repetition guard after a restart
+    lastLine: (id, source) => {
+      const r = notes.read(ctx.runtimeDir, id);
+      const tr = r.ok ? r.note.transcript || [] : [];
+      for (let k = tr.length - 1; k >= 0; k--) if (tr[k] && tr[k].source === source) return { text: tr[k].text, t: tr[k].t || 0 };
+      return null;
+    },
     onText: async (c) => {
-      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t, ms: c.ms });
+      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t, ms: c.ms, heard_as: c.heard_as });
       if (r.ok) { audioErrors.delete(c.id); arm(ctx, c.id); }
     },
     onError: (c) => { audioErrors.set(c.id, { at: new Date().toISOString(), error: c.error }); },
+    // how far the live transcription has cut each source, kept with the capture so a restart picks up what it had buffered
+    onCut: (c) => { try { notesCapture.setCut(ctx.runtimeDir, c.id, { source: c.source, sample: Math.round(c.until * whisper.RATE / 1000) }); } catch { /* best effort */ } },
   });
   return transcriber;
 }
@@ -403,7 +434,7 @@ function engineInfo(ctx, w) {
   const out = { ready: live.ready, live: live.ready ? live.engine : null, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size,
     language: whisper.getLanguage(ctx.runtimeDir), languages: whisper.LANGUAGES.map(([value, label]) => ({ value, label })),
     model: whisper.getModel(ctx.runtimeDir), models: whisper.MODELS.map((m) => ({ value: m.id, label: m.label })),
-    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir), clean_audio: notesAudio.getClean(ctx.runtimeDir), ffmpeg: !!notesPolish.detect(),
+    accuracy: whisper.getAccuracy(ctx.runtimeDir), accuracies: whisper.ACCURACIES.map((a) => ({ value: a.id, label: a.label })), keep_audio: notesAudio.getKeep(ctx.runtimeDir), clean_audio: notesAudio.getClean(ctx.runtimeDir), ffmpeg: !!notesPolish.detect(), screen: notesScreen.getOn(ctx.runtimeDir), ocr: !!notesScreen.ocrDetect(),
     final: finalInfo(ctx), wispr: wisprOn(ctx) };
   if (!w) return { whisper: out, jev: null };
   const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
@@ -596,12 +627,21 @@ 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) };
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
       r.bullets_state = bulletsState(ctx, r.note);
     }
     send(ctx, res, r);
     return true;
   }
+  if (p === '/api/notes/screen' && (req.method === 'GET' || req.method === 'HEAD')) {
+    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: false, error: 'this note is private and keeps no screenshots' }, 404); return true; }
+    notesScreen.serve(req, res, dir, nid, url.searchParams.get('t'));
+    return true;
+  }
   if (p === '/api/notes/recording' && (req.method === 'GET' || req.method === 'HEAD')) {
     const nid = url.searchParams.get('id');
     const r = notes.read(dir, nid);
@@ -669,8 +709,13 @@ async function handle(req, res, url, ctx) {
     const rm = resumeMsOf(ctx);
     // a pause that ran out ends the meeting first (final notes and all), then the record is refused
     endMeeting(ctx, id, 'timeout');
+    // one capture per note: another tab or window that is sending this note's audio keeps it (notes-recording-reliability)
+    if (notesCapture.busy(dir, id)) return done({ ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' });
     const r = notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id, resumeMs: rm });
     if (r.ok) {
+      // the page names each chunk's place from here: the capture's token, and the meeting time it starts at
+      const c = notesCapture.start(dir, id, { baseMs: r.meeting_ms });
+      if (c.ok) r.capture = { token: c.token, base_ms: c.base_ms };
       clearExpiry(id); swept.delete(id);
       // a new Listen tries the agent again when it could not start last time
       const cur = notes.read(dir, id);
@@ -685,6 +730,7 @@ async function handle(req, res, url, ctx) {
   }
   if (p === '/api/notes/pause') {
     const r = notes.pause(dir, { id, resumeMs: resumeMsOf(ctx) });
+    notesCapture.close(dir, id);
     // listening stopped: the minute timer stops, and what was said since the last minute is one more batch.
     // The meeting stays open: Wispr Flow and the final pass wait for Stop or for the hour to run out.
     if (r.ok) { disarm(id); runMinute(ctx, id, { final: true }); if (r.state === 'paused') armExpiry(ctx, id, r.resume_until); }
@@ -692,6 +738,7 @@ async function handle(req, res, url, ctx) {
   }
   if (p === '/api/notes/stop') {
     const r = notes.stop(dir, { id, resumeMs: resumeMsOf(ctx) });
+    notesCapture.close(dir, id);
     if (r.ok) { clearExpiry(id); swept.add(id); disarm(id); runMinute(ctx, id, { final: true }); scheduleWispr(ctx, id); }
     return done(r);
   }
@@ -718,15 +765,41 @@ async function handle(req, res, url, ctx) {
     if (pcm24 && pcm24.length % 2) return done({ ok: false, status: 400, error: 'the audio must be 16-bit samples' });
     if (!liveDetect(ctx).ready) return done({ ok: false, status: 409, error: 'local transcription is not set up' });
     const ms = (pcm.length / 2 / whisper.RATE) * 1000;
-    const t = Math.max(0, notes.meetingMs(note.note) - ms);
+    // A chunk that names its capture (notes-recording-reliability) is placed at the capture's start plus its offset, and a sequence
+    // number already written is answered as done and neither written nor transcribed again. A chunk with no token keeps the old
+    // placement by arrival time, unless a capture with a token is live: then it comes from a second tab and is refused.
+    let t; let sample = null; let cap = null;
+    if (body.cap !== undefined) {
+      cap = notesCapture.check(dir, id, { token: String(body.cap), source, seq: body.seq });
+      if (!cap.ok) return done(cap);
+      if (cap.dup) return done({ ok: true, cut: false, dup: true });
+      const off = Number(body.off);
+      if (!Number.isInteger(off) || off < 0) return done({ ok: false, status: 400, error: 'a chunk needs its sample offset' });
+      sample = Math.round(cap.base_ms * whisper.RATE / 1000) + off;
+      t = (sample / whisper.RATE) * 1000;
+    } else {
+      if (notesCapture.tokened(dir, id)) return done({ ok: false, status: 409, error: 'this meeting is already being recorded in another tab or window' });
+      t = Math.max(0, notes.meetingMs(note.note) - ms);
+    }
     // the audio is kept for replay unless the PM switched that off (D92); a private note never reaches this line
     arm(ctx, id);
     // each source is also kept apart for the final pass after Stop, which deletes it when the PM keeps no audio (Run 9)
     // a 24 kHz chunk must cover the same time as the 16 kHz chunk (to a tenth of a second); one that does not is not kept
     const sameTime = !!pcm24 && pcm24.length > 0 && Math.abs(pcm24.length / 2 / notesAudio.HI_RATE - pcm.length / 2 / whisper.RATE) <= 0.1;
     if (pcm24 && pcm24.length && !sameTime) audioErrors.set(id, { at: new Date().toISOString(), error: 'the 24 kHz audio of one chunk did not match its 16 kHz audio, so the replay has a gap there' });
-    { try { notesAudio.write(dir, { id, source, pcm, pcm24: sameTime ? pcm24 : null, t, mixed: notesAudio.getKeep(dir) }); } catch (e) { audioErrors.set(id, { at: new Date().toISOString(), error: 'the audio was not kept: ' + ((e && e.message) || e) }); } }
-    return done(transcriberFor(ctx).push({ id, source, pcm, t, final: body.final === true }));
+    { try { notesAudio.write(dir, { id, source, pcm, pcm24: sameTime ? pcm24 : null, t, sample, mixed: notesAudio.getKeep(dir) }); } catch (e) { audioErrors.set(id, { at: new Date().toISOString(), error: 'the audio was not kept: ' + ((e && e.message) || e) }); } }
+    const tr = transcriberFor(ctx);
+    if (cap && !fedHere.has(id + '|' + source + '|' + body.cap)) {
+      fedHere.add(id + '|' + source + '|' + body.cap);
+      if (fedHere.size > 400) fedHere.delete(fedHere.values().next().value);
+      // after a restart, what this source said since its last cut was written but never transcribed: transcribe it first
+      const gap = notesCapture.untranscribed(dir, id, { source, before: sample });
+      const back = gap ? notesAudio.readSource(dir, id, source, gap.from, gap.to) : null;
+      if (back && back.pcm.length) tr.push({ id, source, pcm: back.pcm, t: (back.from / whisper.RATE) * 1000, exact: true });
+    }
+    const pushed = tr.push({ id, source, pcm, t, final: body.final === true, exact: !!cap });
+    if (cap) notesCapture.mark(dir, id, { source, seq: body.seq, end: sample + pcm.length / 2 });
+    return done(pushed);
   }
   if (p === '/api/notes/label') return done(notes.setLabel(dir, { id, index: Number(body.index), cat: body.cat, drop: body.drop === true }));
   if (p === '/api/notes/speaker') {
@@ -749,6 +822,23 @@ async function handle(req, res, url, ctx) {
     if (!r.ok) return done(r);
     return done({ ok: true, deleted: notesAudio.remove(dir, id) });
   }
+  if (p === '/api/notes/screen') {
+    const note = notes.read(dir, id);
+    if (!note.ok) return done(note);
+    if (note.note.private) return done({ ok: false, status: 409, error: 'this note is marked private, so nothing more is kept in it' });
+    if (!note.note.recorded_from) return done({ ok: false, status: 409, error: 'press Listen first' });
+    if (!notesScreen.getOn(dir)) return done({ ok: false, status: 409, error: 'Capture the shared screen is switched off in Settings' });
+    const own = notesCapture.owns(dir, id, { token: body.cap });
+    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 }));
+  }
+  if (p === '/api/notes/screen-delete') {
+    const r = notes.read(dir, id);
+    if (!r.ok) return done(r);
+    return done({ ok: true, deleted: notesScreen.remove(dir, id) });
+  }
   if (p === '/api/notes/clean-audio') {
     // the PM asks for the cleaned copy of one note now; the work goes on in the background and the replay changes when it ends
     const r = notes.read(dir, id);
@@ -765,6 +855,13 @@ async function handle(req, res, url, ctx) {
     if (body.wispr !== undefined) {
       if (typeof body.wispr !== 'boolean') { ctx.json(res, { ok: false, error: 'say wispr: true or wispr: false' }, 400); return true; }
       setWisprOn(dir, body.wispr);
+      if (body.language === undefined && body.model === undefined && body.accuracy === undefined && body.keep_audio === undefined && body.clean_audio === undefined && body.jev === undefined && body.check === undefined && body.screen === undefined) {
+        ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true;
+      }
+    }
+    if (body.screen !== undefined) {
+      const sc = notesScreen.setOn(dir, body.screen);
+      if (!sc.ok) { ctx.json(res, { ok: false, error: sc.error }, 400); return true; }
       if (body.language === undefined && body.model === undefined && body.accuracy === undefined && body.keep_audio === undefined && body.clean_audio === undefined && body.jev === undefined && body.check === undefined) {
         ctx.json(res, { ok: true, ...engineInfo(ctx, o.ok ? o.w : null) }); return true;
       }
@@ -808,7 +905,7 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/private') {
     vocabCache.delete(id);
     const r = notes.setPrivate(dir, { id, private: body.private });
-    if (r.ok && r.private) { clearExpiry(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); }
+    if (r.ok && r.private) { clearExpiry(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); notesAudio.remove(dir, id); notesCapture.remove(dir, id); notesScreen.remove(dir, id); }
     return done(r);
   }
   if (p === '/api/notes/summarize') {
@@ -837,7 +934,7 @@ async function handle(req, res, url, ctx) {
     }
     return done(r);
   }
-  if (p === '/api/notes/delete') { clearExpiry(id); swept.delete(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); const r = notes.remove(dir, id); if (r.ok) notesAudio.remove(dir, id); return done(r); }
+  if (p === '/api/notes/delete') { clearExpiry(id); swept.delete(id); disarm(id); unwatchLate(id); cancelFinal(ctx, id); unwatchWispr(id); if (transcriber) transcriber.drop(id); const r = notes.remove(dir, id); if (r.ok) { notesAudio.remove(dir, id); notesCapture.remove(dir, id); notesScreen.remove(dir, id); } return done(r); }
   if (p === '/api/notes/highlight') {
     // the PM's highlight: the transcript of the window, then Jev's label and the repository check of its text
     const r = notes.addHighlight(dir, { id, from: body.from, to: body.to });
@@ -886,7 +983,8 @@ function startAgent(ctx, dir, id, w) {
     notes.agentStarted(dir, { id, started: false, reason: 'this workspace cannot start sessions' });
     return { ok: true, started: false, session: null, reason: 'this workspace cannot start sessions', handoff: h.handoff, out: h.out, withheld: h.withheld };
   }
-  const s = ctx.spawnSession({ name: 'notes: summary', agent: 'claude', ws: w ? w.id : undefined, origin: 'notes-summary:' + id, initialInput: h.prompt + '\r' });
+  const s = ctx.spawnSession({ name: 'notes: summary', agent: 'claude', ws: w ? w.id : undefined, origin: 'notes-summary:' + id, initialInput: h.prompt + '\r',
+    addDirs: [...new Set([path.dirname(h.handoff), path.dirname(h.out)])] });
   const started = !!s && s.state !== 'exited';
   const reason = started ? '' : ((s && s.note) || 'could not start a claude session');
   notes.agentStarted(dir, { id, session: s ? s.id : null, started, reason });

package/workspace/lib/routes-outbox.js

@@ -5,6 +5,7 @@
  *                                              claims: { ok, refused: [line] }, last_result }], channels }
  *   POST /api/outbox/draft   { channel, recipient, subject?, body } → { ok, entry }   origin is 'pm' (a page press)
  *   POST /api/outbox/edit    { id, body }                 → { ok, entry }   a new hash; the old hash is void
+ *   POST /api/outbox/discard { id, undo? }                → { ok }   hides a draft (undo: true brings it back); a sent entry is refused
  *   POST /api/outbox/confirm { id, hash, reason? }        → { ok:false, reason:'no channel connected' }  entry stays queued
  *                                                          → 422 { ok:false, state:'blocked', refused } when a claim fails the trust rules
  *                                                            and no written reason is given; with a reason it is an override (recorded)
@@ -17,7 +18,8 @@
  * The handlers are pure over (req, body, runtimeDir) so a test needs no server.
  */
 const guard = require('./pm-guard.js');
-const outbox = require('../../scripts/outbox.js');
+const { repoScript } = require('./repo-script.js');
+const outbox = require(repoScript('outbox.js'));
 const store = require('./outbox-store.js');
 const crypto = require('crypto');
 
@@ -57,6 +59,24 @@ function edit(req, body, runtimeDir, now = new Date()) {
   return { status: 200, body: { ok: true, entry: view({ ...e, last_result: null }), voided_hash: cur.hash } };
 }
 
+/* Discard one draft from the queue (Reports > Drafts), or take the discard back (undo: true). The line stays in the log; the fold hides the entry.
+ * A sent entry is not discarded: it is a record of what left. */
+function discard(req, body, runtimeDir, now = new Date()) {
+  const bad = guarded(req, body); if (bad) return bad;
+  const all = store.readLines(store.outboxFile(runtimeDir));
+  const id = String(body.id || '');
+  if (body.undo === true) {
+    if (!all.some((l) => l && l.id === id && l.event === 'discarded')) return fail(404, 'no discarded outbox entry with that id');
+    store.appendEvent(runtimeDir, { event: 'restored', id }, now);
+    return { status: 200, body: { ok: true, id, restored: true } };
+  }
+  const cur = store.readOutbox(runtimeDir).find((e) => e.id === id);
+  if (!cur) return fail(404, 'no such outbox entry');
+  if (cur.state === 'sent') return fail(409, 'a sent entry is a record and is not discarded');
+  store.appendEvent(runtimeDir, { event: 'discarded', id }, now);
+  return { status: 200, body: { ok: true, id, discarded: true } };
+}
+
 function confirm(req, body, runtimeDir, now = new Date(), senders) {
   const bad = guarded(req, body); if (bad) return bad;
   const cur = store.readOutbox(runtimeDir).find((e) => e.id === body.id);
@@ -78,11 +98,11 @@ function confirm(req, body, runtimeDir, now = new Date(), senders) {
   return { status: 200, body: { ok: true, hash: r.hash, override: r.override, state: 'sent' } };
 }
 
-const ROUTES = { 'POST /api/outbox/draft': draft, 'POST /api/outbox/edit': edit, 'POST /api/outbox/confirm': confirm };
+const ROUTES = { 'POST /api/outbox/draft': draft, 'POST /api/outbox/edit': edit, 'POST /api/outbox/discard': discard, 'POST /api/outbox/confirm': confirm };
 
 module.exports = {
   prefixes: ['/api/outbox'],
-  claimCheck, list, draft, edit, confirm, ROUTES,
+  claimCheck, list, draft, edit, discard, confirm, ROUTES,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     if (p === '/api/outbox' && req.method === 'GET') { const r = list(ctx.runtimeDir); ctx.json(res, r.body, r.status); return true; }

package/workspace/lib/routes-pm-items.js

@@ -5,7 +5,7 @@
  *   GET  /api/pm-items                     → { ok, today, lists: { waiting, today, week, triage, later }, jobs, items,
  *                                              work: { inbox, today, upcoming, waiting, someday }  open items, placed once here
  *                                              review, review_days: 7        open items untouched 7 days, most stale first
- *                                              focus: { suggestions, accepted }   at most 3 suggestions: { key, title, why, item_ids, job }
+ *                                              focus: { suggestions, accepted, dismissed }   at most 3 suggestions: { key, title, why, item_ids, job }; dismissed = the keys marked not today
  *                                              counts: { inbox, today, upcoming, waiting, someday, review } }
  *   POST /api/pm-items/add    { line }     → { ok, item }            one line: the parser (lib/pm-items.js) reads the parts
  *   POST /api/pm-items/edit   { id, fields }→ { ok, item }            fields: title, due, priority, waiting_on, job,
@@ -45,7 +45,9 @@ const guard = require('./pm-guard.js');
 const pmItems = require('./pm-items.js');
 const jobs = require('./jobs-to-be-done.js');
 const workFocus = require('./work-focus.js');
+const workEvidence = require('./work-evidence.js');
 const steps = require('./item-steps.js');
+const { repoScript } = require('./repo-script.js');
 
 const FIELDS = ['title', 'due', 'priority', 'waiting_on', 'job', 'defer', 'flagged', 'resolves', 'kind', 'person', 'evidence', 'outcome'];
 const STRING_OR_NULL = ['resolves', 'person', 'evidence', 'outcome'];
@@ -75,10 +77,11 @@ function resolvesTitles(items, ctx, url) {
   } catch { return {}; }
 }
 
-function view(itemLines, jobLines, now, stepLines = [], focusLines = []) {
+function view(itemLines, jobLines, now, stepLines = [], focusLines = [], proof = null) {
   const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
   const byItem = steps.foldSteps(stepLines).byItem;
-  const items = pmItems.fold(itemLines).map((i) => ({ ...i, steps: byItem[i.id] || [] }));
+  const folded = pmItems.fold(itemLines).map((i) => ({ ...i, steps: byItem[i.id] || [] }));
+  const items = proof ? workEvidence.withEvidence(folded, { ...proof, now: now.getTime() }) : folded;
   const currentJobs = jobs.foldJobs(jobLines).map((j) => ({ ...j, ...jobs.progress(j.id, items) }));
   const lists = Object.fromEntries(pmItems.LISTS.map((l) => [l, []]));
   for (const it of items) lists[pmItems.placement(it, today)].push(it);
@@ -88,11 +91,21 @@ function view(itemLines, jobLines, now, stepLines = [], focusLines = []) {
   for (const l of pmItems.WORK_LISTS) work[l] = pmItems.sortWorkList(l, work[l], today);
   const review = pmItems.reviewQueue(items, now);
   const state = workFocus.foldFocus(focusLines, todayIso);
-  const focus = { suggestions: workFocus.focusSuggestions(work.today, currentJobs, state, todayIso), accepted: state.accepted };
+  const focus = { suggestions: workFocus.focusSuggestions(work.today, currentJobs, state, todayIso), accepted: state.accepted, dismissed: [...state.dismissed] };
   const counts = { ...Object.fromEntries(pmItems.WORK_LISTS.map((l) => [l, work[l].length])), review: review.length };
   return { ok: true, today: todayIso, lists, jobs: currentJobs, items, work, review, review_days: pmItems.REVIEW_DAYS, focus, counts };
 }
 
+// The calendar events and notes that can prove an offline item happened. Read only when an open offline item exists. Best effort: a failed read gives no proof.
+function proofSources(ctx, itemLines) {
+  if (!ctx.runtimeDir || !pmItems.fold(itemLines).some((i) => i.kind === 'offline' && !i.done)) return null;
+  let events = [];
+  let notes = [];
+  try { events = require('./routes-calendar-import.js').readEvents(ctx.runtimeDir); } catch { /* no calendar cache */ }
+  try { const l = require('./notes.js').list(ctx.runtimeDir); notes = l && l.ok ? l.notes : []; } catch { /* no notes */ }
+  return { events, notes };
+}
+
 // Each operation returns { status, body, events } and writes nothing itself; the caller appends `events`.
 function checkFields(fields, allowed) {
   if (!fields || typeof fields !== 'object') return 'fields must be an object';
@@ -226,7 +239,7 @@ function planSteps(b, itemLines) {
   // With an agent's reply (from the reply path), parse it: a step that sends something to a person is forced to
   // agent-drafts by the planner. Without one, fall back to the single review step for the PM.
   if (b.reply !== undefined) {
-    const plan = require('../../scripts/step-planner.js').parsePlanReply(b.reply);
+    const plan = require(repoScript('step-planner.js')).parsePlanReply(b.reply);
     if (!plan.ok) return { status: 400, body: { ok: false, error: plan.error } };
     const added = plan.steps.map((st) => steps.addStep(b.id, st.text, st.who, newId('step')));
     return { status: 200, body: { ok: true, steps: added.map((r) => ({ id: r.event.id, text: r.event.text, who: r.event.who })) }, events: added.map((r) => r.event) };
@@ -299,7 +312,7 @@ module.exports = {
     const p = url.pathname;
     if (p === '/api/pm-items' && req.method === 'GET') {
       const c = prepare(ctx);
-      const v = view(c.itemLines, c.jobLines, c.now, c.stepLines, c.focusLines);
+      const v = view(c.itemLines, c.jobLines, c.now, c.stepLines, c.focusLines, proofSources(ctx, c.itemLines));
       v.resolves_titles = resolvesTitles(v.items, ctx, url);
       ctx.json(res, v);
       return true;

package/workspace/lib/routes-records.js

@@ -11,8 +11,9 @@
  */
 const path = require('path');
 const guard = require('./pm-guard.js');
-const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
-const ledger = require(path.join(__dirname, '..', '..', 'scripts', 'trust', 'ledger.js'));
+const { repoScript } = require('./repo-script.js');
+const records = require(repoScript('records/index.js'));
+const ledger = require(repoScript('trust/ledger.js'));
 
 const rootOf = (ctx) => (ctx && ctx.recordsDir) || path.join(ctx.repoRoot || path.join(__dirname, '..', '..'), 'planning', 'records');
 const UI = () => ledger.actorFrom({ ui: true });

package/workspace/lib/routes-releases.js

@@ -18,7 +18,8 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const guard = require('./pm-guard.js');
-const R = require('../../scripts/releases.js');
+const { repoScript } = require('./repo-script.js');
+const R = require(repoScript('releases.js'));
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const dirOf = (ctx) => path.join(ctx.runtimeDir, 'releases');

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

@@ -13,8 +13,9 @@
  * Read-only. The repository read is slow (it derives each initiative's stage from git), so a successful read is kept 5 minutes. */
 const fs = require('fs');
 const path = require('path');
-const RF = require('../../scripts/report-families.js');
-const { foldReleases } = require('../../scripts/releases.js');
+const { repoScript } = require('./repo-script.js');
+const RF = require(repoScript('report-families.js'));
+const { foldReleases } = require(repoScript('releases.js'));
 
 const prefixes = ['/api/report-families/facts'];
 const TTL = 5 * 60 * 1000;
@@ -24,7 +25,7 @@ function repoInis(root, opts) {
   const hit = memo.get(root);
   const now = (opts && opts.clock) ? opts.clock() : Date.now();
   if (hit && now - hit.at < TTL) return hit.inis;
-  const { readRepoFacts } = require('../../scripts/signals/facts.js');
+  const { readRepoFacts } = require(repoScript('signals/facts.js'));
   const inis = (readRepoFacts(root, {}).inis || []).map((i) => ({ id: i.id, title: i.title, promised: i.promised, done: !!i.done }));
   memo.set(root, { at: now, inis });
   return inis;

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

@@ -5,7 +5,8 @@
  *   POST /api/report-families/check   { family, variant?, sections, known_keys?, absent_keys?, stale_keys? }
  *                                    → { ok, blocked, reasons, warnings, sections, ... }
  * Pure. The check reads nothing from disk and writes nothing. There is no send and no issue route in this wave. */
-const RF = require('../../scripts/report-families.js');
+const { repoScript } = require('./repo-script.js');
+const RF = require(repoScript('report-families.js'));
 
 const prefixes = ['/api/report-families'];
 const strs = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined);

package/workspace/lib/routes-roadmap-ops.js

@@ -19,10 +19,11 @@
 const fs = require('fs');
 const path = require('path');
 const guard = require('./pm-guard.js');
-const records = require(path.join(__dirname, '..', '..', 'scripts', 'records', 'index.js'));
-const ledger = require(path.join(__dirname, '..', '..', 'scripts', 'trust', 'ledger.js'));
-const roadmap = require(path.join(__dirname, '..', '..', 'scripts', 'roadmap-ops.js'));
-const breakdown = require(path.join(__dirname, '..', '..', 'scripts', 'breakdown-ops.js'));
+const { repoScript } = require('./repo-script.js');
+const records = require(repoScript('records/index.js'));
+const ledger = require(repoScript('trust/ledger.js'));
+const roadmap = require(repoScript('roadmap-ops.js'));
+const breakdown = require(repoScript('breakdown-ops.js'));
 
 const REPO = path.join(__dirname, '..', '..');
 const rootOf = (ctx) => (ctx && ctx.recordsDir) || path.join((ctx && ctx.repoRoot) || REPO, 'planning', 'records');

package/workspace/lib/routes-runs.js

@@ -13,11 +13,12 @@ const path = require('path');
 const guard = require('./pm-guard.js');
 const actor = require('./actor.js');
 const runAnswers = require('./run-answers.js');
-const { groupSessions } = require('../../scripts/sessions-list.js');
-const { cardFor, correctionEvent } = require('../../scripts/card-state.js');
-const { readLines, runFor, foldReplies } = require('../../scripts/replies.js');
-const C = require('../../scripts/reply-contract/reply-contract.js');
-const { appendOutbox } = require('../../scripts/outbox.js');
+const { repoScript } = require('./repo-script.js');
+const { groupSessions } = require(repoScript('sessions-list.js'));
+const { cardFor, correctionEvent } = require(repoScript('card-state.js'));
+const { readLines, runFor, foldReplies } = require(repoScript('replies.js'));
+const C = require(repoScript('reply-contract/reply-contract.js'));
+const { appendOutbox } = require(repoScript('outbox.js'));
 
 const prefixes = ['/api/runs'];
 const RUN_RE = /^sess-\d+$/;

package/workspace/lib/routes-settings.js

@@ -0,0 +1,51 @@
+'use strict';
+/* routes-settings.js — the console3 settings store over HTTP (initiative console3-settings).
+ *
+ *   GET  /api/settings?ws=…                       → { ok, settings, overrides, categories, state_dir }
+ *   POST /api/settings { key, value, ws }         → { ok, key, value }        page press; 400 for a value the setting refuses
+ *   POST /api/settings { key, reset: true, ws }   → { ok, key, value }        back to the default
+ *
+ * Only the settings in lib/settings-store.js live here. A setting with a store of its own (the recording language, Online,
+ * the TypeSafe key, validate consent, profiles) keeps its own route, and the Settings page calls that one. Writes pass
+ * pm-guard requirePagePress, so an agent token is refused. Nothing here makes a network request. */
+const store = require('./settings-store.js');
+const guard = require('./pm-guard.js');
+
+/** The workspace a request names, only when it is registered under exactly that id (getWs falls back to the home one). */
+function wsOf(ctx, id) {
+  if (id == null || id === '') return null;
+  const w = typeof ctx.getWs === 'function' ? ctx.getWs(String(id)) : null;
+  return w && w.id === String(id) ? w.id : false;
+}
+
+function read(ctx, wsParam) {
+  const ws = wsOf(ctx, wsParam);
+  if (ws === false) return { status: 404, body: { ok: false, error: 'This workspace is not registered.' } };
+  return { status: 200, body: { ok: true, ws: ws || null, ...store.all(ctx.runtimeDir, ws, { env: ctx.env || process.env }), state_dir: ctx.runtimeDir } };
+}
+
+function write(ctx, req, body) {
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return { status: g.status, body: { ok: false, error: g.error } };
+  const key = typeof body.key === 'string' ? body.key : '';
+  const ws = wsOf(ctx, body.ws);
+  if (ws === false) return { status: 404, body: { ok: false, error: 'This workspace is not registered.' } };
+  const r = body.reset === true ? store.reset(ctx.runtimeDir, key, ws) : store.set(ctx.runtimeDir, key, body.value, ws);
+  if (!r.ok) return { status: r.status || 400, body: { ok: false, key, error: r.error } };
+  return { status: 200, body: { ok: true, key, value: r.value } };
+}
+
+module.exports = {
+  prefixes: ['/api/settings'],
+  read, write,
+  handle: async (req, res, url, ctx) => {
+    if (url.pathname !== '/api/settings') return false;
+    if (req.method === 'GET') { const r = read(ctx, url.searchParams.get('ws')); ctx.json(res, r.body, r.status); return true; }
+    if (req.method !== 'POST') { ctx.json(res, { ok: false, error: '/api/settings takes GET or POST' }, 405); return true; }
+    const got = await ctx.readJson(req);
+    if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
+    const r = write(ctx, req, got.body || {});
+    ctx.json(res, r.body, r.status);
+    return true;
+  },
+};

package/workspace/lib/routes-signals.js

@@ -9,8 +9,9 @@
  * File: <runtime>/signals/signals.jsonl (append only, scripts/trust/ledger.js). */
 const path = require('path');
 const guard = require('./pm-guard.js');
-const S = require('../../scripts/signal-rules.js');
-const L = require('../../scripts/trust/ledger.js');
+const { repoScript } = require('./repo-script.js');
+const S = require(repoScript('signal-rules.js'));
+const L = require(repoScript('trust/ledger.js'));
 
 const fileOf = (runtimeDir) => path.join(runtimeDir, 'signals', 'signals.jsonl');
 const fail = (status, error) => ({ status, body: { ok: false, error } });