bareloop 0.9.0 → 0.10.0

package/src/validate.js

@@ -177,6 +177,69 @@ function unboundedQuantLen(src, i) {
   return len;
 }
 
+/** How many characters of `(`-prologue sit at `src[i]` before the group's BODY:
+ * 1 for a plain or capturing group, 3 for `(?:` `(?=` `(?!`, 4 for `(?<=` `(?<!`,
+ * and past the `>` of a named group `(?<name>`. The body is read back when the
+ * group closes, and a prologue counted as body text would make `(?:a|aa)` split
+ * as `?:a` / `aa` — no prefix relation, and the hazard read as safe.
+ * @param {string} src @param {number} i index of the `(` */
+function groupPrologueLen(src, i) {
+  if (src[i + 1] !== '?') return 1;
+  const c = src[i + 2];
+  if (c === ':' || c === '=' || c === '!') return 3;
+  if (c === '<') {
+    if (src[i + 3] === '=' || src[i + 3] === '!') return 4;   // lookbehind
+    const close = src.indexOf('>', i + 3);                    // named group
+    return close === -1 ? 3 : close - i + 1;
+  }
+  return 1;                                                    // modifier groups etc — read the lot as body (fail-safe)
+}
+
+/**
+ * Do a group body's TOP-LEVEL alternation branches overlap — is one a prefix of
+ * another, equality included? That is the practical detectable core of the
+ * overlapping-alternation blowup (`(a|aa)`, `(a|a)`, `(\d|\d\d)`, `(a|a?)`):
+ * two branches that can consume the same text give the engine two ways to reach
+ * the same position, and an unbounded repeat multiplies them.
+ *
+ * The comparison is over the branches' SOURCE TEXT, which is what makes it
+ * conservative rather than exact — `(ab|abc)+` carries the prefix relation and
+ * did not blow up on the body measured. Exactness needs the real regex engine
+ * F49 declined to take as a dependency, and guessing it wrong would ADMIT an
+ * exponential pattern, so the over-rejection stands as a named limit.
+ *
+ * Splitting respects escapes, character classes and nested groups: a `|` inside
+ * `[a|b]` or inside `(x|y)` is not this group's alternation, and treating it as
+ * one would invent branches nobody wrote.
+ * @param {string} body the text between a group's prologue and its `)`
+ * @returns {boolean}
+ */
+function altBranchesOverlap(body) {
+  /** @type {string[]} */
+  const branches = [];
+  let start = 0;
+  let depth = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === '\\') { i++; continue; }
+    if (c === '[') { i++; if (body[i] === '^') i++; while (i < body.length && body[i] !== ']') { if (body[i] === '\\') i++; i++; } continue; }
+    if (c === '(') { depth++; continue; }
+    if (c === ')') { depth--; continue; }
+    if (c === '|' && depth === 0) { branches.push(body.slice(start, i)); start = i + 1; }
+  }
+  if (branches.length === 0) return false;                    // no top-level alternation at all
+  branches.push(body.slice(start));
+  for (let i = 0; i < branches.length; i++) {
+    for (let j = 0; j < branches.length; j++) {
+      // `startsWith` covers EQUALITY, which is the 2ⁿ case: `(a|a)+$` took 52.3s
+      // on a 27-character body. Skipping i===j is what keeps that from being
+      // every pattern's own reflexive match.
+      if (i !== j && branches[j].startsWith(branches[i])) return true;
+    }
+  }
+  return false;
+}
+
 /**
  * F49 — a heuristic reject for the catastrophic-backtracking footgun: an
  * unbounded quantifier applied to a group whose body itself repeats unboundedly
@@ -201,16 +264,40 @@ function unboundedQuantLen(src, i) {
  * So the reject targets the dominant exponential class and fails it as a
  * mechanical gap at the validation gate, before any tokens burn. A full ReDoS
  * analyzer needs a real regex engine (an external native dep we do not take for
- * a LOW issue); exotic overlapping-alternation blowup is out of scope by
- * decision (PARKED to the close-authoring rung — PRD v1.55).
+ * a LOW issue).
+ *
+ * SECOND CLASS, added 2026-08-12 — OVERLAPPING ALTERNATION under an unbounded
+ * repeat (`(a|aa)+`, `(a|a)+`, `(\d|\d\d)*`). F49 recorded this as a genuine
+ * false NEGATIVE of the shape approach and PARKED the widening, because changing
+ * the detector changes which SIGNED specs are admissible. It is closed here on
+ * measurement, one fresh process per point (a hot RegExp tiers up out of the V8
+ * interpreter, and a single-process sweep read a LONGER body as faster —
+ * backwards for an exponential, and the harness rather than the regex).
+ * `(a|aa)+$` against a run of `a` with one non-matching tail character:
+ *
+ *     27ch 218ms · 31ch 1,879ms · 35ch 12,082ms · 39ch 52,563ms · 41ch 189,420ms
+ *
+ * ~6.8× per 4 characters — the Fibonacci decomposition count, φ⁴. `(a|a)+$` (the
+ * 2ⁿ equal-branch case) took 52,256ms on 27ch, and `((a|aa))+$` — the redundant
+ * wrapper the `((a+))+` entry above exists for — 15,426ms on 35ch, which is why
+ * the overlap propagates up through a wrapper exactly as the inner repeat does.
+ * Input-bounding is theater here for F49's own reason: tens of characters suffice.
+ *
+ * The detected core is the PREFIX RELATION between top-level branches (one branch
+ * a prefix of another, equality included — `(a|a)+` is the 2ⁿ case). Whether a
+ * given prefix overlap can actually be DRIVEN exponentially depends on what
+ * follows the group, and deciding that needs the real engine this file declined
+ * to take as a dependency — so the reject is conservative by construction, which
+ * is the fail-safe direction.
+ *
+ * MONOTONIC, and that is the rule this change lives under: it only ever ADDS
+ * rejections. Nothing above is narrowed, and no previously-rejected shape became
+ * admissible (asserted over the whole corpus in tests/plan.test.js). F49's
+ * "never sharpen the detector" bars chasing false POSITIVES; closing a false
+ * NEGATIVE by adding rejections is the opposite, allowed direction — distinct
+ * rules, not in tension (the `((a+))+` widening set the precedent).
  *
  * SCOPE IS ASYMMETRIC, both directions named on purpose:
- *   - false NEGATIVE: overlapping-alternation blowup (`(a|ab)+`-class) is not
- *     detected — there is no inner QUANTIFIER to find, so the shape scan cannot
- *     see it; the blowup comes from overlapping alternation BRANCHES under a
- *     repeat. A genuine limit of the approach, not a bug in it. Widening the
- *     detector changes which SIGNED specs are admissible, which is
- *     arbiter-adjacent — parked, not chased (PRD v1.55).
  *   - false POSITIVE: a group whose repetitions are disambiguated by a literal
  *     anchor/delimiter (`(?:^- .+$\n?)+`, `(?:CHANGELOG:.+\n)+`) is FLAGGED even
  *     though a real engine runs it linearly — the scan sees the nested-quantifier
@@ -221,13 +308,28 @@ function unboundedQuantLen(src, i) {
  *     and guessing it wrong would ADMIT an exponential pattern — so the shape
  *     reject stands, and the over-rejection is a named, accepted limitation.
  *
+ *     The alternation class has its OWN instance of the same limit, measured and
+ *     locked in `REDOS_OVERREJECTED_ALT`: `(ab|abc)+$`, `(x|xy|xyz)+$` and
+ *     `(x(a|aa))+$` carry the prefix relation and did NOT blow up on the bodies
+ *     measured (0.3–0.4ms at 41–91 characters). "Did not blow up on the body
+ *     measured" is the honest claim — no adversarial search was run for a worse
+ *     input — and rejecting them is again the direction that never admits an
+ *     exponential pattern.
+ *
  * The input is guaranteed to compile as a RegExp (checked first by the caller),
  * so this scan assumes valid, balanced JS regex syntax.
  * @param {string} src a compiled regex source string
- * @returns {boolean} true iff a nested unbounded quantifier is present
+ * @returns {boolean} true iff a nested unbounded quantifier, or an unboundedly
+ *   repeated group with overlapping alternation branches, is present
  */
 export function hasNestedQuantifier(src) {
-  /** @type {{ quant: boolean }[]} */
+  /** `quant`: the body repeats unboundedly. `alt`: the body (or a group beneath
+   * it) carries overlapping alternation branches. `at`: where the body starts,
+   * so the branches can be read back when the group closes. The two hazard flags
+   * are tracked separately and propagate separately — merging them would let a
+   * plain nested repeat be reported as an alternation overlap and vice versa,
+   * and the two are different rewrites for the author. */
+  /** @type {{ quant: boolean, alt: boolean, at: number }[]} */
   const stack = [];
   for (let i = 0; i < src.length; i++) {
     const c = src[i];
@@ -254,11 +356,19 @@ export function hasNestedQuantifier(src) {
       while (i < src.length && src[i] !== ']') { if (src[i] === '\\') i++; i++; }
       continue;
     }
-    if (c === '(') { stack.push({ quant: false }); continue; }
+    if (c === '(') { stack.push({ quant: false, alt: false, at: i + groupPrologueLen(src, i) }); continue; }
     if (c === ')') {
       const g = stack.pop();
       const qlen = unboundedQuantLen(src, i + 1);
       if (g && g.quant && qlen) return true;    // group repeats unboundedly AND its body did too
+      // …and the SECOND class: the body's own top-level branches overlap, so the
+      // engine has more than one way to consume the same text and an unbounded
+      // repeat multiplies those ways (MEASURED: `(a|aa)+$` 12.1s on a 35-char
+      // body). `g.alt` carries an overlap found in a group BENEATH this one, for
+      // the redundant-wrapper reason one comment down.
+      const overlap = !!g && (g.alt || altBranchesOverlap(src.slice(g.at, i)));
+      if (overlap && qlen) return true;
+      if (overlap && stack.length) stack[stack.length - 1].alt = true;
       // The group is an unbounded-repeated atom of its parent when it is directly
       // re-quantified (qlen) OR its own body already repeats unboundedly (g.quant):
       // a redundant wrapper — ((a+))+ , (?:(a+))* , (((\d*)))+ — is the SAME
@@ -276,3 +386,50 @@ export function hasNestedQuantifier(src) {
   }
   return false;
 }
+
+/**
+ * The catastrophic-backtracking reject, applied to a WHOLE signed document by
+ * tree walk — `sweepSecretLiterals`'s twin, and for its reason: some signed
+ * documents carry their regexes at a depth no per-field check enumerates.
+ *
+ * WHY IT EXISTS (PRD v1.60 §1, an OPEN GAP now closed). v1.55 took F49's reject
+ * to the operator's own regex fields, and the admissibility sweep that backed it
+ * walked `jobs/*.json`. That is not the population of signed specs: a REGISTRY
+ * BRIDGE is signed the same way, ships its plans VERBATIM (reuse stores the
+ * whole plan, never a template), and lives outside `jobs/`, so a pathological
+ * pattern arriving through a bridge was never swept. Nothing had decided
+ * bridge-borne patterns were safe — the sweep was written against the directory
+ * that held every spec at the time and was never re-aimed.
+ *
+ * WHAT is rejected is UNCHANGED: `hasNestedQuantifier`, one inventory, shared
+ * with job.js and plan.js. Only WHERE it looks is wider. Widening the DETECTOR
+ * is arbiter-adjacent and stays parked (F49); widening the POPULATION is this.
+ *
+ * KEY-SCOPED, deliberately. `pattern` and `gapKeep` are the exactly-three regex
+ * fields F49 names (`artifact-written.pattern`, `judged.pattern`, `gapKeep`);
+ * every other string in a signed document is prose, a path or a command, and
+ * running a regex-shape scan over prose would red goals for containing `(a+)+`
+ * in a sentence. A field carrying a regex under a NEW key is not swept until
+ * this list names it — stated so the limit is read rather than rediscovered.
+ *
+ * COMPILE-FIRST, like both per-field callers: the scan's contract is that its
+ * input is valid regex syntax, and a string that does not compile is the OTHER
+ * validator's red. Two reds on one string bury the real one.
+ * @param {any} root
+ * @param {(code: string, path: string, detail?: string) => void} red
+ */
+export function sweepNestedQuantifiers(root, red) {
+  (/** @type {(node: any, at: string, key: string) => void} */
+  function sweep(node, at, key) {
+    if (typeof node === 'string') {
+      if (key !== 'pattern' && key !== 'gapKeep') return;
+      try { new RegExp(node, 'm'); } catch { return; }
+      if (hasNestedQuantifier(node)) {
+        red('invalid-value', at, `catastrophic-backtracking risk: a nested unbounded quantifier (${node}) can hang the untimed evaluator on the MAIN event loop, where the in-process stall fuse cannot fire (F49). Rewrite the pattern — drop the outer repeat, or match once.`);
+      }
+      return;
+    }
+    if (Array.isArray(node)) node.forEach((v, i) => sweep(v, `${at}.${i}`, key));
+    else if (isObj(node)) for (const [k, v] of Object.entries(node)) sweep(v, at ? `${at}.${k}` : k, k);
+  })(root, '', '');
+}

package/types/authorflow.d.ts

@@ -149,6 +149,31 @@ export function declarationTool(box: {
  * @param {Record<string, any>} [catalogue]
  */
 export function catalogueBlock(catalogue?: Record<string, any>): string;
+/**
+ * HOW THE GENRE'S OWN TOOLS PRINT — rendered FROM `genreInstruments`, so the
+ * pattern the author is handed and the pattern the tree already grades with are
+ * one string.
+ *
+ * This block is the fix for run msmbpjk6: a parser for a tool WE OWN THE FACTS
+ * ABOUT was left to the model to compose, and it composed tsc's terminal-only
+ * shape against piped output — 0 matches on 67 real error lines. The delivery is
+ * deliberately the MANDATORY-GUARD delivery, not advice: the pattern arrives
+ * spelled out, marked genre property, with the real captured line beside it, in
+ * the same register as the guard battery that arrives already parameterised.
+ *
+ * It states the MECHANISM (pipe, not a terminal) rather than only the answer,
+ * because the same trap is waiting behind every tool that pretty-prints for a
+ * human, and only some of them are in the table yet. That prediction has since
+ * been paid off by measurement: `node --test` prints TAP down a pipe and the
+ * spec reporter on a terminal, the identical flip, on a second tool.
+ *
+ * Each row also carries its `capture`, because a count term and a tally term are
+ * read by DIFFERENT aggregates and the wrong pairing is a silent misreading, not
+ * an error — `first` over a line the tool omits on a good run reports a broken
+ * instrument. The block states that mapping once rather than per row.
+ * @param {string} lang
+ */
+export function instrumentsBlock(lang: string): string;
 /** The three laws. Stated to the author; enforced, where checkable, by M2. */
 export function lawsBlock(): string;
 /**
@@ -321,7 +346,10 @@ export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }: {
  * run could not be read afterwards. A cost entry with no raw beside it is that
  * run again.
  */
-export function makeCostBook(): {
+/** @param {{ceilingUsd?: number|null}} [o] the OPERATOR's ceiling; `null`/absent is UNBOUNDED */
+export function makeCostBook({ ceilingUsd }?: {
+    ceilingUsd?: number | null;
+}): {
     /** @param {string} label @param {any} r a bare-agent run result @param {number} [attempt] */
     add(label: string, r: any, attempt?: number): {
         label: string;
@@ -347,17 +375,28 @@ export function makeCostBook(): {
         reason: string | null;
     }[];
     report(): {
-        costUsd: number | null;
-        knownUsd: number;
-        spendComplete: boolean;
-        nullCostCalls: number;
-        unpricedRounds: number;
         calls: {
             label: string;
             costUsd: number | null;
             unpricedRounds: number;
         }[];
+        costUsd: number | null;
+        knownUsd: number;
+        spendComplete: boolean;
+        nullCostCalls: number;
+        unpricedRounds: number;
     };
+    /**
+     * THE CEILING'S OWN READING, asked between metered calls. The book is the one
+     * place this pipeline's spend accumulates, so it is the one place that can
+     * answer honestly — and it answers through the shared predicate rather than a
+     * second hand-spelled comparison (`src/text.js`, beside `priceOf`).
+     * @returns {'cap-halt'|'pricing-red'|null}
+     */
+    capStop(): "cap-halt" | "pricing-red" | null;
+    /** what was set, stated — `null` is "nobody set one", which is UNBOUNDED and
+     * a visible operator choice, never a defaulted number */
+    ceilingUsd: number | null;
 };
 /**
  * The default model boundary: one bare-agent Loop per call, with the declaration
@@ -406,13 +445,15 @@ export function makeLoopGenerate(provider: any, { system, maxTokens }?: {
  *
  * @param {{workdir: string, seedRef: string, lang: string, verdictType: string,
  *   answers: Record<string|number, string>, questions?: Record<string|number, string>,
- *   scout: {state: string, facts: any, reason?: string|null, calls?: any[], raws?: any[]},
+ *   scout: {state: string, facts: any, reason?: string|null, cause?: string|null, calls?: any[], raws?: any[],
+ *     budgetStop?: 'cap-halt'|'pricing-red'|null},
  *   listing?: {stop: string|null, files: string[]|null, block: string|null, meta: any}|null,
  *   generate: Function, seedReadFn?: Function, closeCtx?: any,
+ *   ceilingUsd?: number|null,
  *   maxRevisions?: number, structureRetries?: number,
  *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>}} o
  */
-export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, scout, listing, generate, seedReadFn, closeCtx, maxRevisions, structureRetries, structuredMode, catalogue, }: {
+export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, scout, listing, generate, seedReadFn, closeCtx, ceilingUsd, maxRevisions, structureRetries, structuredMode, catalogue, }: {
     workdir: string;
     seedRef: string;
     lang: string;
@@ -423,8 +464,10 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
         state: string;
         facts: any;
         reason?: string | null;
+        cause?: string | null;
         calls?: any[];
         raws?: any[];
+        budgetStop?: "cap-halt" | "pricing-red" | null;
     };
     listing?: {
         stop: string | null;
@@ -435,6 +478,7 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
     generate: Function;
     seedReadFn?: Function;
     closeCtx?: any;
+    ceilingUsd?: number | null;
     maxRevisions?: number;
     structureRetries?: number;
     structuredMode?: "tool" | "text";

package/types/authoring.d.ts

@@ -102,6 +102,60 @@ export function genreEnv(lang: string, { sourcePrefixes }?: {
  * one of them, because ownership is only real if it is mechanical.
  * @param {string} lang @returns {string[]} */
 export function genreOwnedEnvNames(lang: string): string[];
+/**
+ * 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: string): {
+    id: string;
+    what: string;
+    lineMatch: string;
+    capture: number | null;
+    example: string;
+    why: string;
+}[];
 /**
  * GROUNDING for a RECORDED genre environment — the provenance half of the
  * owned-env rule, and the reason the by-value comparison is worth anything.
@@ -368,6 +422,42 @@ export const TYPES_GENRE: Readonly<{
             /** no import-resolution hazard on this runner — an EMPTY list, declared,
              * never an absent field that would read as "not looked into" (F59) */
             env: readonly never[];
+            instruments: readonly (Readonly<{
+                id: "tsc-error-line";
+                what: "one type error, as the TypeScript checker prints it";
+                lineMatch: "error TS\\d+";
+                capture: null;
+                example: "src/backup.js(21,19): error TS7006: Parameter 'now' implicitly has an 'any' type.";
+                why: string;
+            }> | Readonly<{
+                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: string;
+            }> | Readonly<{
+                id: "node-test-pass-count";
+                what: "how many tests passed, off the TAP summary";
+                lineMatch: "^# pass (\\d+)$";
+                capture: 1;
+                example: "# pass 316";
+                why: string;
+            }> | Readonly<{
+                id: "node-test-fail-count";
+                what: "how many tests failed, off the TAP summary";
+                lineMatch: "^# fail (\\d+)$";
+                capture: 1;
+                example: "# fail 1";
+                why: string;
+            }> | Readonly<{
+                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: string;
+            }>)[];
         }>;
         python: Readonly<{
             suppressions: readonly (Readonly<{
@@ -393,6 +483,28 @@ export const TYPES_GENRE: Readonly<{
                 join: ":";
                 why: string;
             }>[];
+            instruments: readonly (Readonly<{
+                id: "mypy-error-line";
+                what: "one type error, as mypy prints it";
+                lineMatch: " error: ";
+                capture: null;
+                example: "packages/spawner/src/aurora_spawner/timeout_policy.py:89: error: Statement is unreachable  [unreachable]";
+                why: string;
+            }> | Readonly<{
+                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: string;
+            }> | Readonly<{
+                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: string;
+            }>)[];
         }>;
     }>;
 }>;

package/types/authorjob.d.ts

@@ -81,14 +81,14 @@ export function refuseLockedKind(kind: string): Refusal;
  * @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,
  *   closeDecl: any, seedRef: string|null, authoring: any, reds: Red[], stop: string|null,
  *   cost: any, interview: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, seedFn, scoutFn, listingFn, authorFn, authorOpts, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, seedFn, scoutFn, listingFn, authorFn, authorOpts, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
@@ -99,6 +99,7 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
     seedRef?: string | null;
     scout?: any;
     listing?: any;
+    ceilingUsd?: number | null;
     seedFn?: Function;
     scoutFn?: Function;
     listingFn?: Function;

package/types/authorscout.d.ts

@@ -91,13 +91,14 @@ export function defaultSurveyor({ workdir, granted, auditPath, ctx }: {
  *
  * @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 function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, createLoop, createSurveyor, }: {
+export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, createLoop, createSurveyor, }: {
     workdir: string;
     provider?: any;
     rounds?: number;
@@ -106,6 +107,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
     maxTokens?: number;
     ctx?: boolean;
     attempts?: number;
+    ceilingUsd?: number | null;
     createLoop?: (o: {
         system: string;
         policy: any;
@@ -125,6 +127,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         costUsd: number | null;
         unpricedRounds: number;
     }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
 }>;
 /**
  * `git ls-tree -r --name-only <seed>` — the files as of the SEED COMMIT.
@@ -249,6 +252,16 @@ export const SURVEY_CAUSES: Readonly<{
     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";
 }>;
 /**
  * THE MALFORMED CLASS — the only causes a retry fires on.

package/types/index.d.ts

@@ -12,7 +12,7 @@ export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBr
 export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES } from "./ledger.js";
 export { workBranchName, prepareWorkBranch, WORK_BRANCH_PREFIX, WORK_BRANCH_RE } from "./workbranch.js";
 export { runDeclaredClose, runStage, seedRead, seedAtHead, seedListing, changedSet, makeSeedTrees, LIVE_KINDS, STOP_FAULTS, JUDGED_MARKER, EXIT_GREEN, EXIT_RED, EXIT_STOP } from "./kinds.js";
-export { validateDeclaration, normalizeDeclaration, KIND_CATALOGUE, CATALOGUE_KINDS, CATALOGUE_LIVE_KINDS, LOCKED_KINDS, TYPES_GENRE, TYPES_GENRE_TEMPLATE, GENRE_LANGUAGES, genreEnv, genreOwnedEnvNames, DIRECTIONS, BASELINES, MAX_STAGES, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling } from "./authoring.js";
+export { validateDeclaration, normalizeDeclaration, KIND_CATALOGUE, CATALOGUE_KINDS, CATALOGUE_LIVE_KINDS, LOCKED_KINDS, TYPES_GENRE, TYPES_GENRE_TEMPLATE, GENRE_LANGUAGES, genreEnv, genreOwnedEnvNames, genreInstruments, DIRECTIONS, BASELINES, MAX_STAGES, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling } from "./authoring.js";
 export { runAuthorScout, buildSeedListing, seedFileList, classifySurvey, AUTHOR_SCOUT_VERBS, SCOUT_ATTEMPTS, SURVEY_CAUSES, SCOUT_RETRY_CAUSES } from "./authorscout.js";
 export { scrubRaw, RAW_PERSIST_MAX, RAW_TRIM_MARKER } from "./text.js";
 export { authorClose, authorPrompt, declarationSchema, makeLoopGenerate, MAX_REVISIONS, QUESTION_SETS, GREEN_QUESTIONS, CLASS_STATEMENTS, questionsFor, requiredAnswersFor } from "./authorflow.js";

package/types/kinds.d.ts

@@ -36,15 +36,25 @@ export function seedListing(workdir: string, seedRef: string): Promise<{
     files: string[];
 }>;
 /**
- * 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
  */
@@ -146,13 +156,36 @@ export function normalizeParser(parser: any, at?: string): {
  * 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: string, terms: any[], { scope, workdir }?: {
     scope?: any;
@@ -167,6 +200,7 @@ export function parseValue(output: string, terms: any[], { scope, workdir }?: {
     breakdown: any[];
     notes: string[];
     preScopeMatches: number;
+    matched: string[][];
 };
 /**
  * A caller-scoped holder for detached seed worktrees. Scoped rather than
@@ -296,6 +330,24 @@ export const SIGNS: readonly number[];
  * counted demand (the request-red path), and reaching one at runtime is a
  * stop — never a red, and never a silent pass. */
 export const LIVE_KINDS: readonly string[];
+/**
+ * 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: readonly string[];
 export type Red = {
     code: string;
     path: string;