create-pmos 0.133.0 → 0.135.0

package/workspace/lib/notes-whisper.js

@@ -25,9 +25,14 @@
  * The cuts are long (a pause of 1 s, at least 4 s) so that a cut holds a whole sentence more often than a fragment;
  * lib/notes.js joins a cut that still ends mid-sentence to the one before it.
  *
- * VOCABULARY AND CONTEXT. Each run gets `--prompt` with the names and terms of the repository (the `vocab` callback, or the
- * `prompt` string) and the last line heard from the same source, at most PROMPT_MAX characters. Whisper then spells the
- * repository's people and product terms as the repository does, and reads the cut as the continuation of the line before.
+ * VOCABULARY. Each run gets `--prompt` with the names and terms of the repository (the `vocab` callback, or the `prompt`
+ * string), at most PROMPT_MAX characters, so Whisper spells the repository's people and product terms as the repository does.
+ * The line before is no longer passed (notes-recording-reliability): it made Whisper repeat it, and a line in another language
+ * pulled the next cut into that language. promptFor still takes a previous line for the final pass.
+ *
+ * GUARDS (notes-recording-reliability, lib/notes-live-guard.js). A cut that repeats the line before it is dropped, a sentence
+ * repeated back to back is kept once, the meeting's words are taken out of the microphone's line (the echo through the PM's
+ * speakers), and with English chosen a cut that comes back in another language is run again in English.
  *
  * INVENTED LINES. whisper.cpp's no-speech threshold (`-nth`) drops segments it thinks are silence. A cut that is mostly
  * quiet and comes back as only "Thank you." or "you" is a known invention and is dropped (cleanText). A program too old
@@ -38,6 +43,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const { execFile } = require('child_process');
+const liveGuard = require('./notes-live-guard.js');
 
 const RATE = 16000;
 const FRAME_MS = 100;
@@ -53,6 +59,9 @@ const LEAD_MS = 300;                 // speech that starts a cut keeps this much
 const MIN_RMS = 180;                 // in 16-bit units; below this a frame is quiet whatever the room
 const MAX_QUEUE = 24;
 const RUN_TIMEOUT_MS = 120000;
+const HOLD_MS = 12000;               // a microphone line waits at most this long for the meeting's line of the same time
+const MEETING_LIVE_MS = 30000;       // meeting audio this recent means the meeting is being captured
+const ECHO_KEEP_MS = 60000;          // the lines kept for the echo check
 const MODEL_BASE = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/';
 // The faster model is the same one quantized to 5 bits: a third of the size, so it loads and runs faster on an M1, and it
 // makes a few more mistakes. Every cut starts the program again, so the time to load the model is paid on every line.
@@ -253,9 +262,10 @@ function runWhisper({ bin, model, file, lang = DEFAULT_LANGUAGE, accuracy = DEFA
  * @param {Function} [a.run]     runWhisper, replaceable in the suites
  * @param {Function} [a.detect]  detect, replaceable in the suites
  */
-function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWhisper, detect: det = () => detect(runtimeDir), vocab = null, prompt = '' }) {
+function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = () => {}, run = runWhisper, detect: det = () => detect(runtimeDir), vocab = null, prompt = '',
+  echo = true, holdMs = HOLD_MS, recent = null, lastLine = null }) {
   const bufs = new Map();     // `${id}|${source}` → { id, source, chunks, ms, voicedMs, quietMs, t, noise }
-  const lastText = new Map(); // `${id}|${source}` → the last words heard there, the context of the next cut
+  const lastText = new Map(); // `${id}|${source}` → { text, t }: the last line heard there, for the repetition guard
   const vocabOf = (job) => { if (typeof vocab !== 'function') return prompt || ''; try { return String(vocab({ id: job.id, source: job.source }) || ''); } catch { return prompt || ''; } };
   const noiseOf = new Map();  // source → the quiet level last measured, so a new cut starts from it
   let queue = Promise.resolve();
@@ -264,13 +274,102 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
   // a cut left by a process that ended while the program ran is deleted when the next transcriber starts
   try { for (const f of fs.readdirSync(tmpDir)) if (/^cut-[0-9a-f]+\.wav$/.test(f)) fs.unlinkSync(path.join(tmpDir, f)); } catch { /* no folder yet */ }
 
+  /* LIVE ECHO (notes-recording-reliability). A microphone line is held until the meeting source has nothing left to say about the
+   * same time: the meeting's audio has arrived up to the line's end, no meeting cut queued that starts before the line ends, and
+   * no meeting speech buffered from before then. Then
+   * the meeting's words are taken out of it (lib/notes-live-guard.js stripEcho), and what is left, if anything, is the PM's.
+   * A line is never held longer than holdMs. A note with no meeting audio holds nothing. */
+  const heard = new Map();    // note id → [{ source, t, end, text }] the lines of the last ECHO_KEEP_MS, for the echo check
+  const meetingAt = new Map();// note id → when meeting audio last arrived (Date.now())
+  const meetingTo = new Map();// note id → how far (ms) the meeting audio placed by its own clock has arrived
+  const inQueue = [];         // { id, source, t } of the cuts queued and not yet emitted
+  const held = [];            // { job, text, until }
+  let holdTimer = null;
+  const remember = (job, text) => {
+    const xs = (heard.get(job.id) || []).filter((x) => x.end >= job.t - ECHO_KEEP_MS);
+    xs.push({ source: job.source, t: job.t, end: job.t + job.ms, text });
+    heard.set(job.id, xs);
+  };
+  const meetingBusyBefore = (id, end) => {
+    // the meeting's audio of this time has not arrived yet: its line may still be coming, whichever source the page sent first
+    if (meetingTo.has(id) && meetingTo.get(id) < end) return true;
+    if (inQueue.some((q) => q.id === id && q.source === 'meeting' && q.t < end)) return true;
+    const b = bufs.get(id + '|meeting');
+    return !!(b && b.voicedMs >= MIN_VOICED_MS && b.t < end);
+  };
+  const emit = async (job, text, extra) => {
+    const key = job.id + '|' + job.source;
+    let prev = lastText.get(key);
+    if (!prev && typeof lastLine === 'function') { try { prev = lastLine(job.id, job.source) || null; } catch { prev = null; } }
+    if (liveGuard.repeats(text, prev, job.t)) return;
+    lastText.set(key, { text, t: job.t });
+    remember(job, text);
+    await onText({ ...job, text, ...(extra || {}) });
+  };
+  // the meeting lines heard here, and the note's own meeting lines (`recent`), so a restart still knows what the meeting said
+  const meetingLines = (id) => {
+    let stored = [];
+    try { stored = typeof recent === 'function' ? (recent(id) || []) : []; } catch { stored = []; }
+    return stored.concat((heard.get(id) || []).filter((x) => x.source === 'meeting'));
+  };
+  const ownWords = (job, text) => liveGuard.stripEcho({ t: job.t, end: job.t + job.ms, text }, meetingLines(job.id));
+  function release(force = false) {
+    const now = Date.now();
+    for (let i = 0; i < held.length;) {
+      const h = held[i];
+      if (force || now >= h.until || !meetingBusyBefore(h.job.id, h.job.t + h.job.ms)) {
+        held.splice(i, 1);
+        queue = queue.then(async () => { const own = ownWords(h.job, h.text); if (own) await emit(h.job, own, h.extra); }).catch(() => {});
+      } else i++;
+    }
+    if (holdTimer) { clearTimeout(holdTimer); holdTimer = null; }
+    if (held.length) { holdTimer = setTimeout(() => release(), 250); if (holdTimer.unref) holdTimer.unref(); }
+  }
+  async function deliver(job, text, extra) {
+    // only cuts placed by their capture's own clock (`exact`) are compared: a time taken from arrival says nothing about overlap
+    const meetingLive = echo && job.exact && job.source === 'mic' && Date.now() - (meetingAt.get(job.id) || 0) < MEETING_LIVE_MS;
+    if (!meetingLive) { await emit(job, text, extra); return; }
+    const own = ownWords(job, text);
+    if (!own) return;
+    if (!meetingBusyBefore(job.id, job.t + job.ms)) { await emit(job, own, extra); return; }
+    held.push({ job, text: own, extra, until: Date.now() + holdMs });
+    release();
+  }
+
+  /* LANGUAGE (decision 8: accented English is always English). With English (or detect) chosen, a cut that comes back in
+   * another language is run again forced to English, with the vocabulary alone as its prompt. The English text is kept and the
+   * first text goes with it as `heard_as`. When the run in English still is not English, the first text is kept. */
+  async function transcribe(d, job, file, voicedRatio) {
+    const lang = getLanguage(runtimeDir);
+    const args = { engine: d.engine || 'whisper', bin: d.bin, model: d.model, file, accuracy: getAccuracy(runtimeDir), prompt: promptFor(vocabOf(job), '') };
+    const r = await run({ ...args, lang });
+    if (!r.ok) return r;
+    const text = liveGuard.onceEach(cleanText(r.text, { voicedRatio }));
+    if (!text || !(lang === 'en' || lang === 'auto') || !liveGuard.looksForeign(text, r.language)) return { ok: true, text };
+    const again = await run({ ...args, lang: 'en' });
+    const en = again.ok ? liveGuard.onceEach(cleanText(again.text, { voicedRatio })) : '';
+    if (!en || liveGuard.looksForeign(en, again.language)) return { ok: true, text };
+    return { ok: true, text: en, extra: { heard_as: { text, language: r.language || '' } } };
+  }
+
+  const cutEnd = new Map();   // `${id}|${source}` → where the last cut of that source ended (ms)
   function cut(b) {
     bufs.delete(b.id + '|' + b.source);
-    if (b.voicedMs < MIN_VOICED_MS || !b.chunks.length) return false;
+    cutEnd.set(b.id + '|' + b.source, Math.max(cutEnd.get(b.id + '|' + b.source) || 0, b.t + b.ms));
+    // the caller learns how far this source is transcribed once the cut is done, in order, so a restart redoes a cut it lost
+    // A microphone line still held for the echo check is not written yet, so the progress stops at its start: a restart then
+    // transcribes it again rather than losing it (and the repetition guard drops the lines after it that were written).
+    const done = () => {
+      const waitFor = held.filter((h) => h.job.id === b.id && h.job.source === b.source).map((h) => h.job.t);
+      try { onCut({ id: b.id, source: b.source, until: Math.min(b.t + b.ms, ...waitFor) }); } catch { /* the caller's bookkeeping */ }
+    };
+    if (b.voicedMs < MIN_VOICED_MS || !b.chunks.length) { queue = queue.then(done).catch(() => {}); if (held.length) release(); return false; }
     if (waiting >= MAX_QUEUE) { onError({ id: b.id, source: b.source, error: 'transcription is falling behind, so a few seconds were skipped' }); return false; }
     const pcm = Buffer.concat(b.chunks);
-    const job = { id: b.id, source: b.source, t: b.t, ms: b.ms };
+    const job = { id: b.id, source: b.source, t: b.t, ms: b.ms, ...(b.ts ? { exact: true } : {}) };
     const voicedRatio = b.ms > 0 ? b.voicedMs / b.ms : 1;
+    const q = { id: job.id, source: job.source, t: job.t };
+    inQueue.push(q);
     waiting++;
     queue = queue.then(async () => {
       const d = det();
@@ -279,15 +378,13 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
       const file = path.join(tmpDir, 'cut-' + crypto.randomBytes(6).toString('hex') + '.wav');
       try {
         fs.writeFileSync(file, wav(pcm), { mode: 0o600 });
-        const key = job.id + '|' + job.source;
         // `engine` is 'qwen' when the caller's detect chose Qwen3-ASR (lib/notes-qwen.js); `run` then sends the cut there
-        const r = await run({ engine: d.engine || 'whisper', bin: d.bin, model: d.model, file, lang: getLanguage(runtimeDir), accuracy: getAccuracy(runtimeDir), prompt: promptFor(vocabOf(job), lastText.get(key)) });
+        const r = await transcribe(d, job, file, voicedRatio);
         if (!r.ok) { onError({ ...job, error: r.error }); return; }
-        const text = cleanText(r.text, { voicedRatio });
-        if (text) { lastText.set(key, text); await onText({ ...job, text }); }
+        if (r.text) await deliver(job, r.text, r.extra);
       } catch (e) { onError({ ...job, error: String((e && e.message) || e) }); }
       finally { try { fs.unlinkSync(file); } catch { /* already gone */ } }
-    }).catch(() => {}).finally(() => { waiting--; });
+    }).catch(() => {}).finally(() => { waiting--; done(); const i = inQueue.indexOf(q); if (i >= 0) inQueue.splice(i, 1); if (held.length) release(); });
     return true;
   }
 
@@ -295,24 +392,37 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
    * One chunk from the page. `t` is the chunk's start, in ms from the note's recording start.
    * @returns {{ ok:true, cut:boolean }}
    */
-  function push({ id, source, pcm, t = 0, final = false }) {
+  function push({ id, source, pcm, t = 0, final = false, exact = false }) {
     const k = id + '|' + source;
+    if (source === 'meeting' && pcm && pcm.length) {
+      meetingAt.set(id, Date.now());
+      if (exact) meetingTo.set(id, Math.max(meetingTo.get(id) || 0, t + (pcm.length / 2 / RATE) * 1000));
+    }
+    // a chunk that names its own place and belongs before audio already cut comes too late for the live transcript: on its own it
+    // would be a fragment of a sentence already written. Its audio is kept, and the final pass after Stop reads it.
+    if (exact && !final && t + 1 < (cutEnd.get(k) || 0)) return { ok: true, cut: false, late: true };
     let b = bufs.get(k);
     const lv = pcm && pcm.length ? levels(pcm) : [];
-    if (!b) { b = { id, source, chunks: [], ms: 0, voicedMs: 0, quietMs: 0, t, noise: noiseOf.has(source) ? noiseOf.get(source) : null }; bufs.set(k, b); }
+    if (!b) { b = { id, source, chunks: [], ts: exact ? [] : null, ms: 0, voicedMs: 0, quietMs: 0, t, noise: noiseOf.has(source) ? noiseOf.get(source) : null }; bufs.set(k, b); }
     for (const v of lv) {
       // the quiet level is learnt from quiet frames only, so speech at the very start is not taken for the room's noise
       const voiced = v > Math.max(MIN_RMS, (b.noise == null ? 0 : b.noise) * 3);
       if (voiced) { b.voicedMs += FRAME_MS; b.quietMs = 0; }
       else { b.quietMs += FRAME_MS; b.noise = b.noise == null ? v : b.noise * 0.9 + v * 0.1; }
     }
-    if (pcm && pcm.length) { b.chunks.push(pcm); b.ms += (pcm.length / 2 / RATE) * 1000; }
+    if (pcm && pcm.length) {
+      // a chunk that names its own place (`exact`) and arrives after a later one goes back where it belongs in the buffer
+      const at = exact && b.ts && t < b.t + b.ms - 1 && t >= b.t ? b.ts.findIndex((x) => x > t) : -1;
+      if (at >= 0) { b.chunks.splice(at, 0, pcm); b.ts.splice(at, 0, t); } else { b.chunks.push(pcm); if (b.ts) b.ts.push(t); }
+      b.ms += (pcm.length / 2 / RATE) * 1000;
+    }
     if (b.noise != null) noiseOf.set(source, b.noise);
     // quiet before anyone speaks is not kept: only the last LEAD_MS of it stays in front of the speech
     if (!b.voicedMs && b.ms > LEAD_MS + 1000) {
       const keepBytes = Math.round(RATE * LEAD_MS / 1000) * 2;
       const all = Buffer.concat(b.chunks);
       b.chunks = [all.subarray(Math.max(0, all.length - keepBytes))];
+      if (b.ts) b.ts = [b.t + b.ms - LEAD_MS];
       b.t += b.ms - LEAD_MS; b.ms = LEAD_MS;
     }
     let did = false;
@@ -322,12 +432,25 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, run = runWh
   }
   /** Cut whatever is buffered for a note (the page stopped). */
   function flush(id) { for (const b of Array.from(bufs.values())) if (b.id === id) cut(b); }
+  /** Is audio of this note and source buffered and not cut yet? */
+  const has = (id, source) => bufs.has(id + '|' + source);
   /** Drop a note's buffers without transcribing them (the note was marked private or deleted). */
   function drop(id) {
     for (const [k, b] of Array.from(bufs.entries())) if (b.id === id) bufs.delete(k);
     for (const k of Array.from(lastText.keys())) if (k.startsWith(id + '|')) lastText.delete(k);
+    for (let i = held.length - 1; i >= 0; i--) if (held[i].job.id === id) held.splice(i, 1);
+    heard.delete(id); meetingAt.delete(id); meetingTo.delete(id);
+    for (const k of Array.from(cutEnd.keys())) if (k.startsWith(id + '|')) cutEnd.delete(k);
+  }
+  /** Settled: every queued cut is transcribed and every held line is out. */
+  async function idle() {
+    for (;;) {
+      const q = queue; await q;
+      if (held.length) { release(true); continue; }
+      if (q === queue) return;
+    }
   }
-  return { push, flush, drop, pending: () => waiting, idle: () => queue };
+  return { push, flush, drop, has, pending: () => waiting + held.length, idle };
 }
 
 module.exports = { detect, setupCommand, getLanguage, setLanguage, LANGUAGES, DEFAULT_LANGUAGE, getModel, setModel, MODELS, DEFAULT_MODEL,

package/workspace/lib/notes.js

@@ -520,7 +520,7 @@ function joinText(prev, next, names) {
   const tail = KEEP_CAP.test(next) || (names && names.has(word)) || PROPER_DAYS.test(word) ? next : next.charAt(0).toLowerCase() + next.slice(1);
   return askMark(head.replace(/[,\s]+$/, '') + ' ' + tail);
 }
-function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms = null, now = Date.now() } = {}) {
+function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms = null, heard_as = null, now = Date.now() } = {}) {
   const note = load(dir, id);
   if (!note) return err(404, 'no such note');
   if (note.private) return err(409, 'this note is marked private, so nothing more is recorded in it');
@@ -536,6 +536,8 @@ function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms =
   const tr = note.transcript || (note.transcript = []);
   const tEnd = Number.isFinite(ms) && ms > 0 ? t + Math.round(ms) : null;
   const open = JOINS.has(src) && endsOpen(raw);
+  // the first text of a line that came back in another language and was run again in English (notes-recording-reliability, D8)
+  const heardAs = heard_as && typeof heard_as.text === 'string' && heard_as.text ? { text: heard_as.text.slice(0, MAX_PHRASE), language: String(heard_as.language || '').slice(0, 40) } : null;
   const out = [];
   // the first sentence may finish the line before it, from the same source
   if (JOINS.has(src)) {
@@ -558,7 +560,7 @@ function appendTranscript(dir, { id, text, source = 'speech', t: at = null, ms =
   const base = tr.length;
   const added = sentences.map((s, k) => { const isOpen = open && k === sentences.length - 1;
     return { at: iso(now), t, ...(tEnd != null ? { t_end: tEnd } : {}), text: s, source: src, cat: isOpen ? null : categoryOf(s, names), cat_by: 'local',
-      ...(isOpen ? { open: true } : {}), index: base + k }; });
+      ...(isOpen ? { open: true } : {}), ...(heardAs ? { heard_as: heardAs } : {}), index: base + k }; });
   note.transcript = tr.concat(added.map(({ index, ...x }) => x));
   note.updated_at = iso(now);
   store(dir, note);

package/workspace/lib/outbox-store.js

@@ -1,7 +1,7 @@
 'use strict';
 /* outbox-store.js — the file layer over scripts/outbox.js (console3 wave B3). Sends NOTHING.
  *
- *   <runtime>/outbox/outbox.jsonl    append-only; one line per event: queued | edited | pressed | sent
+ *   <runtime>/outbox/outbox.jsonl    append-only; one line per event: queued | edited | pressed | sent | discarded | restored
  *   <runtime>/outbox/items/<id>.json the scripts/trust/outbox.js item, written only when a sender is registered
  *   <runtime>/outbox/sent.jsonl      the trust ledger of sends (one 'send' line per send, with the override flag)
  *   <runtime>/outbox/promises.jsonl  the promise ledger, through scripts/promises.js (scripts/trust/ledger.js)
@@ -13,10 +13,11 @@
  */
 const fs = require('fs');
 const path = require('path');
-const outbox = require('../../scripts/outbox.js');
-const promises = require('../../scripts/promises.js');
-const T = require('../../scripts/trust/outbox.js');
-const L = require('../../scripts/trust/ledger.js');
+const { repoScript } = require('./repo-script.js');
+const outbox = require(repoScript('outbox.js'));
+const promises = require(repoScript('promises.js'));
+const T = require(repoScript('trust/outbox.js'));
+const L = require(repoScript('trust/ledger.js'));
 
 const dirOf = (runtimeDir) => path.join(runtimeDir, 'outbox');
 const outboxFile = (runtimeDir) => path.join(dirOf(runtimeDir), 'outbox.jsonl');
@@ -37,8 +38,11 @@ function readLines(file) {
 
 function foldOutbox(lines = []) {
   const byId = new Map();
+  const gone = new Set();   // ids the PM discarded; a 'restored' line (the Undo) brings one back
   for (const ev of lines) {
     if (!ev || !ev.id) continue;
+    if (ev.event === 'discarded') { gone.add(ev.id); continue; }
+    if (ev.event === 'restored') { gone.delete(ev.id); continue; }
     if (ev.event === 'queued' || ev.event === 'edited') {
       const { event, ...entry } = ev;
       byId.set(ev.id, { ...entry, state: ev.state === 'blocked' ? 'blocked' : 'queued', last_result: null, refused: null, created_at: (byId.get(ev.id) || {}).created_at || ev.at });
@@ -49,7 +53,7 @@ function foldOutbox(lines = []) {
       else byId.set(ev.id, { ...cur, last_result: ev.reason || null });
     }
   }
-  return [...byId.values()];
+  return [...byId.values()].filter((e) => !gone.has(e.id));
 }
 
 const readOutbox = (runtimeDir) => foldOutbox(readLines(outboxFile(runtimeDir)));

package/workspace/lib/pmos-verbs.js

@@ -63,7 +63,9 @@ function load(verb) {
   const full = path.join(__dirname, VERBS[verb].module);
   try { return require(full); }
   catch (e) {
-    if (e && e.code === 'MODULE_NOT_FOUND' && String(e.message).includes(full)) return null;
+    // Only the module itself missing means "not built". The message also lists the requiring file ("Require stack"), so a
+    // module whose own require fails must not read as absent (incident workspace-package-script-closure).
+    if (e && e.code === 'MODULE_NOT_FOUND' && String(e.message).split('\n')[0].includes(full)) return null;
     throw e;
   }
 }

package/workspace/lib/proactive-cli.js

@@ -11,6 +11,7 @@
  *   pmos proactive feedback <id> useful|not-useful|wrong-priority|opened|dismissed [--note TEXT]
  *   pmos proactive feedback --missed TEXT
  *   pmos proactive brief [show]
+ *   pmos proactive settings [--name TEXT] [--role TEXT] [--work TEXT] [--duties TEXT]   what the PM says about themselves
  *   pmos proactive settings [--brief-source NAME=on|off] [--scope SERVICE:NAME=watch|search|ignore|none] [--day-check 30|60|off]
  *                           [--website URL] [--no-website URL]
  *   pmos proactive brief submit --file PATH [--merge]
@@ -80,6 +81,7 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       patch.triggers = { [m[1]]: m[2] === 'on' };
     }
     if ('name' in flags) patch.name = flags.name;
+    for (const k of ['role', 'work', 'duties']) if (k in flags) patch.about = { ...(patch.about || {}), [k]: String(flags[k]) };
     if ('background-prepare' in flags) { const v = onOff(flags['background-prepare'], '--background-prepare'); if (v.err) return fail(v.err); patch.backgroundPrepare = v; }
     if ('brief-scoring' in flags) { const v = onOff(flags['brief-scoring'], '--brief-scoring'); if (v.err) return fail(v.err); patch.briefScoring = v; }
     if ('brief-source' in flags) {
@@ -116,6 +118,11 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
     }
     say(`engine ${s.enabled ? 'on' : 'off'} · stalled after ${s.stalledDays} days · quiet ${s.quiet ? s.quiet.start + '-' + s.quiet.end : 'none'} · learning ${s.pauseLearning ? 'paused' : 'on'}`);
     say('brief sources: ' + BRIEF_SOURCES.map((k) => `${k} ${s.briefSources && s.briefSources[k] ? 'on' : 'off'}`).join(', ') + ' · scoring ' + (s.briefScoring ? 'on' : 'off') + (s.name ? ' · name ' + s.name : ''));
+    const ab = s.about || {};
+    if (ab.role || ab.work || ab.duties) {
+      say('about the PM: ' + [ab.role && 'role ' + ab.role, ab.work && 'work ' + ab.work].filter(Boolean).join(' · '));
+      if (ab.duties) say('job description: ' + ab.duties.replace(/\n+/g, ' / '));
+    }
     say('background prepare ' + (s.backgroundPrepare ? 'on' : 'off'));
     const dc = s.dayCheck || { every: 60, start: '09:00', end: '18:00' };
     say('day check ' + (dc.every ? `every ${dc.every} min, ${dc.start}-${dc.end}` : 'off') + ' · websites: ' + ((s.websites || []).join(', ') || 'none'));

package/workspace/lib/proactive.js

@@ -43,7 +43,12 @@ const MAX_WEBSITES = 10;
 // G22: the daytime check — every 30 or 60 minutes, or off (0), between start and end of the working day.
 const DAY_CHECK_EVERY = [0, 30, 60];
 const DAY_CHECK_DEFAULT = Object.freeze({ every: 60, start: '09:00', end: '18:00' });
-const DEFAULTS = Object.freeze({ name: '', briefSources: BRIEF_DEFAULT, briefScoring: false, backgroundPrepare: false, enabled: true, triggers: Object.freeze(Object.fromEntries(TRIGGERS.map((t) => [t, true]))), stalledDays: 5, quiet: null, pauseLearning: false,
+// What the PM says about themselves on the first-run page (onboarding-scan-and-map): the role, the work in one line and the
+// job description. The brief, the day check and requirement gathering read it from `pmos proactive settings` to judge
+// what matters to this PM. Plain text only, clipped to these lengths.
+const ABOUT_MAX = Object.freeze({ role: 80, work: 200, duties: 1000 });
+const ABOUT_DEFAULT = Object.freeze({ role: '', work: '', duties: '' });
+const DEFAULTS = Object.freeze({ name: '', about: ABOUT_DEFAULT, briefSources: BRIEF_DEFAULT, briefScoring: false, backgroundPrepare: false, enabled: true, triggers: Object.freeze(Object.fromEntries(TRIGGERS.map((t) => [t, true]))), stalledDays: 5, quiet: null, pauseLearning: false,
   scopes: Object.freeze({ slack: Object.freeze({}), jira: Object.freeze({}), confluence: Object.freeze({}) }), placeRepos: Object.freeze({ slack: Object.freeze({}), jira: Object.freeze({}), confluence: Object.freeze({}) }), dayCheck: DAY_CHECK_DEFAULT, websites: Object.freeze([]) });
 
 const idOf = (key) => crypto.createHash('sha1').update(String(key)).digest('hex').slice(0, 12);
@@ -177,10 +182,18 @@ const HHMM = /^([01]\d|2[0-3]):([0-5]\d)$/;
 /** @returns {{ok:true, settings:object}|{ok:false, error:string}} — `raw` is merged over the defaults; nothing is partly applied. */
 function normalizeSettings(raw) {
   const r = raw && typeof raw === 'object' ? raw : {};
-  const s = { name: DEFAULTS.name, briefSources: { ...BRIEF_DEFAULT }, briefScoring: DEFAULTS.briefScoring, backgroundPrepare: DEFAULTS.backgroundPrepare, enabled: DEFAULTS.enabled, triggers: { ...DEFAULTS.triggers }, stalledDays: DEFAULTS.stalledDays, quiet: DEFAULTS.quiet, pauseLearning: DEFAULTS.pauseLearning,
+  const s = { name: DEFAULTS.name, about: { ...ABOUT_DEFAULT }, briefSources: { ...BRIEF_DEFAULT }, briefScoring: DEFAULTS.briefScoring, backgroundPrepare: DEFAULTS.backgroundPrepare, enabled: DEFAULTS.enabled, triggers: { ...DEFAULTS.triggers }, stalledDays: DEFAULTS.stalledDays, quiet: DEFAULTS.quiet, pauseLearning: DEFAULTS.pauseLearning,
     scopes: { slack: {}, jira: {}, confluence: {} }, placeRepos: { slack: {}, jira: {}, confluence: {} }, dayCheck: { ...DAY_CHECK_DEFAULT }, websites: [] };
   if (r.enabled !== undefined) { if (typeof r.enabled !== 'boolean') return { ok: false, error: 'enabled must be true or false' }; s.enabled = r.enabled; }
   if (r.name !== undefined) { if (typeof r.name !== 'string' || r.name.length > 40) return { ok: false, error: 'name must be text of at most 40 characters' }; s.name = r.name.replace(/\s+/g, ' ').trim(); }
+  if (r.about !== undefined) {
+    if (!r.about || typeof r.about !== 'object' || Array.isArray(r.about)) return { ok: false, error: 'about must be an object of role, work and duties → text' };
+    for (const [k, v] of Object.entries(r.about)) {
+      if (!(k in ABOUT_MAX)) return { ok: false, error: `unknown about field "${k}" — one of ${Object.keys(ABOUT_MAX).join(', ')}` };
+      if (typeof v !== 'string' || v.length > ABOUT_MAX[k]) return { ok: false, error: `about.${k} must be text of at most ${ABOUT_MAX[k]} characters` };
+      s.about[k] = k === 'duties' ? v.replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim() : v.replace(/\s+/g, ' ').trim();
+    }
+  }
   if (r.briefScoring !== undefined) { if (typeof r.briefScoring !== 'boolean') return { ok: false, error: 'briefScoring must be true or false' }; s.briefScoring = r.briefScoring; }
   if (r.backgroundPrepare !== undefined) { if (typeof r.backgroundPrepare !== 'boolean') return { ok: false, error: 'backgroundPrepare must be true or false' }; s.backgroundPrepare = r.backgroundPrepare; }
   if (r.briefSources !== undefined) {

package/workspace/lib/repo-script.js

@@ -0,0 +1,36 @@
+'use strict';
+/* repo-script.js — where a module from the repo's scripts/ tree is, in a checkout AND in an install
+ * (incident workspace-package-script-closure).
+ *
+ *   repoScript('trust/ledger.js') → an absolute path; pass it to require(), or to a child process
+ *
+ * The workspace shares code with the CLI agents run: the ledger, the records, the calendar import, the signal engine.
+ * That code lives in scripts/ at the repo root, and the package ships workspace/ only. So each module is looked for in
+ * two places, in this order, the same order lib/console-state.js uses for the workflow engine:
+ *
+ *   1. ../../scripts/<rel> — a repo checkout (PMOS-self, any dev clone). Preferred, so a developer's workspace runs
+ *      the very file CI and the CLI run.
+ *   2. lib/engine/<rel>    — the copy scripts/vendor-workspace-engine.js makes when it builds the package. It mirrors
+ *      the scripts/ tree, so the module's own relative requires resolve there too.
+ *
+ * When neither exists the second path is returned, and require() names it in its error: that is the path the vendor step
+ * did not fill.
+ *
+ * THE ARGUMENT IS A STRING LITERAL. The vendor step finds what to copy by reading the bundle's source for every
+ * repoScript('<rel>') call, so the list of vendored files is derived from the code and never written down. A call with
+ * any other argument fails the vendor step.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const CHECKOUT = path.join(__dirname, '..', '..', 'scripts');
+const VENDORED = path.join(__dirname, 'engine');
+
+function repoScript(rel) {
+  const r = String(rel || '');
+  if (!r || path.isAbsolute(r) || r.split(/[\\/]/).includes('..')) throw new Error(`repoScript: '${r}' must be a path inside scripts/, such as 'trust/ledger.js'`);
+  const inCheckout = path.join(CHECKOUT, r);
+  return fs.existsSync(inCheckout) ? inCheckout : path.join(VENDORED, r);
+}
+
+module.exports = { repoScript, CHECKOUT, VENDORED };

package/workspace/lib/report-dashboards.js

@@ -13,7 +13,8 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const model = require('../../scripts/calendar-model.js');
+const { repoScript } = require('./repo-script.js');
+const model = require(repoScript('calendar-model.js'));
 
 const ALL = ['portfolio', 'board', 'initiative'];
 const LIBRARY = Object.freeze([
@@ -105,7 +106,9 @@ function scopeFilter(body, facts, scope, id, today, opts = {}) {
   if (scope === 'portfolio') return { ...base, delivery: { rows: deliveryRows(inis, range, today) } };
 
   let onScope;
-  if (scope === 'board') onScope = (i) => boardOf(i, slug) === id;
+  // opts.boardOf is the Initiatives board model (routes-boards.js boardIndex) when the server has it; boardOf is the fallback.
+  const boardFn = typeof opts.boardOf === 'function' ? opts.boardOf : (i) => boardOf(i, slug);
+  if (scope === 'board') onScope = (i) => boardFn(i) === id;
   else if (scope === 'initiative') onScope = (i) => i.id === id;
   else throw new Error('scope must be portfolio, board or initiative');
   const iniIds = new Set(inis.filter(onScope).map((i) => i.id));

package/workspace/lib/report-frame.js

@@ -0,0 +1,122 @@
+/* report-frame.js — the text of a dashboard: one sentence per report, the frame (Headline, Sections, Needs your call, Sources)
+ * and the draft body (initiative console3-dashboard-schedules, PRD R6).
+ *
+ *   modelOf(raw) · builderOf(rep) · plural(n, one, many)
+ *   readingOf(rep, raw)                                   → { line, nums, needs }
+ *   frameOf({ title, reports, raw, audience, today })     → { title, audience, today, headline, sections, needs, sources }
+ *   draftBody(frame)                                      → the outbox draft text
+ *
+ * ONE FILE, BOTH SIDES. The Reports page (public/pm/c3-reports.js) loads it as /lib/report-frame.js (self.ReportFrame), and the
+ * scheduled run (lib/report-schedules.js) requires it, so a scheduled draft reads exactly like a "Make a draft now" draft. Pure: no
+ * DOM, no I/O, no clock.
+ */
+'use strict';
+(function (root, factory) {
+  const api = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  else root.ReportFrame = api;
+})(typeof self !== 'undefined' ? self : this, function () {
+  /* The model the builders read, from the data answer, the way c3-strategy-panels.js build() makes it. */
+  function modelOf(raw) {
+    const M = { ...raw, outcomes: raw.outcomes || [], signals: raw.signals || [] };
+    if (!M.signalsAll) M.signalsAll = M.signals.map((s) => ({ ...s }));
+    return M;
+  }
+  const builderOf = (rep) => (rep && (rep.builder || rep.id)) || '';
+
+  /* ── the text of a report, for the share frame: one sentence, the numbers behind it, and what needs a call ─────────────── */
+  const fmt = (v) => (v == null ? '' : Number.isInteger(v) ? String(v) : String(Math.round(v * 100) / 100));
+  const plural = (n, one, many) => n + ' ' + (n === 1 ? one : many);
+  const ST_TXT = { done: 'done', ok: 'on time', risk: 'at risk', late: 'delayed', over: 'overdue', park: 'parked', prop: 'proposed', none: 'no status' };
+  const SEV_TXT = { pivot: 'at the pivot line', drift: 'drifting', watch: 'on watch', up: 'upside' };
+  function readingOf(rep, raw) {
+    const M = modelOf(raw || {}); const b = builderOf(rep);
+    const out = { line: '', nums: [], needs: [] };
+    if (b === 'north') {
+      const N = M.north; const P = N && N.points;
+      if (!P || P.length < 2) { out.line = 'No north-star metric is recorded.'; return out; }
+      const p = P.find((x) => x.at === N.now) || P[P.length - 1]; const u = N.unit || '';
+      if (p.actual == null || !p.plan) { out.line = (N.label || 'The north star') + ' has no reading yet.'; return out; }
+      const v = Math.round((p.actual / p.plan - 1) * 100);
+      out.line = (N.label || 'The north star') + (v === 0 ? ' is on plan.' : ' is ' + Math.abs(v) + '% ' + (v < 0 ? 'behind' : 'ahead of') + ' plan.');
+      out.nums.push('Now ' + fmt(p.actual) + u + ', plan ' + fmt(p.plan) + u + '.');
+      return out;
+    }
+    if (b === 'outcomes') {
+      const L = M.outcomes;
+      if (!L.length) { out.line = 'No key result is scored.'; return out; }
+      const on = L.filter((k) => k.status === 'ok').length;
+      out.line = on + ' of ' + L.length + ' outcomes ' + (on === 1 ? 'is' : 'are') + ' on course.';
+      for (const k of L) {
+        const u = k.unit || '';
+        out.nums.push(k.status === 'unscored' ? k.name + ': not scored.' : k.name + ': now ' + fmt(k.now) + u + ', should be ' + fmt(k.expected) + u + ', target ' + fmt(k.target) + u + '.');
+        if (k.status === 'off') out.needs.push(k.name + ' is off course.');
+      }
+      return out;
+    }
+    if (b === 'signals') {
+      const L = M.signals;
+      if (!L.length) { out.line = 'No signal is open.'; return out; }
+      const by = {}; for (const s of L) by[s.sev] = (by[s.sev] || 0) + 1;
+      out.line = plural(L.length, 'signal is', 'signals are') + ' open: ' + Object.keys(by).map((k) => by[k] + ' ' + (SEV_TXT[k] || k)).join(', ') + '.';
+      for (const s of L) { out.nums.push(s.t + '. ' + (s.ev || '')); if (s.sev === 'pivot' || s.sev === 'drift') out.needs.push(s.t + '.'); }
+      return out;
+    }
+    if (b === 'delivery') {
+      const R = (M.delivery && M.delivery.rows) || [];
+      if (!R.length) { out.line = 'No commitment has a promised date this quarter.'; return out; }
+      const n = (f) => R.filter(f).length;
+      out.line = n((r) => r.st === 'ok' || r.st === 'done') + ' of ' + R.length + ' commitments are on time or done, ' + n((r) => r.st === 'risk') + ' at risk, ' + n((r) => r.st === 'late' || r.st === 'over') + ' delayed or overdue.';
+      for (const r of R) { out.nums.push(r.n + ': ' + (ST_TXT[r.st] || r.st) + '.'); if (r.st === 'late' || r.st === 'over') out.needs.push(r.n + ' is ' + ST_TXT[r.st] + '.'); }
+      return out;
+    }
+    if (b === 'maturity') {
+      const T = M.maturity;
+      if (!T || !T.pillars || !T.pillars.length) { out.line = 'No pillar maturity is recorded.'; return out; }
+      out.line = T.pillars.filter((p) => p.proj >= p.tgt).length + ' of ' + T.pillars.length + ' pillars are on course for ' + T.target_label + '.';
+      for (const p of T.pillars) out.nums.push(p.n + ': stage ' + p.now + ', target ' + p.tgt + ', projected ' + p.proj + '.');
+      return out;
+    }
+    if (b === 'bets') {
+      const T = M.timeline;
+      if (!T || !T.rows || !T.rows.length) { out.line = 'No bet is recorded.'; return out; }
+      const cp = (T.checkpoints || [])[0];
+      out.line = plural(T.rows.length, 'bet is', 'bets are') + ' on the plan. ' + (cp ? 'The next checkpoint is ' + cp.label + '.' : 'No checkpoint is recorded.');
+      for (const r of T.rows) out.nums.push(r.title + ': ' + (ST_TXT[r.st] || 'no status') + '.');
+      return out;
+    }
+    if (b === 'synergy') {
+      const S = M.synergy;
+      if (!S || !S.rows || !S.rows.length) { out.line = 'No bet is recorded.'; return out; }
+      if (!S.columns || !S.columns.length) { out.line = 'No key result exists to measure the bets against.'; return out; }
+      const active = S.rows.filter((r) => !r.parked);
+      const gaps = S.columns.filter((_, j) => !active.some((r) => r.weights[j] > 0));
+      out.line = plural(active.length, 'active bet covers', 'active bets cover') + ' ' + (S.columns.length - gaps.length) + ' of ' + S.columns.length + ' ' + (S.unit || 'key results') + '.';
+      for (const r of S.rows) out.nums.push(r.title + (r.parked ? ': parked.' : ': active.'));
+      for (const g of gaps) out.needs.push('No active bet covers ' + g.n + '.');
+      return out;
+    }
+    out.line = 'This report has no text form.';
+    return out;
+  }
+
+  /* The report frame of a dashboard, as data (the sheet and the draft body are both drawn from it). */
+  function frameOf({ title, reports, raw, audience, today }) {
+    const lead = audience !== 'Team';
+    const sections = reports.map((r) => { const t = readingOf(r, raw); return { id: r.id, title: r.title, line: t.line, nums: lead ? [] : t.nums, needs: t.needs }; });
+    const needs = [...new Set(sections.flatMap((s) => s.needs))];
+    const headline = !sections.length ? 'This dashboard has no reports yet.'
+      : needs.length ? needs[0] + (needs.length > 1 ? ' ' + plural(needs.length - 1, 'more thing needs', 'more things need') + ' your call.' : '') : sections[0].line;
+    const sources = [...new Set(reports.map((r) => r.source).filter(Boolean))];
+    return { title, audience: lead ? 'Leadership' : 'Team', today, headline, sections, needs, sources };
+  }
+  function draftBody(F) {
+    const L = [F.title + ' for ' + F.audience + ', ' + F.today, 'Headline: ' + F.headline, '', 'Sections'];
+    for (const s of F.sections) { L.push(s.title, '- ' + s.line + ' [reported]'); for (const n of s.nums) L.push('- ' + n + ' [reported]'); }
+    L.push('', 'Needs your call');
+    if (F.needs.length) for (const n of F.needs) L.push('- ' + n + ' [reported]'); else L.push('Nothing needs your call in this scope.');
+    L.push('', 'Sources: ' + (F.sources.length ? F.sources.join('; ') : 'none') + '. Read on ' + F.today + '.');
+    return L.join('\n');
+  }
+  return { modelOf, builderOf, plural, readingOf, frameOf, draftBody };
+});