create-pmos 0.528.0 → 0.530.0

package/workspace/lib/meeting-suggest.js

@@ -0,0 +1,105 @@
+'use strict';
+/* meeting-suggest.js — the ✦ spelling the word fix offers (batch 27 item 12, word fix A: MpW1, MpWPhone). Local and read-only.
+ *
+ *   suggest({ heard, fixes, invite, people, repo }) → { means, from: ['fix' | 'invite' | 'repo'], file?, alts: [spelling] } | null    pure
+ *   repoWords(root, { exclude }) → [{ w, file, n }]   the names and terms the repository's Markdown writes (capitalised words, CamelCase,
+ *                                                      and two capitalised words in a row), cached with lib/notes-repo.js passages
+ *
+ * WHERE A SPELLING COMES FROM. Three places, and nothing else: a word the PM fixed before (the same heard words, remembered), the
+ * meeting's invite (its title, its people, its agenda and its material, as the page sends them), and the repository of the note's
+ * workspace (lib/notes-repo.js reads its Markdown; D79 exclusions are honoured). A spelling counts only when it is the heard words
+ * written another way ("Light box" → "Lightbox") or one or two letters away from them ("Lite box" → "Lightbox"), with the same first
+ * letter. When nothing matches, the answer is null and the page shows no ✦ line (zero is silence): a guess is never shown.
+ *
+ * WHAT IT NEVER DOES. It writes nothing and sends nothing. No model is asked. */
+const notesRepo = require('./notes-repo.js');
+
+const squash = (s) => String(s || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
+const clean = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+function lev(a, b, max) {
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i]; let low = i;
+    for (let j = 1; j <= b.length; j++) { cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)); low = Math.min(low, cur[j]); }
+    if (low > max) return max + 1;
+    prev = cur;
+  }
+  return prev[b.length];
+}
+/** The words as they sound, roughly: "light" and "lite" fold to "lit", "Scarlett" to "scarlet". English spelling only; nothing more clever. */
+const fold = (s) => (String(s || '').toLowerCase().match(/[\p{L}\p{N}]+/gu) || []).map((w) => w.replace(/ght/g, 't').replace(/igh/g, 'i').replace(/ph/g, 'f').replace(/ck/g, 'k')
+  .replace(/(\p{L})\1/gu, '$1').replace(/^(.{3,})e$/u, '$1')).join('');
+/** How far a spelling is from the heard words: 0 the same letters written another way, 1–2 letters away, or null (not the same word). */
+function distance(heard, cand) {
+  const h = squash(heard), c = squash(cand);
+  if (h.length < 3 || c.length < 3 || h[0] !== c[0]) return null;
+  if (clean(heard) === clean(cand)) return null;
+  if (h === c) return 0;
+  const max = h.length >= 5 ? 2 : 0;   // a short word must be the same letters: three or four letters one away is another word
+  const f = fold(heard), g = fold(cand);
+  const d = Math.min(lev(h, c, max), f.length >= 3 && f === g ? 1 : lev(f, g, max) + 1);
+  return d <= max ? d : null;
+}
+/** The names and terms a text writes: capitalised words and CamelCase (two letters or more), and two capitalised words in a row. */
+function namesIn(text) {
+  const out = [];
+  const t = String(text || '');
+  const ws = t.match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) || [];
+  for (let i = 0; i < ws.length; i++) {
+    const w = ws[i].replace(/['’-]+$/, '');
+    const cap = /^\p{Lu}/u.test(w) || /\p{Ll}\p{Lu}/u.test(w);
+    if (cap && w.length >= 3) out.push(w);
+    const nx = ws[i + 1] ? ws[i + 1].replace(/['’-]+$/, '') : '';
+    if (cap && nx && /^\p{Lu}/u.test(nx)) out.push(w + ' ' + nx);
+  }
+  return out;
+}
+/** A spelling no common word has: CamelCase ("MoEngage", "ePaper"), capitals ("IDPF") or a digit. */
+const distinct = (w) => /\p{Ll}\p{Lu}/u.test(w) || /^\p{Lu}{2,}$/u.test(w.replace(/\s+/g, '')) || /\d/.test(w);
+const CACHE_MS = 60000;
+const cache = new Map();
+function repoWords(root, { exclude = [], now = Date.now() } = {}) {
+  if (!root) return [];
+  const key = root + '|' + JSON.stringify(exclude);
+  const hit = cache.get(key);
+  if (hit && now - hit.at < CACHE_MS) return hit.words;
+  const count = new Map();
+  for (const p of notesRepo.passages(root, { exclude, now })) {
+    for (const w of namesIn(p.text)) { const x = count.get(w); if (x) x.n++; else count.set(w, { w, file: p.path, n: 1 }); }
+  }
+  const words = [...count.values()];
+  cache.set(key, { at: now, words });
+  return words;
+}
+
+/** The best spelling for the heard words, and up to two others. fixes: [{ heard, means }] remembered fixes (phrase lower case);
+ * invite: [text] the meeting's title, agenda and material; people: [name] the invite's people; repo: repoWords(). */
+function suggest({ heard, fixes = [], invite = [], people = [], repo = [] } = {}) {
+  const h = clean(heard);
+  if (!h || h.length > 60) return null;
+  const c = new Map();   // spelling → { means, d, from:Set, n, file }
+  const words = h.split(' ').length;
+  const add = (w, from, n = 1, file = '', person = false) => {
+    if (w.toLowerCase() === h.toLowerCase() && !distinct(w)) return;   // "users" and "Users" are the same word
+    const d = from === 'fix' ? 0 : distance(h, w); if (d == null) return;
+    // letters away is a misheard NAME only: CamelCase, capitals or digits, a person of the invite, or several heard words that are one word
+    if (d > 0 && from !== 'fix' && !(distinct(w) || person || (words > 1 && !/\s/.test(w)))) return;
+    const k = clean(w); const x = c.get(k) || { means: k, d, from: new Set(), n: 0, file: '' };
+    x.d = Math.min(x.d, d); x.from.add(from); x.n += n; if (file && !x.file) x.file = file;
+    c.set(k, x);
+  };
+  const hp = squash(h);
+  for (const f of fixes) if (f && f.means && squash(f.heard) === hp && clean(f.means) !== h) add(f.means, 'fix');
+  for (const t of invite) for (const w of namesIn(t)) add(w, 'invite');
+  for (const p of people) for (const w of namesIn(p)) add(w, 'invite', 1, '', true);
+  for (const r of repo) if (r && r.w) add(r.w, 'repo', r.n || 1, r.file || '');
+  if (!c.size) return null;
+  const rank = (x) => (x.from.has('fix') ? 0 : 10) + x.d * 2 - Math.min(3, x.from.size) - Math.min(2, Math.log10(1 + x.n));
+  const list = [...c.values()].sort((a, b) => rank(a) - rank(b) || b.n - a.n || a.means.localeCompare(b.means));
+  const best = list[0];
+  return { means: best.means, from: ['fix', 'invite', 'repo'].filter((k) => best.from.has(k)), ...(best.from.has('repo') && best.file ? { file: best.file } : {}),
+    alts: list.slice(1).filter((x) => squash(x.means) !== squash(best.means) || x.means !== best.means).slice(0, 2).map((x) => x.means) };
+}
+
+module.exports = { suggest, repoWords, distance, namesIn, squash, fold };

package/workspace/lib/meeting-terms.js

@@ -1,34 +1,57 @@
 'use strict';
-/* meeting-terms.js — a word heard wrong, fixed in place (batch 25 item 11, "Meeting recording view C": MvF, MvN).
+/* meeting-terms.js — a word heard wrong, fixed in place (batch 25 item 11 MvF/MvN; batch 27 item 12 word fix A: MpW1, MpW2, MpWPhone).
  *
- * The PM selects a word in a meeting's summary, a quote or the transcript ("More engaged") and types what it is ("MoEngage"). It is kept
- * as one of the lessons of lib/meeting-learn.js, of kind 'term': its phrase is the heard words, its meaning is the fix. So, with no new
- * record, the agent's handoff already carries it for later notes (meeting-learn.js handoffLines: "“more engaged”: MoEngage") and its
- * Undo is the lesson's forget. The page shows the fix in every place this note shows the words, and underlines the heard words in other
- * notes with the fix as the guess. The note's own files are NOT rewritten: rewriting every stored copy of a word is not proven.
+ * The PM selects a word or a few words in a meeting's notes ("Lite box") and fixes it ("Lightbox"). The fix shows at once in every place
+ * this note shows the words. Remembering it for LATER notes waits for the PM (batch 27 item 12): the ✦ ask "Remember “Lightbox” for your
+ * next meetings?" — ✓ makes it one of the lessons of lib/meeting-learn.js, of kind 'term' (its phrase is the heard words, its meaning the
+ * fix), so the agent's handoff carries it for later notes (meeting-learn.js handoffLines) and other notes underline the heard words with
+ * the fix as the guess. ✕ keeps it in this note only. A fix made before batch 27 was a lesson at once; it stays remembered.
+ * The note's own files are NOT rewritten: rewriting every stored copy of a word is not proven.
  *
- *   term(dir, { note, heard, means, now }) → { ok, term, terms } | { ok: false, status, error }
- *   terms(dir) → [{ id, heard, means, note, at }]   the word fixes that hold now; the latest fix of the same words in a note wins
- *   (forget: lib/meeting-learn.js forget({ lesson: <term id> }))
- * One line of <runtime>/meeting-lessons.jsonl per fix, append-only, file mode. Nothing here sends anything. */
+ *   term(dir, { note, heard, means, now }) → { ok, term, terms } | { ok: false, status, error }    the fix, in this note only (keep 'ask')
+ *   keep(dir, { lesson, keep: true | false, now }) → { ok, term, terms } | { ok: false, status, error }   the PM's answer to the ✦ ask
+ *   terms(dir) → [{ id, heard, means, note, at, keep: 'yes' | 'ask' | 'no' }]   the fixes that hold now; the latest fix of the same words in a note wins
+ *   (Undo: lib/meeting-learn.js forget({ lesson: <term id> }), which this module honours too)
+ *
+ * THE FILE. <runtime>/meeting-lessons.jsonl (meeting-learn.js FILE), append-only, file mode: { t: 'term' } is a fix in its note,
+ * { t: 'lesson', kind: 'term' } with the same id is the fix remembered, { t: 'keep', lesson, keep: 'no' } is "this note only", and
+ * { t: 'forget', lesson } takes the fix away. Nothing here sends anything. */
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const ML = require('./meeting-learn.js');
 
 const NOTE_ID = /^[A-Za-z0-9_-]{1,80}$/;
+const LESSON_ID = /^l[0-9a-f]{10}$/;
 const MAX_WORD = 60;
 const clean = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
 /** The heard words as a lesson's phrase: lower case, the same words meeting-learn.js mentions() matches. */
 const phraseOf = (s) => (clean(s).toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}.'-]*/gu) || []).map((w) => w.replace(/[.'-]+$/, '')).filter(Boolean).join(' ');
 
+function readLines(dir) {
+  let text = '';
+  try { text = fs.readFileSync(path.join(dir, ML.FILE), 'utf8'); } catch { return []; }
+  const out = [];
+  for (const l of text.split('\n')) { if (!l.trim()) continue; try { const o = JSON.parse(l); if (o && typeof o === 'object') out.push(o); } catch { /* a torn line is skipped */ } }
+  return out;
+}
+
 function terms(dir) {
+  if (!dir) return [];
+  const by = new Map();
+  for (const l of readLines(dir)) {
+    if (l.t === 'term' && l.id && l.phrase && l.meaning) by.set(l.id, { id: l.id, heard: l.phrase, means: l.meaning, note: l.note, at: l.at, keep: 'ask' });
+    else if (l.t === 'lesson' && l.kind === 'term' && l.id && l.phrase && l.meaning) {
+      const x = by.get(l.id);
+      if (x) x.keep = 'yes'; else by.set(l.id, { id: l.id, heard: l.phrase, means: l.meaning, note: l.note, at: l.at, keep: 'yes' });
+    } else if (l.t === 'keep' && by.has(l.lesson)) { const x = by.get(l.lesson); if (x.keep === 'ask') x.keep = 'no'; }
+    else if (l.t === 'forget' && l.lesson) by.delete(l.lesson);
+  }
   const out = [];
-  for (const l of ML.lessons(dir)) {
-    if (l.kind !== 'term' || !l.phrase || !l.meaning) continue;
-    const i = out.findIndex((x) => x.note === l.note && x.heard === l.phrase);
+  for (const x of by.values()) {
+    const i = out.findIndex((y) => y.note === x.note && y.heard === x.heard);
     if (i >= 0) out.splice(i, 1);
-    out.push({ id: l.id, heard: l.phrase, means: l.meaning, note: l.note, at: l.at });
+    out.push(x);
   }
   return out;
 }
@@ -46,8 +69,25 @@ function term(dir, body = {}) {
   const at = new Date(body.now || Date.now()).toISOString();
   const id = 'l' + crypto.createHash('sha1').update('term|' + note + '|' + heard + '|' + means + '|' + at).digest('hex').slice(0, 10);
   fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(path.join(dir, ML.FILE), JSON.stringify({ v: 1, t: 'lesson', id, phrase: heard, kind: 'term', meaning: means, orig: null, note, point: '', at }) + '\n');
-  return { ok: true, term: { id, heard, means, note, at }, terms: terms(dir) };
+  fs.appendFileSync(path.join(dir, ML.FILE), JSON.stringify({ v: 1, t: 'term', id, phrase: heard, meaning: means, note, at }) + '\n');
+  const all = terms(dir);
+  return { ok: true, term: all.find((x) => x.id === id), terms: all };
+}
+
+/** The PM's answer to "Remember “…” for your next meetings?": ✓ makes the fix a lesson for later notes, ✕ keeps it in its note. */
+function keep(dir, body = {}) {
+  if (!dir) return { ok: false, status: 500, error: 'no runtime folder' };
+  const id = String(body.lesson || '');
+  if (!LESSON_ID.test(id)) return { ok: false, status: 400, error: 'lesson is the id of a word fix' };
+  if (typeof body.keep !== 'boolean') return { ok: false, status: 400, error: 'keep is true (remember it) or false (this meeting only)' };
+  const x = terms(dir).find((y) => y.id === id);
+  if (!x) return { ok: false, status: 404, error: 'no word fix has that id' };
+  const at = new Date(body.now || Date.now()).toISOString();
+  const line = body.keep ? { v: 1, t: 'lesson', id, phrase: x.heard, kind: 'term', meaning: x.means, orig: null, note: x.note, point: '', at }
+    : { v: 1, t: 'keep', lesson: id, keep: 'no', at };
+  if (body.keep || x.keep === 'ask') fs.appendFileSync(path.join(dir, ML.FILE), JSON.stringify(line) + '\n');
+  const all = terms(dir);
+  return { ok: true, term: all.find((y) => y.id === id), terms: all };
 }
 
-module.exports = { term, terms, MAX_WORD };
+module.exports = { term, terms, keep, MAX_WORD, phraseOf };

package/workspace/lib/notes-screen.js

@@ -5,6 +5,7 @@
  *   list(runtimeDir, id) → [{ t, file, w, h, bytes, why?, text? }]   sorted by t; empty when the note has none
  *   serve(req, res, runtimeDir, id, t)        the shot at t as its image, cached for good; 404 JSON when there is none
  *   remove(runtimeDir, id) → boolean          delete the note's screenshots
+ *   readShot(runtimeDir, id, frame) → Buffer | null · setJev(runtimeDir, id, frame, jev) → boolean   what Jev saw in a shot (lib/jev-screen.js)
  *   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)
@@ -294,7 +295,20 @@ function readText(bin, runtimeDir, id, frame) {
     });
   });
 }
+/** The bytes of one listed shot, or null. */
+function readShot(runtimeDir, id, frame) {
+  if (!ID_RE.test(String(id || '')) || !frame || !FILE_RE.test(String(frame.file || ''))) return null;
+  try { return fs.readFileSync(path.join(dirOf(runtimeDir, id), frame.file)); } catch { return null; }
+}
+/** Keep what Jev saw in a shot ({ kind, box?, … }) on its row, only if the same shot is still there and not set aside. */
+function setJev(runtimeDir, id, frame, jev) {
+  const rows = readIndex(runtimeDir, id);
+  const row = rows.find((f) => f.t === frame.t && f.file === frame.file && f.bytes === frame.bytes && !f.aside);
+  if (!row) return false;
+  row.jev = jev;
+  try { writeIndex(runtimeDir, id, rows); return true; } catch { return false; }
+}
 /** Resolves when every text read queued so far has ended. */
 function ocrIdle() { return queue.then(() => (waiting > 0 ? ocrIdle() : undefined)); }
 
-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 };
+module.exports = { add, list, readShot, setJev, 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/report-chat.js

@@ -31,7 +31,7 @@ const RULE = [
   '  A change to the draft of a set-up report (a date, a slide, a wording): {"kind":"report","id":"<its id>","change":"the change, in the PM\'s words"}. The page passes it to the report\'s own session by itself, with no press, and the draft updates beside this chat; nothing is issued. Do not change the draft yourself.',
   '  Every refinement the PM gives about a set-up report (the tab shows "Draft · <date>"), in this chat or later in it, is such a change: end with the change block, with the whole change in it, and say in ONE line what you passed, e.g. "Passed to the Nov 9 draft: tender stays open with no award date; Feature implementation not started."',
   '  Never say "press Draft it", "the proposal is unchanged" or "the report drafts in its own session" for a set-up report. If the draft needs something you do not know (a date), ask it once in the same answer and pass the change with what is known: the draft marks the unknown, it does not wait.',
-  '  A look change to the open draft (a palette, tables, a Gantt style) is such a change too. Put the paths of any file the PM attached (a sample PDF, a screenshot) in the change text, so the report\'s session reads them. Several changes in a row each pass; say the draft is updating, never "the draft stays as it is".',
+  '  A LOOK change (a palette, colours, fonts, table format, a Gantt or chart style, "follow this deck or screenshot") is NOT a change to the draft text: the drafting session may not change the look. Send {"kind":"report","id":"<its id>","design":"the look, in the PM\'s words, complete"} and, when the PM attached a file to follow, "sample":"<its path>" (a .pdf, .pptx, .docx, .png or .jpg; one file, the newest). The page starts the next look version by itself; the PM keeps it with ✓ beside the chat and the open draft is redrawn in it, its numbers unchanged. Say that in one line. A message that asks for both sends the look as "design" and the words as "change" in one block.',
   '  An issued report (its latest cycle is issued) is frozen: pass nothing, and say the change goes into the template for the next cycle.',
   '  The set-up reports are the setup lines of report-setups.jsonl (planning/ or pmos/state/); a later change line wins, a remove line deletes one.',
   '- A chart of one measure: {"kind":"chart","proposal":{"measure":"<KR metric id>","title":"short title","question":"what it answers","form":"line|bars|number|meter","range":null,"target":null,"better":"higher|lower","note":""}}',
@@ -43,7 +43,7 @@ const RULE = [
   'If the message is not about a report, a chart or a dashboard, answer it and add no block.',
 ].join('\n');
 
-const REMIND = 'This chat is about a report. If it is set up (report-setups.jsonl, by name) every refinement is a change to its open draft: end with {"kind":"report","id":"<its id>","change":"the whole change, in the PM\'s words"} in a pmos-report block, the page passes it by itself, and say in one line what you passed and that the draft is updating (put the paths of attached files in the change). Never say "the draft stays as it is" or "press Draft it" or "the proposal is unchanged" for a set-up report; ask anything unknown once and pass what is known. An issued report is frozen: pass nothing. Same rules as before.';
+const REMIND = 'This chat is about a report. If it is set up (report-setups.jsonl, by name) every refinement is a change to its open draft: end with {"kind":"report","id":"<its id>","change":"the whole change, in the PM\'s words"} in a pmos-report block, the page passes it by itself, and say in one line what you passed and that the draft is updating. A look change (palette, tables, Gantt, a deck or screenshot to follow) is "design":"the look" with "sample":"<the attached file path>" instead of "change": the page starts the next look and the PM keeps it with ✓. Never say "the draft stays as it is" or "press Draft it" or "the proposal is unchanged" for a set-up report; ask anything unknown once and pass what is known. An issued report is frozen: pass nothing. Same rules as before.';
 
 /** A later message in a chat that already carried the rule (the PM refines without saying "report"): the short reminder, then the PM's words. */
 function remind(text) { return MARK + ' ' + REMIND + '\n\n' + SAYS + String(text == null ? '' : text); }
@@ -57,7 +57,7 @@ function linkedNote(rep) {
   return [
     `This chat set up the report "${name}" (report id ${id}). The PM pressed Draft it already: the report is set up and its own session drafts it.${rep.draft ? ' Its latest draft: ' + String(rep.draft).slice(0, 200) + '.' : ''}`,
     'Read every message here as feedback on that draft unless it is plainly about something else. Never tell the PM to press Draft it again, and never say the proposal is unchanged.',
-    `When the PM asks for a change to the draft in any words (a date, a status, a row, a slide, a wording, a point to keep open), answer in a few lines and end with {"kind":"report","id":"${id}","change":"the change, in the PM's words, complete"}. Put every point of the PM's message in "change"; it is all the report's session reads.`,
+    `A look change (palette, tables, a Gantt or chart style, a deck or screenshot to follow) is {"kind":"report","id":"${id}","design":"the look, complete","sample":"<the attached file's path, if any>"}: the page starts the next look and the PM keeps it with ✓. When the PM asks for a change to the draft's content in any words (a date, a status, a row, a slide, a wording, a point to keep open), answer in a few lines and end with {"kind":"report","id":"${id}","change":"the change, in the PM's words, complete"}. Put every point of the PM's message in "change"; it is all the report's session reads.`,
     'PMOS passes the block to the report\'s session as your answer lands, and the draft beside this chat changes. Say so in one line. When you need an answer from the PM first, ask it and add no block.',
   ].join('\n');
 }

package/workspace/lib/routes-lab.js

@@ -35,19 +35,61 @@ function titles(w) {
   try { const b = require('./routes-boards.js').baseRows(w); if (b && b.ok) for (const r of b.rows || []) if (r && r.id) m.set(r.id, { title: r.title || r.id, board: r.board || '' }); } catch { /* none */ }
   return m;
 }
+// Why a grill run started, in plain words (lib/grill-runs.js why), for "Checked <initiative> for risks · <why> · <what it found>"
+// (Wawan, 2026-11-04: "I don't understand" "Grill · … why: monthly").
+const GRILL_WHY = { monthly: 'monthly check', ask: 'you asked', exit: 'it passed a stage', forecast: 'its forecast moved', move: 'its tasks or end date moved', plan: 'its PRD changed' };
+const plural = (n, one, many) => n + ' ' + (n === 1 ? one : many);
+/** A grill run's findings: filed by the run (proposals.js propose lines carry the run), and the ones still waiting for the PM. */
+function grillFound(P, run) {
+  let filed = 0, waiting = 0;
+  if (!P) return { filed, waiting };
+  const kept = PR.keptIds(P);
+  for (const p of P.props.values()) if (p.run === run) { filed++; if (!kept.has(p.id) && !P.drops.has(PR.sigOf(p))) waiting++; }
+  return { filed, waiting };
+}
+/** A report job of the shared queue (origin report-design:<id>), named with the report: "Redrew TSC Monthly in its saved look". */
+function reportRow(x, root, runtimeDir) {
+  let name = '';
+  // a line written before the queue kept `ref`: the session's own record still names its origin
+  if (!x.ref && x.session && runtimeDir && /^[A-Za-z0-9-]{1,40}$/.test(x.session)) {
+    try { const o = JSON.parse(fs.readFileSync(require('path').join(runtimeDir, 'sessions', x.session + '.json'), 'utf8')).origin; if (typeof o === 'string' && o.startsWith('report-design:')) x = { ...x, ref: o.slice(14) }; } catch { /* the session record is gone */ }
+  }
+  // or the cycle render it wrote: a <slot>.design.json written within two minutes of the job's end
+  if (!x.ref && root) {
+    try {
+      const path = require('path'), dir = path.join(root, require('./report-draft.js').stateRel(root), 'reports'), end = Date.parse(x.at);
+      let best = null;
+      for (const id of fs.readdirSync(dir)) {
+        let files; try { files = fs.readdirSync(path.join(dir, id)); } catch { continue; }
+        for (const f of files) if (f.endsWith('.design.json')) { const d = Math.abs(fs.statSync(path.join(dir, id, f)).mtimeMs - end); if (d <= 120000 && (!best || d < best.d)) best = { id, d }; }
+      }
+      if (best) x = { ...x, ref: best.id };
+    } catch { /* no reports folder */ }
+  }
+  try { if (x.ref && root) { const s = require('./report-setups.js').stateOf(root).setups.get(x.ref); name = s && s.name ? s.name : ''; } } catch { name = ''; }
+  const what = /cycle/.test(x.title || '') ? 'Redrew ' + (name || 'a report') + ' in its saved look' : 'Made the next look of ' + (name || 'a report');
+  return { job: x.job, title: what, meta: '', at: x.at };
+}
 /** What the other background jobs did this week, as record rows. Each source that cannot be read is left out. */
 function others(ctx, w, dir, T, now) {
   const out = [], since = now - WEEK, name = (ini) => (T.get(ini) || {}).title || ini;
   try {
     const G = require('./grill.js'), F = ctx.runtimeDir ? G.read(ctx.runtimeDir) : null;
-    for (const r of F ? F.runs.values() : []) if (r.ended && r.ok !== false && r.ws === w.id && (Date.parse(r.endAt || r.at) || 0) >= since) out.push({ job: 'grill', title: 'Grill · ' + name(r.ini), meta: 'why: ' + r.why, at: r.endAt || r.at, ini: r.ini, board: r.board || '' });
+    const P = (() => { try { return dir ? PR.read(dir) : null; } catch { return null; } })();
+    for (const r of F ? F.runs.values() : []) if (r.ended && r.ok !== false && r.ws === w.id && (Date.parse(r.endAt || r.at) || 0) >= since) {
+      const f = grillFound(P, r.run);
+      const found = !f.filed ? 'nothing found' : f.waiting === f.filed ? plural(f.filed, 'finding', 'findings') + ' waiting'
+        : plural(f.filed, 'finding', 'findings') + (f.waiting ? ', ' + f.waiting + ' waiting' : ', all seen');
+      // the initiative chip only when something waits there for the PM
+      out.push({ job: 'grill', title: 'Checked ' + name(r.ini) + ' for risks', meta: [GRILL_WHY[r.why] || r.why, found].filter(Boolean).join(' · '), at: r.endAt || r.at, ...(f.waiting ? { ini: r.ini, board: r.board || '' } : {}) });
+    }
   } catch { /* no grill log */ }
   try {
     // the AI jobs' audit (lib/ai-guard.js AUDIT), read as a file: this page files nothing through the guard
     const audit = dir ? fs.readFileSync(require('path').join(dir, 'ai-audit.jsonl'), 'utf8').split('\n').slice(-400).map((s) => { try { return JSON.parse(s); } catch { return null; } }).filter(isObj) : [];
     for (const l of audit) if (l.event === 'end' && (Date.parse(l.at) || 0) >= since) out.push({ job: l.job, title: (JOB_NAMES[l.job] || l.job), meta: l.filed != null ? l.filed + ' filed' : '', at: l.at });
   } catch { /* no audit */ }
-  try { if (ctx.bgQueue && typeof ctx.bgQueue.record === 'function') for (const x of ctx.bgQueue.record({ ws: w.id, since }) || []) if (isObj(x) && x.job !== 'grill') out.push(x); /* grill runs are read above, from their own log */ } catch { /* the queue says nothing */ }
+  try { if (ctx.bgQueue && typeof ctx.bgQueue.record === 'function') for (const x of ctx.bgQueue.record({ ws: w.id, since }) || []) if (isObj(x) && x.job !== 'grill') out.push(x.job === 'report-design' ? reportRow(x, w.root, ctx.runtimeDir) : x); /* grill runs are read above, from their own log */ } catch { /* the queue says nothing */ }
   return out;
 }
 

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

@@ -10,10 +10,14 @@
  *   POST /api/meeting-points/forget { lesson } → { ok }        Undo of what PMOS learned, and of a word fix (its term id)
  *   POST /api/meeting-points/term { note, heard, means } → { ok, term, terms }   a word fixed in place, in every place the note shows it
  *   The GET answers { terms } too: the word fixes that hold now (lib/meeting-terms.js).
+ *   POST /api/meeting-points/keep { lesson, keep } → { ok, term, terms }   the ✦ ask: remember a word fix for the next meetings (true) or not
+ *   GET  /api/meeting-points/suggest?note=<id>&heard=<words>&invite=<text>…&people=<name>… → { ok, suggest: { means, from, file?, alts } | null }
+ *        the spelling a word fix offers (lib/meeting-suggest.js): a fix remembered before, the invite the page sends, the workspace's repository
  * The POSTs are page presses (lib/pm-guard.js requirePagePress). Handlers are pure over (q | body, ctx) so a test needs no server. */
 const MP = require('./meeting-points.js');
 const ML = require('./meeting-learn.js');
 const MT = require('./meeting-terms.js');
+const MS = require('./meeting-suggest.js');
 const guard = require('./pm-guard.js');
 
 const fail = (status, error) => ({ status, body: { ok: false, error } });
@@ -26,7 +30,7 @@ function read(q, ctx) {
 function learn(req, body, ctx, op) {
   const g = guard.requirePagePress(req, body);
   if (!g.ok) return fail(g.status, g.error);
-  const r = op === 'forget' ? ML.forget(ctx.runtimeDir, body) : op === 'term' ? MT.term(ctx.runtimeDir, body) : ML.edit(ctx.runtimeDir, body);
+  const r = op === 'forget' ? ML.forget(ctx.runtimeDir, body) : op === 'term' ? MT.term(ctx.runtimeDir, body) : op === 'keep' ? MT.keep(ctx.runtimeDir, body) : ML.edit(ctx.runtimeDir, body);
   if (!r.ok) return fail(r.status || 400, r.error);
   return { status: 200, body: r };
 }
@@ -37,13 +41,33 @@ function write(req, body, ctx) {
   return r.ok ? { status: 200, body: { ok: true, points: r.points } } : fail(r.status || 400, r.error);
 }
 
+/** The ✦ spelling for heard words: the remembered fixes, the invite's words the page sends, and the note's workspace repository. */
+function suggest(q, ctx, all = {}) {
+  const note = String(q.note || ''), heard = String(q.heard || '').replace(/\s+/g, ' ').trim();
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(note)) return fail(400, 'note is the id of a meeting note');
+  if (!heard || heard.length > MT.MAX_WORD) return fail(400, 'heard is the words to fix, at most ' + MT.MAX_WORD + ' characters');
+  const list = (k) => (Array.isArray(all[k]) ? all[k] : []).map((x) => String(x).slice(0, 300)).slice(0, 60);
+  let repo = [];
+  try {
+    const n = require('./notes.js').load(ctx.runtimeDir, note);
+    const w = n && n.ws && typeof ctx.getWs === 'function' ? ctx.getWs(n.ws) : null;
+    if (w && w.root) repo = MS.repoWords(w.root, { exclude: require('./typesafe-settings.js').getRepo(ctx.runtimeDir, w.root).exclude || [] });
+  } catch { repo = []; }   // no repository to read: the other places still answer
+  const fixes = MT.terms(ctx.runtimeDir).filter((x) => x.keep === 'yes' || x.note === note);
+  return { status: 200, body: { ok: true, suggest: MS.suggest({ heard, fixes, invite: list('invite'), people: list('people'), repo }) } };
+}
+
 const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true; };
 
 module.exports = {
   prefixes: ['/api/meeting-points'],
-  read, write, learn,
+  read, write, learn, suggest,
   handle: async (req, res, url, ctx) => {
-    const op = url.pathname === '/api/meeting-points/edit' ? 'edit' : url.pathname === '/api/meeting-points/forget' ? 'forget' : url.pathname === '/api/meeting-points/term' ? 'term' : '';
+    if (url.pathname === '/api/meeting-points/suggest') {
+      if (req.method !== 'GET') return respond(ctx, res, fail(405, 'GET only'));
+      return respond(ctx, res, suggest(Object.fromEntries(url.searchParams), ctx, { invite: url.searchParams.getAll('invite'), people: url.searchParams.getAll('people') }));
+    }
+    const op = { '/api/meeting-points/edit': 'edit', '/api/meeting-points/forget': 'forget', '/api/meeting-points/term': 'term', '/api/meeting-points/keep': 'keep' }[url.pathname] || '';
     if (op) {
       if (req.method !== 'POST') return respond(ctx, res, fail(405, 'POST only'));
       const got = await ctx.readJson(req);

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

@@ -5,7 +5,8 @@
  *   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
+ *        shots, joined. It writes nothing itself. When kept shots have no answer from Jev yet and the gates let notes use Jev, the
+ *        handler starts Jev on them in the background (routes-notes.js lookAtShots) and sets `jev_running`. 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.
@@ -16,6 +17,7 @@ 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 jevScreen = require('./jev-screen.js');
 
 const fail = (status, error) => ({ status, body: { ok: false, error } });
 const DAY = /^\d{4}-\d{2}-\d{2}$/;
@@ -59,6 +61,8 @@ async function read(q, ctx) {
   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 });
+  // Jev is cutting this note's shots to the slide now (opening the note starts it, lib/routes-notes.js): the page reads the replay again
+  if (jevScreen.busy(note.id)) body.jev_running = true;
   return { status: 200, body };
 }
 
@@ -70,6 +74,13 @@ module.exports = {
   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 }));
+    const r = await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json });
+    // shots Jev has not looked at (a past meeting, kept before Jev was on): start Jev on them in the background, as GET
+    // /api/notes/one does, so a replay opened from the calendar is cut to the slide too. It never blocks the answer.
+    const nid = r.status === 200 && r.body && r.body.note ? r.body.note.id : null;
+    if (nid && !r.body.jev_running && notesScreen.list(ctx.runtimeDir, nid).some((f) => !f.jev)) {
+      try { if (require('./routes-notes.js').lookAtShots(ctx, nid)) r.body.jev_running = true; } catch { /* advisory */ }
+    }
+    return respond(ctx, res, r);
   },
 };

package/workspace/lib/routes-notes.js

@@ -100,6 +100,7 @@ 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 jevScreen = require('./jev-screen.js');
 const notesEcho = require('./notes-echo.js');
 const notesPolish = require('./notes-polish.js');
 const notesFinal = require('./notes-final.js');
@@ -135,12 +136,28 @@ function enrich(ctx, id, added, kind = 'lines') {
 }
 function gatesFor(ctx, root) {
   const dir = ctx.runtimeDir;
-  if (!root) return { root: null, exclude: [], ask: null, check: false, key: null, askOpts: {} };
+  if (!root) return { root: null, exclude: [], ask: null, askImage: null, check: false, key: null, askOpts: {} };
   const repo = tsSettings.getRepo(dir, root);
   const sw = jevNotes.getSwitch(dir, root);
   const key = tsSettings.getKey(dir);
   const snd = jevNotes.senderFor(key, { consent: repo.consent, jev: sw.jev, check: sw.check }, typeof ctx.jevModelOpts === 'function' ? ctx.jevModelOpts(root) : {});
-  return { root, exclude: repo.exclude, ask: snd.ask, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
+  return { root, exclude: repo.exclude, ask: snd.ask, askImage: snd.askImage, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
+}
+/** The repository whose gates hold for Jev looking at a note's shots: the note's own, or for a note bound to no repository
+ * (most past meetings) the first repository where "notes may use Jev" is on and the PM gave consent. */
+function shotRootOf(ctx, note) {
+  const w = note.ws && typeof ctx.getWs === 'function' ? ctx.getWs(note.ws) : null;
+  if (w && w.root) return w.root;
+  return jevNotes.onRoots(ctx.runtimeDir).find((r) => tsSettings.getRepo(ctx.runtimeDir, r).consent) || null;
+}
+/** Jev looks at the note's shots it has not seen (MpJ), in the background, when the repository's gates let notes use Jev.
+ * Opening a past meeting (GET /api/notes/one, GET /api/meeting-replay) starts it, so old captures are cut to the slide too. */
+function lookAtShots(ctx, id) {
+  const note = stillOpen(ctx.runtimeDir, id);
+  if (!note) return null;
+  const g = gatesFor(ctx, shotRootOf(ctx, note));
+  if (!g.askImage) return null;
+  return jevScreen.run({ runtimeDir: ctx.runtimeDir, id, g });
 }
 const stillOpen = (dir, id) => { const r = notes.read(dir, id); return r.ok && !r.note.private ? r.note : null; };
 /** Jev's label (when the label gates hold), then for a checkable item the closest repository passage and Jev's comparison
@@ -798,6 +815,8 @@ async function handle(req, res, url, 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), aside: r.note.private ? 0 : notesScreen.asideCount(dir, nid) };
+      // shots Jev has not looked at yet (kept before Jev was switched on, or while it could not be reached): asked now, in the background
+      if (!r.note.private && r.screen.frames.some((f) => !f.jev)) { try { lookAtShots(ctx, nid); } catch { /* advisory */ } }
       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)
@@ -1027,7 +1046,9 @@ 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, surface: body.surface }));
+    const kept = 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 (kept.ok) { try { lookAtShots(ctx, id); } catch { /* Jev is advisory: the shot is kept either way */ } }
+    return done(kept);
   }
   if (p === '/api/notes/screen-aside') {
     const r = notes.read(dir, id);
@@ -1199,6 +1220,6 @@ function startAgent(ctx, dir, id, w) {
   return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
+module.exports = { prefixes, handle, lookAtShots, shotRootOf, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
   __resetResume: () => { resumedFor = null; },
   __idle: () => Promise.all([transcriber ? transcriber.idle() : null, finalRunner ? finalRunner.idle() : null, ...chains.values()]) };

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

@@ -55,6 +55,19 @@ function cyclesOf(root, id) {
 }
 function readText(root, rel) { try { return fs.readFileSync(path.join(path.resolve(String(root)), rel), 'utf8'); } catch { return null; } }
 function sessionFile(root, id) { return path.join(path.dirname(RT.ledgerOf(root, id)), 'session.json'); }
+// The drafting session's answer to a change (Wawan, 2026-11-04: it declined a look change in its own terminal and the panel said "drafting it"
+// for good). ask() writes ask.json { at, change } and asks the session to write answer.json { text } when it is done or does nothing;
+// stateOf() shows the answer once it is newer than the ask, and says the change is with the session until then.
+const askFile = (root, id) => path.join(path.dirname(RT.ledgerOf(root, id)), 'ask.json');
+const answerFile = (root, id) => path.join(path.dirname(RT.ledgerOf(root, id)), 'answer.json');
+function readJson(f) { try { const o = JSON.parse(fs.readFileSync(f, 'utf8')); return isObj(o) ? o : null; } catch { return null; } }
+function answerOf(root, id) {
+  const a = readJson(askFile(root, id)); if (!a || !a.at) return { asking: null, answer: null };
+  let st = null; try { st = fs.statSync(answerFile(root, id)); } catch { st = null; }
+  const ans = st && st.mtimeMs >= Date.parse(a.at) ? readJson(answerFile(root, id)) : null;
+  const txt = ans && typeof ans.text === 'string' ? ans.text.replace(/\s+/g, ' ').trim().slice(0, 400) : '';
+  return txt ? { asking: null, answer: { text: txt, at: new Date(st.mtimeMs).toISOString(), asked: a.at } } : { asking: { at: a.at }, answer: null };
+}
 function readSession(root, id) { try { const o = JSON.parse(fs.readFileSync(sessionFile(root, id), 'utf8')); return isObj(o) && typeof o.session === 'string' ? o : null; } catch { return null; } }
 const alive = (ctx, sid) => !!sid && !!(ctx.chatSessions && typeof ctx.chatSessions.alive === 'function' && ctx.chatSessions.alive(sid));
 function draftingOf(ctx, w, id) { try { return typeof ctx.structureDraftState === 'function' ? ctx.structureDraftState(w, id) || null : null; } catch { return null; } }
@@ -81,6 +94,7 @@ function stateOf(ctx, w, id, now = Date.now()) {
     template: { current: f.current, versions: f.versions.map((v) => ({ ...v, words: RT.settingsWords(v.settings, names), cycles: counts.get(v.n) || 0 })) },
     cycles, latest, drafting,
     session: sess ? { id: sess.session, alive: alive(ctx, sess.session), since: sess.since || null } : null,
+    ...answerOf(root, id),
     review,
     sections: { saved: live.structure, titles: names.sections(live.structure) || (s && Array.isArray(s.sections) ? s.sections.slice() : []) },
     look: lookOf(root, id, live.design, names),
@@ -152,18 +166,23 @@ function draftWords(id, rel) {
   return rel && slot ? `The draft: ${rel} (slot ${slot}). Change that file in place: edit only the note or notes the change is about, and keep every caveat. `
     + `Do not redraft for a change to the words. Only when the PM asks for fresh numbers, run \`pmos report draft ${id} ${slot} --redraft\`; never \`pmos report draft ${id}\` without the slot, and do not draft a new slot.` : '';
 }
+/** The last line of every change: where the session says what it did, so the PM reads it beside the chat (never only in this terminal). */
+function answerWords(root, id) {
+  return `When you are done, or if you change nothing, write ONE JSON object {"text":"<one or two plain sentences for the PM: what you changed, or why you did not>"} to ${answerFile(root, id)}. A look change (palette, tables, a Gantt style) is not yours: say it goes in the report's look, which the PM keeps with ✓ beside the chat.`;
+}
 /** The words the report's session gets for one change. */
-function askPrompt(skill, id, rel, change) {
+function askPrompt(skill, id, rel, change, root) {
   return `${skill}\n\nThe PM's request for this run, given when it was scheduled (do not ask again): ${id}\n\n`
     + `This is the report's own drafting session (the PMOS report flow), not the PM's chat. ${rel ? draftWords(id, rel) + ' ' : ''}`
-    + `The change the PM asked for: ${change}\nChange only the draft. Never issue, send or share it: the PM issues it on the page.`;
+    + `The change the PM asked for: ${change}\nChange only the draft. Never issue, send or share it: the PM issues it on the page. ${answerWords(root, id)}`;
 }
 function ask(ctx, w, id, change, rel) {
   const root = w.root;
   const d = draftingOf(ctx, w, id);
   const sess = readSession(root, id);
   const target = d && d.state === 'drafting' && alive(ctx, d.session) ? d.session : sess && alive(ctx, sess.session) ? sess.session : null;
-  const msg = `[PMOS report change] ${rel ? draftWords(id, rel) + ' ' : ''}The change: ${change}. Change only the draft; never issue, send or share it.`;
+  try { fs.mkdirSync(path.dirname(askFile(root, id)), { recursive: true }); fs.writeFileSync(askFile(root, id), JSON.stringify({ at: new Date().toISOString(), change: String(change).slice(0, 600) }) + '\n'); } catch { /* the panel then shows no answer */ }
+  const msg = `[PMOS report change] ${rel ? draftWords(id, rel) + ' ' : ''}The change: ${change}. Change only the draft; never issue, send or share it. ${answerWords(root, id)}`;
   if (target) {
     const sent = typeof ctx.sendToSession === 'function' && ctx.sendToSession(target, msg);
     if (sent) return { ok: true, session: target, path: rel, passed: true };
@@ -174,7 +193,7 @@ function ask(ctx, w, id, change, rel) {
   const origin = 'report-session:' + id;
   if (typeof ctx.endSupersededRuns === 'function') { try { ctx.endSupersededRuns(origin); } catch { /* the old one ends by itself */ } }
   const s = setupOf(root, id);
-  const sp = ctx.spawnSession({ name: 'Report · ' + ((s && s.name) || id), agent: 'claude', ws: w.id, origin, initialInput: askPrompt(skill, id, rel, change) + '\r' });
+  const sp = ctx.spawnSession({ name: 'Report · ' + ((s && s.name) || id), agent: 'claude', ws: w.id, origin, initialInput: askPrompt(skill, id, rel, change, root) + '\r' });
   if (!sp || sp.state === 'exited' || !sp.id) return { ok: false, status: 409, error: 'The report\'s session did not start: ' + ((sp && sp.note) || 'no session') };
   try { fs.mkdirSync(path.dirname(sessionFile(root, id)), { recursive: true }); fs.writeFileSync(sessionFile(root, id), JSON.stringify({ session: sp.id, since: new Date().toISOString() }) + '\n'); } catch { /* shown as no session */ }
   return { ok: true, session: sp.id, path: rel, started: true };
@@ -250,7 +269,18 @@ async function handle(req, res, url, ctx) {
     if (!ar.ok) return fail(ar);
     const names = RT.namesOf(w.root, id);
     const v = RT.addVersion(w.root, id, next, { names, why: RT.diffWords(was, next, names).join('; ').slice(0, 200) });
-    return v.ok ? send({ status: 200, body: { ok: true, n: v.n, state: stateOf(ctx, w, id) } }) : fail(v);
+    if (!v.ok) return fail(v);
+    // a new look kept with ✓ redraws the open draft in it at once, as the design studio's "This is it" does (Wawan, 2026-11-04: the look asked
+    // for in the chat never reached the draft). Only the look is redrawn: the text and its numbers stay; an issued cycle keeps its look.
+    let redraw = null;
+    if (ar.done && ar.done.design && next.design != null) {
+      const cur = cyclesOf(w.root, id)[0];
+      if (cur && cur.state === 'draft') {
+        let r; try { r = require('./routes-report-design.js').startCycle(ctx, w, id, cur.path); } catch (e) { r = { ok: false, error: String((e && e.message) || e) }; }
+        redraw = { path: cur.path, slot: cur.slot, started: !!(r && r.ok), ...(r && r.ok ? {} : { reason: String((r && r.error) || '') }) };
+      } else if (cur) redraw = { path: cur.path, slot: cur.slot, started: false, reason: 'sent' };
+    }
+    return send({ status: 200, body: { ok: true, n: v.n, redraw, state: stateOf(ctx, w, id) } });
   }
   if (sub === 'restore') {
     const f = RT.backfill(w.root, id, RT.fold(RT.readLines(w.root, id))), v = f.versions.find((x) => x.n === +body.n);