create-pmos 0.527.0 → 0.529.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/okr-goals.js

@@ -154,12 +154,31 @@ function read(root) {
 function matchAnchor(anchor, objectives) {
   const s = String(anchor || '').replace(/\*\*/g, '').trim();
   if (!s || /^(health|domain):/i.test(s)) return null;
+  // by name as well as by id (workspace grill W4): an anchor that names a key result's words is that key result, even when its id is
+  // missing, names two key results, or is a number from an older file that now belongs to another key result
+  const named = byName(s, objectives);
   const km = new RegExp('(?:^|[^A-Za-z0-9])' + KR + END).exec(s);
-  if (!km) return null;
+  if (!km) return named;
   const om = new RegExp('(?:^|[^A-Za-z0-9])' + OBJ + END).exec(s.slice(0, km.index + 1));
   const kid = krId(km[1]), oid = om ? objId(om[1]) : null;
   const hits = [];
   for (const o of objectives || []) { if (oid && o.id !== oid) continue; const k = o.krs.find((x) => x.id === kid); if (k) hits.push({ o, k }); }
+  if (named) return named;
+  return hits.length === 1 ? hits[0] : null;
+}
+/** Words compared as words: lower case, letters and digits only, one space between. */
+const words = (t) => String(t || '').toLowerCase().replace(/\([^)]*\)/g, ' ').replace(/[^a-z0-9]+/g, ' ').trim();
+/** The one key result whose name the text holds, or whose name holds the text (two words and 12 letters or more, so "KR2" or one word never match); null
+ *  when none or more than one does. Ids are taken out of the text first, so only the words compare. PURE. */
+function byName(text, objectives) {
+  const t = ' ' + words(String(text || '').replace(new RegExp('\\b(?:' + OBJ + '|' + KR + ')' + END, 'g'), ' ')) + ' ';
+  if (t.trim().length < 8) return null;
+  const part = t.trim().length >= 12 && t.trim().split(' ').length >= 2;   // a part of a name: two words or more, so one word never joins
+  const hits = [];
+  for (const o of objectives || []) for (const k of o.krs || []) {
+    const n = words(k.title);
+    if (n.length >= 8 && (t.includes(' ' + n + ' ') || (part && (' ' + n + ' ').includes(t)))) hits.push({ o, k });
+  }
   return hits.length === 1 ? hits[0] : null;
 }
 
@@ -181,7 +200,8 @@ function build({ okr, goals, initiatives, records, today }) {
   const t = Date.parse(String(today || '').slice(0, 10)) || Date.now();
   const P = okr.period ? Object.assign({}, okr.period, { day: t >= okr.period.from && t <= okr.period.to ? Math.round((t - okr.period.from) / DAY) + 1 : 0, days: Math.round((okr.period.to - okr.period.from) / DAY) + 1, fromAt: iso(okr.period.from), toAt: iso(okr.period.to) }) : null;
   const moversOf = new Map();
-  for (const r of initiatives || []) { const m = matchAnchor(r.anchor, okr.objectives); if (!m) continue; const key = m.o.id + '::' + m.k.id; if (!moversOf.has(key)) moversOf.set(key, []); moversOf.get(key).push(r); }
+  // an initiative with no anchor that resolves, titled with a key result's name, moves that key result (workspace grill W4: the join is by id and by name)
+  for (const r of initiatives || []) { const m = matchAnchor(r.anchor, okr.objectives) || (/^(health|domain):/i.test(String(r.anchor || '').trim()) ? null : byName(r.title, okr.objectives)); if (!m) continue; const key = m.o.id + '::' + m.k.id; if (!moversOf.has(key)) moversOf.set(key, []); moversOf.get(key).push(r); }
   const objectives = okr.objectives.map((o) => ({
     id: o.id, token: o.token, title: o.title,
     krs: o.krs.map((k) => {
@@ -197,4 +217,4 @@ function build({ okr, goals, initiatives, records, today }) {
   return { files: okr.files, period: P, objectives, total: krs.length, read: krs.filter((k) => k.read).length, needs, readers: [...used] };
 }
 
-module.exports = { read, parse, periodOf, dueOf, sourceOf, needOf, matchAnchor, readerOf, build };
+module.exports = { read, parse, periodOf, dueOf, sourceOf, needOf, matchAnchor, byName, readerOf, build };

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-morning-goals.js

@@ -44,7 +44,11 @@ async function read(ctx, req, want) {
   for (const p of await productsOf(ctx, req, want)) {
     const m = await modelOf(ctx, req, p.ws);
     if (!m) { missing.push(p.name); continue; }
-    products.push({ ws: p.ws, name: (m.board && m.board.name && m.board.name !== 'Intelligence' ? m.board.name : p.name), goals: m.goals || [], model: m });
+    // the goal an initiative moves: the goal's own moves, and the OKR file's link (an initiative anchored to a key result that this goal reads)
+    const via = new Map();
+    for (const o of (m.okrFile && m.okrFile.objectives) || []) for (const k of o.krs || []) if (k && k.goal) for (const r of k.moves || []) if (r && r.id) (via.get(k.goal) || via.set(k.goal, []).get(k.goal)).push({ id: r.id });
+    const goals = (m.goals || []).map((g) => (g && via.has(g.id) ? { ...g, moves: [...(g.moves || []), ...via.get(g.id)] } : g));
+    products.push({ ws: p.ws, name: (m.board && m.board.name && m.board.name !== 'Intelligence' ? m.board.name : p.name), goals, model: m });
   }
   const list = MG.collect(products);
   const dir = ctx.runtimeDir || null;

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);

package/workspace/news-viewers-test.js

@@ -152,7 +152,8 @@ const ROWS = { 'psle-article-paywall-lock': { title: 'PSLE Article Paywall Lock'
     await sleep(800);
     await p.click('[data-hm-day]');
     await until(() => p.evaluate(() => !!document.querySelector('#czViewer [data-yd="fin"]')));
-    await p.evaluate(() => { const f = document.querySelector('#czViewer [data-czs-fold="drafts"]'); if (f && f.getAttribute('aria-expanded') !== 'true') f.click(); });
+    // Good morning says "N drafted for you" once: its line opens the fold (batch 27 item 10)
+    await p.click('#czViewer [data-yd="gm-fold"][data-fold="drafts"]');
     await p.click('#czViewer [data-yd="fin"]');
     await until(() => p.evaluate(() => /Project Ascent status summary/.test((document.querySelector('#czVwTitle') || {}).textContent || '')));
     const t = await vwText(p);

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.527.0",
+  "version": "0.529.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.527.0",
+      "version": "0.529.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

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