bareloop 0.40.0 → 0.42.0

package/types/authorscout.d.ts

@@ -92,7 +92,7 @@ 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, callTimeoutMs?: number,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
  *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
@@ -115,7 +115,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
-        thinkingApplied?: boolean | null;
+        thinkingStatus?: string;
     }) => void;
     createLoop?: (o: {
         system: string;
@@ -147,6 +147,72 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
     }[];
     budgetStop: "cap-halt" | "pricing-red" | null;
 }>;
+/**
+ * Run the look. `createLoop` is the same seam the repo scout has; nothing else here needs a live process.
+ * @param {{texts: Record<string, string>, inputs: {n: number, label: string}[], jobLines: {n: number, text: string, rule?: string, rules?: string[]}[],
+ *   provider?: any, rounds?: number, maxTokens?: number, ceilingUsd?: number|null, callTimeoutMs?: number,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
+ *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
+ *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>,
+ *   prove?: (source: string, phrase: string) => number}} o
+ * @returns {Promise<{state: 'PRESENT'|'ABSENT', facts: any, reason: string|null, cause: string|null, meta: any, raw: string,
+ *   raws: ReturnType<typeof scrubRaw>[], calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
+ *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export function runInputLook({ texts, inputs, jobLines, provider, rounds, maxTokens, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, prove, }: {
+    texts: Record<string, string>;
+    inputs: {
+        n: number;
+        label: string;
+    }[];
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    provider?: any;
+    rounds?: number;
+    maxTokens?: number;
+    ceilingUsd?: number | null;
+    callTimeoutMs?: number;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+        thinkingStatus?: string;
+    }) => void;
+    createLoop?: (o: {
+        system: string;
+        policy: any;
+        onLlmResult: any;
+        provider: any;
+        rates?: {
+            in: number;
+            out: number;
+        };
+    }) => any;
+    rates?: {
+        in: number;
+        out: number;
+    } | null;
+    callOptions?: Record<string, any>;
+    prove?: (source: string, phrase: string) => number;
+}): Promise<{
+    state: "PRESENT" | "ABSENT";
+    facts: any;
+    reason: string | null;
+    cause: string | null;
+    meta: any;
+    raw: string;
+    raws: ReturnType<typeof scrubRaw>[];
+    calls: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
+}>;
 /**
  * `git ls-tree -r --name-only <seed>` — the files as of the SEED COMMIT.
  * Deliberately NOT `ls-files`, which reads the index and the working tree: this
@@ -336,6 +402,10 @@ export const SCOUT_SYSTEM: string;
  * produce) — never by asking politely in prose (F19/F37).
  */
 export const SCOUT_RECOVERY_PROMPT: string;
+/** the look's hard round bound */
+export const LOOK_ROUNDS: 8;
+export const LOOK_SYSTEM: string;
+export const LOOK_RECOVERY_PROMPT: "You are out of looking turns. Report NOW, from what you have already read: call the report tool once with everything you can check and everything you could not find.";
 /** per-path full-listing cap; over it, names give way to counted directories */
 export const LIST_CAP: 40;
 /** whole-block ceiling — the block is a prompt ingredient, like the survey */

package/types/config.d.ts

@@ -16,15 +16,31 @@ export function configPath(home?: string): string;
 export function readConfig(opts?: {
     home?: string;
 }): ConfigRead;
+/**
+ * One key-row field's value problem in plain words, or null when fine.
+ * @param {string} field `model` | `shape` | `baseUrl` | `legacyMaxTokens`
+ * @param {unknown} v
+ * @returns {string|null}
+ */
+export function providerFieldProblem(field: string, v: unknown): string | null;
+/**
+ * THE one rule for a row's model lines, used by config validation and the Settings routes. A price
+ * is a PAIR (`inPerM` and `outPerM`, each a finite number >= 0 — 0 / 0 typed is a chosen price) or
+ * neither (null / absent). A ticked line (`use`) needs both. Plain words, or null.
+ * @param {unknown} list
+ * @returns {string|null}
+ */
+export function modelsProblem(list: unknown): string | null;
 /**
  * Apply a patch and write. `null` deletes a field. Top-level fields shallow-merge;
- * `keys` merges per key variable name, then per field. Validated before anything is
- * written; nothing is written on a refusal.
+ * `keys` merges per key variable name, then per field; `models.<ENV>` is REPLACED WHOLE (`null`
+ * clears it). Validated before anything is written; nothing is written on a refusal.
  *
- * Patch fields understood: `monthlyLimitUsd` (finite > 0), `anthropicBalanceNote`
- * (finite >= 0), `keys.<ENV NAME>.{name,shape,baseUrl}` (Name = a model id, shape = a provider table name, baseUrl = blank or http(s)). Any other
- * field is passed through untouched (kept), but the whole document is swept for
- * secret-shaped strings first.
+ * Patch fields understood: `monthlyLimitUsd` (finite > 0), `keys.<ENV>.{shape,baseUrl,legacyMaxTokens}`,
+ * `models.<ENV>` (a list judged by {@link modelsProblem}). The first write of a row's `models` list
+ * removes that row's older `name` / `priceInPerM` / `priceOutPerM` in the SAME write (never two
+ * sources); a retired top-level `anthropicBalanceNote` is dropped on any write. Any other field is
+ * kept, but the whole document is swept for secret-shaped strings first.
  * @param {Record<string, any>} patch
  * @param {{ home?: string }} [opts]
  * @returns {Record<string, any>} the document as written
@@ -35,6 +51,7 @@ export function updateConfig(patch: Record<string, any>, opts?: {
 /** A plain-words config failure (bad value, secret-shaped string, unreadable file). */
 export class ConfigError extends Error {
 }
+export function cleanBaseUrl(v: string): string;
 export type ConfigRead = {
     /**
      * the parsed document ({} when missing/unreadable)

package/types/declaredclose.d.ts

@@ -53,7 +53,8 @@ export function declaredStages(closeDecl: any): any[] | null;
  *
  * @param {any} closeDecl
  * @param {{at?: string, listing?: string[]|null, deferListing?: boolean,
- *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null,
+ *   inputLabels?: string[]|null}} [opts]
  * @returns {{ok: boolean, reds: Red[], closeDecl: any, grounded: boolean,
  *   scoped: {scoped: boolean, via: string|null},
  *   ceiling: {class: string, kind: string, stage: string|null, locked: boolean}|null}}
@@ -68,6 +69,7 @@ export function validateCloseDecl(closeDecl: any, opts?: {
     jobLines?: {
         n: number;
     }[] | null;
+    inputLabels?: string[] | null;
 }): {
     ok: boolean;
     reds: Red[];
@@ -162,7 +164,7 @@ export function closeGrade(v: any): {
 /** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
 /** The genres a `closeDecl` may name. v1 admits exactly one (D13) — a genre
  * classifier is designed the day there is a second genre to classify. */
-export const DECLARED_GENRES: readonly "TYPES"[];
+export const DECLARED_GENRES: readonly string[];
 /**
  * The exact field set of a `closeDecl` — anything else is a smuggle channel, the
  * same rule `STAGE_FIELDS` enforces on a command stage.

package/types/draftspend.d.ts

@@ -2,10 +2,10 @@
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
- *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
- *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
- *    call's run (true | false | null), present only when thinkingMode was sent)
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
+ *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  * @typedef {{kind: string, no: number, at: string, [k: string]: any}} DraftEvent
  */
@@ -108,10 +108,10 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
- *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
- *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
- *    call's run (true | false | null), present only when thinkingMode was sent)
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
+ *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  */
 export type DraftEvent = {

package/types/facts.d.ts

@@ -0,0 +1,71 @@
+/** the `fact` part of a step's parameters, or null (a step has at most one) @param {any} params @returns {any|null} */
+export function factPartOf(params: any): any | null;
+/**
+ * The SHAPE of a `fact` part (what it may carry), pushed as reds in the same form `rubricStepShapeReds` uses. Whether the
+ * bareguard rubric it builds is signable is asked of bareguard itself (`checkRubricParts` builds it once at drafting).
+ * @param {any} part @param {string} w the path prefix @param {(code: string, path: string, detail: string) => void} red
+ */
+export function factShapeReds(part: any, w: string, red: (code: string, path: string, detail: string) => void): void;
+/**
+ * bareguard's `decides` list for a fact part: one decide per fact, in the fact order (so `d<j>` is the fact's own index).
+ * @param {any} part @returns {Record<string, any>[]}
+ */
+export function factDecides(part: any): Record<string, any>[];
+/**
+ * The claims bareguard reads for a fact step, built from the step file's `results`. The claim TEXT is written here, by code,
+ * from the values the worker gave (the worker writes no claim text): `name: value; name: value`. A phrase fact contributes its
+ * own signed words. A result that is not an object, or has no string quote, still becomes a claim — an empty one — so
+ * bareguard reds it by name rather than the result vanishing.
+ * @param {any} part @param {unknown} results @returns {{claim: string, quote: string, values?: Record<string, string>}[]}
+ */
+export function factClaims(part: any, results: unknown): {
+    claim: string;
+    quote: string;
+    values?: Record<string, string>;
+}[];
+/**
+ * One fact as a plain row, written by code from the signed fields:
+ * `fact · price — money, at most 450 US dollars, after "Price", quoted from "Flights"`.
+ * @param {any} f @param {string} source
+ * @returns {string}
+ */
+export function factSentence(f: any, source: string): string;
+/**
+ * One fact as the WORKER is told it (item 7): what to write for it and where in the quote it sits, in plain words, from the signed
+ * fields. A phrase fact has no value to write — the quote has to say it.
+ * @param {any} f @returns {string}
+ */
+export function factBrief(f: any): string;
+/** the "N results" row of a fact part, or null @param {any} part @returns {string|null} */
+export function countSentence(part: any): string | null;
+/**
+ * Every plan-card row a fact part carries: its facts, then its count.
+ * @param {any} part @returns {string[]}
+ */
+export function factRows(part: any): string[];
+/**
+ * One bareguard `cited` item (`#<result>:d<j>:<reason>[:<detail>]`, or `#<result>:<reason>`) as a sentence the worker can act
+ * on. The names and numbers are bareguard's measurements and the person's signed facts, never inferred here.
+ * @param {string} item @param {any} part @returns {string}
+ */
+export function plainFactItem(item: string, part: any): string;
+/**
+ * The fields each fact shape takes, in the fact part's own names (`rule` = bareguard's op/value/lo/hi; `unit`/`currency`; `phrase`
+ * = the presence decide's phrases), read off bareguard's rubric vocabulary.
+ * @returns {Record<string, string[]>} shape -> the fields it takes besides name and shape
+ */
+export function factShapeFields(): Record<string, string[]>;
+/**
+ * The lines the drafter is shown about which shape takes which fields, generated from {@link factShapeFields} (shapes with the same
+ * fields are listed together). One owner: the composer brief and the confirm note both print this.
+ * @returns {string}
+ */
+export function factShapeGuide(): string;
+/** the shapes a fact may have (bareguard's value kinds, plus `phrase` = a presence decide) */
+export const FACT_SHAPES: readonly string[];
+/** the comparison ops a rule may use (bareguard's) */
+export const FACT_OPS: readonly string[];
+/** bareguard signs at most this many decides on one `cited` check */
+export const MAX_FACTS: 10;
+/** every field a part of class `fact` may carry (the shared ones are checked by rubricStepShapeReds) */
+export const FACT_PART_FIELDS: readonly string[];

package/types/factwords.d.ts

@@ -0,0 +1,42 @@
+/**
+ * How many times exact words occur in a source, white space blind. Zero for empty words.
+ * @param {string} source the raw source text @param {string} words
+ * @returns {number}
+ */
+export function countExact(source: string, words: string): number;
+/**
+ * How many times a phrase or unit occurs as WHOLE words, case and spacing aside ("SFO" is not found inside "sfocus").
+ * @param {string} source @param {string} words @returns {number}
+ */
+export function countPhrase(source: string, words: string): number;
+/**
+ * The reds for ONE fact part against its frozen source text.
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan}} o
+ * @returns {{code: string, detail: string}[]}
+ */
+export function checkFactWords({ part, text, line, scan }: {
+    part: any;
+    text: string;
+    line: number | string;
+    scan?: import("./labelscan.js").LabelScan;
+}): {
+    code: string;
+    detail: string;
+}[];
+/**
+ * The reds for every fact part of a declaration. A fact part whose input text is not at hand is a red: a check whose words were never
+ * proved against the source is never signed.
+ * @param {any} declaration @param {Record<string, string>|null} texts label -> frozen text
+ * @returns {{code: string, path: string, detail: string}[]}
+ */
+export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null): {
+    code: string;
+    path: string;
+    detail: string;
+}[];
+/**
+ * The look's own proof hook: how often a phrase the look built is in an input.
+ * @param {Record<string, string>} texts @returns {(source: string, phrase: string) => number}
+ */
+export function proverOf(texts: Record<string, string>): (source: string, phrase: string) => number;
+export function squash(t: string): string;

package/types/index.d.ts

@@ -15,7 +15,7 @@ export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBr
 export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES, VOUCHED_RATE_SOURCES, rateProvenance, spendProvenance } from "./ledger.js";
 export { readShimArm, READ_SHIM_CAP, READ_SHIM_STRATEGY, READ_SHIM_DIFF_STRATEGY } from "./readshim.js";
 export { runDeclaredClose, runStage, seedRead, seedAtHead, LIVE_KINDS, STOP_FAULTS, JUDGED_MARKER, HUMAN_DECISIONS, SEED_EXEMPT_KINDS, normalizeHumanRuling, resolveHumanRuling, JUDGE_ATTEMPTS, MAX_JUDGED_PATHS, DOOR_OPEN_OUTCOMES, REVIEW_DOOR_CLASSES, doorOpens, mechanicalStages } from "./kinds.js";
-export { JUDGE_MODEL, resolveJudge, JUDGE_RULES, JUDGE_RULE_IDS, runLocate, decide, CALIBRATION_SIZE, validateCalibrationSet, expectedOf } from "./judged.js";
+export { resolveJudge, JUDGE_RULES, JUDGE_RULE_IDS, runLocate, decide, CALIBRATION_SIZE, validateCalibrationSet, expectedOf } from "./judged.js";
 export { proposeJudgedArtifacts, signJudgedArtifacts, foldJudgedArtifacts } from "./cardauthor.js";
 export { runCalibration, INJECTION_LOCATE_BATTERY, CASUALTY_AXES } from "./calibrate.js";
 export { validateDeclaration, KIND_CATALOGUE, LOCKED_KINDS, genreEnv, genreInstruments, LOCKED_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling, NEVER_OFFERED_KINDS } from "./authoring.js";

package/types/inputlook.d.ts

@@ -0,0 +1,238 @@
+/**
+ * The input as the AI sees it: lines with any run of white space (U+202F included) made one space and the page reader's bracketed tags
+ * (`[ref=549]`) removed - an id that is only the page reader's, never part of a label.
+ * @param {string} text @returns {string[]}
+ */
+export function lookLines(text: string): string[];
+/**
+ * The two read-only tools: search the input text, read a slice around a hit. They are closures over in-memory text and touch nothing
+ * else - read-only BY CONSTRUCTION, not by a fence. Several inputs: the `input` argument names which (its label).
+ * @param {Record<string, string>} texts label -> frozen text
+ * @returns {{name: string, description: string, parameters: any, execute: (a: any) => Promise<any>}[]}
+ */
+export function lookReadTools(texts: Record<string, string>): {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (a: any) => Promise<any>;
+}[];
+/** the strict answer form (a JSON schema - never free prose with JSON inside) */
+export function lookReportSchema(): {
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        facts: {
+            type: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    name: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    shape: {
+                        enum: string[];
+                    };
+                    source: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    label: {
+                        type: string;
+                        description: string;
+                    };
+                    value: {
+                        type: string;
+                        description: string;
+                    };
+                    example: {
+                        type: string;
+                        description: string;
+                    };
+                    rule: {
+                        type: string;
+                        additionalProperties: boolean;
+                        required: string[];
+                        properties: {
+                            op: {
+                                enum: string[];
+                            };
+                            value: {};
+                            lo: {};
+                            hi: {};
+                        };
+                        description: string;
+                    };
+                    aiProposal: {
+                        type: string;
+                        description: string;
+                    };
+                    forRule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                };
+            };
+        };
+        prose: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                    };
+                    text: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        notFound: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                    };
+                    rule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    words: {
+                        type: string;
+                        description: string;
+                    };
+                    why: {
+                        type: string;
+                        minLength: number;
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * What the AI is told: the numbered job, the inputs and their label lists, and what to do.
+ * @param {{jobLines: {n: number, text: string, rule?: string, rules?: string[]}[], labels: string[], lists: Record<string, string>}} o
+ * @returns {string}
+ */
+export function lookPrompt({ jobLines, labels, lists }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    labels: string[];
+    lists: Record<string, string>;
+}): string;
+/**
+ * Turn the AI's raw report into a VERIFIED one, by code, at $0. A fact is carried only when: its shape is a real shape, its source is
+ * a real input, and its label is ON THE LIST for that input and shape (an id is resolved to its exact words). Anything else is moved
+ * to `notFound` with a plain reason naming the word - never dropped silently. `prove` is the "found in the source" test of the
+ * phrase a phrase fact builds (label + value), supplied by the caller.
+ * @param {unknown} raw
+ * @param {{scans: Record<string, import('./labelscan.js').LabelScan>, jobLines: {n: number}[], prove?: (source: string, phrase: string) => number}} o
+ * @returns {LookReport}
+ */
+export function verifyLookReport(raw: unknown, { scans, jobLines, prove }: {
+    scans: Record<string, import("./labelscan.js").LabelScan>;
+    jobLines: {
+        n: number;
+    }[];
+    prove?: (source: string, phrase: string) => number;
+}): LookReport;
+/**
+ * The look's report as the DRAFTER reads it: one block, per job line, of what can be checked (with the exact words to copy) and what
+ * could not be found. Written by code from the verified report.
+ * @param {LookReport} report @returns {string}
+ */
+export function renderLookReport(report: LookReport): string;
+/**
+ * The label scans and the rendered lists for the inputs the look will read.
+ * @param {Record<string, string>} texts
+ * @returns {{scans: Record<string, import('./labelscan.js').LabelScan>, lists: Record<string, string>}}
+ */
+export function labelListsOf(texts: Record<string, string>): {
+    scans: Record<string, import("./labelscan.js").LabelScan>;
+    lists: Record<string, string>;
+};
+/**
+ * L3: a reason the AI gave, cut only at a sentence end (never mid-sentence): whole sentences while they fit in `max` characters,
+ * and nothing at all if the first one alone does not fit. A trailing full stop is dropped (the caller closes the clause).
+ * @param {string} text @param {number} max @returns {string}
+ */
+export function wholeSentences(text: string, max: number): string;
+/**
+ * I1 (hamr, 2026-10-13, "Ruled by hamr" 2): when the look shows the person's intent on one `~` rule was NOT captured - its words or
+ * meaning are not in the source - the person is asked about THAT rule at once, named by its line and rule. Only a look entry that names
+ * a rule number counts; anything else the look could not find is not asked piecemeal (it is Not checked, or the whole job is reviewed).
+ * The wording is the code's own, never the model's. The keep-or-drop and the cap are `normalizeQuestions` (src/authorflow.js).
+ * @param {LookNotFound[]} notFound @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{line: number, question: string}[]} every candidate question (the caller applies the machine's caps)
+ */
+export function ruleQuestions(notFound: LookNotFound[], jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[]): {
+    line: number;
+    question: string;
+}[];
+/** the name of the answer tool - the one place the AI's report enters */
+export const LOOK_REPORT_TOOL: "report_look";
+/** how many hits one search returns at most, and how long a snippet or a read line is */
+export const LOOK_MAX_HITS: 40;
+export { LABEL_SHAPES };
+export type LookFact = {
+    line: number;
+    name: string;
+    shape: string;
+    source: string;
+    label?: string;
+    labelId?: string;
+    value?: string;
+    phrase?: string;
+    example: string;
+    rule?: any;
+    aiProposal?: boolean;
+    forRule?: number;
+};
+export type LookNotFound = {
+    line: number;
+    rule?: number;
+    words?: string;
+    why: string;
+};
+export type LookReport = {
+    facts: LookFact[];
+    prose: {
+        line: number;
+        text?: string;
+    }[];
+    notFound: LookNotFound[];
+};
+import { LABEL_SHAPES } from './labelscan.js';

package/types/job.d.ts

@@ -122,18 +122,18 @@ export function checkApproval(job: object, approvals: unknown): boolean;
  * mismatched flag is a mistake worth stopping on, never a silent swap); the
  * same id from both is not a conflict. Extracted from scripts/run-u.mjs so
  * the decision is testable without running the script or touching a provider.
- * @param {{ specModel?: string, flagModel?: string, defaultModel: string }} args
+ * @param {{ specModel?: string, flagModel?: string, suppliedModel?: string }} args
  *   `specModel` — `job.model` if the signed spec carries one, else undefined.
  *   `flagModel` — the model id an explicit `--model <tier>` resolved to, else
  *   undefined (a flag that was never passed, not merely a default tier name).
- *   `defaultModel` — the runner's own default when neither spec nor flag says.
+ *   `suppliedModel` — a model the CALLER supplies when neither spec nor flag says (bareloop keeps none of its own).
  * @returns {{ model: string, source: 'spec'|'flag'|'default' }}
- * @throws {Error} when the spec names a model and the flag names a different one
+ * @throws {Error} when the spec names a model and the flag names a different one, or when no model is named at all
  */
-export function resolveWorkerModel({ specModel, flagModel, defaultModel }: {
+export function resolveWorkerModel({ specModel, flagModel, suppliedModel }: {
     specModel?: string;
     flagModel?: string;
-    defaultModel: string;
+    suppliedModel?: string;
 }): {
     model: string;
     source: "spec" | "flag" | "default";

package/types/jobblock.d.ts

@@ -52,11 +52,18 @@ export function renderInputs(inputs: JobInput[]): string;
  * The two cross-checks between a parsed job block and the Check type: a RUBRIC job needs at least one `PASS:` and one
  * `FAIL:` example (the calibration compile reads them); a DETERMINISTIC job has no judge, so an example line would be
  * silently dropped — a red instead.
+ * PART 1a (hamr's ruling P1=B, docs/product/ITEM33-BUILD.md "Addendum 2026-10-12"): the examples are required of a rubric
+ * job ONLY when it holds a judged part. A rubric job on the person's own local files holds none in this build (its
+ * parts are counted or checked against a quote), so the caller says `judged: false` and a block without examples fits.
+ * Examples written anyway are never a red there — they simply have no judge to read them yet.
  * @param {JobLine[]} lines
  * @param {boolean} rubric
+ * @param {{judged?: boolean}} [o] `judged` (default true): does this job hold a judged part, so that it needs examples?
  * @returns {string|null} the plain red, or null when the block fits the Check type
  */
-export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean): string | null;
+export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean, { judged }?: {
+    judged?: boolean;
+}): string | null;
 /**
  * The signed `jobLines` field from parsed lines: the person's own words, `{n, text, rule, rules}` (examples stay inside the
  * rule text, where the person wrote them). `rules` is the same `~` lines as an array, BESIDE the joined `rule` (never