create-pmos 0.116.0 → 0.118.0

package/workspace/lib/notes.js

@@ -2,7 +2,7 @@
 /* notes.js — the PM's notes: typed notes, dictation, meeting transcripts and their summaries (meeting-notes, Runs 1 to 9).
  *
  *   list(dir) · read(dir, id) · create(dir, { title }) · save(dir, { id, title, body }) · remove(dir, id)
- *   record(dir, { id, ws }) · appendTranscript(dir, { id, text, source, t, ms }) · setPrivate(dir, { id, private })
+ *   record(dir, { id, ws }) · pause(dir, { id }) · stop(dir, { id }) · expire(dir, { id, resumeMs }) · appendTranscript(dir, { id, text, source, t, ms }) · setPrivate(dir, { id, private })
  *   categoryOf(text, names) → 'decision'|'action'|'question'|'topic'|'statement'|'small talk'   the local label (Run 2)
  *   meetsBar(cat, text) → boolean     whether a line is good enough to be a decision, an action or a question (any labeller)
  *   checkable(seg) → boolean          whether a line is worth a repository check
@@ -21,6 +21,17 @@
  *                                        the minute batches and the agent's bullets (Run 8; see "minute batches" below)
  *   `dir` is the per-user runtime directory (server.js STATE). Notes live in `<dir>/notes/`, never in a repository.
  *
+ * PAUSE IS NOT STOP (Run 13, R51, R56). Pause keeps the meeting open for RESUME_MS (one hour). A Listen inside that hour
+ * resumes it. After the hour the meeting ends by itself (`expire`, ended_by 'timeout'). Stop ends it for good (`stop`,
+ * ended_by 'stop'). A meeting that ended cannot be recorded again: `record` answers 409. Each stretch of recording is
+ * `sessions: [{ from, to }]` (ISO times; `to` is null while open); `sessionsOf` derives one for a note from before Run 13.
+ * `stateOf(note, now, resumeMs)` is 'recording' | 'paused' | 'ended' | 'idle'. A row and a note carry state, paused_at,
+ * resume_until (paused_at + resumeMs while paused), ended_at, ended_by and sessions.
+ *
+ * MEETING CONTEXT (Run 13, R59). `meeting.context` is a snapshot of the calendar meeting's context, kept when the note is made
+ * or linked: with, attendees, role, external, series, purpose, prep, agenda, links, refs, where, organizer, taken_at.
+ * `cleanContext` clips and checks every field; nothing the client sends is trusted, and anything else is dropped.
+ *
  * WHERE A NOTE LIVES. One JSON file per note, `<dir>/notes/<id>.json`, written to a temporary file and renamed, so a crash
  * never leaves half a note. A transcript holds other people's words, which is why it stays in the per-user directory, as
  * the Live notes transcript does (D85). Deleting a note deletes its file and its agent handoff files.
@@ -65,6 +76,7 @@ const crypto = require('crypto');
 const { scan } = require('./secret-scan');
 const { cleanPhrase } = require('./live-notes');
 
+const RESUME_MS = 60 * 60 * 1000;
 const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
 const MAX_TITLE = 160;
 const MAX_BODY = 400 * 1024;
@@ -104,15 +116,46 @@ const newId = (now) => 'n-' + Math.floor(now).toString(36) + '-' + crypto.random
 const cleanTitle = (t) => String(t == null ? '' : t).replace(/\s+/g, ' ').trim().slice(0, MAX_TITLE);
 const wordsOf = (s) => (String(s || '').match(/[\p{L}\p{N}']+/gu) || []).length;
 
+/* ── pause, stop and the state of a meeting (Run 13) ─────────────────────────────────────────────── */
+/** The resume window in ms: PMOS_NOTES_RESUME_MS (50 or more), else one hour. Routes pass their own through `resumeMs`. */
+function RESUME_MS_NOW() { const v = Number(process.env.PMOS_NOTES_RESUME_MS); return Number.isFinite(v) && v >= 50 ? v : RESUME_MS; }
+const resumeOf = (o) => (Number.isFinite(Number(o)) && Number(o) >= 50 ? Number(o) : RESUME_MS_NOW());
+/** The recording stretches of a note: [{ from, to }]. A note from before Run 13 has one, derived from its first Listen and its pause. */
+function sessionsOf(note) {
+  if (note && Array.isArray(note.sessions)) return note.sessions.map((x) => ({ from: x.from, to: x.to || null }));
+  if (note && note.recorded_from) return [{ from: note.recorded_from, to: note.paused_at || null }];
+  return [];
+}
+/** 'recording' | 'paused' | 'ended' | 'idle'. Pure. `ended` also covers a pause older than the window that nothing has marked yet. */
+function stateOf(note, now = Date.now(), resumeMs = RESUME_MS) {
+  if (!note) return 'idle';
+  if (note.ended_at) return 'ended';
+  if (!note.recorded_from) return 'idle';
+  if (note.paused_at) {
+    const p = Date.parse(note.paused_at);
+    return Number.isFinite(p) && now - p > resumeMs ? 'ended' : 'paused';
+  }
+  return note.private ? 'idle' : 'recording';
+}
+function stateFields(n, now, resumeMs) {
+  const state = stateOf(n, now, resumeMs);
+  const p = Date.parse(n.paused_at);
+  let endedAt = n.ended_at || null;
+  let endedBy = n.ended_by || null;
+  if (state === 'ended' && !endedAt && Number.isFinite(p)) { endedAt = iso(Math.min(now, p + resumeMs)); endedBy = 'timeout'; }
+  return { state, paused_at: n.paused_at || null, resume_until: state === 'paused' && Number.isFinite(p) ? iso(p + resumeMs) : null,
+    ended_at: endedAt, ended_by: endedBy, sessions: sessionsOf(n) };
+}
+
 /** The row a list shows. Never the body or the transcript. */
-function rowOf(n) {
+function rowOf(n, now = Date.now(), resumeMs = RESUME_MS) {
   return { id: n.id, title: n.title || 'Untitled note', created_at: n.created_at, updated_at: n.updated_at, private: !!n.private,
     words: wordsOf(n.body), segments: (n.transcript || []).length, summary: !!(n.summary || (n.agent && n.agent.markdown)),
     meeting: n.meeting || null, initiative: n.initiative || null, ws: n.ws || null,
     // the meeting time so far (a paused note's clock) and how many statements differ from a repository file (the Notes menu)
     meeting_ms: n.recorded_from ? meetingMs(n) : 0, conflicts: n.private ? 0 : conflictsOf(n).length,
     // a private note shows its title on the calendar and the initiative, never its summary
-    summary_lines: n.private ? [] : summaryLines(n) };
+    summary_lines: n.private ? [] : summaryLines(n), ...stateFields(n, now, resumeMs) };
 }
 /** The statements of a note that a repository file says otherwise: transcript lines, the agent's bullets and the PM's
  * highlights whose check verdict is 'differs'. → [{ text, doc, line, t, from }] */
@@ -147,6 +190,30 @@ const EVENT_ID_RE = /^[A-Za-z0-9_-]{1,40}$/;
 const INI_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
 const minuteOf = (s) => { const t = Date.parse(s); return Number.isFinite(t) ? Math.floor(t / 60000) : null; };
 const normTitle = (t) => String(t || '').toLowerCase().replace(/\s+/g, ' ').trim();
+
+const httpUrl = (u) => {
+  if (typeof u !== 'string' || u.length > 500) return null;
+  try { const x = new URL(u); return x.protocol === 'http:' || x.protocol === 'https:' ? u : null; } catch { return null; }
+};
+const ctxText = (v, n) => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim().slice(0, n) || null : null);
+const ctxList = (v, n, max) => (Array.isArray(v) ? v.map((x) => ctxText(x, n)).filter(Boolean).slice(0, max) : []);
+/** A snapshot of the meeting's context. Every field is clipped and checked; anything else is dropped. null when `c` is not an object. */
+function cleanContext(c, now) {
+  if (!c || typeof c !== 'object' || Array.isArray(c)) return null;
+  const a = Number(c.attendees);
+  const links = (Array.isArray(c.links) ? c.links : []).map((l) => {
+    const url = l && httpUrl(l.url); const label = l && ctxText(l.label, 60);
+    return url && label ? { label, url } : null;
+  }).filter(Boolean).slice(0, 5);
+  const refs = (Array.isArray(c.refs) ? c.refs : []).map((r) => {
+    const label = r && ctxText(r.label, 120);
+    return label ? { label, source: ctxText(r.source, 30), link: httpUrl(r.link) } : null;
+  }).filter(Boolean).slice(0, 5);
+  return { with: ctxText(c.with, 120), attendees: c.attendees != null && c.attendees !== '' && Number.isInteger(a) && a >= 0 && a <= 1000 ? a : null,
+    role: ['present', 'decide', 'attend'].includes(c.role) ? c.role : null, external: c.external === true, series: ctxText(c.series, 200),
+    purpose: ctxText(c.purpose, 240), prep: ctxText(c.prep, 240), agenda: ctxList(c.agenda, 140, 6), links, refs,
+    where: ctxText(c.where, 120), organizer: ctxText(c.organizer, 120), taken_at: iso(now) };
+}
 /** A meeting link: a calendar event (its id, where it came from, its start, end and title) or a meeting that is not on the
  * calendar. null unlinks. Returns { ok, meeting } or an error. */
 function cleanMeeting(m, now) {
@@ -160,7 +227,8 @@ function cleanMeeting(m, now) {
   if (m.end != null && minuteOf(m.end) === null) return err(400, 'the end of the event is not a time');
   if (m.event_id != null && !EVENT_ID_RE.test(String(m.event_id))) return err(400, 'that is not a calendar event id');
   return { ok: true, meeting: { kind: 'event', event_id: m.event_id != null ? String(m.event_id) : null, src: m.src === 'memory' ? 'memory' : 'brief',
-    start: new Date(Date.parse(m.start)).toISOString(), end: m.end != null ? new Date(Date.parse(m.end)).toISOString() : null, title, linked_at: iso(now) } };
+    start: new Date(Date.parse(m.start)).toISOString(), end: m.end != null ? new Date(Date.parse(m.end)).toISOString() : null, title, linked_at: iso(now),
+    ...(cleanContext(m.context, now) ? { context: cleanContext(m.context, now) } : {}) } };
 }
 /** An initiative link: { id, ws, repo, title, by }. `repo` is the repository's name in the page, to open the initiative. `by` is pm (chosen), event (from the calendar event) or local (suggested). */
 function cleanInitiative(x, by) {
@@ -193,6 +261,9 @@ function link(dir, { id, meeting, initiative, by = 'pm', now = Date.now() } = {}
   if (meeting !== undefined) {
     const m = cleanMeeting(meeting, now);
     if (!m.ok) return m;
+    // a link without context keeps the stored context of the same event
+    const prev = note.meeting;
+    if (m.meeting && m.meeting.kind === 'event' && !m.meeting.context && prev && prev.context && sameEvent(prev, m.meeting)) m.meeting.context = prev.context;
     note.meeting = m.meeting;
     if (m.meeting && m.meeting.kind === 'event' && !String(note.title || '').trim()) note.title = m.meeting.title;
   }
@@ -206,11 +277,11 @@ function link(dir, { id, meeting, initiative, by = 'pm', now = Date.now() } = {}
   store(dir, note);
   return { ok: true, note };
 }
-function list(dir) {
+function list(dir, { now = Date.now(), resumeMs } = {}) {
   let names = [];
   try { names = fs.readdirSync(notesDir(dir)).filter((f) => f.endsWith('.json')); } catch { return { ok: true, notes: [] }; }
   const notes = [];
-  for (const f of names) { const n = load(dir, f.slice(0, -5)); if (n && n.id) notes.push(rowOf(n)); }
+  for (const f of names) { const n = load(dir, f.slice(0, -5)); if (n && n.id) notes.push(rowOf(n, now, resumeOf(resumeMs))); }
   notes.sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at)) || (a.id < b.id ? 1 : -1));
   return { ok: true, notes };
 }
@@ -227,11 +298,11 @@ function create(dir, { title = '', meeting, initiative, now = Date.now() } = {})
   return { ok: true, note };
 }
 /** Read one note. An agent summary file written since the request is imported here, so the note is the one source. */
-function read(dir, id) {
+function read(dir, id, { now = Date.now(), resumeMs } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
   importAgent(dir, note);
-  return { ok: true, note };
+  return { ok: true, note: { ...note, ...stateFields(note, now, resumeOf(resumeMs)) } };
 }
 function save(dir, { id, title, body, now = Date.now() } = {}) {
   const note = load(dir, id);
@@ -349,28 +420,79 @@ function meetingMs(note, now = Date.now()) {
 }
 /** When the meeting clock started, as the page counts it: the first Listen moved on by the time it was stopped. */
 const clockFrom = (note, now = Date.now()) => iso(now - meetingMs(note, now));
-/** Recording starts: the first start fixes the time every transcript offset is counted from. A start after a stop adds
- * the stopped time to `paused_ms`, so the meeting time carries on from where it stopped. */
-function record(dir, { id, ws = undefined, now = Date.now() } = {}) {
-  const note = load(dir, id);
+const REFUSE = Object.freeze({
+  stop: 'this meeting was stopped, so it cannot be resumed',
+  timeout: 'this meeting was paused for over an hour, so it ended and cannot be resumed' });
+/** Close the open recording stretch, if any. */
+function closeSession(note, at) {
+  const ss = sessionsOf(note);
+  const open = ss.find((x) => !x.to);
+  if (open) open.to = at;
+  note.sessions = ss;
+  return !!open;
+}
+/** Recording starts: the first start fixes the time every transcript offset is counted from. A start after a pause adds
+ * the paused time to `paused_ms`, so the meeting time carries on from where it stopped. A meeting that ended (Stop, or a
+ * pause longer than the resume window) is refused with 409. */
+function record(dir, { id, ws = undefined, now = Date.now(), resumeMs } = {}) {
+  let note = load(dir, id);
   if (!note) return err(404, 'no such note');
   if (note.private) return err(409, 'this note is marked private, so it is not recorded. Mark it not private first.');
+  if (stateOf(note, now, resumeOf(resumeMs)) === 'ended') {
+    if (!note.ended_at) expire(dir, { id, now, resumeMs });
+    note = load(dir, id);
+    return err(409, REFUSE[note.ended_by] || REFUSE.stop);
+  }
   let changed = false;
   if (!note.recorded_from) { note.recorded_from = iso(now); changed = true; }
   const stopped = Date.parse(note.paused_at);
   if (Number.isFinite(stopped)) { note.paused_ms = (Number(note.paused_ms) || 0) + Math.max(0, now - stopped); note.paused_at = null; changed = true; }
+  const ss = sessionsOf(note);
+  if (!ss.some((x) => !x.to)) { ss.push({ from: iso(now), to: null }); changed = true; }
+  note.sessions = ss;
   if (ws !== undefined && note.ws !== (ws || null)) { note.ws = ws || null; changed = true; }
   if (changed) { note.updated_at = iso(now); store(dir, note); }
   return { ok: true, recorded_from: note.recorded_from, clock_from: clockFrom(note, now), meeting_ms: meetingMs(note, now) };
 }
-/** Listening stopped: the meeting clock stops too, until the next Listen. */
-function pause(dir, { id, now = Date.now() } = {}) {
+const endedShape = (note, now, resumeMs) => ({ meeting_ms: meetingMs(note, now), ...stateFields(note, now, resumeMs) });
+/** Listening stopped but the meeting stays open: the meeting clock stops until the next Listen, for the resume window. */
+function pause(dir, { id, now = Date.now(), resumeMs } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
   const closed = closeOpenLines(note);
   if (note.recorded_from && !note.paused_at) note.paused_at = iso(now);
-  if (closed.length || note.paused_at) store(dir, note);
-  return { ok: true, meeting_ms: meetingMs(note, now), closed: closed.length };
+  const s = note.paused_at ? closeSession(note, note.paused_at) : false;
+  if (closed.length || note.paused_at || s) store(dir, note);
+  return { ok: true, ...endedShape(note, now, resumeOf(resumeMs)), closed: closed.length };
+}
+/** The meeting ends for good: it is paused if it was listening, then marked ended by 'stop'. Calling it again changes nothing. */
+function stop(dir, { id, now = Date.now(), resumeMs } = {}) {
+  const note = load(dir, id);
+  if (!note) return err(404, 'no such note');
+  const closed = closeOpenLines(note);
+  if (note.recorded_from && !note.paused_at) note.paused_at = iso(now);
+  if (note.paused_at) closeSession(note, note.paused_at);
+  if (!note.ended_at) { note.ended_at = iso(now); note.ended_by = 'stop'; }
+  if (!note.sessions && note.recorded_from) note.sessions = sessionsOf(note);
+  note.updated_at = iso(now);
+  store(dir, note);
+  return { ok: true, ...endedShape(note, now, resumeOf(resumeMs)), closed: closed.length };
+}
+/** A pause older than the resume window ends the meeting by 'timeout', at the moment the window closed.
+ * → { ok, expired } plus the same fields as pause. */
+function expire(dir, { id, now = Date.now(), resumeMs } = {}) {
+  const note = load(dir, id);
+  if (!note) return err(404, 'no such note');
+  const win = resumeOf(resumeMs);
+  const p = Date.parse(note.paused_at);
+  let expired = false;
+  if (!note.ended_at && Number.isFinite(p) && now - p > win) {
+    note.ended_at = iso(Math.min(now, p + win)); note.ended_by = 'timeout'; note.updated_at = iso(now);
+    if (!note.sessions) note.sessions = sessionsOf(note);
+    store(dir, note);
+    expired = true;
+  }
+  return { ok: true, expired, ...endedShape(note, now, win) };
 }
 /** Listening stopped, so no cut will finish a line still open: each one is closed and gets its local label. A label the PM
  * chose is kept. → the closed lines' indexes */
@@ -1545,7 +1667,7 @@ function editFinal(dir, { id, sec, i, text, now = Date.now() } = {}) {
 }
 
 module.exports = { addHighlight, updateHighlight, removeHighlight, editFinal, conflictsOf, setFinal, setFinalState, renameFinalSpeaker, finalSpeaker, transcriptLines, cleanNotes, notesMarkdown, groundQuote, parseTime, NOTES_SHAPE,
-  wisprHandoff, wisprPrompt, setWispr, importWispr, notesOutOf, wisprOutOf, list, read, create, link, findByEvent, sameEvent, cleanMeeting, summaryLines, save, remove, record, pause, meetingMs, appendTranscript, updateSegment, setLabel, editLine, versionsOf, renameSpeaker, speakerOf, categoryOf, isFact, CATS, PM_CATS, VERSION_FOLD_MS, setPrivate, dictation, cleanSentences, spokenPunctuation,
+  wisprHandoff, wisprPrompt, setWispr, importWispr, notesOutOf, wisprOutOf, list, read, create, link, findByEvent, sameEvent, cleanMeeting, summaryLines, save, remove, record, pause, stop, expire, stateOf, sessionsOf, cleanContext, RESUME_MS, meetingMs, appendTranscript, updateSegment, setLabel, editLine, versionsOf, renameSpeaker, speakerOf, categoryOf, isFact, CATS, PM_CATS, VERSION_FOLD_MS, setPrivate, dictation, cleanSentences, spokenPunctuation,
   summarize, localSummary, agentHandoff, agentStarted, toMarkdown, promptFor, fmtTime, ownerOf, dueOf, ID_RE, notesDir, handoffOf, agentOutOf,
   meetsBar, checkable, vocabOf, termsIn, namesIn, SECTION_CAP, JOIN_GAP_MS,
   takeBatch, setMinutesAgent, minuteHandoff, bulletsPrompt, bulletsFollowUp, importBullets, closeOpenBullets, minuteHanded, lateMinutes, markFallback, updateBullet, editBullet, minutesDirOf, minuteMdOf, minuteJsonOf, MAX_BULLET };

package/workspace/lib/routes-notes.js

@@ -17,7 +17,16 @@
  *   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;
  *                                             clock_from is the first Listen moved on by the time listening was stopped
- *   POST /api/notes/pause      { id }       → { ok, meeting_ms }      listening stopped: the meeting clock stops until the next Listen
+ *   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
+ *                                             (PMOS_NOTES_RESUME_MS or ctx.notesResumeMs, 50 or more), and a timer ends it after that.
+ *                                             It writes the last minute batch. It does not ask for Wispr Flow's notes.
+ *   POST /api/notes/stop       { id }       → { ok, meeting_ms, state, … }   the meeting ends for good: the last minute batch, and the
+ *                                             Wispr Flow fetch is scheduled. A stopped meeting cannot be recorded again.
+ *   When a pause runs out (the timer, or the first list or read after a restart) the meeting ends with ended_by 'timeout':
+ *   the Wispr Flow fetch is scheduled and the final pass is queued once. POST /api/notes/record answers 409 for a meeting that
+ *   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/label      { id, index, cat }           → { ok, segment }   the PM's own label for a line
@@ -83,7 +92,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/summarize', '/api/notes/summarize-agent', '/api/notes/delete', '/api/notes/audio', '/api/notes/label',
+  '/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']);
 
 /* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
@@ -170,6 +179,43 @@ function arm(ctx, id) {
   if (t.timer.unref) t.timer.unref();
   timers.set(id, t);
 }
+/* ── the resume window (Run 13): a paused meeting ends by itself ─────────────────────────────────── */
+const resumeMsOf = (ctx) => { const v = Number(ctx.notesResumeMs || process.env.PMOS_NOTES_RESUME_MS); return Number.isFinite(v) && v >= 50 ? v : notes.RESUME_MS; };
+const expiryTimers = new Map();      // note id → the timer that ends a paused meeting
+function clearExpiry(id) { const t = expiryTimers.get(id); if (t) { clearTimeout(t); expiryTimers.delete(id); } }
+/** The meeting ended by itself: write nothing new, ask for Wispr Flow's notes and queue the final pass (not twice). */
+function endMeeting(ctx, id, by = 'timeout') {
+  if (by !== 'timeout') return { ok: true, expired: false };
+  const dir = ctx.runtimeDir;
+  const r = notes.expire(dir, { id, resumeMs: resumeMsOf(ctx) });
+  if (!r.ok || !r.expired) return r;
+  clearExpiry(id);
+  const cur = notes.read(dir, id, { resumeMs: resumeMsOf(ctx) });
+  if (cur.ok && !cur.note.private) {
+    disarm(id);
+    runMinute(ctx, id, { final: true });
+    scheduleWispr(ctx, id);
+    const fs0 = cur.note.final_state && cur.note.final_state.state;
+    if (!fs0) queueFinal(ctx, id);
+  }
+  return r;
+}
+function armExpiry(ctx, id, resumeUntil) {
+  clearExpiry(id);
+  const left = Number.isFinite(Date.parse(resumeUntil)) ? Date.parse(resumeUntil) - Date.now() : resumeMsOf(ctx);
+  const t = setTimeout(() => { expiryTimers.delete(id); endMeeting(ctx, id, 'timeout'); }, Math.max(1, left) + 5);
+  if (t.unref) t.unref();
+  expiryTimers.set(id, t);
+}
+const swept = new Set();      // note ids already ended by a sweep
+/** After a restart no timer is left: a list or a read ends a meeting whose pause ran out. Idempotent and cheap. */
+function sweepExpired(ctx, rows) {
+  for (const n of rows) {
+    if (n.state !== 'ended' || n.ended_by !== 'timeout' || !n.paused_at || swept.has(n.id)) continue;
+    swept.add(n.id);
+    endMeeting(ctx, n.id, 'timeout');
+  }
+}
 function disarm(id) { const t = timers.get(id); if (t) { clearTimeout(t.timer); timers.delete(id); } }
 /** One minute's work for a note, after its earlier work: import what the agent wrote, then the next batch. */
 function runMinute(ctx, id, { final = false } = {}) { return chain(id, () => minuteNow(ctx, id, { final })); }
@@ -538,15 +584,16 @@ async function handle(req, res, url, ctx) {
   if (!dir) { ctx.json(res, { ok: false, error: 'the notes store is not available' }, 500); return true; }
   if (p === '/api/notes' || p === '/api/notes/one') {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
-    if (p === '/api/notes') { send(ctx, res, notes.list(dir)); return true; }
+    if (p === '/api/notes') { const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) }); if (l.ok) sweepExpired(ctx, l.notes); send(ctx, res, l); return true; }
     const nid = url.searchParams.get('id');
     // the bullets the agent wrote since the last read; Jev labels and checks them after the note's earlier work
     const imp = notes.importBullets(dir, { id: nid });
     if (imp.added.length) enrich(ctx, nid, imp.added, 'bullets');
     notes.importWispr(dir, { id: nid });
-    let r = notes.read(dir, nid);
+    let r = notes.read(dir, nid, { resumeMs: resumeMsOf(ctx) });
+    if (r.ok) { sweepExpired(ctx, [r.note]); r = notes.read(dir, nid, { resumeMs: resumeMsOf(ctx) }); }
     // the page is open: the agent that wrote the notes before Wispr Flow's arrived writes them again, merged
-    if (r.ok && mergeWispr(ctx, nid)) r = notes.read(dir, nid);
+    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) };
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
@@ -619,8 +666,12 @@ async function handle(req, res, url, ctx) {
   if (p === '/api/notes/record') {
     const o = wsOf();
     if (!o.ok) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
-    const r = notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id });
+    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');
+    const r = notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id, resumeMs: rm });
     if (r.ok) {
+      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);
       if (cur.ok && cur.note.minutes && cur.note.minutes.agent === 'failed') notes.setMinutesAgent(dir, { id, agent: null, reason: '' });
@@ -633,9 +684,15 @@ async function handle(req, res, url, ctx) {
     return done(r);
   }
   if (p === '/api/notes/pause') {
-    const r = notes.pause(dir, { id });
-    // listening stopped: the minute timer stops, and what was said since the last minute is one more batch
-    if (r.ok) { disarm(id); runMinute(ctx, id, { final: true }); scheduleWispr(ctx, id); }
+    const r = notes.pause(dir, { id, resumeMs: resumeMsOf(ctx) });
+    // 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); }
+    return done(r);
+  }
+  if (p === '/api/notes/stop') {
+    const r = notes.stop(dir, { id, resumeMs: resumeMsOf(ctx) });
+    if (r.ok) { clearExpiry(id); swept.add(id); disarm(id); runMinute(ctx, id, { final: true }); scheduleWispr(ctx, id); }
     return done(r);
   }
   if (p === '/api/notes/transcript') {
@@ -751,7 +808,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) { 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); }
     return done(r);
   }
   if (p === '/api/notes/summarize') {
@@ -780,7 +837,7 @@ async function handle(req, res, url, ctx) {
     }
     return done(r);
   }
-  if (p === '/api/notes/delete') { 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); 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 });

package/workspace/package-lock.json

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

package/workspace/package.json

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