bareloop 0.9.0 → 0.10.0

package/src/authoring.js

@@ -417,6 +417,86 @@ export const TYPES_GENRE = Object.freeze({
       /** no import-resolution hazard on this runner — an EMPTY list, declared,
        * never an absent field that would read as "not looked into" (F59) */
       env: Object.freeze([]),
+      instruments: Object.freeze([
+        Object.freeze({
+          id: 'tsc-error-line',
+          what: 'one type error, as the TypeScript checker prints it',
+          lineMatch: 'error TS\\d+',
+          capture: null,
+          // REAL, from the captured `npm run typecheck -- --strict` of the pulselog
+          // patient (2026-08-09): 67 error lines, every one in this shape.
+          example: 'src/backup.js(21,19): error TS7006: Parameter \'now\' implicitly has an \'any\' type.',
+          why: 'tsc prints a DIFFERENT shape on a terminal (`src/backup.js:21:19 - error TS7006:`) than through a '
+            + 'pipe, and a close only ever reads the piped one. Run msmbpjk6 composed the terminal shape: it matched '
+            + '0 of 67 real error lines while the tool exited 2, so the stage read a crashed instrument. This pattern '
+            + 'is anchored on the CODE, not on the path spelling, so it reads both shapes and cannot lose that flip.',
+        }),
+        // ── node --test, the SAME pipe-vs-terminal trap, MEASURED ──────────────
+        //
+        // PROVENANCE, two independent halves.
+        //
+        // (1) REAL CAPTURED OUTPUT. The mailproof job-#2 battery's own spines carry
+        // whole `npm test` → `node --test` captures inside their `close-precheck`
+        // gap: `bareloop-patients/mailproof-job2-bareloop/battery-P1-mrm7gk25.jsonl`
+        // (`# tests 317` / `# pass 312` / `# fail 5`, five `not ok` lines) and
+        // `battery-P2-mrm7gk25.jsonl` (`# pass 316` / `# fail 1`). Nothing there was
+        // written to match a pattern — it is what the runner printed down the close's
+        // pipe, months before this table existed.
+        //
+        // (2) A SHIPPED, LIVE-FIRED SPELLING. `jobs/pulselog-author-types.json`
+        // already grades `^# pass (\d+)$` and `^# fail (\d+)$` (stages `tests-kept`
+        // and `test-suite-zero-failures`), and run msoc6t8v graded green through it.
+        // The table is not minting a new ruler; it is HANDING OVER the one the tree
+        // already grades with, the way the tsc term does.
+        //
+        // WHY IT IS THE TSC TRAP AGAIN, measured on this machine (node v22.22.2,
+        // one test file, identical args, 2026-08-13): through a PIPE the runner
+        // prints TAP — `TAP version 13`, `# pass 1`, `not ok 2 - b`; on a real pty it
+        // prints the spec reporter — `ℹ pass 1`, no `#`, no TAP at all. A close only
+        // ever reads the piped half, and a pattern composed against the pretty half
+        // matches nothing while the suite runs fine. Exactly what cost run msmbpjk6
+        // its authoring pass on tsc, waiting behind a second tool.
+        Object.freeze({
+          id: 'node-test-total-count',
+          what: 'how many tests the runner EXECUTED, off the TAP summary',
+          lineMatch: '^# tests (\\d+)$',
+          capture: 1,
+          example: '# tests 317',
+          why: 'the EXECUTED count is the honest denominator: a passed-count floor is satisfiable by a suite that '
+            + 'stopped running, so a stage asking "is the suite still whole?" counts this, not passes. Anchored '
+            + 'both ends because the runner prefixes ordinary chatter with the same `# ` (`# Subtest: <name>`), and '
+            + 'an unanchored `# tests` would count test NAMES.',
+        }),
+        Object.freeze({
+          id: 'node-test-pass-count',
+          what: 'how many tests passed, off the TAP summary',
+          lineMatch: '^# pass (\\d+)$',
+          capture: 1,
+          example: '# pass 316',
+          why: 'the spelling `jobs/pulselog-author-types.json` already grades with, green through run msoc6t8v. '
+            + 'The runner prints this line on a green run too, so a zero here is a REPORTED zero.',
+        }),
+        Object.freeze({
+          id: 'node-test-fail-count',
+          what: 'how many tests failed, off the TAP summary',
+          lineMatch: '^# fail (\\d+)$',
+          capture: 1,
+          example: '# fail 1',
+          why: 'this runner prints every counter on every run — a fully green suite still prints `# fail 0` '
+            + '(measured), so reading the figure cannot confuse "no failures" with "never reported". Its pytest '
+            + 'counterpart has no such guarantee, which is why python has no fail-COUNT term.',
+        }),
+        Object.freeze({
+          id: 'node-test-failed-line',
+          what: 'one failing test, as the TAP reporter names it',
+          lineMatch: '^not ok \\d+ ',
+          capture: null,
+          example: 'not ok 7 - edit-renotify: a non-participant edit, and edits on a pending event, ping no one',
+          why: 'one line per failing test, so it TALLIES and no match is a genuine counted zero. The trailing '
+            + 'space and the `^` both carry weight: every passing test prints `ok 7 - …`, and without the anchor '
+            + 'each of those would count as a failure.',
+        }),
+      ]),
     }),
     python: Object.freeze({
       suppressions: Object.freeze([
@@ -437,6 +517,58 @@ export const TYPES_GENRE = Object.freeze({
             + 'found by probe). It moves no seed number, so no seed-verdict read can see its absence.',
         }),
       ]),
+      instruments: Object.freeze([
+        Object.freeze({
+          id: 'mypy-error-line',
+          what: 'one type error, as mypy prints it',
+          lineMatch: ' error: ',
+          capture: null,
+          // REAL, from a live aurora run's own spine
+          // (bareloop-patients/aurora-u-bareloop/u-ms2c0ls7.jsonl).
+          example: 'packages/spawner/src/aurora_spawner/timeout_policy.py:89: error: Statement is unreachable  [unreachable]',
+          why: 'the operator\'s own hand-written close reads mypy this way (scripts/u-spawner-close.mjs:133), minted '
+            + 'by paid live runs. It is anchored on the SEVERITY word, not on the path spelling, so a relative or '
+            + 'absolute path, a package prefix or a config-driven root all read the same.',
+        }),
+        // ── pytest, from the aurora battery's own captured runs ────────────────
+        //
+        // PROVENANCE: six `close-precheck` gaps in
+        // `bareloop-patients/aurora-soar-bareloop/battery-A{1..4}-*.jsonl` carry the
+        // whole captured pytest run of the aurora patient (pytest 9.1.1, python
+        // 3.14.6, the patient's own `pytest.ini` addopts, which include `-ra`) —
+        // 2,690-odd tests, the `short test summary info` section and the final counts
+        // line. Real, uncrafted, paid for.
+        //
+        // WHAT IS NOT ANCHORED, and why. Every archived counts line arrives padded
+        // with `=` on both sides, and the padding WIDTH is terminal-derived: the
+        // archived long line gets exactly one `=` per side, a short local run gets
+        // twenty-five (measured, pytest 9.0.2, 2026-08-13). Under `-q` the padding is
+        // absent entirely. So the term anchors on the WORD and its number, never on
+        // the decoration — the same discipline as anchoring tsc on the code rather
+        // than the path.
+        Object.freeze({
+          id: 'pytest-pass-count',
+          what: 'how many tests passed, off pytest\'s final counts line',
+          lineMatch: '(\\d+) passed',
+          capture: 1,
+          example: '= 1 failed, 2690 passed, 3 skipped, 18 deselected, 1775 warnings in 326.12s (0:05:26) =',
+          why: 'the ONE segment of this line pytest prints whether the run was green or red, so it is the only '
+            + 'count on it that can be read as a figure without risking "never reported". The other segments '
+            + '(failed, skipped, deselected) are omitted when their count is zero — a green run prints just '
+            + '`1 passed in 0.04s` (measured) — so a term reading THOSE would go silent exactly when the news is '
+            + 'good, and a silent figure term is a broken instrument, not a zero.',
+        }),
+        Object.freeze({
+          id: 'pytest-failed-line',
+          what: 'one failing test, as pytest\'s short summary names it',
+          lineMatch: '^FAILED ',
+          capture: null,
+          example: 'FAILED packages/soar/tests/test_agent_registry_deprecation.py::TestAgentRegistryDeprecation::test_registry_and_discovery_equivalent_results',
+          why: 'this is how you count pytest FAILURES: exactly one line per failing test (measured under both `-ra` '
+            + 'and `-q`), so it TALLIES and no match at all is a legitimate counted zero rather than an unreported '
+            + 'number. It needs pytest\'s short summary section, which the patient\'s own config must not suppress.',
+        }),
+      ]),
     }),
   }),
 });
@@ -599,6 +731,64 @@ export function genreOwnedEnvNames(lang) {
   return language(lang).env.map((/** @type {any} */ e) => e.name);
 }
 
+/**
+ * HOW THE GENRE'S OWN TOOLS PRINT — genre property, like the suppression battery
+ * and like `MYPYPATH`, and for the same reason: it is a FACT ABOUT AN INSTRUMENT
+ * WE ALREADY OWN, not a composition choice. Seven hand-written closes read tsc
+ * with the identical `/error TS\d+/` (`scripts/u-pulselog-close.mjs:122`,
+ * `u-bareguard-close.mjs:123`, `u-bareagent-close.mjs:123`,
+ * `u-baremobile-close.mjs:122`, `u-litectx-close.mjs:140`, `types-close.mjs:190`,
+ * `types-check.mjs:60`) and one reads mypy with `' error: '`
+ * (`u-spawner-close.mjs:133`) — the same provenance the SUPPRESSIONS table has:
+ * operator knowledge minted by paying for live runs.
+ *
+ * WHY IT BECAME GENRE DATA (run msmbpjk6, 2026-08-09, $0.43). Left to the model,
+ * the parser for a known tool is a DRAFT-TIME LOTTERY on a fact nobody needed to
+ * guess: that run composed tsc's TTY-only pretty shape
+ * (`^\S+\.js:\d+:\d+ - error TS\d+:`), which matched 0 of the 67 real error lines
+ * the piped run actually printed, while the tool exited 2. The gates held — the
+ * stage read as a crashed instrument and signing was refused, correctly — but the
+ * refusal cost a whole authoring run to learn something the tree already knew. An
+ * earlier run (mslwbkz7) happened to roll the right shape. A coin-flip on an
+ * owned fact is not a capability question.
+ *
+ * WHAT THIS IS NOT: it does not close the parser. A stage counting something we
+ * have NOT measured still writes its own pattern, and that remains a real gap —
+ * named, not smoothed. This table is where a measured instrument fact lands, one
+ * at a time, with its provenance.
+ *
+ * THE TEST-COUNT FACTS (2026-08-13) landed under exactly that rule, and closed
+ * two of the three gaps the paragraph above used to name by hand: the executed
+ * count and the failure line, for both runners, are now measured facts rather
+ * than draft-time lotteries. Provenance rides on each entry.
+ *
+ * WHAT STAYED OUT, deliberately, because no evidence covers it:
+ *  - a pytest FAIL-COUNT figure. A green pytest run omits the segment entirely
+ *    (`1 passed in 0.04s`), so a figure term over it reports "never reported" on
+ *    precisely the runs that went well. Failures are counted with the `^FAILED `
+ *    tally instead, where no match IS zero.
+ *  - a pytest EXECUTED count. `collected N items` is printed under `-ra` and NOT
+ *    under `-q` (measured both ways), so no single spelling survives the modes a
+ *    patient may configure; a stage needing it still composes its own and says so.
+ *
+ * Returns a fresh copy per call, for the reason `classGuards` does: a frozen
+ * constant handed to a caller that edits it is one shared table away from a
+ * silently changed ruler.
+ * @param {string} lang
+ * @returns {{id: string, what: string, lineMatch: string, capture: number|null, example: string, why: string}[]}
+ */
+export function genreInstruments(lang) {
+  const instruments = language(lang).instruments ?? [];
+  // F59's shape at a table that feeds a RULER: an empty list would read as "this
+  // language's tools need no stated format", which is exactly the sentence that
+  // put the pretty-format regex into a signed-close candidate.
+  if (!instruments.length) {
+    throw new Error(`no known-instrument formats for language "${lang}" — a language the genre admits states how its `
+      + 'own checker prints, or the model is back to guessing a fact we already own');
+  }
+  return instruments.map((/** @type {any} */ i) => ({ ...i }));
+}
+
 /**
  * GROUNDING for a RECORDED genre environment — the provenance half of the
  * owned-env rule, and the reason the by-value comparison is worth anything.

package/src/authorjob.js

@@ -365,7 +365,7 @@ function composerRefusal(reds) {
  * @param {{answers: Record<string|number, any>, repoPath?: string|null, lang: string,
  *   verdictType?: string|null,
  *   questions?: Record<string|number, string>|null, generate?: Function, provider?: any,
- *   seedRef?: string|null, scout?: any, listing?: any,
+ *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null,
  *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
  *   authorFn?: Function, authorOpts?: object}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
@@ -375,6 +375,7 @@ function composerRefusal(reds) {
 export async function authorCloseForJob({
   answers, repoPath = null, lang, verdictType = null, questions = null,
   generate, provider = null, seedRef = null, scout = null, listing = null,
+  ceilingUsd = null,
   seedFn = seedAtHead, scoutFn = runAuthorScout, listingFn = buildSeedListing,
   authorFn = authorClose, authorOpts = {},
 }) {
@@ -437,7 +438,14 @@ export async function authorCloseForJob({
   // D11 — the scout LOOKS, the author WRITES, neither acts. An ABSENT survey is
   // never "no special facts are needed" (F59), and `authorClose` refuses on it at
   // $0, so nothing here has to second-guess the classification.
-  const survey = scout ?? await scoutFn({ workdir, provider });
+  // ONE CEILING, BOTH PAID SEAMS. The survey and the declaration loop are two
+  // populations of paid call with two accumulators, and the operator set ONE
+  // number: handing it to both is what makes the advertised ceiling and the
+  // enforced ceiling the same ceiling (the standing hard line, in its money
+  // form). `null` travels EXPLICITLY rather than being left off — unbounded is a
+  // stated operator choice, and an absent field read as falsy is the same state
+  // arrived at by accident.
+  const survey = scout ?? await scoutFn({ workdir, provider, ceilingUsd });
   const seeds = listing ?? await listingFn({
     workdir, seedRef: seed, sourcePaths: survey?.facts?.sourcePaths, testPaths: survey?.facts?.testPaths,
   });
@@ -445,7 +453,7 @@ export async function authorCloseForJob({
   const authored = await authorFn({
     workdir, seedRef: seed, lang, verdictType: picked,
     answers: interview.answers, questions: questions ?? questionsFor(picked),
-    scout: survey, listing: seeds, generate, ...authorOpts,
+    scout: survey, listing: seeds, generate, ceilingUsd, ...authorOpts,
   });
 
   if (!authored.ok) {

package/src/authorscout.js

@@ -50,11 +50,11 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { Gate } from 'bareguard';
 import { LiteCtx } from 'litectx';
-import { seedListing } from './kinds.js';
+import { seedListing, GATE_AUDIT_FILE, ARBITER_BOOK_STORES } from './kinds.js';
 import { TOOL_MENU, WRITE_VERBS, STORE_VERBS } from './job.js';
 import { TOOL_BY_VERB, CTX_TOOLS, createCtxTools, toolAction, strategyFor } from './tools.js';
 import { redactSecrets, SECRET_PATTERNS } from './validate.js';
-import { extractArtifact, priceOf, scrubRaw, stampRaw } from './text.js';
+import { extractArtifact, priceOf, scrubRaw, stampRaw, tallyCalls, capStop } from './text.js';
 
 const require = createRequire(import.meta.url);
 const { Loop, wireGate } = require('bare-agent');
@@ -115,6 +115,16 @@ export const SURVEY_CAUSES = Object.freeze({
   NON_OBJECT: 'non-object',
   /** valid JSON, no content — F59's whole point, and a SEMANTIC failure */
   EMPTY_OBJECT: 'empty-object',
+  /**
+   * THE SURVEY WAS NEVER ASKED FOR: the operator's money ceiling was already
+   * spent when the first attempt came due, so no call was made. Named as its own
+   * cause for the reason this enum exists at all — a new route to ABSENT has to
+   * be named, and naming it is the moment somebody decides whether it retries.
+   * This one does not, and cannot: a retry is precisely what the cap forbade.
+   * It is deliberately ABSENT of the model's own doing, and the prose says so —
+   * "the scout did not complete" would blame a model that never spoke.
+   */
+  NOT_FUNDED: 'not-funded',
 });
 
 /**
@@ -280,9 +290,9 @@ export function classifySurvey(blob, meta) {
  * `runAuthorScout` where they can be proven.
  * @param {{workdir: string, granted: readonly string[], auditPath?: string, ctx?: boolean}} o
  */
-export async function defaultSurveyor({ workdir, granted, auditPath = join(workdir, 'gate-audit.jsonl'), ctx = true }) {
+export async function defaultSurveyor({ workdir, granted, auditPath = join(workdir, GATE_AUDIT_FILE), ctx = true }) {
   const gate = new Gate({
-    fs: { writeScope: [], readScope: [workdir], deny: [auditPath, join(workdir, '.smoke'), join(workdir, '.litectx')] },
+    fs: { writeScope: [], readScope: [workdir], deny: [auditPath, ...ARBITER_BOOK_STORES.map((s) => join(workdir, s))] },
     limits: { maxTurns: AUTHOR_SCOUT_ROUNDS + 2 },
     audit: { path: auditPath },
     secrets: { patterns: SECRET_PATTERNS },
@@ -338,11 +348,12 @@ const defaultLoop = (/** @type {any} */ { system, policy, onLlmResult, provider
  *
  * @param {{workdir: string, provider?: any,
  *   rounds?: number, minBytes?: number, blobMax?: number, maxTokens?: number, ctx?: boolean,
- *   attempts?: number,
+ *   attempts?: number, ceilingUsd?: number|null,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any}) => any,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
  * @returns {Promise<Survey & {raw: string, raws: ReturnType<typeof scrubRaw>[],
- *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[]}>}
+ *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
+ *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
  */
 export async function runAuthorScout({
   workdir, provider = null,
@@ -352,6 +363,7 @@ export async function runAuthorScout({
   maxTokens = AUTHOR_SCOUT_MAX_TOKENS,
   ctx = true,
   attempts = SCOUT_ATTEMPTS,
+  ceilingUsd = null,
   createLoop = defaultLoop,
   createSurveyor = defaultSurveyor,
 }) {
@@ -395,8 +407,21 @@ export async function runAuthorScout({
      * judged. An instrument that misaddresses its own reading is the blind
      * -instrument class, one field wide. */
     let verdictAt = -1;
+    /** the operator's money ceiling, when it is what ended the ladder. `null` on
+     * every other path INCLUDING the unbounded one, so a reader never has to
+     * infer a governance stop from an absence.
+     * @type {'cap-halt'|'pricing-red'|null} */
+    let budgetStop = null;
 
     while (attempt < allowed) {
+      // THE CEILING, between attempts. The attempt cap bounds how many times the
+      // survey may ask; it says nothing about what those asks cost, and this is
+      // the pipeline's FIRST paid stage — a ladder that spends the whole wallet
+      // before the declaration is ever authored is the failure this closes.
+      // Checked before the counter moves, so `attempt` stays the number of
+      // attempts that actually happened.
+      const halt = capStop({ ceilingUsd, ...tallyCalls(calls) });
+      if (halt) { budgetStop = halt; break; }
       attempt += 1;
       const label = attempt === 1 ? 'author-scout' : `author-scout#${attempt}`;
 
@@ -432,7 +457,29 @@ export async function runAuthorScout({
         // F59's reserved TOOLLESS final round. It fires on the ONE population it
         // was sized for — a survey that was CUT OFF and came back short — never
         // on a survey that simply finished with little to say.
-        if (bounded && Buffer.byteLength(blob) < minBytes && Array.isArray(r?.msgs) && r.msgs.length) {
+        // …and the reserved round is a PAID CALL like any other, so it sits behind
+        // the same ceiling. Left outside it, the one call the cap most needs to
+        // stop is the one that escapes: the recovery fires exactly when the first
+        // call was cut off, which is exactly when the wallet is thinnest.
+        //
+        // THE CEILING IS ASKED ABOUT A CALL THAT WOULD ACTUALLY BE MADE, and the
+        // ORDER is what makes that true: the recovery predicate is settled FIRST,
+        // and `capStop` is consulted only when a recovery was genuinely pending.
+        // Asked unconditionally it answers a question nobody put — the wallet is
+        // over, but nothing was refused — and `budgetStop` means the ceiling is
+        // WHAT ENDED THE LADDER, which is then a lie on every other attempt-1
+        // ending: a dead socket on an unbounded first call, or a survey that came
+        // back PRESENT and needed no second call at all. Both then render as
+        // `cap-halt` at `path: budgetUsd`, steering the operator to raise a number
+        // that cannot move the outcome. Nothing about the REFUSAL moves here — the
+        // same predicate, the same tally, the same call not made (the top-of-loop
+        // latch still names the ceiling whenever a retry was due). This is which
+        // ending gets the label, and nothing else.
+        const recoveryWanted = bounded && Buffer.byteLength(blob) < minBytes
+          && Array.isArray(r?.msgs) && r.msgs.length > 0;
+        const recoveryHalt = recoveryWanted ? capStop({ ceilingUsd, ...tallyCalls(calls) }) : null;
+        if (recoveryHalt) budgetStop = recoveryHalt;
+        if (recoveryWanted && !recoveryHalt) {
           const recovery = createLoop({ system, policy: surveyor.policy, onLlmResult: surveyor.onLlmResult, provider });
           s2 = await recovery.run([...r.msgs, { role: 'user', content: SCOUT_RECOVERY_PROMPT }], [],
             { cacheMessages: true, maxTokens });
@@ -484,12 +531,26 @@ export async function runAuthorScout({
       if (!SCOUT_RETRY_CAUSES.includes(/** @type {string} */ (survey.cause))) break;
     }
 
-    const final = /** @type {Survey} */ (survey);
+    // THE SURVEY THAT WAS NEVER ASKED FOR. The ceiling was already spent when the
+    // first attempt came due, so no call was made and there is no reply to
+    // classify. It is spelled out rather than run through `classifySurvey`, which
+    // would read the empty blob and report that the model came back EMPTY — a
+    // model that never spoke cannot have said nothing, and blaming it would send
+    // the operator to the scout when the fact is the wallet.
+    const final = /** @type {Survey} */ (survey ?? {
+      state: 'ABSENT',
+      facts: null,
+      cause: SURVEY_CAUSES.NOT_FUNDED,
+      reason: budgetStop === 'pricing-red'
+        ? 'the survey was never asked for: spend could not be priced, so the ceiling could not be enforced (F6)'
+        : `the survey was never asked for: the $${ceilingUsd} ceiling was already spent`,
+      meta: { bytes: 0, rounds: 0, bounded: false, recovered: false, error: null, attempts: 0, attemptsAllowed: allowed },
+    });
     // Exhaustion is still the same honest ABSENT — it now says how many times we
     // paid to find out. One attempt says nothing about retries, because there
     // were none.
     const reason = final.reason !== null && attempt > 1 ? `${final.reason} — after ${attempt} attempts` : final.reason;
-    return { ...final, reason, raw: blob, raws, calls };
+    return { ...final, reason, raw: blob, raws, calls, budgetStop };
   } finally {
     // a leaked surveyor leaks a gate handle and a litectx index — always, even
     // when the loop threw

package/src/bridges.js

@@ -34,7 +34,7 @@
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { isObj, isNonEmptyString } from './validate.js';
+import { isObj, isNonEmptyString, sweepNestedQuantifiers } from './validate.js';
 import { TOOL_MENU, LOCKED_TOOLS } from './job.js';
 import { closeStagesOf } from './plan.js';
 
@@ -183,6 +183,19 @@ export function validateBridge(input) {
   if (!Array.isArray(e.history)) red('invalid-value', 'history', 'array of per-run rows');
   else e.history.forEach((/** @type {unknown} */ h, /** @type {number} */ i) => validateHistoryRow(h, `history.${i}.`, red));
 
+  // PRD v1.60 §1 — the operator-regex admissibility sweep, whose population was
+  // `jobs/*.json` and is now every signed spec wherever it lives. A bridge ships
+  // its plans VERBATIM, and a stored `artifact-written.pattern` reaches the same
+  // untimed exit evaluator on the same main event loop that F49 measured. The
+  // reject is UNCHANGED (`hasNestedQuantifier`, one inventory) — only the
+  // population is wider, so a clean bridge is byte-identically clean.
+  //
+  // Whole-entry rather than per-field, because a bridge's regexes sit inside a
+  // plan stored as opaque data (`isObj(o.plan)` is all this validator asserts
+  // about it): enumerating a path into a document this one deliberately does not
+  // parse is how a sweep goes blind the next time the plan schema moves.
+  sweepNestedQuantifiers(e, red);
+
   // R1's coherence, checked only once everything it reads is itself valid (a
   // second red on an already-broken field would bury the real defect): every green
   // mints exactly one version, and a red mints none.

package/src/index.js

@@ -96,6 +96,9 @@ export {
 export {
   validateDeclaration, normalizeDeclaration, KIND_CATALOGUE, CATALOGUE_KINDS, CATALOGUE_LIVE_KINDS,
   LOCKED_KINDS, TYPES_GENRE, TYPES_GENRE_TEMPLATE, GENRE_LANGUAGES, genreEnv, genreOwnedEnvNames,
+  // how the genre's own tools PRINT — genre property for the same reason the
+  // suppression battery is (2026-08-09, run msmbpjk6)
+  genreInstruments,
   DIRECTIONS, BASELINES, MAX_STAGES,
   // the verdict-class surface (PRD v1.57 §1–§2): the radio's own menu, the guard
   // battery keyed off it, and the ceiling that makes the pick a promise

package/src/kinds.js

@@ -346,24 +346,55 @@ export async function seedListing(workdir, seedRef) {
 // ── contract (c): the changed-set primitive ──────────────────────────────────
 
 /**
- * The two arbiter books, and the shape of each exclusion is the whole point.
+ * The arbiter books, and the shape of each exclusion is the whole point.
  *
- * `.litectx/` is a PREFIX — everything beneath the store belongs to the
- * arbiter. `gate-audit.jsonl` is an EXACT repo-relative path and never a
- * basename or a pattern: the gate audit is written to
+ * `.litectx/` and `.smoke/` are PREFIXES — everything beneath either store
+ * belongs to the arbiter. `gate-audit.jsonl` is an EXACT repo-relative path and
+ * never a basename or a pattern: the gate audit is written to
  * `join(workdir, 'gate-audit.jsonl')` and nowhere else, so a worker-authored
  * `src/gate-audit.jsonl` is NOT an arbiter book and must still count as work.
  * Matching by basename would swallow it — and swallowing a worker's real
- * write is the failure direction that reads as a clean tree.
+ * write is the failure direction that reads as a clean tree. `src/smoke.js` and
+ * `tests/smoke.test.js` are that same decoy for the store below.
+ *
+ * `.smoke/` — F98's parked residual, closed here. The fence has always denied
+ * `join(workdir, '.smoke')` on every worker (src/planrun.js, src/authorscout.js)
+ * and the persona now states the rule; this reader, which decides what COUNTS AS
+ * WORK, was the one place that never knew the name. On patients whose .gitignore
+ * default-denies dot-directories the store never reaches `ls-files --others` and
+ * the gap is masked — by the PATIENT's config, not by anything here. Incidental
+ * masking is not an exclusion: on a patient without that line the arbiter's own
+ * store would enter the changed set as the worker's writing.
  * @param {string} rel a repo-relative POSIX path
  * @returns {string|null} the book it belongs to, or null
  */
 export function isArbiterBook(rel) {
-  if (rel === '.litectx' || rel.startsWith('.litectx/')) return '.litectx/';
-  if (rel === 'gate-audit.jsonl') return 'gate-audit.jsonl';
+  for (const store of ARBITER_BOOK_STORES) {
+    if (rel === store || rel.startsWith(`${store}/`)) return `${store}/`;
+  }
+  if (rel === GATE_AUDIT_FILE) return GATE_AUDIT_FILE;
   return null;
 }
 
+/**
+ * The arbiter's book NAMES, one home. F98's mechanism was exactly this list
+ * living as independent literals: the fence deny arrays (src/planrun.js,
+ * src/authorscout.js) knew `.smoke` while `isArbiterBook` — the reader that
+ * decides what COUNTS AS WORK — did not, and the drift was masked by the
+ * patient's own .gitignore. Every consumer (the fence deny lists, this file's
+ * reader, the persona's stated law, run.js's smoke-store root) now spells the
+ * names from here, so adding or renaming a book is one edit that cannot leave
+ * a site behind.
+ *
+ * `ARBITER_BOOK_STORES` are directory PREFIXES; `GATE_AUDIT_FILE` is an EXACT
+ * repo-relative path (see `isArbiterBook`'s docstring for why never a
+ * basename). Order is the fence deny-list order and the persona's prose order.
+ */
+export const SMOKE_STORE = '.smoke';
+export const LITECTX_STORE = '.litectx';
+export const GATE_AUDIT_FILE = 'gate-audit.jsonl';
+export const ARBITER_BOOK_STORES = Object.freeze([SMOKE_STORE, LITECTX_STORE]);
+
 /**
  * Everything this run changed against the seed: the tracked diff PLUS
  * untracked files (an untracked file has no diff — the case a naive
@@ -699,13 +730,36 @@ export function normalizeParser(parser, at = 'parser') {
  * that matched BEFORE the filter judged them — kept, unattributable and dropped
  * alike — and it is the only evidence of liveness a caller has once the scope
  * has removed the whole population. It is never the number being read.
+ *
+ * `matched` is the KEPT lines themselves, PER TERM and index-aligned with
+ * `breakdown`: entry i holds, in output order, exactly the lines term i's
+ * subtotal was computed FROM. Run u-msn227nq paid for the echo — the executor
+ * counted 8 real `error TS…` lines and told the worker "8 match(es)", discarding
+ * every address, and a worker with a number and no file to open went looking for
+ * the arbiter's own books instead.
+ *
+ * TWO EXCLUSIONS, both of them "this line is not what the count is made of":
+ *  - a scope-DROPPED line is never in here. It was never counted, so aiming the
+ *    worker at it would aim it outside its own population.
+ *  - under `first`, only the line the aggregate actually READ. The later matches
+ *    are real matches (`breakdown[i].matches` still counts them) but the value
+ *    never contained them, and echoing them points the worker at a number that
+ *    is not in the reading.
+ *
+ * And the GROUPING is the third: a term's sign lives in `breakdown[i]`, so lines
+ * pooled flat across terms lose the one fact that says what they DID to the
+ * number. A subtracted term's line rendered beside an added one reads as a wall
+ * to go fix, and fixing it moves the count the wrong way. Deduplication is
+ * therefore within a term only — one line matched by two terms plays two
+ * arithmetic roles and is named under each. The count is computed from `values`,
+ * never from this list.
  * @param {string} output @param {any[]} terms normalised terms
  * Every stop here is `crashed` in the arbiter's vocabulary — the command RAN,
  * came back, and the number could not be read out of it. Nothing in this
  * function can observe a spawn failure, a timeout or a signal, so it never
  * claims one.
  * @param {{scope?: any, workdir?: string}} [o]
- * @returns {{stop: string, fault: string, notes?: string[]}|{stop: null, value: number, breakdown: any[], notes: string[], preScopeMatches: number}}
+ * @returns {{stop: string, fault: string, notes?: string[]}|{stop: null, value: number, breakdown: any[], notes: string[], preScopeMatches: number, matched: string[][]}}
  */
 export function parseValue(output, terms, { scope = null, workdir = '' } = {}) {
   let value = 0;
@@ -715,6 +769,10 @@ export function parseValue(output, terms, { scope = null, workdir = '' } = {}) {
   const breakdown = [];
   /** @type {string[]} */
   const notes = [];
+  // the KEPT lines PER TERM, in output order and deduplicated within the term —
+  // see the note above
+  /** @type {string[][]} */
+  const matched = [];
   const filtering = scopeFilters(scope);
   // one resolver (and one realpath cache) per call, built only when a filter
   // will actually read it
@@ -739,6 +797,9 @@ export function parseValue(output, terms, { scope = null, workdir = '' } = {}) {
     try { re = new RegExp(t.lineMatch, 'g'); } catch (e) { return { stop: `INSTRUMENT: term ${i} lineMatch /${t.lineMatch}/ is not a valid regex: ${String(/** @type {any} */ (e)?.message ?? e)}`, fault: STOP_FAULTS.CRASHED }; }
     /** @type {number[]} */
     const values = [];
+    /** @type {string[]} */
+    const kept = [];
+    const seen = new Set();
     let dropped = 0;
     let unattributable = 0;
     for (const line of region.split('\n')) {
@@ -750,6 +811,10 @@ export function parseValue(output, terms, { scope = null, workdir = '' } = {}) {
         if (p === null) unattributable += 1;
         else if (!inScope(p, scope, phys)) { dropped += 1; continue; }
       }
+      // past the filter, so this line is a CANDIDATE for the harvest — kept here
+      // rather than at aggregation because this is the only place the raw line
+      // still exists, and narrowed to what the aggregate actually read below
+      if (!seen.has(line)) { seen.add(line); kept.push(line); }
       for (const h of hits) {
         if (t.capture === null) { values.push(1); continue; }
         const rawCapture = h[t.capture];
@@ -789,10 +854,14 @@ export function parseValue(output, terms, { scope = null, workdir = '' } = {}) {
       }
       subtotal = values[0];
     }
+    // `first` read ONE line — `kept[0]`, since `values[0]` is the first hit on
+    // the first kept line. The rest matched (and `matches` below still says so)
+    // but are not what this subtotal is made of.
+    matched.push(t.aggregate === 'first' ? kept.slice(0, 1) : kept);
     breakdown.push({ term: i, lineMatch: t.lineMatch, aggregate: t.aggregate, sign: t.sign, matches: values.length, subtotal, contribution: t.sign * subtotal });
     value += t.sign * subtotal;
   }
-  return { stop: null, value, breakdown, notes, preScopeMatches };
+  return { stop: null, value, breakdown, notes, preScopeMatches, matched };
 }
 
 // ── D12: the baseline is MEASURED at this run's own seed, every run ──────────
@@ -1084,7 +1153,7 @@ async function runCountNotWorse(stage, ctx) {
         notes: [],
       };
     }
-    return { stop: null, value: v.value, breakdown: v.breakdown, notes: v.notes, exit: r.code, dropped: r.dropped, fault: STOP_FAULTS.FAILED };
+    return { stop: null, value: v.value, breakdown: v.breakdown, notes: v.notes, matched: v.matched, exit: r.code, dropped: r.dropped, fault: STOP_FAULTS.FAILED };
   };
 
   const now = await measure(ctx.workdir, 'the current tree');
@@ -1126,8 +1195,30 @@ async function runCountNotWorse(stage, ctx) {
   if (worse) {
     gap.push(`${stage.name}: ${value} against a baseline of ${baseline} (${p.direction}) — worse`);
     gap.push(`  baseline ${baselineSource}`);
-    for (const b of /** @type {any[]} */ (now.breakdown)) {
+    // …each term stating itself, and THEN the lines that term's subtotal is made
+    // of, nested under it. A count with no addresses is the semantic genre F38
+    // measured as inert: run u-msn227nq's worker was handed "8 match(es)", had
+    // nowhere to open, and probed the arbiter's books until the deny guard ended
+    // the run. The instrument NAMED these lines — echoing what it named is the
+    // same licence `pattern-absent-in-diff` already runs under, not the barred
+    // move of naming a culprit the instrument never reported.
+    //
+    // NESTED, not pooled, because a line's arithmetic role is the term's and only
+    // the term's row carries it. `value` is a SIGNED sum: a term declared
+    // `sign: -1` subtracts, so its lines are ones the count went DOWN for, and a
+    // worker handed them flat beside the added ones reads every line as a wall
+    // and "fixes" one that moves the number the wrong way. The row directly above
+    // each block already says `contributes +n` / `-n`; sitting the lines under it
+    // is what makes that statement reach them. Nothing is withheld — under
+    // `higher-is-better` the subtracted term is exactly where the news usually is
+    // — and nothing is relabelled: the lines are still verbatim, one indent in.
+    //
+    // They ride the Gap like every other line: the stage prefix (Layer R's
+    // redKeep derives from it), the cap, and the trim marker on overflow.
+    const perTerm = /** @type {string[][]} */ (now.matched ?? []);
+    for (const [i, b] of /** @type {any[]} */ (now.breakdown).entries()) {
       gap.push(`  term ${b.term} /${b.lineMatch}/ ${b.aggregate}: ${b.matches} match(es), subtotal ${b.subtotal}, contributes ${b.contribution >= 0 ? '+' : ''}${b.contribution}`);
+      for (const l of perTerm[i] ?? []) gap.push(`    ${l}`);
     }
   }
   return result(stage, {

package/src/ledger.js

@@ -75,7 +75,11 @@ const EXCLUDED_ESCALATIONS = new Set([
   // real upstream ask would be sourced from anyway.
   'step-stalled',
   'step-variance',      // A's replan trigger: a planning story, never a lib bug
-  'gate-red',           // governance working as intended
+  // Governance working as intended — and no longer minted anywhere in this tree
+  // (a denial streak is a bounded attempt, not a terminal). Kept listed because
+  // this set is the EXECUTABLE excluded-set: dropping a name does not delete the
+  // category, it re-files any future emission of it as a counted capability gap.
+  'gate-red',
   'smoke-red',          // already counted via primitive-smoke
   'hitl-close',         // by design: a human is the close
   'close-unsupported',  // honest refusal, by design