bareloop 0.40.0 → 0.42.0

package/types/providers.d.ts

@@ -1,47 +1,3 @@
-/**
- * The per-call options the rubric JUDGE's model calls carry for this provider instance: `{ thinkingMode: 'off' }` when
- * bare-agent measures the model switchable, else `{}` (F192: judge runs thinking off; a judge on a model that cannot turn it
- * off must not throw).
- * @param {any} provider a constructed bare-agent provider
- * @returns {Record<string, any>}
- */
-export function judgeCallOptions(provider: any): Record<string, any>;
-/**
- * Throw unless `mode` is one of {@link DRAFT_THINKING_MODES} — an operator-param guard, so a typo never silently means a mode.
- * @param {unknown} mode
- * @returns {'on'|'off'}
- */
-export function assertDraftThinking(mode: unknown): "on" | "off";
-/**
- * What the drafting calls on this provider ACTUALLY carry for thinking, for the draft log and the panel row: `'on'` (mode on,
- * nothing sent), `'off'` (mode off and the switch is sent), `'not-switchable'` (mode off, model measured not switchable —
- * nothing sent), `'unverified'` (mode off, model not measured by bare-agent — nothing sent). Never re-derives a model list.
- * @param {any} provider a constructed bare-agent provider
- * @param {unknown} [mode] 'on' | 'off' (default 'off')
- * @returns {'on'|'off'|'not-switchable'|'unverified'}
- */
-export function draftThinkingSent(provider: any, mode?: unknown): "on" | "off" | "not-switchable" | "unverified";
-/**
- * {@link draftThinkingSent} for a model the caller has only NAMED (provider shape, model id, baseUrl) — no key, no network. For
- * the panel's first drafting row, which is shown before the key is read. Constructing the provider only makes the class and
- * the model id available to `thinkingSupport`; it sends nothing.
- * @param {{providerName: string, model: string, baseUrl?: string|null}} o
- * @param {unknown} [mode] 'on' | 'off' (default 'off')
- * @returns {'on'|'off'|'not-switchable'|'unverified'}
- */
-export function draftThinkingFor({ providerName, model, baseUrl }: {
-    providerName: string;
-    model: string;
-    baseUrl?: string | null;
-}, mode?: unknown): "on" | "off" | "not-switchable" | "unverified";
-/**
- * The ONE owner of the per-call options every DRAFTING model call carries (scout, confirm, author, revise, structure retries).
- * `{ thinkingMode: 'off' }` exactly when {@link draftThinkingSent} says `'off'`, else `{}`.
- * @param {any} provider a constructed bare-agent provider
- * @param {unknown} [mode] 'on' | 'off' (default 'off')
- * @returns {Record<string, any>}
- */
-export function draftCallOptions(provider: any, mode?: unknown): Record<string, any>;
 /**
  * Look up a provider's table entry. Throws a NAMED error on an unrecognized
  * provider — never a silent default (the `resolveRates`-style-substring-
@@ -81,80 +37,67 @@ export function resolveProvider(providerName: string): ProviderTableEntry;
  */
 export function apiKeyProblem(value: string): string | null;
 /**
- * Construct ONE provider instance for `providerName`/`model`, applying
- * `exposeErrorBody: true` (F153 — every constructed provider, unconditionally)
- * and the model's own request-key gating (`paramsFor`). `baseUrl` (PRD item
- * 28, ruling (d), 2026-09-09: admitted in v1) is forwarded only when given —
- * every provider constructor here defaults it on its own when absent.
+ * Construct ONE provider instance for `providerName`/`model`, applying `exposeErrorBody: true` (F153 — every constructed
+ * provider, unconditionally). `baseUrl` (PRD item 28, ruling (d), 2026-09-09: admitted in v1) is forwarded only when given.
+ * `legacyMaxTokens` is the Settings ROW's "old max_tokens" tick: a server that ignores `max_completion_tokens` (F149) does not
+ * bind the output cap until it is on. It is forwarded only for `openai-api` and only when `true` — nothing here sniffs a host
+ * or a model id to decide it.
  * @param {string} providerName
- * @param {{apiKey?: string, model?: string, baseUrl?: string}} [options]
+ * @param {{apiKey?: string, model?: string, baseUrl?: string, legacyMaxTokens?: boolean}} [options]
  */
-export function makeProvider(providerName: string, { apiKey, model, baseUrl }?: {
+export function makeProvider(providerName: string, { apiKey, model, baseUrl, legacyMaxTokens }?: {
     apiKey?: string;
     model?: string;
     baseUrl?: string;
+    legacyMaxTokens?: boolean;
 }): any;
 /**
- * Build the `{provider, providerFor, judgeProvider}` triple both runners
- * need (`src/authorrun.js` and `src/panel/authorsession.js` call it) — ONE seam instead of two copies of the same construction and
- * tier-memoization logic. `model`/`tierModels` are already-RESOLVED inputs
- * (the caller runs `resolveWorkerModel` itself, exactly as both runners did
- * before this factory existed — that decision stays where each runner's own
- * `--model` flag/spec precedence lives, not duplicated in here).
+ * Build the `{provider, providerFor, judgeProvider}` triple both authoring runners need (`src/authorrun.js` and
+ * `src/panel/authorsession.js` call it) — ONE seam instead of two copies of the same construction. `model` is the
+ * already-RESOLVED worker model id (the caller picked the Settings line).
  *
- * THE JUDGE IS NO LONGER PINNED TO ANTHROPIC (PRD item 32.2, hamr 2026-09-10:
- * *"what i care about is that judge becomes llm agnostic and not set to one
- * model or provider"*). It is constructed through this same factory, from a
- * `judgeProviderName`/`judgeModel` pair the CALLER resolved (`resolveJudge`,
- * src/judged.js — the spec's signed `judge` override, else the job's own worker
- * provider and model). Item 28's pin, and item 28 part (2)'s deferral of a
- * signed `judge:{provider,model}` field, both close here.
- *
- * `judgeApiKey` stays a SEPARATE argument rather than being derived: the judge
- * may legitimately be a different provider from the worker, and reading its key
- * for it would put a second env-var reader in a module whose whole job is to
- * have exactly one. The caller reads the resolved judge provider's own `envKey`
- * and hands the key in — the same contract the worker key already has here.
+ * THE JUDGE IS NOT PINNED (PRD item 32.2): it is constructed through this same factory from a `judgeProviderName`/`judgeModel`
+ * pair the CALLER resolved. `judgeApiKey` stays a SEPARATE argument: the judge may be a different provider from the worker,
+ * and each key is read by the caller from its own row.
  * @param {object} args
- * @param {string} args.providerName spec.provider (or the anthropic-api default)
- * @param {string|undefined} args.apiKey the WORKER's key, read from the provider's own `envKey`
+ * @param {string} args.providerName the worker's API shape id
+ * @param {string|undefined} args.apiKey the WORKER's key, read from its row's env name
  * @param {string} args.model the already-resolved worker model id
- * @param {Readonly<Record<string, string>>} args.tierModels the already-resolved tier -> model map (spec override folded in by the caller)
- * @param {string|undefined} [args.baseUrl] spec.baseUrl, if any
- * @param {string|undefined} args.judgeApiKey the judge's own key, read by the caller from the RESOLVED judge provider's `envKey`
+ * @param {string|undefined} [args.baseUrl] the worker row's Base URL
+ * @param {boolean} [args.legacyMaxTokens] the worker row's old max_tokens tick
+ * @param {string|undefined} args.judgeApiKey the judge's own key
  * @param {string} args.judgeModel the resolved judge model id
- * @param {string} [args.judgeProviderName] the resolved judge provider name; defaults to `providerName` (the job's own worker provider), which is `resolveJudge`'s own default
- * @param {string|undefined} [args.judgeBaseUrl] the judge provider's endpoint, when it takes one
+ * @param {string} [args.judgeProviderName] the resolved judge shape; defaults to `providerName`
+ * @param {string|undefined} [args.judgeBaseUrl] the judge row's endpoint
+ * @param {boolean} [args.judgeLegacyMaxTokens] the judge row's old max_tokens tick (defaults to the worker's when the judge shares its provider)
  */
-export function buildRunnerProviders({ providerName, apiKey, model, tierModels, baseUrl, judgeApiKey, judgeModel, judgeProviderName, judgeBaseUrl, }: {
+export function buildRunnerProviders({ providerName, apiKey, model, baseUrl, legacyMaxTokens, judgeApiKey, judgeModel, judgeProviderName, judgeBaseUrl, judgeLegacyMaxTokens, }: {
     providerName: string;
     apiKey: string | undefined;
     model: string;
-    tierModels: Readonly<Record<string, string>>;
     baseUrl?: string | undefined;
+    legacyMaxTokens?: boolean | undefined;
     judgeApiKey: string | undefined;
     judgeModel: string;
     judgeProviderName?: string | undefined;
     judgeBaseUrl?: string | undefined;
+    judgeLegacyMaxTokens?: boolean | undefined;
 }): {
     provider: any;
-    providerFor: (tier: string) => any;
+    providerFor: (_tier: string) => any;
     judgeProvider: any;
 };
 /**
- * $0 reachability check: a GET against `providerName`'s own models-list
- * endpoint, server-side, with the key in a header — NEVER a completion
- * request, so it never spends a token (PANEL-BUILD.md P3 build item 7: "the
- * person must get feedback BEFORE drafting if the chosen model can't
- * work"). Reused, unmodified, by the panel's model-readiness route today
- * (`src/panel/authorroutes.js`) and by the future Settings providers
- * table's own "test" column (PANEL-BUILD.md P4) — ONE function, not two
- * hand-typed copies of the same probe.
+ * $0 reachability check: ONE GET of the provider's models list (`src/modellist.js`, the one owner of
+ * that call), server-side, with the key in a header — NEVER a completion request, so it never spends
+ * a token (PANEL-BUILD.md P3 build item 7: "the person must get feedback BEFORE drafting if the
+ * chosen model can't work"). Used by the panel's model-readiness route (`src/panel/authorroutes.js`);
+ * Settings > Providers' Test and Refresh call `listModels` directly. A blank `baseUrl` makes no call.
  *
- * NEVER returns the key, never logs it — the key only ever appears in a
- * request header sent straight to the provider's own host.
+ * NEVER returns the key, never logs it — the key only ever appears in a request header sent
+ * straight to the provider's own host.
  * @param {object} o
- * @param {string} o.providerName
+ * @param {string} o.providerName an API shape id
  * @param {string} o.apiKey
  * @param {string} [o.model] when given, the response is also checked for this model id
  * @param {string} [o.baseUrl]
@@ -194,55 +137,6 @@ export function checkProviderReachable({ providerName, apiKey, model, baseUrl, f
  * @returns {string[]|null} lines to print, in order, or null when there is nothing to say
  */
 export function probeWarningLines(providerName: string): string[] | null;
-/**
- * Today's anthropic-api tier table — EXACTLY the `DEFAULT_TIER_MODELS` both
- * runners hardcoded before this factory existed. Any change to these two
- * values is a change to shipped anthropic-api behaviour, not a refactor.
- */
-export const ANTHROPIC_TIER_MODELS: Readonly<{
-    sonnet: "claude-sonnet-5";
-    haiku: "claude-haiku-4-5-20251001";
-}>;
-/**
- * DeepSeek (F149/F150) is a SINGLE model, not a tiered family — hamr's
- * ruling above: one secondary provider, not a menu. Both tiers map to the
- * same model id ON PURPOSE: `resolveWorkerModel`/a runner's `providerFor
- * (tier)` only ever LOOK UP a tier's model id (src/job.js:818-827,
- * scripts/run-u.mjs's `providerFor`) — neither assumes the tiers name
- * different models — so repeating the one id is the honest representation
- * of a single-model provider, not a second model masquerading as `haiku`.
- * If DeepSeek (or a future openai-api entrant) ever ships a genuinely
- * cheaper tier model, this is where it would earn its own `haiku` id.
- *
- * MODEL SWAP (F171, item 34 L16, hamr 2026-09-13): `deepseek-chat` is no
- * longer served — a live `/models` call returned only `deepseek-flash` and
- * `deepseek-v4-pro`. Switched to `deepseek-flash` (DeepSeek V4.1). F149's
- * `legacyMaxTokens` measurement (asked 64 output tokens, got 665/608) was
- * taken on `deepseek-chat` and is UNVERIFIED on `deepseek-flash` — kept on
- * below as the fail-safe (over-capping direction is safe; see F171).
- */
-export const OPENAI_TIER_MODELS: Readonly<{
-    sonnet: "deepseek-flash";
-    haiku: "deepseek-flash";
-}>;
-/**
- * Gemini (PRD item 31.3, hamr 2026-09-09: "anthropic, openai, gemini drop
- * ollama for now"). Two real tiers, unlike DeepSeek's single model: `flash` is
- * the cheap tier by design, so `haiku` maps to it honestly rather than
- * repeating one id.
- *
- * ADMITTED-PENDING-PROBE. The probe rule stands (PRD item 28 ruling (d),
- * 2026-09-09): no endpoint is in the menu without its own clean paid probe,
- * and `gemini-api` has ZERO runs. `anthropic-api` is the original (~167
- * archived runs) and `openai-api` was probed green through the shipped runner
- * (run mtu12vks, $1.64/$4, F157); gemini owes that fire and has not paid it.
- * `PROBE_STATUS` below is the machine-readable form of that debt — nothing in
- * here silently pretends the provider is proven.
- */
-export const GEMINI_TIER_MODELS: Readonly<{
-    sonnet: "gemini-2.5-pro";
-    haiku: "gemini-2.5-flash";
-}>;
 /**
  * Which admitted providers have paid for their own end-to-end probe, and which
  * have not. Read by the runner to print a loud marker; never read to REFUSE —
@@ -254,32 +148,13 @@ export const PROBE_STATUS: Readonly<Record<string, {
     probed: boolean;
     evidence: string;
 }>>;
-/**
- * The drafter's THINKING knob — an enumerated OPERATOR param, never model output and never read from env inside the library.
- * `'on'` sends nothing (the model's own thinking, byte-identical to a no-knob call); `'off'` sends `thinkingMode: 'off'` where
- * bare-agent measures the model switchable. The DEFAULT is `'off'` (hamr 2026-10-11, decided by the frozen ON/OFF contrast,
- * docs/logs/2026-10-10-drafter-thinking-contrast-prereg.md); `'on'` stays selectable for a later Settings checkbox.
- */
-export const DRAFT_THINKING_MODES: readonly string[];
 export type ProviderTableEntry = {
     /**
      * the bare-agent provider class
      */
     ctor: new (options: any) => any;
-    /**
-     * the environment variable this provider reads its key from
-     */
-    envKey: string;
-    /**
-     * tier name -> model id
-     */
-    tiers: Readonly<Record<string, string>>;
     /**
      * the CONSTRUCTOR OPTION NAME this provider reads its endpoint from — NOT assumed to be `baseUrl` (see below)
      */
     endpointKey: string;
-    /**
-     * per-model request-key/param gating, applied on TOP of {exposeErrorBody:true, apiKey, model, <endpointKey>?}
-     */
-    paramsFor: (model: string | undefined) => Record<string, any>;
 };

package/types/providershapes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `id` is the value saved in config.json (and the signed spec's `provider`).
+ * @type {readonly {id: string, label: string}[]}
+ */
+export const SHAPES: readonly {
+    id: string;
+    label: string;
+}[];
+/** @type {readonly string[]} */
+export const SHAPE_IDS: readonly string[];

package/types/rubricstep.d.ts

@@ -0,0 +1,286 @@
+/**
+ * The one statement of the step-file shape, in plain words. The worker's goal and the composer's prompt both carry it.
+ * @returns {string}
+ */
+export function stepFileContract(): string;
+/**
+ * What the worker is told about each line, from the close that will grade it (PART 1b item 7): a FACTS line gets its
+ * facts and its count; a TEXT line that follows a facts line is told its numbers come from that line's quotes. Written by code from
+ * the signed parts, never by a model. A line with no rubric-step stage gets nothing here.
+ * @param {any} closeDecl @returns {{line: number, text: string}[]}
+ */
+export function lineBriefs(closeDecl: any): {
+    line: number;
+    text: string;
+}[];
+/**
+ * The worker's goal for a rubric job on local files — written by code from the person's own numbered lines, never by a
+ * model. It states everything the close will judge about the FORM of the answer (the file, the keys, the quotes); what
+ * each line asks for stays in the person's own words, with its `~` rules beneath it.
+ * @param {{jobLines: {n: number, text: string, rule: string}[], files: {label: string, rel: string}[], confirmedGoal?: string|null, closeDecl?: any}} o
+ *   `confirmedGoal` — the one goal sentence the person confirmed in the confirm turn, kept as the plan line
+ *   `closeDecl` — the drafted close: with it, each line is briefed by what its stage checks (a facts line or a text line, `lineBriefs`)
+ * @returns {string}
+ */
+export function rubricGoal({ jobLines, files, confirmedGoal, closeDecl }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule: string;
+    }[];
+    files: {
+        label: string;
+        rel: string;
+    }[];
+    confirmedGoal?: string | null;
+    closeDecl?: any;
+}): string;
+/**
+ * The SHAPE of a `rubric-step` stage's parameters — what a part may carry — and nothing about which class is allowed in
+ * this build (that is `checkRubricParts`, which also sees the whole job). Pure, never throws.
+ * @param {unknown} p the stage's `params`
+ * @param {string} at the path prefix for reds, e.g. `stages[1].params`
+ * @returns {ShapeRed[]}
+ */
+export function rubricStepShapeReds(p: unknown, at: string): ShapeRed[];
+/** the labels of the inputs a step's `cited` parts name (each once, in order) @param {any} params @returns {string[]} */
+export function citedLabels(params: any): string[];
+/**
+ * The rubric spec for ONE step, built from its parameters and the sha256 of each input it cites (taken from the source
+ * manifest at run start — a rubric is rebuilt per run because the inputs belong to the run, not to the signed job).
+ * `happened` is bareguard's own foundational check; the `text` floor below it stops a step file whose only key is junk
+ * from passing a rubric that has no countable part.
+ * @param {{step: number, parts: any[]}} params
+ * @param {Record<string, string>} inputShas label -> sha256 hex, for every label the step cites
+ * @returns {Record<string, any>} a spec for bareguard's `createRubric`
+ */
+export function buildStepSpec(params: {
+    step: number;
+    parts: any[];
+}, inputShas: Record<string, string>): Record<string, any>;
+/**
+ * The step file's bytes as the close reads them: the parsed JSON object, or WHY there is none. A file cut off mid-write
+ * parses to nothing (reason `not-json`); text cut off INSIDE an otherwise valid JSON object cannot be told from a short
+ * answer — that limit is documented, not hidden.
+ * @param {string|null} bytes the file's text, or null when it does not exist
+ * @returns {{obj: Record<string, any>, why: null}|{obj: null, why: 'missing'|'not-json'|'not-object'}}
+ */
+export function parseStepFile(bytes: string | null): {
+    obj: Record<string, any>;
+    why: null;
+} | {
+    obj: null;
+    why: "missing" | "not-json" | "not-object";
+};
+/**
+ * The step file as bareguard's rubric reads it: a flat object. `text` stays `text`; each label in `cites` becomes the field
+ * `cites:<label>` (the name a `cited` check reads its claims from). Nothing else in the file is read.
+ * @param {Record<string, any>} obj
+ * @param {string[]} [countLabels] labels whose claim COUNT a minClaims/maxClaims part reads
+ * @param {any} [factPart] the step's `fact` part: its `results` become claims (text built by code) under `cites:<source>`
+ * @returns {Record<string, any>}
+ */
+export function flattenStep(obj: Record<string, any>, countLabels?: string[], factPart?: any): Record<string, any>;
+/**
+ * One bareguard gap as a sentence the worker can act on. The numbers and names are bareguard's own measurements and the
+ * person's signed limits, never anything this module infers; a gap this table does not know falls back to bareguard's own
+ * rendering, so nothing is ever dropped.
+ * @param {number} step @param {string} why why there was no object, when there was none
+ * @param {any} g a bareguard gap
+ * @param {any} [params] the stage's parameters (a fact step words its gaps by fact)
+ * @returns {string}
+ */
+export function plainStepGap(step: number, why: string, g: any, params?: any): string;
+/**
+ * Grade ONE step: build the rubric, run it over the step file's fields, and say what happened in the close's own terms.
+ * Pure of the filesystem (the runner in src/kinds.js reads the files). `stopped` = the instrument failed (never a red).
+ * @param {{params: {step: number, parts: any[]}, bytes: string|null, outputBytes: string|null, inputs: Record<string, string>,
+ *   factQuotes?: Record<number, string[]>, factMissing?: number[]}} o
+ *   `factQuotes` maps an earlier fact line's number to the quotes its (already checked) step file holds — what a prose step's numbers are tied to
+ *   `factMissing` lists the earlier fact lines whose step file is not there (yet): a normal red, never an instrument fault
+ *   `inputs` maps each cited label to its frozen TEXT; its sha256 is taken here from that text, and bareguard compares it to
+ *   the manifest's recorded sha via `inputShas`.
+ * @param {Record<string, string>} inputShas the manifest's recorded sha256 per cited label
+ * @returns {Promise<{verdict: 'green'|'red'|'stopped', gapLines: string[], fault: string|null, detail: Record<string, any>}>}
+ */
+export function gradeStep({ params, bytes, outputBytes, inputs, factQuotes, factMissing }: {
+    params: {
+        step: number;
+        parts: any[];
+    };
+    bytes: string | null;
+    outputBytes: string | null;
+    inputs: Record<string, string>;
+    factQuotes?: Record<number, string[]>;
+    factMissing?: number[];
+}, inputShas: Record<string, string>): Promise<{
+    verdict: "green" | "red" | "stopped";
+    gapLines: string[];
+    fault: string | null;
+    detail: Record<string, any>;
+}>;
+/**
+ * The labels of a job's numbered inputs, or null when it carries none (a caller that has no inputs in hand skips the label rule).
+ * @param {unknown} inputs @returns {string[]|null}
+ */
+export function inputLabelsOf(inputs: unknown): string[] | null;
+/**
+ * R11 — the drafting-time rules for the `rubric-step` stages of a declaration, each a red in the person's plain words that
+ * names the job line and ends "Nothing spent." where nothing was. Pure; never throws. Judged parts are RED in this build
+ * (the judge arrives in the next one): the sorting is still asked for, so a part that needs the judge is named as such
+ * instead of being approximated by a count.
+ *   - a stage serves exactly the one job line it names (`step` = its only `fromLine`), and no line has two stages;
+ *   - a part with no class (`none`) cannot be counted or checked against a quote;
+ *   - a `judged` part needs the judge; a `guard` part is about web sources and the job has no web input;
+ *   - two countable parts of ONE line that no text can satisfy together (a minimum above a maximum) are a contradiction,
+ *     naming both parts and both numbers;
+ *   - a `cited` part names a label the person's inputs do not have.
+ * @param {any[]} stages the declaration's stages
+ * @param {{inputLabels?: string[]|null, red: (code: string, path: string, detail: string, extra?: object) => void}} o
+ *   `inputLabels` absent = the label rule is not run (a caller with no inputs in hand)
+ */
+export function checkRubricParts(stages: any[], { inputLabels, red }: {
+    inputLabels?: string[] | null;
+    red: (code: string, path: string, detail: string, extra?: object) => void;
+}): void;
+/** the ~ rules of one job line, one string each (`rules` when the line has the array, else the joined `rule` split on "; ") @param {any} l @returns {string[]} */
+export function lineRules(l: any): string[];
+/**
+ * PART 1b, RF16 + RF17 — the rules that need the person's own job lines. Only a close built for REQUIRED FACTS is held to them (a
+ * close with a fact part, or any part that says which `~` rules it carries out): an older Part 1a close is left as it was signed.
+ *   - every `~` rule of every job line is carried out by a part (its number in the part's `rules`), or is listed in `refused` with
+ *     its `rule` number, or its whole line is refused: a rule that is none of those was silently dropped, and that is a red;
+ *   - a number the AI made out of the person's words (a bound the person did not write) must be marked `aiProposal`, and a time
+ *     limit the AI proposes must be a range (`between`), never one-sided — "not a red-eye" must not let a 10 PM flight through.
+ * @param {any[]} stages @param {{jobLines?: any[]|null, refused?: any, red: (code: string, path: string, detail: string, extra?: object) => void}} o
+ */
+export function checkRubricRules(stages: any[], { jobLines, refused, red }: {
+    jobLines?: any[] | null;
+    refused?: any;
+    red: (code: string, path: string, detail: string, extra?: object) => void;
+}): void;
+/**
+ * PART 1c L3 - the person's own words win over the AI's reading of them, settled by CODE before anything is validated or signed:
+ *   - a limit on a fact whose bounds are all in the words the person wrote (the line, its `~` rules, an answer they gave) is the
+ *     person's, so it is NOT marked "AI's proposal" (smv710w8c3wdh: the plan called the person's own range the AI's);
+ *   - a time range the AI proposed while the person wrote ONE explicit positive time range ("between 07:00 and 23:00") on that line
+ *     is replaced by exactly that range (smv710w8c3wdh: the plan said 5:00 AM). Only when it is unambiguous: one such range in the
+ *     line's rules and one AI-proposed `between` time fact on the line; a rule with a negation ("not between ...") is never read as a range;
+ *   - a `~` rule is a check or under Not checked, never both: a `refused` entry for a rule that a part of its own line carries is dropped.
+ * Pure; returns a new declaration, the input untouched. The model is told the same in the brief; this makes it true either way.
+ * @param {any} declaration @param {any[]|null|undefined} jobLines @returns {any}
+ */
+export function settlePersonsWords(declaration: any, jobLines: any[] | null | undefined): any;
+/**
+ * PART 1b — put the number tie on every prose step. A rubric-step stage with no fact part that comes AFTER one or more fact
+ * stages gets exactly one `numbersFromFacts` part naming those lines; one the model wrote is replaced. Pure; returns a new
+ * declaration (the input is untouched). The model never writes this part: it is code's, so a draft cannot omit it.
+ * @param {any} declaration @returns {any}
+ */
+export function withFactBindings(declaration: any): any;
+/**
+ * The ~ rules the drafter listed under Not checked (`refused` entries that name a `rule`), each as one line in the person's own
+ * words: `line N: "<the rule as written>" — <the drafter's reason>` (PART 1b, RF6 / RF16).
+ * @param {any} closeDecl @param {any[]|null|undefined} jobLines @returns {string[]}
+ */
+export function ruleNotChecked(closeDecl: any, jobLines: any[] | null | undefined): string[];
+/**
+ * The Not-checked lines code owns for the rubric-step stages of a close: a prose step's CONTENT is judged by the person at
+ * Accept, and the card says so (PART 1b, RF5). One line per prose step (a stage with no fact part).
+ * @param {any} closeDecl @returns {string[]}
+ */
+export function proseNotChecked(closeDecl: any): string[];
+/**
+ * One countable part as a plain sentence, written by code from the part's signed fields (never from the model's words), so the
+ * plan card and the close are one thing seen twice.
+ * @param {any} part @returns {string}
+ */
+export function partSentence(part: any): string;
+/**
+ * The checks a signed close actually runs, per job line, in plain code-written sentences: one per countable part of every
+ * rubric-step stage. This is the ONE reader both the plan card and the sign-time invariant use.
+ * @param {any} closeDecl
+ * @returns {{line: number, text: string, covers: number[]}[]}
+ */
+export function checksOfClose(closeDecl: any): {
+    line: number;
+    text: string;
+    covers: number[];
+}[];
+/**
+ * Reconcile the CONFIRMED plan with the close the composer actually wrote. The plan card after drafting shows exactly
+ * the close's own checks (`checksOfClose`); every confirmed check that no part carries out (no part lists its number in
+ * `covers`) is moved to Not checked, in the person's words, with the reason. A check can therefore never be shown and then
+ * silently dropped (run mv5bk400: "lists 3 releases" was confirmed, then left out of the signed close without a word).
+ * @param {{confirmed: {text: string, fromLine: number[]|null}[], notChecked: string[], closeDecl: any, jobLines?: any[]|null}} o
+ *   `jobLines` — the person's numbered lines, so a ~ rule the drafter listed as Not checked reads in the person's own words
+ * @returns {{checkItems: {text: string, fromLine: number[]}[], notChecked: string[], moved: {text: string, fromLine: number[]|null}[]}}
+ */
+export function reconcileRubricPlan({ confirmed, notChecked, closeDecl, jobLines }: {
+    confirmed: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+    notChecked: string[];
+    closeDecl: any;
+    jobLines?: any[] | null;
+}): {
+    checkItems: {
+        text: string;
+        fromLine: number[];
+    }[];
+    notChecked: string[];
+    moved: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+};
+/**
+ * The sign-time invariant: the checks the person was shown (`shown`, from the plan card) are exactly the checks the signed
+ * close runs (`checksOfClose`), per line. Pure.
+ * @param {{text: string, fromLine: number[]|null}[]} shown @param {any} closeDecl
+ * @returns {{ok: true}|{ok: false, error: string}}
+ */
+export function planMatchesClose(shown: {
+    text: string;
+    fromLine: number[] | null;
+}[], closeDecl: any): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The frozen TEXT of the named inputs, read the way the runner reads them: the source door's record (`source.json`, one level
+ * above the tree) names each input's file and sha256, and a file whose bytes no longer match is not returned. Used at DRAFTING
+ * (the drafter reads the input, the early tests run on it) and at run start (the backstop). Never throws.
+ * @param {string} workdir the frozen tree @param {string[]} labels
+ * @returns {Promise<{ok: true, texts: Record<string, string>}|{ok: false, why: string}>}
+ */
+export function readFrozenInputs(workdir: string, labels: string[]): Promise<{
+    ok: true;
+    texts: Record<string, string>;
+} | {
+    ok: false;
+    why: string;
+}>;
+/** where the per-line step files live, inside the job's tree; `copyOut` delivers them with the rest of `output/` */
+export const STEP_DIR: "output/steps";
+export function stepFileRel(n: number): string;
+/** the largest step file the close reads: a bigger one is a stop, never silently truncated (bareguard's own source cap) */
+export const STEP_MAX_BYTES: number;
+/** the closed set of classes a part is sorted into; `none` = "I could not sort this one" (a red, in plain words, never a guess) */
+export const PART_CLASSES: readonly string[];
+/**
+ * The counted/quoted checks a `countable` part may name, with the fields each needs — read off bareguard's own rule table
+ * (`rubricVocabulary`): the names are bareguard's, so a check this build cannot run is inexpressible, not rejected late.
+ * (`max`/`min` need a numeric field the step file does not have, so they are not offered.)
+ * @type {Readonly<Record<string, readonly string[]>>}
+ */
+export const COUNT_CHECKS: Readonly<Record<string, readonly string[]>>;
+export function sha256Of(b: string | Buffer): string;
+export type ShapeRed = {
+    code: string;
+    path: string;
+    detail: string;
+};

package/types/source.d.ts

@@ -330,6 +330,100 @@ export function proveInputFiles(inputs: {
     ok: false;
     error: string;
 }>;
+/**
+ * Does this source manifest belong to a rubric job on local files (`proveRubricInputs` wrote it)? One spelling for both
+ * doors (the panel session and the CLI author run): a non-repo source that froze numbered, labelled input files.
+ * @param {Record<string, any>|null|undefined} manifest
+ * @returns {boolean}
+ */
+export function isRubricFilesManifest(manifest: Record<string, any> | null | undefined): boolean;
+/**
+ * PART 1a (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-12"): the front door for a RUBRIC job whose inputs are the
+ * person's own LOCAL FILES, not a repo. Each numbered `label: /absolute/file` line is proven at $0 and frozen into the
+ * same hidden-git tree a plain folder gets (`prepareSource`, which also refuses a secret shape, an environment file
+ * and a symlink), under `input/`; the manifest then also records `inputs: [{label, rel, sha256}]` — the bytes the
+ * rubric's `cited` check will search a quote in, hashed once, here. A line that is a web address is fetched ONCE with
+ * barebrowse (PART 1c, read only) and its text frozen under `input/` like a file (the manifest row also records its `url`,
+ * so run start can fetch it again); a `search:` line is a named refusal (a later build); so is a relative path, a missing file, a folder, a file over
+ * {@link RUBRIC_INPUT_MAX_BYTES}, and text that is not valid UTF-8. Every refusal is plain words naming the line and
+ * ends "Nothing spent." — nothing here touches a model.
+ * @param {{inputs: {n: number, label: string, value: string}[], into: string, destination?: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `fetchUrl` - how a web address is read (default barebrowse via `fetchPageText`; a test injects a stub, never the network)
+ * @returns {Promise<{ok: true, prep: {stop: null, into: string, tree: string, manifestPath: string, manifest: Record<string, any>}}|{ok: false, error: string, code: string}>}
+ */
+export function proveRubricInputs({ inputs, into, destination, fetchUrl }: {
+    inputs: {
+        n: number;
+        label: string;
+        value: string;
+    }[];
+    into: string;
+    destination?: string;
+    fetchUrl?: (url: string) => Promise<{
+        ok: true;
+        text: string;
+        url: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+}): Promise<{
+    ok: true;
+    prep: {
+        stop: null;
+        into: string;
+        tree: string;
+        manifestPath: string;
+        manifest: Record<string, any>;
+    };
+} | {
+    ok: false;
+    error: string;
+    code: string;
+}>;
+/**
+ * Is this Inputs value a path to an existing regular FILE on this machine (not a repo folder, not a web address, not a
+ * missing path)? The $0 peek that tells a rubric job on local files from a rubric job on a repo before a session exists;
+ * `proveRubricInputs` makes the authoritative, line-by-line proof.
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeLocalFile(value: string): boolean;
+/**
+ * Is this Inputs value one a rubric job can work on without a repo: a regular FILE on this machine, or a web address (PART 1c)?
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeRubricInput(value: string): boolean;
+/**
+ * RUN START for a rubric job with web inputs (PART 1c, RF22): fetch every web input AGAIN and make that text the run's frozen input
+ * BEFORE the worker starts. The drafting copy was only for the look (prices change); the close grades, and the worker reads, THIS
+ * copy. It is written into the prepared tree, committed as the new seed (so the page is never read as a worker write), and
+ * `source.json` is rewritten (new sha256 per input, new seed, `draftSha256` keeps what the look saw). Nothing but the text of a
+ * recorded web address is ever refetched; a job with only file inputs returns at once and changes nothing.
+ * @param {{into: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `into` - the prepared copy (source.json + tree/)
+ * @returns {Promise<{ok: true, refreshed: string[], seed: string|null}|{ok: false, error: string}>}
+ */
+export function refreezeUrlInputs({ into, fetchUrl }: {
+    into: string;
+    fetchUrl?: (url: string) => Promise<{
+        ok: true;
+        text: string;
+        url: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+}): Promise<{
+    ok: true;
+    refreshed: string[];
+    seed: string | null;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** the per-file ceiling for a rubric input: bareguard's `cited` check searches a quote in a source only up to this size
+ * (its `quoteSourceMaxBytes`); a bigger file could never be cited from, so the door refuses it at $0 */
+export const RUBRIC_INPUT_MAX_BYTES: number;
 /**
  * a named, non-throwing stop
  */