create-pmos 0.528.0 → 0.530.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.528.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,44 @@
     "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",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1243,
+          "t": "A look change from a report's chat becomes its next look, kept with ✓ and redrawn into the open draft; the drafting session's answer shows",
+          "s": "A look change from a report's chat becomes its next look, kept with ✓ and redrawn into the open draft; the drafting session's answer shows",
+          "k": "fix"
+        },
+        {
+          "n": 1245,
+          "t": "The Lab's background record says in plain words what Claude did, what came out and when",
+          "s": "The Lab's background record says in plain words what Claude did, what came out and when",
+          "k": "fix"
+        },
+        {
+          "n": 1244,
+          "t": "Meeting player, Jev crop display and word fix A",
+          "s": "Meeting player, Jev crop display and word fix A",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.528.0",
       "at": "2026-11-04T12:00:44.809Z",
@@ -395,40 +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"
-        }
-      ]
-    },
-    {
-      "v": "0.509.0",
-      "at": "2026-11-03T14:23:32.696Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1198,
-          "t": "No initiative without an expected outcome",
-          "s": "No initiative without an expected outcome",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@b9f6f671
+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-04T12:00: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-04T12:00: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-04T12:00:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
 status: stable
 ---
 

package/workspace/briefing-premium-calendar-3-test.js

@@ -145,21 +145,23 @@ const json = (r, b, status = 200) => r.fulfill({ status, contentType: 'applicati
   const r = C.page;
   // batch 25 item 11 (MvC): no tabs; the kept points sit left, the timeline is docked, the lines are the Transcript part of the one strip
   const unfold = async (id) => { if (await r.evaluate((k) => document.querySelector(`#czViewer .vzr-fold [data-a="strip"][data-k="${k}"]`).getAttribute('aria-expanded') !== 'true', id)) await tap(r, `.vzr-fold [data-a="strip"][data-k="${id}"]`); };
-  ok('R7 a kept recording has the replay card under the summary', await until(() => r.evaluate(() => !!document.querySelector('#czViewer .vzp-card .vzp-pl') && !document.querySelector('#czViewer [role="tablist"]')), 15000));
-  const playing = () => r.evaluate(() => /^Pause/.test((document.querySelector('#czViewer .vzp-dt [data-a="play"]') || { getAttribute: () => '' }).getAttribute('aria-label') || ''));
-  ok('R7 Replay shows the player, the strip and the kept points (MtReplay)', await until(() => r.evaluate(() => !!document.querySelector('#czViewer .vzp-dt .vzp-strip') && document.querySelectorAll('#czViewer .vzp-kr').length > 0)));
-  await tap(r, '.vzp-dt [data-a="play"]');
+  ok('R7 a kept recording has the replay card under the summary', await until(() => r.evaluate(() => !!document.querySelector('#czViewer .vzp-card .vzr-np') && !document.querySelector('#czViewer [role="tablist"]')), 15000));
+  const playing = () => r.evaluate(() => /^Pause/.test((document.querySelector('#czViewer .vzr-np:not(.vzr-ph1) [data-a="play"]') || { getAttribute: () => '' }).getAttribute('aria-label') || ''));
+  ok('R7 Replay shows the player, the strip and the kept points (MtReplay)', await until(() => r.evaluate(() => !!document.querySelector('#czViewer .vzr-np:not(.vzr-ph1) .vzp-strip') && document.querySelectorAll('#czViewer .vzp-kr').length > 0)));
+  await tap(r, '.vzr-np:not(.vzr-ph1) [data-a="play"]');
   ok('R7 Play plays', await until(playing));
-  const pos = () => r.evaluate(() => (document.querySelector('#czViewer .vzp-dt [data-clk="pos"]') || {}).textContent || '');
+  const pos = () => r.evaluate(() => (document.querySelector('#czViewer .vzr-np:not(.vzr-ph1) [data-clk="pos"]') || {}).textContent || '');
   const p0 = await pos();
   ok('R7 the playhead keeps time on its own clock', await until(async () => (await pos()) !== p0 && /^00:0[1-9]$/.test(await pos()), 5000), await pos());
-  await tap(r, '.vzp-dt [data-a="play"]');
+  await tap(r, '.vzr-np:not(.vzr-ph1) [data-a="play"]');
   const p1 = await pos();
   await r.waitForTimeout(600);   // longer than the playhead's 250 ms step: a paused playhead does not move
   ok('R7 Pause stops the playhead', (await pos()) === p1 && !(await playing()), p1 + ' / ' + await pos());
-  await r.$eval('#czViewer .vzp-dt .vzp-th[data-a="seekto"]', (b) => b.click());
-  ok('R7 a capture plays from its time, with the topic of that time', await until(async () => /^03:1\d$/.test(await pos()) && await r.evaluate(() => /Viewer beside the chat/.test((document.querySelector('#czViewer .vzp-top[aria-current="true"]') || {}).textContent || ''))), await pos());
-  await tap(r, '.vzp-dt [data-a="play"]');
+  await tap(r, '.vzr-np:not(.vzr-ph1) [data-a="caps"]');   // batch 27 item 12 (MpD4): the captures row is hidden until its icon is pressed
+  await until(() => r.evaluate(() => !!document.querySelector('#czViewer .vzr-np:not(.vzr-ph1) .vzp-th[data-a="seekto"]')));
+  await r.$eval('#czViewer .vzr-np:not(.vzr-ph1) .vzp-th[data-a="seekto"]', (b) => b.click());
+  ok('R7 a capture plays from its time, with the chapter of that time named above the bar (MpD1)', await until(async () => /^03:1\d$/.test(await pos()) && await r.evaluate(() => /Viewer beside the chat/.test((document.querySelector('#czViewer .vzr-np:not(.vzr-ph1) .vzr-nt b') || {}).textContent || ''))), await pos());
+  await tap(r, '.vzr-np:not(.vzr-ph1) [data-a="play"]');
   /* R12 every line: the Transcript fold seeks the replay */
   await unfold('tr');
   ok('R12 the Transcript lists every line, each with its time to play from', await until(async () => /Saved views move in their own work-item\./.test(await text(r)) && !!(await r.$('#czViewer [data-a="trseek"][data-t="760000"]'))), (await text(r)).slice(0, 300));

package/workspace/briefing-premium-calendar-test.js

@@ -102,7 +102,7 @@ const json = (r, b, status = 200) => r.fulfill({ status, contentType: 'applicati
 
   /* C8 a kept recording offers Replay */
   const R = await open('/premium-viewer.html?open=meeting&note=n1');
-  ok('C8 a kept recording offers Replay, and the card reads its replay', await until(() => R.page.evaluate(() => !!document.querySelector('#czViewer .vzp-card .vzp-pl')), 15000) && R.S.gets.some((g) => /meeting-replay\?note=n1/.test(g)));
+  ok('C8 a kept recording offers Replay, and the card reads its replay', await until(() => R.page.evaluate(() => !!document.querySelector('#czViewer .vzp-card .vzr-np')), 15000) && R.S.gets.some((g) => /meeting-replay\?note=n1/.test(g)));
   await R.ctx.close();
 
   /* C3 honest states */

package/workspace/changelog.json

@@ -1,4 +1,42 @@
 [
+ {
+  "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",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1243,
+    "t": "A look change from a report's chat becomes its next look, kept with ✓ and redrawn into the open draft; the drafting session's answer shows",
+    "s": "A look change from a report's chat becomes its next look, kept with ✓ and redrawn into the open draft; the drafting session's answer shows",
+    "k": "fix"
+   },
+   {
+    "n": 1245,
+    "t": "The Lab's background record says in plain words what Claude did, what came out and when",
+    "s": "The Lab's background record says in plain words what Claude did, what came out and when",
+    "k": "fix"
+   },
+   {
+    "n": 1244,
+    "t": "Meeting player, Jev crop display and word fix A",
+    "s": "Meeting player, Jev crop display and word fix A",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.528.0",
   "at": "2026-11-04T12:00:44.809Z",

package/workspace/fixtures/premium-viewer-fixtures.js

@@ -84,8 +84,10 @@ function install(page, o = {}) {
     page.route('**/api/notes/series?*', (r) => json(r, { ok: true, series: { key: 'viewer-sync', meetings: [{ id: 'n0', at: '2026-10-15T10:00:00Z', decided: 1, steps: 3 }, { id: 'n1', at: W.NOTE.meeting.start, decided: 2, steps: 3 }] } })),
     page.route('**/api/notes/search*', (r) => json(r, { ok: true, ids: ['n4'], hits: [{ id: 'n4', snip: '…which teams use saved views for teams every week…', open: true }] })),
     page.route('**/api/meeting-points/*', (r) => {   // a correction and its Undo (the answers lib/meeting-learn.js gives)
-      const b = post(r); if (/forget$/.test(new URL(r.request().url()).pathname)) { S.terms = (S.terms || []).filter((x) => x.id !== b.lesson); return json(r, { ok: true }); }
-      if (/term$/.test(new URL(r.request().url()).pathname)) { const t = { id: 't0123456789', note: b.note, heard: b.heard, means: b.means }; S.terms = (S.terms || []).concat([t]); return json(r, { ok: true, term: t, terms: S.terms }); }
+      if (/suggest$/.test(new URL(r.request().url()).pathname)) return json(r, { ok: true, suggest: S.suggest || null });   // batch 27 item 12: the ✦ spelling (none unless a test sets one)
+      const b = post(r); if (/keep$/.test(new URL(r.request().url()).pathname)) { S.terms = (S.terms || []).map((x) => (x.id === b.lesson ? { ...x, keep: b.keep ? 'yes' : 'no' } : x)); return json(r, { ok: true, term: S.terms.find((x) => x.id === b.lesson), terms: S.terms }); }
+      if (/forget$/.test(new URL(r.request().url()).pathname)) { S.terms = (S.terms || []).filter((x) => x.id !== b.lesson); return json(r, { ok: true }); }
+      if (/term$/.test(new URL(r.request().url()).pathname)) { const t = { id: 't0123456789', note: b.note, heard: b.heard, means: b.means, keep: 'ask' }; S.terms = (S.terms || []).concat([t]); return json(r, { ok: true, term: t, terms: S.terms }); }
       const phrase = require('../lib/meeting-learn.js').phraseOf(b.orig && b.orig.text, b.text);
       S.edits = { ...(S.edits || {}), [b.id]: { kind: b.kind, text: b.text, orig: b.orig } };
       return json(r, { ok: true, edits: S.edits, lesson: b.learn === false ? null : { id: 'l0123456789', phrase, kind: b.kind, meaning: b.text, orig: b.orig }, check: [] });

package/workspace/guide/idle-lab.md

@@ -39,7 +39,7 @@ The Lab shows only once there is something to show. Top to bottom:
 
 - One ✦ line for the week: the idle time Claude used, how many results you kept, and how many findings fit no initiative.
 - The findings that fit no initiative, each with ✓ and ✕.
-- **What Claude did in the background**: every background job this week, not only the idle lab. A result that waits on an initiative is a link there. It is not a second copy.
+- **What Claude did in the background**: every background job this week, not only the idle lab. Each row says in plain words what Claude did, why it ran and what came out, and when. For example: "Checked Inline login for eShop for risks · monthly check · 3 findings waiting · Sat 00:32", or "Redrew TSC Monthly Product Update in its saved look · 19:37". **See what it found** shows only when a result waits on the initiative. It opens the initiative, where the result is. It is not a second copy.
 - **You kept**: how many prototypes and scans you kept.
 - **Next time you step away**: what Claude plans to do next. Claude picks these by itself. To skip one, say so in chat.
 

package/workspace/guide/notes.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: notes"
 description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, decisions with their why and who, next steps with an open question, a discussion paragraph, and Wispr Flow's notes merged in and fetched by hand when the fetch fails; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository for conflicts, capture highlights during the meeting, create tasks from next steps, correct and tag lines, see what changed in your notes, replay the meeting, see screenshots of the shared screen beside the transcript, link a note to its meeting and its initiative, and get a summary."
-timestamp: 2026-11-03
+timestamp: 2026-11-04
 ---
 
 # Guide: notes
@@ -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
 
@@ -245,19 +245,31 @@ A meeting with a recording opens wide, in two columns. Press **Back to the side*
 
 - **Left:** the summary (two lines; press **Read it all** for the rest), then the kept points. Each point is one line. The icon shows its kind: a green dot is a decision, a box is a next step, a question mark is an open question. The header counts each kind. A next step said within two minutes after a decision, in the same topic, shows under that decision, with **Make a task**.
 - **Confirm:** press **✓** on a row to confirm it (press it again to undo). **Confirm N** in the header confirms every point that is left.
-- **Right:** press a row to see its evidence: the screen at that moment, the quote, and the screen captures near it. Press **▶** to play from the point. The pen opens the edit card. **Not right** moves the point to **Left out**.
+- **Right:** one player. The screen capture at the playing time is at the top. Under it is the name of the chapter that plays, with **chapter N of M**. The bar under the name shows each chapter as one part, with a gap between parts, and an icon for each kept point in its chapter. Move the pointer over the bar to see the capture and the chapter at that place. Press the bar to play from there.
+- **Controls:** back 15 seconds, play or pause, and forward 15 seconds, with **‹** and **›** for the previous and next chapter. The speed (1×, 1.5×, 2×) is at the left. At the right, the captures icon shows or hides the row of screen captures, and the chapters icon opens the list of chapters. Press a chapter in the list to play from its start. Escape closes the list.
+- **Caption:** under the controls, the line said at the playing time shows larger, with the speaker. The line before it and the line after it show lighter.
+- **A kept point:** press a row to play from that point. The selected row shows the pen (it opens the edit card) and **Not right** (it moves the point to **Left out**).
 - **Under the points:** one row of parts. Press one to open it: **Left out**, **Next steps**, **Since the last one**, **Facts mentioned**, **Names and terms**, **Prep and material** and **Transcript**.
-- **Bottom:** the timeline stays in view, with the full name of each chapter and a dot for each kept point.
 
-The captures row shows every kept screen capture. It does not yet show only the shared screen: that needs Jev for Images, which PMOS does not have yet.
+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. 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
 
-In the summary, a quote, **Left out** or the transcript, select the word (double-click it, or drag over up to four words). The word becomes a field. Type the right spelling and press **✓** or Enter. The word shows fixed in every place this meeting shows it, and the message says how many places. **Undo** puts it back. **Names and terms** lists the people of the invite and the words you fixed.
+Select a word or a few words anywhere in the meeting's notes: a kept point, the summary, **Next steps**, **Facts mentioned**, **Left out**, the caption or the transcript. You can also double-click one word. A small box opens under the words:
+
+- **Heard as “…”** says what was heard. The field holds the fix. Type the right spelling and press **✓** or Enter. Escape closes the box and changes nothing.
+- **✦ Claude suggests …** shows only when a real match was found: a fix you made before, a name in the meeting's invite (its title, agenda, material or people), or a word that the workspace's repository writes. The line names where the spelling came from. Press a spelling to put it in the field. When nothing matches, no suggestion shows.
+- **N places in this meeting** counts where the words show, by kind: kept points, next steps, facts, **Left out** and transcript lines.
+
+On a phone, the box opens at the bottom of the screen.
+
+After the fix, the words show fixed in every place this meeting shows them, and the message says **Fixed in N places**, with **Undo**. The fix shows in **Names and terms**: the word, what was heard, the places, and an Undo icon.
 
-Later notes spell the word your way: the fix goes to your agent with the notes it writes. In other meetings, the same heard words are underlined. Press one to fix it there too, with your fix already typed.
+**Names and terms** also asks **Remember “…” for your next meetings?** Press **✓** to remember it: later notes spell the word your way (the fix goes to your agent with the notes it writes), and in other meetings the same heard words are underlined, with your fix ready. Press **✕** to keep the fix in this meeting only. Until you press **✓**, the fix is for this meeting only. A fix made before this change stays remembered.
 
-The note's own files do not change. The fix shows where PMOS draws the note.
+The note's own files do not change. The fix shows where PMOS draws the note. A one-time hint under the kept points says how to select a word. It goes away after your first fix.
 
 ### Fix or delete a key point
 

package/workspace/guide/reports-set-up.md

@@ -59,7 +59,9 @@ Each cycle is a document: Draft or Issued, with its output, its copy state and w
 - A download happens only when you press a download item.
 - You issue a report. An issued report is frozen.
 - While a draft is written, the report waits until the file is still, then shows it once. The slides do not flicker, and the scroll position stays.
-- When a report has an open draft, keep talking in the chat. Each change you ask for, such as a date, a wording or a look, goes to that draft by itself. You do not press anything. The draft updates beside the chat, and Claude says in one line what it passed. An issued report does not change. Change its template for the next cycle.
+- When a report has an open draft, keep talking in the chat. Each change to its words, such as a date, a status or a wording, goes to that draft by itself. You do not press anything. The draft updates beside the chat, and Claude says in one line what it passed. An issued report does not change. Change its template for the next cycle.
+- The report's session writes one line when it is done with your change: what it changed, or why it did not. The line shows in the report beside the chat. The report says "drafting it" only while a draft is written.
+- A change to the look, such as the colours, the tables or the Gantt, or a deck or screenshot to follow, is not a change to the words. Attach the file in the chat if there is one. Claude starts the next look of the report from your words and the file. It shows in the report's template with ✓ and ✕. Press ✓ to keep it: the open draft is drawn again in the new look, and its numbers stay the same. Nothing is issued.
 
 ## Send a dashboard as a report
 

package/workspace/lib/bg-queue.js

@@ -39,7 +39,7 @@
  * THE RECORD, <stateDir>/bg-queue.jsonl:
  *   turn  { at, kind: 'turn', job, step, go, why }   a job's turn changed (it was held and now goes, or the reason changed). A steady
  *                                                     minute writes nothing.
- *   done  { at, kind: 'done', job, title, ws, ini?, session, meta? }   a background session ended (ended(), from the server's one
+ *   done  { at, kind: 'done', job, title, ws, ini?, session, meta?, ref? }   a background session ended (ended(), from the server's one
  *                                                     session-end hook). A session the PM started, or a chat, is not written.
  * status() is the last plan, for the Lab ("what runs next"). record({ ws, since }) is the done lines, newest first, for the Lab's
  * "What Claude did in the background" (lib/routes-lab.js): [{ job, title, meta?, at, ini?, board? }].
@@ -182,6 +182,8 @@ function create(host = {}) {
     const job = jobOfOrigin(s.origin);
     if (!job) return;
     const line = { at: new Date(now).toISOString(), kind: 'done', job, title: String(s.name || job).slice(0, 160), ws: s.ws || null, session: s.id || null };
+    const ref = String(s.origin).split(':').slice(1).join(':').slice(0, 120);   // what the job was for (a report's id for report-design), for the Lab's words
+    if (ref) line.ref = ref;
     const ini = s.initiative || initiativeOfOrigin(s.origin);
     if (ini) line.ini = String(ini);
     if (s.outcome && typeof s.outcome === 'string') line.meta = s.outcome.slice(0, 160);
@@ -202,6 +204,8 @@ function create(host = {}) {
       if (l.meta) row.meta = l.meta;
       if (l.ini) row.ini = l.ini;
       if (l.board) row.board = l.board;
+      if (l.ref) row.ref = l.ref;
+      if (l.session) row.session = l.session;
       out.push(row);
     }
     return out.reverse();

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

@@ -23,7 +23,7 @@
  *     topics: [{ id, text, src, state, minutes, n, first_t, stretches, parked, by }]   visited ones first, in the order they came up
  *     runs:   [{ topic, n, from_ms, to_ms }]
  *     notes:  [{ id, t, cat, body, heard, why, src }]                          PMOS's notes with the time they were made
- *     shots:  [{ t, w, h, why?, text? }]                                       kept shots only
+ *     shots:  [{ t, w, h, why?, text?, jev? }]                                 kept shots only; jev = { kind, box? } when Jev for images read the shot
  *     recordings: how many times the recording was started (1 for most notes)
  *     gaps:   [{ from_ms, to_ms }]                                            where the recording was off between two starts (empty when there was one)
  *     aside_count }
@@ -105,13 +105,25 @@ function timeOfKey(item, lines) {
   return null;
 }
 
+/** 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.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;
+  const kind = j.kind === 'faces' ? 'faces' : 'content';
+  return { kind, ...(box && kind === 'content' ? { box } : {}) };
+}
+
 /** Join the three records. */
 function build({ note, event = null, stateLines = [], frames = [], audio = null, topics = [], now = Date.now() } = {}) {
   const n = note || {};
   const lines = linesOf(n);
   const start = startOf(n, event);
   const shots = (frames || []).filter((f) => f && finite(f.t) && !f.aside).sort((a, b) => a.t - b.t)
-    .map((f) => ({ t: f.t, w: f.w || 0, h: f.h || 0, ...(f.why ? { why: f.why } : {}), ...(f.text ? { text: str(f.text, SHOT_TEXT_MAX) } : {}) }));
+    .map((f) => ({ t: f.t, w: f.w || 0, h: f.h || 0, ...(f.why ? { why: f.why } : {}), ...(f.text ? { text: str(f.text, SHOT_TEXT_MAX) } : {}), ...(jevOf(f.jev) ? { jev: jevOf(f.jev) } : {}) }));
   const asideCount = (frames || []).filter((f) => f && f.aside).length;
 
   // Focus's state: topics, stretches, PMOS's notes. Stretches are measured from meeting time 0.