bareloop 0.39.0 → 0.41.0

package/types/providerrows.d.ts

@@ -7,26 +7,26 @@
  */
 export function usableKey<T extends string | undefined>(raw: T): T | string;
 /**
- * What a key with no saved entry shows. Any name not listed is OpenAI-compatible with a
- * blank URL and a blank Name.
+ * The model lines of a row, pure (no I/O, no rewrite of the file). A row WITH `models.<ENV>` uses
+ * that list and ignores `keys.<ENV>.{name,priceInPerM,priceOutPerM}`. A row WITHOUT it whose
+ * `keys.<ENV>.name` is a non-empty saved string reads as ONE line: ticked when BOTH older prices
+ * are finite numbers >= 0 (the line carries them), else UNTICKED with no price (a ticked line
+ * needs both prices). A row with no saved name reads as no lines — nothing is carried from a
+ * built-in table.
  * @param {string} envName
- * @returns {{ name: string, shape: string, baseUrl: string }}
+ * @param {Record<string, any>} config
+ * @returns {ModelLine[]}
  */
-export function defaultsFor(envName: string): {
-    name: string;
-    shape: string;
-    baseUrl: string;
-};
+export function effectiveModels(envName: string, config: Record<string, any>): ModelLine[];
 /**
- * @typedef {object} KeyRow
- * @property {string} envName the key variable NAME (read-only label; never a value)
- * @property {string} name the model id Chat uses ('' = not offered in Chat)
- * @property {string} provider the `src/providers.js` table entry (the API shape's id)
- * @property {string} baseUrl the saved Base URL ('' = the shape's default host)
- * @property {unknown} [priceInPerM] the customer's own price, USD per 1M input tokens — carried RAW
- *   (present only when the config row names it); {@link ratesFor} is the one place that validates it
- * @property {unknown} [priceOutPerM] the same, for output tokens
+ * Every ticked-and-priced line of the rows, in keys-file order.
+ * @param {readonly KeyRow[]} rows
+ * @returns {{ row: KeyRow, line: ModelLine }[]}
  */
+export function tickedLines(rows: readonly KeyRow[]): {
+    row: KeyRow;
+    line: ModelLine;
+}[];
 /**
  * The rows: one per name in `filled`, saved entry over defaults.
  * @param {{ filled: readonly string[], config: Record<string, any> }} src
@@ -37,20 +37,33 @@ export function keyRows({ filled, config }: {
     config: Record<string, any>;
 }): KeyRow[];
 /**
- * The rows for a keys home. `undefined` home (a door that skipped the keys file) = no
- * rows, so nothing resolves through the file and the provider's built-in variable stands.
+ * The key names that make rows: every key in the keys file with a value (file order), plus — when `env` is given — a key only the
+ * SHELL holds that config already names (`keys.<ENV>` or `models.<ENV>`), sorted after them. The page shows such a row as
+ * "found in shell"; the run path must resolve it the same way.
+ * @param {readonly string[]} filled the keys file's filled names
+ * @param {Record<string, any>} config
+ * @param {Record<string, string|undefined>} [env] the shell side
+ * @returns {string[]}
+ */
+export function rowNamesOf(filled: readonly string[], config: Record<string, any>, env?: Record<string, string | undefined>): string[];
+/**
+ * The rows for a keys home. `undefined` home (a door that skipped the keys file) = no rows. With `env`, a shell-only key that
+ * config names is a row too ({@link rowNamesOf}).
  * @param {string|undefined} home
+ * @param {Record<string, string|undefined>} [env]
  * @returns {KeyRow[]}
  */
-export function rowsForHome(home: string | undefined): KeyRow[];
+export function rowsForHome(home: string | undefined, env?: Record<string, string | undefined>): KeyRow[];
 /**
- * @param {string} provider
- * @returns {string} the shape's default host ('' = the vendor's own)
+ * EVERY row a config home names, keyed or not: the keys file's filled names plus every name `keys.<ENV>` / `models.<ENV>` carries. For
+ * a readout that must say which variable a model line WOULD read ("KEY is not set in this shell") before any key exists. Never for a run.
+ * @param {string|undefined} home
+ * @returns {KeyRow[]}
  */
-export function defaultUrlOf(provider: string): string;
+export function namedRowsForHome(home: string | undefined): KeyRow[];
 /**
- * An endpoint in comparable form: blank = the shape's default host; scheme + host lower-cased,
- * trailing slashes dropped.
+ * An endpoint in comparable form: scheme + host lower-cased, trailing slashes dropped. A blank
+ * Base URL is blank — there is no default host.
  * @param {string} provider
  * @param {string|null|undefined} baseUrl
  * @returns {string}
@@ -58,8 +71,7 @@ export function defaultUrlOf(provider: string): string;
 export function endpointOf(provider: string, baseUrl: string | null | undefined): string;
 /**
  * A job's provider in plain words for a refusal line: the host its Base URL points at (else the
- * shape's own default host, else the shape's label), plus the model when the spec names one.
- * Never a key, a path or a status code.
+ * shape's label), plus the model when the spec names one. Never a key, a path or a status code.
  * @param {{provider?: string, baseUrl?: string|null, model?: string|null}} spec
  * @returns {string}
  */
@@ -68,15 +80,10 @@ export function providerInWords(spec: {
     baseUrl?: string | null;
     model?: string | null;
 }): string;
-/**
- * The URL a row talks to, for display ('' = the vendor's own host, which has no URL to show).
- * @param {KeyRow} row
- * @returns {string}
- */
-export function shownUrl(row: KeyRow): string;
 /**
  * Which row a `(provider, baseUrl[, model])` identity belongs to: the rows on that shape and
- * endpoint; when several share it, the one whose Name is the model, else the first.
+ * endpoint; when several share it, the one that HAS a ticked-and-priced line for `model`, else
+ * the first.
  * @param {readonly KeyRow[]} rows
  * @param {{ provider?: string|null, baseUrl?: string|null, model?: string|null }} id
  * @returns {KeyRow|null}
@@ -87,56 +94,97 @@ export function findRow(rows: readonly KeyRow[], { provider, baseUrl, model }: {
     model?: string | null;
 }): KeyRow | null;
 /**
- * What Chat's Model menu offers and how a pick resolves: the row whose Name is the model
- * (a blank Name is never offered). `baseUrl` is absent when blank, exactly as a spec omits it.
+ * How a Model-menu pick resolves: the row named by `provider` (its key's env name) with a ticked-and-priced line for `model`.
+ * With no `provider` (an older caller) the first row ticking the model. `baseUrl` is absent when blank, exactly as a spec omits it.
+ * A model no row ticks, or a row that does not tick it, is `null` — never offered, never run.
  * @param {readonly KeyRow[]} rows
- * @param {string} model
- * @returns {{ provider: string, baseUrl?: string, envName: string, name: string }|null}
+ * @param {{ provider?: string|null, model?: string|null }} pick `provider` is the KEY's env name
+ * @returns {{ provider: string, baseUrl?: string, envName: string, name: string, legacyMaxTokens: boolean }|null}
  */
-export function modelChoiceFor(rows: readonly KeyRow[], model: string): {
+export function modelChoiceFor(rows: readonly KeyRow[], { provider, model }: {
+    provider?: string | null;
+    model?: string | null;
+}): {
     provider: string;
     baseUrl?: string;
     envName: string;
     name: string;
+    legacyMaxTokens: boolean;
 } | null;
 /**
- * The models Chat offers, in keys-file order.
+ * The lines Chat's Model menu offers: every ticked-and-priced line of the rows, in keys-file order, labelled `<KEY> · <model>`.
  * @param {readonly KeyRow[]} rows
- * @returns {{ id: string, envName: string, shape: string }[]}
+ * @returns {{ slot: string, model: string, label: string }[]}
  */
-export function chatModels(rows: readonly KeyRow[]): {
-    id: string;
-    envName: string;
-    shape: string;
+export function chatLines(rows: readonly KeyRow[]): {
+    slot: string;
+    model: string;
+    label: string;
 }[];
 /**
- * The key variable NAME a job on `(provider, baseUrl[, model])` reads: the matching row's
- * variable, else the provider's built-in one (byte-identical to before for anything no row
- * claims).
+ * Judge a Model-menu pick `{provider, model}` against the rows, for the doors that start a session. `ok:true` carries the choice;
+ * otherwise the plain refusal (one of the three sentences).
+ * @param {readonly KeyRow[]} rows
+ * @param {{ provider?: string|null, model?: string|null }} pick
+ * @returns {{ ok: true, choice: NonNullable<ReturnType<typeof modelChoiceFor>> } | { ok: false, say: string }}
+ */
+export function judgePick(rows: readonly KeyRow[], pick: {
+    provider?: string | null;
+    model?: string | null;
+}): {
+    ok: true;
+    choice: NonNullable<ReturnType<typeof modelChoiceFor>>;
+} | {
+    ok: false;
+    say: string;
+};
+/**
+ * Which Settings line a RUN works on. A spec's own `model` wins; a spec that names none (signed before models were required)
+ * takes `--model <id>`; a spec with no `baseUrl` (the same era) matches a row on any endpoint of its shape. `--provider <KEY>`
+ * narrows to one key when two keys tick the same id. Pure; the signed spec is never changed, so its hash is untouched.
+ * @param {readonly KeyRow[]} rows
+ * @param {{ provider?: string|null, baseUrl?: string|null, model?: string|null }} spec the signed spec's worker fields
+ * @param {{ model?: string|null, provider?: string|null }} [flags] the operator's `--model` / `--provider`
+ * @returns {{ ok: true, row: KeyRow, line: ModelLine, model: string, baseUrl: string|undefined } | { ok: false, say: string }}
+ */
+export function resolveWorker(rows: readonly KeyRow[], spec: {
+    provider?: string | null;
+    baseUrl?: string | null;
+    model?: string | null;
+}, flags?: {
+    model?: string | null;
+    provider?: string | null;
+}): {
+    ok: true;
+    row: KeyRow;
+    line: ModelLine;
+    model: string;
+    baseUrl: string | undefined;
+} | {
+    ok: false;
+    say: string;
+};
+/**
+ * The key variable NAME a job on `(provider, baseUrl[, model])` reads: the matching row's own env name. There is NO built-in
+ * name: no matching row = no key (`name: null`).
  * @param {string|null|undefined} provider
  * @param {string|null|undefined} baseUrl
  * @param {readonly KeyRow[]} rows
  * @param {string|null|undefined} [model]
- * @returns {{ name: string, builtIn: string, chosen: boolean }}
+ * @returns {{ name: string|null, chosen: boolean }}
  */
 export function keyNameFor(provider: string | null | undefined, baseUrl: string | null | undefined, rows: readonly KeyRow[], model?: string | null | undefined): {
-    name: string;
-    builtIn: string;
+    name: string | null;
     chosen: boolean;
 };
 /**
- * The env a door hands to provider construction, with the matching row's key variable
- * standing in for the provider's built-in one: `env[builtIn] = env[row.envName]` (the `null`
- * no-key marker becomes {@link NO_KEY_PLACEHOLDER}). A copy — never mutates the input.
- * No matching row and no marker = the env unchanged.
+ * The key VALUE for a row's env name out of an env (the `null` no-key marker becomes {@link NO_KEY_PLACEHOLDER}); `undefined`
+ * when the row's variable is unset or empty.
  * @param {Record<string,string|undefined>} env
- * @param {string|null|undefined} provider
- * @param {string|null|undefined} baseUrl
- * @param {readonly KeyRow[]} rows
- * @param {string|null|undefined} [model]
- * @returns {Record<string,string|undefined>}
+ * @param {string|null|undefined} envName
+ * @returns {string|undefined}
  */
-export function applyConfiguredKey(env: Record<string, string | undefined>, provider: string | null | undefined, baseUrl: string | null | undefined, rows: readonly KeyRow[], model?: string | null | undefined): Record<string, string | undefined>;
+export function keyValueOf(env: Record<string, string | undefined>, envName: string | null | undefined): string | undefined;
 /**
  * The one readout line for a resolved customer price, preview and run tail alike:
  * `yours: in $0.006 / out $1.20 per 1M tokens (DEEPSEEK_API_KEY row)`. A 0 / 0 price is accepted (the price
@@ -150,12 +198,12 @@ export function priceReadout(price: {
     envName: string;
 }): string;
 /**
- * The customer's own price for the row a `(provider, baseUrl[, model])` identity belongs to —
- * the SAME row match {@link keyNameFor} uses (`findRow`), so the price and the key always come
- * from one row. `null` = no price set (the run keeps bare-agent's built-in guess, byte-identical
- * to before). Both fields or neither, each a finite number >= 0, USD per 1M tokens; anything
- * else throws `ConfigError` naming the row and field — a bad price never silently falls back to
- * the guess. `rates` is bare-agent's `Loop({ rates })` shape (USD per 1K); `inPerM`/`outPerM`
+ * The customer's own price for the model LINE of the row a `(provider, baseUrl[, model])` identity
+ * belongs to — the SAME row match {@link keyNameFor} uses (`findRow`), so the price and the key
+ * always come from one row. With a `model`, the row's line of that name; without one, the row's
+ * first ticked line. `null` = no price set (the run keeps bare-agent's built-in guess). A line's
+ * price is a pair or nothing ({@link modelsProblem} guards the file), so a half price never
+ * reaches here. `rates` is bare-agent's `Loop({ rates })` shape (USD per 1K); `inPerM`/`outPerM`
  * are what a readout prints.
  * @param {string|null|undefined} provider
  * @param {string|null|undefined} baseUrl
@@ -173,13 +221,38 @@ export function ratesFor(provider: string | null | undefined, baseUrl: string |
     envName: string;
 } | null;
 /**
- * The price a judge's rounds are booked at. A price belongs to the MODEL's row: when the judge is
- * the worker's own provider it calls the worker's endpoint, so a row on that endpoint NAMED for the
- * judge's model prices it ({@link ratesFor}); a judge model that is absent or names no row there
- * keeps the worker's price (the worker's row, or none = the guess). A different provider resolves
- * on its own default endpoint, as before. A bad price on the resolved row throws like `ratesFor`.
- * The judge's KEY is chosen elsewhere (`applyConfiguredKey`, by the worker's model), so the two
- * can come from different rows — same provider + endpoint, judge model naming another row.
+ * A model line's own price in bare-agent's shape, or `null` when the line carries none (a price is a pair or nothing).
+ * @param {ModelLine} line
+ * @returns {{ rates: { in: number, out: number }, inPerM: number, outPerM: number }|null}
+ */
+export function ratesOfLine(line: ModelLine): {
+    rates: {
+        in: number;
+        out: number;
+    };
+    inPerM: number;
+    outPerM: number;
+} | null;
+/**
+ * The row a judge's key and endpoint come from: the worker's own row when the judge shares the worker's API shape, else the judge
+ * shape's row that ticks the judge's model (else the first row of that shape). `null` when no row is on that shape.
+ * @param {readonly KeyRow[]} rows
+ * @param {{ provider: string, model?: string|null }} judge
+ * @param {string|null|undefined} workerProvider
+ * @param {KeyRow|null} workerRow
+ * @returns {KeyRow|null}
+ */
+export function judgeRowFor(rows: readonly KeyRow[], judge: {
+    provider: string;
+    model?: string | null;
+}, workerProvider: string | null | undefined, workerRow: KeyRow | null): KeyRow | null;
+/**
+ * The price a judge's rounds are booked at. A price belongs to the MODEL's line: when the judge is
+ * the worker's own provider it calls the worker's endpoint, so a row on that endpoint with a line
+ * NAMED for the judge's model prices it ({@link ratesFor}); a judge model that is absent or names
+ * no line there keeps the worker's price (the worker's row, or none = the guess). A different
+ * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`applyConfiguredKey`,
+ * by the worker's model), so the two can come from different rows.
  * @param {{ provider: string, model?: string|null }} judge
  * @param {string|null|undefined} workerProvider
  * @param {string|null|undefined} workerBaseUrl
@@ -191,52 +264,72 @@ export function judgeRatesFor(judge: {
     provider: string;
     model?: string | null;
 }, workerProvider: string | null | undefined, workerBaseUrl: string | null | undefined, workerPrice: ReturnType<typeof ratesFor>, rows: readonly KeyRow[]): ReturnType<typeof ratesFor>;
-/** DeepSeek's OpenAI-shaped endpoint (the same string the panel's Model menu used). */
-export const DEEPSEEK_BASE_URL: "https://api.deepseek.com/v1";
-/**
- * The API shapes the dropdown offers. `id` is the `src/providers.js` table name;
- * `defaultUrl` is the host a blank Base URL means ('' = the vendor's own, unshown).
- * @type {readonly {id: string, label: string, defaultUrl: string}[]}
- */
-export const SHAPES: readonly {
-    id: string;
-    label: string;
-    defaultUrl: string;
-}[];
-/** The five empty lines a fresh keys file is created with, in this order. */
-export const PRESET_KEY_NAMES: readonly string[];
-/** A local server's default endpoint: Ollama's OpenAI-compatible host (LM Studio / llama.cpp: change the URL). */
-export const LOCAL_BASE_URL: "http://127.0.0.1:11434/v1";
+export { SHAPES };
 /**
  * A key line whose value is the word `null` is SET and means "no real key": the row exists and
  * the provider is handed this harmless stand-in (local servers ignore auth). It is not a
  * secret and is never shown or logged as a key.
  */
 export const NO_KEY_PLACEHOLDER: "no-key-needed";
-export type KeyRow = {
+export function isTickedLine(l: ModelLine): boolean;
+/** The plain sentence when a stale Chat pick names a key and a model no row ticks (fwd's wording, bareloop's seam). */
+export const REFUSE_NO_TICK: "Tick a model in Settings > Providers. Nothing was spent.";
+export const REFUSE_NO_PICK: "Pick a model. Nothing was spent.";
+export function refuseNotSetUp(key: string): string;
+/**
+ * The CLI sentence when a run names no model and the spec carries none (fwd's `pickTicked` sentence).
+ */
+export const REFUSE_NAME_MODEL: "Name the model with --model <id>: one ticked in Settings > Providers with both prices.";
+/**
+ * one model line of a row (`models.<ENV>` in config.json)
+ */
+export type ModelLine = {
     /**
-     * the key variable NAME (read-only label; never a value)
+     * the model id
+     */
+    model: string;
+    /**
+     * ticked = offered in Chat (needs both prices)
      */
+    use: boolean;
+    /**
+     * the customer's own price, USD per 1M input tokens
+     */
+    inPerM?: number | undefined;
+    /**
+     * the same, for output tokens
+     */
+    outPerM?: number | undefined;
+};
+export type PriceResult = {
+    rates: {
+        in: number;
+        out: number;
+    };
+    inPerM: number;
+    outPerM: number;
     envName: string;
+} | null;
+export type KeyRow = {
     /**
-     * the model id Chat uses ('' = not offered in Chat)
+     * the key variable NAME (read-only label; never a value)
      */
-    name: string;
+    envName: string;
     /**
      * the `src/providers.js` table entry (the API shape's id)
      */
     provider: string;
     /**
-     * the saved Base URL ('' = the shape's default host)
+     * the saved Base URL ('' = none typed yet)
      */
     baseUrl: string;
     /**
-     * the customer's own price, USD per 1M input tokens — carried RAW
-     * (present only when the config row names it); {@link ratesFor} is the one place that validates it
+     * the "old max_tokens" tick (only meaningful on `openai-api`)
      */
-    priceInPerM?: unknown;
+    legacyMaxTokens: boolean;
     /**
-     * the same, for output tokens
+     * the row's model lines
      */
-    priceOutPerM?: unknown;
+    models: ModelLine[];
 };
+import { SHAPES } from './providershapes.js';

package/types/providers.d.ts

@@ -1,10 +1,3 @@
-/**
- * The per-call options the rubric JUDGE's model calls carry for this provider
- * instance, from the allow-list above. Empty for any provider/model not listed.
- * @param {any} provider a constructed bare-agent provider
- * @returns {Record<string, any>}
- */
-export function judgeCallOptions(provider: any): 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-
@@ -18,7 +11,7 @@ export function resolveProvider(providerName: string): ProviderTableEntry;
 /**
  * Report whether a resolved API key VALUE (not its presence — every call
  * site already presence-checks separately) carries a shape an HTTP header
- * value cannot: F181 (`docs/logs/FINDINGS.md`) — a two-line secret-store
+ * value cannot: F181 (`docs/wiki/FINDINGS.md`) — a two-line secret-store
  * entry put the key plus a trailing metadata line into `OPENAI_API_KEY`
  * (`"<key>\nmeta"`), the presence-only check at every door passed, and Node
  * crashed `TypeError [ERR_INVALID_CHAR]` inside its own header-encode at the
@@ -44,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).
- *
- * 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.
+ * 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).
  *
- * `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]
@@ -157,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 —
@@ -222,20 +153,8 @@ 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/run.d.ts

@@ -158,7 +158,7 @@
  *        frozen A0 baseline arm has to be exactly today, so a guard firing under a disabled
  *        shim would make the baseline a treatment arm. The default-flip belongs to a
  *        paid contrast nobody has approved yet (the `layerRoot` precedent, F41).
- * @param {boolean} [opts.scout=true] operator-only switch (docs/product/SCOUT-CONTRAST.md),
+ * @param {boolean} [opts.scout=true] operator-only switch (docs/logs/SCOUT-CONTRAST.md),
  *   forwarded verbatim to the plan flow: `false` on a fresh run (no `resumeSeed`) skips the
  *   read-only survey and records `scout-skipped {reason:'operator-off'}` instead — the
  *   planner drafts from `(no scout notes)`. Runner territory exactly like `readShim`: the