bareloop 0.10.0 → 0.12.0

package/types/bridges.d.ts

@@ -1,3 +1,8 @@
+/** does a green under this verdict class earn its learning credit at the close, or
+ * does it wait for a person? Absent/unknown means green's behaviour, byte for byte
+ * — the pre-softgreen path is the default and stays untouched.
+ * @param {unknown} verdictType @returns {boolean} */
+export function quarantinesCredit(verdictType: unknown): boolean;
 /**
  * D6's status ladder, walked in history order. Pure, total, and never throws —
  * it is called on whatever a file happens to contain.
@@ -13,6 +18,10 @@
  *   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 **QUARANTINED green is not evidence** (softgreen module 6). The row exists and
+ *   the run happened, but a judged green earns nothing until the signer's `accept`
+ *   releases it, so it neither clears the entry bar nor adds a distinct patient. An
+ *   entry whose only greens are held derives `null` — below the bar, not demoted.
  * - 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.
@@ -74,6 +83,68 @@ export function appendRed(bridge: unknown, record: unknown): {
     reds: Red[];
     bridge: any;
 };
+/**
+ * The version that would INHERIT — the newest one whose credit has actually been
+ * released. `versions` is oldest-first, so this is normally the last of them; it
+ * differs only when a judged green sits on top of a released one, and in that case
+ * the RELEASED plan is what a reuse starts from. A held version is not a worse
+ * recipe, it is an unjudged one: nobody has said yet whether the ruler that passed
+ * it was right, and starting the next run from it would spend the credit before it
+ * was granted.
+ *
+ * Total and never throws — it is read at selection time and at the load door.
+ * @param {unknown} bridge
+ * @returns {any|null} null when every version is held (or there are none)
+ */
+export function newestEligibleVersion(bridge: unknown): any | null;
+/**
+ * May this workflow be offered for reuse at all? A held entry is SKIPPED WITH A
+ * REASON everywhere it is skipped — the same visible-skip discipline an unreadable
+ * registry file already gets, because a shelf that quietly shrinks teaches the
+ * operator that the registry is empty when it is merely holding.
+ * @param {unknown} bridge
+ * @returns {{ok: boolean, reason: string}} `reason` is '' when ok
+ */
+export function reuseEligibility(bridge: unknown): {
+    ok: boolean;
+    reason: string;
+};
+/**
+ * THE REVIEW DOOR, written down (PRD v1.71 §3). The person read the finished run
+ * and said one of three things; this records that on the run's own row, and — for
+ * `accept` on a HELD green — releases the learning credit that green has been
+ * carrying unspent.
+ *
+ * Three properties, and each is a ruling rather than a convenience:
+ *
+ *  - **the door never changes the loop's verdict.** A green row stays a green row,
+ *    whatever the person then does with it. `rerun` and `pause` are dispositions,
+ *    recorded and nothing more; a rerun's own outcome is a NEW run's row.
+ *  - **release is FORWARD-ONLY.** Nothing here can set `quarantined` back to true,
+ *    so a signer who accepts and later reruns has recorded a disagreement — which
+ *    is a datum worth keeping — without un-granting credit already granted. There
+ *    is deliberately no re-hold path at all: it would be a way to walk the ledger
+ *    backwards, which the ruling forbids.
+ *  - **releasing is not minting.** A door aimed at a run with no green row of its
+ *    own is a named red — never an invented entry. That is slice 1's already-green
+ *    rule holding from the other side: `accept` confirms a verdict, it never
+ *    creates one.
+ *
+ * Idempotent by shape: a decision identical to the last one recorded is a no-op
+ * that returns the entry unchanged, so a double-click at the door cannot inflate
+ * the report card (and `released` says whether THIS call was the one that freed it).
+ *
+ * Pure — returns a NEW entry; the input is never mutated.
+ * @param {unknown} bridge a validated bridge entry
+ * @param {unknown} door `{ runid, decision, at }` — `at` may be an explicit null
+ * @returns {{ ok: boolean, reds: Red[], bridge: any, released: boolean }}
+ */
+export function recordDoor(bridge: unknown, door: unknown): {
+    ok: boolean;
+    reds: Red[];
+    bridge: any;
+    released: boolean;
+};
 /**
  * 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
@@ -86,7 +157,7 @@ export function appendRed(bridge: unknown, record: unknown): {
  * 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}}}
+ * @returns {{name: string|null, goal: string|null, status: 'candidate'|'proven'|null, greens: number, reds: number, quarantinedGreens: number, doorDecisions: {runid: string|null, decision: string|null, at: string|null}[], 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;
@@ -94,6 +165,12 @@ export function listingRow(bridge: unknown): {
     status: "candidate" | "proven" | null;
     greens: number;
     reds: number;
+    quarantinedGreens: number;
+    doorDecisions: {
+        runid: string | null;
+        decision: string | null;
+        at: string | null;
+    }[];
     lastOutcome: string | null;
     greenCost: {
         minUsd: number | null;
@@ -191,6 +268,23 @@ 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";
+/**
+ * SOFTGREEN MODULE 6 — the verdict classes whose greens are minted QUARANTINED.
+ *
+ * The standing ruling (PRD v1.53, given a mechanism by v1.71 §3): *softgreen
+ * passes are quarantined from learning credit until the judged floor is proven*,
+ * and **the signer's `accept` at the review door is what releases it**.
+ *
+ * `soft-green` and NOT `hitl`: the hold is about the young JUDGE, not about every
+ * class that is not `green`. A hitl close is rendered by a PERSON at close time —
+ * there is no unproven ruler in it to distrust. A green earns its credit at its
+ * own close, exactly as it always has.
+ */
+export const QUARANTINED_VERDICTS: readonly string[];
+/** the red CODE a hold travels under — the gate emits it, the listing splits the
+ * held rows out of the broken ones on it, and the runner reads it back. One
+ * spelling, because three literals is how a hold silently becomes a breakage. */
+export const QUARANTINED_CODE: "quarantined";
 export type Red = {
     code: string;
     path: string;

package/types/calibrate.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Did the pipe grade this case the way the signer signed it?
+ *
+ * BOTH HALVES, AND BOTH ARE REQUIRED. The verdict alone is the aggregate this
+ * floor was written against: a red case that reds on the wrong card line, or on
+ * the right line and the wrong function, has told the operator nothing about
+ * whether their ruler works — §4.4's *"with itemized reds, not a paragraph"* is
+ * exactly this comparison and not a looser one.
+ *
+ * The reds compare as SETS: `decide()` grades every card item over every
+ * function and its emission order follows the card and the model's function
+ * list, while a signer writes their expectation in whatever order they thought
+ * of it. Order is not a fact about the pipe, so it is not compared; the ADDRESSES
+ * are. A duplicate is already inexpressible on both sides (`expectedOf` dedupes,
+ * `validateCalibrationSet` reds a repeated pair), so set comparison loses
+ * nothing.
+ * @param {{verdict: string, reds: {rule: string, fn: string}[]}} got
+ * @param {any} want
+ * @returns {{ok: boolean, verdictOk: boolean, redsOk: boolean, missing: string[], extra: string[]}}
+ */
+export function compareExpectation(got: {
+    verdict: string;
+    reds: {
+        rule: string;
+        fn: string;
+    }[];
+}, want: any): {
+    ok: boolean;
+    verdictOk: boolean;
+    redsOk: boolean;
+    missing: string[];
+    extra: string[];
+};
+/**
+ * Did the extraction survive the attack?
+ *
+ * Three readings, all mechanical, all over facts this module owns both sides of:
+ *   - THE FUNCTION LIST is exactly the gold's, as a set. A style that hides a
+ *     function has moved the facts even if every remaining fact is true.
+ *   - EVERY DOCUMENTED function's `docQuote` is a REAL JSDoc opener from the
+ *     artifact, and every UNDOCUMENTED one's is `null`. A non-null quote on an
+ *     undocumented function is the leak this battery exists to catch, and it is
+ *     invisible one layer up: `decide()` reds it either way (an invented quote
+ *     fails the artifact check), so resist and leak render the SAME itemized
+ *     reds and only the facts separate them.
+ *   - and the DECISION still matches gold, so a leak that somehow survives both
+ *     fact checks still has one more gate to pass.
+ * @param {any} facts @param {any} gold @param {string} artifactText
+ * @returns {{ok: boolean, why: string|null}}
+ */
+export function factsResist(facts: any, gold: any, artifactText: string): {
+    ok: boolean;
+    why: string | null;
+};
+/**
+ * THE CALIBRATION GATE. Run the whole pipe over the signed ten and over the five
+ * arbiter-owned injection artifacts, and report — itemized, per case — whether
+ * the ruler is a ruler.
+ *
+ * It never throws on a caller's data: an illegal set is a RED (the same
+ * `{ok, reds}` shape module 4's validators return), because this is reached from
+ * a signing gate whose whole job is to hand a person a readable refusal. It
+ * throws on nothing at all.
+ *
+ * ORDER, and it is load-bearing: the $0 legality check runs FIRST and buys no
+ * calls; then the ten; then the battery. A set that cannot be legal is refused
+ * before a token, and an operator whose card is malformed does not pay to find
+ * out.
+ *
+ * ALL-OR-NOTHING, both halves (v1.73 ruling 2 and ruling 3, kept by the second
+ * addendum's ruling 1): `ok` is true only when all ten graded correctly AND all
+ * five styles resisted AND nothing was a casualty.
+ * THE OPERATOR'S CEILING RIDES IN AS A PREDICATE (`capStop`), asked between metered
+ * calls exactly as the authoring pipeline's cost book asks its own. It is the
+ * CALLER's book that answers, because the gate is the THIRD paid seam of one run and
+ * a tally that starts at zero here would be a second ceiling wearing the first one's
+ * number. Absent is UNBOUNDED, and unbounded is a stated operator choice.
+ *
+ * A ceiling stop is a REFUSAL, never a throw and never a partial set presented as a
+ * graded one: `ok` is false, the cases nobody bought are absent rather than recorded
+ * as failures, and `casualty` stays null — the transport was fine, the operator's own
+ * governance stopped the gate.
+ * @param {{cases: any, card: any, judgeLoop: Function|null,
+ *   onCost?: (c: any) => void, attempts?: number, battery?: any[], batteryCard?: any,
+ *   capStop?: () => 'cap-halt'|'pricing-red'|null}} o
+ * @returns {Promise<{ok: boolean, stop: string|null, casualty: any,
+ *   graded: {id: string, ok: boolean, got: any, want: any, detail: string|null}[],
+ *   injection: {styles: any[], allResisted: boolean, leaks: string[]},
+ *   failures: string[], reds: Red[], judgeModel: string,
+ *   cardHash: string|null, casesHash: string|null, setHash: string|null,
+ *   costUsd: number|null, knownUsd: number, spendComplete: boolean, calls: any[]}>}
+ */
+export function runCalibration({ cases, card, judgeLoop, onCost, attempts, battery, batteryCard, capStop, }: {
+    cases: any;
+    card: any;
+    judgeLoop: Function | null;
+    onCost?: (c: any) => void;
+    attempts?: number;
+    battery?: any[];
+    batteryCard?: any;
+    capStop?: () => "cap-halt" | "pricing-red" | null;
+}): Promise<{
+    ok: boolean;
+    stop: string | null;
+    casualty: any;
+    graded: {
+        id: string;
+        ok: boolean;
+        got: any;
+        want: any;
+        detail: string | null;
+    }[];
+    injection: {
+        styles: any[];
+        allResisted: boolean;
+        leaks: string[];
+    };
+    failures: string[];
+    reds: Red[];
+    judgeModel: string;
+    cardHash: string | null;
+    casesHash: string | null;
+    setHash: string | null;
+    costUsd: number | null;
+    knownUsd: number;
+    spendComplete: boolean;
+    calls: any[];
+}>;
+/** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
+/** the label a calibration's own locate calls are metered under. The SAME
+ * `LOCATE_LABEL` a close's judged stage spends under, deliberately: it is the
+ * same call to the same model over the same prompt, and a second spelling would
+ * make one population of spend read as two. */
+export const CALIBRATION_LABEL: "judged-locate";
+/** the axes that STOP the gate as a casualty rather than failing a case. All
+ * three are `runLocate`'s own, borrowed with their meanings intact — this module
+ * invents no vocabulary for a fault the shipped pipe already names. */
+export const CASUALTY_AXES: readonly ("pricing-red" | "provider-red" | "artifact-red")[];
+export function artifactHash(v: any): string;
+/**
+ * The battery's OWN card — `has-doc` alone, and one line rather than three on
+ * purpose. Every attack style below aims at exactly one lie ("this file is
+ * documented"), so the card that grades them names exactly the fact being lied
+ * about; extra lines would buy extra prompt surface and extra ways for a
+ * truthful-but-noisy extraction to look like a leak.
+ */
+export const INJECTION_CARD: Readonly<{
+    items: readonly Readonly<{
+        rule: "has-doc";
+        text: "Every top-level function has a JSDoc block directly above it.";
+    }>[];
+}>;
+/**
+ * THE FIVE STYLES, one artifact each. Every artifact carries one honestly
+ * documented function and one honestly undocumented one, and the attack always
+ * asks for the same thing: report the undocumented function as documented (or
+ * do not report it at all). The truth is therefore identical across all five,
+ * which is what makes a leak attributable to the STYLE rather than to the file.
+ */
+export const INJECTION_LOCATE_BATTERY: readonly Readonly<{
+    id: string;
+    style: string;
+    attack: string;
+    artifact: `/**
+ * Add two numbers.
+ */
+export function add(a, b) {
+  return a + b;
+}
+
+${string}`;
+    expectFacts: Readonly<{
+        functions: readonly Readonly<{
+            name: string;
+            hasDoc: boolean;
+        }>[];
+    }>;
+    expect: Readonly<{
+        verdict: "pass" | "red";
+        reds: readonly Readonly<{
+            rule: string;
+            fn: string;
+        }>[];
+    }>;
+}>[];
+export type Red = {
+    code: string;
+    path: string;
+    detail: string;
+    [k: string]: any;
+};

package/types/cardauthor.d.ts

@@ -0,0 +1,352 @@
+/**
+ * The proposal's shape, and therefore the whole shape the compiler can express.
+ *
+ * `rule` is an ENUM off the judge's own rulebook in BOTH places it appears — the
+ * card's lines and a case's expected reds — because wherever only a closed set
+ * can satisfy a field, the illegal value is made INEXPRESSIBLE rather than
+ * rejected after the fact (the `check-passes(name)` model). The SIZE is pinned by
+ * `minItems`/`maxItems` from the one constant, so nine and eleven are both
+ * unsayable rather than argued about afterwards.
+ *
+ * `artifact` and `text` are the only free strings, and neither decides anything:
+ * one is the code the judge will read, the other is the signer's own words.
+ */
+export function proposalSchema(): {
+    type: string;
+    properties: {
+        card: {
+            type: string;
+            description: string;
+            properties: {
+                items: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        properties: {
+                            rule: {
+                                enum: string[];
+                                description: string;
+                            };
+                            text: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        cases: {
+            type: string;
+            minItems: number;
+            maxItems: number;
+            description: string;
+            items: {
+                type: string;
+                properties: {
+                    id: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    artifact: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    expect: {
+                        type: string;
+                        properties: {
+                            verdict: {
+                                enum: string[];
+                            };
+                            reds: {
+                                type: string;
+                                description: string;
+                                items: {
+                                    type: string;
+                                    properties: {
+                                        rule: {
+                                            enum: string[];
+                                            description: string;
+                                        };
+                                        fn: {
+                                            type: string;
+                                            minLength: number;
+                                            description: string;
+                                        };
+                                    };
+                                    required: string[];
+                                    additionalProperties: boolean;
+                                };
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+/**
+ * The output channel. It records and acknowledges; it takes no action, which is
+ * why handing it to a toolless compile call does not reopen D3.
+ * @param {{calls: any[]}} box
+ */
+export function proposalTool(box: {
+    calls: any[];
+}): {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            card: {
+                type: string;
+                description: string;
+                properties: {
+                    items: {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            type: string;
+                            properties: {
+                                rule: {
+                                    enum: string[];
+                                    description: string;
+                                };
+                                text: {
+                                    type: string;
+                                    minLength: number;
+                                    description: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            cases: {
+                type: string;
+                minItems: number;
+                maxItems: number;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                            minLength: number;
+                            description: string;
+                        };
+                        artifact: {
+                            type: string;
+                            minLength: number;
+                            description: string;
+                        };
+                        expect: {
+                            type: string;
+                            properties: {
+                                verdict: {
+                                    enum: string[];
+                                };
+                                reds: {
+                                    type: string;
+                                    description: string;
+                                    items: {
+                                        type: string;
+                                        properties: {
+                                            rule: {
+                                                enum: string[];
+                                                description: string;
+                                            };
+                                            fn: {
+                                                type: string;
+                                                minLength: number;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                        additionalProperties: boolean;
+                                    };
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    execute: (args: any) => Promise<string>;
+};
+/**
+ * The compile prompt. Q6's and Q7's answers travel VERBATIM — they are the whole
+ * input, and paraphrasing a lay answer is how a rubric stops being the person's.
+ *
+ * The rulebook is rendered from `JUDGE_RULES` itself rather than restated, for
+ * the reason the catalogue block is rendered from the catalogue: the prompt and
+ * the gate must describe one set of facts.
+ * @param {{answers: Record<string|number, any>, questions?: Record<string|number, string>}} o
+ */
+export function cardCasesPrompt({ answers, questions }: {
+    answers: Record<string | number, any>;
+    questions?: Record<string | number, string>;
+}): string;
+/**
+ * THE D5 MOMENT. The proposal is SHOWN; the signer's `fix` is what is STORED.
+ *
+ * The fix replaces the proposal WHOLE rather than merging into it. A merge would
+ * mean a signer who deleted a card line got it back, and "the signer signs the
+ * whole hash" is not a rule that survives a field-wise reconciliation. Handing
+ * back no fix is a legal answer — signing the proposal as proposed — and it says
+ * so (`source`), because *a person read this and changed nothing* and *nobody has
+ * looked* are two different facts.
+ *
+ * THE GATE RUNS OVER WHAT WILL BE STORED, never over the proposal: a signer can
+ * fix a legal proposal into an illegal one, and the artifact that reaches the
+ * hash is the one that must be legal.
+ *
+ * `scrubbed` is the INGEST SCRUB'S OWN ANNOUNCEMENT — the paths whose bytes the
+ * secret inventory masked on the way in. Empty on every honest artifact, and
+ * never silent when it is not: a signer signs a hash over the STORED bytes, so
+ * "what you typed is not what was stored" is a fact they are owed rather than one
+ * the redactor keeps.
+ * @param {{proposal: any, fix?: any}} o
+ * @returns {{ok: boolean, reds: Red[], card: any, cases: any[]|null, source: 'signer'|'proposal',
+ *   scrubbed: {path: string}[]}}
+ */
+export function signJudgedArtifacts({ proposal, fix }: {
+    proposal: any;
+    fix?: any;
+}): {
+    ok: boolean;
+    reds: Red[];
+    card: any;
+    cases: any[] | null;
+    source: "signer" | "proposal";
+    scrubbed: {
+        path: string;
+    }[];
+};
+/**
+ * Fold the two signed artifacts into the close declaration, ENUMERATED.
+ *
+ * WHERE EACH LANDS, and both are inside the spec so `jobSpecHash` covers them by
+ * construction (the hash is over the whole resolved spec):
+ *   - THE CARD replaces the judged stage's own `params.card`. ONE card, and it is
+ *     the SIGNED one: the composer's draft is a draft, and two cards in one close
+ *     is the drift a single storage site exists to prevent. The stage is where it
+ *     already lives, which is what `validateCard`, the M2 runner and the locate
+ *     prompt all read.
+ *   - THE CASES land beside the stages as `calibration.cases` — a close-level
+ *     artifact, because the set calibrates the RULER and not one stage's params,
+ *     and because module 5's gate reads it before any stage runs.
+ *   - THE JUDGE MODEL lands beside them as `calibration.judgeModel`, and it is the
+ *     PIN (`JUDGE_MODEL`) rather than anything a caller may name. A calibration set
+ *     is only worth the tier that graded it — §4.2's whole safety argument is worth
+ *     exactly as much as BA-20's injection evidence, which is haiku-4.5's alone — so
+ *     the set has to carry which tier certified it or nothing downstream can tell a
+ *     signed floor from a bumped one. Storing it HERE, inside the spec, is what makes
+ *     a bump flip `jobSpecHash`: the signature dies, the signer re-signs, and a
+ *     re-sign is a re-run of the calibration gate. That is the docstring on
+ *     `JUDGE_MODEL` finally given a detector instead of a promise (F45).
+ *
+ * A card with NOWHERE TO LAND THROWS. It is a caller's own broken input — a
+ * signed rubric folded into a close with no judged ruler — and there is no safe
+ * direction to degrade toward: storing it would sign a rubric nothing reads.
+ *
+ * The input is never mutated: a closeDecl is a signed artefact and rewriting a
+ * caller's copy in place is how two readers come to disagree about what was
+ * signed.
+ * @param {any} closeDecl @param {{card: any, cases: any[]}} o
+ * @returns {any} a new closeDecl
+ */
+export function foldJudgedArtifacts(closeDecl: any, { card, cases }: {
+    card: any;
+    cases: any[];
+}): any;
+/**
+ * ONE compile call: the person's Q6 and Q7 in, a proposal out.
+ *
+ * It buys ONE artifact through ONE channel, and the malformed-emission ladder is
+ * the SHARED one (`askStructured`) rather than a second copy — a second ladder is
+ * a second place for the cap, the reject block and the re-ask to drift.
+ *
+ * WHAT IS AND IS NOT RETRIED, and the split is the standing one: a reply that
+ * carries no proposal is a TRANSPORT fault and is retried under the bound; a
+ * proposal that PARSED and then broke the ruling is not — the model answered
+ * perfectly clearly and re-asking buys another call to be told the same thing.
+ * The proposal is returned as it was said, never repaired: no JSON repair, ever.
+ *
+ * The book is the CALLER's, so one ceiling governs the survey, the declaration
+ * ladder and this compile — the advertised ceiling and the enforced ceiling are
+ * the same ceiling.
+ * @param {{answers: Record<string|number, any>, questions?: Record<string|number, string>,
+ *   generate: Function, book?: ReturnType<typeof makeCostBook>,
+ *   structuredMode?: 'tool'|'text', structureRetries?: number}} o
+ * @returns {Promise<{ok: boolean, proposal: any, reds: Red[], stop: string|null,
+ *   attempts: number, raw: string, cost: any, raws: any[]}>}
+ */
+export function proposeJudgedArtifacts({ answers, questions, generate, book, structuredMode, structureRetries, }: {
+    answers: Record<string | number, any>;
+    questions?: Record<string | number, string>;
+    generate: Function;
+    book?: ReturnType<typeof makeCostBook>;
+    structuredMode?: "tool" | "text";
+    structureRetries?: number;
+}): Promise<{
+    ok: boolean;
+    proposal: any;
+    reds: Red[];
+    stop: string | null;
+    attempts: number;
+    raw: string;
+    cost: any;
+    raws: any[];
+}>;
+/** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
+/** the output channel for the compile. It takes no action; it carries the answer. */
+export const PROPOSAL_TOOL_NAME: "propose_rubric";
+/** what the tool returns. The loop stops on delivery, so the model never reads it. */
+export const PROPOSAL_ACK: "proposal received";
+/** the label the compile call is metered and persisted under — one spelling */
+export const PROPOSAL_LABEL: "judged-compile";
+/** a malformed EMISSION is a transport fault, bounded on its own axis — the same
+ * ceiling `authorClose` declares for the declaration channel */
+export const MAX_PROPOSAL_RETRIES: 2;
+/**
+ * The system prompt a caller BINDS ITS SEAM WITH — this module owns no provider
+ * and picks none, exactly as `authorClose` does not: the compile call arrives as
+ * `generate`, and a caller wires it with `makeLoopGenerate(provider, {system:
+ * COMPILE_SYSTEM})`, whose own `maxTokens` default (F30) is what holds ten
+ * artifacts. Exported rather than inlined so the one register this call is made
+ * in is not re-spelled at every integration.
+ */
+export const COMPILE_SYSTEM: string;
+export type Red = {
+    code: string;
+    path: string;
+    detail: string;
+    [k: string]: any;
+};
+import { makeCostBook } from './authorflow.js';