create-pmos 0.134.0 → 0.136.0

package/workspace/lib/notes-screen.js

@@ -0,0 +1,180 @@
+'use strict';
+/* notes-screen.js — the screenshots a note keeps of the screen the PM shared in the meeting (notes-screen-capture). Local only.
+ *
+ *   add(runtimeDir, { id, t, buf, w, h }) → { ok, frame } | { ok: false, status, error }   keep one shot at meeting time t (ms)
+ *   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
+ *   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)
+ *
+ * WHAT IT KEEPS. A folder next to the note's audio, `<runtime>/notes/recordings/<id>.screen/`: one image file per shot, named by
+ * its meeting time in milliseconds (`000123456.jpg`), and `index.json`, an array of { t, file, w, h, bytes, why?, text? } sorted by t,
+ * written whole through a temporary file and renamed, so a stop in the middle never leaves half an index. A shot at the same
+ * time as an earlier one replaces it. A note keeps at most MAX_SHOTS shots or MAX_BYTES bytes; a shot past either is refused
+ * with 409 and a plain sentence, and the shots already kept stay.
+ *
+ * WHICH BYTES. Only a JPEG, a PNG or a WebP, found by the file's first bytes and not by what the page says it is, and at most
+ * MAX_SHOT_BYTES each. The page sends a JPEG (public/pm), so a shot is far under the limit.
+ *
+ * ON-SCREEN TEXT. When tesseract is on this machine (PMOS_TESSERACT names it, else the PATH and where Homebrew puts it), each
+ * kept shot is read for its text, one at a time and in the background, and the text is added to that shot's row in the index.
+ * A failed or timed-out read leaves the shot with no text and is not an error. Without tesseract nothing is read.
+ *
+ * WHAT IT NEVER DOES. It sends nothing and opens no network module. The only program it runs is the tesseract the PM installed,
+ * on a file in the note's own folder, with no shell and a time limit. The routes (lib/routes-notes.js) keep no shot for a private
+ * note, for a note that is not listening, or when the PM switched capturing off, and delete the folder when a note is made
+ * private or deleted.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+
+const MAX_SHOT_BYTES = 2 * 1024 * 1024;
+const MAX_SHOTS = 2000;
+const MAX_BYTES = 500 * 1024 * 1024;
+const MAX_T = 999999999;                    // the file name holds nine digits of milliseconds
+const OCR_TIMEOUT_MS = 30000;
+const OCR_MAX_CHARS = 4000;
+const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
+const FILE_RE = /^\d{9}\.(jpg|png|webp)$/;
+const TYPES = { jpg: 'image/jpeg', png: 'image/png', webp: 'image/webp' };
+
+const dirOf = (runtimeDir, id) => path.join(runtimeDir, 'notes', 'recordings', id + '.screen');
+const indexOf = (runtimeDir, id) => path.join(dirOf(runtimeDir, id), 'index.json');
+const settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'screen-settings.json');
+
+function readSettings(runtimeDir) { try { const s = JSON.parse(fs.readFileSync(settingsFile(runtimeDir), 'utf8')); return s && typeof s === 'object' ? s : {}; } catch { return {}; } }
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, text, { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+/** "Capture the shared screen": on until the PM turns it off, for this machine. */
+function getOn(runtimeDir) { return readSettings(runtimeDir).on !== false; }
+function setOn(runtimeDir, on) {
+  if (typeof on !== 'boolean') return { ok: false, error: 'say screen: true or screen: false' };
+  writeAtomic(settingsFile(runtimeDir), JSON.stringify({ ...readSettings(runtimeDir), on }));
+  return { ok: true, on };
+}
+
+/** The image type the first bytes name: 'jpg' | 'png' | 'webp' | null. */
+function kindOf(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 12) return null;
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return 'jpg';
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return 'png';
+  if (buf.toString('latin1', 0, 4) === 'RIFF' && buf.toString('latin1', 8, 12) === 'WEBP') return 'webp';
+  return null;
+}
+
+function readIndex(runtimeDir, id) {
+  try {
+    const a = JSON.parse(fs.readFileSync(indexOf(runtimeDir, id), 'utf8'));
+    if (!Array.isArray(a)) return [];
+    return a.filter((f) => f && Number.isFinite(f.t) && typeof f.file === 'string' && FILE_RE.test(f.file)).sort((x, y) => x.t - y.t);
+  } catch { return []; }
+}
+const writeIndex = (runtimeDir, id, rows) => writeAtomic(indexOf(runtimeDir, id), JSON.stringify(rows));
+const dimension = (n) => (Number.isFinite(Number(n)) && Number(n) > 0 ? Math.min(20000, Math.round(Number(n))) : 0);
+
+/** Keep one shot. `t` is the meeting time in ms, `buf` the image bytes, `w` and `h` its size in pixels. */
+function add(runtimeDir, { id, t, buf, w, h, why } = {}) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const time = typeof t === 'number' ? t : NaN;
+  if (!Number.isFinite(time) || time < 0 || time > MAX_T) return { ok: false, status: 400, error: 'a screenshot needs its meeting time' };
+  const at = Math.round(time);
+  if (!Buffer.isBuffer(buf) || !buf.length) return { ok: false, status: 400, error: 'there is no picture to keep' };
+  if (buf.length > MAX_SHOT_BYTES) return { ok: false, status: 413, error: 'that screenshot is larger than 2 MB' };
+  const kind = kindOf(buf);
+  if (!kind) return { ok: false, status: 400, error: 'a screenshot must be a JPEG, PNG or WebP picture' };
+  const rows = readIndex(runtimeDir, id);
+  const old = rows.find((f) => f.t === at);
+  const others = rows.filter((f) => f !== old);
+  if (others.length >= MAX_SHOTS) return { ok: false, status: 409, error: 'this note already keeps ' + MAX_SHOTS + ' screenshots, the most it holds' };
+  if (others.reduce((n, f) => n + (f.bytes || 0), 0) + buf.length > MAX_BYTES) return { ok: false, status: 409, error: 'this note\'s screenshots have reached 500 MB, the most it holds' };
+  const file = String(at).padStart(9, '0') + '.' + kind;
+  const dir = dirOf(runtimeDir, id);
+  fs.mkdirSync(dir, { recursive: true });
+  const target = path.join(dir, file);
+  const tmp = target + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, buf, { mode: 0o600 });
+  fs.renameSync(tmp, target);
+  if (old && old.file !== file) { try { fs.unlinkSync(path.join(dir, old.file)); } catch { /* none */ } }
+  const frame = { t: at, file, w: dimension(w), h: dimension(h), bytes: buf.length };
+  // why the page kept it (the screen changed, a line pointed at it, a highlight): plain words, kept short
+  const reason = typeof why === 'string' ? why.replace(/\s+/g, ' ').trim().slice(0, 120) : '';
+  if (reason) frame.why = reason;
+  writeIndex(runtimeDir, id, others.concat([frame]).sort((x, y) => x.t - y.t));
+  queueOcr(runtimeDir, id, frame);
+  return { ok: true, frame };
+}
+
+function list(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return [];
+  return readIndex(runtimeDir, id);
+}
+
+/** The shot at meeting time `t` as its image. A shot is never changed once kept, so the browser may keep it for good. */
+function serve(req, res, runtimeDir, id, t) {
+  const miss = () => { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: 'this note has no screenshot at that time' })); };
+  if (!ID_RE.test(String(id || '')) || t === null || t === undefined || t === '' || !Number.isFinite(Number(t))) return miss();
+  const at = Math.round(Number(t));
+  const f = readIndex(runtimeDir, id).find((x) => x.t === at);
+  if (!f) return miss();
+  const file = path.join(dirOf(runtimeDir, id), f.file);
+  let size;
+  try { size = fs.statSync(file).size; } catch { return miss(); }
+  res.writeHead(200, { 'Content-Type': TYPES[path.extname(f.file).slice(1)] || 'application/octet-stream', 'Content-Length': size, 'Cache-Control': 'private, max-age=31536000, immutable' });
+  if (req.method === 'HEAD') { res.end(); return; }
+  fs.createReadStream(file).on('error', () => res.end()).pipe(res);
+}
+
+/** Delete the note's screenshots. True when a folder was there. */
+function remove(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return false;
+  const dir = dirOf(runtimeDir, id);
+  const had = fs.existsSync(dir);
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  return had;
+}
+
+/* ── on-screen text ──────────────────────────────────────────────────────────────────────────────── */
+const isExec = (f) => { try { fs.accessSync(f, fs.constants.X_OK); return fs.statSync(f).isFile(); } catch { return false; } };
+/** The tesseract on this machine: PMOS_TESSERACT, else the PATH, else where Homebrew puts it. */
+function ocrDetect({ env = process.env, fallbacks = ['/opt/homebrew/bin', '/usr/local/bin'] } = {}) {
+  const named = env.PMOS_TESSERACT;
+  if (named) return isExec(named) ? { bin: named } : null;
+  for (const d of String(env.PATH || '').split(path.delimiter).concat(fallbacks)) { if (!d) continue; const f = path.join(d, 'tesseract'); if (isExec(f)) return { bin: f }; }
+  return null;
+}
+const tidy = (s) => String(s || '').replace(/\s+/g, ' ').trim().slice(0, OCR_MAX_CHARS);
+
+let queue = Promise.resolve();
+let waiting = 0;
+function queueOcr(runtimeDir, id, frame) {
+  const found = ocrDetect();
+  if (!found) return;
+  waiting++;
+  queue = queue.then(() => readText(found.bin, runtimeDir, id, frame)).catch(() => {}).then(() => { waiting--; });
+}
+function readText(bin, runtimeDir, id, frame) {
+  const file = path.join(dirOf(runtimeDir, id), frame.file);
+  return new Promise((resolve) => {
+    execFile(bin, [file, 'stdout'], { timeout: OCR_TIMEOUT_MS, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+      const text = err ? '' : tidy(stdout);
+      if (text) {
+        // patch the row only if the same shot is still there (it may have been replaced or deleted while it was read)
+        const rows = readIndex(runtimeDir, id);
+        const row = rows.find((f) => f.t === frame.t && f.file === frame.file && f.bytes === frame.bytes);
+        if (row) { row.text = text; try { writeIndex(runtimeDir, id, rows); } catch { /* the folder went away */ } }
+      }
+      resolve();
+    });
+  });
+}
+/** Resolves when every text read queued so far has ended. */
+function ocrIdle() { return queue.then(() => (waiting > 0 ? ocrIdle() : undefined)); }
+
+module.exports = { add, list, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };

package/workspace/lib/notes-whisper.js

@@ -275,11 +275,13 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
   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: no meeting cut queued that starts before the line ends, and no meeting speech buffered from before then. Then
+   * 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;
@@ -289,6 +291,8 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
     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);
@@ -390,7 +394,10 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
    */
   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 (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 };
@@ -432,7 +439,7 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
     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);
+    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. */

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/records-dir.js

@@ -0,0 +1,29 @@
+'use strict';
+/* records-dir.js — the records folder (planning/records/<kind>.jsonl, scripts/records) of the workspace a request is about.
+ *
+ *   recordsDirFor(ctx, ws) → an absolute path
+ *
+ * Order: ctx.recordsDir (a test's folder) → the workspace's own folder, from scripts/signals/layout-paths.js (a kit tenant keeps
+ * its records in pmos/state/records, the PMOS repo in planning/records) → the PMOS checkout this server runs from, the old
+ * default, for a server with no registered workspace. `ws` is the ?ws= id; null is the home workspace (server.js getWs).
+ *
+ * Before this, every records route read the PMOS checkout's planning/records whatever the workspace, so a tenant's Reports and
+ * Signals showed nothing (initiative reports-tenant-records).
+ */
+const path = require('path');
+const { repoScript } = require('./repo-script.js');
+
+const CHECKOUT_RECORDS = path.join(__dirname, '..', '..', 'planning', 'records');
+
+function recordsDirFor(ctx, ws) {
+  if (ctx && ctx.recordsDir) return ctx.recordsDir;
+  if (ctx && ctx.repoRoot) return path.join(ctx.repoRoot, 'planning', 'records');
+  let w = null;
+  try { w = ctx && typeof ctx.getWs === 'function' ? ctx.getWs(ws || null) : null; } catch { w = null; }
+  if (w && w.root) {
+    try { return require(repoScript('signals/layout-paths.js')).pathsFor(w.root).recordsDir; } catch { /* fall through */ }
+  }
+  return CHECKOUT_RECORDS;
+}
+
+module.exports = { recordsDirFor, CHECKOUT_RECORDS };

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