@sligqoer/dsh-usage-stats 0.2.0 → 0.2.2

package/lib/model-capabilities.js

@@ -1,41 +0,0 @@
-/** Seeded, locally graded tasks. Scores describe these tasks only, never model identity. */
-import { binomialTail } from './model-fingerprints.js'
-export function capabilityTasks(seed) {
-  let state = seed >>> 0
-  const rand = max => { state = (Math.imul(state, 1664525) + 1013904223) >>> 0; return state % max }
-  const tasks = []
-  const add = (domain, prompt, answer) => tasks.push({ id: `${domain}-${tasks.length}`, domain,
-    prompt: prompt + '\nReturn only JSON with exactly one key "answer". Do not use tools.',
-    check(text) { const value = JSON.parse(text.trim()); return Object.keys(value).length === 1 && JSON.stringify(value.answer) === JSON.stringify(answer) } })
-  for (let i = 0; i < 4; i++) {
-    const a = rand(17) + 2, b = rand(23) + 1, turns = rand(16) + 30
-    let x = rand(300), initial = x, sum = 0
-    for (let j = 0; j < turns; j++) { x = (x * a + b + j) % 997; sum += j % 3 === 0 ? -x : x }
-    add('code', `Evaluate this JavaScript without executing it. What is sum?\nlet x=${initial}, sum=0; for(let j=0;j<${turns};j++){x=(x*${a}+${b}+j)%997;sum+=j%3===0?-x:x;}`, sum)
-    const edges = [], costs = Array(11).fill(Infinity); costs[0] = 0
-    for (let u = 0; u < 10; u++) for (let v = u + 1; v <= Math.min(10, u + 4); v++) edges.push([u, v, rand(31) + 1])
-    for (let u = 0; u < 10; u++) for (const [from, to, weight] of edges) if (from === u) costs[to] = Math.min(costs[to], costs[from] + weight)
-    add('reasoning', `Find the minimum total weight of a directed path from node 0 to node 10. Edges [from,to,weight]: ${JSON.stringify(edges)}`, costs[10])
-    const entries = Array.from({ length: 160 }, (_, n) => ({ key: `record_${n}`, priority: rand(1000), value: rand(100_000) }))
-    const chosen = rand(150) + 5, key = entries[chosen].key
-    add('context', `Read the following records. For key ${key}, return the value in the LAST occurrence. Ignore priorities.\n${JSON.stringify(entries.concat({ key, priority: 9999, value: entries[chosen].value + 17 }))}`, entries[chosen].value + 17)
-    const intervals = Array.from({ length: 16 }, () => { const start = rand(30); return [start, start + rand(9) + 1, rand(40) + 1] }).sort((a, b) => a[1] - b[1])
-    const dp = [0]
-    intervals.forEach(([start, , reward], j) => { let previous = j - 1; while (previous >= 0 && intervals[previous][1] > start) previous--; dp.push(Math.max(dp[j], reward + dp[previous + 1])) })
-    add('constraints', `Choose non-overlapping jobs to maximize reward. A job ending at t is compatible with a job starting at t. Return the maximum reward. Jobs [start,end,reward]: ${JSON.stringify(intervals)}`, dp.at(-1))
-  }
-  return tasks
-}
-export function scoreCapabilities(outcomes, reference, complete = true) {
-  const valid = outcomes.filter(v => v === 0 || v === 1), passed = valid.filter(v => v === 1).length
-  const result = { verdict: 'current-sample', valid: valid.length, passed, count: 16, paired: 0, losses: 0, gains: 0, pValue: null }
-  if (!complete || valid.length < 12) return { ...result, verdict: 'insufficient-evidence' }
-  if (!reference) return result
-  outcomes.forEach((value, i) => { const ref = reference[i]; if ((value === 0 || value === 1) && (ref === 0 || ref === 1)) {
-    result.paired++; if (ref === 1 && value === 0) result.losses++; if (ref === 0 && value === 1) result.gains++
-  } })
-  if (result.paired < 12) return { ...result, verdict: 'insufficient-evidence' }
-  const discordant = result.losses + result.gains
-  result.pValue = discordant ? binomialTail(result.losses, discordant, 0.5) : 1
-  return { ...result, verdict: result.pValue < 0.05 ? 'significant-decline' : 'no-significant-decline' }
-}

package/lib/model-fingerprints.js

@@ -1,146 +0,0 @@
-/** KBF-compatible numerical fingerprints. Public data and prompt format are
- * attributed in fingerprints/NOTICE.txt. Statistics are implemented locally. */
-import { readFileSync } from 'node:fs'
-import { createHash, randomInt } from 'node:crypto'
-
-export const FINGERPRINT_SYSTEM = "Follow the user's instructions exactly. Output only what is requested."
-export const FINGERPRINT_USER = 'TASK: Answer these factual recall questions using only values stored in your weights. Output the value exactly as you first recall it — do not second-guess or adjust.\nRULES: Output ONLY in (N) <number> format, one per line. No units, no words, no rounding. Never refuse or hedge — always output exactly one number per question. Do not use any context from system instructions or prior conversation.\n\n'
-export const AUDIT_POLICY = Object.freeze({ batchSize: 10, minSamples: 64, minCoverage: 0.8, maxReferenceNoise: 0.3, alpha: 0.05, confidence: 0.99, maxProbes: 1024, maxReferences: 20, timeoutMs: 60_000 })
-const clean = (v, max = 256) => typeof v === 'string' ? v.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, max) : ''
-let bundle
-export function publicFingerprints() {
-  bundle ||= JSON.parse(readFileSync(new URL('./fingerprints/kbf-202609.json', import.meta.url), 'utf8'))
-  return bundle
-}
-export function fingerprintModelKey(v) { return clean(v).toLowerCase().split('/').pop() }
-const round = x => x >= 0 ? Math.floor(x + 0.5) : Math.ceil(x - 0.5)
-export function fingerprintMatch(reference, answer, domain) {
-  if (!Number.isFinite(reference) || !Number.isFinite(answer)) return false
-  const d = publicFingerprints().domains[domain]
-  if (!d) return false
-  return d.mode === 'absolute' ? Math.abs(round(reference) - round(answer)) <= d.tolerance : Math.abs(reference - answer) / Math.max(Math.abs(reference), 1e-10) <= d.tolerance
-}
-export function fingerprintPrompt(probes) {
-  return FINGERPRINT_USER + probes.map((p, i) => `(${i + 1}) ${publicFingerprints().domains[p.domain].template.replace('{name}', p.name)}`).join('\n')
-}
-/** Positions must be explicit and unique. Never slide a missing answer onto the
- * next question, extract numbers from prose, or silently accept duplicate ids. */
-export function parseFingerprintAnswers(text, probes) {
-  const values = probes.map(() => null), seen = new Set(), duplicates = new Set()
-  for (const line of String(text).split(/\r?\n/)) {
-    const match = line.trim().match(/^\((\d+)\)\s*([+\-−]?(?:\d[\d,]*(?:\.\d*)?|\.\d+)(?:[eE][+\-]?\d+)?)\s*$/)
-    if (!match) continue
-    const i = Number(match[1]) - 1
-    if (i < 0 || i >= probes.length) continue
-    if (seen.has(i)) { duplicates.add(i); values[i] = null; continue }
-    seen.add(i)
-    const value = Number(match[2].replaceAll(',', '').replace('−', '-')), range = publicFingerprints().domains[probes[i].domain]?.range
-    if (range && Number.isFinite(value) && value >= range[0] && value <= range[1] && !duplicates.has(i)) values[i] = value
-  }
-  return values
-}
-const logs = [0]
-function logFactorial(n) { while (logs.length <= n) logs.push(logs.at(-1) + Math.log(logs.length)); return logs[n] }
-function binomialSum(lo, hi, n, p) {
-  if (lo > hi) return 0
-  if (p === 0) return lo === 0 ? 1 : 0
-  if (p === 1) return hi === n ? 1 : 0
-  const terms = [], base = logFactorial(n)
-  for (let k = lo; k <= hi; k++) terms.push(base - logFactorial(k) - logFactorial(n - k) + k * Math.log(p) + (n - k) * Math.log1p(-p))
-  const largest = Math.max(...terms)
-  return Math.min(1, Math.exp(largest) * terms.reduce((sum, x) => sum + Math.exp(x - largest), 0))
-}
-export function binomialTail(k, n, p) {
-  if (!Number.isInteger(k) || !Number.isInteger(n) || k < 0 || k > n || n < 1 || !Number.isFinite(p) || p < 0 || p > 1) throw new Error('Invalid binomial counts')
-  return binomialSum(k, n, n, p)
-}
-export function clopperPearsonUpper(k, n) {
-  if (!Number.isInteger(k) || !Number.isInteger(n) || n < 1 || k < 0 || k > n) throw new Error('Invalid calibration counts')
-  if (k === n) return 1
-  let lo = 0, hi = 1
-  for (let i = 0; i < 60; i++) { const p = (lo + hi) / 2; if (binomialSum(0, k, n, p) > 0.01) lo = p; else hi = p }
-  return (lo + hi) / 2
-}
-export function scoreFingerprint(reference, outcomes, complete = true) {
-  const referenceValues = reference.probes.map(p => p.calibration), calibration = referenceValues.filter(v => v === 0 || v === 1)
-  const valid = outcomes.filter(v => v === 0 || v === 1), mismatches = valid.filter(v => v === 0).length
-  const self = reference.calibration || { total: calibration.length, mismatches: calibration.filter(v => v === 0).length }
-  const count = reference.probes.length, coverage = count ? valid.length / count : 0, selfCoverage = count ? self.total / count : 0
-  const result = { verdict: 'insufficient-evidence', reason: 'coverage', count, valid: valid.length, mismatches, coverage,
-    selfTotal: self.total, selfMismatches: self.mismatches, selfCoverage, alpha: AUDIT_POLICY.alpha, confidence: AUDIT_POLICY.confidence, p0: null, pValue: null }
-  if (!complete) return { ...result, reason: 'unfinished' }
-  if (count < AUDIT_POLICY.minSamples || valid.length < AUDIT_POLICY.minSamples || self.total < AUDIT_POLICY.minSamples) return { ...result, reason: 'sample-size' }
-  if (coverage < AUDIT_POLICY.minCoverage || selfCoverage < AUDIT_POLICY.minCoverage) return result
-  const p0 = clopperPearsonUpper(self.mismatches, self.total), pValue = binomialTail(mismatches, valid.length, p0)
-  return { ...result, verdict: pValue < AUDIT_POLICY.alpha ? 'significant-difference' : 'no-significant-difference', reason: 'statistical-test', p0, pValue }
-}
-export function normalizeFingerprint(value, origin = 'imported') {
-  if (!value || typeof value !== 'object') throw new Error('基线内容不是有效对象。')
-  const model = clean(value.model || value.reference_model), input = value.probes
-  if (!model || !Array.isArray(input) || input.length < AUDIT_POLICY.minSamples || input.length > AUDIT_POLICY.maxProbes) throw new Error('基线需要模型名称和 64–1,024 个探针。')
-  const self = value.target_results?.[model.split('/').pop()], vector = self?.match_vector
-  const domains = publicFingerprints().domains, seen = new Set()
-  const probes = input.map((p, i) => {
-    const domain = clean(p?.domain, 64), name = clean(p?.name, 512), answer = p?.cloze_consensus ?? p?.value, key = domain + '\0' + name
-    if (!domains[domain] || !name || !Number.isFinite(answer) || seen.has(key)) throw new Error('基线含未知领域、重复探针或无效参考答案。')
-    seen.add(key)
-    const range = domains[domain].range
-    if (answer < range[0] || answer > range[1]) throw new Error('参考答案超出探针允许范围。')
-    const calibration = p.calibration ?? vector?.[i]
-    return { domain, name, value: answer, calibration: calibration === 0 || calibration === 1 ? calibration : null }
-  })
-  const total = value.calibration?.total ?? self?.total, mismatches = value.calibration?.mismatches ?? self?.hamming
-  let calibration
-  if (!probes.some(p => p.calibration !== null)) {
-    if (!Number.isInteger(total) || total < AUDIT_POLICY.minSamples || total > probes.length || !Number.isInteger(mismatches) || mismatches < 0 || mismatches > total) throw new Error('基线缺少独立自测校准计数。')
-    calibration = { total, mismatches }
-  }
-  const config = value.config || self?.test_config || {}
-  const temperature = config.temperature ?? config.temp ?? 0
-  if (temperature !== 0) throw new Error('基线自测温度必须为 0。')
-  const system = clean(config.system || config.sys || FINGERPRINT_SYSTEM, 512)
-  if (system !== FINGERPRINT_SYSTEM) throw new Error('基线使用了不同的系统提示词，请重新校准。')
-  const reasoningEffort = clean(config.reasoningEffort || 'off', 64)
-  const selection = value.selection && { provider: clean(value.selection.provider), model: clean(value.selection.model), ...(reasoningEffort !== 'off' ? { reasoningEffort } : {}) }
-  const payload = { version: 2, model, provider: clean(value.provider || value.provider_map?.[model] || selection?.provider || '未标明'),
-    origin, date: clean(value.date || value.timestamp || new Date().toISOString(), 64), config: { system, temperature: 0, reasoningEffort }, probes,
-    ...(calibration ? { calibration } : {}), ...(selection?.provider && selection.model ? { selection } : {}) }
-  // Retain public provenance, never imported endpoint URLs, headers or secrets.
-  if (origin === 'public') { payload.source = value.source; payload.sha256 = value.sha256 }
-  if (value.capabilities?.version === 1 && Number.isInteger(value.capabilities.seed) && Array.isArray(value.capabilities.outcomes) && value.capabilities.outcomes.length === 16) {
-    payload.capabilities = { version: 1, seed: value.capabilities.seed >>> 0, effort: clean(value.capabilities.effort, 64),
-      outcomes: value.capabilities.outcomes.map(v => v === 0 || v === 1 ? v : null) }
-  }
-  payload.id = origin === 'public' ? value.id : 'local/' + createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 24)
-  return payload
-}
-export function fingerprintSummary(ref) {
-  const scored = scoreFingerprint(ref, [])
-  return { id: ref.id, model: ref.model, provider: ref.provider, origin: ref.origin, date: ref.date, source: ref.source,
-    count: ref.probes.length, selfTotal: scored.selfTotal, selfMismatches: scored.selfMismatches,
-    effort: ref.config.reasoningEffort, hasCapabilities: !!ref.capabilities, subsetAvailable: !ref.calibration }
-}
-export function subsetFingerprint(ref, count) {
-  if (count >= ref.probes.length || ref.calibration) return ref
-  const indices = ref.probes.map((_, i) => i)
-  for (let i = indices.length - 1; i > 0; i--) { const j = randomInt(i + 1); [indices[i], indices[j]] = [indices[j], indices[i]] }
-  const selected = indices.slice(0, count).sort((a, b) => a - b)
-  return { ...ref, probes: selected.map(i => ref.probes[i]) }
-}
-export function calibrationPool(count) {
-  const groups = new Map(), seen = new Set()
-  for (const ref of publicFingerprints().references) for (const p of ref.probes) {
-    const key = p.domain + '\0' + p.name
-    if (seen.has(key)) continue
-    seen.add(key)
-    if (!groups.has(p.domain)) groups.set(p.domain, [])
-    groups.get(p.domain).push({ domain: p.domain, name: p.name })
-  }
-  const pool = []
-  while (pool.length < count && groups.size) for (const [domain, entries] of groups) {
-    if (pool.length >= count) break
-    if (!entries.length) { groups.delete(domain); continue }
-    pool.push(entries.splice(randomInt(entries.length), 1)[0])
-  }
-  return pool
-}

package/lib/model-match.js

@@ -1,407 +0,0 @@
-/** Local, bounded evidence analysis. Response-declared names are observations,
- * never proof of a provider's real model identity. No conversation text is kept. */
-import { randomUUID, randomInt } from 'node:crypto'
-import { readFileSync } from 'node:fs'
-import { mkdir, writeFile, rename } from 'node:fs/promises'
-import { dirname } from 'node:path'
-import { publicFingerprints, normalizeFingerprint, fingerprintSummary, fingerprintModelKey, subsetFingerprint,
-  calibrationPool, fingerprintPrompt, parseFingerprintAnswers, fingerprintMatch, scoreFingerprint, FINGERPRINT_SYSTEM, AUDIT_POLICY } from './model-fingerprints.js'
-import { capabilityTasks, scoreCapabilities } from './model-capabilities.js'
-
-const LIMIT = 30
-const usageKeys = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']
-const safeText = (value, max = 256) => typeof value === 'string' ? value.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, max) : ''
-const nonnegative = value => Number.isFinite(value) && value >= 0 ? value : 0
-export function safeUsage(value) {
-  return Object.fromEntries(usageKeys.map(key => [key, nonnegative(value?.[key])]))
-}
-export function modelSelection(value) {
-  const provider = safeText(value?.provider), model = safeText(value?.model)
-  if (!provider || !model) return null
-  const reasoningEffort = safeText(value.reasoningEffort, 64)
-  return { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}) }
-}
-function record(value) {
-  const selection = modelSelection(value)
-  if (!selection) return null
-  const responseModel = safeText(value.responseModel)
-  const responseEffort = safeText(value.responseEffort, 64)
-  const stop = ['stop', 'max-tokens', 'tool-calls', 'error', 'aborted', 'unknown'].includes(value.stop) ? value.stop : 'unknown'
-  return { ...selection, time: nonnegative(value.time), requestHeader: value.requestHeader === true,
-    ...(responseModel ? { responseModel } : {}), ...(responseEffort ? { responseEffort } : {}),
-    stop, usage: safeUsage(value.usage) }
-}
-export function normalizeEvidence(value) {
-  if (!value || value.version !== 1) return null
-  return { version: 1, latestRequest: modelSelection(value.latestRequest),
-    records: (Array.isArray(value.records) ? value.records : []).slice(-LIMIT).map(record).filter(Boolean) }
-}
-
-export function captureModelEvidence(events, inheritedEventCount = 0) {
-  let latestRequest = null
-  const records = []
-  const inherited = Math.max(0, Math.floor(Number(inheritedEventCount) || 0))
-  for (const [index, event] of (events || []).entries()) {
-    if (event?.type === 'request/header') latestRequest = modelSelection(event.data?.header?.config) || latestRequest
-    if (event?.type !== 'assistant/message' || index < inherited) continue
-    const source = event.data?.message?.source
-    const selection = modelSelection(source)
-    if (!selection) continue
-    const paired = latestRequest?.provider === selection.provider && latestRequest?.model === selection.model
-    const response = source.replayState?.response
-    records.push(record({ ...(paired ? latestRequest : selection), time: event.time,
-      requestHeader: paired, responseModel: response?.responseModel,
-      responseEffort: response?.providerThinkingLevel,
-      stop: response?.stopReason === 'length' ? 'max-tokens' : response?.stopReason === 'toolUse' ? 'tool-calls' : response?.stopReason,
-      usage: event.data.usage }))
-  }
-  return { version: 1, latestRequest, records: records.slice(-LIMIT) }
-}
-
-/** Only obvious provider-prefix/date-snapshot variations are comparable. No
- * aliases used by usage charts are used to decide identity or compatibility. */
-function comparableModel(value) {
-  return safeText(value).toLowerCase().split('/').pop().replace(/[-_]\d{4}[-_]\d{2}[-_]\d{2}$/, '')
-}
-export function analyzeModelEvidence(value, requested) {
-  const evidence = normalizeEvidence(value)
-  const selection = modelSelection(requested) || evidence?.latestRequest || evidence?.records.at(-1) || null
-  const samples = (evidence?.records || []).filter(item => selection && item.provider === selection.provider && item.model === selection.model &&
-    (!selection.reasoningEffort || item.reasoningEffort === selection.reasoningEffort))
-  let exact = 0, compatible = 0, different = 0, missing = 0
-  for (const item of samples) {
-    if (!item.responseModel) missing++
-    else if (item.responseModel === item.model) exact++
-    else if (comparableModel(item.responseModel) === comparableModel(item.model)) compatible++
-    else different++
-  }
-  // Metadata describes declarations only. Identity remains untested even when
-  // every response repeats the requested name or every name differs.
-  return { selection: modelSelection(selection), verdict: 'insufficient-evidence', strength: 'weak',
-    declarationStatus: different ? 'name-difference' : exact + compatible ? 'names-consistent' : 'not-reported',
-    counts: { samples: samples.length, exact, compatible, different, missing },
-    // Newest first, deliberately excludes replay blocks, ids, headers and text.
-    records: samples.slice(-10).reverse(),
-    missingReasoningUsage: samples.filter(item => item.reasoningEffort && item.usage.reasoningTokens === 0).length }
-}
-
-export class ModelMatchError extends Error {}
-export const PROBE_PLAN = Object.freeze({ maxTokens: 800, capabilityMaxTokens: 1024, timeoutMs: AUDIT_POLICY.timeoutMs })
-function abortable(promise, signal) {
-  return new Promise((resolve, reject) => {
-    const abort = () => reject(new Error('aborted'))
-    if (signal.aborted) { abort(); return }
-    signal.addEventListener('abort', abort, { once: true })
-    Promise.resolve(promise).then(resolve, reject).finally(() => signal.removeEventListener('abort', abort))
-  })
-}
-
-const batches = values => Array.from({ length: Math.ceil(values.length / 10) }, (_, i) => values.slice(i * 10, i * 10 + 10))
-const sumTokens = usage => usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens
-/** Answer agreement, not the statistical test's p-value or identity probability. */
-export function modelTestScore(job) {
-  const identity = job?.identity
-  if (job?.status !== 'complete' || job.mode !== 'audit' || !['significant-difference', 'no-significant-difference'].includes(identity?.verdict)) return null
-  const { count, valid, mismatches } = identity
-  if (![count, valid, mismatches].every(Number.isInteger) || valid < AUDIT_POLICY.minSamples || valid > count || mismatches < 0 || mismatches > valid || valid / count < AUDIT_POLICY.minCoverage) return null
-  return { value: Math.round((valid - mismatches) * 1000 / valid) / 10, matched: valid - mismatches, valid, count, method: 'answer-agreement' }
-}
-export function summarizeModelTest(job) {
-  if (job.status === 'running') return { verdict: 'running', reason: 'running' }
-  if (job.mode === 'calibrate' && job.status === 'complete' && job.baselineId) return { verdict: 'reference-created', reason: 'reference-created' }
-  if (job.status === 'complete') {
-    if (job.identity?.verdict === 'significant-difference') return { verdict: 'suspected-mismatch', reason: 'behavior-difference' }
-    if (job.capability?.verdict === 'significant-decline') return { verdict: 'suspected-decline', reason: 'capability-decline' }
-    if (job.identity?.verdict === 'no-significant-difference') return { verdict: 'no-anomaly', reason: 'behavior-consistent' }
-    if (job.mode === 'capability' && job.capability?.verdict === 'no-significant-decline') return { verdict: 'no-decline', reason: 'capability-consistent' }
-    if (job.mode === 'capability' && job.capability?.verdict === 'current-sample') return { verdict: 'capability-complete', reason: 'no-capability-reference' }
-  }
-  const results = job.results || []
-  const invalid = Object.fromEntries(['incomplete', 'unparseable', 'unavailable', 'timeout', 'parameters-ignored'].map(code => [code, results.filter(r => r.outcome === code).length]))
-  const reason = job.status === 'cancelled' ? 'cancelled' : job.status === 'interrupted' ? 'interrupted' : job.status === 'budget-exhausted' ? 'budget' :
-    invalid['parameters-ignored'] ? 'parameters' : invalid.timeout ? 'timeout' : invalid.unavailable ? 'request-failed' : invalid.incomplete ? 'truncated' :
-      invalid.unparseable ? 'format' : job.identity?.reason === 'coverage' || job.identity?.reason === 'sample-size' ? 'coverage' : job.mode === 'calibrate' ? 'reference-failed' : 'unfinished'
-  return { verdict: 'inconclusive', reason, invalid }
-}
-const jobView = job => ({ id: job.id, sessionId: job.sessionId, selection: job.selection, testSelection: job.testSelection, capabilitySelection: job.capabilitySelection,
-  mode: job.mode, status: job.status, phase: job.phase, startedAt: job.startedAt, finishedAt: job.finishedAt, progress: job.results.length,
-  plan: job.plan, reference: job.reference && fingerprintSummary(job.reference), baselineId: job.baselineId || null,
-  results: job.results.map(({ time, selection, phase, outcome, stop, usage, usageReported, valid, mismatches, ttftMs, decodeMs }) => ({ time, selection, phase, outcome, stop, usage, usageReported, valid, mismatches, ttftMs, decodeMs })),
-  usage: safeUsage(job.usage), usageReported: job.results.some(r => r.usageReported),
-  usageIncomplete: job.status === 'running' || job.results.some(r => !r.usageReported),
-  identity: job.identity || null, capability: job.capability || null, message: job.message || '', conclusion: summarizeModelTest(job), score: modelTestScore(job), usageSaved: job.usageSaved === true,
-  channel: { ttftMs: job.results.some(r => r.ttftMs !== null) ? job.results.filter(r => r.ttftMs !== null).reduce((n, r) => n + r.ttftMs, 0) / job.results.filter(r => r.ttftMs !== null).length : null,
-    tps: job.results.some(r => r.decodeMs > 0 && r.usage.outputTokens > 0) ? job.results.filter(r => r.decodeMs > 0 && r.usage.outputTokens > 0).reduce((n, r) => n + r.usage.outputTokens, 0) * 1000 / job.results.filter(r => r.decodeMs > 0 && r.usage.outputTokens > 0).reduce((n, r) => n + r.decodeMs, 0) : null } })
-
-/** No inference happens in catalog, import, export or plan. A one-use quote
- * freezes reference, parameters and maximum workload before the manual start. */
-export function createModelMatchRunner(ctx, options = {}) {
-  const jobs = new Map(), quotes = new Map(), references = new Map()
-  let disposed = false, loaded = false, storageWarning = '', saveQueue = Promise.resolve()
-  async function checkpoint(job, patch = {}) {
-    if (!options.onUpdate) return
-    try { await options.onUpdate({ ...jobView({ ...job, ...patch }), usageSaved: true }); job.usageSaved = true }
-    catch { job.usageSaved = false; job.halt = true; job.message = '检测用量保存失败，已停止后续请求；请检查本地存储。' }
-  }
-  function load() {
-    if (loaded) return
-    loaded = true
-    for (const raw of publicFingerprints().references) { const ref = normalizeFingerprint(raw, 'public'); references.set(ref.id, ref) }
-    if (!options.path) return
-    try {
-      const data = JSON.parse(readFileSync(options.path, 'utf8'))
-      for (const raw of (data.references || []).slice(0, AUDIT_POLICY.maxReferences)) {
-        try { const ref = normalizeFingerprint(raw, raw.origin === 'calibrated' ? 'calibrated' : 'imported'); references.set(ref.id, ref) } catch { storageWarning = '部分本地基线无效，请重新导入或校准。' }
-      }
-    } catch (error) { if (error.code !== 'ENOENT') storageWarning = '本地基线文件无法读取，请检查文件后重新加载插件。' }
-  }
-  function save() {
-    if (!options.path) return Promise.resolve()
-    const document = JSON.stringify({ version: 2, references: [...references.values()].filter(r => r.origin !== 'public') })
-    const next = saveQueue.catch(() => {}).then(async () => {
-      await mkdir(dirname(options.path), { recursive: true })
-      const temporary = options.path + '.tmp'
-      await writeFile(temporary, document, { mode: 0o600 })
-      await rename(temporary, options.path)
-    })
-    saveQueue = next
-    return next
-  }
-  function getReference(id) { load(); const ref = references.get(id); if (!ref) throw new ModelMatchError('参考基线已不可用，请重新选择。'); return ref }
-  function ensureLocalCapacity() { if ([...references.values()].filter(r => r.origin !== 'public').length >= AUDIT_POLICY.maxReferences) throw new ModelMatchError('本地基线已达 20 份，请先移除旧基线。') }
-  async function resolveTestSelection(selection, effort) {
-    const llm = ctx.get('llm')
-    if (typeof llm?.stream !== 'function' || typeof llm?.resolveModelInfo !== 'function') throw new ModelMatchError('当前宿主不支持模型参数校验，请更新 DSH。')
-    let info
-    try { info = await llm.resolveModelInfo(selection.provider, selection.model, AbortSignal.timeout(10_000)) }
-    catch { throw new ModelMatchError('模型信息无法读取，请检查供应商配置后重试。') }
-    const efforts = info.reasoning?.efforts?.map(e => e.id)
-    if (effort === 'off') {
-      if (efforts && !efforts.includes('off')) throw new ModelMatchError('该模型无法关闭推理，不能使用关闭推理的公开基线。请建立相同推理强度的本地参考。')
-      return { provider: selection.provider, model: selection.model, ...(efforts ? { reasoningEffort: 'off' } : {}) }
-    }
-    const actual = effort || info.reasoning?.defaultEffort
-    if (actual && !efforts?.includes(actual)) throw new ModelMatchError('参考与目标的推理强度不兼容，请重新校准。')
-    return { provider: selection.provider, model: selection.model, ...(actual ? { reasoningEffort: actual } : {}) }
-  }
-  async function request(job, task, phase, config) {
-    const timeout = new AbortController(), timer = setTimeout(() => timeout.abort(), options.timeoutMs || PROBE_PLAN.timeoutMs)
-    timer.unref?.()
-    const signal = AbortSignal.any([job.controller.signal, timeout.signal])
-    const item = { time: 0, selection: modelSelection(config.selection), phase, outcome: 'unavailable', stop: 'unknown', usage: safeUsage(null), usageReported: false, valid: 0, mismatches: 0, ttftMs: null, decodeMs: null }
-    let iterator, text = '', firstToken = 0, finish, values = task.probes?.map(() => null)
-    const started = Date.now()
-    try {
-      iterator = ctx.get('llm').stream({ ...config.selection, temperature: config.temperature, maxTokens: task.probes ? task.probes.length * 80 : PROBE_PLAN.capabilityMaxTokens,
-        messages: [{ role: 'system', content: [{ type: 'text', text: FINGERPRINT_SYSTEM }] }, { role: 'user', content: [{ type: 'text', text: task.prompt }] }], signal })[Symbol.asyncIterator]()
-      for (;;) {
-        const next = await abortable(iterator.next(), signal)
-        if (signal.aborted) throw new Error('aborted')
-        if (next.done) break
-        const chunk = next.value
-        if (chunk?.type === 'text-delta') {
-          if (chunk.text && !firstToken) firstToken = Date.now()
-          text += String(chunk.text || '')
-          if (text.length > 32_768) { item.stop = 'max-tokens'; break }
-        }
-        if (chunk?.type === 'usage') { item.usage = safeUsage(chunk.usage); item.usageReported = usageKeys.some(k => Number.isFinite(chunk.usage?.[k])) }
-        if (chunk?.type === 'finish') { finish = chunk; break }
-      }
-      if (finish) item.stop = record({ ...job.selection, stop: finish.reason?.kind })?.stop || 'unknown'
-      if (item.stop === 'stop') {
-        // Public KBF references suppress reasoning. A relay reporting reasoning
-        // despite off invalidates comparability, rather than receiving a pass.
-        if ((config.noReasoning || config.selection.reasoningEffort === 'off') && item.usage.reasoningTokens > 0) item.outcome = 'parameters-ignored'
-        else if (task.probes) {
-          values = parseFingerprintAnswers(text, task.probes)
-          item.valid = values.filter(Number.isFinite).length
-          item.mismatches = task.probes.filter((p, i) => Number.isFinite(p.value) && Number.isFinite(values[i]) && !fingerprintMatch(p.value, values[i], p.domain)).length
-          item.outcome = item.valid ? 'scored' : 'unparseable'
-        } else {
-          try { item.outcome = task.check(text) ? 'pass' : 'fail' } catch { item.outcome = 'unparseable' }
-          item.valid = ['pass', 'fail'].includes(item.outcome) ? 1 : 0
-        }
-        if (firstToken) { item.ttftMs = firstToken - started; item.decodeMs = Date.now() - firstToken }
-      } else item.outcome = item.stop === 'max-tokens' ? 'incomplete' : 'unavailable'
-    } catch {
-      item.outcome = job.controller.signal.aborted ? 'cancelled' : timeout.signal.aborted ? 'timeout' : 'unavailable'
-      item.stop = signal.aborted ? 'aborted' : 'error'
-    } finally {
-      clearTimeout(timer); timeout.abort()
-      try { Promise.resolve(iterator?.return?.()).catch(() => {}) } catch { /* broken adapters cannot block cancellation */ }
-      text = ''
-    }
-    job.results.push(item)
-    item.time = Date.now()
-    for (const key of usageKeys) job.usage[key] += item.usage[key]
-    if (['unavailable', 'timeout', 'parameters-ignored'].includes(item.outcome)) { job.halt = true; job.message = item.outcome === 'parameters-ignored' ? '通道未遵守关闭推理的测试参数，请重新校准。' : '请求未完成，已停止后续请求；检查通道后可重新测试。' }
-    if (sumTokens(job.usage) >= job.plan.budgetTokens) { job.halt = true; job.budgetExhausted = true; job.message = '已达到已上报 Token 预算，后续请求已停止。' }
-    await checkpoint(job)
-    return { values: task.probes ? values : undefined, outcome: item.outcome, score: item.outcome === 'pass' ? 1 : item.outcome === 'fail' ? 0 : null }
-  }
-  const stopped = job => disposed || job.halt || job.controller.signal.aborted
-  async function runFingerprints(job, probes, phase, temperature) {
-    const values = []
-    job.phase = phase
-    for (const batch of batches(probes)) {
-      if (stopped(job)) break
-      const response = await request(job, { probes: batch, prompt: fingerprintPrompt(batch) }, phase, { selection: job.testSelection, temperature, noReasoning: job.reference?.config.reasoningEffort === 'off' || (job.mode === 'calibrate' && !job.testSelection.reasoningEffort) })
-      values.push(...(response.values || batch.map(() => null)))
-    }
-    while (values.length < probes.length) values.push(null)
-    return values
-  }
-  async function runCapabilities(job, seed, selection) {
-    job.phase = 'capabilities'
-    const outcomes = []
-    for (const task of capabilityTasks(seed)) { if (stopped(job)) break; outcomes.push((await request(job, task, 'capabilities', { selection, temperature: 0 })).score) }
-    while (outcomes.length < 16) outcomes.push(null)
-    return outcomes
-  }
-  async function run(job, quote) {
-    await checkpoint(job)
-    let referenceToSave
-    if (job.mode === 'calibrate') {
-      const passes = []
-      for (const [i, temp] of [0, 0.7, 0.7].entries()) { if (stopped(job)) break; passes.push(await runFingerprints(job, quote.pool, 'consensus-' + (i + 1), temp)) }
-      if (!stopped(job) && passes.length === 3) {
-        const stable = quote.pool.flatMap((p, i) => passes.every(v => Number.isFinite(v[i]) && fingerprintMatch(passes[0][i], v[i], p.domain)) ? [{ ...p, value: passes[0][i] }] : [])
-        if (stable.length < AUDIT_POLICY.minSamples) { job.halt = true; job.message = '稳定探针少于 64 个，未保存基线；可提高校准题量后重试。' }
-        else {
-          const holdout = await runFingerprints(job, stable, 'calibration', 0)
-          const probes = stable.map((p, i) => ({ ...p, calibration: Number.isFinite(holdout[i]) ? (fingerprintMatch(p.value, holdout[i], p.domain) ? 1 : 0) : null }))
-          referenceToSave = normalizeFingerprint({ model: quote.claimedModel, provider: job.selection.provider, date: new Date().toISOString(), selection: job.testSelection,
-            config: { system: FINGERPRINT_SYSTEM, temperature: 0, reasoningEffort: job.testSelection.reasoningEffort || 'off' }, probes }, 'calibrated')
-          const calibrationCheck = scoreFingerprint(referenceToSave, probes.map(p => p.calibration))
-          if (calibrationCheck.verdict === 'insufficient-evidence' || calibrationCheck.p0 > AUDIT_POLICY.maxReferenceNoise) { job.halt = true; job.message = '参考自测覆盖不足或波动过大，未保存基线。' }
-        }
-      }
-    } else if (job.mode === 'audit') {
-      const values = await runFingerprints(job, job.reference.probes, 'fingerprint', 0)
-      const outcomes = job.reference.probes.map((p, i) => Number.isFinite(values[i]) ? (fingerprintMatch(p.value, values[i], p.domain) ? 1 : 0) : null)
-      job.identity = scoreFingerprint(job.reference, outcomes, !stopped(job))
-    }
-    if (!stopped(job) && (job.mode === 'capability' || quote.includeCapabilities)) {
-      const seed = quote.capabilitySeed, outcomes = await runCapabilities(job, seed, quote.capabilitySelection)
-      const reference = job.reference?.capabilities
-      job.capability = scoreCapabilities(outcomes, reference?.outcomes, !stopped(job))
-      if (referenceToSave && outcomes.filter(v => v === 0 || v === 1).length >= 12) referenceToSave.capabilities = { version: 1, seed, effort: quote.capabilitySelection.reasoningEffort || '', outcomes }
-    }
-    let status = job.controller.signal.aborted || disposed ? 'cancelled' : job.budgetExhausted ? 'budget-exhausted' : job.halt ? 'failed' : 'complete'
-    if (status === 'complete' && referenceToSave) {
-      ensureLocalCapacity()
-      const normalized = normalizeFingerprint(referenceToSave, 'calibrated')
-      references.set(normalized.id, normalized)
-      try {
-        await save()
-        if (disposed || job.controller.signal.aborted) { references.delete(normalized.id); await save(); status = 'cancelled' }
-        else { job.reference = normalized; job.baselineId = normalized.id; job.identity = scoreFingerprint(normalized, normalized.probes.map(p => p.calibration)); job.message = '参考基线已保存，可用于同模型的后续检测。' }
-      }
-      catch { references.delete(normalized.id); status = 'failed'; job.message = '基线保存失败，请检查本地存储后重新校准。' }
-    }
-    if (status !== 'complete') {
-      if (job.identity) job.identity = { ...job.identity, verdict: 'insufficient-evidence', reason: 'unfinished', pValue: null }
-      if (job.capability) job.capability = { ...job.capability, verdict: 'insufficient-evidence', pValue: null }
-    }
-    job.finishedAt = Date.now()
-    await checkpoint(job, { status })
-    if ((disposed || job.controller.signal.aborted) && status !== 'cancelled') {
-      status = 'cancelled'
-      if (job.baselineId) { references.delete(job.baselineId); job.baselineId = null; await save() }
-      if (job.identity) job.identity = { ...job.identity, verdict: 'insufficient-evidence', reason: 'unfinished', pValue: null }
-      if (job.capability) job.capability = { ...job.capability, verdict: 'insufficient-evidence', pValue: null }
-      await checkpoint(job, { status })
-    }
-    if (options.onUpdate && job.usageSaved === false && status === 'complete') {
-      status = 'failed'
-      if (job.identity) job.identity = { ...job.identity, verdict: 'insufficient-evidence', reason: 'unfinished', pValue: null }
-      if (job.capability) job.capability = { ...job.capability, verdict: 'insufficient-evidence', pValue: null }
-    }
-    job.status = status
-  }
-  return {
-    catalog() { load(); return { references: [...references.values()].map(fingerprintSummary), policy: AUDIT_POLICY, storageWarning } },
-    exportReference(id) { return getReference(id) },
-    async importReference(raw) {
-      load()
-      let ref
-      try { ref = normalizeFingerprint(raw) } catch (error) { throw new ModelMatchError(error.message) }
-      if (!references.has(ref.id)) ensureLocalCapacity()
-      const previous = references.get(ref.id); references.set(ref.id, ref)
-      try { await save() } catch { if (previous) references.set(ref.id, previous); else references.delete(ref.id); throw new ModelMatchError('基线保存失败，请检查本地存储。') }
-      return fingerprintSummary(ref)
-    },
-    async removeReference(id) {
-      const ref = getReference(id)
-      if (ref.origin === 'public') throw new ModelMatchError('公开参考随插件提供，无法移除。')
-      if ([...jobs.values()].some(j => j.status === 'running' && j.reference?.id === id)) throw new ModelMatchError('该基线正在使用，请先取消测试。')
-      references.delete(id)
-      try { await save() } catch { references.set(id, ref); throw new ModelMatchError('基线移除失败，请重试。') }
-    },
-    async plan(body) {
-      if (disposed) throw new ModelMatchError('匹配服务已停止。')
-      load()
-      const mode = ['audit', 'calibrate', 'capability'].includes(body?.mode) ? body.mode : 'audit'
-      const selection = modelSelection(body?.selection), sessionId = safeText(body?.sessionId)
-      if (!selection || !sessionId) throw new ModelMatchError('请先选择当前会话与模型。')
-      let reference, pool, count = 0, includeCapabilities = mode === 'calibrate' || body.includeCapabilities === true
-      let testSelection, capabilitySelection, capabilitySeed = randomInt(0x100000000), claimedModel = selection.model
-      if (mode === 'calibrate') {
-        ensureLocalCapacity()
-        if (body.ackReference !== true) throw new ModelMatchError('请确认所选通道可作为可信参考。')
-        claimedModel = safeText(body.claimedModel)
-        if (!claimedModel) throw new ModelMatchError('请选择该参考对应的目标模型。')
-        count = body.probeCount === 256 ? 256 : 128; pool = calibrationPool(count)
-        testSelection = await resolveTestSelection(selection, selection.reasoningEffort || 'off')
-      } else if (mode === 'audit' || body.referenceId) {
-        reference = getReference(body.referenceId)
-        if (fingerprintModelKey(reference.model) !== fingerprintModelKey(selection.model)) throw new ModelMatchError('参考基线与当前模型不同，请选择对应基线或建立本地参考。')
-        if (mode === 'audit') {
-          const selfCheck = scoreFingerprint(reference, reference.probes.map(() => 1))
-          if (selfCheck.verdict === 'insufficient-evidence' || selfCheck.p0 > AUDIT_POLICY.maxReferenceNoise) throw new ModelMatchError('参考自测覆盖不足或波动过大，请重新校准后检测。')
-        }
-        count = body.probeCount === 128 && !reference.calibration ? Math.min(128, reference.probes.length) : reference.probes.length
-        testSelection = await resolveTestSelection(selection, mode === 'capability' ? selection.reasoningEffort || '' : reference.config.reasoningEffort)
-        if (reference.capabilities) capabilitySeed = reference.capabilities.seed
-      }
-      testSelection ||= await resolveTestSelection(selection, selection.reasoningEffort || (mode === 'capability' ? '' : 'off'))
-      if (mode === 'capability' || includeCapabilities) {
-        capabilitySelection = await resolveTestSelection(selection, selection.reasoningEffort || '')
-        if (reference?.capabilities && reference.capabilities.effort !== (capabilitySelection.reasoningEffort || '')) throw new ModelMatchError('能力基线的推理强度与当前模型不同，请选择相同档位或重新校准。')
-      }
-      const requests = (mode === 'calibrate' ? 4 : mode === 'audit' ? 1 : 0) * Math.ceil(count / 10) + (mode === 'capability' || includeCapabilities ? 16 : 0)
-      const maxOutputTokens = (mode === 'calibrate' ? 4 : mode === 'audit' ? 1 : 0) * count * 80 + (mode === 'capability' || includeCapabilities ? 16 * 1024 : 0)
-      const fingerprintChars = mode === 'capability' ? 0 : batches(pool || reference.probes.slice(0, count)).reduce((n, batch) => n + fingerprintPrompt(batch).length + FINGERPRINT_SYSTEM.length, 0) * (mode === 'calibrate' ? 4 : 1)
-      const capabilityChars = mode === 'capability' || includeCapabilities ? capabilityTasks(capabilitySeed).reduce((n, task) => n + task.prompt.length + FINGERPRINT_SYSTEM.length, 0) : 0
-      if (body.budgetTokens !== undefined && (!Number.isInteger(body.budgetTokens) || body.budgetTokens < 1024 || body.budgetTokens > 500_000)) throw new ModelMatchError('Token 预算应为 1,024–500,000 的整数。')
-      const budgetTokens = body.budgetTokens ?? 120_000
-      const plan = { requests, probes: count, maxOutputTokens, estimatedInputTokens: Math.ceil((fingerprintChars + capabilityChars) / 3), budgetTokens,
-        batchSize: 10, temperature: 0, timeoutMs: PROBE_PLAN.timeoutMs, capabilities: mode === 'capability' || includeCapabilities, capabilityTasks: mode === 'capability' || includeCapabilities ? 16 : 0 }
-      while (quotes.size >= 10) quotes.delete(quotes.keys().next().value)
-      const id = randomUUID()
-      quotes.set(id, { id, mode, selection, sessionId, reference, pool, count, includeCapabilities, testSelection, capabilitySelection, capabilitySeed, claimedModel, plan, createdAt: Date.now() })
-      return { id, mode, selection, testSelection, capabilitySelection, reference: reference && fingerprintSummary(reference), claimedModel, plan }
-    },
-    start(body) {
-      if (disposed) throw new ModelMatchError('匹配服务已停止。')
-      if (body?.ackCost !== true) throw new ModelMatchError('请确认测试会消耗 Token 后再开始。')
-      const quote = quotes.get(body.planId)
-      if (!quote || Date.now() - quote.createdAt > 5 * 60_000) throw new ModelMatchError('测试预算已过期，请刷新预算后开始。')
-      if (body.sessionId !== quote.sessionId) throw new ModelMatchError('当前会话已变化，请重新生成预算。')
-      if ([...jobs.values()].some(j => j.status === 'running')) throw new ModelMatchError('已有测试正在运行，请先等待或取消。')
-      if (quote.reference && references.get(quote.reference.id) !== quote.reference) throw new ModelMatchError('参考基线已变化，请刷新预算。')
-      quotes.delete(quote.id)
-      while (jobs.size >= 10) jobs.delete(jobs.keys().next().value)
-      const job = { id: randomUUID(), sessionId: quote.sessionId, selection: quote.selection, testSelection: quote.testSelection, mode: quote.mode,
-        capabilitySelection: quote.capabilitySelection,
-        reference: quote.reference && subsetFingerprint(quote.reference, quote.count), plan: quote.plan, status: 'running', phase: 'queued',
-        startedAt: Date.now(), finishedAt: 0, controller: new AbortController(), results: [], usage: safeUsage(null) }
-      jobs.set(job.id, job)
-      queueMicrotask(() => { void run(job, quote).catch(async () => { job.status = 'failed'; job.message = '测试未完成，请检查通道或重新生成预算。'; job.finishedAt = Date.now(); await checkpoint(job) }) })
-      return jobView(job)
-    },
-    status(id, sessionId) { const job = id ? jobs.get(id) : [...jobs.values()].reverse().find(j => !sessionId || j.sessionId === sessionId); if (id && !job) throw new ModelMatchError('测试记录已过期。'); return job ? jobView(job) : null },
-    cancel(id) { const job = jobs.get(id); if (!job) throw new ModelMatchError('测试记录已过期。'); if (job.status === 'running') job.controller.abort(); return jobView(job) },
-    dispose() { disposed = true; quotes.clear(); for (const job of jobs.values()) job.controller.abort() },
-  }
-}