bareloop 0.10.0 → 0.12.0

package/types/clock.d.ts

@@ -53,8 +53,11 @@ export function isWallTimeout(err: any, clock: Clock): boolean;
  *   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. `priorElapsedMs`: time this attempt's
- *   PREDECESSOR already consumed (see below).
+ *   tests — the default is the real clock, and it stays injectable precisely so
+ *   every test here can drive time deterministically without a sleep. That default
+ *   is MONOTONIC (fact 4 above), not `Date.now`: a wall-clock jump — a suspend, an
+ *   NTP step, a hand-set date — must not be able to reach a signed deadline.
+ *   `priorElapsedMs`: time this attempt's PREDECESSOR already consumed (see below).
  * @returns {Clock}
  */
 export function createClock({ maxWallMs, closeStages, now, priorElapsedMs }?: {

package/types/declaredclose.d.ts

@@ -6,6 +6,16 @@ export function isDeclaredClose(job: any): boolean;
  *
  * `offer` and `needs` pass through untouched when a declaration carries them
  * (v1's schema does not let one), so `checkMenu`'s derivation is unchanged.
+ *
+ * THE JUDGE TIER RIDES ALONG, and it rides as a STAMP for the same reason `offer`
+ * does. The tier that graded this close's calibration set is a CLOSE-level fact
+ * (`calibration.judgeModel`), and the stage that would buy a judge call is a STAGE;
+ * `runStage` is handed stages and never the declaration they came out of. Rather than
+ * plumb a second close-level channel down through every executor seam, the one place
+ * that already turns a declaration into stages carries it across — and it carries it
+ * from the SIGNED bytes, so a stage can never name a tier the signature does not.
+ * `runJudgedFloor` refuses a mismatch; the absence of a stamp is the SPEC gate's
+ * business (`validateCloseDecl` reds a set with no model), never a runtime fall-back.
  * @param {any} closeDecl
  * @returns {any[]|null} null when this is not a declaration
  */
@@ -97,7 +107,10 @@ export function guardNames(closeDecl: any, verdictType: string): string[];
  * @param {any[]} stages declared stage descriptors, already validated
  * @param {(s: string) => string} [redact] the scrub, applied at THIS boundary
  * @param {{timeoutMs?: number, cwd?: string, seedRef?: string,
- *   seedTrees?: any, gapCap?: number, maxBuffer?: number, baselineMode?: 'auto'|'worktree'}} [opts]
+ *   seedTrees?: any, gapCap?: number, maxBuffer?: number, baselineMode?: 'auto'|'worktree',
+ *   humanRuling?: {decision: string, text?: string|null}|null,
+ *   judgeLoop?: ((o: {system: string}) => any)|null,
+ *   onJudgeCost?: ((c: any) => void)|null}} [opts]
  * @returns {Promise<any>}
  */
 export function runDeclaredStages(stages: any[], redact?: (s: string) => string, opts?: {
@@ -108,6 +121,14 @@ export function runDeclaredStages(stages: any[], redact?: (s: string) => string,
     gapCap?: number;
     maxBuffer?: number;
     baselineMode?: "auto" | "worktree";
+    humanRuling?: {
+        decision: string;
+        text?: string | null;
+    } | null;
+    judgeLoop?: ((o: {
+        system: string;
+    }) => any) | null;
+    onJudgeCost?: ((c: any) => void) | null;
 }): Promise<any>;
 /**
  * The trend reader's input for ONE close verdict, whichever executor produced
@@ -150,6 +171,12 @@ export const DECLARED_GENRES: readonly "TYPES"[];
  * channel of its own.
  */
 export const CLOSE_DECL_FIELDS: readonly string[];
+/** what a stored calibration set carries, ENUMERATED: the frozen cases and the judge
+ * tier that graded them. Both are inside the spec, so `jobSpecHash` covers both — which
+ * is the whole mechanism behind "a judge-model bump forces a full recalibration"
+ * (src/judged.js, `JUDGE_MODEL`): the field moves, the hash moves, the signature dies,
+ * and the re-sign re-runs the gate. Anything else in there is a field nobody reads. */
+export const CALIBRATION_FIELDS: readonly string[];
 /**
  * The prefix M1 puts on EVERY gap line of a declared stage (its `ctx.gapKeep`).
  * A literal, so the anchored pattern below is exact.
@@ -160,11 +187,71 @@ export const DECLARED_GAP_PREFIX: "close: ";
  * it; because every declared line carries the prefix, it designates the stage's
  * whole judged output rather than a hand-picked slice of it. */
 export const DECLARED_GAP_KEEP: string;
-/** The verdict class a DECLARED close may claim. Hard, and by CONSTRUCTION
- * rather than by assertion: every live kind is a mechanical command whose
- * measurement is the truth, and the two judgment kinds are locked out at the
- * catalogue (M2) and absent from the executor (M1). Named as data so the job
- * validator reads one hierarchy table rather than hard-coding a class. */
+/**
+ * The close verdict word for a run WAITING on a person (N4 §1.3/§1.4). A
+ * literal, exported, because three readers key on it — the runner's pause
+ * branch, the ledger's excluded set, and the trend reader's blind rule — and
+ * three hand-spelled copies of one terminal is how they come to disagree.
+ *
+ * It is not in `CLOSE_FAULTS` and must never be added: a fault says the close
+ * could not render a verdict, and this says the close is not FINISHED rendering
+ * one. The first escalates; the second is a checkpoint the operator returns to.
+ */
+export const HUMAN_PAUSE: "human-pause";
+/**
+ * The RUN-level terminal names the hitl class mints one layer up from
+ * `HUMAN_PAUSE` (N4 §1.3–§1.5): the checkpoint, and the honest refusal of the
+ * operator's rerun input. Spelled once here, beside the close-verdict word they
+ * translate, for the same reason `HUMAN_PAUSE` is — the emitters (`planrun.js`),
+ * the ledger's excluded set, the resume reader (`reuse.js`), and the runner
+ * script all key on them, and hand-spelled copies of one terminal is how they
+ * come to disagree.
+ *
+ * There were three (2026-08-17): `hitl-cancel` was the signer's own terminal and
+ * is DELETED with the door it belonged to. A person who does not want to carry on
+ * now PAUSES — the same checkpoint, resumable, retired by the TTL if nobody comes
+ * back — so nothing in this tree mints that name any more. The ledger keeps the
+ * bare string in its excluded set so a spine written before this change still
+ * reads as governance rather than as a capability gap; that is a READER's
+ * backward compatibility, and deliberately not a constant a writer could reach.
+ */
+export const HITL_PAUSE: "hitl-pause";
+export const HITL_DECISION_RED: "hitl-decision-red";
+/**
+ * The terminals above that leave the run WAITING ON A PERSON — as a list, minted
+ * beside the names it holds so a reader keys on membership rather than on a
+ * spelling, and a rename here travels to every reader for free.
+ *
+ * It is deliberately NOT `reuse.js`'s `CHECKPOINT_OUTCOMES`, which is the wider
+ * RESUME list: every stop that left work on disk and an allowance unspent, money
+ * and time included. Those are governance stops the reuse loop is meant to try
+ * again under its remaining tries; this is the half no further attempt can
+ * change, because the allowance still unspent is a human answer. `CHECKPOINT_OUTCOMES`
+ * is composed FROM this list so the two can never disagree about which is which.
+ *
+ * `HITL_DECISION_RED` is not here: it is a verdict already rendered on the operator's
+ * own input, not a question still open.
+ */
+export const HUMAN_CHECKPOINTS: readonly string[];
+/** The verdict classes a DECLARED close may claim. Named as data so the job
+ * validator reads one hierarchy table rather than hard-coding a class.
+ *
+ * `hard` is by CONSTRUCTION: every mechanical kind is a command whose measurement
+ * is the truth. `hitl` joined it at N4 slice 1, and `soft` at softgreen module 3
+ * — each only because its kind is genuinely LIVE (`human-confirms`, then
+ * `judged-floor`): the widening and the kind go in one commit, or this table
+ * admits a class the executor cannot render.
+ *
+ * `hitl` STAYS despite the class's retirement (PRD v1.71: the human stage moved
+ * out of the close and became the review door at the end of every run). It is
+ * kept because `jobs/litectx-maintainer.json` is a SIGNED spec carrying a hitl
+ * declaration, and a signed spec is untouchable — dropping the spelling here
+ * would invalidate a signature the operator already gave, which is a re-sign
+ * nobody asked for. Retiring it is a separate, deliberate deletion.
+ *
+ * The direction that matters is unchanged. This says which class a declaration
+ * MAY claim; `closeCeiling` says which class its stages actually NEED. A pick
+ * below the ceiling is still the silent upgrade `class-ceiling` refuses. */
 export const DECLARED_CLOSE_CLASSES: readonly string[];
 export type Red = {
     code: string;

package/types/index.d.ts

@@ -1,20 +1,24 @@
 export { makeSpine } from "./spine.js";
 export { runPlan } from "./planrun.js";
-export { runJob } from "./run.js";
 export { ralph, runClose, runStages, CLOSE_FAULTS } from "./ralph.js";
 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, closeStagesOf } 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 { runJob, ACCOUNTED_ROUND_TYPES } from "./run.js";
+export { BRIDGE_SCHEMA, validateBridge, deriveStatus, listingRow, loadGate, mintBridge, appendGreen, appendRed, loadBridge, loadRegistry, saveBridge, makeRegistry, registryExists, QUARANTINED_VERDICTS, QUARANTINED_CODE, quarantinesCredit, newestEligibleVersion, reuseEligibility, recordDoor } 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 { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate, CHECKPOINT_OUTCOMES, PAUSE_TTL_MS, checkpointAgeGate, applyDoorDecision, writeRunGreenRow } from "./reuse.js";
 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, genreInstruments, DIRECTIONS, BASELINES, MAX_STAGES, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling } from "./authoring.js";
+export { runDeclaredClose, runStage, seedRead, seedAtHead, seedListing, changedSet, makeSeedTrees, LIVE_KINDS, STOP_FAULTS, JUDGED_MARKER, EXIT_GREEN, EXIT_RED, EXIT_STOP, HUMAN_DECISIONS, SEED_EXEMPT_KINDS, JUDGED_FLOOR_KIND, normalizeHumanRuling, resolveHumanRuling, JUDGE_ATTEMPTS, MAX_JUDGED_PATHS, REVIEW_DOOR, DOOR_OPEN_OUTCOMES, REVIEW_DOOR_CLASSES, doorOpens, mechanicalStages } from "./kinds.js";
+export { answerReviewDoor, doorRecordOf, doorAgeGate } from "./reviewdoor.js";
+export { JUDGE_MODEL, JUDGE_MAX_TOKENS, JUDGE_RULES, JUDGE_RULE_IDS, LOCATE_AXES, LOCATE_LABEL, validateCard, validateFacts, locatePrompt, runLocate, decide, defaultJudgeLoop, CALIBRATION_SIZE, CASE_VERDICTS, validateCalibrationSet, validateJudgedArtifacts, expectedOf } from "./judged.js";
+export { proposeJudgedArtifacts, signJudgedArtifacts, foldJudgedArtifacts, proposalSchema, proposalTool, cardCasesPrompt, PROPOSAL_TOOL_NAME, PROPOSAL_LABEL, MAX_PROPOSAL_RETRIES, COMPILE_SYSTEM } from "./cardauthor.js";
+export { runCalibration, compareExpectation, factsResist, artifactHash, INJECTION_LOCATE_BATTERY, INJECTION_CARD, CALIBRATION_LABEL, CASUALTY_AXES } from "./calibrate.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, classMenu, closeCeiling, NEVER_OFFERED_KINDS } 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";
-export { validateCloseDecl, runDeclaredStages, declaredStages, isDeclaredClose, guardNames, closeGrade, DECLARED_GENRES, DECLARED_GAP_PREFIX, DECLARED_GAP_KEEP, DECLARED_CLOSE_CLASSES, CLOSE_DECL_FIELDS } from "./declaredclose.js";
+export { authorClose, authorPrompt, declarationSchema, makeLoopGenerate, MAX_REVISIONS, QUESTION_SETS, GREEN_QUESTIONS, SOFTGREEN_QUESTIONS, CLASS_STATEMENTS, questionsFor, requiredAnswersFor } from "./authorflow.js";
+export { validateCloseDecl, runDeclaredStages, declaredStages, isDeclaredClose, guardNames, closeGrade, DECLARED_GENRES, DECLARED_GAP_PREFIX, DECLARED_GAP_KEEP, DECLARED_CLOSE_CLASSES, CLOSE_DECL_FIELDS, HUMAN_PAUSE, HITL_PAUSE, HITL_DECISION_RED, HUMAN_CHECKPOINTS } from "./declaredclose.js";
 export { runInterview, authorCloseForJob, assembleSpec, prepareSigning, refusalEvents, refuseLockedKind, GENRE, REFUSAL_LIB, REFUSAL_CATEGORY, AUTHORED_SPEC_FIELDS } from "./authorjob.js";

package/types/job.d.ts

@@ -153,11 +153,29 @@ export const MIN_WALL_MS: 120000;
  * counts admission demand, and a generic invalid-value would bury it as a typo. */
 export const LOCKED_TOOLS: readonly string[];
 /** Layer 2 (design record 2026-07-21, decision 5): the verdict-type radio of
- * the four-field plan shape. v1 ADMITS only `green`; soft-green/hitl are
- * declared-but-locked — declaring one is a `request-red` (the tool-menu
- * pattern: disclosure ≠ admission), so the ledger counts the demand and the
- * non-code rung later fills a declared slot instead of reshaping the schema. */
+ * the four-field plan shape. All three are ADMITTED as of softgreen module 3;
+ * the declared-but-locked mechanism below (`LOCKED_VERDICTS`) is what carried
+ * them here one rung at a time — declaring a locked one is a `request-red` (the
+ * tool-menu pattern: disclosure ≠ admission), so the ledger counted the demand
+ * instead of the schema being reshaped when the rung finally landed. */
 export const VERDICT_TYPES: readonly string[];
+/** N4 slice 1 admitted `hitl`; softgreen module 3 admits `soft-green`, and the
+ * menu is now EMPTY — every class the radio names is built.
+ *
+ * `soft-green`'s lock was never a policy, it was a missing floor: a judged
+ * verdict with no ruler mints nothing honestly. Modules 1 and 2 built the ruler
+ * (a pinned judge that only LOCATES, an arbiter-owned `decide()`, a calibration
+ * gate) and wired it as the `judged-floor` kind, so the lock has nothing left to
+ * protect (design record 2026-08-17 §4, and the 2026-08-18 thresholds addendum).
+ *
+ * EMPTY here means "nothing is locked", which is a TRUE statement about a closed
+ * menu — not F59's absent-read-as-empty, where a `{}` stood in for a fact nobody
+ * gathered. The mechanism below stays exactly as it is: it is read at call time
+ * from this constant, so re-locking a class (or admitting a fourth) is one edit
+ * and the counted `request-red` path comes back with it. `LOCKED_CLASSES` in
+ * src/authoring.js is the twin and moved in the same commit; the suite pins the
+ * two identical. */
+/** @type {readonly string[]} */
 export const LOCKED_VERDICTS: readonly string[];
 export const CADENCE_UNITS: readonly string[];
 /** SP-2: API-first; local deferred (PRD §5/§8). `clipipe-subscription` (F42,

package/types/judged.d.ts

@@ -0,0 +1,280 @@
+/**
+ * The rubric card: Q6's answer compiled into enumerated items, signed by the
+ * person and enumerated in the spec hash. `rule` selects from `JUDGE_RULES`;
+ * `text` is the signer's own words, carried so a red can be explained in them.
+ *
+ * Wherever a schema takes free text but only a closed set can satisfy it, hand
+ * over the enumerated set — so `rule` is a SELECT and `text` is the only free
+ * field, and it decides nothing.
+ * @param {any} card
+ * @returns {{ok: boolean, reds: string[]}}
+ */
+export function validateCard(card: any): {
+    ok: boolean;
+    reds: string[];
+};
+/**
+ * THE CALIBRATION SET's gate. Never throws on proposed input — every failure is a
+ * named red in the shipped `{ok, reds}` shape.
+ *
+ * A CASE is `{id, artifact, expect: {verdict, reds: [{rule, fn}]}}`:
+ *   `artifact` is REAL TEXT — what LOCATE will actually be pointed at, never a
+ *   description of it; `verdict` is what `decide()` must render; and `reds` is the
+ *   ITEMIZED expectation, because the floor is *graded correctly WITH ITEMIZED
+ *   REDS* — a pipe that reds the right case for the wrong reason has not been
+ *   calibrated, it has been lucky. `rule` selects from the CARD's own lines (the
+ *   §4.3 ceiling made mechanical: the judge only ever checks lines the card
+ *   names) and `fn` is the address `decide()` itself reports.
+ *
+ * THE SIZE and THE POLARITY are separate reds on purpose: one is hamr's
+ * threshold, the other is *the test must be able to FAIL*. A set of ten that can
+ * only pass is exactly as unusable as a set of nine, and one red for both would
+ * send an operator to fix the wrong half.
+ *
+ * `card` is REQUIRED and its absence is a red rather than a skipped check — a
+ * validator handed no card would report a set it never examined against anything.
+ * @param {any} cases @param {{card?: any}} [o]
+ * @returns {{ok: boolean, reds: {code: string, path: string, detail: string, [k: string]: any}[]}}
+ */
+export function validateCalibrationSet(cases: any, { card }?: {
+    card?: any;
+}): {
+    ok: boolean;
+    reds: {
+        code: string;
+        path: string;
+        detail: string;
+        [k: string]: any;
+    }[];
+};
+/**
+ * BOTH signed artifacts, judged independently and reported together. The card
+ * goes through `validateCard` rather than a second spelling of it.
+ * @param {{card: any, cases: any}} o
+ * @returns {{ok: boolean, reds: {code: string, path: string, detail: string, [k: string]: any}[]}}
+ */
+export function validateJudgedArtifacts({ card, cases }: {
+    card: any;
+    cases: any;
+}): {
+    ok: boolean;
+    reds: {
+        code: string;
+        path: string;
+        detail: string;
+        [k: string]: any;
+    }[];
+};
+/**
+ * A `decide()` result reduced to the shape a case STORES. ONE spelling, so the
+ * expectation a signer signs and the reading module 5 takes off the live pipe are
+ * one shape read twice rather than two that can disagree.
+ *
+ * `why` and `quote` are deliberately dropped: both are the judge's prose about
+ * one emission, no signer can predict either, and pinning them would fail an
+ * honest pipe on wording. What survives is the ADDRESS — which card line, which
+ * function — which is what "itemized reds" means.
+ * @param {any} decision
+ * @returns {{verdict: string, reds: {rule: string, fn: string}[]}}
+ */
+export function expectedOf(decision: any): {
+    verdict: string;
+    reds: {
+        rule: string;
+        fn: string;
+    }[];
+};
+/**
+ * The SHAPE gate on a locate emission, and only the shape: is this the object
+ * the rest of the pipe can read at all? A shape miss is an ARTIFACT-RED — the
+ * emission is broken and the caller may buy another one.
+ *
+ * What is deliberately NOT here: per-rule field presence, and an empty function
+ * list. Both are well-formed emissions whose CONTENT is unusable, and content
+ * is `decide()`'s to red on (contract (a)) — routing them here would let a
+ * retry ladder spend money re-asking a model that answered perfectly clearly.
+ * It takes the facts and NOTHING else — no card. The shape of a locate emission
+ * is the same shape whatever the card asked for, and a second parameter nobody
+ * reads is a signature promising a coupling that does not exist.
+ * @param {any} facts
+ * @returns {{ok: boolean, reds: string[]}}
+ */
+export function validateFacts(facts: any): {
+    ok: boolean;
+    reds: string[];
+};
+/**
+ * The locate prompt for ONE card — the only derivation in this module, and it
+ * runs card → prompt, one hop, one direction. A rule the card did not name buys
+ * no prompt tokens and produces no facts nobody reads.
+ * @param {any} card @returns {string}
+ */
+export function locatePrompt(card: any): string;
+/**
+ * ONE locate attempt. The caller owns the ladder — this function has no retry,
+ * no cap and no opinion about how many times it should be called, because a
+ * retry is a spend decision and spend decisions are the arbiter's.
+ *
+ * THE AXIS PRECEDENCE, and the order is load-bearing:
+ *   1. THE CALL FAILED → `provider-red`. A thrown or errored call has no
+ *      knowable cost, so asking the meter about it would mislabel a transport
+ *      casualty as a broken meter and send the operator to fix the wrong thing.
+ *   2. THE COST IS NULL → `pricing-red`. Checked BEFORE the emission is even
+ *      looked at: a retry of an unpriced call buys more spend nobody can see,
+ *      so this is the non-retryable stop and it outranks every retryable one.
+ *   3. TRUNCATED → `provider-red`, on its own field, never folded into a parse
+ *      error. "The model was cut off" and "the model wrote nonsense" are two
+ *      findings, and one field spelling both is how a reader confuses them.
+ *   4. UNPARSEABLE or SHAPE-BROKEN → `artifact-red`. No repair, ever.
+ *
+ * On every route out, red or clean, `onCost` fires exactly once with the honest
+ * read: a paid call that leaves no meter record is F12 wearing a judge's coat.
+ * @param {{artifactText: string, card: any, loopFactory: (o: {provider?: any, system: string}) => any,
+ *   maxTokens?: number, attempt?: number, onCost?: (c: {costUsd: number|null, unpricedRounds: number}) => void}} o
+ * @returns {Promise<{ok: boolean, facts: any|null, red: {axis: string, detail: string}|null,
+ *   costUsd: number|null, unpricedRounds: number, truncated: boolean, parseError: boolean,
+ *   raw: ReturnType<typeof scrubRaw>}>}
+ */
+export function runLocate({ artifactText, card, loopFactory, maxTokens, attempt, onCost }: {
+    artifactText: string;
+    card: any;
+    loopFactory: (o: {
+        provider?: any;
+        system: string;
+    }) => any;
+    maxTokens?: number;
+    attempt?: number;
+    onCost?: (c: {
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
+}): Promise<{
+    ok: boolean;
+    facts: any | null;
+    red: {
+        axis: string;
+        detail: string;
+    } | null;
+    costUsd: number | null;
+    unpricedRounds: number;
+    truncated: boolean;
+    parseError: boolean;
+    raw: ReturnType<typeof scrubRaw>;
+}>;
+/**
+ * Render the per-item verdicts over one locate result. PURE: same input, same
+ * output, forever — which is what makes a calibration set mean anything.
+ *
+ * FIRST-RED-WINS, in SIGNED CARD ORDER. Every item is still EVALUATED after the
+ * first red (calibration demands itemized reds, not a paragraph and not a short
+ * circuit); `firstRed` is the composed stage verdict's reason, and its
+ * stability comes from the card's own order rather than from whatever order the
+ * model happened to emit its functions in.
+ *
+ * `artifactText` is OPTIONAL and its absence is honest rather than lenient:
+ * with the artifact in hand every quote a rule consumes is verified to exist in
+ * it, and without it `decide()` simply does not make a claim it cannot support.
+ * Callers that HAVE the authoritative artifact (which is every real caller,
+ * since the same text was just judged) should always pass it.
+ * @param {any} facts a `runLocate` result's `facts`, or null
+ * @param {any} card
+ * @param {{artifactText?: string|null}} [opts]
+ * @returns {{verdict: 'pass'|'red', items: {rule: string, text: string, ok: boolean, reds: RuleRed[]}[],
+ *   firstRed: string|null, reason: string|null}}
+ */
+export function decide(facts: any, card: any, { artifactText }?: {
+    artifactText?: string | null;
+}): {
+    verdict: "pass" | "red";
+    items: {
+        rule: string;
+        text: string;
+        ok: boolean;
+        reds: RuleRed[];
+    }[];
+    firstRed: string | null;
+    reason: string | null;
+};
+/**
+ * THE JUDGE MODEL, PINNED. Never agent-selectable and never a step knob: it is
+ * the only tier with established injection resistance upstream (BA-20's
+ * INJECTION_BATTERY is haiku-4.5 only), and §4.2's whole safety argument is
+ * worth exactly as much as that evidence. A judge-model bump forces a full
+ * recalibration — mandatory, per the model-bump dead-weight replay rule.
+ *
+ * THAT IS ENFORCED, not asked for, and it is enforced in three places because a
+ * rule with no wired detector is prose (F45):
+ *   1. the value here is STORED with the set it graded — `foldJudgedArtifacts`
+ *      writes it as `closeDecl.calibration.judgeModel`, inside the spec, so
+ *      `jobSpecHash` covers it by construction. Bump this constant and every
+ *      signed judged spec hashes differently: the signature dies, and re-signing
+ *      is what re-runs the calibration gate.
+ *   2. `validateCloseDecl` REQUIRES it on any stored set — a set nobody can
+ *      attribute to a tier is a floor nobody can tell apart from a bumped one.
+ *   3. `runJudgedFloor` refuses to grade when the stored tier is not this one,
+ *      naming both models. It does not degrade in either direction: grading on
+ *      the new tier judges against a floor nobody calibrated, and the old tier is
+ *      not on offer.
+ */
+export const JUDGE_MODEL: "claude-haiku-4-5";
+/**
+ * The locate call's token ceiling. The POC's two real artifacts came back well
+ * inside 2000; this doubles that for headroom on a longer artifact, and the
+ * direction is fail-safe either way — a ceiling that binds produces a TRUNCATED
+ * emission, which is a red with its own field, never a silent partial pass. A
+ * caller may override it per call; it is a default, not a threshold.
+ */
+export const JUDGE_MAX_TOKENS: 4000;
+/** the label every locate call is metered and persisted under — one spelling */
+export const LOCATE_LABEL: "judged-locate";
+/**
+ * The THREE axes a locate attempt can fail on, enumerated because the caller
+ * ROUTES on them and a route decided by reading prose is the class this
+ * programme keeps paying for. All three are shipped bareloop classes, borrowed
+ * with their existing meanings intact:
+ *   - `pricing-red`  the meter is broken. NOT retryable: a retry buys more
+ *                    spend nobody can see.
+ *   - `provider-red` the call failed or was cut off. Retryable.
+ *   - `artifact-red` the call succeeded and its emission is unusable.
+ *                    Retryable, under the CALLER's cap — this module runs one
+ *                    attempt and owns no ladder.
+ */
+export const LOCATE_AXES: Readonly<{
+    PRICING: "pricing-red";
+    PROVIDER: "provider-red";
+    ARTIFACT: "artifact-red";
+}>;
+/**
+ * THE OWNED RULE TABLE. Frozen: the rulebook is the arbiter's, and a caller that
+ * could add a rule at runtime would be authoring the arbiter.
+ * @type {Readonly<Record<string, {id: string, ask: string, check: (fn: any, lines: Set<string>|null) => RuleRed[]}>>}
+ */
+export const JUDGE_RULES: Readonly<Record<string, {
+    id: string;
+    ask: string;
+    check: (fn: any, lines: Set<string> | null) => RuleRed[];
+}>>;
+/** the enumerated set a card may name — handed over verbatim in every refusal */
+export const JUDGE_RULE_IDS: readonly string[];
+/**
+ * THE SIZE — hamr, 2026-08-18, verbatim: *"go build 10, we could double later"*.
+ *
+ * Not a number measurement found, and not one the agent may revisit: a size
+ * change is a spec-level threshold change and stays operator territory (the
+ * standing no-agent-threshold-picking rule). The second half of his sentence is
+ * part of the ruling — doubling later is explicitly allowed — which is why it is
+ * ONE constant read by the schema, the validator and the refusal alike.
+ */
+export const CALIBRATION_SIZE: 10;
+/** the two verdicts a case may expect — `decide()`'s own closed set */
+export const CASE_VERDICTS: readonly string[];
+export function defaultJudgeLoop({ provider, system }: {
+    provider: any;
+    system: string;
+}): import("bare-agent").Loop;
+export type RuleRed = {
+    fn: string;
+    why: string;
+    quote: string | null;
+};
+import { scrubRaw } from './text.js';