dsh-llm-verifier 0.6.2 → 0.6.4

package/src/client-fields.ts

@@ -58,6 +58,10 @@ export interface Values {
   cacheMaxEntries: number
   estimatedInputUsdPerMillion: number
   estimatedOutputUsdPerMillion: number
+  estimatedCachedInputUsdPerMillion: number
+  autoPriceFromCatalog: boolean
+  autoPriceOnline: boolean
+  priceProviderOverride: string
   autoVerifySubagents: boolean
   extraJudges: ExtraJudgeDraft[]
 }
@@ -112,6 +116,10 @@ export const CONFIG_DEFAULTS: Values = {
   cacheMaxEntries: 10000,
   estimatedInputUsdPerMillion: 0,
   estimatedOutputUsdPerMillion: 0,
+  estimatedCachedInputUsdPerMillion: 0,
+  autoPriceFromCatalog: true,
+  autoPriceOnline: true,
+  priceProviderOverride: '',
   autoVerifySubagents: false,
   extraJudges: [],
 }
@@ -244,8 +252,12 @@ export const FIELDS: readonly FieldSpec[] = [
   number('retryBaseDelayMs', 'execution', { min: 1, integer: true, unitKey: 'settings.unit.ms' }),
   number('timeoutMs', 'execution', { min: 1, integer: true, unitKey: 'settings.unit.ms' }),
 
+  toggle('autoPriceFromCatalog', 'cost'),
+  toggle('autoPriceOnline', 'cost'),
+  text('priceProviderOverride', 'cost', true),
   number('estimatedInputUsdPerMillion', 'cost', { min: 0 }),
   number('estimatedOutputUsdPerMillion', 'cost', { min: 0 }),
+  number('estimatedCachedInputUsdPerMillion', 'cost', { min: 0 }),
 ]
 
 export function fieldsOfSection(section: SectionId): FieldSpec[] {
@@ -336,6 +348,10 @@ export function valuesFromView(view: Record<string, unknown> | undefined): Value
     cacheMaxEntries: numberOr('cacheMaxEntries'),
     estimatedInputUsdPerMillion: numberOr('estimatedInputUsdPerMillion'),
     estimatedOutputUsdPerMillion: numberOr('estimatedOutputUsdPerMillion'),
+    estimatedCachedInputUsdPerMillion: numberOr('estimatedCachedInputUsdPerMillion'),
+    autoPriceFromCatalog: v.autoPriceFromCatalog !== false,
+    autoPriceOnline: v.autoPriceOnline !== false,
+    priceProviderOverride: typeof v.priceProviderOverride === 'string' ? v.priceProviderOverride.trim() : '',
     autoVerifySubagents: v.autoVerifySubagents === true,
     extraJudges: normalizeExtraJudges(v.extraJudges),
   }
@@ -417,10 +433,17 @@ export function validateValues(values: Values): FieldIssue[] {
       }
       continue
     }
-    // Empty is a legal value for the two identity-ish text fields: the custom criteria file falls
-    // back to `coding`, and the alternative model falls back to the request's own route. Requiring
-    // text here would reject a save the host accepts.
-    if (field.kind === 'text' && field.key !== 'criteriaFile' && field.key !== 'label' && field.key !== 'autoProcessAlternativeModel') {
+    // Empty is a legal value for the optional text fields: the custom criteria file falls
+    // back to `coding`, the alternative model falls back to the request's own route, label falls
+    // back to provider/model, and priceProviderOverride defaults to empty (no cross-provider guessing).
+    // Requiring text here would reject a save the host accepts.
+    if (
+      field.kind === 'text' &&
+      field.key !== 'criteriaFile' &&
+      field.key !== 'label' &&
+      field.key !== 'autoProcessAlternativeModel' &&
+      field.key !== 'priceProviderOverride'
+    ) {
       const value = typeof raw === 'string' ? raw.trim() : ''
       if (!value) {
         issues.push({ key: field.key, code: 'required' })

package/src/client-i18n.ts

@@ -127,6 +127,14 @@ export const zh = {
   'field.estimatedInputUsdPerMillion.help': '每百万输入 Token 的美元价格，仅用于统计估算。',
   'field.estimatedOutputUsdPerMillion.title': '输出价格',
   'field.estimatedOutputUsdPerMillion.help': '每百万输出 Token 的美元价格，仅用于统计估算。',
+  'field.estimatedCachedInputUsdPerMillion.title': '缓存读取价格',
+  'field.estimatedCachedInputUsdPerMillion.help': '每百万缓存命中输入 Token 的美元价格；留 0 时退回按输入价格计算（旧口径，对缓存密集的调用会高估）。',
+  'field.autoPriceFromCatalog.title': '从本机模型目录自动定价',
+  'field.autoPriceFromCatalog.help': '本机安装的 pi-ai 模型目录（models.dev 快照）里有这条 provider/模型时自动取出单价。手填的价格永远优先；目录里没有就交给在线价格库。',
+  'field.autoPriceOnline.title': '在线价格库兜底',
+  'field.autoPriceOnline.help': '本机目录查不到时向 models.dev 查一次（结果缓存 24 小时）。只按 provider + 模型精确匹配，绝不跨 provider 猜价——同一个模型 id 在不同转售商手里能差 6 倍。',
+  'field.priceProviderOverride.title': '价格来源 Provider',
+  'field.priceProviderOverride.help': '转售路由（例如 command-code）两张价格表里都没有时，填一个 provider id（例如 openrouter），按它的挂牌价折算。留空表示不猜：未定价的路由成本记为 0。',
 
   // Settings Actions & Alerts
   'settings.catalogFailures': '部分模型目录读取失败',
@@ -472,6 +480,14 @@ export const en: I18nDict = {
   'field.estimatedInputUsdPerMillion.help': 'USD price per million input tokens, for statistical estimation only.',
   'field.estimatedOutputUsdPerMillion.title': 'Output Price',
   'field.estimatedOutputUsdPerMillion.help': 'USD price per million output tokens, for statistical estimation only.',
+  'field.estimatedCachedInputUsdPerMillion.title': 'Cached Input Price',
+  'field.estimatedCachedInputUsdPerMillion.help': 'USD per million cached prompt tokens. Left at 0 it falls back to the input price, which is the old estimate and over-reports cache-heavy calls.',
+  'field.autoPriceFromCatalog.title': 'Auto Price From Catalog',
+  'field.autoPriceFromCatalog.help': 'Price this judge route from the installed pi-ai model catalog (a models.dev snapshot). Typed prices always win; a route the catalog does not describe moves on to the online lookup.',
+  'field.autoPriceOnline.title': 'Online Price Lookup',
+  'field.autoPriceOnline.help': 'When the installed catalog has no entry, query models.dev once (cached for 24 hours). Matching is exact provider + model only — prices are never guessed across providers, where the same model id can differ sixfold.',
+  'field.priceProviderOverride.title': 'Price Source Provider',
+  'field.priceProviderOverride.help': 'For a reseller route neither price table knows (for example command-code), name the provider whose list price to follow (for example openrouter). Empty means never guess and leave the route unpriced.',
 
   // Settings Actions & Alerts
   'settings.catalogFailures': 'Some model catalogs failed to load',

package/src/client.test.ts

@@ -805,5 +805,64 @@ describe('client design tokens', () => {
   })
 })
 
+/** Body of one exported function declaration, up to its column-zero closing brace. */
+function declarationBody(source: string, name: string): string {
+  const start = source.indexOf('export function ' + name + '(')
+  expect(start, name).toBeGreaterThanOrEqual(0)
+  const end = source.indexOf('\n}\n', start)
+  return source.slice(start, end === -1 ? undefined : end)
+}
+
+/** One `const NAME: React.CSSProperties = { ... }` object literal, up to its column-zero brace. */
+function styleObject(source: string, name: string): string {
+  const start = source.indexOf('const ' + name + ': React.CSSProperties = {')
+  expect(start, name).toBeGreaterThanOrEqual(0)
+  const end = source.indexOf('\n}', start)
+  expect(end, name).toBeGreaterThan(start)
+  return source.slice(start, end)
+}
+
+/**
+ * The activity card is ONE element that owns both the dock-column width and the card surface.
+ *
+ * The composer stack is a host region a host or skin stylesheet may paint (the dock row, for
+ * instance with the tip surface). A wrapper holding the dock-column width but no background of its
+ * own then shows that paint as a "mask" reaching well past the card on both sides — the reported
+ * "背景遮罩超出了位置" — because a background is only ever clipped to the border box it is declared
+ * on. The host's own TodoPanel does the same single-element thing for the same reason, so this also
+ * keeps the chip a member of that family. Splitting the card back into a wrapper plus an inner bar
+ * reintroduces the bug whatever the inner element looks like, hence the regression.
+ */
+describe('client activity card structure', () => {
+  const read = (): string => readFileSync(fileURLToPath(new URL('./client.tsx', import.meta.url)), 'utf8')
+
+  it('renders the chip as a single box', () => {
+    const body = declarationBody(read(), 'VerifierActivityChip')
+    expect(body.match(/<div/g)?.length).toBe(1)
+    expect(body).toContain('style={activityCard}')
+  })
+
+  it('declares the dock-column width and the card surface on that one element', () => {
+    const card = styleObject(read(), 'activityCard')
+    // The width axis (chat content column minus the composer clearances and the four dock insets).
+    expect(card).toContain('--dsh-composer-side-clearance')
+    expect(card).toContain('maxWidth')
+    expect(card).toContain('--dsh-composer-card-max-width')
+    // The surface, its stroke and the card's fixed height, on the very same element.
+    expect(card).toContain('borderRadius: 12')
+    expect(card).toContain('border:')
+    expect(card).toContain('--dsw-alias-border-l1')
+    expect(card).toContain('background:')
+    expect(card).toContain('--dsw-specific-tip')
+    expect(card).toContain('height: 36')
+  })
+
+  it('leaves no second element on that width axis for a host-painted row surface to show through', () => {
+    const source = read()
+    const dockWidths = source.match(/width: 'calc\(100% - var\(--dsh-composer-side-clearance/g) ?? []
+    expect(dockWidths.length).toBe(1)
+  })
+})
+
 
 

package/src/client.tsx

@@ -1000,18 +1000,19 @@ async function readVerifierActivity(rpc: any, sessionId: string, signal: AbortSi
  * four dock insets — and the fallbacks below only matter on a host that does not publish the three
  * custom properties. Without this clamp the status line stretches to the window edge and its text
  * sits far left of the composer it belongs to, which is exactly the misplacement it is here to fix.
+ *
+ * ONE element owns BOTH the dock-column width and the card surface. The composer stack is a host
+ * region a host or skin stylesheet may paint (the dock row, for instance with the tip surface), and
+ * a wider wrapper that paints no background of its own would show that paint as a mask reaching
+ * well past the card on both sides. The surface here is declared inline, so it is itself the card:
+ * a background can never be painted outside the border box it is declared on.
  */
-const activityDock: React.CSSProperties = {
-  boxSizing: 'border-box',
-  width: 'calc(100% - var(--dsh-composer-side-clearance, 16px) - var(--dsh-composer-side-clearance, 16px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px))',
-  margin: '0 auto',
-}
-const activityBar: React.CSSProperties = {
+const activityCard: React.CSSProperties = {
   boxSizing: 'border-box',
   display: 'flex',
   alignItems: 'center',
   gap: 10,
-  width: '100%',
+  width: 'calc(100% - var(--dsh-composer-side-clearance, 16px) - var(--dsh-composer-side-clearance, 16px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px) - var(--dsh-composer-dock-inset, 8px))',
   maxWidth: 'calc(var(--dsh-composer-card-max-width, 952px) - 4 * var(--dsh-composer-dock-inset, 8px))',
   height: 36,
   margin: '0 auto',
@@ -1066,11 +1067,9 @@ export function VerifierActivityChip({ session, rpc }: { session?: { sessionId?:
   if (rendered === null) return null
   const dotState: StateDotState = rendered.tone === 'busy' ? 'ongoing' : rendered.tone === 'ok' ? 'done' : 'error'
   return (
-    <div style={activityDock}>
-      <div style={activityBar} role="status" aria-live="polite">
-        <StateDot state={dotState} size={8} />
-        <span style={activityTextStyle}>{rendered.text}</span>
-      </div>
+    <div style={activityCard} role="status" aria-live="polite">
+      <StateDot state={dotState} size={8} />
+      <span style={activityTextStyle}>{rendered.text}</span>
     </div>
   )
 }

package/src/config.ts

@@ -129,6 +129,14 @@ export interface Config {
   cacheMaxEntries?: number
   estimatedInputUsdPerMillion?: number
   estimatedOutputUsdPerMillion?: number
+  /** USD per million prompt tokens served from cache; 0 falls back to the input rate. */
+  estimatedCachedInputUsdPerMillion?: number
+  /** Price a judge route from the installed pi-ai catalog when the operator typed no rate. */
+  autoPriceFromCatalog?: boolean
+  /** Consult the models.dev snapshot when the installed catalog has no price for the route. */
+  autoPriceOnline?: boolean
+  /** Provider id whose list price to follow for a route neither price table knows. */
+  priceProviderOverride?: string
   extraJudges?: JudgeConfig[]
 }
 
@@ -176,6 +184,10 @@ export interface ResolvedConfig {
   cacheMaxEntries: number
   estimatedInputUsdPerMillion: number
   estimatedOutputUsdPerMillion: number
+  estimatedCachedInputUsdPerMillion: number
+  autoPriceFromCatalog: boolean
+  autoPriceOnline: boolean
+  priceProviderOverride: string
   judges: ResolvedJudge[]
 }
 
@@ -232,6 +244,10 @@ export const Config: z<Config> = z.object({
   cacheMaxEntries: z.number().step(1).min(1).default(10000),
   estimatedInputUsdPerMillion: z.number().min(0).default(0),
   estimatedOutputUsdPerMillion: z.number().min(0).default(0),
+  estimatedCachedInputUsdPerMillion: z.number().min(0).default(0),
+  autoPriceFromCatalog: z.boolean().default(true),
+  autoPriceOnline: z.boolean().default(true),
+  priceProviderOverride: z.string().default(''),
   extraJudges: z.array(z.object({
     provider: z.string(),
     model: z.string(),
@@ -326,7 +342,11 @@ export function resolveConfig(config: Config = {}): ResolvedConfig {
   if (cacheDir.split(/[\\/]+/u).includes('..')) throw new Error('llm-verifier: cacheDir must stay inside the topic directory')
   const estimatedInputUsdPerMillion = config.estimatedInputUsdPerMillion ?? 0
   const estimatedOutputUsdPerMillion = config.estimatedOutputUsdPerMillion ?? 0
-  if (![estimatedInputUsdPerMillion, estimatedOutputUsdPerMillion].every(value => Number.isFinite(value) && value >= 0)) throw new Error('llm-verifier: estimated token prices must be finite non-negative numbers')
+  const estimatedCachedInputUsdPerMillion = config.estimatedCachedInputUsdPerMillion ?? 0
+  if (![estimatedInputUsdPerMillion, estimatedOutputUsdPerMillion, estimatedCachedInputUsdPerMillion].every(value => Number.isFinite(value) && value >= 0)) throw new Error('llm-verifier: estimated token prices must be finite non-negative numbers')
+  // A reseller route has no price in either table; the override names the provider whose list
+  // price the operator chose to follow. Empty (the default) means "never guess across providers".
+  const priceProviderOverride = (config.priceProviderOverride ?? '').trim()
   const criteriaPreset = config.criteriaPreset ?? 'coding'
   if (criteriaPreset !== 'custom' && !CRITERIA_PRESET_IDS.includes(criteriaPreset as CriteriaPresetId)) throw new Error('llm-verifier: criteriaPreset must be one of ' + [...CRITERIA_PRESET_IDS, 'custom'].join(', '))
   // A half-configured custom rubric is NOT a config error: CriteriaResolver falls back to the
@@ -420,6 +440,10 @@ export function resolveConfig(config: Config = {}): ResolvedConfig {
     cacheDir,
     estimatedInputUsdPerMillion,
     estimatedOutputUsdPerMillion,
+    estimatedCachedInputUsdPerMillion,
+    autoPriceFromCatalog: config.autoPriceFromCatalog ?? true,
+    autoPriceOnline: config.autoPriceOnline ?? true,
+    priceProviderOverride,
     ...values,
     temperature,
     judges,

package/src/engine.ts

@@ -1,6 +1,7 @@
 import { addUsage, attachUsage, callVerifier, emptyUsage, partialUsage, predictScoringChannel, requestAttempts, type ScoringMode, type UsageStats, type VerifierClientConfig, type VerifierImage } from './caller.ts'
 import { ScoreCache, SingleFlight, stableHash, type CachedPairScore } from './cache.ts'
 import type { DecisionTrace } from './decisions.ts'
+import { costUsd } from './pricing.ts'
 import {
   DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, PROPOSAL_CRITERIA, accumulatePairs, buildPairwisePrompt, buildProgressPrompt,
   dedupeCriterionId, diagnosticKey, extractProgressScore, extractScore, parseDiagnostics, pivotRoundPairs, rankScores,
@@ -314,13 +315,15 @@ export class VerifierEngine {
   readonly cache: ScoreCache | undefined
   readonly inputPrice: number
   readonly outputPrice: number
+  /** Cache-read rate; an omitted one falls back to the input rate. */
+  readonly cachedInputPrice: number
   private readonly flights: SingleFlight<{ value: CachedPairScore; hit: boolean }>
 
   constructor(
     client: VerifierClientConfig | readonly VerifierClientConfig[],
     maxConcurrency = 8,
     cache?: ScoreCache,
-    prices: { input: number; output: number } = { input: 0, output: 0 },
+    prices: { input: number; output: number; cachedInput?: number } = { input: 0, output: 0 },
     flights: SingleFlight<{ value: CachedPairScore; hit: boolean }> = new SingleFlight(),
   ) {
     const list = Array.isArray(client) ? client : [client]
@@ -331,11 +334,14 @@ export class VerifierEngine {
     this.cache = cache
     this.inputPrice = prices.input
     this.outputPrice = prices.output
+    // Backward compatible default: a caller that only knows two rates keeps the old estimate
+    // (cache reads at the input rate) instead of suddenly pricing them at zero.
+    this.cachedInputPrice = prices.cachedInput ?? prices.input
     this.flights = flights
   }
 
   private finishStats(stats: RunStats): RunStats {
-    stats.estimatedCostUsd = ((stats.inputTokens + stats.cachedInputTokens) * this.inputPrice + stats.outputTokens * this.outputPrice) / 1_000_000
+    stats.estimatedCostUsd = costUsd(stats, { input: this.inputPrice, output: this.outputPrice, cachedInput: this.cachedInputPrice })
     return stats
   }
 

package/src/index.ts

@@ -23,6 +23,7 @@ import { inspectTeamTasks, buildTeamTaskVerificationPrompt } from './team-gate.t
 import { StatisticsStore, emptyRunStats, errorDetails, mergeStatisticsOverviews, parseStatisticsQuery, resolveStatisticsFile, summarizeVerdict, type RouteObservation, type StatisticsOverview, type VerdictSummary, type VerifierToolName } from './statistics.ts'
 import { resolveTopicDataDir, type SessionArtifactLocator } from './topic-storage.ts'
 import { DecisionStore, boundDecisionCalls, resolveDecisionsFile, type DecisionCall, type DecisionRecord, type DecisionTrace } from './decisions.ts'
+import { PriceResolver, costUsd } from './pricing.ts'
 
 export const name = 'llm-verifier'
 export const inject = ['tools', 'agents', 'attachments', 'llm', 'connection', 'sessionPersistence']
@@ -35,6 +36,7 @@ export * from './topic-storage.ts'
 export * from './decisions.ts'
 export * from './auto.ts'
 export * from './router.ts'
+export * from './pricing.ts'
 export * from './plan-gate.ts'
 export * from './team-gate.ts'
 export { callVerifier, RequestLimiter, type VerifierClientConfig, type VerifierImage, type UsageStats, type VerifierCompletion } from './caller.ts'
@@ -203,6 +205,32 @@ export function apply(ctx: Context, config: Config = {}): void {
   // verdict, never the model history (see `verifier-activity.ts` for why it is not a session event).
   const activities = new VerifierActivities()
   const autoRouter = new AutoVerifierRouter(createActivityObserver(activities))
+  // Automatic judge pricing: typed rates win, otherwise the installed pi-ai catalog and (when
+  // enabled) the models.dev snapshot. One resolver per plugin instance keeps both tables cached.
+  const priceResolver = new PriceResolver()
+  /**
+   * Rates in effect for one route.
+   *
+   * The operator's typed rates always win. Otherwise the installed catalog prices the route
+   * offline, and models.dev is consulted only when that misses. Nothing is ever inferred from a
+   * model id alone: the same id sells for 0.10/0.40 at one reseller and 0.65/1.45 at another, so
+   * a cross-provider guess would be a fabricated number in a cost column. `priceProviderOverride`
+   * is how an operator points a reseller route at the list price they chose to follow.
+   * @param provider - route's provider id.
+   * @param model - route's model id.
+   * @param selected - configuration in effect.
+   * @returns The rates plus the source that answered, never throwing.
+   */
+  const pricesFor = (provider: string, model: string, selected: ReturnType<typeof current>) => priceResolver.resolve(provider, model, {
+    manual: {
+      input: selected.estimatedInputUsdPerMillion,
+      output: selected.estimatedOutputUsdPerMillion,
+      cachedInput: selected.estimatedCachedInputUsdPerMillion,
+    },
+    fromCatalog: selected.autoPriceFromCatalog,
+    online: selected.autoPriceOnline,
+    ...(selected.priceProviderOverride ? { overrideProvider: selected.priceProviderOverride } : {}),
+  })
   const topics = new Map<string, { dataDir: string; cache: ScoreCache; capabilities: TopLogprobCapabilityCache; flights: SingleFlight<{ value: CachedPairScore; hit: boolean }>; statistics: StatisticsStore; decisions: DecisionStore; process: ProcessCycleStore }>()
   const topic = (header: SessionHeader) => {
     const selected = current()
@@ -302,7 +330,10 @@ export function apply(ctx: Context, config: Config = {}): void {
       await ctx.llm.resolveCallConfig({ provider: judge.provider, model: judge.model, ...(judge.reasoningEffort ? { reasoningEffort: judge.reasoningEffort as never } : {}), maxTokens: judge.maxTokens })
       clients.push({ ctx, llm: ctx.llm, attachments: services.attachments, topLogprobCapabilities: topicEntry.capabilities, provider: judge.provider, model: judge.model, temperature: selected.temperature, label: judge.label, ...(judge.reasoningEffort ? { reasoningEffort: judge.reasoningEffort } : {}), maxTokens: judge.maxTokens, timeoutMs: selected.timeoutMs, maxRetries: selected.maxRetries, retryBaseDelayMs: selected.retryBaseDelayMs, limiter })
     }
-    return { verifier: new VerifierEngine(clients, selected.maxConcurrency, topicEntry.cache, { input: selected.estimatedInputUsdPerMillion, output: selected.estimatedOutputUsdPerMillion }, topicEntry.flights), selected }
+    // One rate table for the whole invocation, taken from the primary judge: the engine reports
+    // one cost line per call, exactly as it did with the operator's single manual table.
+    const prices = await pricesFor(selected.provider, selected.model, selected)
+    return { verifier: new VerifierEngine(clients, selected.maxConcurrency, topicEntry.cache, { input: prices.input, output: prices.output, cachedInput: prices.cachedInput }, topicEntry.flights), selected, prices }
   }
   const engine = async (agent: Agent) => engineForHeader(agent.session.header)
   const images = (values: readonly string[] | undefined, signal: AbortSignal) => loadVerifierImages(values, signal)
@@ -474,6 +505,9 @@ export function apply(ctx: Context, config: Config = {}): void {
     const call = agent.session.requestHeader()?.config
     if (call === undefined) throw new Error('llm-verifier: this session has no logged request header yet, so best-of-n cannot tell which model should write the drafts — generate candidates with parallel subagents and rank them with verifier_select instead')
     const target = { provider: call.provider, model: call.model, ...(call.reasoningEffort === undefined ? {} : { reasoningEffort: String(call.reasoningEffort) }) }
+    // The drafts come from the session model, so they are priced with THAT route's rates rather
+    // than with the judge's, which is what the single manual table could only approximate.
+    const generationPrices = await pricesFor(target.provider, target.model, selected)
     // The task and the optional reference context share ONE explicit budget, each with its own item
     // cap, so a huge context cannot push the combined request past the documented ceiling.
     const contextRaw = typeof contextInput === 'string' ? contextInput : undefined
@@ -495,7 +529,7 @@ export function apply(ctx: Context, config: Config = {}): void {
     const generation = emptyRunStats()
     let unknownDrafts = 0
     const finishGeneration = (): RunStats => {
-      generation.estimatedCostUsd = ((generation.inputTokens + generation.cachedInputTokens) * selected.estimatedInputUsdPerMillion + generation.outputTokens * selected.estimatedOutputUsdPerMillion) / 1_000_000
+      generation.estimatedCostUsd = costUsd(generation, generationPrices)
       return generation
     }
     const failWithUsage = (error: Error): never => {
@@ -623,10 +657,10 @@ export function apply(ctx: Context, config: Config = {}): void {
     return { result, selected }
   })
   const classifyRoute = async (agent: Agent, prompt: string, signal: AbortSignal, phase: string, observation?: RouteObservation) => record('verifier_route_classify', agent, async (trace) => {
-    const { verifier, selected } = await engine(agent)
+    const { verifier, selected, prices } = await engine(agent)
     const completion = await callVerifierText(verifier.client, prompt, signal)
     trace?.({ label: 'route classify', channel: completion.scoringMode, prompt, output: completion.text })
-    const stats: RunStats = { ...completion.usage, cacheHits: 0, cacheMisses: 0, estimatedCostUsd: ((completion.usage.inputTokens + completion.usage.cachedInputTokens) * selected.estimatedInputUsdPerMillion + completion.usage.outputTokens * selected.estimatedOutputUsdPerMillion) / 1_000_000, topLogprobScores: 0, explicitTagScores: 1 }
+    const stats: RunStats = { ...completion.usage, cacheHits: 0, cacheMisses: 0, estimatedCostUsd: costUsd(completion.usage, prices), topLogprobScores: 0, explicitTagScores: 1 }
     return { result: { text: completion.text, stats }, selected }
   }, phase, observation)
   const extractTask = async (agent: Agent, fromSeq: number, toSeq: number, maxChars: number, signal: AbortSignal) => extractSession(agent, async (ref: ImageAttachmentRef) => { const stored = await services.attachments.readImage(ref, signal); return { data: stored.data, mediaType: stored.ref.mediaType } }, { fromSeq, toSeq, includeAssistantText: true, maxChars })
@@ -843,7 +877,7 @@ export function apply(ctx: Context, config: Config = {}): void {
       // the verifier table (the same estimate best-of-n documents). Tokens are reported too.
       const stats: RunStats = {
         ...report.usage,
-        estimatedCostUsd: ((report.usage.inputTokens + report.usage.cachedInputTokens) * selected.estimatedInputUsdPerMillion + report.usage.outputTokens * selected.estimatedOutputUsdPerMillion) / 1_000_000,
+        estimatedCostUsd: costUsd(report.usage, await pricesFor(selected.provider, selected.model, selected)),
       }
       // The row is the SAME shape for both cycle sizes; only the tool name and the summarizer differ,
       // so a tournament row still reports the process phase, the route observation and its usage.
@@ -1013,6 +1047,10 @@ export function apply(ctx: Context, config: Config = {}): void {
       for (const client of verifier.clients) {
         const label = client.label ?? client.provider + '/' + client.model
         const startedAt = Date.now()
+        // The diagnostic answers "which rate is my judge being priced at, and why", which is the
+        // only place a silently auto-derived (or still unpriced) route is visible.
+        const prices = await pricesFor(client.provider, client.model, current())
+        const priceView = { input: prices.input, output: prices.output, cachedInput: prices.cachedInput, source: prices.source }
         // Forget the cached channel verdict for this judge before probing. A mark written up to 24h
         // ago — possibly before the provider was (re)configured, and certainly before a host
         // restart — would make the probe replay a stale answer instead of checking, which is the one
@@ -1028,13 +1066,14 @@ export function apply(ctx: Context, config: Config = {}): void {
             ok: true,
             channelProbed: true,
             channel: completion.scoringMode,
+            prices: priceView,
             scoreA: extractScore(completion, '<score_A>'),
             scoreB: extractScore(completion, '<score_B>'),
             latencyMs: Date.now() - startedAt,
             ...completion.usage,
           })
         } catch (error) {
-          judges.push({ label, provider: client.provider, model: client.model, ok: false, latencyMs: Date.now() - startedAt, error: error instanceof Error ? error.message : String(error) })
+          judges.push({ label, provider: client.provider, model: client.model, ok: false, prices: priceView, latencyMs: Date.now() - startedAt, error: error instanceof Error ? error.message : String(error) })
         }
       }
       return rpcSuccess({

package/src/pricing.test.ts

@@ -0,0 +1,174 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  MODELS_DEV_URL,
+  PRICE_TTL_MS,
+  PriceResolver,
+  costUsd,
+  loadCatalogTable,
+  mergeProviderDocument,
+  parseModelsDevDocument,
+  priceKey,
+  resolveCatalogDataDir,
+  type PriceTable,
+} from './pricing.ts'
+
+const manual = { input: 0, output: 0, cachedInput: 0 }
+
+const dirs: string[] = []
+afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }) })
+
+/** A catalog directory holding one provider document, in the installed pi-ai shape. */
+function catalogDir(provider: string, document: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), 'dsh-verifier-prices-'))
+  dirs.push(dir)
+  writeFileSync(join(dir, provider + '.json'), JSON.stringify(document))
+  return dir
+}
+
+const PI_AI_DOCUMENT = {
+  'openai-completions': {
+    'deepseek-v4-flash': {
+      id: 'deepseek-v4-flash',
+      cost: { input: 0.14, output: 0.28, cacheRead: 0.0028, cacheWrite: 0 },
+    },
+    'no-cost-model': { id: 'no-cost-model' },
+  },
+}
+
+describe('costUsd', () => {
+  it('bills cached prompt tokens at their own rate instead of the input rate', () => {
+    const prices = { input: 0.15, output: 0.6, cachedInput: 0.003, source: 'catalog' as const }
+    const usage = { inputTokens: 1_000_000, cachedInputTokens: 1_000_000, outputTokens: 0 }
+    expect(costUsd(usage, prices)).toBeCloseTo(0.15 + 0.003, 10)
+    // The old formula (inputTokens + cachedInputTokens) * input is 100x the cache-read price.
+    expect(costUsd(usage, prices)).toBeLessThan(0.15 * 2)
+  })
+
+  it('prices an unpriced route at zero rather than failing', () => {
+    expect(costUsd({ inputTokens: 10_000, cachedInputTokens: 90_000, outputTokens: 5_000 }, { input: 0, output: 0, cachedInput: 0, source: 'none' })).toBe(0)
+  })
+})
+
+describe('catalog parsing', () => {
+  it('reads the installed pi-ai shape, keyed by protocol block', () => {
+    const table: PriceTable = new Map()
+    expect(mergeProviderDocument('deepseek', PI_AI_DOCUMENT, table)).toBe(1)
+    expect(table.get(priceKey('deepseek', 'deepseek-v4-flash'))).toEqual({ input: 0.14, output: 0.28, cachedInput: 0.0028 })
+    expect(table.has(priceKey('deepseek', 'no-cost-model'))).toBe(false)
+  })
+
+  it('reads the models.dev shape, including snake_case cache fields', () => {
+    const table: PriceTable = new Map()
+    const added = parseModelsDevDocument({
+      openrouter: { id: 'openrouter', models: { 'deepseek/deepseek-v4.1-flash': { id: 'deepseek/deepseek-v4.1-flash', cost: { input: 0.15, output: 0.6, cache_read: 0.003 } } } },
+      'no-models': { id: 'no-models' },
+    }, table)
+    expect(added).toBe(1)
+    expect(table.get(priceKey('openrouter', 'deepseek/deepseek-v4.1-flash'))).toEqual({ input: 0.15, output: 0.6, cachedInput: 0.003 })
+  })
+
+  it('loads every provider document in a directory and survives a corrupt one', () => {
+    const dir = catalogDir('deepseek', PI_AI_DOCUMENT)
+    writeFileSync(join(dir, 'broken.json'), '{ not json')
+    const table = loadCatalogTable(dir)
+    expect(table.size).toBe(1)
+    expect(loadCatalogTable(join(dir, 'missing'))).toEqual(new Map())
+  })
+
+  it('finds the adapter catalog by walking the install tree, and reports none instead of guessing', () => {
+    const root = mkdtempSync(join(tmpdir(), 'dsh-verifier-pkg-'))
+    dirs.push(root)
+    const data = join(root, 'node_modules', '@earendil-works', 'pi-ai', 'dist', 'providers', 'data')
+    mkdirSync(data, { recursive: true })
+    // The plugin walks up from its own lib/ directory, which is how a profile install resolves.
+    expect(resolveCatalogDataDir(join(root, 'node_modules', 'dsh-llm-verifier', 'lib'), undefined)).toBe(data)
+    const empty = mkdtempSync(join(tmpdir(), 'dsh-verifier-pkg-'))
+    dirs.push(empty)
+    expect(resolveCatalogDataDir(empty, undefined)).toBeUndefined()
+  })
+})
+
+describe('PriceResolver', () => {
+  it('lets the operator typed rates win over every automatic source', async () => {
+    const resolver = new PriceResolver({ catalogDir: () => catalogDir('deepseek', PI_AI_DOCUMENT), fetch: vi.fn() as never })
+    const prices = await resolver.resolve('deepseek', 'deepseek-v4-flash', { manual: { input: 9, output: 9, cachedInput: 9 } })
+    expect(prices).toEqual({ input: 9, output: 9, cachedInput: 9, source: 'manual' })
+  })
+
+  it('falls back to the input rate for cache reads when the operator typed only two rates', async () => {
+    const resolver = new PriceResolver({})
+    const prices = await resolver.resolve('x', 'y', { manual: { input: 0.5, output: 1.5, cachedInput: 0 } })
+    expect(prices.cachedInput).toBe(0.5)
+    expect(prices.source).toBe('manual')
+  })
+
+  it('prices a catalog route with no configuration at all', async () => {
+    const resolver = new PriceResolver({ catalogDir: () => catalogDir('deepseek', PI_AI_DOCUMENT) })
+    const prices = await resolver.resolve('deepseek', 'deepseek-v4-flash', { manual })
+    expect(prices).toEqual({ input: 0.14, output: 0.28, cachedInput: 0.0028, source: 'catalog' })
+  })
+
+  it('consults the online snapshot only after the catalog misses, and only when enabled', async () => {
+    const fetcher = vi.fn(async () => new Response(JSON.stringify({
+      openrouter: { models: { 'deepseek/deepseek-v4.1-flash': { cost: { input: 0.15, output: 0.6, cache_read: 0.003 } } } },
+    })))
+    const resolver = new PriceResolver({ catalogDir: () => catalogDir('deepseek', PI_AI_DOCUMENT), fetch: fetcher as never })
+    const offline = await resolver.resolve('openrouter', 'deepseek/deepseek-v4.1-flash', { manual })
+    expect(offline.source).toBe('none')
+    expect(fetcher).not.toHaveBeenCalled()
+
+    const online = await resolver.resolve('openrouter', 'deepseek/deepseek-v4.1-flash', { manual, online: true })
+    expect(online).toEqual({ input: 0.15, output: 0.6, cachedInput: 0.003, source: 'online' })
+    expect(fetcher).toHaveBeenCalledTimes(1)
+    // A second route reuses the cached snapshot instead of re-fetching 4.6 MB.
+    await resolver.resolve('openrouter', 'deepseek/deepseek-v4.1-flash', { manual, online: true })
+    expect(fetcher).toHaveBeenCalledTimes(1)
+  })
+
+  it('prices a reseller route only through an explicit provider override, never by guessing', async () => {
+    const fetcher = vi.fn(async () => new Response(JSON.stringify({
+      openrouter: { models: { 'deepseek/deepseek-v4.1-flash': { cost: { input: 0.15, output: 0.6, cache_read: 0.003 } } } },
+      'nano-gpt': { models: { 'deepseek/deepseek-v4.1-flash': { cost: { input: 0.65, output: 1.45, cache_read: 0.13 } } } },
+    })))
+    const resolver = new PriceResolver({ catalogDir: () => undefined, fetch: fetcher as never })
+    const unguarded = await resolver.resolve('command-code', 'deepseek/deepseek-v4.1-flash', { manual, online: true })
+    expect(unguarded.source).toBe('none')
+
+    const guarded = await resolver.resolve('command-code', 'deepseek/deepseek-v4.1-flash', { manual, online: true, overrideProvider: 'openrouter' })
+    expect(guarded).toEqual({ input: 0.15, output: 0.6, cachedInput: 0.003, source: 'online' })
+    // The override is a lookup key, not a fallback chain: the other vendor's price is never used.
+    expect(guarded.input).not.toBe(0.65)
+  })
+
+  it('degrades to unpriced when the snapshot cannot be read', async () => {
+    const resolver = new PriceResolver({ catalogDir: () => undefined, fetch: (async () => { throw new Error('offline') }) as never })
+    expect(await resolver.resolve('p', 'm', { manual, online: true })).toEqual({ input: 0, output: 0, cachedInput: 0, source: 'none' })
+    const invalid = new PriceResolver({ catalogDir: () => undefined, fetch: (async () => new Response('<html>nope</html>')) as never })
+    expect(await invalid.resolve('p', 'm', { manual, online: true })).toEqual({ input: 0, output: 0, cachedInput: 0, source: 'none' })
+  })
+
+  it('single-flights concurrent online lookups and expires both tables on the TTL', async () => {
+    let clock = 1_000
+    const fetcher = vi.fn(async () => {
+      await new Promise(resolve => setTimeout(resolve, 5))
+      return new Response(JSON.stringify({ p: { models: { m: { cost: { input: 1, output: 2, cache_read: 3 } } } } }))
+    })
+    const resolver = new PriceResolver({ catalogDir: () => undefined, fetch: fetcher as never, now: () => clock })
+    const [a, b] = await Promise.all([resolver.onlineTable(), resolver.onlineTable()])
+    expect(fetcher).toHaveBeenCalledTimes(1)
+    expect(a.get(priceKey('p', 'm'))).toEqual(b.get(priceKey('p', 'm')))
+
+    clock += PRICE_TTL_MS + 1
+    await resolver.resolve('p', 'm', { manual, online: true })
+    expect(fetcher).toHaveBeenCalledTimes(2)
+  })
+
+  it('uses the documented public snapshot URL', async () => {
+    const fetcher = vi.fn(async () => new Response('{}'))
+    await new PriceResolver({ catalogDir: () => undefined, fetch: fetcher as never }).onlineTable()
+    expect(fetcher.mock.calls[0]?.[0]).toBe(MODELS_DEV_URL)
+  })
+})