create-pmos 0.529.0 → 0.530.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.529.0",
+  "version": "0.530.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {
@@ -32,6 +32,19 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.530.0",
+      "at": "2026-11-04T14:38:26.528Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1246,
+          "t": "Send meeting captures to Jev and keep only the slide (MpJ)",
+          "s": "Send meeting captures to Jev and keep only the slide (MpJ)",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.529.0",
       "at": "2026-11-04T13:14:44.790Z",
@@ -420,27 +433,6 @@
           "d": "Updates listed pull request titles and numbers, grouped by kind, which was hard to skim. Updates opens with a short summary of the week, then the newest version, then each change as a plain story, with a dot for New and Fixed."
         }
       ]
-    },
-    {
-      "v": "0.510.0",
-      "at": "2026-11-03T14:33:47.373Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1197,
-          "t": "Clean Updates lines: no, one PR number, no repeated title, right group",
-          "s": "Clean Updates lines: no, one PR number, no repeated title, right group",
-          "k": "fix",
-          "h": "Clearer update notes",
-          "d": "Update notes could repeat a line, show odd tags, or put every change under Improved. Now each change shows once, in the right group."
-        },
-        {
-          "n": 1199,
-          "t": "A Board product head's name opens its page in the Viewer",
-          "s": "A Board product head's name opens its page in the Viewer",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@96caad55
+kernel-source: pmos@5a2765e8
 assembled: 2026-11-04
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-11-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-11-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-11-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "v": "0.530.0",
+  "at": "2026-11-04T14:38:26.528Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1246,
+    "t": "Send meeting captures to Jev and keep only the slide (MpJ)",
+    "s": "Send meeting captures to Jev and keep only the slide (MpJ)",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.529.0",
   "at": "2026-11-04T13:14:44.790Z",

package/workspace/guide/notes.md

@@ -190,7 +190,7 @@ Without Jev, the workspace labels each line with its own rules and finds the clo
 1. Save a TypeSafe key and switch on validation for the repository (see [Validate with TypeSafe](validate-with-typesafe.md)).
 2. Open the settings and switch on **Label lines with Jev**. Switch on **Check notes against this repository with Jev** for the checks too. Both are off until you switch them on, for each repository.
 
-With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Audio, speaker names and private notes never go. A line that looks like a secret is not sent.
+With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Each screen capture goes too, so Jev can find the slide or document in it (see the meeting player below). Audio, speaker names and private notes never go. A line that looks like a secret is not sent, and a capture set aside as another app is not sent.
 
 ## Correct and tag a line
 
@@ -253,7 +253,7 @@ A meeting with a recording opens wide, in two columns. Press **Back to the side*
 
 The captures row is hidden until you press the captures icon. It shows the five captures near the playing time, and **+N more** shows the rest.
 
-When Jev is on for the repository (Settings › **Label lines with Jev**) and Jev gave a box for a capture, the player and the captures row show only the slide or document in that box. The meeting window and the faces are cut off, and a capture that shows only faces is not in the captures row. The icon at the top right of the picture shows the whole frame. When Jev is off, or gave no box, you see the whole frame. Note: PMOS does not yet send the captures to Jev, so for now every capture shows the whole frame.
+When Jev is on for the repository (Settings › **Label lines with Jev**) and Jev gave a box for a capture, the player and the captures row show only the slide or document in that box. The meeting window and the faces are cut off, and a capture that shows only faces is not in the captures row. The icon at the top right of the picture shows the whole frame. When Jev is off, or gave no box, you see the whole frame. Captures kept before you switched Jev on are sent the next time you open the meeting. Jev reads pictures up to 1568 px a side. On a Mac a larger capture from an earlier meeting is made smaller first; on another computer it shows the whole frame.
 
 ### Fix a word that was heard wrong
 

package/workspace/lib/jev-notes.js

@@ -4,6 +4,7 @@
  *   gatesFor(key, flags) · checkGatesFor(key, flags) · senderFor(key, flags, askOpts) · infoFor(present, flags)
  *   label({ ask, key, askOpts, text, pause })            → { cat, p } | { cat: null, reason }
  *   compare({ ask, key, askOpts, text, passage, pause }) → { verdict: 'agrees'|'differs'|'related', words } | { verdict: null, reason }
+ *   screen({ askImage, key, askOpts, image, root })      → { kind: 'slide'|'document'|'faces'|'unsure', box?, p } | { kind: null, reason }
  *   getSwitch(runtimeDir, root) · setSwitch(runtimeDir, root, { jev, check })
  *
  * WHAT MAY LEAVE THE MACHINE. For a label: one cleaned transcript line and one Choice question. For a check: the line and
@@ -13,6 +14,9 @@
  * per-user runtime directory. Never sent: audio, a speaker's name, a line or passage the secret scan matches, a private
  * note (the caller refuses it before this module), anything while paused.
  *
+ * For a screen capture (MpJ): the capture's picture and nothing else, with one Choice and one Box question, under the same three
+ * gates. The caller sends only shots the note lists: never a shot set aside as another app, never one from a private note.
+ *
  * WHAT A RESULT IS. Advisory (D40), shown in words. A label under UNSURE_BELOW keeps the local label. A check says
  * "agrees" or "differs" only above SURE; otherwise "related", which is what the local match alone also says.
  *
@@ -68,8 +72,8 @@ const checkGatesFor = (key, f) => checkGates({ key: typesafe.validKey(key), cons
 /** { ask, check, askOpts }: `ask` sends labels and `check` is true when checks may also be sent. Both shut when a gate is. */
 function senderFor(key, flags, askOpts = {}) {
   const g = gatesFor(key, flags);
-  if (!g.open) return { ask: null, check: false, gates: g, askOpts: {} };
-  return { ask: (a) => typesafe.ask(a), check: checkGatesFor(key, flags).open, gates: g, askOpts: { ...NOTES_ASK, ...askOpts } };
+  if (!g.open) return { ask: null, askImage: null, check: false, gates: g, askOpts: {} };
+  return { ask: (a) => typesafe.ask(a), askImage: (a) => typesafe.askImage(a), check: checkGatesFor(key, flags).open, gates: g, askOpts: { ...NOTES_ASK, ...askOpts } };
 }
 /** What the view needs to explain the two switches. Booleans and sentences only. */
 function infoFor(present, flags) {
@@ -86,6 +90,11 @@ function getSwitch(runtimeDir, root) {
   const r = s && s.repos && root ? s.repos[root] : null;
   return { jev: !!(r && r.jev === true), check: !!(r && r.check === true) };
 }
+/** The repositories whose switch "notes may use Jev" is on, sorted: a note bound to no repository looks at its shots under the first of these that also has consent (routes-notes.js lookAtShots). */
+function onRoots(runtimeDir) {
+  const s = readJson(switchFile(runtimeDir), {});
+  return Object.entries((s && s.repos) || {}).filter(([, v]) => v && v.jev === true).map(([r]) => r).sort();
+}
 function setSwitch(runtimeDir, root, { jev, check } = {}) {
   const s = readJson(switchFile(runtimeDir), {});
   const prev = getSwitch(runtimeDir, root);
@@ -156,7 +165,53 @@ async function compare({ ask, key, askOpts = {}, text, passage, root = '' }) {
   if (same != null && same >= SURE) return { verdict: 'agrees', words: wordsFor(same), model: res.model || null };
   return { verdict: 'related', words: null, model: res.model || null };
 }
+/* ── screen captures (MpJ) ──────────────────────────────────────────────────────────────────────── */
+const SHOT_KINDS = {
+  slide: 'A shared slide or presentation is on the screen.',
+  document: 'A shared document, web page, spreadsheet, board or app screen is on the screen.',
+  faces: 'Only the people in the meeting: their video tiles, pictures or names. Nothing is shared.',
+  other: 'Something else, such as an empty, loading or desktop screen.',
+};
+const SHOT_KIND_Q = 'The `capture` is a screenshot taken during a video meeting. What does it mainly show?';
+const SHOT_BOX_Q = 'the shared slide or document in `capture`, without the meeting app\'s toolbars and without the video tiles of the people';
+const SHOT_SHOWN = ['slide', 'document'];
+const SHOT_ASK = { timeoutMs: 20000, retries: 1, backoffMs: 600 };
+const r4 = (n) => Math.round(n * 10000) / 10000;
+/** Jev's { top, bottom, left, right } (fractions of the picture) as [x, y, w, h], or null when it is not a useful crop. */
+function boxOf(ans) {
+  const b = ans && ans.box;
+  if (!b || typeof b !== 'object') return null;
+  const [t, bo, l, ri] = [b.top, b.bottom, b.left, b.right].map(Number);
+  if (![t, bo, l, ri].every((v) => Number.isFinite(v) && v >= -0.01 && v <= 1.01)) return null;
+  const x = Math.max(0, l), y = Math.max(0, t), w = Math.min(1, ri) - x, h = Math.min(1, bo) - y;
+  if (!(w > 0.1) || !(h > 0.1)) return null;          // a sliver is not a slide
+  if (w * h > 0.95) return null;                       // the whole frame already: nothing to crop
+  return [r4(x), r4(y), r4(w), r4(h)];
+}
+/** What one capture shows, from Jev. Faces are named only when Jev is sure; a crop only for a slide or a document. */
+async function screen({ askImage, key, askOpts = {}, image, root = '' }) {
+  const p = pauseOf(root);
+  if (!askImage) return { kind: null, reason: 'off' };
+  if (p.paused) return { kind: null, reason: 'paused', sentence: p.paused };
+  const questions = { kind: { type: 'choice', instructions: SHOT_KIND_Q, criteria: SHOT_KINDS }, area: { type: 'box', instructions: SHOT_BOX_Q } };
+  const res = await askImage({ key, image, name: 'capture', questions, ...SHOT_ASK, ...askOpts });
+  if (!res.requested) return { kind: null, reason: 'refused', sentence: res.reason || null };
+  note(p, res);
+  if (!res.ok) return { kind: null, reason: 'failed', sentence: res.reason || null };
+  const probs = choiceProbs(res.answers && res.answers.kind);
+  const top = Object.entries(probs).filter(([k]) => SHOT_KINDS[k]).sort((a, b) => b[1] - a[1])[0];
+  const model = res.model || null;
+  if (!top) return { kind: null, reason: 'unreadable' };
+  if (top[0] === 'faces' && top[1] >= SURE) return { kind: 'faces', p: r4(top[1]), model };
+  if (SHOT_SHOWN.includes(top[0]) && top[1] >= UNSURE_BELOW) {
+    const box = boxOf(res.answers && res.answers.area);
+    return box ? { kind: top[0], box, p: r4(top[1]), model } : { kind: top[0], p: r4(top[1]), model };
+  }
+  return { kind: 'unsure', p: r4(top[1]), model };
+}
+
 function pauseStatus(root) { const p = pauses.get(root); return p && p.paused ? p.paused : null; }
 
-module.exports = { gates, checkGates, gatesFor, checkGatesFor, gateSentence, senderFor, infoFor, getSwitch, setSwitch, label, compare, choiceProbs, pauseStatus,
+module.exports = { gates, checkGates, gatesFor, checkGatesFor, gateSentence, senderFor, infoFor, getSwitch, setSwitch, onRoots, label, compare, screen, boxOf,
+  pictures: { imageSize: typesafe.imageSize, imageRefusal: typesafe.imageRefusal, IMAGE_SIDE: typesafe.IMAGE_SIDE }, choiceProbs, pauseStatus, SHOT_KINDS,
   CATS, UNSURE_BELOW, SURE, REJECTED_LIMIT, UNREACHABLE_LIMIT };

package/workspace/lib/jev-screen.js

@@ -0,0 +1,110 @@
+'use strict';
+/* jev-screen.js — Jev looks at a note's screen captures and keeps only the useful area (batch 27 item 12, board MpJ).
+ *
+ *   run({ runtimeDir, id, g, screen?, jev?, fit? }) → Promise<{ asked, kept, skipped, stopped? }>
+ *   busy(id) → boolean                   a run for the note is in progress
+ *   fitFor(buf, { platform?, sips? }) → Promise<{ buf } | { reason }>   a picture in Jev's size range, or why there is none
+ *
+ * WHAT IT DOES. For each shot the note lists that has no `jev` yet, in meeting-time order, it sends the picture to Jev
+ * (lib/jev-notes.js screen, through lib/typesafe.js askImage) and keeps the answer on the shot's row in the index:
+ *   { kind: 'slide'|'document', box: [x, y, w, h] }   the page shows only the box, with the whole-frame icon (premium-mtg-replay.js)
+ *   { kind: 'faces' }                                 the page leaves the shot out of the captures row
+ *   { kind: 'slide'|'document'|'unsure' } (no box)    the page shows the whole frame, as without Jev
+ *   { kind: 'skip', why }                             not sent (out of Jev's size range and no way to resize here); whole frame
+ * x, y, w, h are fractions of the picture, so they hold for the kept file at any size.
+ *
+ * GATES. `g` is routes-notes.js gatesFor: no `askImage` (no key, no consent, the switch "notes may use Jev" off) means no
+ * request. Private notes and shots set aside as another app are never sent: the caller passes only an open note, and
+ * notes-screen.js list leaves set-aside shots out. It waits for the text reads first, because a text read is what sets a
+ * shot aside. A failed ask leaves the row as it was, so the next run asks again; a pause (jev-notes.js) stops the run.
+ *
+ * SIZE. Jev does not resize: each side 280 to 1568 px. The page captures at most 1568 px a side (notes-screen-capture.js);
+ * older shots were 1600 px wide. On a Mac, `sips` (part of macOS) makes a smaller copy in the temp folder, which is sent and
+ * deleted. Elsewhere such a shot is marked skip and shows whole.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+const jevNotes = require('./jev-notes');
+// the size rules come through the notes bridge: only the bridges require lib/typesafe.js (no-network.test.js)
+const typesafe = jevNotes.pictures;
+const notesScreen = require('./notes-screen');
+
+const SIPS = '/usr/bin/sips';
+const MAX_PER_RUN = 400;
+const running = new Map();   // note id → the run in progress, so two triggers never ask twice for one shot
+
+/** A copy of the picture in Jev's size range, made by sips on a Mac. */
+function fitFor(buf, { platform = process.platform, sips = SIPS } = {}) {
+  const size = typesafe.imageSize(buf);
+  if (!size) return Promise.resolve({ reason: 'not a PNG or a JPEG' });
+  if (!typesafe.imageRefusal(size, buf.length)) return Promise.resolve({ buf });
+  const { min, max } = typesafe.IMAGE_SIDE;
+  if (size.w < min || size.h < min) return Promise.resolve({ reason: `${size.w} × ${size.h} px is smaller than Jev reads` });
+  let can = platform === 'darwin';
+  try { fs.accessSync(sips, fs.constants.X_OK); } catch { can = false; }
+  if (!can) return Promise.resolve({ reason: `${size.w} × ${size.h} px is larger than Jev reads, and this machine cannot make it smaller` });
+  const tmp = path.join(os.tmpdir(), 'pmos-jev-' + crypto.randomBytes(6).toString('hex'));
+  const src = tmp + '.' + size.format, out = tmp + '-fit.' + size.format;
+  return new Promise((resolve) => {
+    try { fs.writeFileSync(src, buf, { mode: 0o600 }); } catch { resolve({ reason: 'the temp folder cannot be written' }); return; }
+    execFile(sips, ['-Z', String(max), src, '--out', out], { timeout: 20000, windowsHide: true }, (err) => {
+      let fit = null;
+      try { if (!err) fit = fs.readFileSync(out); } catch { fit = null; }
+      for (const f of [src, out]) { try { fs.unlinkSync(f); } catch { /* gone */ } }
+      const s2 = fit ? typesafe.imageSize(fit) : null;
+      resolve(fit && s2 && !typesafe.imageRefusal(s2, fit.length) ? { buf: fit } : { reason: 'the smaller copy could not be made' });
+    });
+  });
+}
+
+async function runNow({ runtimeDir, id, g, screen = notesScreen, jev = jevNotes, fit = fitFor }) {
+  const out = { asked: 0, kept: 0, skipped: 0 };
+  if (!g || !g.askImage) return { ...out, stopped: 'off' };
+  await screen.ocrIdle();
+  const todo = screen.list(runtimeDir, id).filter((f) => !f.jev).slice(0, MAX_PER_RUN);
+  for (const f of todo) {
+    const buf = screen.readShot(runtimeDir, id, f);
+    if (!buf) continue;
+    const ok = await fit(buf);
+    if (!ok.buf) { screen.setJev(runtimeDir, id, f, { kind: 'skip', why: ok.reason }); out.skipped++; continue; }
+    out.asked++;
+    const r = await jev.screen({ askImage: g.askImage, key: g.key, askOpts: g.askOpts, image: ok.buf, root: g.root });
+    if (r.reason === 'paused') return { ...out, stopped: 'paused' };
+    if (r.reason === 'refused') { screen.setJev(runtimeDir, id, f, { kind: 'skip', why: r.sentence || 'refused' }); out.skipped++; continue; }
+    if (!r.kind) continue;   // failed or unreadable: asked again next run
+    const row = { kind: r.kind, at: Date.now() };
+    if (r.box) row.box = r.box;
+    if (r.p != null) row.p = r.p;
+    if (r.model) row.model = r.model;
+    if (screen.setJev(runtimeDir, id, f, row)) out.kept++;
+  }
+  return out;
+}
+
+/** Ask Jev about the note's shots that have no answer yet. One run per note at a time: a call during a run makes the run
+ * go once more at its end, so a shot kept meanwhile is asked about too. */
+function run(a) {
+  const cur = running.get(a.id);
+  if (cur) { cur.again = a; return cur.p; }
+  const st = { again: null, p: null };
+  st.p = (async () => {
+    let last;
+    let next = a;
+    while (next) {
+      st.again = null;
+      last = await runNow(next).catch(() => ({ asked: 0, kept: 0, skipped: 0, stopped: 'error' }));
+      next = last.stopped ? null : st.again;
+    }
+    return last;
+  })().finally(() => running.delete(a.id));
+  running.set(a.id, st);
+  return st.p;
+}
+
+/** Whether Jev is looking at this note's shots right now (the replay tells the page to read again when it ends). */
+const busy = (id) => running.has(id);
+
+module.exports = { run, busy, fitFor, MAX_PER_RUN };

package/workspace/lib/meeting-replay.js

@@ -107,11 +107,14 @@ function timeOfKey(item, lines) {
 
 /** What Jev for images said of a shot (batch 27 item 12, MpJ), when a shot's index row holds it: the kind ('content', a slide or a
  * document; 'faces', only people) and the box around the useful area, as fractions of the frame [x, y, w, h]. Anything else is dropped. */
+/* lib/jev-screen.js keeps Jev's kind as slide or document; both are content here */
+const CONTENT = ['content', 'slide', 'document'];
 function jevOf(j) {
-  if (!j || typeof j !== 'object' || !['content', 'faces'].includes(j.kind)) return null;
+  if (!j || typeof j !== 'object' || !(CONTENT.includes(j.kind) || j.kind === 'faces')) return null;
   const b = Array.isArray(j.box) && j.box.length === 4 && j.box.every((x) => Number.isFinite(x) && x >= 0 && x <= 1) ? j.box.map((x) => Math.round(x * 1000) / 1000) : null;
   const box = b && b[2] >= 0.05 && b[3] >= 0.05 && b[0] + b[2] <= 1.001 && b[1] + b[3] <= 1.001 ? b : null;
-  return { kind: j.kind, ...(box && j.kind === 'content' ? { box } : {}) };
+  const kind = j.kind === 'faces' ? 'faces' : 'content';
+  return { kind, ...(box && kind === 'content' ? { box } : {}) };
 }
 
 /** Join the three records. */

package/workspace/lib/notes-screen.js

@@ -5,6 +5,7 @@
  *   list(runtimeDir, id) → [{ t, file, w, h, bytes, why?, text? }]   sorted by t; empty when the note has none
  *   serve(req, res, runtimeDir, id, t)        the shot at t as its image, cached for good; 404 JSON when there is none
  *   remove(runtimeDir, id) → boolean          delete the note's screenshots
+ *   readShot(runtimeDir, id, frame) → Buffer | null · setJev(runtimeDir, id, frame, jev) → boolean   what Jev saw in a shot (lib/jev-screen.js)
  *   getOn(runtimeDir) · setOn(runtimeDir, bool)   "Capture the shared screen", on by default, for this machine
  *   ocrDetect({ env? }) → { bin } | null      the tesseract the PM installed
  *   ocrIdle() → Promise                       resolves when the text queue is empty (tests)
@@ -294,7 +295,20 @@ function readText(bin, runtimeDir, id, frame) {
     });
   });
 }
+/** The bytes of one listed shot, or null. */
+function readShot(runtimeDir, id, frame) {
+  if (!ID_RE.test(String(id || '')) || !frame || !FILE_RE.test(String(frame.file || ''))) return null;
+  try { return fs.readFileSync(path.join(dirOf(runtimeDir, id), frame.file)); } catch { return null; }
+}
+/** Keep what Jev saw in a shot ({ kind, box?, … }) on its row, only if the same shot is still there and not set aside. */
+function setJev(runtimeDir, id, frame, jev) {
+  const rows = readIndex(runtimeDir, id);
+  const row = rows.find((f) => f.t === frame.t && f.file === frame.file && f.bytes === frame.bytes && !f.aside);
+  if (!row) return false;
+  row.jev = jev;
+  try { writeIndex(runtimeDir, id, rows); return true; } catch { return false; }
+}
 /** Resolves when every text read queued so far has ended. */
 function ocrIdle() { return queue.then(() => (waiting > 0 ? ocrIdle() : undefined)); }
 
-module.exports = { add, list, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };
+module.exports = { add, list, readShot, setJev, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };

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

@@ -5,7 +5,8 @@
  *   GET /api/meeting-replay?event=<id>[&date=YYYY-MM-DD]          the note linked to that meeting
  *        → { ok, note, meeting, audio, start_ms, length_ms, lines, keys, topics, runs, notes, shots, aside_count }   (lib/meeting-replay.js)
  *        The note (transcript, decisions, next steps, questions), the Focus state file (topics, stretches, PMOS's notes) and the
- *        shots, joined. Read only: it writes nothing, starts no run and reaches nothing outside the machine. A private note is a
+ *        shots, joined. It writes nothing itself. When kept shots have no answer from Jev yet and the gates let notes use Jev, the
+ *        handler starts Jev on them in the background (routes-notes.js lookAtShots) and sets `jev_running`. A private note is a
  *        404 (it keeps no audio and no shots); an unknown note or a meeting with no note is a 404. A shot that was set aside
  *        (`aside`) is not in `shots`; `aside_count` says how many there are.
  * Handlers are pure over (query, ctx): ctx = { runtimeDir, readEvents?, now? }, so a test needs no server.
@@ -16,6 +17,7 @@ const notesAudio = require('./notes-audio.js');
 const notesScreen = require('./notes-screen.js');
 const F = require('./meeting-focus.js');
 const R = require('./meeting-replay.js');
+const jevScreen = require('./jev-screen.js');
 
 const fail = (status, error) => ({ status, body: { ok: false, error } });
 const DAY = /^\d{4}-\d{2}-\d{2}$/;
@@ -59,6 +61,8 @@ async function read(q, ctx) {
   const rec = notesAudio.info(dir, note.id);
   const audio = rec ? { url: '/api/notes/recording?id=' + encodeURIComponent(note.id) + '&b=' + rec.bytes + (notesAudio.hasClean(dir, note.id) ? '&c=1' : ''), ms: rec.ms } : null;
   const body = R.build({ note, event: ev, stateLines: focus.linesOf(dir, keys), frames: framesOf(dir, note.id), audio, topics: talk ? [] : F.topicsFrom(ev, null), now: nowMs });
+  // Jev is cutting this note's shots to the slide now (opening the note starts it, lib/routes-notes.js): the page reads the replay again
+  if (jevScreen.busy(note.id)) body.jev_running = true;
   return { status: 200, body };
 }
 
@@ -70,6 +74,13 @@ module.exports = {
   handle: async (req, res, url, ctx) => {
     if (url.pathname !== '/api/meeting-replay') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
-    return respond(ctx, res, await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json }));
+    const r = await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json });
+    // shots Jev has not looked at (a past meeting, kept before Jev was on): start Jev on them in the background, as GET
+    // /api/notes/one does, so a replay opened from the calendar is cut to the slide too. It never blocks the answer.
+    const nid = r.status === 200 && r.body && r.body.note ? r.body.note.id : null;
+    if (nid && !r.body.jev_running && notesScreen.list(ctx.runtimeDir, nid).some((f) => !f.jev)) {
+      try { if (require('./routes-notes.js').lookAtShots(ctx, nid)) r.body.jev_running = true; } catch { /* advisory */ }
+    }
+    return respond(ctx, res, r);
   },
 };

package/workspace/lib/routes-notes.js

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

package/workspace/lib/typesafe.js

@@ -81,7 +81,7 @@ function validKey(key) {
   return typeof key === 'string' && key.length >= 8 && key.length <= 512 && !/[\s\u0000-\u001f\u007f]/.test(key);
 }
 
-function once({ key, body, timeoutMs, ep = endpoint() }) {
+function once({ key, body, timeoutMs, ep = endpoint(), headers: extra = null }) {
   const mod = ep.protocol === 'http:' ? http : https;
   const payload = Buffer.from(body, 'utf8');
   return new Promise((resolve) => {
@@ -91,7 +91,7 @@ function once({ key, body, timeoutMs, ep = endpoint() }) {
       protocol: ep.protocol, hostname: ep.hostname, port: ep.port, path: PATH, method: 'POST',
       headers: {
         'Content-Type': 'application/json', 'Content-Length': payload.length,
-        ...(key ? { Authorization: 'Bearer ' + key } : {}), 'User-Agent': 'pmos-workspace',
+        ...(key ? { Authorization: 'Bearer ' + key } : {}), 'User-Agent': 'pmos-workspace', ...(extra || {}),
       },
       timeout: timeoutMs,
     }, (res) => {
@@ -135,10 +135,10 @@ function once({ key, body, timeoutMs, ep = endpoint() }) {
  * @returns {Promise<{ok:true, model, answers, usage}|{ok:false, reason, status?, requested:boolean}>}
  *   `requested` says whether a request left this process, so a caller can tell a refusal from a failure.
  */
-async function send({ key, body, ep, timeoutMs, retries, backoffMs }) {
+async function send({ key, body, ep, timeoutMs, retries, backoffMs, headers = null }) {
   let last = null;
   for (let attempt = 0; attempt <= retries; attempt++) {
-    last = await once({ key, body, timeoutMs, ep });
+    last = await once({ key, body, timeoutMs, ep, headers });
     if (last.ok) return { ...last, requested: true };
     if (!(last.status === 0 || retryable(last.status)) || attempt === retries) break;
     await sleep(backoffMs * Math.pow(2, attempt));
@@ -182,4 +182,70 @@ async function ask({ key, state, questions, model = DEFAULT_MODEL, timeoutMs = 3
   return l.ok ? { ...l, fallback: true, hosted_reason: r.reason } : { ...r, reason: r.reason + '; ' + l.reason };
 }
 
-module.exports = { ask, validKey, configureLocal, localTarget, validPort, validBackend, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, LOCAL_HOST, LOCAL_KEY, BACKENDS, __setEndpointForTests };
+/* ── images (docs.typesafe.ai/images.md, read 2026-11-04) ──────────────────────────────────────────────────────────────
+ * Jev 1.13 and 1.14 take still PNG or JPEG images; a Box question needs Jev 1.14 (jev-latest). Each request that holds an image
+ * or a Box question carries the header `TypeSafe-Danger-Zone-Images: true` (the feature is a preview). The image goes in the
+ * top-level `assets` map under a reference, and the reference is written in `state` where the image belongs. The service does
+ * not resize: each side must be 280 to 1568 px and the picture 78,400 to 2,458,624 px, so a caller sends a picture in range.
+ * The local servers (Winnow, Laya) take text only, so an image is never asked locally. */
+const IMAGE_HEADER = { 'TypeSafe-Danger-Zone-Images': 'true' };
+const IMAGE_SIDE = { min: 280, max: 1568 };
+const IMAGE_PIXELS = { min: 78400, max: 2458624 };
+const MAX_IMAGE_BYTES = 16 * 1024 * 1024;
+
+/** The width and height a PNG or JPEG file says it has, from its own bytes → { format: 'png'|'jpg', w, h } | null. */
+function imageSize(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 24) return null;
+  if (buf.readUInt32BE(0) === 0x89504e47 && buf.toString('latin1', 12, 16) === 'IHDR') return { format: 'png', w: buf.readUInt32BE(16), h: buf.readUInt32BE(20) };
+  if (buf[0] !== 0xff || buf[1] !== 0xd8) return null;
+  let i = 2;
+  while (i + 9 < buf.length) {
+    if (buf[i] !== 0xff) { i++; continue; }
+    const m = buf[i + 1];
+    if (m === 0xff) { i++; continue; }
+    if (m === 0xd8 || m === 0x01 || (m >= 0xd0 && m <= 0xd7)) { i += 2; continue; }
+    const len = buf.readUInt16BE(i + 2);
+    // a start-of-frame marker (C0–CF, but not C4 DHT, C8 JPG, CC DAC) holds the height then the width
+    if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { format: 'jpg', w: buf.readUInt16BE(i + 7), h: buf.readUInt16BE(i + 5) };
+    i += 2 + len;
+  }
+  return null;
+}
+/** Why Jev would refuse this picture, or null when it is in range. */
+function imageRefusal(size, bytes) {
+  if (!size) return 'the picture is not a PNG or a JPEG';
+  if (bytes > MAX_IMAGE_BYTES) return 'the picture is larger than 16 MB';
+  const { w, h } = size;
+  if (w < IMAGE_SIDE.min || h < IMAGE_SIDE.min || w > IMAGE_SIDE.max || h > IMAGE_SIDE.max) return `the picture is ${w} × ${h} px; Jev takes 280 to 1568 px a side`;
+  if (w * h < IMAGE_PIXELS.min || w * h > IMAGE_PIXELS.max) return `the picture has ${w * h} px; Jev takes 78,400 to 2,458,624`;
+  return null;
+}
+
+/**
+ * Ask Jev typed questions about one picture.
+ *
+ * @param {object} a
+ * @param {string} a.key        the API key. Required; no key (or only the local handle) means no request.
+ * @param {Buffer} a.image      a PNG or JPEG file, in Jev's size range (imageRefusal says why not).
+ * @param {string} a.name       how `state` and the questions call the picture, e.g. 'capture'. Letters only.
+ * @param {object} a.questions  { name: { type: 'noul'|'score'|'choice'|'box', instructions, criteria? } }
+ * @param {string} [a.text]     words to send with the picture (no secret: the caller scans them).
+ * @returns {Promise<{ok:true, model, answers, usage}|{ok:false, reason, status?, requested:boolean}>}
+ */
+async function askImage({ key, image, name = 'capture', questions, text = '', model = DEFAULT_MODEL, timeoutMs = 30000, retries = 2, backoffMs = 600 } = {}) {
+  if (!validKey(key) || key === LOCAL_KEY) return { ok: false, requested: false, reason: key === LOCAL_KEY ? 'the local model takes no pictures' : 'no TypeSafe key is set' };
+  const size = imageSize(image);
+  const refused = imageRefusal(size, image ? image.length : 0);
+  if (refused) return { ok: false, requested: false, reason: refused };
+  if (!/^[a-z]{1,32}$/.test(name)) return { ok: false, requested: false, reason: 'the picture needs a short name' };
+  const names = questions && typeof questions === 'object' ? Object.keys(questions) : [];
+  if (!names.length || names.length > MAX_QUESTIONS) return { ok: false, requested: false, reason: `between 1 and ${MAX_QUESTIONS} questions are required` };
+  // the reference is random, so no words in the questions or the text can match it by chance (images.md "References")
+  const ref = require('crypto').randomBytes(6).toString('hex') + '-' + name;
+  const words = String(text || '').slice(0, 4000);
+  const body = JSON.stringify({ model, state: { [name]: ref, ...(words ? { words } : {}) },
+    assets: { [ref]: { type: 'image', format: size.format, data_base64: image.toString('base64') } }, questions });
+  return send({ key, body, ep: endpoint(), timeoutMs, retries, backoffMs, headers: IMAGE_HEADER });
+}
+
+module.exports = { ask, askImage, imageSize, imageRefusal, IMAGE_SIDE, IMAGE_PIXELS, IMAGE_HEADER, validKey, configureLocal, localTarget, validPort, validBackend, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, LOCAL_HOST, LOCAL_KEY, BACKENDS, __setEndpointForTests };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/notes-screen-capture.js

@@ -23,7 +23,7 @@
  *     pictures of the last RING_MS (20 s) in memory for this, because a line is transcribed some seconds after it is said.
  *   - highlight: the PM's Highlight keeps the picture on screen at that moment.
  *   A picture the last kept shot already shows is never kept again, whatever the reason. Each shot carries why it was kept.
- * The shot is a JPEG of the frame at most MAX_W px wide. It is posted with the meeting time, the note and the capture token, so
+ * The shot is a JPEG of the frame at most MAX_SIDE px on its longer side: 1568 is the most Jev for images reads (lib/jev-screen.js). It is posted with the meeting time, the note and the capture token, so
  * the server keeps it beside the transcript and refuses a second tab (lib/notes-screen.js).
  *
  * WHAT IT NEVER DOES. It sends a shot only to this workspace's own server (`post`), never anywhere else.
@@ -32,7 +32,7 @@ import { bind, unbind } from './notes-shots.js';
 
 const SMALL_W = 64;
 const SMALL_H = 36;
-const MAX_W = 1600;
+const MAX_SIDE = 1568;
 const QUALITY = 0.72;
 
 export function changed(prev, cur, { pixel = 24, share = 0.02 } = {}) {
@@ -87,8 +87,9 @@ export function startScreen({ track, id, cap, clock, post, every = 2000, slowGap
   const s = { count: 0, lost: 0, stopped: false, paused: false, last: null, lastAt: 0, prev: null, moving: 0, still: 0, run: 0, ring: [], kept: new Map(), cues: [], heard: new Set(), chain: Promise.resolve(), timer: null };
 
   const snap = async (t, grey) => {
-    const w = Math.min(MAX_W, video.videoWidth);
-    const h = Math.round(video.videoHeight * (w / video.videoWidth));
+    const k = Math.min(1, MAX_SIDE / video.videoWidth, MAX_SIDE / video.videoHeight);
+    const w = Math.round(video.videoWidth * k);
+    const h = Math.round(video.videoHeight * k);
     big.width = w; big.height = h;
     big.getContext('2d').drawImage(video, 0, 0, w, h);
     const blob = await new Promise((res) => big.toBlob(res, 'image/jpeg', QUALITY));

package/workspace/public/pm/premium-vw-mtg.js

@@ -644,6 +644,21 @@ async function load(me, quiet) {
     edits: pts && pts.ok ? pts.edits || {} : (me.D && me.D.edits) || {}, lessons: pts && pts.ok ? pts.lessons || [] : (me.D && me.D.lessons) || [],
     terms: pts && pts.ok ? pts.terms || [] : (me.D && me.D.terms) || [] };
   draw(me);
+  if (rp && rp.ok && rp.jev_running) jevWatch(me, n.id);
+}
+/** Jev is cutting a past meeting's captures to the slide (MpJ): read the replay again every few seconds until it ends, so the
+ * crops show on this open, not the next. At most JEV_TRIES reads; the page draws the shots it has meanwhile. */
+const JEV_EVERY = 4000, JEV_TRIES = 45;
+function jevWatch(me, id, tries = 0) {
+  clearTimeout(me.jevT);
+  me.jevT = setTimeout(async () => {
+    if (MT !== me || !me.D || !me.n || me.n.id !== id) return;
+    const rp = await pmGet('/api/meeting-replay?' + q({ note: id }));
+    if (MT !== me || !me.D || !(rp && rp.ok)) return;
+    const rep = replayModel(rp); rep.raw = rp.keys || [];
+    me.D.rep = rep; draw(me);
+    if (rp.jev_running && tries + 1 < JEV_TRIES) jevWatch(me, id, tries + 1);
+  }, JEV_EVERY);
 }
 async function keyOf(text) {
   try {

package/workspace/public/pm/view-notes.js

@@ -1228,8 +1228,8 @@ function openSettings(ctx, n) {
       const csw = field({ label: 'Check notes against this repository with Jev', kind: 'check', value: !!(j && j.check), onCommit: (v) => setSwitch(ctx, { check: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-sw-check': '' } });
       parts.push(el('div', { class: 'nt-set' }, el('div', { class: 'nt-set__head' }, 'Jev'), jsw, csw,
         el('p', { class: 'nt-hint', 'data-nt-gates': '' }, j && j.paused ? j.paused : j && j.sentence ? j.sentence + ' Lines get the local label and the local repository match.'
-          : j && j.check_open ? 'Each line and, for a captured line, one repository passage go to TypeSafe. Audio, names and private notes never do.'
-            : j && j.label_open ? 'Each line goes to TypeSafe for its label. Audio, names and private notes never do.' : 'Off. Lines get the local label and the local repository match.')));
+          : j && j.check_open ? 'Each line and, for a captured line, one repository passage go to TypeSafe, and each screen capture so it can be cut to the slide. Audio, names and private notes never do.'
+            : j && j.label_open ? 'Each line goes to TypeSafe for its label, and each screen capture so it can be cut to the slide. Audio, names and private notes never do.' : 'Off. Lines get the local label and the local repository match.')));
     }
     parts.push(el('div', { class: 'nt-set' }, el('div', { class: 'nt-set__head' }, 'This note'),
       n.private ? el('p', { class: 'nt-hint' }, 'Private: it is not recorded and nothing from it goes to Jev or to any agent.') : null,

package/workspace/test-files.json

@@ -76,6 +76,7 @@
     "jev-categorize.test.js",
     "jev-status.test.js",
     "jev-route.test.js",
+    "jev-screen.test.js",
     "repo-watch.test.js",
     "markdown.test.mjs",
     "start-policy.test.js",