create-pmos 0.524.0 → 0.526.0

package/workspace/lib/engine/boards.js

@@ -164,8 +164,9 @@ const TOOLS = Object.freeze({
 
 // on hold and cancelled come from a D70 lifecycle line (the PM stopped it); done is the end of the workflow. Only the first
 // three are ACTIVE: an initiative on hold, done or cancelled has no health and is not counted as open (c3-initiative-lifecycle).
-const STATUSES = Object.freeze(['on track', 'at risk', 'late', 'on hold', 'done', 'cancelled']);
-const ACTIVE = Object.freeze(['on track', 'at risk', 'late']);
+// 'no signal' (workspace grill W2): open, but nothing PMOS read says how it is going. It is active, and never counted as on track
+const STATUSES = Object.freeze(['on track', 'at risk', 'late', 'no signal', 'on hold', 'done', 'cancelled']);
+const ACTIVE = Object.freeze(['on track', 'at risk', 'late', 'no signal']);
 const isActive = (r) => !!r && ACTIVE.includes(r.status);
 const VIEWS = Object.freeze(['now', 'mine', 'risk', 'noowner', 'all']);
 /** What a Horizon scan filed with an ask (initiative horizon-scan), cut to its shape; null for any other ask. */

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' | 'report-structure-pull' | 'report-sample-fetch' | 'report-structure' | 'report-structure-dry' | 'ms-review' | 'propose' | 'metric-draft' | 'grill' | 'impact' | 'metric-read' | 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-structure-pull' | 'report-sample-fetch' | 'report-structure' | 'report-structure-dry' | 'ms-review' | 'propose' | 'metric-draft' | 'grill' | 'impact' | 'metric-read' | 'lab-proto' | 'lab-scan' | 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;
  *                                                    for the skill kind, the folders the run may write in, from skillWriteDirs)
  *   skillWriteDirs(skill, { root, scratch })       → the absolute folders a background skill run may write in: its scratch folder and the state folders its skill writes
@@ -102,7 +102,7 @@ const SCAN_REPO_ORIGINS = Object.freeze(['scan-repo:', 'scan-suggest:']);
 // read the argv of each.
 const SCAN_RESEARCH_WEB_ORIGINS = Object.freeze(['scan-research-web:']);
 const SCAN_RESEARCH_REPO_ORIGINS = Object.freeze(['scan-research-repo:']);
-const WEB_KINDS = Object.freeze(['scan-web', 'scan-research-web']);   // kinds that read untrusted pages: no directory, no Read, Glob or Grep
+const WEB_KINDS = Object.freeze(['scan-web', 'scan-research-web', 'lab-scan']);   // kinds that read untrusted pages: no directory, no Read, Glob or Grep
 // report-workspace: the Ask box run (origin `report-setup:<ask>`) and the weekly finder run (origin `report-find:<run>`).
 const REPORT_SETUP_ORIGINS = Object.freeze(['report-setup:']);
 const REPORT_FIND_ORIGINS = Object.freeze(['report-find:']);
@@ -134,7 +134,12 @@ const REPORT_STRUCTURE_DRY_ORIGINS = Object.freeze(['report-structure-dry:']);
 // report-structure-gaps: Test pull reads ONE source for the last complete period (origin `report-structure-pull:<id>:<source>`).
 const REPORT_STRUCTURE_PULL_ORIGINS = Object.freeze(['report-structure-pull:']);
 const WRITE_PATH_KINDS = Object.freeze(['report-design', 'report-sample-fetch', 'report-structure', 'report-structure-dry', 'report-structure-pull']);   // kinds whose one writable file the caller names (argsFor writePaths)
-const WRITE_DIR_KINDS = Object.freeze(['skill']);   // kinds whose writable folders the caller names (argsFor writePaths, each folder and what is under it)
+// The idle lab (lib/idle-lab-engine.js): a prototype run (origin `idle-lab-proto:<ws>:<ini>:<run>`) reads the repository and writes specimens only
+// in its own folder; a scan run (origin `idle-lab-scan:<ws>:<ini|->:<run>`) searches the web and reads pages only through `pmos lab page`, with no
+// repository. Neither sends anything; each files only with `pmos lab file`.
+const LAB_PROTO_ORIGINS = Object.freeze(['idle-lab-proto:']);
+const LAB_SCAN_ORIGINS = Object.freeze(['idle-lab-scan:']);
+const WRITE_DIR_KINDS = Object.freeze(['skill', 'lab-proto']);   // kinds whose writable folders the caller names (argsFor writePaths, each folder and what is under it)
 // A background skill run reads untrusted text (Jira, mail, calendar), so it may write only in its own scratch folder and in the state folders its skill writes
 // by hand. Every other write goes through a `pmos` verb, which checks what it writes. The folders are relative to <state>: `pmos/state/` if it exists, else
 // `planning/` (the rule each skill states). A skill not named here writes only in its scratch folder.
@@ -195,6 +200,13 @@ const TOOLS = Object.freeze({
   // The reading run (lib/metric-read-runs.js): read and search, and the one verb that files a reading. The PM's analytics and Jira are read through
   // the PM's own connectors only where the PM's settings allow it. No Write, no Edit, no web fetch, nothing that sends.
   'metric-read': Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos metrics reading *)', 'Bash(pmos source show *)', 'Bash(pmos source status *)', 'Bash(date *)']),
+  // The idle lab prototype run: read and search the repository and the earlier specimens, and the verb that files a round. Its one writable
+  // folder, the run's specimen folder, is added per run by argsFor (writePaths). No web, nothing that sends.
+  'lab-proto': Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos lab file *)', 'Bash(pmos lab status)', 'Bash(pmos initiative export *)', 'Bash(pmos initiative list *)',
+    'Bash(pmos task list *)', 'Bash(git log *)', 'Bash(date *)']),
+  // The idle lab scan run: WebSearch, and pages only through `pmos lab page` (PMOS fetches public pages and keeps the text the claims quote).
+  // No Read, Glob or Grep, no directory, no WebFetch, nothing that sends.
+  'lab-scan': Object.freeze(['WebSearch', 'Bash(pmos lab page *)', 'Bash(pmos lab file *)', 'Bash(pmos lab status)']),
   // 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.
@@ -310,6 +322,8 @@ function kindFor({ agent, origin, skill, env } = {}) {
   if (GRILL_ORIGINS.some((p) => o.startsWith(p))) return 'grill';
   if (IMPACT_ORIGINS.some((p) => o.startsWith(p))) return 'impact';
   if (METRIC_READ_ORIGINS.some((p) => o.startsWith(p))) return 'metric-read';
+  if (LAB_PROTO_ORIGINS.some((p) => o.startsWith(p))) return 'lab-proto';
+  if (LAB_SCAN_ORIGINS.some((p) => o.startsWith(p))) return 'lab-scan';
   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';
   // 'report-structure-dry:' is not a prefix of 'report-structure:' (the colon differs), so the two are told apart by their prefix alone
@@ -491,7 +505,8 @@ const RUN_ENV = Object.freeze(['PMOS_SCAN_FILE', 'PMOS_SCAN_ORIGIN', 'PMOS_SCAN_
   'PMOS_METRIC_READ_FILE', 'PMOS_METRIC_READ_RECORDS', 'PMOS_METRIC_READ_DRAFTS', 'PMOS_METRIC_READ_WS', 'PMOS_METRIC_READ_RUN', 'PMOS_METRIC_READ_RIDS', 'PMOS_METRIC_READ_TEST',
   'PMOS_PROPOSE_FILE', 'PMOS_PROPOSE_WS', 'PMOS_PROPOSE_BOARD', 'PMOS_PROPOSE_INI', 'PMOS_PROPOSE_RUN',
   'PMOS_GRILL_FILE', 'PMOS_GRILL_LOG', 'PMOS_GRILL_WS', 'PMOS_GRILL_BOARD', 'PMOS_GRILL_INI', 'PMOS_GRILL_RUN', 'PMOS_GRILL_BUDGET',
-  'PMOS_IMPACT_FILE', 'PMOS_IMPACT_RUN', 'PMOS_MS_REVIEW_FILE', 'PMOS_MS_REVIEW_RUN', 'PMOS_MS_REVIEW_PROGRAM']);
+  'PMOS_IMPACT_FILE', 'PMOS_IMPACT_RUN', 'PMOS_MS_REVIEW_FILE', 'PMOS_MS_REVIEW_RUN', 'PMOS_MS_REVIEW_PROGRAM',
+  'PMOS_LAB_RUN', 'PMOS_LAB_KIND', 'PMOS_LAB_PENDING', 'PMOS_LAB_INI', 'PMOS_LAB_BUDGET', 'PMOS_LAB_PAGES', 'PMOS_LAB_SPECIMENS']);
 function runEnvOf(extra) {
   const out = {};
   if (extra && typeof extra === 'object') for (const k of RUN_ENV) if (typeof extra[k] === 'string') out[k] = extra[k];

package/workspace/lib/idle-lab-engine.js

@@ -0,0 +1,531 @@
+'use strict';
+/* idle-lab-engine.js — the idle lab engine (build E of the idle-lab B+C direction, agreed 2026-11-04; canvas main, In development I5 "How it
+ * works"; brief /mnt/project-files/idle-lab/brief.md). While the PM is away, Claude prototypes and scans for the PM's initiatives, proves
+ * what it made, and files it as a ✦ the PM keeps or drops. lib/idle-lab.js is what it files and what the screens read; this file decides
+ * what to do, starts the run, proves the result and files it.
+ *
+ * WHEN. Job `idle-lab`, step 5 of the shared queue (lib/bg-queue.js): it gets a turn only when the PM has been away 30 minutes (or in the
+ * day's last hour), outside quiet hours, under the spend limit and with fewer than 3 background runs live. The queue also checks the off
+ * switch (`pmos ai off idle-lab`). Here: ONE run at a time, at most MAX_RESULTS results in one idle stretch, and when the PM comes back the
+ * running step finishes and nothing new starts.
+ *
+ * WHAT (candidates, in this order):
+ *   prototype-improve  a new round of a prototype after something new about it: the PM's ✕ with a reason, a grill finding or a scan finding
+ *                      filed after the last round. Never while a round waits for the PM (no second ✦ of the same kind).
+ *   prototype-new      an initiative in Triage or Discover whose specimen test (D60) says a description is not enough and that has no
+ *                      prototype yet: 2–3 divergent specimens (skills/core/prototype.skill).
+ *   scan-new           a kept watch item no scan read in 14 days, or an initiative in Triage or Discover that was never scanned for
+ *   scan-improve       a scan finding on an open initiative that is 14 days old: the same ✦ again with only what is new since
+ * An initiative another background run holds (the Driver, a grill, bg-queue holder) is skipped. A key tried in the last 7 days is skipped.
+ *
+ * HOW. Two run kinds, so no run has both untrusted pages and the repository (lib/headless.js):
+ *   lab-proto  origin `idle-lab-proto:<ws>:<ini>:<run>`. Reads the repository; writes specimen HTML only in its own folder
+ *              <runtime>/idle-lab/specimens/<run>/; files with `pmos lab file`. No web.
+ *   lab-scan   origin `idle-lab-scan:<ws>:<ini|->:<run>`. WebSearch and `pmos lab page <url>` (PMOS fetches the page and keeps its text in
+ *              <runtime>/idle-lab/pages/<run>/<n>.txt); files with `pmos lab file`. No repository, no Read.
+ * The run's filings wait in <runtime>/idle-lab/pending/<run>.jsonl. Nothing shows until the run ends and the proof below passes.
+ *
+ * PROOF BEFORE FILING (proven-only rule, Wawan 2026-11-01). Unproven → dropped, and the reason is logged (runs.jsonl end line, ai-audit).
+ *   a specimen   opens and renders in a headless browser (lib/find-browser.js + playwright-core, network blocked but the fonts): a body with
+ *                text or elements, no script error. No browser on the computer = not proven.
+ *   every claim  goes through lib/ai-guard.js file(): a prototype's basis quotes the repository at path:line; a scan claim quotes a page this
+ *                run read, at state:idle-lab/pages/<run>/<n>.txt:<line>. The guard's replay gate, kill switch, cap of 3 and audit hold.
+ * Specimens stay in the runtime folder: nothing is written to a product repository before the PM's ✓.
+ *
+ * LEDGERS
+ *   <runtime>/idle-lab/runs.jsonl   start { run, kind, ws, ini?, key, budget } · end { run, ok, cost, ms, filed, dropped: [why] }
+ *                                   (this month's spend counts toward the Settings › Claude's checks limit, with grill)
+ *   <state>/proposals.jsonl         a result on an initiative (lib/idle-lab.js result; groups prototyped, improved, scanned)
+ *   <state>/idle-lab.jsonl          a result that fits no initiative (loose scan), the `run` line of each idle stretch, the `next` line
+ *
+ *   JOB · VERSION · MAX_RESULTS · candidates(input) PURE · nextOf(cands) PURE · promptOf(skill, c, o) PURE
+ *   readRuns(rt) · appendRun(rt, line) · spentIn(rt, month) · pagesDir(rt, run) · pendingFile(rt, run) · runSpecimenDir(rt, run)
+ *   pageRef(run, n, line) · guardProposal(entry, { run }) PURE · renderCheck(abs) · ensureReplay(rt)
+ *   create(deps) → { tick(turn), finish(run, r), active(), status() }
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const LAB = require('./idle-lab.js');
+const PR = require('./proposals.js');
+
+const JOB = 'idle-lab';
+const VERSION = '1';
+const MAX_RESULTS = 3;            // per idle stretch
+const STALE_MS = 14 * 864e5;      // a watch item or a scan finding is old after 14 days
+const RETRY_MS = 7 * 864e5;       // a key that was tried waits a week before it is tried again
+const MAX_PAGES = 12;             // pages one scan run may read
+const KINDS = Object.freeze(['prototype-improve', 'prototype-new', 'scan-new', 'scan-improve']);
+const ORIGINS = Object.freeze({ proto: 'idle-lab-proto', scan: 'idle-lab-scan' });
+const EARLY = /triage|discover|intake|idea/i;
+const CLOSED = /^(done|stopped|archived|won't do|closed)$/i;
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const str = (v) => (typeof v === 'string' ? v : '');
+const one = (v, n) => String(v == null ? '' : v).replace(/\s+/g, ' ').trim().slice(0, n);
+const hash = (s) => crypto.createHash('sha1').update(String(s)).digest('hex').slice(0, 10);
+const ms = (iso) => Date.parse(iso || '') || 0;
+const monthOf = (now) => { const d = new Date(now); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0'); };
+const shortDay = (iso) => { const d = new Date(ms(iso)); return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()] + ' ' + d.getDate(); };
+
+/* ── folders and the runs ledger ── */
+const dirOf = (rt) => (rt ? path.join(rt, 'idle-lab') : null);
+const runsFile = (rt) => (rt ? path.join(dirOf(rt), 'runs.jsonl') : null);
+const pagesDir = (rt, run) => path.join(dirOf(rt), 'pages', run);
+const pendingFile = (rt, run) => path.join(dirOf(rt), 'pending', run + '.jsonl');
+const runSpecimenDir = (rt, run) => path.join(LAB.specimenDir(rt), run);
+/** The guard ref of line `line` of page `n` this run read (resolved against the runtime folder). */
+const pageRef = (run, n, line) => `state:idle-lab/pages/${run}/${n}.txt:${line}`;
+
+function appendRun(rt, line) {
+  const f = runsFile(rt); if (!f) return null;
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const l = { at: new Date().toISOString(), ...line };
+  fs.appendFileSync(f, JSON.stringify(l) + '\n');
+  return l;
+}
+/** → { runs: Map run → { run, kind, ws, ini, key, budget, at, ended, ok, cost, filed, dropped }, tried: Map key → ms of its last start } */
+function readRuns(rt) {
+  const runs = new Map(), tried = new Map();
+  let text = '';
+  try { text = fs.readFileSync(runsFile(rt), 'utf8'); } catch { return { runs, tried }; }
+  for (const raw of text.split('\n')) {
+    if (!raw.trim()) continue;
+    let l; try { l = JSON.parse(raw); } catch { continue; }
+    if (!isObj(l)) continue;
+    if (l.kind === 'start' && str(l.run)) {
+      runs.set(l.run, { run: l.run, kind: str(l.job), ws: str(l.ws), ini: str(l.ini), key: str(l.key), budget: Number(l.budget) || 0, at: str(l.at), ended: false, ok: null, cost: null, filed: 0, dropped: [] });
+      if (str(l.key)) tried.set(l.key, Math.max(tried.get(l.key) || 0, ms(l.at)));
+    } else if (l.kind === 'end' && runs.has(l.run)) {
+      const r = runs.get(l.run);
+      Object.assign(r, { ended: true, ok: !!l.ok, cost: Number.isFinite(l.cost) ? l.cost : null, filed: Number(l.filed) || 0, dropped: Array.isArray(l.dropped) ? l.dropped : [], endAt: str(l.at) });
+    }
+  }
+  return { runs, tried };
+}
+/** What the idle lab spent in a month (YYYY-MM): an ended run its cost (its budget when unknown), an open run its budget. */
+function spentIn(rt, month) {
+  let s = 0;
+  for (const r of readRuns(rt).runs.values()) if (r.at.slice(0, 7) === month || monthOf(ms(r.at)) === month) s += r.ended ? (r.cost != null ? r.cost : r.budget) : r.budget;
+  return Math.round(s * 100) / 100;
+}
+
+/* ── what to do ── */
+function stateOf(P, kept, p) { return kept.has(p.id) ? 'kept' : P.drops.has(PR.sigOf(p)) ? 'dropped' : 'open'; }
+/**
+ * PURE. Everything the lab could do now, best first.
+ *   products  [{ ws, inis: [{ ini, board, title, stage, needsPrototype, closed }], P (lib/proposals.js fold), scan (lib/scan.js fold) | null,
+ *               board (the product's first board, for a finding that fits no initiative) }]
+ *   held(ws, ini) → true when another background run holds it · tried: Map key → ms
+ * → [{ kind, ws, board, ini, title, why, key, data }]
+ */
+function candidates({ products = [], now = Date.now(), held = () => false, tried = new Map() } = {}) {
+  const out = [];
+  const fresh = (key) => !(tried.has(key) && now - tried.get(key) < RETRY_MS);
+  for (const pr of products) {
+    if (!pr || !pr.ws) continue;
+    const P = pr.P || PR.fold([]);
+    const kept = PR.keptIds(P);
+    const props = [...P.props.values()];
+    const open = (pr.inis || []).filter((i) => i && i.ini && !i.closed && !CLOSED.test(str(i.stage)));
+    for (const i of open) {
+      if (held(pr.ws, i.ini)) continue;
+      const mine = props.filter((p) => p.ini === i.ini);
+      const roots = mine.filter((p) => p.group === 'prototyped').sort((a, b) => ms(a.at) - ms(b.at));
+      const root = roots[roots.length - 1] || null;
+      if (root) {
+        // prototype-improve: something new since the last round, and no round waits for the PM
+        const rounds = mine.filter((p) => p.group === 'improved' && p.data && p.data.of === root.id).sort((a, b) => a.data.round - b.data.round);
+        const last = rounds[rounds.length - 1] || root;
+        const lastState = stateOf(P, kept, last);
+        if (lastState !== 'open') {
+          const signals = [];
+          const why = lastState === 'dropped' && P.dropWhy ? P.dropWhy.get(PR.sigOf(last)) : '';
+          if (why) signals.push({ from: 'drop', text: `Your ✕ on round ${last.group === 'improved' ? last.data.round : 1}: "${one(why, 200)}"` });
+          for (const p of mine) {
+            if (ms(p.at) <= ms(last.at)) continue;
+            if (p.group === 'grill' && stateOf(P, kept, p) !== 'dropped') signals.push({ from: 'grill', text: 'Grill finding: ' + one(p.title || p.why, 160) });
+            if (p.group === 'scanned' && stateOf(P, kept, p) !== 'dropped') signals.push({ from: 'scan', text: 'Scan finding: ' + one(p.title || p.why, 160) });
+          }
+          if (signals.length) {
+            const key = `proto-improve:${pr.ws}:${root.id}:${hash(signals.map((s) => s.text).join('|'))}`;
+            if (fresh(key)) out.push({ kind: 'prototype-improve', ws: pr.ws, board: i.board || root.board || '', ini: i.ini, title: i.title || i.ini, key,
+              why: 'Something new since round ' + (last.group === 'improved' ? last.data.round : 1) + ': ' + signals[0].text,
+              data: { of: root.id, round: (rounds.length ? rounds[rounds.length - 1].data.round : 1) + 1, keys: (root.data.specimens || []).map((s) => ({ key: s.key, title: s.title, file: s.file })),
+                last: last.group === 'improved' ? { round: last.data.round, base: last.data.base, file: last.data.file, changed: last.data.changed } : null, signals: signals.slice(0, 5) } });
+          }
+        }
+      } else if (i.needsPrototype && (!i.stage || EARLY.test(i.stage))) {
+        const key = `proto-new:${pr.ws}:${i.ini}`;
+        if (fresh(key)) out.push({ kind: 'prototype-new', ws: pr.ws, board: i.board || '', ini: i.ini, title: i.title || i.ini, key,
+          why: 'Its specimen test says a description is not enough, and it has no prototype yet.', data: {} });
+      }
+      const scans = mine.filter((p) => p.group === 'scanned' && stateOf(P, kept, p) !== 'dropped').sort((a, b) => ms(a.at) - ms(b.at));
+      const lastScan = scans[scans.length - 1] || null;
+      if (lastScan && now - ms(lastScan.at) >= STALE_MS) {
+        const key = `scan-refresh:${pr.ws}:${i.ini}:${lastScan.at}`;
+        if (fresh(key)) out.push({ kind: 'scan-improve', ws: pr.ws, board: i.board || '', ini: i.ini, title: i.title || i.ini, key,
+          why: 'Its scan finding is from ' + shortDay(lastScan.at) + '. Look again, and keep only what is new.',
+          data: { old: { title: one(lastScan.title, 140), why: one(lastScan.why, 300), at: lastScan.at, sources: (lastScan.sources || []).slice(0, 8) } } });
+      } else if (!lastScan && !mine.some((p) => p.group === 'scanned') && (!i.stage || EARLY.test(i.stage))) {
+        const key = `scan-ini:${pr.ws}:${i.ini}`;
+        if (fresh(key)) out.push({ kind: 'scan-new', ws: pr.ws, board: i.board || '', ini: i.ini, title: i.title || i.ini, key,
+          why: 'It is early and nobody looked outside for it yet: how do others solve this?', data: { question: i.title || i.ini } });
+      }
+    }
+    // the kept watch list: an item no scan read in 14 days
+    const S = pr.scan;
+    if (S && S.itemOrder) {
+      const lastRead = new Map();
+      for (const id of S.scanOrder || []) {
+        const sc = S.scans.get(id);
+        if (!sc || !sc.start) continue;
+        for (const w of sc.watch || []) if (w && w.id) lastRead.set(w.id, Math.max(lastRead.get(w.id) || 0, ms(sc.start)));
+      }
+      for (const id of S.itemOrder) {
+        const it = S.itemById.get(id);
+        if (!it || it.state !== 'kept') continue;
+        const read = lastRead.get(id) || 0;
+        if (now - read < STALE_MS || now - ms(it.at) < STALE_MS && !read && it.at) continue;
+        const ini = it.ini && open.some((x) => x.ini === it.ini) && !held(pr.ws, it.ini) ? it.ini : null;
+        const key = `scan-item:${pr.ws}:${id}:${Math.floor(now / RETRY_MS)}`;
+        if (!fresh(key)) continue;
+        out.push({ kind: 'scan-new', ws: pr.ws, board: (ini && (open.find((x) => x.ini === ini) || {}).board) || pr.board || '', ini, title: it.name, key,
+          why: (read ? 'No scan read it since ' + shortDay(new Date(read).toISOString()) : 'No scan read it yet') + ': a ' + it.kind + ' on your watch list.',
+          data: { item: { id, name: it.name, kind: it.kind, why: one(it.why, 200) } } });
+      }
+    }
+  }
+  const rank = (k) => KINDS.indexOf(k);
+  return out.map((c, n) => ({ c, n })).sort((a, b) => rank(a.c.kind) - rank(b.c.kind) || a.n - b.n).map((x) => x.c);
+}
+
+/** PURE. What the Lab shows under "Next time you step away" for one product: the first 3 candidates, read only. */
+function nextOf(cands) {
+  const verb = { 'prototype-new': 'Prototype', 'prototype-improve': 'Improve the prototype of', 'scan-new': 'Scan for', 'scan-improve': 'Refresh the scan of' };
+  return (cands || []).slice(0, 3).map((c) => ({ kind: c.kind.startsWith('prototype') ? 'prototype' : 'scan', title: verb[c.kind] + ' ' + one(c.title, 100), why: one(c.why, 300) }));
+}
+
+/** PURE. The prompt of one run: the skill, then this run's facts. */
+function promptOf(skill, c, o = {}) {
+  const L = [skill, '', 'This run:', `- Run: ${o.run}`, `- Kind: ${c.kind}`, `- Today: ${o.today || ''}`, `- Your budget: $${o.budget}. Stop when you have your result.`];
+  if (c.ini) L.push(`- Initiative: ${c.ini} · ${one(c.title, 140)}`);
+  L.push(`- Why now: ${one(c.why, 300)}`);
+  if (c.kind === 'prototype-new') L.push(`- Write each specimen as one .html file in ${o.specimens} (and nowhere else). File it with \`pmos lab file prototyped --json -\`.`);
+  if (c.kind === 'prototype-improve') {
+    const d = c.data;
+    L.push(`- This is round ${d.round}. The first round's specimens: ${d.keys.map((k) => k.key + ' · ' + k.title).join('; ')}.`);
+    if (d.last) L.push(`- The last round: round ${d.last.round} of ${d.last.base}, which changed: ${d.last.changed}.`);
+    L.push('- What is new since the last round (work from this):', ...d.signals.map((s) => '  - ' + s.text));
+    L.push(`- The earlier specimens are in ${o.specimenRoot} (Read them). Write the new round as ONE .html file in ${o.specimens}. File it with \`pmos lab file improved --json -\`.`);
+  }
+  if (c.kind === 'scan-new' && c.data.item) L.push(`- The watch item: ${c.data.item.name} (a ${c.data.item.kind})${c.data.item.why ? ': ' + c.data.item.why : ''}`);
+  if (c.kind === 'scan-new' && c.data.question) L.push(`- The question: how do other products and teams handle "${one(c.data.question, 140)}"?`);
+  if (c.kind === 'scan-improve') {
+    const d = c.data.old;
+    L.push(`- The finding from ${shortDay(d.at)}: ${d.title ? d.title + ': ' : ''}${d.why}`, '- Its pages then:', ...d.sources.map((s) => '  - ' + one(s.label, 80) + (s.ref ? ' ' + one(s.ref, 200) : '')));
+    L.push('- File only what is NEW since then, with "refreshed" saying how much is new. Nothing new: file nothing.');
+  }
+  if (c.kind.startsWith('scan')) L.push(`- Read pages ONLY with \`pmos lab page <url>\` (at most ${MAX_PAGES}). File with \`pmos lab file ${c.ini ? 'scanned' : 'scan'} --json -\`.`);
+  L.push('', 'File with `pmos lab file` only. Send nothing.');
+  return L.join('\n');
+}
+
+/* ── the proof ── */
+/** PURE. A pending entry → the shape lib/ai-guard.js checks. A prototype's claim rests on its basis (repository quotes); a scan's claims
+ * cite the pages the run read (`page` n and `line`, turned into the run's page refs). */
+function guardProposal(e, { run }) {
+  const id = 'il-' + hash([run, e.group, e.title || '', e.why || ''].join('|'));
+  let claims = [];
+  if (e.group === 'prototyped' || e.group === 'improved') {
+    claims = [{ text: one(e.why, 600), sources: (Array.isArray(e.basis) ? e.basis : []).slice(0, 8).map((b) => ({ label: one(b && b.label, 120), ref: one(b && b.ref, 300), quote: str(b && b.quote).slice(0, 2000) })) }];
+  } else {
+    claims = (Array.isArray(e.claims) ? e.claims : []).slice(0, 8).map((c) => ({ text: one(c && c.text, 600), sources: (Array.isArray(c && c.sources) ? c.sources : []).slice(0, 8)
+      .map((s) => ({ label: 'page ' + (s && s.page), ref: Number.isInteger(Number(s && s.page)) && Number.isInteger(Number(s && s.line)) ? pageRef(run, Number(s.page), Number(s.line)) : one(s && s.ref, 300), quote: str(s && s.quote).slice(0, 2000) })) }));
+  }
+  return { id, title: one(e.title || e.why, 200), say: one(e.why, 1200), confidence: 'medium', claims, data: { group: e.group } };
+}
+
+/** Open one specimen in a headless browser, with the network shut but the fonts. → { ok, w, h, why? } */
+async function renderCheck(abs, { browser = null } = {}) {
+  let exe = browser;
+  try { if (!exe) exe = require('./find-browser.js').findBrowser(); } catch { exe = null; }
+  if (!exe) return { ok: false, why: 'there is no headless browser on this computer to prove it renders' };
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { return { ok: false, why: 'playwright-core is not installed, so it could not be opened' }; }
+  let b = null;
+  try {
+    b = await chromium.launch({ executablePath: exe, headless: true, args: ['--no-sandbox'] });
+    const page = await b.newPage({ viewport: { width: 1280, height: 800 } });
+    const errors = [];
+    page.on('pageerror', (e) => errors.push(one(e && e.message, 160)));
+    await page.route('**/*', (r) => { const u = r.request().url(); return /^(file:|data:|blob:|about:)/.test(u) || /^https:\/\/fonts\.(googleapis|gstatic)\.com\//.test(u) ? r.continue() : r.abort(); });
+    await page.goto('file://' + abs, { waitUntil: 'load', timeout: 15000 });
+    const m = await page.evaluate(() => { const d = document.body; if (!d) return null; return { w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight, els: d.querySelectorAll('*').length, text: (d.innerText || '').trim().length }; });
+    if (!m) return { ok: false, why: 'it has no body' };
+    if (errors.length) return { ok: false, why: 'a script error: ' + errors[0] };
+    if (m.h < 100 || m.w < 200 || (m.text < 20 && m.els < 10)) return { ok: false, why: `it renders almost nothing (${m.w}×${m.h}, ${m.els} elements)` };
+    return { ok: true, w: m.w, h: m.h };
+  } catch (e) {
+    return { ok: false, why: 'it did not open: ' + one(e && e.message, 160) };
+  } finally { if (b) try { await b.close(); } catch { /* closed */ } }
+}
+
+/** The guard's replay for (idle-lab, VERSION), once per version: a cited scan claim files; a made-up quote and a claim without a page do not. */
+async function ensureReplay(rt, AG = require('./ai-guard.js')) {
+  if (AG.ready(rt, JOB, VERSION)) return { ok: true };
+  const run = 'replay';
+  const dir = pagesDir(rt, run);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, '1.txt'), ['URL: https://example.com/replay', 'TITLE: Replay page', '', 'Teams invite people from the share menu in two steps.', 'Costs stay hidden from guests by default.'].join('\n') + '\n');
+  const entry = (quote, page = 1) => ({ group: 'scanned', title: 'Invite from the share menu', why: 'Two of the products read invite from the share menu.', claims: [{ text: 'Invites start from the share menu.', sources: [{ page, line: 4, quote }] }] });
+  const cases = [
+    { name: 'a claim that quotes the page it read is filed', run: async () => [guardProposal(entry('invite people from the share menu'), { run })], expect: { filed: 1 } },
+    { name: 'a quote that is not on the page is dropped', run: async () => [guardProposal(entry('every product hides the invite in settings'), { run })], expect: { none: true } },
+    { name: 'a page the run never read is dropped', run: async () => [guardProposal(entry('invite people from the share menu', 7), { run })], expect: { none: true } },
+  ];
+  return AG.replay(JOB, VERSION, cases, { root: rt, stateDir: rt });
+}
+
+/* ── the engine ── */
+/**
+ * deps: { runtimeDir() → folder, queue? (lib/bg-queue.js: the engine registers itself as job `idle-lab`), products() → [{ ws, w: { id, root }, dir, board, inis, P, scan }] (the server reads them),
+ *         held(ini) → bool (lib/bg-queue.js holder), budget(now) → { ok, budget, why? }, promptFor(skillId) → text | null,
+ *         spawn(spec) → session (lib/orchestrator-spawn.js: { name, ws, origin, initialInput, initiative, env, writePaths, onDone }),
+ *         stop(session), render?(abs) → Promise<{ ok, w, h, why? }>, guard? (lib/ai-guard.js), env, warn(what, e) }
+ */
+function create(deps) {
+  const warn = deps.warn || (() => {});
+  const AG = deps.guard || require('./ai-guard.js');
+  const render = deps.render || ((abs) => renderCheck(abs));
+  const rt = () => (deps.runtimeDir ? deps.runtimeDir() : null);
+  let active = null;                       // { run, c, start, session, dir }
+  let stretch = null;                      // { since, filed, perWs: Map ws → { ms, n } } while the PM is away
+  let cache = { at: 0, products: null };
+  let replaying = false;
+  const nextSig = new Map();               // ws → signature of the last `next` line written
+
+  function products(now) {
+    if (cache.products && now - cache.at < 10 * 6e4) return cache.products;
+    let p = [];
+    try { p = deps.products() || []; } catch (e) { warn('idle lab products', e); p = []; }
+    cache = { at: now, products: p };
+    return p;
+  }
+
+  function writeNext(prods, cands) {
+    for (const pr of prods) {
+      if (!pr.dir) continue;
+      const items = nextOf(cands.filter((c) => c.ws === pr.ws));
+      const sig = JSON.stringify(items);
+      if (nextSig.get(pr.ws) === sig) continue;
+      try {
+        const L = LAB.read(pr.dir);
+        if (JSON.stringify(L.next ? L.next.items : []) !== sig) LAB.append(pr.dir, { by: null }, { kind: 'next', items });
+        nextSig.set(pr.ws, sig);
+      } catch (e) { warn('idle lab next', e); }
+    }
+  }
+
+  function closeStretch(prods) {
+    if (!stretch) return;
+    for (const [ws, v] of stretch.perWs) {
+      const pr = prods.find((x) => x.ws === ws);
+      if (pr && pr.dir && (v.ms > 0 || v.n > 0)) try { LAB.append(pr.dir, { by: null }, { kind: 'run', job: JOB, ms: Math.round(v.ms), n: v.n }); } catch (e) { warn('idle lab run line', e); }
+    }
+    stretch = null;
+  }
+
+  /** The queue's turn (step 5). turn: { now, idle } */
+  function tick(turn = {}) {
+    const now = turn.now || Date.now();
+    const r = rt(); if (!r) return { started: null };
+    if (!turn.idle) {
+      // the PM is back: the running step finishes by itself, nothing new starts, and the stretch is written down
+      if (!active && stretch) closeStretch(products(now));
+      return { started: null, back: true };
+    }
+    if (active) return { running: active.run };
+    if (!stretch) stretch = { since: now, filed: 0, perWs: new Map() };
+    const prods = products(now);
+    const F = readRuns(r);
+    const cands = candidates({ products: prods, now, held: (ws, ini) => { try { return !!deps.held(ini); } catch { return false; } }, tried: F.tried });
+    writeNext(prods, cands);
+    if (stretch.filed >= MAX_RESULTS) return { started: null, full: true };
+    const off = AG.off(JOB, { env: deps.env || process.env, settingsDir: r });
+    if (off) return { started: null, off };
+    if (!cands.length) return { started: null };
+    // the guard shows nothing of a job whose replay has not passed: run it once per version, then start on the next turn
+    if (!AG.ready(r, JOB, VERSION)) {
+      if (!replaying) { replaying = true; ensureReplay(r, AG).catch((e) => warn('idle lab replay', e)).finally(() => { replaying = false; }); }
+      return { started: null, replay: true };
+    }
+    for (const c of cands) {
+      const b = deps.budget ? deps.budget(now) : { ok: true, budget: 1 };
+      if (!b || !b.ok) return { started: null, paused: (b && b.why) || 'the spend limit is reached' };
+      const s = start(c, { now, budget: b.budget, prods });
+      if (s.ok) return { started: s.run, kind: c.kind };
+      if (s.held) return { started: null, held: true };
+    }
+    return { started: null };
+  }
+
+  function start(c, { now, budget, prods }) {
+    const r = rt();
+    const pr = prods.find((x) => x.ws === c.ws);
+    if (!pr || !pr.w) return { ok: false };
+    const proto = c.kind.startsWith('prototype');
+    const skill = deps.promptFor(proto ? 'idle-lab-prototype' : 'idle-lab-scan');
+    if (!skill) return { ok: false, error: 'the idle lab skill is not installed' };
+    const run = 'il' + now.toString(36) + crypto.randomBytes(3).toString('hex');
+    const spec = runSpecimenDir(r, run);
+    try {
+      fs.mkdirSync(path.dirname(pendingFile(r, run)), { recursive: true });
+      if (proto) fs.mkdirSync(spec, { recursive: true }); else fs.mkdirSync(pagesDir(r, run), { recursive: true });
+    } catch (e) { warn('idle lab folders', e); return { ok: false }; }
+    const day = new Date(now); const today = day.getFullYear() + '-' + String(day.getMonth() + 1).padStart(2, '0') + '-' + String(day.getDate()).padStart(2, '0');
+    const prompt = promptOf(skill, c, { run, today, budget, specimens: spec, specimenRoot: LAB.specimenDir(r) });
+    const env = { PMOS_LAB_RUN: run, PMOS_LAB_KIND: c.kind, PMOS_LAB_PENDING: pendingFile(r, run), PMOS_LAB_INI: c.ini || '', PMOS_LAB_BUDGET: String(budget),
+      ...(proto ? { PMOS_LAB_SPECIMENS: spec } : { PMOS_LAB_PAGES: pagesDir(r, run) }) };
+    active = { run, c, start: now, session: null, dir: pr.dir, root: pr.w.root };
+    let session = null;
+    try {
+      session = deps.spawn({ name: (proto ? 'Prototyping · ' : 'Scanning · ') + one(c.title, 60), ws: c.ws, origin: `${proto ? ORIGINS.proto : ORIGINS.scan}:${c.ws}:${c.ini || '-'}:${run}`,
+        initialInput: prompt + '\r', initiative: c.ini || undefined, env, writePaths: proto ? [spec] : [], addDirs: proto ? [LAB.specimenDir(r)] : [], onDone: (res) => { finish(run, res).catch((e) => warn('idle lab finish', e)); } });
+    } catch (e) { warn('idle lab run', e); }
+    if (session && session.held) { active = null; return { ok: false, held: true }; }
+    appendRun(r, { kind: 'start', run, job: c.kind, ws: c.ws, ini: c.ini || '', key: c.key, budget });
+    const kind = proto ? 'lab-proto' : 'lab-scan';
+    if (!session || session.state === 'exited' || session.headless !== kind) {
+      if (session && session.state !== 'exited' && deps.stop) try { deps.stop(session); } catch { /* best effort */ }
+      appendRun(r, { kind: 'end', run, ok: false, cost: 0, ms: 0, filed: 0, dropped: [(session && session.note) || 'the run could not start in the background'] });
+      active = null;
+      return { ok: false };
+    }
+    active.session = session;
+    return { ok: true, run };
+  }
+
+  function pending(run) {
+    let text = '';
+    try { text = fs.readFileSync(pendingFile(rt(), run), 'utf8'); } catch { return []; }
+    const out = [];
+    for (const raw of text.split('\n')) { if (!raw.trim()) continue; try { const l = JSON.parse(raw); if (isObj(l)) out.push(l); } catch { /* torn */ } }
+    return out.slice(0, MAX_RESULTS);
+  }
+
+  /** The run ended: prove what it filed, file what holds, log the rest. */
+  async function finish(run, res = {}, now = Date.now()) {
+    const a = active && active.run === run ? active : null;
+    const r = rt();
+    if (!a || !r) return { filed: 0 };
+    const out = (res && res.result) || {};
+    const ok = !!(res && !res.timedOut && !res.stopped && res.code === 0 && out.ok !== false && !out.isError);
+    const cost = Number.isFinite(out.costUsd) ? Math.round(out.costUsd * 10000) / 10000 : null;
+    const dropped = [];
+    let filed = 0;
+    try {
+      const entries = pending(run);
+      const proven = [];
+      for (const e of entries) {
+        const p = await prove(e, a);
+        if (p.ok) proven.push({ e, checked: p.checked }); else dropped.push(one(p.why, 200));
+      }
+      if (proven.length) {
+        const g = await AG.file({ job: JOB, version: VERSION, run, root: a.root, stateDir: r, settingsDir: r, env: deps.env || process.env, max: MAX_RESULTS },
+          proven.map((x) => guardProposal(x.e, { run })),
+          async (acc) => { const ids = new Set(acc.map((x) => x.id)); for (const x of proven) if (ids.has(guardProposal(x.e, { run }).id)) { fileOne(x.e, x.checked, a, now); filed++; } });
+        for (const d of g.dropped || []) dropped.push(one(d.why, 200));
+        if (g.held) dropped.push('the guard holds the idle lab until its replay passes');
+        if (g.off) dropped.push(g.off);
+      }
+    } catch (e) { dropped.push('filing failed: ' + one(e && e.message, 160)); warn('idle lab filing', e); }
+    appendRun(r, { kind: 'end', run, ok, cost, ms: Math.max(0, now - a.start), filed, dropped: dropped.slice(0, 6) });
+    if (stretch) {
+      stretch.filed += filed;
+      const v = stretch.perWs.get(a.c.ws) || { ms: 0, n: 0 };
+      v.ms += Math.max(0, now - a.start); v.n += filed; stretch.perWs.set(a.c.ws, v);
+    }
+    cache.at = 0;   // the next turn reads the ledgers again
+    active = null;
+    return { filed, dropped };
+  }
+
+  /** → { ok, checked? } | { ok: false, why } */
+  async function prove(e, a) {
+    const r = rt(), c = a.c;
+    if (!isObj(e)) return { ok: false, why: 'not a result' };
+    if (e.group === 'prototyped' || e.group === 'improved') {
+      if (!c.kind.startsWith('prototype')) return { ok: false, why: 'a scan run cannot file a prototype' };
+      const files = e.group === 'prototyped' ? (Array.isArray(e.specimens) ? e.specimens.map((s) => s && s.file) : []) : [e.file];
+      if (!files.length || files.some((f) => !str(f).startsWith(a.run + '/'))) return { ok: false, why: 'a specimen is not in this run\'s folder' };
+      const sizes = [];
+      for (const f of files) {
+        const abs = LAB.specimenPath(r, f);
+        let st = null; try { st = abs ? fs.statSync(abs) : null; } catch { st = null; }
+        if (!st || !st.isFile()) return { ok: false, why: `specimen ${f} was not written` };
+        if (st.size > 2e6) return { ok: false, why: `specimen ${f} is over 2 MB` };
+        const v = await render(abs);
+        if (!v || !v.ok) return { ok: false, why: `specimen ${f} is not proven: ${(v && v.why) || 'it did not render'}` };
+        sizes.push(`${v.w}×${v.h}`);
+      }
+      return { ok: true, checked: (files.length === 1 ? 'It opened and rendered' : `All ${files.length} opened and rendered`) + ' in a headless browser (' + sizes.join(', ') + ')' };
+    }
+    if (e.group === 'scanned' || e.group === 'scan') {
+      if (!c.kind.startsWith('scan')) return { ok: false, why: 'a prototype run cannot file a scan' };
+      return { ok: true };   // every claim's page and quote are checked by the guard
+    }
+    return { ok: false, why: 'unknown group ' + one(e.group, 20) };
+  }
+
+  /** The pages a scan run read, as the ✦'s sources: [{ label, ref: url }] */
+  function pagesOf(run, nums) {
+    const out = [];
+    for (const n of nums) {
+      let head = '';
+      try { head = fs.readFileSync(path.join(pagesDir(rt(), run), n + '.txt'), 'utf8').split('\n').slice(0, 2).join('\n'); } catch { continue; }
+      const url = (/^URL: (.+)$/m.exec(head) || [])[1] || '', title = (/^TITLE: (.*)$/m.exec(head) || [])[1] || '';
+      if (url) out.push({ label: one(title || url.replace(/^https?:\/\//, '').split('/')[0], 80), ref: url });
+    }
+    return out;
+  }
+
+  function fileOne(e, checked, a, now) {
+    const c = a.c, at = new Date(now).toISOString();
+    const pageNums = () => [...new Set((e.claims || []).flatMap((x) => (x && Array.isArray(x.sources) ? x.sources : []).map((s) => Number(s && s.page)).filter(Number.isInteger)))];
+    if (e.group === 'prototyped' || e.group === 'improved') {
+      const input = { title: e.title, why: e.why, checked, sources: (e.basis || []).map((b) => ({ label: one(b.label, 80) || 'basis', ref: one(b.ref, 500) })) };
+      if (e.group === 'prototyped') input.specimens = e.specimens;
+      else Object.assign(input, { of: c.data.of, round: c.data.round, base: e.base, changed: e.changed, file: e.file });
+      const R = LAB.result(e.group, input);
+      if (R.error) throw new Error(R.error);
+      const id = e.group === 'prototyped' ? PR.idOf(c.ini, 'prototyped', 'new', '') : PR.idOf(c.ini, 'improved', 'round', c.data.of + ':' + c.data.round);
+      fs.appendFileSync(PR.ledgerFile(a.dir), JSON.stringify({ at, by: null, kind: 'propose', ini: c.ini, board: c.board, run: a.run, id, ...R.prop }) + '\n');
+      return;
+    }
+    const nums = pageNums(), sources = pagesOf(a.run, nums);
+    const refreshed = c.kind === 'scan-improve' ? (one(e.refreshed, 200) || 'from the ' + shortDay(c.data.old.at) + ' scan') : '';
+    if (e.group === 'scanned' && c.ini) {
+      const R = LAB.result('scanned', { title: e.title, why: e.why, sources, pages: nums.length, ...(refreshed ? { refreshed } : {}) });
+      if (R.error) throw new Error(R.error);
+      // one scan ✦ per initiative: a refresh replaces it (the newest line for an id wins)
+      fs.appendFileSync(PR.ledgerFile(a.dir), JSON.stringify({ at, by: null, kind: 'propose', ini: c.ini, board: c.board, run: a.run, id: PR.idOf(c.ini, 'scanned', 'finding', ''), ...R.prop }) + '\n');
+      return;
+    }
+    const R = LAB.loose('scan', { title: e.title || e.why, why: e.why, sources, data: refreshed ? { refreshed } : {} });
+    if (R.error) throw new Error(R.error);
+    LAB.append(a.dir, { by: null }, { kind: 'propose', ...R.prop });
+  }
+
+  // the shared queue (lib/bg-queue.js) gives the turn: step 5, after the idle clock, quiet hours, the spend limit and the runs-at-once limit
+  if (deps.queue && typeof deps.queue.register === 'function') deps.queue.register(JOB, (turn) => { try { tick(turn); } catch (e) { warn('idle lab tick', e); } });
+
+  return {
+    tick, finish,
+    active: () => (active ? { run: active.run, kind: active.c.kind, ini: active.c.ini, ws: active.c.ws } : null),
+    status: () => ({ active: active ? active.run : null, stretch: stretch ? { since: new Date(stretch.since).toISOString(), filed: stretch.filed } : null }),
+  };
+}
+
+module.exports = { JOB, VERSION, MAX_RESULTS, MAX_PAGES, STALE_MS, RETRY_MS, KINDS, ORIGINS, candidates, nextOf, promptOf, guardProposal, renderCheck, ensureReplay,
+  readRuns, appendRun, spentIn, monthOf, dirOf, pagesDir, pendingFile, runSpecimenDir, pageRef, create };