create-pmos 0.203.0 → 0.205.0

package/workspace/extension/popup.js

@@ -0,0 +1,195 @@
+/* popup.js — the PMOS button's popup (popup.html): "Add this page to a report design".
+ * PMOS draws the popup: the page is one frame, ${address}/c3.html?capture=1&pop=1&…, which lists the reports and has the Add button. The extension never posts to PMOS
+ * itself, because every PMOS write needs a press on a PMOS page (a nonce and an Origin check). So when the frame asks (postMessage { pmosCapture: 'request' }), this
+ * page takes the open tab and posts it back to the frame ({ pmosCapture: 'data', … }), and the frame uploads it with its own press. Both ways, the message must
+ * come from the other window and from the PMOS origin; the extension posts to the PMOS origin only.
+ *   Google Slides and Google Docs  → the PDF, fetched here with the user's own Google cookies (host permission for https://docs.google.com/*)
+ *   any other page                 → pictures of the whole page, scrolled top to bottom: at most 8, JPEG, 650 ms apart (Chrome's capture rate limit), scroll put back after
+ * When nothing answers at the address, this page says so and offers Try again. Nothing else is fetched. */
+(function () {
+  'use strict';
+  var A = window.PMOS_ADDRESS;
+  var C = window.PMOS_CAPTURE;
+  var CHECK_MS = 4000;     // how long to wait for PMOS to answer
+  var READY_MS = 8000;     // how long to wait for the frame to say it is drawn
+  var SETTLE_MS = 300;     // after a scroll, before the picture
+  var msg = document.getElementById('msg');
+  var frame = null;
+  var frameOrigin = '';
+  var readyTimer = null;
+  var busy = false;
+  var current = null;      // { tab, kind, address }
+
+  function readAddress(done) {
+    var fallback = A.DEFAULT_ADDRESS;
+    try {
+      var o = {}; o[A.KEY] = fallback;
+      chrome.storage.sync.get(o, function (v) { done(A.normalizeAddress(v && v[A.KEY]) || fallback); });
+    } catch (e) { done(fallback); }
+  }
+  function getTab(done) {
+    try { chrome.tabs.query({ active: true, currentWindow: true }, function (t) { done((t && t[0]) || null); }); } catch (e) { done(null); }
+  }
+  /** Resolves when something answers at the address (an opaque no-cors reply is enough), rejects when nothing listens. */
+  function answers(addr) {
+    var ctl = typeof AbortController === 'function' ? new AbortController() : null;
+    var t = ctl ? setTimeout(function () { ctl.abort(); }, CHECK_MS) : null;
+    return fetch(addr + '/c3.html', { mode: 'no-cors', cache: 'no-store', signal: ctl ? ctl.signal : undefined })
+      .then(function (r) { if (t) clearTimeout(t); return r; }, function (e) { if (t) clearTimeout(t); throw e; });
+  }
+  var sleep = function (ms) { return new Promise(function (r) { setTimeout(r, ms); }); };
+
+  /* ── the popup's own states ── */
+  function head(host) {
+    var h = document.createElement('div'); h.className = 'head';
+    var b = document.createElement('b'); b.textContent = 'PMOS'; h.appendChild(b);
+    var s = document.createElement('span'); s.textContent = 'Add this page to a report design'; h.appendChild(s);
+    host.appendChild(h);
+  }
+  function show(text, withRetry, extra) {
+    if (frame) { frame.remove(); frame = null; }
+    clearTimeout(readyTimer);
+    msg.textContent = '';
+    msg.className = 'msg';
+    if (!msg.parentNode) document.body.appendChild(msg);
+    head(msg);
+    var p = document.createElement('p'); p.textContent = text; msg.appendChild(p);
+    if (extra) msg.appendChild(extra);
+    if (withRetry) {
+      var b = document.createElement('button'); b.type = 'button'; b.textContent = 'Try again'; b.setAttribute('data-act', 'retry');
+      b.addEventListener('click', function () { start(); });
+      msg.appendChild(b);
+    }
+  }
+  function showDown(addr) {
+    var a = document.createElement('a'); a.href = '#'; a.textContent = 'Set the address';
+    a.addEventListener('click', function (e) { e.preventDefault(); try { chrome.runtime.openOptionsPage(); } catch (x) { /* no options page */ } });
+    show('PMOS is not answering at ' + addr + '. Start PMOS, then try again.', true, a);
+  }
+
+  /* ── the frame ── */
+  function post(m) {
+    if (!frame || !frame.contentWindow || !C.validOutgoing(m)) return false;
+    frame.contentWindow.postMessage(m, frameOrigin);
+    return true;
+  }
+  function showFrame(tab, kind, addr, screens) {
+    var q = new URLSearchParams({ capture: '1', pop: '1', pkind: kind, ptitle: C.sampleName(tab.title, tab.url), purl: tab.url || '' });
+    if (screens) q.set('pscreens', String(screens));
+    frame = document.createElement('iframe');
+    frame.title = 'PMOS: add this page to a report design';
+    frame.src = addr + '/c3.html?' + q.toString();
+    frameOrigin = new URL(addr).origin;
+    if (msg.parentNode) msg.remove();
+    document.body.appendChild(frame);
+    // an older PMOS answers but has no capture page: it never says ready
+    readyTimer = setTimeout(function () { showDown(addr); }, READY_MS);
+  }
+
+  /* ── what is taken ── */
+  var toBase64 = function (buf) {
+    var bytes = new Uint8Array(buf); var s = '';
+    for (var i = 0; i < bytes.length; i += 0x8000) s += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
+    return btoa(s);
+  };
+  var run = function (tabId, func, args) {
+    return chrome.scripting.executeScript({ target: { tabId: tabId }, func: func, args: args || [] }).then(function (r) { return r && r[0] ? r[0].result : undefined; });
+  };
+  var measure = function () { var d = document.documentElement; var b = document.body; return { h: Math.max(d ? d.scrollHeight : 0, b ? b.scrollHeight : 0), vh: window.innerHeight, y: window.scrollY }; };
+  var scrollTo = function (y) { window.scrollTo({ top: y, left: 0, behavior: 'instant' }); return window.scrollY; };
+
+  function takePdf(tab, kind) {
+    var url = C.exportUrl(tab.url);
+    post({ pmosCapture: 'progress', text: 'Getting the PDF from Google', step: 1, of: 3 });
+    return fetch(url, { credentials: 'include', cache: 'no-store', redirect: 'follow' }).then(function (r) {
+      if (!r.ok) throw new Error('Google did not give the PDF (' + r.status + '). Open the file in Chrome while signed in to Google, then try again.');
+      return r.arrayBuffer();
+    }, function () { throw new Error('Chrome could not reach Google to get the PDF. Check the connection, then try again.'); }).then(function (buf) {
+      var bytes = new Uint8Array(buf);
+      if (!(bytes[0] === 0x25 && bytes[1] === 0x50 && bytes[2] === 0x44 && bytes[3] === 0x46)) throw new Error('Google did not give a PDF. Sign in to Google in this Chrome, make sure you can open the file, then try again.');
+      if (bytes.length > C.MAX_BYTES) throw new Error('The PDF is over 20 MB. PMOS keeps a sample up to 20 MB. Add a smaller copy.');
+      post({ pmosCapture: 'progress', text: 'Reading the PDF', step: 2, of: 3 });
+      var pages = C.pdfPageCount(bytes);
+      return { pmosCapture: 'data', kind: 'pdf', name: C.sampleName(tab.title, tab.url), url: tab.url, pages: pages || undefined, data: toBase64(buf) };
+    });
+  }
+
+  function takePictures(tab) {
+    var tabId = tab.id; var windowId = tab.windowId;
+    var start = null; var pics = []; var bytes = 0; var last = 0;
+    return run(tabId, measure).then(function (m) {
+      if (!m || !m.vh) throw new Error('Chrome does not let PMOS read this page.');
+      start = m.y || 0;
+      var plan = C.scrollPlan(m.h, m.vh, C.MAX_PICTURES);
+      var n = plan.offsets.length;
+      var chain = Promise.resolve();
+      plan.offsets.forEach(function (y, i) {
+        chain = chain.then(function () {
+          post({ pmosCapture: 'progress', text: 'Picture ' + (i + 1) + ' of ' + n + (i ? ', scrolling down' : ''), step: i + 1, of: n + 1 });
+          return run(tabId, scrollTo, [y]);
+        }).then(function () {
+          var wait = Math.max(SETTLE_MS, C.MIN_GAP_MS - (Date.now() - last));
+          return sleep(wait);
+        }).then(function () {
+          last = Date.now();
+          return chrome.tabs.captureVisibleTab(windowId, { format: 'jpeg', quality: 80 });
+        }).then(function (dataUrl) {
+          var b64 = String(dataUrl || '').replace(/^data:[^,]*,/, '');
+          if (!b64) throw new Error('Chrome did not give a picture of the page.');
+          bytes += C.base64Bytes(b64);
+          if (bytes > C.MAX_BYTES) throw new Error('The pictures are over 20 MB. PMOS keeps a sample up to 20 MB. Open a shorter page, or add it as a PDF.');
+          pics.push(b64);
+        });
+      });
+      return chain;
+    }).then(function () {
+      return { pmosCapture: 'data', kind: 'pictures', name: C.sampleName(tab.title, tab.url), url: tab.url, pictures: pics };
+    }).then(function (out) { return restore(tabId, start).then(function () { return out; }); },
+      function (e) { return restore(tabId, start).then(function () { throw e; }); });
+  }
+  function restore(tabId, y) { return y == null ? Promise.resolve() : run(tabId, scrollTo, [y]).catch(function () { /* the page went away */ }); }
+
+  function capture() {
+    if (busy || !current) return;
+    busy = true;
+    var tab = current.tab;
+    var job = C.exportUrl(tab.url) ? takePdf(tab, current.kind) : takePictures(tab);
+    job.then(function (out) {
+      post({ pmosCapture: 'progress', text: 'Sending it to PMOS', step: out.kind === 'pdf' ? 3 : (out.pictures.length + 1), of: out.kind === 'pdf' ? 3 : (out.pictures.length + 1) });
+      if (!post(out)) throw new Error('The page could not be sent to PMOS.');
+    }).catch(function (e) {
+      post({ pmosCapture: 'error', error: String((e && e.message) || 'The page could not be taken.') });
+    }).then(function () { busy = false; });
+  }
+
+  window.addEventListener('message', function (e) {
+    var m = C.fromFrame(e, frame && frame.contentWindow, frameOrigin);
+    if (!m) return;
+    if (m.pmosCapture === 'ready') { clearTimeout(readyTimer); return; }
+    if (m.pmosCapture === 'resize') { if (frame) frame.style.height = m.height + 'px'; return; }
+    if (m.pmosCapture === 'close') { window.close(); return; }
+    if (m.pmosCapture === 'open') {
+      try { chrome.tabs.create({ url: frameOrigin + '/c3.html?studio=' + encodeURIComponent(m.report) }); } catch (x) { /* no tabs */ }
+      window.close();
+      return;
+    }
+    if (m.pmosCapture === 'request') capture();
+  });
+
+  function start() {
+    busy = false;
+    readAddress(function (addr) {
+      getTab(function (tab) {
+        var kind = tab ? C.classifyUrl(tab.url) : 'blocked';
+        if (!tab || kind === 'blocked') { show('Chrome does not let PMOS read this page. Open a web page, such as a Google Slides deck or any site, then press the PMOS button.', false); return; }
+        current = { tab: tab, kind: kind, address: addr };
+        var go = function (screens) {
+          answers(addr).then(function () { showFrame(tab, C.pageKind(tab.url), addr, screens); }, function () { showDown(addr); });
+        };
+        if (kind !== 'other') { go(0); return; }
+        run(tab.id, measure).then(function (m) { go(m && m.vh ? C.scrollPlan(m.h, m.vh, 1000).total : 0); }, function () { go(0); });
+      });
+    });
+  }
+  start();
+})();

package/workspace/guide/report-design.md

@@ -22,7 +22,7 @@ Use one of these two buttons:
 
 1. Select **Deck** or **Document** at the top of the studio.
 2. Write what the report is for and who reads it. For example: "This goes to the progress session every other Thursday. The decisions must stand out."
-3. Press **Add a sample** to give PMOS a report that people liked. You can upload a file, paste a link, or pick a report document that PMOS has. Each sample shows what PMOS took from it. PMOS cannot open a link, so a link sample tells you which file to add. For Google Slides, choose **File**, **Download**, **PDF document (.pdf)** in Slides, then add that file. PMOS sees the pages of a PDF or an image, so it can follow their look. From a .pptx or a .docx, PMOS gets only the words.
+3. Press **Add a sample** to give PMOS a report that people liked. You can upload a file, paste a link, add a page from Chrome (see below), or pick a report document that PMOS has. Each sample shows what PMOS took from it. PMOS reads a link from Google Slides, Docs or Sheets, or from Confluence, through your own connectors. It saves the words and the structure (slide titles, order, sections and tables), and it changes nothing in the file. It does not get the look. To match the look, also add the file as a PDF or a screenshot. For Google Slides, choose **File**, **Download**, **PDF document (.pdf)** in Slides, then add that file. If your connectors cannot read the link, the sample says so. Any other link is kept by its address, and PMOS cannot open it. PMOS sees the pages of a PDF or an image, so it can follow their look. From a .pptx or a .docx, PMOS gets only the words.
 4. Press **Make the next version**. PMOS makes a version from your words and this cycle's data. This takes a short time. You can leave the studio. The studio shows when the version is ready.
 5. Read the version in the preview. Write what to change and press **Make the next version** again. Each turn makes a new version: D1, D2, D3 and so on.
 
@@ -30,6 +30,20 @@ To set the width of the studio, use **Half**, **3/4** or **Whole** at the top ri
 
 If a turn fails, the studio shows why. Nothing changes. Try the turn again.
 
+
+### Add a page from Chrome
+
+You can add the page you are looking at in Chrome, on any website, as a sample. This needs the PMOS extension in Chrome. Run `pmos extension` in a terminal for the steps to load it.
+
+1. In Chrome, open the page, for example a Google Slides deck, a Google Doc or a Confluence page.
+2. Press the **PMOS** button in the Chrome toolbar. The popup says "Add this page to a report design".
+3. Choose the report in the **Report** list. It starts on the report whose design studio you opened last.
+4. Press **Add as a sample**. Keep the popup open while it saves. When it says "Added to" and the name of the report, press **Open the studio**.
+
+A Google Slides deck or a Google Doc comes to PMOS as a PDF, so PMOS can follow its look. The sample reads "From Chrome, PDF, 12 slides", or "pages" for a document. Chrome asks Google for the PDF with your own Google sign-in. Any other page comes as pictures of the whole page, scrolled top to bottom, at most 8 pictures. The sample reads "From Chrome, 3 page pictures". PMOS reads every picture, and follows its look as it does for a PDF. A sample is at most 20 MB. If the page is bigger, the popup says so: open a shorter page, or add a smaller copy.
+
+The sample shows in a design studio that is already open, in a few seconds. If the popup says "PMOS is not answering", start PMOS and press **Try again**. Nothing leaves your computer: the popup sends the page only to your own PMOS.
+
 ### Point at a part
 
 Keep **Point and say** on. Click a part of the preview and write what to change there. A numbered marker shows the spot. Your next turn sends the markers with your words.

package/workspace/lib/extension-cli.js

@@ -1,5 +1,5 @@
 'use strict';
-/* extension-cli.js — `pmos extension`: where the Chrome extension for Google Meet is, and how to load it (initiative c3-meet-extension).
+/* extension-cli.js — `pmos extension`: where the PMOS Chrome extension is (the Meet panel and the button that adds a page to a report design), and how to load it (initiatives c3-meet-extension, report-design-studio).
  *
  *   pmos extension    print the absolute path of workspace/extension and the steps to load it in Chrome
  *
@@ -10,20 +10,22 @@ const path = require('path');
 
 const COMMANDS = { extension: [] };
 const FOLDER = path.resolve(__dirname, '..', 'extension');
-const USAGE = ['usage: pmos extension — the Chrome extension that shows the meeting companion over a Google Meet call'];
+const USAGE = ['usage: pmos extension — the Chrome extension: the meeting companion over a Google Meet call, and a button that adds a page to a report design'];
 
 /** The lines `pmos extension` prints for a folder. Pure. */
 function lines(folder, exists = true) {
   const out = [];
   if (!exists) { out.push(`✗ the extension folder is not here: ${folder}`, '  Reinstall the workspace with `pmos upgrade`.'); return out; }
-  out.push('PMOS for Google Meet (Chrome)', '', `  folder  ${folder}`, '',
+  out.push('PMOS for Chrome', '', `  folder  ${folder}`, '',
     'Load it in three steps:',
     '  1. In Chrome, open chrome://extensions',
     '  2. Turn on Developer mode (top right)',
     '  3. Press Load unpacked, then pick the folder above',
     '',
     'PMOS is looked for at http://localhost:7433. If pmos printed another port, open the extension\'s Options and set that address.',
-    'Then open a Google Meet call: the panel shows at the bottom right.');
+    'Then open a Google Meet call: the panel shows at the bottom right.',
+    'To add a page to a report design, open any page and press the PMOS button in the toolbar. Choose the report, then Add as a sample.',
+    'After an update, press the reload arrow on the extension\'s card in chrome://extensions.');
   return out;
 }
 

package/workspace/lib/headless.js

@@ -3,7 +3,7 @@
  * (initiative workspace-headless-jobs; PM decision 2026-10-11: keep Jev, no direct Claude API, background
  * jobs that need no human run headless).
  *
- *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | 'core-doc' | 'report-design' | null   (null: open a pane, as before)
+ *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | 'core-doc' | 'report-design' | 'report-sample-fetch' | null   (null: open a pane, as before)
  *   argsFor(kind, { modelArgs, addDirs, writePaths }) → the argv after `claude` (writePaths: the one render file a report-design job may write)
  *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
  *   streamLines(line)                              → { log: [lines], result: object|null }   one stream-json event, for the live log
@@ -80,7 +80,9 @@ const REPORT_FIND_ORIGINS = Object.freeze(['report-find:']);
 const CORE_DOC_ORIGINS = Object.freeze(['core-doc:']);
 // report-design-studio: a studio turn, a cycle render or a re-render to match (origin `report-design:<cadence>`).
 const REPORT_DESIGN_ORIGINS = Object.freeze(['report-design:']);
-const WRITE_PATH_KINDS = Object.freeze(['report-design']);   // kinds whose one writable file the caller names (argsFor writePaths)
+// report-design-studio: reading ONE linked Google or Confluence file through the PM's own connectors (origin `report-sample-fetch:<cadence>:<sampleId>`).
+const REPORT_SAMPLE_FETCH_ORIGINS = Object.freeze(['report-sample-fetch:']);
+const WRITE_PATH_KINDS = Object.freeze(['report-design', 'report-sample-fetch']);   // kinds whose one writable file the caller names (argsFor writePaths)
 
 // What each kind may use. Read-only search is always allowed. The notes passes write their JSON (and rename the .tmp
 // file) in their notes folder, which --add-dir opens to them; the skills also run `pmos` verbs and repository scripts.
@@ -110,6 +112,8 @@ const TOOLS = Object.freeze({
   'core-doc': Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos coredoc write *)']),
   // The design run: read and search only. Its one write, the render file, is added per run by argsFor (writePaths). No Bash, no web, nothing that sends.
   'report-design': Object.freeze(['Read', 'Glob', 'Grep']),
+  // The link fetch run: Read, and its one write (the text copy of the linked file) is added per run by argsFor. No Bash, no web, no connector tool named.
+  'report-sample-fetch': Object.freeze(['Read']),
   skill: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(pmos *)', 'Bash(node *)',
     'Bash(git log *)', 'Bash(git status *)', 'Bash(git diff *)', 'Bash(ls *)', 'Bash(date *)']),
 });
@@ -134,6 +138,7 @@ function kindFor({ agent, origin, skill, env } = {}) {
   if (REPORT_FIND_ORIGINS.some((p) => o.startsWith(p))) return 'report-find';
   if (CORE_DOC_ORIGINS.some((p) => o.startsWith(p))) return 'core-doc';
   if (REPORT_DESIGN_ORIGINS.some((p) => o.startsWith(p))) return 'report-design';
+  if (REPORT_SAMPLE_FETCH_ORIGINS.some((p) => o.startsWith(p))) return 'report-sample-fetch';
   if (skill && HEADLESS_SKILLS.includes(String(skill))) return 'skill';
   return null;
 }
@@ -141,7 +146,7 @@ function kindFor({ agent, origin, skill, env } = {}) {
 function argsFor(kind, { modelArgs = [], addDirs = [], writePaths = [] } = {}) {
   if (!TOOLS[kind]) throw new Error('unknown headless kind: ' + kind);
   const tools = TOOLS[kind].slice();
-  // A report-design run may write its render file and nothing else: one absolute path, no wildcard, no comma.
+  // A report-design run may write its render file (a report-sample-fetch run, its text copy) and nothing else: one absolute path, no wildcard, no comma.
   if (WRITE_PATH_KINDS.includes(kind)) {
     for (const p of Array.isArray(writePaths) ? writePaths : []) {
       const s = String(p || '');
@@ -260,4 +265,4 @@ function logLines(r, exitCode) {
   return out;
 }
 
-module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, CORE_DOC_ORIGINS, REPORT_DESIGN_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, CORE_DOC_ORIGINS, REPORT_DESIGN_ORIGINS, REPORT_SAMPLE_FETCH_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };

package/workspace/lib/report-design.js

@@ -19,6 +19,7 @@
  * THE LINES of design.jsonl. Every line is { ev, …, at, actor }. `actor` is the guard's actor for a press, or { by: 'pmos', via: 'job' } for a job:
  *   describe      { text, format }                         the PM's plain words, and Deck or Document
  *   sample        { id, name, kind, source, ext, readable } a sample was added (the file is samples/<id>.<ext>, its record samples/<id>.json)
+ *   fetched       { id, ok, via?, title?, reason? }        a link sample was read through the PM's connectors (ok), or could not be (reason); the words are samples/<id>.txt
  *   took          { id, took, readable }                   what a job took from a sample (or that it could not read it)
  *   turn          { text, points, base, job }              a refine turn started a job; `base` is the version it builds on
  *   version       { n, format, turn, answer, from }        a job (or an adopted cycle) landed D<n>
@@ -44,9 +45,10 @@ const zlib = require('zlib');
 const RD = require('./report-draft.js');
 const issues = require('./issues.js');
 
-const EVENTS = Object.freeze(['describe', 'sample', 'took', 'turn', 'version', 'accept', 'revert', 'error', 'cycle-decision']);
+const EVENTS = Object.freeze(['describe', 'sample', 'fetched', 'took', 'turn', 'version', 'accept', 'revert', 'error', 'cycle-decision']);
 const FORMATS = Object.freeze(['deck', 'doc']);
-const SAMPLE_KINDS = Object.freeze(['pdf', 'pptx', 'docx', 'image', 'link', 'pmos-doc']);
+const SAMPLE_KINDS = Object.freeze(['pdf', 'pptx', 'docx', 'image', 'pictures', 'link', 'pmos-doc']);
+const MAX_PICTURES = 12;
 const MAX_SAMPLE_BYTES = 20 * 1024 * 1024;
 const MAX_THUMB_BYTES = 256 * 1024;
 const MAX_TEXT = 4000;
@@ -117,8 +119,12 @@ function fold(events) {
       if (FORMATS.includes(l.format)) st.format = l.format;
       st.log.push({ at: l.at, who: 'you', kind: 'describe', text: str(l.text) });
     } else if (l.ev === 'sample') {
-      st.samples.set(l.id, { id: l.id, name: str(l.name), kind: l.kind, source: str(l.source), ext: str(l.ext), took: null, readable: l.readable !== false, at: l.at });
+      st.samples.set(l.id, { id: l.id, name: str(l.name), kind: l.kind, source: str(l.source), ext: str(l.ext), took: null, readable: l.readable !== false, at: l.at,
+        ...(l.via === 'chrome' ? { via: 'chrome' } : {}), ...(Number.isInteger(l.count) ? { count: l.count } : {}), ...(Number.isInteger(l.pages) ? { pages: l.pages } : {}) });
       st.log.push({ at: l.at, who: 'you', kind: 'sample', text: str(l.name), sample: l.id });
+    } else if (l.ev === 'fetched') {
+      const s = st.samples.get(l.id);
+      if (s) { s.readable = l.ok === true; s.fetched = l.ok === true; s.fetch_reason = l.ok === true ? null : str(l.reason) || 'no reason'; }
     } else if (l.ev === 'took') {
       const s = st.samples.get(l.id);
       if (s) { if (typeof l.took === 'string' && l.took) s.took = l.took; if (typeof l.readable === 'boolean') s.readable = l.readable; }
@@ -204,7 +210,7 @@ function addSample(root, cadence, input, { actor, now } = {}) {
     let u; try { u = new URL(link); } catch { return refuse(400, 'link must be a full address, such as https://…'); }
     if (u.protocol !== 'https:' && u.protocol !== 'http:') return refuse(400, 'link must be an http or https address');
     if (link.length > 2000) return refuse(400, 'link is too long');
-    // the job reads files only (Read, Glob, Grep), so a link is kept by its address and the PM is told how to add a copy PMOS can read
+    // the job reads files only (Read, Glob, Grep), so a link is kept by its address; a Google or Confluence link is then read by the fetch run (recordFetched)
     rec = { id, name: oneLine(input.name || linkName(u), 120), kind: 'link', source: link, ext: '', readable: false, thumb: null, text_file: null };
   } else if (typeof input.doc === 'string' && input.doc.trim()) {
     const rel = input.doc.trim().replace(/\\/g, '/');
@@ -216,6 +222,32 @@ function addSample(root, cadence, input, { actor, now } = {}) {
     writeAtomic(path.join(p.samples, `${id}.md`), text);
     const fm = /^---\r?\n[\s\S]*?\btitle:\s*["']?([^\n"']+)/.exec(text);
     rec = { id, name: oneLine(input.name || (fm ? fm[1] : rel.split('/').slice(-2).join(' ')), 120), kind: 'pmos-doc', source: rel, ext: 'md', readable: true, thumb: null, text_file: null };
+  } else if (str(input.kind) === 'pictures' || Array.isArray(input.pictures)) {
+    // pictures of a whole page, scrolled top to bottom, from the Chrome extension (the page frames PMOS; see extension/popup.js)
+    const list = Array.isArray(input.pictures) ? input.pictures : null;
+    if (str(input.kind) !== 'pictures' || !list || !list.length) return refuse(400, 'pictures needs kind "pictures" and a list of pictures (base64 JPEG or PNG)');
+    if (list.length > MAX_PICTURES) return refuse(400, `at most ${MAX_PICTURES} pictures in one sample`);
+    const bufs = [];
+    let total = 0;
+    for (const [i, raw] of list.entries()) {
+      if (typeof raw !== 'string' || !raw) return refuse(400, `picture ${i + 1} is empty`);
+      const b64 = raw.replace(/^data:[^,]*,/, '');
+      total += Math.floor(b64.length * 3 / 4);
+      if (total > MAX_SAMPLE_BYTES + 4 * list.length) return refuse(413, 'a sample is at most 20 MB');
+      const buf = Buffer.from(b64, 'base64');
+      const s = buf.length ? sniff(buf) : null;
+      if (!s || s.kind !== 'image') return refuse(415, `picture ${i + 1} must be a PNG or a JPG`);
+      bufs.push({ buf, ext: s.ext });
+    }
+    if (bufs.reduce((n, b) => n + b.buf.length, 0) > MAX_SAMPLE_BYTES) return refuse(413, 'a sample is at most 20 MB');
+    fs.mkdirSync(p.samples, { recursive: true });
+    const files = bufs.map((b, i) => { const f = `${id}-${i + 1}.${b.ext}`; writeAtomic(path.join(p.samples, f), b.buf); return f; });
+    const first = bufs[0];
+    const thumb = first.buf.length <= MAX_THUMB_BYTES ? `data:image/${first.ext === 'jpg' ? 'jpeg' : 'png'};base64,${first.buf.toString('base64')}` : null;
+    const src = typeof input.source_url === 'string' ? input.source_url.trim() : '';
+    const u = parseUrl(src);
+    const source = u && /^https?:$/.test(u.protocol) && src.length <= 2000 ? src : 'upload';
+    rec = { id, name: oneLine(input.name || 'Page pictures', 120), kind: 'pictures', source, ext: first.ext, count: files.length, files, via: 'chrome', bytes: bufs.reduce((n, b) => n + b.buf.length, 0), readable: true, thumb, text_file: null };
   } else {
     const kind = str(input.kind);
     if (!['pdf', 'pptx', 'docx', 'image'].includes(kind)) return refuse(400, 'kind must be pdf, pptx, docx or image (or send a link, or a report doc)');
@@ -240,27 +272,78 @@ function addSample(root, cadence, input, { actor, now } = {}) {
       try { thumb = ooxmlThumb(buf); } catch { thumb = null; }
     }
     rec = { id, name: oneLine(input.name || `${kind} sample`, 120), kind, source: 'upload', ext, bytes: buf.length, readable, thumb, text_file: textFile };
+    if (kind === 'pdf' && input.from === 'chrome') {
+      // a PDF the Chrome extension fetched: where it came from and how many pages it has
+      const src = typeof input.source_url === 'string' ? input.source_url.trim() : '';
+      const u = parseUrl(src);
+      if (u && /^https?:$/.test(u.protocol) && src.length <= 2000) rec.source = src;
+      rec.via = 'chrome';
+      const n = Number(input.pages);
+      if (Number.isInteger(n) && n > 0 && n < 5000) rec.pages = n;
+    }
   }
   writeAtomic(path.join(p.samples, `${id}.json`), JSON.stringify({ ...rec, took: null, added_at: iso(now) }, null, 2) + '\n');
-  append(root, cadence, { ev: 'sample', id, name: rec.name, kind: rec.kind, source: rec.source, ext: rec.ext, readable: rec.readable }, { actor, now });
+  append(root, cadence, { ev: 'sample', id, name: rec.name, kind: rec.kind, source: rec.source, ext: rec.ext, readable: rec.readable,
+    ...(rec.via ? { via: rec.via } : {}), ...(rec.count ? { count: rec.count } : {}), ...(rec.pages ? { pages: rec.pages } : {}) }, { actor, now });
   return { ok: true, sample: sampleOut(rec) };
 }
-function sampleOut(s) {
+function sampleOut(s, { fetching } = {}) {
   const out = { id: s.id, name: s.name, kind: s.kind, source: s.source, took: s.took || null, thumb: typeof s.thumb === 'string' && s.thumb.startsWith('data:image/') ? s.thumb : null, readable: s.readable !== false };
-  if (s.kind === 'link') out.hint = linkHint(s.source);
+  if (s.via === 'chrome') {
+    out.via = 'chrome';
+    out.line = chromeLine(s);
+    if (s.count) out.count = s.count;
+    if (s.pages) out.pages = s.pages;
+  }
+  if (s.kind === 'link') {
+    if (fetching) { out.fetching = true; out.hint = 'PMOS is reading this link with your connectors.'; }
+    else out.hint = linkHint(s.source, { fetched: !!(s.text_file && s.fetched), reason: s.fetch_reason });
+  }
   return out;
 }
+/** The kind line of a sample the Chrome extension added: 'From Chrome, PDF, 12 slides' | 'From Chrome, PDF, 3 pages' | 'From Chrome, 3 page pictures'. */
+function chromeLine(s) {
+  if (s.kind === 'pictures') { const n = s.count || 0; return n ? `From Chrome, ${n} page ${n === 1 ? 'picture' : 'pictures'}` : 'From Chrome, page pictures'; }
+  const g = googleOf(parseUrl(s.source));
+  const n = s.pages || 0;
+  return n ? `From Chrome, PDF, ${n} ${g && g[2] === 'Slides' ? (n === 1 ? 'slide' : 'slides') : (n === 1 ? 'page' : 'pages')}` : 'From Chrome, PDF';
+}
 /* Google files: name them for what they are, and say which download PMOS can read */
 // a PDF, because the job sees its pages; from a .pptx or .docx it gets the words only, not the look
 const GOOGLE = [[/^\/presentation\//, 'Google Slides deck', 'Slides'], [/^\/document\//, 'Google Docs document', 'Docs'], [/^\/spreadsheets\//, 'Google Sheets sheet', 'Sheets']];
 const googleOf = (u) => (u && /(^|\.)docs\.google\.com$/i.test(u.hostname) ? GOOGLE.find((g) => g[0].test(u.pathname)) || null : null);
 const parseUrl = (v) => { try { return new URL(String(v || '')); } catch { return null; } };
 function linkName(u) { const g = googleOf(u); return g ? g[1] : u.hostname + u.pathname; }
-/** What the PM sees under a link sample: PMOS cannot open web pages, and how to add a copy it can read. */
-function linkHint(source) {
+/** What the PM sees under a link sample: what PMOS read through the connectors, or why it did not, and how to add a copy that shows the look. */
+function linkHint(source, { fetched = false, reason = null } = {}) {
   const g = googleOf(parseUrl(source));
-  if (g) return `PMOS cannot open ${g[2]} from a link, because it needs your Google sign-in. In ${g[2]}, choose File, Download, PDF document (.pdf), then add that file here. PMOS sees the pages of a PDF, so it can follow their look.`;
-  return 'PMOS cannot open web pages. Save the page as a PDF or take a screenshot, then add that file here.';
+  const pdfStep = g ? ` In ${g[2]}, choose File, Download, PDF document (.pdf), then add that file here.` : ' Save the page as a PDF or take a screenshot, then add that file here.';
+  if (fetched) return `PMOS read the words and structure of this link. To match its look, also add it as a PDF or a screenshot.${g ? pdfStep : ''}`;
+  if (g) return `${reason ? 'Your connectors could not read it. ' : ''}PMOS cannot open ${g[2]} from a link, because it needs your Google sign-in. In ${g[2]}, choose File, Download, PDF document (.pdf), then add that file here. PMOS sees the pages of a PDF, so it can follow their look.`;
+  return `${reason ? 'Your connectors could not read it. ' : ''}PMOS cannot open web pages. Save the page as a PDF or take a screenshot, then add that file here.`;
+}
+/** 'Google Slides deck' | 'Google Docs document' | 'Google Sheets sheet' for a Google link, else null. */
+function googleKind(source) { const g = googleOf(parseUrl(source)); return g ? g[1] : null; }
+/** True for a link the fetch run can try: a Google Slides, Docs or Sheets file, or a Confluence page. */
+function fetchableLink(source) {
+  const u = parseUrl(source);
+  if (!u || !/^https?:$/.test(u.protocol)) return false;
+  if (googleOf(u)) return true;
+  return /(^|\.)atlassian\.net$/i.test(u.hostname) && /^\/wiki\//.test(u.pathname);
+}
+/** A fetch run read the link: samples/<id>.txt holds its words (ok), or the link could not be read (reason). Appends a 'fetched' event. */
+function recordFetched(root, cadence, id, { ok = true, title, via, reason, now } = {}) {
+  if (!SAMPLE_ID_RE.test(String(id))) return false;
+  const p = paths(root, cadence);
+  const rec = sampleRecord(root, cadence, id);
+  if (!rec || rec.kind !== 'link') return false;
+  const good = ok === true;
+  const next = { ...rec, readable: good, text_file: good ? `${id}.txt` : null, fetch_reason: good ? null : oneLine(reason || 'no reason', 300),
+    ...(good ? { fetched_at: iso(now), via: oneLine(via || '', 120) || null } : {}) };
+  if (good && typeof title === 'string' && title.trim()) next.title = oneLine(title, 160);
+  writeAtomic(path.join(p.samples, `${id}.json`), JSON.stringify(next, null, 2) + '\n');
+  append(root, cadence, { ev: 'fetched', id, ok: good, ...(good ? { via: next.via, title: next.title || null } : { reason: next.fetch_reason }) }, { now });
+  return true;
 }
 /** Record what a job took from a sample (also kept in samples/<id>.json). */
 function recordTook(root, cadence, id, took, readable, { now } = {}) {
@@ -274,21 +357,28 @@ function recordTook(root, cadence, id, took, readable, { now } = {}) {
   append(root, cadence, { ev: 'took', id, took: t, ...(rd === undefined ? {} : { readable: rd }) }, { now });
   return true;
 }
-/** The file the job reads for a sample: the pdf or image itself, the extracted words of a .pptx/.docx, the copy of a report doc; null for a link. */
+/** The file the job reads for a sample: the pdf or image itself, the extracted words of a .pptx/.docx, the copy of a report doc, the text copy of a fetched link; null for any other link. */
 function sampleReadPath(root, cadence, s) {
   const p = paths(root, cadence);
-  if (s.kind === 'link') return null;
+  if (s.kind === 'pictures') {
+    // every picture of the page, in order (samples/<id>-1.jpg, <id>-2.jpg, …); null when none is there
+    let names = [];
+    try { names = fs.readdirSync(p.samples).filter((f) => f.startsWith(`${s.id}-`) && /^\d+\.(jpg|png)$/.test(f.slice(s.id.length + 1))); } catch { names = []; }
+    names.sort((a, b) => parseInt(a.slice(s.id.length + 1), 10) - parseInt(b.slice(s.id.length + 1), 10));
+    return names.length ? names.map((f) => path.join(p.samples, f)) : null;
+  }
+  if (s.kind === 'link') { const f = path.join(p.samples, `${s.id}.txt`); return s.fetched && fs.existsSync(f) ? f : null; }
   if (s.kind === 'pptx' || s.kind === 'docx') { const f = path.join(p.samples, `${s.id}.txt`); return fs.existsSync(f) ? f : null; }
   const f = path.join(p.samples, `${s.id}.${s.ext}`);
   return fs.existsSync(f) ? f : null;
 }
 
 // ── the GET answer ────────────────────────────────────────────────────────────────────────────────────────
-function designAnswer(root, cadence, { running } = {}) {
+function designAnswer(root, cadence, { running, fetching } = {}) {
   const st = stateOf(root, cadence);
   const samples = [...st.samples.values()].map((s) => {
     const rec = sampleRecord(root, cadence, s.id) || {};
-    return sampleOut({ ...s, thumb: rec.thumb || null, took: s.took || rec.took || null });
+    return sampleOut({ ...s, thumb: rec.thumb || null, took: s.took || rec.took || null, text_file: rec.text_file || null }, { fetching: !!(fetching && fetching.has(s.id)) });
   });
   const versions = [...st.versions.values()].sort((a, b) => a.n - b.n).map((v) => {
     const m = versionMeta(root, cadence, v.n) || {};
@@ -320,7 +410,7 @@ function writeBrief(root, cadence, setup, { now } = {}) {
     '## Description', '', st.description ? st.description : 'No description was given.', '', '## Samples', ''];
   const samples = [...st.samples.values()];
   if (!samples.length) lines.push('No samples.');
-  for (const s of samples) lines.push(`- ${s.name} (${s.kind}${s.kind === 'link' || s.kind === 'pmos-doc' ? ', ' + s.source : ''}): ${s.took ? 'PMOS took ' + s.took : (s.readable ? 'nothing taken yet' : 'could not be read')}`);
+  for (const s of samples) lines.push(`- ${s.name} (${s.kind}${s.kind === 'link' || s.kind === 'pmos-doc' ? ', ' + s.source : ''}${s.via === 'chrome' ? ', from Chrome' : ''}): ${s.took ? 'PMOS took ' + s.took : (s.readable ? 'nothing taken yet' : 'could not be read')}`);
   lines.push('', '## Reference outline', '');
   for (const o of (Array.isArray(meta.outline) ? meta.outline : [])) lines.push(`- ${o.id} (${o.kind || 'slide'}): ${o.title || ''}`);
   const sec = (h, list) => { lines.push('', `## ${h}`, ''); if (!list || !list.length) lines.push('None written yet.'); else for (const x of list) lines.push(`- ${x}`); };
@@ -749,7 +839,7 @@ function currentCycle(root, cadence) {
 module.exports = {
   EVENTS, FORMATS, SAMPLE_KINDS, MAX_SAMPLE_BYTES, CHOICES, PIN_OPS, CADENCE_RE, SLOT_RE, SLIDE_ID_RE, PMOS_ACTOR,
   paths, append, readEvents, fold, stateOf, designAnswer, versionMeta, versionHtml, writeVersion, rulesFor, cleanRules,
-  addSample, sampleOut, sampleRecord, recordTook, sampleReadPath, writeBrief,
+  addSample, sampleOut, sampleRecord, recordTook, recordFetched, fetchableLink, googleKind, sampleReadPath, writeBrief,
   tokenize, sanitize, cleanCss, outlineOf, formatOf, diffOutline,
   cyclePaths, readCycle, writeCycle, decideCycle, isIssuedSlot, docSha, currentCycle, previousCycle,
   notesOf, setSpeaker, pinOp, ooxmlText, ooxmlThumb, unzipSome,