bareloop 0.6.0 → 0.8.0

package/types/bridges.d.ts

@@ -0,0 +1,198 @@
+/**
+ * D6's status ladder, walked in history order. Pure, total, and never throws —
+ * it is called on whatever a file happens to contain.
+ *
+ * - **candidate** — at least one green.
+ * - **proven** — greens on ≥2 DISTINCT patients (R2: the same SHAPE on a second
+ *   instance; two greens on ONE patient is a lookup table, which the memorization
+ *   audit kills).
+ * - a **red** on a PROVEN entry drops it to candidate, and re-promotion then needs
+ *   greens on two distinct patients AGAIN — that is what "until a new green on a
+ *   second distinct patient re-proves" means, so the demoting red clears the
+ *   distinct-patient set rather than leaving the old count standing to re-promote
+ *   the entry on the first repeat green.
+ * - a red on a CANDIDATE changes nothing: there is nothing below the entry bar, and
+ *   the entry stays in the record with the red beside it.
+ * - a **CASUALTY is not a red.** Only the literal outcome `'red'` demotes; every
+ *   other non-green outcome (`provider-red`, `wall-halt`, `close-crashed`, …) is a
+ *   casualty, and casualties are never evidence in either direction.
+ *
+ * @param {unknown} history the bridge's per-run rows, oldest first
+ * @returns {'candidate'|'proven'|null} null = below the entry bar (no green yet)
+ */
+export function deriveStatus(history: unknown): "candidate" | "proven" | null;
+/**
+ * Validate a bridge entry (`schema: "bridge-v1"`). Never throws on JSON text or
+ * plain parsed data — the same ingest contract both config validators hold; every
+ * failure is a named red. Returns the parsed entry on ok, null on any red.
+ * @param {object|string|unknown} input parsed entry, or raw JSON text
+ * @returns {{ ok: boolean, reds: Red[], bridge: any }}
+ */
+export function validateBridge(input: object | string | unknown): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+};
+/**
+ * FIRST GREEN MINTS: build a new registry entry from one green. The entry bar is
+ * a green (D6) — there is deliberately no way to create an entry without one, so
+ * a failed plan cannot enter the registry even by accident.
+ * @param {unknown} meta `{ name, goal, specHash, closeStageNames, toolsUsed }` —
+ *   `specHash` may be an explicit null (one probe-era bridge on disk has none), and
+ *   the KEY is required so an unknown hash has to be said rather than omitted.
+ * @param {unknown} record `{ runid, patient, at, plan, costUsd, spendComplete, wallMs, rounds, specHash? }`
+ * @returns {{ ok: boolean, reds: Red[], bridge: any }}
+ */
+export function mintBridge(meta: unknown, record: unknown): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+};
+/**
+ * A green on an EXISTING bridge: the plan AS EXECUTED becomes its next version,
+ * and the run gets a history row. Pure — returns a NEW entry; the input is never
+ * mutated, so a caller that reds still holds the bridge it read from disk.
+ * @param {unknown} bridge a validated bridge entry
+ * @param {unknown} record `{ runid, patient, at, plan, costUsd, spendComplete, wallMs, rounds, specHash? }`
+ * @returns {{ ok: boolean, reds: Red[], bridge: any }}
+ */
+export function appendGreen(bridge: unknown, record: unknown): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+};
+/**
+ * A red (or a casualty): a history row ONLY. R1 — the bridge file is never edited
+ * in place by a red; the recipe that greened stays exactly as it greened, and the
+ * status derivation reads the demotion off the history.
+ * @param {unknown} bridge a validated bridge entry
+ * @param {unknown} record `{ runid, patient, at, outcome, failingStage, costUsd, spendComplete, wallMs, rounds }`
+ * @returns {{ ok: boolean, reds: Red[], bridge: any }}
+ */
+export function appendRed(bridge: unknown, record: unknown): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+};
+/**
+ * One row of D3's listing: what the user (and the selecting LLM) sees per bridge —
+ * name, the job sentence it greened, status, greens/reds, and the cost/time BAND of
+ * its greens. Deliberately no score (D6).
+ *
+ * The cost band SKIPS unknowns and says how many it skipped: an aggregate that
+ * treats a null as 0 reports a floor that reads as exact, which is F6 in an honest
+ * coat. With no priced green at all, every bound is null — never 0.
+ *
+ * Total and never throws: the listing is a display surface, and one malformed
+ * entry must not take the whole listing down (loadRegistry already reports it).
+ * @param {unknown} bridge
+ * @returns {{name: string|null, goal: string|null, status: 'candidate'|'proven'|null, greens: number, reds: number, lastOutcome: string|null, greenCost: {minUsd: number|null, maxUsd: number|null, minWallMs: number|null, maxWallMs: number|null, unpricedCount: number, untimedCount: number}}}
+ */
+export function listingRow(bridge: unknown): {
+    name: string | null;
+    goal: string | null;
+    status: "candidate" | "proven" | null;
+    greens: number;
+    reds: number;
+    lastOutcome: string | null;
+    greenCost: {
+        minUsd: number | null;
+        maxUsd: number | null;
+        minWallMs: number | null;
+        maxWallMs: number | null;
+        unpricedCount: number;
+        untimedCount: number;
+    };
+};
+/**
+ * D2's LOAD-TIME gate, as SPLIT by the 2026-08-01 addendum. Exactly three checks —
+ * *"is this the right KIND of recipe?"*, asked at the box:
+ *
+ *  1. **verdict type matches.** v1 admits `green` only, and a bridge only ever
+ *     exists because a green minted it, so the bridge side is `green` by
+ *     construction and the check reads the JOB's declared type. **The day a second
+ *     verdict class is admitted, the bridge entry must carry its own verdictType
+ *     and this becomes a two-sided comparison** — recorded here so it cannot be
+ *     quietly assumed to already be one.
+ *  2. **close-stage KINDS match.** v1 simplification: the same stage NAMES in the
+ *     same ORDER is the definition of the same kinds. The probes' R2-legal pair
+ *     matched on four identical stage names over different patients, which is the
+ *     material this rule was ruled on; a real kind-comparison (what each stage
+ *     INSPECTS, independent of what it was named) is a later rung's problem and is
+ *     not pretended here.
+ *  3. **every stored verb fits THIS job's signed menu.** An omitted `tools` means
+ *     the concrete current TOOL_MENU — the same predicate `resolveSpec` and
+ *     `validatePlan` read (MED-1), so what the gate judges is what was signed.
+ *
+ * **NOTHING about paths, scopes or targets.** Those are instance-bound and are
+ * EXPECTED to red: every recipe from a different day names yesterday's bricks, and
+ * that is what a recipe IS, not a flaw. The pre-probe measured the drafter
+ * replacing them unaided (3/3 legal after tweak), while the gate as originally
+ * frozen would have refused all six of them at the door. The full `validatePlan`
+ * still judges the TWEAKED draft at draft time — nothing executes unvalidated, and
+ * no second, looser path exists for an inherited plan (D4).
+ *
+ * A failing gate is the **recipe-stale / wrong-kind** OUTCOME — a distinct result
+ * with cold drafting offered, never a throw.
+ * @param {unknown} bridge
+ * @param {unknown} job the validateJob-green spec this run is signed against
+ * @returns {{ ok: boolean, reds: Red[] }}
+ */
+export function loadGate(bridge: unknown, job: unknown): {
+    ok: boolean;
+    reds: Red[];
+};
+/**
+ * Read one bridge file. Never throws — a missing/unreadable file and a malformed
+ * one are both named reds, because the registry is read at selection time and one
+ * bad file must not take the run down.
+ * @param {string} file
+ * @returns {{ ok: boolean, reds: Red[], bridge: any }}
+ */
+export function loadBridge(file: string): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+};
+/**
+ * Read a whole registry directory. A malformed entry is SKIPPED AND REPORTED —
+ * one red per bad file, the good entries still returned, sorted by name for a
+ * stable listing. `ok` is false when anything was skipped, so a caller can surface
+ * the skip instead of silently listing fewer workflows than exist on disk.
+ * @param {string} dir the operator-supplied registry path (no default location)
+ * @returns {{ ok: boolean, reds: Red[], bridges: any[] }}
+ */
+export function loadRegistry(dir: string): {
+    ok: boolean;
+    reds: Red[];
+    bridges: any[];
+};
+/**
+ * Write one bridge entry, ATOMICALLY (temp + rename): a registry read concurrent
+ * with a write must see the old entry or the new one, never a half-written file
+ * that then reads as a malformed skip. An INVALID entry is refused before anything
+ * touches the disk — the registry never holds a file its own validator rejects.
+ * @param {string} dir the operator-supplied registry directory (must exist)
+ * @param {unknown} bridge
+ * @returns {{ ok: boolean, reds: Red[], file: string|null }}
+ */
+export function saveBridge(dir: string, bridge: unknown): {
+    ok: boolean;
+    reds: Red[];
+    file: string | null;
+};
+/**
+ * Create a registry directory. Separate from `saveBridge` ON PURPOSE: saving must
+ * never conjure a registry from a typo'd path, so making one is an explicit act.
+ * @param {string} dir
+ * @returns {string} the directory
+ */
+export function makeRegistry(dir: string): string;
+/** @param {string} dir @returns {boolean} does a registry directory exist */
+export function registryExists(dir: string): boolean;
+export const BRIDGE_SCHEMA: "bridge-v1";
+export type Red = {
+    code: string;
+    path: string;
+    detail?: string;
+};

package/types/clock.d.ts

@@ -20,6 +20,14 @@
  * the same (raise `maxWallMs`), and the alternative — calling a governance stop
  * transport on the chance that it was — is the failure this closes.
  *
+ * BOTH derived bounds land here, because both are derived from the same wall:
+ * BA-18's idle timeout (`callTimeoutMs`) and BA-19's total-duration deadline
+ * (`callDeadlineMs`). Adding the second CODE does not widen the rule — the
+ * discriminator is still `clock.expired()`, never the code. That matters for the
+ * deadline specifically: a provider someone else constructed with its own
+ * `deadlineMs` could throw this code on a run with time left, and that is transport,
+ * exactly as it was before.
+ *
  * @param {any} err the throw as caught
  * @param {Clock} clock the run's clock
  * @returns {boolean}
@@ -35,22 +43,25 @@ export function isWallTimeout(err: any, clock: Clock): boolean;
  * @property {() => boolean} expired whether the deadline has passed (always false when unbounded)
  * @property {(closeTimeoutMs: number) => number|null} enforcedMs the HONEST worst case
  * @property {(providerDefaultMs?: number) => number} callTimeoutMs the derived per-call bound
+ * @property {() => number|null} callDeadlineMs the derived per-call TOTAL-duration ceiling; `null` when unbounded
  * @property {(closeTimeoutMs: number) => object} report one spine-safe shape carrying both numbers
  */
 /**
  * Start a wall clock for one run.
- * @param {{ maxWallMs?: number|null, closeStages?: number, now?: () => number }} [opts]
+ * @param {{ maxWallMs?: number|null, closeStages?: number, now?: () => number, priorElapsedMs?: number }} [opts]
  *   `maxWallMs`: the signed operator cap, or absent/null for an honestly unbounded
  *   run. `closeStages`: how many stages the job's close runs (W5) — each one gets
  *   the FULL `closeTimeoutMs`, so this is the multiplier on the overshoot, not a
  *   decoration. Defaults to 1, the single-predicate close. `now`: injected for
- *   tests — the default is the real clock.
+ *   tests — the default is the real clock. `priorElapsedMs`: time this attempt's
+ *   PREDECESSOR already consumed (see below).
  * @returns {Clock}
  */
-export function createClock({ maxWallMs, closeStages, now }?: {
+export function createClock({ maxWallMs, closeStages, now, priorElapsedMs }?: {
     maxWallMs?: number | null;
     closeStages?: number;
     now?: () => number;
+    priorElapsedMs?: number;
 }): Clock;
 /** BA-18's default request/idle timeout (`AnthropicProvider.timeoutMs`), the
  * ceiling every derived per-call timeout starts from. Kept in sync deliberately:
@@ -69,6 +80,13 @@ export const MIN_CALL_TIMEOUT_MS: 30000;
  * `category`, so every consumer that defaults an uncategorised throw would file
  * it as transport. */
 export const TIMEOUT_CODE: "ETIMEDOUT";
+/** bare-agent's rejection code when its TOTAL-duration deadline trips (BA-19,
+ * `provider-http.js` → `applyRequestDeadline`). A DIFFERENT code from the idle
+ * bound's on purpose — upstream splits them precisely so a consumer routing
+ * governance stops apart from transport casualties can tell which timer fired. Like
+ * `TIMEOUT_CODE` it carries no `category`, so every default-to-transport catch site
+ * would file it as a casualty. */
+export const DEADLINE_CODE: "EDEADLINE";
 export type Clock = {
     /**
      * whether the operator set a cap at all
@@ -102,6 +120,10 @@ export type Clock = {
      * the derived per-call bound
      */
     callTimeoutMs: (providerDefaultMs?: number) => number;
+    /**
+     * the derived per-call TOTAL-duration ceiling; `null` when unbounded
+     */
+    callDeadlineMs: () => number | null;
     /**
      * one spine-safe shape carrying both numbers
      */

package/types/exits.d.ts

@@ -36,6 +36,20 @@ export function evalExits(exits: Array<Record<string, any>>, { dir, snapshot, ru
     pass: boolean;
     results: ExitResult[];
 }>;
+/** The check gap is ALREADY bounded upstream by runClose's boundGap (head +
+ * gapKeep block ≤ 8192 + tail ≈ 10KB, with the failing-test NAMES preserved).
+ * The evaluator must NOT re-truncate it: a 400-char clamp deletes exactly those
+ * `not ok`/`FAILED` names — the mechanical gap the F46 conversion mechanism
+ * feeds the worker (F28 reintroduced). This cap is a defensive backstop above
+ * boundGap's own envelope: a normal bounded gap passes through intact, and only
+ * a pathological seam that returned an unbounded gap would ever be trimmed.
+ *
+ * Exported for the ONE reason `boundGap`/`GAP_KEEP_TRIM_MARKER` are (src/ralph.js):
+ * the replan brief re-bounds this same artifact one seam later (`closeGapBlock`), and
+ * a second hand-spelled ceiling there would be a second answer to "how big may a
+ * check gap be" — the two would drift on exactly the property that matters, whether
+ * the `not ok`/`FAILED` names survive. */
+export const CHECK_GAP_MAX: 12000;
 /**
  * `fault` present means the INSTRUMENT could not judge (unwired snapshot/seam,
  * a check in runClose's forbidden zone) — it carries the runClose verdict name

package/types/index.d.ts

@@ -6,4 +6,7 @@ export { globToPrefix, scanSecrets } from "./validate.js";
 export { validateJob, jobSpecHash, checkApproval, checkMenu, CLOSE_TYPES, CLASS_BY_CLOSE, GOLD_COMPARE, CADENCE_UNITS, PROVIDERS, CONDITION_KEYS, TOOL_MENU, LOCKED_TOOLS, STORE_VERBS, VERDICT_TYPES, LOCKED_VERDICTS } from "./job.js";
 export { validatePlan, stageClose, EXIT_TYPES, MAX_EXITS_PER_STEP, MAX_PLAN_STEPS, WRITE_VERBS } from "./plan.js";
 export { snapshotScope, evalExits } from "./exits.js";
+export { BRIDGE_SCHEMA, validateBridge, deriveStatus, listingRow, loadGate, mintBridge, appendGreen, appendRed, loadBridge, loadRegistry, saveBridge, makeRegistry, registryExists } from "./bridges.js";
+export { renderListing, selectionPrompt } from "./selection.js";
+export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate } from "./reuse.js";
 export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES } from "./ledger.js";

package/types/job.d.ts

@@ -1,4 +1,9 @@
-/** @typedef {{code: string, path: string, detail?: string, verb?: string}} Red — `verb` rides request-reds as structured data (the ledger keys on it, never on prose) */
+/** @typedef {{code: string, path: string, detail?: string, verb?: string, lib?: string}} Red — `verb` and `lib` ride request-reds as structured data (the ledger keys on them, never on prose).
+ * `lib` is the TERRITORY the demand lands against, stamped HERE at the emit site
+ * (the typed-lib rule): one code, two catalogues — a locked TOOL verb is demand
+ * against the worker-surface package, a locked VERDICT type is demand against
+ * bareloop's OWN menu. Inferring it downstream is how a bareloop refusal gets
+ * filed as an upstream bug (the BA-2 misattribution class). */
 /**
  * Validate an operator-owned job spec (`schema: "job-v1"`). Never throws on
  * JSON text or plain parsed data — the ingest contract; a live object with a
@@ -165,11 +170,17 @@ export const PROVIDERS: readonly string[];
  * not duplicated here). */
 export const CONDITION_KEYS: readonly string[];
 /**
- * — `verb` rides request-reds as structured data (the ledger keys on it, never on prose)
+ * — `verb` and `lib` ride request-reds as structured data (the ledger keys on them, never on prose).
+ * `lib` is the TERRITORY the demand lands against, stamped HERE at the emit site
+ * (the typed-lib rule): one code, two catalogues — a locked TOOL verb is demand
+ * against the worker-surface package, a locked VERDICT type is demand against
+ * bareloop's OWN menu. Inferring it downstream is how a bareloop refusal gets
+ * filed as an upstream bug (the BA-2 misattribution class).
  */
 export type Red = {
     code: string;
     path: string;
     detail?: string;
     verb?: string;
+    lib?: string;
 };

package/types/ladder.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Normalize a gap for comparison. Deliberately NARROW: only bytes a re-run changes
+ * on its own are removed. Error COUNTS, file names and line numbers all survive —
+ * a trajectory like "30 errors" → "22 errors" must read as two different gaps, and
+ * a normalizer that scrubbed numbers would turn the converging case this module
+ * exists to protect into an instant strike.
+ * @param {string} text @returns {string}
+ */
+export function normalizeGap(text: string): string;
+/**
+ * The comparable key for a gap: the normalized text, hashed. Hashed rather than
+ * kept whole because the seen-set lives for the whole step and a close's output
+ * can be tens of KB — and because the set holds no content, nothing here can leak
+ * model or file bytes into a record.
+ * @param {string} text @returns {string}
+ */
+export function gapKey(text: string): string;
+/**
+ * Build one ladder. ONE PER STEP: the seen-set and the strike count are the step's
+ * own history, and a ladder shared across steps would strike a fresh step for a gap
+ * an earlier one had already seen.
+ *
+ * @param {object} opts
+ * @param {number} [opts.limit] strikes that end the step (default `STRIKE_LIMIT`)
+ * @param {() => number} opts.writeCount the CUMULATIVE count of the worker's
+ *   allow-decision write/edit records so far this step (planrun reads it off the
+ *   gate audit). Required, and a throw when it is missing rather than a silent
+ *   degradation to repeats-only: a strike rule running on one of its two signals
+ *   with nothing on the record saying so is the blind-instrument class, and this
+ *   is the BA-4 param-guard class where a throw is the right answer.
+ */
+export function createLadder({ limit, writeCount }: {
+    limit?: number | undefined;
+    writeCount: () => number;
+}): {
+    /**
+     * Read one RED iteration. Called by ralph after the judge has rendered a
+     * non-green, non-fault verdict — a green never reaches here, so every reading
+     * is a failing iteration by construction.
+     * @param {{iteration: number, gap?: string}} o
+     * @returns {{governor: string, iteration: number, strike: boolean, strikes: number,
+     *   limit: number, wrote: boolean, repeatOf: number|null, distinctGaps: number}}
+     */
+    record({ iteration, gap }: {
+        iteration: number;
+        gap?: string;
+    }): {
+        governor: string;
+        iteration: number;
+        strike: boolean;
+        strikes: number;
+        limit: number;
+        wrote: boolean;
+        repeatOf: number | null;
+        distinctGaps: number;
+    };
+    /** has the step run out of strikes? */
+    struckOut: () => boolean;
+    /** the ladder's own books — counts and iteration numbers, never gap content */
+    report: () => {
+        iterations: number;
+        strikes: number;
+        limit: number;
+        distinctGaps: number;
+        repeats: {
+            at: number;
+            firstAt: number;
+        }[];
+        idle: number[];
+    };
+    /**
+     * The mechanism, in one sentence, for the replan brief. It is the only channel
+     * the redrafting planner adapts to, so it states WHICH shape ended the step and
+     * the evidence for it — never a label on its own, and never a culprit file
+     * beyond what the close itself reported (F28): the inputs here are iteration
+     * numbers and counts, so naming one is inexpressible.
+     * @returns {string}
+     */
+    brief(): string;
+};
+/**
+ * The strike ceiling. Shell-owned, exactly where the fixed count was: the runner
+ * sets it, the agent cannot express it, and it is arbiter territory — a step's own
+ * plan may not tighten it and may not raise it. Two is hamr's number.
+ */
+export const STRIKE_LIMIT: 2;

package/types/plan.d.ts

@@ -24,42 +24,6 @@
  * @returns {string[]} the offerable scopes, deduped, shallowest-first, capped
  */
 export function legalScopes(writeScope: string[], dirs?: string[], cap?: number): string[];
-/**
- * F49 — a heuristic reject for the catastrophic-backtracking footgun: an
- * unbounded quantifier applied to a group whose body itself repeats unboundedly
- * (`(a+)+`, `(\d*)*`, `([a-z]+){1,}`) — including through a redundant wrapping
- * group (`((a+))+`, `(?:(a+))*`), which is the SAME exponential class as `(a+)+`
- * and is caught by propagating the inner repeat up through the wrapper. Such a
- * pattern can hang `RegExp.test` for
- * seconds on a short crafted body, and `evalExits` runs the agent-authored
- * `artifact-written` pattern with NO timeout. This is self-DoS only — the agent
- * authors both the pattern and (via the worker) the artifact, so a hang burns
- * only its own run's wall-clock; there is NO arbiter compromise (it cannot
- * escape the fence, forge a green, or leak a secret). 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.
- *
- * SCOPE IS ASYMMETRIC, both directions named on purpose:
- *   - false NEGATIVE: overlapping-alternation blowup (`(a|ab)+`-class) is not
- *     detected — out of scope (self-DoS only, no arbiter compromise).
- *   - 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
- *     SHAPE, not the disambiguation. Rejecting it is the FAIL-SAFE direction (it
- *     never admits an unsafe pattern), and the cost is bounded: the plan drafter
- *     gets a mechanical gap and rewrites (drop the outer `+`, or match once).
- *     Detecting "safe because anchored" needs the same real engine we declined,
- *     and guessing it wrong would ADMIT an exponential pattern — so the shape
- *     reject stands, and the over-rejection is a named, accepted limitation.
- *
- * 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
- */
-export function hasNestedQuantifier(src: string): boolean;
 /**
  * The close, as the ordered STAGE LIST the plan flow actually executes (PRD
  * v1.28). A staged close is already that list; the legacy object form is the
@@ -90,7 +54,7 @@ export function stageClose(close: any): any[] | null;
  * job spec. Never throws on JSON text or plain parsed data; every failure is
  * a named red. Returns the parsed plan on ok (single parse), null on any red.
  * @param {object|string} input parsed plan, or raw JSON text (parse failures are a red)
- * @param {{ job?: any, maxStepRounds?: number, scopes?: string[], capRuns?: number }} [opts] `job`: the
+ * @param {{ job?: any, maxStepRounds?: number, scopes?: string[], seedRed?: string[], priorChecks?: string[] }} [opts] `job`: the
  *   validateJob-GREEN four-field spec (the ceiling, the fence, and the checks
  *   menu all come from it — a missing or non-plan-shape job fails CLOSED);
  *   `maxStepRounds`: the shell's per-step rounds ceiling (interpret's
@@ -98,13 +62,28 @@ export function stageClose(close: any): any[] | null;
  *   `scopes`: the offered `tree-changed` menu from `legalScopes` (the SAME array
  *   the drafting prompt enumerated). Omitted, it derives from the signed
  *   writeScope — never a free-text fallback (F50).
+ *
+ *   The two shape-lottery gate rules (2026-08-04) — both keyed on RECORDED
+ *   facts, never an LLM judgment of "is this job small", and both inactive
+ *   when their fact is omitted (resume/reuse callers stay byte-identical):
+ *   `seedRed`: check names whose PREFLIGHT verdict was needs_revision. Rule
+ *   A-v2 — a seed-red check is the goal itself, not a milestone; it may only
+ *   sit on the plan's FINAL write step (`check-placement`). The $0 archive
+ *   sweep: seed-red-check-on-an-early-step has 0 honest greens ever; the one
+ *   wide closing step greens 7/7. Green-at-seed checks stay free mid-plan
+ *   (the 20 TESTGEN mid-plan greens — a guard, not a goal).
+ *   `priorChecks`: the check names the PREDECESSOR plan carried (replan gate
+ *   only). Rule B — a redraft may not drop one (`check-shed`): exits without
+ *   the check verify FORM alone, so a shed lets the run "green" unearned
+ *   (u-msdsmkid mechanism b; the 3 archived sheds were all on step-red runs).
  * @returns {{ ok: boolean, reds: Red[], plan: object|null }}
  */
-export function validatePlan(input: object | string, { job, maxStepRounds, scopes, capRuns }?: {
+export function validatePlan(input: object | string, { job, maxStepRounds, scopes, seedRed, priorChecks }?: {
     job?: any;
     maxStepRounds?: number;
     scopes?: string[];
-    capRuns?: number;
+    seedRed?: string[];
+    priorChecks?: string[];
 }): {
     ok: boolean;
     reds: Red[];
@@ -120,7 +99,6 @@ export const MAX_EXITS_PER_STEP: 2;
 /** plan size bound — per-step rounds bound the spend, but an unbounded step
  * COUNT is still an unbounded claim on the wallet; same 8 as loop.maxIterations */
 export const MAX_PLAN_STEPS: 8;
-export { WRITE_VERBS };
 /** scope-menu bound: the menu is a PROMPT ingredient on every draft and
  * redraft, so an unbounded repo would price the drafting call by its directory
  * count. Shallow entries survive the cap (see `legalScopes`) because they are
@@ -130,7 +108,27 @@ export const MAX_SCOPE_MENU: 24;
  * construction — the agent picks a tier, never names an arbitrary model string
  * (the tier→model mapping and any effort params are the RUNNER's, per provider).
  * opus is deliberately absent: reserved for fresh builds hamr explicitly assigns,
- * never plan-selectable. */
+ * never plan-selectable.
+ *
+ * 2026-08-06 — haiku dropped, on hamr's order: "haiku should be dropped to see if
+ * it passes, if it's agent poor work or harness, like always." This is a REVERSIBLE
+ * ATTRIBUTION PROBE, not a finding that haiku is incapable. What the $0 archive read
+ * (186 spines / 71 accepted plans / 255 steps) actually shows is a CONFOUND, in both
+ * directions: only 20 steps ever declared a tier at all — haiku 12 (9 of them on a
+ * REPLANNED plan, 6 the LAST step of their plan, bounds 3–12 rounds, 2 ever green)
+ * against explicitly-declared sonnet 8 (bounds 14–32, 5 green). The planner picks
+ * haiku for steps it judges mechanical, and replanned steps sit on runs already in
+ * trouble, so neither column is a controlled read. All three bareagent-u runs of
+ * 2026-08-06 tiered the REPLANNED step down (haiku/6, haiku/8, haiku/12) and all
+ * three failed, against sonnet initial steps at 30–40 rounds — a confound sitting
+ * on the programme's most recent capability read. Removing the tier is how it gets
+ * attributed: with only one tier expressible, a still-failing replan is agent or
+ * harness, not the tier.
+ *
+ * The `model` FIELD and its validator branch stay: a one-entry menu means a plan (or
+ * a stored bridge) declaring `model:"sonnet"` still validates, and restoring haiku is
+ * a one-token edit. This narrows only what the AGENT may express — `--model haiku`
+ * remains the OPERATOR's probe knob (PRD v1.36), untouched in the runner scripts. */
 export const STEP_MODELS: readonly string[];
 export type Red = {
     code: string;
@@ -139,3 +137,5 @@ export type Red = {
     verb?: string;
 };
 import { WRITE_VERBS } from './job.js';
+import { hasNestedQuantifier } from './validate.js';
+export { WRITE_VERBS, hasNestedQuantifier };