bareloop 0.10.0 → 0.12.0

package/types/authorflow.d.ts

@@ -32,12 +32,21 @@ export function schemaCoverage(catalogue?: Record<string, any>): {
  * and they arrive as validation reds through the revise loop — a schema that
  * tried to restate them would be a second validator.
  *
+ * `verdictType` narrows the branches to the kinds the picked class may express
+ * (softgreen module 3, `classMenu`): a green job cannot SPELL `judged-floor`,
+ * rather than spelling it and being told afterwards. COVERAGE is still computed
+ * over the WHOLE catalogue — the class filter must never make a parameter look
+ * orphaned and turn a menu narrowing into a catalogue-drift alarm.
+ *
  * THROWS on a catalogue it cannot cover: a malformed catalogue is a bareloop bug,
  * and failing loudly beats emitting a schema that quietly cannot say something
  * the validator will then demand.
  * @param {Record<string, any>} [catalogue]
+ * @param {{verdictType?: string|null}} [o]
  */
-export function declarationSchema(catalogue?: Record<string, any>): {
+export function declarationSchema(catalogue?: Record<string, any>, { verdictType }?: {
+    verdictType?: string | null;
+}): {
     type: string;
     properties: {
         stages: {
@@ -86,12 +95,13 @@ export function declarationSchema(catalogue?: Record<string, any>): {
  * The output channel. It records and acknowledges; it takes no action, which is
  * why handing it to a toolless authoring call does not reopen D3.
  * @param {{calls: any[]}} box
- * @param {{catalogue?: Record<string, any>}} [o]
+ * @param {{catalogue?: Record<string, any>, verdictType?: string|null}} [o]
  */
 export function declarationTool(box: {
     calls: any[];
-}, { catalogue }?: {
+}, { catalogue, verdictType }?: {
     catalogue?: Record<string, any>;
+    verdictType?: string | null;
 }): {
     name: string;
     description: string;
@@ -146,9 +156,19 @@ export function declarationTool(box: {
  * The catalogue, as the authoring call sees it — rendered FROM the catalogue, so
  * the prompt and the validator judge one set of facts. `shape` and `asserts` are
  * M2's own strings.
+ *
+ * `verdictType` narrows it to the picked class's menu, exactly as it narrows the
+ * schema — the prompt and the tool must offer ONE set of kinds, or the composer
+ * reads about a kind it cannot call. A kind above the ceiling is omitted rather
+ * than rendered as unavailable: a LOCKED row says "this does not run in v1",
+ * which is a fact about the build; "not for your class" is a fact about a choice
+ * the person already made, and printing it invites the composer to argue with it.
  * @param {Record<string, any>} [catalogue]
+ * @param {{verdictType?: string|null}} [o]
  */
-export function catalogueBlock(catalogue?: Record<string, any>): string;
+export function catalogueBlock(catalogue?: Record<string, any>, { verdictType }?: {
+    verdictType?: string | null;
+}): string;
 /**
  * HOW THE GENRE'S OWN TOOLS PRINT — rendered FROM `genreInstruments`, so the
  * pattern the author is handed and the pattern the tree already grades with are
@@ -346,9 +366,25 @@ export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }: {
  * run could not be read afterwards. A cost entry with no raw beside it is that
  * run again.
  */
-/** @param {{ceilingUsd?: number|null}} [o] the OPERATOR's ceiling; `null`/absent is UNBOUNDED */
-export function makeCostBook({ ceilingUsd }?: {
+/**
+ * @param {{ceilingUsd?: number|null,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void}} [o]
+ *   `ceilingUsd` is the OPERATOR's ceiling; `null`/absent is UNBOUNDED.
+ *   `onCall` is a REPORTING seam fired as each metered call lands — the shell's
+ *   only chance to know what has been spent while the run is still alive. It is
+ *   never consulted and never governs: `capStop` below is still the one
+ *   predicate, still asked between calls, and still reads the same `entries`.
+ *   `absorb` deliberately does NOT fire it: those calls were metered (and
+ *   reported) by whoever made them, and reporting them twice would double the
+ *   scout's spend in every reader downstream.
+ */
+export function makeCostBook({ ceilingUsd, onCall }?: {
     ceilingUsd?: number | null;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
 }): {
     /** @param {string} label @param {any} r a bare-agent run result @param {number} [attempt] */
     add(label: string, r: any, attempt?: number): {
@@ -417,6 +453,48 @@ export function makeLoopGenerate(provider: any, { system, maxTokens }?: {
     system?: string;
     maxTokens?: number;
 }): (messages: any[], tools: any[], opts?: any) => Promise<any>;
+/**
+ * ONE structured ask, with the malformed-emission retry bounded on its OWN axis.
+ * A reply that carries no artifact is an ARTIFACT-RED — name the axis, retry
+ * under a cap, write nothing — and it never consumes a revision, because a
+ * transport fault is not a defect in a close.
+ *
+ * THE CHANNEL IS A PARAMETER, and that is softgreen module 4's only change here:
+ * the rubric card and the calibration set are a SECOND schema-forced emission
+ * with the same failure modes, and a second ladder is a second place for the cap,
+ * the reject block and the re-ask to drift. The declaration channel below is the
+ * one this loop has always used, spelled out rather than inlined — nothing about
+ * the authoring path's behaviour moves.
+ * @param {{messages: any[], generate: Function, mode: 'tool'|'text', retries: number,
+ *   label: string, book: ReturnType<typeof makeCostBook>,
+ *   channel: {name: string, instruction: string, textPath?: string, tool: (box: {calls: any[]}) => any}}} o
+ * @returns {Promise<{artifact: any, attempts: number, convo: any[], raw: string,
+ *   providerError: string|null, red: Red|null, budget: 'cap-halt'|'pricing-red'|null}>}
+ */
+export function askStructured({ messages, generate, mode, retries, label, book, channel }: {
+    messages: any[];
+    generate: Function;
+    mode: "tool" | "text";
+    retries: number;
+    label: string;
+    book: ReturnType<typeof makeCostBook>;
+    channel: {
+        name: string;
+        instruction: string;
+        textPath?: string;
+        tool: (box: {
+            calls: any[];
+        }) => any;
+    };
+}): Promise<{
+    artifact: any;
+    attempts: number;
+    convo: any[];
+    raw: string;
+    providerError: string | null;
+    red: Red | null;
+    budget: "cap-halt" | "pricing-red" | null;
+}>;
 /**
  * THE AUTHORING FLOW.
  *
@@ -450,10 +528,12 @@ export function makeLoopGenerate(provider: any, { system, maxTokens }?: {
  *   listing?: {stop: string|null, files: string[]|null, block: string|null, meta: any}|null,
  *   generate: Function, seedReadFn?: Function, closeCtx?: any,
  *   ceilingUsd?: number|null,
+ *   onPhase?: (phase: string, data?: any) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   maxRevisions?: number, structureRetries?: number,
  *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>}} o
  */
-export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, scout, listing, generate, seedReadFn, closeCtx, ceilingUsd, maxRevisions, structureRetries, structuredMode, catalogue, }: {
+export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, scout, listing, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue, }: {
     workdir: string;
     seedRef: string;
     lang: string;
@@ -479,6 +559,12 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
     seedReadFn?: Function;
     closeCtx?: any;
     ceilingUsd?: number | null;
+    onPhase?: (phase: string, data?: any) => void;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
     maxRevisions?: number;
     structureRetries?: number;
     structuredMode?: "tool" | "text";
@@ -529,28 +615,112 @@ export const STRUCTURE_INSTRUCTION_TEXT: string;
  * cannot emit anything else (D2/D3), so a genre it has never seen is a
  * composition problem, not a catalogue problem.
  *
- * The GREEN set is questions 1–6 of the frozen TYPES set (prereg §5) BYTE FOR
- * BYTE. What is gone is the seventh slot — D13's genre CONFIRM ("this looks like
- * a type-fixing job, correct?") — superseded in full: the interview never asks
- * about a genre again. The refusal it carried did not disappear; it MOVED to the
- * composer, on the same counted `request-red` path (see `authorCloseForJob`).
- * The remaining six are already genre-neutral, which is why generalising them
- * required deleting a slot rather than rewording one.
+ * The GREEN set descends from questions 1–6 of the frozen TYPES set (prereg §5).
+ * TWO slots have been deleted since, both because the interview was ASKING FOR
+ * SOMETHING IT ALREADY HAD or already knew:
+ *
+ *   - D13's genre CONFIRM ("this looks like a type-fixing job, correct?") —
+ *     superseded in full: the interview never asks about a genre again, and the
+ *     refusal it carried MOVED to the composer, on the same counted
+ *     `request-red` path (see `authorCloseForJob`);
+ *   - "Is there a code repo I can look at? Where?" — DROPPED on hamr's ruling
+ *     after he drove the terminal interview himself (2026-08-15, verbatim: *"drop
+ *     Q6"*). The repository is a MANDATORY, STRUCTURED input already —
+ *     `runInterview`'s own `repoPath`, which the runner takes from `--patient` and
+ *     refuses to start without. Asking a person to re-type in prose a path the
+ *     machine is holding in a variable is the SWE tax this product refuses, and
+ *     it invites a second, drifting answer for the same fact (hamr's own answer
+ *     on the live run was *"Yes — the patient itself."*). Nothing downstream lost
+ *     anything: the scout reads `repoPath`, never the answer.
+ *
+ * Question 2 was WIDENED in the same ruling: it now asks for the read-or-draw-from
+ * files as well as the ones that change. The two halves belong in one answer
+ * because they are one decision for the person answering — what the work touches,
+ * and what it touches only to look at.
+ *
+ * The five that remain are genre-neutral, which is why every generalisation so far
+ * has deleted a slot rather than reworded one. They are NUMBERED CONTIGUOUSLY from
+ * 1: the number a person sees is the key their answer is filed under, and a gap
+ * would be a hole in a form nobody can explain.
  */
 export const GREEN_QUESTIONS: Readonly<{
     1: "What do you want done?";
-    2: "Which files or folders should change?";
+    2: "Which files or folders should change? And which files should the work read or draw from (they stay untouched)?";
+    3: "Is there anything that must not change?";
+    4: "How do you check today whether it's working?";
+    5: "What would make you say this came back worse than before?";
+}>;
+/**
+ * THE HITL SET (N4 slice 1) — the green questions BYTE FOR BYTE, plus one.
+ *
+ * The five are unchanged deliberately rather than economically: the
+ * mechanical-first composition law (2026-08-07) says every hitl close is
+ * *deterministic stages first, judge minimal, human last*, so a hitl job needs
+ * exactly the same mechanical facts a green one does — what changes, what must
+ * not, how it is checked today, what "worse" looks like. Rewording them would
+ * fork one interview into two that drift.
+ *
+ * The last one is the only thing the green set cannot supply, and it is not a
+ * flourish: `human-confirms` requires an `ask` — the question the signer answers
+ * at the end of the run — and nothing else in the interview names it. Without it
+ * the composer would have to invent what a person is deciding, which is the one
+ * thing a human stage must never have done for it. It is the SPREAD's next number
+ * rather than a fixed one, so a green-side deletion renumbers it instead of
+ * leaving a gap (it was 7 while the green set held six, and is 6 now it holds five).
+ */
+export const HITL_QUESTIONS: Readonly<{
+    6: "When you look at the finished result yourself, what are you deciding?";
+    1: "What do you want done?";
+    2: "Which files or folders should change? And which files should the work read or draw from (they stay untouched)?";
+    3: "Is there anything that must not change?";
+    4: "How do you check today whether it's working?";
+    5: "What would make you say this came back worse than before?";
+}>;
+/**
+ * THE SOFTGREEN SET (module 3, design record §4.6) — the green questions BYTE
+ * FOR BYTE, plus TWO.
+ *
+ * Same discipline as the hitl set, and for the same reason: a softgreen close is
+ * *mechanical stages first, the judged stage after* (§4.5), so a softgreen job
+ * needs every mechanical fact a green one does. No renumbering of the green set,
+ * no genre question, nothing reworded.
+ *
+ * The two additions are the only things the green set cannot supply, and neither
+ * is a flourish — they are the judged floor's two REQUIRED inputs:
+ *   - Q6 becomes the RUBRIC CARD (§4.3): the person's own pass/fail lines,
+ *     compiled into enumerated items, signed, and enumerated in the spec hash.
+ *     The documented ceiling rides with it — the judge catches violations of
+ *     STATED card items only, and the fix for a miss is a new card line and a
+ *     re-sign, never a smarter judge.
+ *   - Q7 becomes the frozen CALIBRATION SET (§4.4): the whole pipe must grade it
+ *     correctly before the close is signable.
+ * Both are asked in the person's own terms — an example they would pass and one
+ * they would fail, not a rubric they are asked to write — because compiling a lay
+ * answer into extractable items is the LLM's job (D5, proposed-and-signed) and
+ * asking the person to do it is the SWE tax this product refuses.
+ *
+ * What the two answers COMPILE INTO is module 4. This module carries them
+ * exactly as the hitl set carries its own last answer: they ride in `answers`,
+ * they reach the composer verbatim through the prompt's interview block, and
+ * nothing here derives anything from them.
+ */
+export const SOFTGREEN_QUESTIONS: Readonly<{
+    6: "When you judge the result yourself, what separates a pass from a fail? Name the few things you actually look for.";
+    7: "Give one example you'd pass and one you'd fail, and say why.";
+    1: "What do you want done?";
+    2: "Which files or folders should change? And which files should the work read or draw from (they stay untouched)?";
     3: "Is there anything that must not change?";
     4: "How do you check today whether it's working?";
     5: "What would make you say this came back worse than before?";
-    6: "Is there a code repo I can look at? Where?";
 }>;
 /**
- * The three sets. `questions: null` on a locked class is ABSENT, never `{}`:
- * an empty set would read as "this class needs no questions", which is a
- * different and false statement (F59's distinction, at the interview layer).
- * Nothing ever reads them — a locked class refuses at ADMISSION, before its
- * questions run — and the two readers below throw rather than hand back nothing.
+ * The three sets, all LIVE as of softgreen module 3. The locked shape stays
+ * spelled out in the readers below rather than deleted with the last locked
+ * class: `questions: null` is ABSENT, never `{}` — an empty set would read as
+ * "this class needs no questions", a different and false statement (F59's
+ * distinction, at the interview layer) — and a locked class refuses at ADMISSION,
+ * before its questions run, so the two readers throw rather than hand back
+ * nothing. A fourth class arrives locked, and the machinery is here for it.
  * @type {Record<string, {locked: boolean, questions: Record<string|number, string>|null, required: readonly number[]|null}>}
  */
 export const QUESTION_SETS: Record<string, {
@@ -754,6 +924,48 @@ export const PARAM_SCHEMAS: Readonly<{
     requireNonEmpty: {
         const: boolean;
     };
+    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;
+    };
+    paths: {
+        type: string;
+        minItems: number;
+        maxItems: number;
+        items: {
+            type: string;
+        };
+        description: string;
+    };
+    ask: {
+        type: string;
+        minLength: number;
+        description: string;
+    };
 }>;
 export type Red = {
     code: string;

package/types/authoring.d.ts

@@ -9,10 +9,11 @@
  * `CLASS_BY_VERDICT` exist to stop, defeated from ABOVE by never letting the
  * illegal pair be formed.
  *
- * INERT IN v1 BY CONSTRUCTION, which is why it is cheap now: every LIVE kind is
- * mechanical, so no declaration a v1 catalogue can express reaches above green.
- * It is written before the second class exists so the first soft-green kind is
- * not the thing that discovers the question.
+ * NO LONGER INERT: `human-confirms` (N4 slice 1) and `judged-floor` (softgreen
+ * module 2) are both live and both above green, so a green declaration naming
+ * one is a real red rather than a hypothetical. `classMenu` below is the other
+ * half of the same rule, applied one step earlier — the composer is never handed
+ * a kind this would refuse.
  *
  * A kind the catalogue does not know contributes NOTHING — it already carries an
  * `unknown-kind` red, and guessing a class for it would be deriving the promise
@@ -28,6 +29,31 @@ export function closeCeiling(declaration: any, catalogue?: Record<string, KindSp
     stage: string | null;
     locked: boolean;
 } | null;
+/**
+ * THE MENU A JOB OF THIS CLASS MAY EXPRESS — the ceiling rule, moved one step
+ * EARLIER, to the moment the composer is handed its vocabulary.
+ *
+ * `closeCeiling` refuses an above-ceiling kind AFTER a paid call has composed a
+ * declaration around it. That is a late red for an illegal pick the composer was
+ * shown in its own catalogue and its own tool schema — and the standing rule is
+ * the opposite: wherever only a closed set can satisfy a field, hand over the
+ * enumerated set, so the illegal value is INEXPRESSIBLE rather than rejected
+ * after the fact (the `check-passes(name)` model). A green job is therefore never
+ * shown `judged-floor` or `human-confirms` at all.
+ *
+ * ONLY THE MENU NARROWS. The VALIDATOR keeps the whole catalogue, deliberately:
+ * a model that names a kind it was never offered must be told which RULE it
+ * broke (`class-ceiling`), not that the kind does not exist (`unknown-kind`) —
+ * one is the truth and the other invites it to invent a spelling.
+ *
+ * `null` means UNFILTERED and exists for callers inspecting the catalogue itself
+ * (the schema/coverage suite). Every composing call site passes the user's own
+ * picked class; `authorPrompt` already throws without one.
+ * @param {string|null} verdictType
+ * @param {Record<string, KindSpec>} [catalogue]
+ * @returns {string[]} kind names at or below the picked class, in catalogue order
+ */
+export function classMenu(verdictType: string | null, catalogue?: Record<string, KindSpec>): string[];
 /**
  * Which kinds can carry an environment at all, read off the CATALOGUE rather
  * than a hand-kept list. ONE spelling, because two consumers must agree
@@ -290,9 +316,17 @@ export function normalizeDeclaration(declaration: any): any;
 /** @typedef {{required: readonly string[], optional: readonly string[], pathParams: readonly string[], locked?: true, verdictClass: string, shape: string, asserts: string}} KindSpec */
 /** the whole menu, in ascending order of what it takes to render the verdict */
 export const VERDICT_CLASSES: readonly string[];
-/** declared-but-locked: selecting one is COUNTED demand, never an admission */
+/** declared-but-locked: selecting one is COUNTED demand, never an admission.
+ * `hitl` LEFT this list at N4 slice 1 and `soft-green` at softgreen module 3
+ * (see `src/job.js`'s twin, `LOCKED_VERDICTS`, which moved in the same commit) —
+ * the judged floor its lock was waiting on is built, wired and calibrated.
+ *
+ * EMPTY is a true statement about a closed menu, not F59's absent-as-empty: the
+ * mechanism is read at call time from this constant, so re-locking a class is
+ * one edit and every counted refusal comes back with it. */
+/** @type {readonly string[]} */
 export const LOCKED_CLASSES: readonly string[];
-/** the classes v1 actually builds — exactly one */
+/** the classes v1 actually builds */
 export const LIVE_CLASSES: readonly string[];
 /**
  * The whole vocabulary, as DATA. `shape` and `asserts` are the strings the
@@ -508,40 +542,66 @@ export const TYPES_GENRE: Readonly<{
         }>;
     }>;
 }>;
-/**
- * THE GUARD BATTERY, KEYED BY VERDICT CLASS (hamr's ruling, PRD v1.57 §2).
- *
- * D5's battery was genre-keyed data. Under class-keyed interviews it has no
- * genre to hang from, and the ruling gives it the same home the interview took:
- * **the battery attaches to the verdict class the user picked** — not to a
- * problem-genre label, and not per catalogue KIND.
- *
- * WHY THE CLASS. What a battery is FOR is the class of dishonesty the class of
- * VERDICT admits. A green job is a job whose *done* is claimed to be
- * machine-checkable, so it carries the green battery whatever problem it came
- * from — that is the anti-suppression obligation the F87 genre earned, and it
- * must not travel with a label the interview no longer asks for.
- *
- * ATTACHMENT POINT vs CONTENTS, and the split is the whole implementation:
- *   - the battery's STRUCTURE and its un-removability key off the CLASS. That
- *     is this table: which guards exist, what they assert, which slot is the
- *     model's (`fill`), and which params are ours.
- *   - the battery's CONTENTS fill in at COMPOSITION (`compose`), because a
- *     suppression pattern, a file extension and a checker's escape hatch belong
- *     to the TOOL the declaration names, and nothing before composition knows
- *     that tool. `classGuards` resolves them from the language data below.
- *
- * A LOCKED class carries `guards: null`, not `[]`. Absent is never empty (F59):
- * `[]` would read as "this class needs no guards", which is exactly the sentence
- * D5 exists to make unsayable. Nothing ever reaches it — admission refuses a
- * locked class before its battery is asked for — and `classGuards` throws rather
- * than hand back nothing if anything ever does.
- * @type {Record<string, {locked: boolean, guards: readonly any[]|null}>}
- */
-export const CLASS_BATTERIES: Record<string, {
-    locked: boolean;
-    guards: readonly any[] | null;
+export const CLASS_BATTERIES: Readonly<{
+    green: Readonly<{
+        locked: false;
+        guards: readonly (Readonly<{
+            name: "changed-from-seed";
+            kind: "files-changed";
+            params: Readonly<{
+                requireNonEmpty: true;
+            }>;
+            compose: readonly never[];
+            fill: readonly string[];
+        }> | Readonly<{
+            name: "no-suppressions";
+            kind: "pattern-absent-in-diff";
+            params: Readonly<{}>;
+            compose: readonly string[];
+            fill: readonly never[];
+        }>)[];
+    }>;
+    'soft-green': Readonly<{
+        locked: false;
+        guards: readonly (Readonly<{
+            name: "changed-from-seed";
+            kind: "files-changed";
+            params: Readonly<{
+                requireNonEmpty: true;
+            }>;
+            compose: readonly never[];
+            fill: readonly string[];
+        }> | Readonly<{
+            name: "no-suppressions";
+            kind: "pattern-absent-in-diff";
+            params: Readonly<{}>;
+            compose: readonly string[];
+            fill: readonly never[];
+        }>)[];
+    }>;
+    hitl: Readonly<{
+        locked: false;
+        guards: readonly (Readonly<{
+            name: "changed-from-seed";
+            kind: "files-changed";
+            params: Readonly<{
+                requireNonEmpty: true;
+            }>;
+            compose: readonly never[];
+            fill: readonly string[];
+        }> | Readonly<{
+            name: "no-suppressions";
+            kind: "pattern-absent-in-diff";
+            params: Readonly<{}>;
+            compose: readonly string[];
+            fill: readonly never[];
+        }>)[];
+    }>;
 }>;
+/** the kinds NO ONE runs as an in-run ruler — ruling 5's law, as data. A
+ * declaration that offers one is a red rather than a normalization: the signer
+ * must not read one thing and have the runner store another. */
+export const NEVER_OFFERED_KINDS: readonly string[];
 export type Red = {
     code: string;
     path: string;

package/types/authorjob.d.ts

@@ -82,13 +82,16 @@ export function refuseLockedKind(kind: string): Refusal;
  *   verdictType?: string|null,
  *   questions?: Record<string|number, string>|null, generate?: Function, provider?: any,
  *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null,
+ *   onPhase?: (phase: string, data?: any) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
- *   authorFn?: Function, authorOpts?: object}} o
+ *   authorFn?: Function, authorOpts?: object,
+ *   signerFix?: Function|any, proposeFn?: Function, compileOpts?: object}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
- *   closeDecl: any, seedRef: string|null, authoring: any, reds: Red[], stop: string|null,
- *   cost: any, interview: any}>}
+ *   closeDecl: any, seedRef: string|null, authoring: any, judged: any, reds: Red[],
+ *   stop: string|null, cost: any, interview: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, seedFn, scoutFn, listingFn, authorFn, authorOpts, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
@@ -100,11 +103,20 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
     scout?: any;
     listing?: any;
     ceilingUsd?: number | null;
+    onPhase?: (phase: string, data?: any) => void;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
     seedFn?: Function;
     scoutFn?: Function;
     listingFn?: Function;
     authorFn?: Function;
     authorOpts?: object;
+    signerFix?: Function | any;
+    proposeFn?: Function;
+    compileOpts?: object;
 }): Promise<{
     ok: boolean;
     refusal: Refusal | null;
@@ -112,6 +124,7 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
     closeDecl: any;
     seedRef: string | null;
     authoring: any;
+    judged: any;
     reds: Red[];
     stop: string | null;
     cost: any;
@@ -163,6 +176,24 @@ export function assembleSpec(specDraft: any, { closeDecl, verdictType }: {
  *      A close with NO work stage red at seed has nothing to do and is refused
  *      decision-ready — gate-2 round 2's arm B died exactly there, on a mypy that
  *      scanned nothing and therefore read clean.
+ *   4. THE CALIBRATION GATE (softgreen module 5) — for a close carrying a
+ *      `judged-floor` stage ONLY. The whole judged pipe runs over the signed ten
+ *      and the five arbiter-owned injection artifacts, and anything short of
+ *      10/10 with itemized reds and 5/5 resisted is an unsignable close. It is
+ *      the ONE gate here that spends money, so it runs LAST — every free refusal
+ *      has already had its chance, and nobody pays to discover a broken
+ *      declaration.
+ *
+ * D9.3 AND THE JUDGED-ONLY CLOSE (2026-08-18 second addendum, ruling 3; hamr:
+ * *"fix it now, we are delivering softgreen, isn't that the whole point?"*). Gate
+ * 3 protects against a close that cannot fail — one that scans nothing and reads
+ * green at seed against a true red. A judged stage SKIPS the seed read by ruling
+ * 8, so a close whose only work stage is judged has no seed red to show and used
+ * to be unsignable: the one job shape softgreen exists for. For that shape, and
+ * ONLY that shape, a PASSED calibration gate plays the seed-red role — it is that
+ * close's own proof of failability, held to the same all-or-nothing bar. A close
+ * with a mechanical work stage is UNCHANGED: it still needs a seed red, whatever
+ * its calibration says.
  *
  * Gates 2 and 3 share ONE execution, and that is stated rather than hidden: at
  * job creation the tree IS the seed, so "does every stage run against the real
@@ -175,11 +206,13 @@ export function assembleSpec(specDraft: any, { closeDecl, verdictType }: {
  * comes back is the resolved spec, its hash, and the evidence to sign against.
  *
  * @param {{spec: any, workdir: string, seedRef?: string|null, shellCapUsd?: number,
- *   timeoutMs?: number, seedFn?: Function, listingFn?: Function, seedReadFn?: Function}} o
+ *   timeoutMs?: number, seedFn?: Function, listingFn?: Function, seedReadFn?: Function,
+ *   judgeLoop?: Function|null, onJudgeCost?: ((c: any) => void)|null, calibrateFn?: Function,
+ *   ceilingUsd?: number|null, priorCalls?: any[]}} o
  * @returns {Promise<{ok: boolean, specHash: string|null, seedRef: string|null,
  *   gates: any, work: any[], guards: any[], stops: any[], reds: Red[], refusal: Refusal|null}>}
  */
-export function prepareSigning({ spec, workdir, seedRef, shellCapUsd, timeoutMs, seedFn, listingFn, seedReadFn, }: {
+export function prepareSigning({ spec, workdir, seedRef, shellCapUsd, timeoutMs, seedFn, listingFn, seedReadFn, judgeLoop, onJudgeCost, calibrateFn, ceilingUsd, priorCalls, }: {
     spec: any;
     workdir: string;
     seedRef?: string | null;
@@ -188,6 +221,11 @@ export function prepareSigning({ spec, workdir, seedRef, shellCapUsd, timeoutMs,
     seedFn?: Function;
     listingFn?: Function;
     seedReadFn?: Function;
+    judgeLoop?: Function | null;
+    onJudgeCost?: ((c: any) => void) | null;
+    calibrateFn?: Function;
+    ceilingUsd?: number | null;
+    priorCalls?: any[];
 }): Promise<{
     ok: boolean;
     specHash: string | null;

package/types/authorscout.d.ts

@@ -92,13 +92,14 @@ export function defaultSurveyor({ workdir, granted, auditPath, ctx }: {
  * @param {{workdir: string, provider?: any,
  *   rounds?: number, minBytes?: number, blobMax?: number, maxTokens?: number, ctx?: boolean,
  *   attempts?: number, ceilingUsd?: number|null,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any}) => any,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
  * @returns {Promise<Survey & {raw: string, raws: ReturnType<typeof scrubRaw>[],
  *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
  *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
  */
-export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, createLoop, createSurveyor, }: {
+export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, onCall, createLoop, createSurveyor, }: {
     workdir: string;
     provider?: any;
     rounds?: number;
@@ -108,6 +109,11 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
     ctx?: boolean;
     attempts?: number;
     ceilingUsd?: number | null;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
     createLoop?: (o: {
         system: string;
         policy: any;