bareloop 0.5.1 → 0.7.0

package/types/run.d.ts

@@ -27,32 +27,68 @@
  * @param {object} opts
  * @param {unknown} opts.approvals `{ specHash, signer, ts }` records (from OUTSIDE the spec)
  * @param {string} opts.workdir the run directory (the fence's root)
- * @param {string} [opts.target] the step artifact path (text-mode steps; unused by tool-mode steps)
  * @param {any} opts.provider shell-owned LLM binding (never the config's; the Loop path)
  * @param {(o: {policy: Function, onTurn?: Function, maxTurns: number, hasTools: boolean}) => any} [opts.nativeProvider]
  *   native clipipe provider factory (BA-16), required for a `clipipe-subscription` plan-shape job —
  *   threaded to runPlan, which builds one per worker (native tool mode when `hasTools`, else a
  *   metered claude-json text provider for the toolless drafter); ignored on every Loop-driven provider
  * @param {(type: string, data?: object) => object} opts.emit spine emitter
- * @param {number} [opts.capRuns] shell-owned per-step iteration cap
+ * @param {(tier: string) => any} [opts.providerFor] P: per-step model-tier provider factory (forwarded to the plan flow)
+ * @param {number} [opts.capRuns] shell-owned iteration cap for the plan flow's
+ *   CLOSE-FIX loop (a plan STEP runs under the strike ladder instead)
+ * @param {number} [opts.strikeLimit] shell-owned strike ceiling for a plan step's ladder
  * @param {number} [opts.shellCapUsd] the shell's hard USD ceiling
  * @param {number} [opts.closeTimeoutMs] close wall-clock cap (shell territory)
- * @param {ExecCmd} [opts.execCmd] process runner for the hitl PR mechanics
+ * @param {unknown} [opts.bridge] Layer 3 — a bridge-v1 entry to reuse as the drafter's
+ *   STARTING DRAFT (design record 2026-08-01, D4), forwarded to the plan flow. Omitted is
+ *   the cold path and is byte-identical to a pre-Layer-3 run. WHICH entry (the listing, an
+ *   operator pin, the LLM's pick) is the caller's decision, and so is what to do when the
+ *   load gate refuses one: a refusal returns the distinct `recipe-stale` outcome with zero
+ *   spend rather than silently drafting cold, because starting a paid run on a decision
+ *   nobody made is the same class of error as widening a cap to manufacture a green.
+ * @param {number} [opts.priorSpentUsd=0] RESUME (module C) — money a PREVIOUS, killed
+ *   attempt of this same try already spent. It seeds the ledger, so the restarted
+ *   attempt runs under the REMAINDER of the signed `budgetUsd` and the terminal
+ *   `job-end` states the try's WHOLE spend across both attempts. hamr's ruling: "a
+ *   budget ceiling folds in prior spend so re-invoking cannot silently widen it" —
+ *   the fold is the seam precisely because the CAP is in the spec hash, so
+ *   tightening the cap instead would make a new spec version needing a signature
+ *   nobody typed. The caller reconstructs the figure from the dead run's own spine.
+ * @param {boolean} [opts.priorSpendComplete=true] RESUME — was that fold EXACT?
+ *   `readResume` reports false when any round inside the dead attempt came back
+ *   unpriced, which makes the fold a FLOOR. The unknown does not heal by being carried
+ *   forward, so it rides one-way onto every `job-end` this run emits: a total built on
+ *   a floor is a floor, and reporting it as exact is F6 in a resume's coat.
+ * @param {number} [opts.priorWallMs=0] RESUME — the same ruling in a time coat: wall
+ *   time the killed attempt already consumed, folded into the run clock so the
+ *   restart gets the remainder of the SIGNED wall, never a fresh allotment.
+ * @param {any} [opts.resumeSeed] RESUME (module C v2) — WHERE inside the killed attempt
+ *   the kill landed, read off its own spine by `readResume`: the plan it accepted and the
+ *   steps that reached their exits. Forwarded verbatim to the plan flow, which reloads
+ *   the plan instead of re-scouting and re-drafting, and skips the finished steps.
+ *   hamr's ruling: *"start last step instead from the beginning, why would i want to
+ *   waste more money on something i already started"*. Absent is the ordinary path.
+ * @param {{stage?: string|null, value?: number|null}[]} [opts.resumeGrades] RESUME — the
+ *   close grades the killed leg recorded (`readResume`'s `restart.grades`), forwarded to
+ *   the plan flow as the trend's BASELINES. A resumed run's halt readout judges the whole
+ *   chain, not just the leg: without them a leg that re-grades an unchanged tree reports
+ *   `flat` — "revise the goal" — on a run that was converging when the money ran out.
+ *   Counts and stage names only; no close bytes cross this seam. Absent is the cold path.
  * @param {boolean} [opts.layerRoot=false] Layer R (within-run ratchet) — shell
- *        territory, threaded to every predicate step's interpreter. Defaults OFF
+ *        territory, threaded to the plan flow. Defaults OFF
  *        (decided 2026-07-21): fixation is extinct on every current job (F41), so
  *        ON has never won its own A/B — the acceptance read defers to Layer 2 (or
  *        a manufactured-fixation probe). `true` is the ON/experimental arm; the
  *        default is the OFF arm. (Shell-owned seam, same doctrine as the provider
  *        binding.)
- * @returns {Promise<string>} outcome: 'green' | 'escalated' | 'unapproved-spec' |
- *   'job-red' | 'smoke-red' | 'config-red' | 'pricing-red' | 'provider-red' |
- *   'cap-halt' | 'close-unsupported' | `step-red:<id>`
+ * @returns {Promise<string>} outcome: 'green' | 'already-green' | 'escalated' |
+ *   'unapproved-spec' | 'job-red' | 'smoke-red' | 'plan-red' | 'check-red' |
+ *   'close-red' | 'close-unsupported' | 'recipe-stale' | 'pricing-red' | 'provider-red' |
+ *   'interpreter-red' | 'cap-halt' | 'wall-halt' | 'step-stalled' | `step-red:<id>`
  */
-export function runJob(rawSpec: object | string, { approvals, workdir, target, provider, nativeProvider, emit, capRuns, shellCapUsd, closeTimeoutMs, execCmd, layerRoot }: {
+export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, layerRoot, bridge, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades }: {
     approvals: unknown;
     workdir: string;
-    target?: string | undefined;
     provider: any;
     nativeProvider?: ((o: {
         policy: Function;
@@ -61,10 +97,20 @@ export function runJob(rawSpec: object | string, { approvals, workdir, target, p
         hasTools: boolean;
     }) => any) | undefined;
     emit: (type: string, data?: object) => object;
+    providerFor?: ((tier: string) => any) | undefined;
     capRuns?: number | undefined;
+    strikeLimit?: number | undefined;
     shellCapUsd?: number | undefined;
     closeTimeoutMs?: number | undefined;
-    execCmd?: ExecCmd | undefined;
+    bridge?: unknown;
+    priorSpentUsd?: number | undefined;
+    priorSpendComplete?: boolean | undefined;
+    priorWallMs?: number | undefined;
+    resumeSeed?: any;
+    resumeGrades?: {
+        stage?: string | null;
+        value?: number | null;
+    }[] | undefined;
     layerRoot?: boolean | undefined;
 }): Promise<string>;
 export type Red = {
@@ -72,10 +118,3 @@ export type Red = {
     path: string;
     detail?: string;
 };
-export type ExecCmd = (argv: string[], opts?: {
-    cwd?: string;
-}) => {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-};

package/types/selection.d.ts

@@ -0,0 +1,46 @@
+/**
+ * D3's listing: what the operator inspects and what the selecting model reads — the SAME
+ * text, so the two can never be choosing from different sets.
+ *
+ * Per bridge, one compact block: name, the job sentence it greened, status, greens/reds
+ * with the last outcome, and the cost/time band of its greens.
+ *
+ * Total and never throws: a listing is a display surface, and one malformed entry must
+ * not take the whole listing down (`listingRow` holds the same contract). Deterministic
+ * by name, whatever order the entries arrived in — a set that reshuffles between calls
+ * would make one picker's answer unreadable against another's.
+ *
+ * @param {unknown} registry `loadRegistry`'s result (`{ok, reds, bridges}`) or a bare
+ *   array of entries. The RESULT form is preferred: it carries the skip reds, and the
+ *   skips are the half a bare array cannot tell you about.
+ * @returns {string}
+ */
+export function renderListing(registry: unknown): string;
+/**
+ * The SELECT-WORKFLOW prompt: the text a later module sends to ask which workflow (if
+ * any) the run should start from. Pure — it sends nothing and parses nothing.
+ *
+ * D3's two standing rules are IN the prompt rather than enforced after the fact:
+ *  - *"none matches"* is a first-class answer, and it means the agent drafts new. A picker
+ *    with no way to decline would return the closest thing on the shelf every time, which
+ *    is how a registry becomes a lookup table.
+ *  - a PINNED workflow may be refused **only explicitly, with a reason** — never silently
+ *    ignored or quietly substituted. The operator's pick is the operator's; overriding it
+ *    invisibly is the one thing a picker must not be able to do.
+ *
+ * The output contract is stated so the answer is machine-readable, but the PARSE belongs
+ * to the runner that sends this (modules 4/5) — and the runner's parser and this shape are
+ * one contract in two places, which is why the shape is spelled out here rather than left
+ * to the model.
+ *
+ * @param {string} listing `renderListing`'s text — verbatim, so the picker sees exactly
+ *   what the human inspecting the registry sees
+ * @param {string} ask the job's goal sentence, in the operator's own words
+ * @param {string|null} [pinned] the operator's PIN, stated IN the call. D3 rules that a
+ *   pin is never bypassed and never silently overridden — so the pin does not skip the
+ *   call, it enters it, and the model's only legal ways out are confirming it or
+ *   refusing it by name with a reason. Stated here rather than assembled by the runner:
+ *   a second spelling of the pin sentence is a second prompt, and the two would drift.
+ * @returns {string}
+ */
+export function selectionPrompt(listing: string, ask: string, pinned?: string | null): string;

package/types/spine.d.ts

@@ -1,6 +1,13 @@
 /**
  * Create an emitter bound to one JSONL file.
  * @param {string} file absolute path; created on first emit
+ * @param {{startSeq?: number}} [opts] `startSeq`: the last `seq` already IN the file, for a
+ *   process that CONTINUES an existing spine (a resumed run appends to the dead run's own
+ *   log — module C). `seq` is monotonic per SPINE, so a second series restarting at 1
+ *   would give one append-only log two rows with the same number and silently break every
+ *   reader that orders by it. Default 0: a fresh file, which is every other caller.
  * @returns {(type: string, data?: object) => object} emit — returns the event as written
  */
-export function makeSpine(file: string): (type: string, data?: object) => object;
+export function makeSpine(file: string, { startSeq }?: {
+    startSeq?: number;
+}): (type: string, data?: object) => object;

package/types/stall.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @typedef {Object} StallWatch
+ * @property {<T>(call: (gen: number) => Promise<T>) => Promise<T>} watch run `call`,
+ *   reissuing it whenever it goes `stallMs` without a beat; rejects `StallError` past
+ *   `maxStalls`. Each issue is handed its GENERATION — the token every callback that
+ *   call installs must carry back, so a corpse's callbacks cannot touch the live call.
+ * @property {(gen: number) => void} beat a round completed on generation `gen` — reset
+ *   the window. From any other generation it is inert.
+ * @property {(gen: number) => boolean} isCurrent is `gen` still the call this watch is
+ *   waiting on? The caller reads it to withhold everything else a dead call would do.
+ * @property {() => number} stalls how many stalls this watch has absorbed
+ */
+/**
+ * Start a stall watchdog.
+ * @param {{ stallMs?: number, maxStalls?: number, onStall?: (n: number) => void,
+ *          expired?: () => boolean,
+ *          setTimer?: (fn: () => void, ms: number) => any,
+ *          clearTimer?: (id: any) => void }} [opts]
+ *   `onStall` is announced for EVERY stall including the last — a trim or a
+ *   recovery that happens silently is indistinguishable from one that never
+ *   happened (F28's rule, applied to time).
+ *   `expired` is the run's WALL, read at the one moment this module decides to
+ *   spend again (L4). Omitted, the watch behaves exactly as it did before the wall
+ *   existed — a caller with no clock reissues on the same rules.
+ * @returns {StallWatch}
+ */
+export function createStallWatch({ stallMs, maxStalls, onStall, expired, setTimer, clearTimer, }?: {
+    stallMs?: number;
+    maxStalls?: number;
+    onStall?: (n: number) => void;
+    expired?: () => boolean;
+    setTimer?: (fn: () => void, ms: number) => any;
+    clearTimer?: (id: any) => void;
+}): StallWatch;
+/** hamr's number: no completed round for five minutes is a stall. */
+export const STALL_MS: 300000;
+/** hamr's number: three stalls, then stop reissuing and replan. The count is
+ * CUMULATIVE over the watch's whole life and `watch()` never resets it — planrun
+ * builds one watch per WORKER, so the ceiling is spent across the STEP, not per
+ * call: two stalls on one call and one on the next give up just the same. That
+ * is deliberate (a step that keeps hanging is a step to replan, not a call to
+ * retry forever), and it is why nothing here says "on one call". */
+export const MAX_STALLS: 3;
+/**
+ * A stall gave up. Carries the category the step loop's replan trigger reads and
+ * the `lib` attribution stamped AT THE THROW SITE (never sniffed from prose).
+ */
+export class StallError extends Error {
+    /** @param {string} message @param {number} stalls */
+    constructor(message: string, stalls: number);
+    /** @type {string} */
+    category: string;
+    /** @type {string} */
+    lib: string;
+    /** @type {number} */
+    stalls: number;
+}
+export type StallWatch = {
+    /**
+     * run `call`,
+     * reissuing it whenever it goes `stallMs` without a beat; rejects `StallError` past
+     * `maxStalls`. Each issue is handed its GENERATION — the token every callback that
+     * call installs must carry back, so a corpse's callbacks cannot touch the live call.
+     */
+    watch: <T>(call: (gen: number) => Promise<T>) => Promise<T>;
+    /**
+     * a round completed on generation `gen` — reset
+     * the window. From any other generation it is inert.
+     */
+    beat: (gen: number) => void;
+    /**
+     * is `gen` still the call this watch is
+     * waiting on? The caller reads it to withhold everything else a dead call would do.
+     */
+    isCurrent: (gen: number) => boolean;
+    /**
+     * how many stalls this watch has absorbed
+     */
+    stalls: () => number;
+};

package/types/tools.d.ts

@@ -0,0 +1,262 @@
+/**
+ * The strategy suffix for ONE worker's grant: every sentence that survives names
+ * only tools this worker can actually call. Reproduces the exported paragraphs
+ * exactly on a full grant.
+ * @param {string[]} granted the step's granted VERBS (the menu IS the grant, 2b)
+ * @returns {string} the system-prompt suffix, '' when nothing is granted
+ */
+export function strategyFor(granted: string[]): string;
+/**
+ * The retrieval pair (F19). `shell_read` cannot seek — it starts at byte zero — so a
+ * pointer at a symbol was inert and the worker paged whole files to reach one function.
+ * `ctx_recall` hands back a POINTER (no body: a search index returns pointers, and bodies
+ * on every hit rebuild the bloat — measured, a 5-hit recall dumps ~15k tokens unbidden);
+ * `ctx_get` trades that pointer for ONE chunk. A chunk starts at its doc-comment, so the
+ * body arrives WITH the docstring that says what it was supposed to do.
+ * @param {any} lc the run's LiteCtx (rooted at workdir)
+ * @param {string} workdir
+ * @param {(type: string, data: object) => void} emit the spine — a retrieval verb whose
+ *   RESULT is invisible cannot be judged: a `ctx_get` that silently reds (stale pointer,
+ *   bad range) looks exactly like one that worked, and the worker's fallback to a
+ *   whole-file read looks like a free choice instead of a forced one.
+ */
+export function createCtxTools(lc: any, workdir: string, emit: (type: string, data: object) => void): ({
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            n: {
+                type: string;
+                description: string;
+            };
+            path?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            symbol?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: ({ query, n }: {
+        query: string;
+        n?: number;
+    }) => Promise<any>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            startLine: {
+                type: string;
+                description: string;
+            };
+            endLine: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            symbol?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: ({ path: p, startLine, endLine }: {
+        path: string;
+        startLine: number;
+        endLine: number;
+    }) => Promise<any>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            symbol: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            path?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<string>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            symbol?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<string>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query?: undefined;
+            n?: undefined;
+            path?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            symbol?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required?: undefined;
+    };
+    execute: (args: any) => Promise<string>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            symbol: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            id?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<string>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            text: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            path?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            symbol?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<string>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+            n?: undefined;
+            path?: undefined;
+            startLine?: undefined;
+            endLine?: undefined;
+            symbol?: undefined;
+            text?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<string>;
+})[];
+export const PERSONA_TOOLS: string;
+export const RETRIEVAL_STRATEGY: string;
+export const EDIT_STRATEGY: string;
+export const TOOL_BY_VERB: Readonly<{
+    read: "shell_read";
+    grep: "shell_grep";
+    write: "shell_write";
+    edit: "shell_edit";
+    recall: "ctx_recall";
+    get: "ctx_get";
+    impact: "ctx_impact";
+    related: "ctx_related";
+    recent: "ctx_recent";
+    compress: "ctx_compress";
+    peek: "ctx_peek";
+    stash: "ctx_stash";
+    remember: "ctx_remember";
+    forget: "ctx_forget";
+}>;
+export const ISOLATE_MAX_BYTES: 65536;
+export const CTX_TOOLS: readonly string[];
+export const COMPONENT_STRATEGIES: Readonly<{
+    select: string;
+    compress: string;
+    isolate: string;
+}>;
+export function toolAction(name: string, args: any, workdir?: string): {
+    type: string;
+    path: string;
+    args: {
+        bytes: number;
+        tool?: undefined;
+    };
+} | {
+    type: string;
+    path: string;
+    args: {
+        tool: string;
+        bytes?: undefined;
+    };
+} | {
+    type: string;
+    args: any;
+    path?: undefined;
+};
+/**
+ * litectx recall hit — body present only with `{body: true}`
+ */
+export type RecallHit = {
+    body?: string | null;
+    text?: string | null;
+};

package/types/trend.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Read one close gap into its stage and its count. Pure, and both halves are
+ * independently nullable: a gap with no header still yields its count, a gap
+ * with no red-marked line still yields its stage.
+ * @param {string} [gap] the close's gap, exactly as `runStages` built it
+ * @returns {{stage: string|null, value: number|null}}
+ */
+export function readGrade(gap?: string): {
+    stage: string | null;
+    value: number | null;
+};
+/**
+ * Build one trend reader. ONE PER SERIES: the money readout wants the whole run's
+ * close grades (the precheck is the seed the work is measured against), while the
+ * fix governor wants only the grades its own loop produced. Two instances, one
+ * rule — never one instance with a phase field, which is how a shared reader comes
+ * to answer two questions with one number.
+ *
+ * @param {object} [opts]
+ * @param {string[]} [opts.stageOrder] the staged close's stage names IN ORDER, so
+ *   "the run got further than it ever had" is readable. Empty disables that signal
+ *   entirely (an unknown ordering is unknown, never assumed).
+ * @param {number} [opts.limit] consecutive no-progress readings that strike the
+ *   loop out (default `FIX_STRIKE_LIMIT`).
+ * @param {number|null} [opts.blindCap] the RETIRED count, kept as the bound for
+ *   the case the instrument cannot read at all. Counted in iterations PAST the
+ *   baseline, so a blind loop runs exactly the number of attempts the old fixed
+ *   count bought it. `null` = no fallback bound (money and the wall still apply).
+ * @param {{stage?: string|null, value?: number|null}[]} [opts.seed] RESUME — the
+ *   grades a PREVIOUS leg of this same run already recorded, oldest first, read off
+ *   its own spine. Baselines only (see THE SEED above). Empty/omitted is the cold
+ *   path and is byte-identical to the pre-resume reader.
+ */
+export function createTrend({ stageOrder, limit, blindCap, seed }?: {
+    stageOrder?: string[] | undefined;
+    limit?: number | undefined;
+    blindCap?: number | null | undefined;
+    seed?: {
+        stage?: string | null;
+        value?: number | null;
+    }[] | undefined;
+}): {
+    /**
+     * Read one RED close grade. A green never reaches here (both callers stop on
+     * satisfied), so every reading is a failing grade by construction.
+     * @param {{gap?: string, stage?: string|null, value?: number|null}} o either a
+     *   raw gap (parsed here) or an already-read `{stage, value}` — never both
+     *   spellings of the same reading in one call.
+     * @returns {{iteration: number, stage: string, value: number|null, improved: boolean,
+     *   comparable: boolean, noProgress: number, limit: number, stageIndex: number}}
+     */
+    record({ gap, stage, value }?: {
+        gap?: string;
+        stage?: string | null;
+        value?: number | null;
+    }): {
+        iteration: number;
+        stage: string;
+        value: number | null;
+        improved: boolean;
+        comparable: boolean;
+        noProgress: number;
+        limit: number;
+        stageIndex: number;
+    };
+    /** has the loop run out of ideas — or, while the instrument is blind, out of
+     * the count it replaced? Money and the wall are unchanged and bound it either way.
+     * The blind arm counts the streak PAST its own first reading, the same `- 1` the
+     * blind-from-birth path always used: a streak's opening grade is the baseline the
+     * blind iterations are measured from, so a never-comparable run binds on exactly
+     * the reading it always did. */
+    struckOut: () => boolean;
+    /** the reader's own books. COUNTS AND STAGE NAMES ONLY — no close bytes ever
+     * enter a record from here, because the spine is append-only forever. */
+    report: () => {
+        iterations: number;
+        strikes: number;
+        limit: number;
+        blind: boolean;
+        stages: {
+            stage: string;
+            values: number[];
+        }[];
+    };
+    /**
+     * The DECISION-READY readout (PRD v1.46 §2): which way the run was going when
+     * something cut it, in the three verdicts hamr named, and the lever each
+     * implies. The library only reports — it never adjusts a budget (hard line).
+     * @returns {{trend: 'converging'|'flat'|'unknown', motion: 'changed'|'unchanged'|null,
+     *   reading: string, lever: string, series: {stage: string, values: number[]}[]}}
+     */
+    verdict(): {
+        trend: "converging" | "flat" | "unknown";
+        motion: "changed" | "unchanged" | null;
+        reading: string;
+        lever: string;
+        series: {
+            stage: string;
+            values: number[];
+        }[];
+    };
+};
+/** The strikes that end the close-fix loop. Shell-owned, exactly where the fixed
+ * count was, and the SAME number the step ladder uses — hamr's 2. Validated by a
+ * $0 replay over all 8 archived fix loops: 0 greens harmed (every historical
+ * fix-loop green converted in <= 2 verdicts) and 1 real waste case caught
+ * (reuse-msc6w93z, dead flat at 2 errors for 7 verdicts until the wall). */
+export const FIX_STRIKE_LIMIT: 2;