create-pmos 0.240.0 → 0.242.0

package/workspace/lib/notes-screen.js

@@ -8,6 +8,10 @@
  *   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)
+ *   classifyShot(text, { hints? }) → { aside, app, call }   does the text of a shot look like another app and not like the call? Pure.
+ *   listAside(runtimeDir, id) · asideCount(runtimeDir, id)   the shots set aside for review
+ *   keep(runtimeDir, id, t) · discard(runtimeDir, id, t) · discardAll(runtimeDir, id)   the PM's answer to a set-aside shot
+ *   sweepAside(runtimeDir, { now?, days? }) → n   delete the shots set aside for more than 7 days
  *
  * 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,
@@ -22,6 +26,13 @@
  * 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.
  *
+ * SET ASIDE. When the picture is the whole screen (the shot's `surface` is 'monitor'), every app the PM switches to is on it. After the
+ * text is read, a shot whose text looks like another app (Slack, a mailbox, a chat) and not like the call (Zoom's or Meet's controls) or
+ * what is shared in it is marked `aside: true` in the index. A set-aside shot is not listed and not served by default, so the note, the
+ * replay and the agent never see it. The PM reviews them (listAside) and answers each one: Keep it (the shot joins the note), Delete
+ * (file and row go) or Delete all. sweepAside deletes the shots set aside for more than 7 days. A shot with no text, a shot from a
+ * window or a tab, and every shot on a machine with no tesseract are kept, as before.
+ *
  * 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
@@ -37,6 +48,8 @@ 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 ASIDE_DAYS = 7;
+const SURFACES = ['window', 'browser', 'monitor'];
 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' };
@@ -80,7 +93,7 @@ const writeIndex = (runtimeDir, id, rows) => writeAtomic(indexOf(runtimeDir, id)
 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 } = {}) {
+function add(runtimeDir, { id, t, buf, w, h, why, surface } = {}) {
   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' };
@@ -106,27 +119,36 @@ function add(runtimeDir, { id, t, buf, w, h, why } = {}) {
   // 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;
+  // what the picture shows: the meeting's window, a browser tab or the whole screen; only the whole screen is checked for other apps
+  if (SURFACES.includes(surface)) frame.surface = surface;
   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) {
+/** The note's shots, by meeting time. A set-aside shot is not in this list. */
+function list(runtimeDir, id, { aside = false } = {}) {
+  if (!ID_RE.test(String(id || ''))) return [];
+  return readIndex(runtimeDir, id).filter((f) => !!f.aside === !!aside);   // { aside: true } lists the set-aside shots instead
+}
+/** The shots set aside for review, by meeting time. */
+function listAside(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return [];
-  return readIndex(runtimeDir, id);
+  return readIndex(runtimeDir, id).filter((f) => f.aside);
 }
+const asideCount = (runtimeDir, id) => listAside(runtimeDir, id).length;
 
 /** 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) {
+function serve(req, res, runtimeDir, id, t, { aside = false } = {}) {
   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);
+  const f = readIndex(runtimeDir, id).find((x) => x.t === at && !!x.aside === !!aside);   // a set-aside shot is served only for the review
   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' });
+  res.writeHead(200, { 'Content-Type': TYPES[path.extname(f.file).slice(1)] || 'application/octet-stream', 'Content-Length': size, 'Cache-Control': aside ? 'private, no-store' : 'private, max-age=31536000, immutable' });
   if (req.method === 'HEAD') { res.end(); return; }
   fs.createReadStream(file).on('error', () => res.end()).pipe(res);
 }
@@ -140,6 +162,95 @@ function remove(runtimeDir, id) {
   return had;
 }
 
+/* ── set aside: the PM's answer ──────────────────────────────────────────────────────────────────── */
+const rmFile = (runtimeDir, id, f) => { try { fs.unlinkSync(path.join(dirOf(runtimeDir, id), f.file)); } catch { /* none */ } };
+const asideRow = (rows, t) => rows.find((f) => f.t === Math.round(Number(t)) && f.aside);
+/** Keep it: the shot joins the note, and it is not checked again. */
+function keep(runtimeDir, id, t) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const row = asideRow(rows, t);
+  if (!row) return { ok: false, status: 404, error: 'that shot is not set aside' };
+  delete row.aside; delete row.asideApp; delete row.asideAt;
+  row.kept = true;
+  writeIndex(runtimeDir, id, rows);
+  return { ok: true, frame: row };
+}
+/** Delete: the file and its row go. Only a set-aside shot can be deleted here. */
+function discard(runtimeDir, id, t) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const row = asideRow(rows, t);
+  if (!row) return { ok: false, status: 404, error: 'that shot is not set aside' };
+  rmFile(runtimeDir, id, row);
+  writeIndex(runtimeDir, id, rows.filter((f) => f !== row));
+  return { ok: true, deleted: 1 };
+}
+/** Delete all: every set-aside shot of the note. The kept shots stay. */
+function discardAll(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return { ok: false, status: 400, error: 'no such note' };
+  const rows = readIndex(runtimeDir, id);
+  const gone = rows.filter((f) => f.aside);
+  if (!gone.length) return { ok: true, deleted: 0 };
+  for (const f of gone) rmFile(runtimeDir, id, f);
+  writeIndex(runtimeDir, id, rows.filter((f) => !f.aside));
+  return { ok: true, deleted: gone.length };
+}
+/** Delete every shot set aside for more than `days` days, in every note. Returns how many went. */
+function sweepAside(runtimeDir, { now = Date.now(), days = ASIDE_DAYS } = {}) {
+  let names = [];
+  try { names = fs.readdirSync(path.join(runtimeDir, 'notes', 'recordings')); } catch { return 0; }
+  let n = 0;
+  for (const name of names) {
+    if (!name.endsWith('.screen')) continue;
+    const id = name.slice(0, -'.screen'.length);
+    if (!ID_RE.test(id)) continue;
+    const rows = readIndex(runtimeDir, id);
+    if (!rows.some((f) => f.aside)) continue;
+    const left = rows.filter((f) => {
+      if (!f.aside || !Number.isFinite(f.asideAt) || now - f.asideAt < days * 864e5) return true;
+      rmFile(runtimeDir, id, f); n++; return false;
+    });
+    if (left.length !== rows.length) { try { writeIndex(runtimeDir, id, left); } catch { /* the folder went away */ } }
+  }
+  return n;
+}
+
+/* ── what looks like another app ─────────────────────────────────────────────────────────────────── */
+// The call: the controls of Zoom, Meet and Teams, and what each says while someone shares. Any one of these keeps the shot.
+const CALL = /\b(unmute|mute|stop video|start video|participants?|share screen|stop share(?:ing)?|new share|you are screen sharing|you are viewing|you'?re presenting|stop presenting|present now|presenting|raise hand|lower hand|breakout rooms?|leave meeting|leave call|end meeting|meeting controls|zoom meeting|zoom workplace|meet\.google\.com|google meet|turn (?:on|off) camera|turn (?:on|off) microphone|live captions|waiting room|in this meeting|hide self view|gallery view|speaker view)\b/i;
+// Another app. `strong`: one is enough. `weak`: two different ones are needed.
+const OTHER = [
+  { app: 'Slack', strong: [/\bslack\b/i], weak: [/\bdirect messages\b/i, /\bchannels\b/i, /\bthreads\b/i, /\bhuddles?\b/i, /\bmentions (?:&|and) reactions\b/i, /\bmessage #[a-z0-9_-]+/i] },
+  { app: 'Gmail', strong: [/\bgmail\b/i, /\binbox\b/i], weak: [/\bcompose\b/i, /\bstarred\b/i, /\bsnoozed\b/i, /\bsent mail\b/i, /\bdrafts\b/i, /\bprimary\b/i, /\bpromotions\b/i] },
+  { app: 'Outlook', strong: [/\boutlook\b/i], weak: [/\bnew mail\b/i, /\bjunk email\b/i, /\bsent items\b/i, /\bfocused\b/i] },
+  { app: 'WhatsApp', strong: [/\bwhatsapp\b/i], weak: [] },
+  { app: 'Telegram', strong: [/\btelegram\b/i], weak: [] },
+  { app: 'Discord', strong: [/\bdiscord\b/i], weak: [] },
+  { app: 'Messages', strong: [/\bimessage\b/i, /\bmessenger\b/i], weak: [] },
+  { app: 'Social media', strong: [/\bfacebook\b/i, /\binstagram\b/i, /\btwitter\b/i, /\blinkedin\b/i, /\btiktok\b/i], weak: [] },
+  { app: 'Video or music', strong: [/\byoutube\b/i, /\bnetflix\b/i, /\bspotify\b/i], weak: [] },
+];
+
+/** Does the text of a shot look like another app and not like the call? Pure.
+ *  → { aside, app, call }. `hints` are words from what is shared in the meeting (a deck's title, say): a shot that names one is kept.
+ *  Text that is empty, or that names no app, is never set aside. */
+function classifyShot(text, { hints = [] } = {}) {
+  const t = String(text || '');
+  if (!t.trim()) return { aside: false, app: null, call: false };
+  if (CALL.test(t)) return { aside: false, app: null, call: true };
+  const low = t.toLowerCase();
+  for (const h of hints || []) { const w = String(h || '').trim().toLowerCase(); if (w.length >= 4 && low.includes(w)) return { aside: false, app: null, call: false }; }
+  for (const o of OTHER) {
+    if (o.strong.some((re) => re.test(t)) || o.weak.filter((re) => re.test(t)).length >= 2) return { aside: true, app: o.app, call: false };
+  }
+  return { aside: false, app: null, call: false };
+}
+// the words of what is shared in the meeting, for classifyShot: set by whoever knows them (the material of the meeting), else none
+let hintsOf = null;
+/** fn(runtimeDir, id) → [word]: what is shared in this note's meeting. Optional. */
+function setHints(fn) { hintsOf = typeof fn === 'function' ? fn : null; }
+
 /* ── 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. */
@@ -168,7 +279,16 @@ function readText(bin, runtimeDir, id, frame) {
         // 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 */ } }
+        if (row) {
+          row.text = text;
+          // the whole screen was the picture: a shot that looks like another app is set aside, for the PM to keep or delete
+          if (row.surface === 'monitor' && !row.kept) {
+            let hints = []; try { hints = hintsOf ? hintsOf(runtimeDir, id) || [] : []; } catch { hints = []; }
+            const c = classifyShot(text, { hints });
+            if (c.aside) { row.aside = true; row.asideApp = c.app; row.asideAt = Date.now(); }
+          }
+          try { writeIndex(runtimeDir, id, rows); } catch { /* the folder went away */ }
+        }
       }
       resolve();
     });
@@ -177,4 +297,4 @@ function readText(bin, runtimeDir, id, frame) {
 /** 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 };
+module.exports = { add, list, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };

package/workspace/lib/report-structure-needs.js

@@ -0,0 +1,64 @@
+'use strict';
+/* report-structure-needs.js — the needs provider of the report structure step (initiative report-structure, contract section 8).
+ * lib/needs-providers.js folds these rows into server.js deriveNeeds, and from there into /api/needs, the Briefing and Work.
+ *
+ *   kinds: report-source-check
+ *   rowsFor(w, { lead }) → rows · sig(w) → string
+ *
+ *   report-source-check   one row for each Chrome or computer source that failed its check while a scheduled draft waits for it:
+ *                         "Check <source> for <report>". The draft waits up to 4 hours (lib/routes-report-structure.js sweep), then is drafted
+ *                         without the source. The row goes when the draft starts. Kind 8 (needs repair); the act is Check again on the report.
+ *
+ * The rows are repository-wide, so a tree that is not the lead returns []. Nothing here writes.
+ */
+const fs = require('fs');
+const path = require('path');
+const RD = require('./report-draft.js');
+
+const NAME = 'report-structure-needs';
+
+function holds(root) {
+  const out = [];
+  let base;
+  try { base = path.join(path.resolve(String(root)), RD.stateRel(root), 'reports'); } catch { return out; }
+  let ids = []; try { ids = fs.readdirSync(base); } catch { return out; }
+  for (const id of ids) {
+    if (!/^[a-z][a-z0-9-]{0,39}$/.test(id) || id === 'definitions') continue;
+    const dir = path.join(base, id, 'structure');
+    let hold = null; try { hold = JSON.parse(fs.readFileSync(path.join(dir, 'hold.json'), 'utf8')); } catch { hold = null; }
+    if (!hold || typeof hold !== 'object') continue;
+    out.push({ id, dir, hold });
+  }
+  return out;
+}
+const readJson = (f) => { try { const o = JSON.parse(fs.readFileSync(f, 'utf8')); return o && typeof o === 'object' ? o : null; } catch { return null; } };
+
+function rowsFor(w, { lead } = {}) {
+  if (!lead || !w || !w.root) return [];
+  const rows = [];
+  for (const { id, dir, hold } of holds(w.root)) {
+    const since = Date.parse(hold.since);
+    let name = id;
+    try { const s = require('./report-setups.js').stateOf(w.root).setups.get(id); if (s && s.name) name = s.name; } catch { /* the id is the name */ }
+    let plan = null;
+    try { const v = readJson(path.join(dir, 'versions', `S${hold.saved}.json`)); plan = v; } catch { plan = null; }
+    for (const sid of Array.isArray(hold.sources) ? hold.sources : []) {
+      const c = readJson(path.join(dir, 'checks', `${sid}.json`));
+      if (!c || c.running || c.ok || !(Date.parse(c.at) >= since - 1000)) continue;
+      const src = plan && Array.isArray(plan.sources) ? plan.sources.find((s) => s.id === sid) : null;
+      const step = (c.steps || []).find((s) => s.state === 'needs-you');
+      rows.push({
+        run_id: `${NAME}:${id}:${sid}`, kind: 'report-source-check', initiative_id: null, question: `Check ${(src && src.name) || sid} for ${name}`, doc: null, ws: w.id,
+        today: { kind: 8, source: NAME, cause: step ? `${step.label}: ${step.reason || 'needs you'}` : 'The check did not pass', evidence: `${path.relative(path.resolve(w.root), dir).split(path.sep).join('/')}/checks/${sid}.json`,
+          act: { label: 'Check again', cli: null } },
+      });
+    }
+  }
+  return rows;
+}
+function sig(w) {
+  if (!w || !w.root) return '';
+  return holds(w.root).map((h) => `${h.id}:${h.hold.since}:${(Array.isArray(h.hold.sources) ? h.hold.sources : []).map((s) => { try { return fs.statSync(path.join(h.dir, 'checks', `${s}.json`)).mtimeMs; } catch { return 0; } }).join(',')}`).join('|');
+}
+
+module.exports = { kinds: ['report-source-check'], rowsFor, sig };