dsh-llm-verifier 0.2.0 → 0.3.0

package/src/client-i18n.ts

@@ -33,7 +33,7 @@ export const zh = {
   'field.autoRouteMaxPerSession.title': '每会话最多路由',
   'field.autoRouteMaxPerSession.help': '同一会话中自动路由的尝试上限；与「每会话最多验收」共享计数器，实际可用次数同样是两者之和。',
   'field.autoTrackCompletionThreshold.title': '进度完成阈值',
-  'field.autoTrackCompletionThreshold.help': 'track 任一检查点低于该值时 steering 要求 Agent 继续执行；范围 0–1。',
+  'field.autoTrackCompletionThreshold.help': 'track 最新检查点低于该值时 steering 要求 Agent 继续执行；更早的检查点只作展示，范围 0–1。',
   'field.autoRouteMaxItemChars.title': '单项证据字符上限',
   'field.autoRouteMaxItemChars.help': '每个候选或检查点在脱敏后允许发送给裁判的最大字符数。',
   'field.autoRouteMaxInputChars.title': '路由证据总字符上限',
@@ -116,6 +116,7 @@ export const zh = {
   'settings.catalogFailures': '部分模型目录读取失败',
   'settings.saved': '设置已保存。',
   'settings.reload': '重新载入',
+  'settings.unsaved': '当前页面有未保存的修改：点击「保存」后才会写入设置；「重新载入」会丢弃这些修改。',
   'settings.save': '保存设置',
   'settings.saving': '保存中…',
 
@@ -145,6 +146,7 @@ export const zh = {
   'stats.outcome.passed': '通过',
   'stats.outcome.below-threshold': '未达标',
   'stats.outcome.tie': '平局',
+  'stats.outcome.compared': '已比较',
   'stats.outcome.error': '异常',
   'stats.outcome.dropped-over-budget': '超预算丢弃',
   'stats.outcome.invalid-references': '引用无效',
@@ -152,6 +154,8 @@ export const zh = {
   'stats.verdict.winner': '胜方 {winner}',
   'stats.verdict.scoreThreshold': '得分 {score}（阈值 {threshold}）',
   'stats.verdict.scoreOnly': '得分 {score}',
+  'stats.verdict.checkpoints': '检查点 {scores}',
+  'stats.verdict.criteria': '标准 {criteria}',
 
   // Metrics
   'metric.cacheHitRate': '缓存命中率',
@@ -243,7 +247,7 @@ export const en: I18nDict = {
   'field.autoRouteMaxPerSession.title': 'Max Routes per Session',
   'field.autoRouteMaxPerSession.help': 'Session attempt cap for automatic routing; shares its counter with "Max Verifications per Session" (effective limit is the sum of both).',
   'field.autoTrackCompletionThreshold.title': 'Progress Completion Threshold',
-  'field.autoTrackCompletionThreshold.help': 'When any track checkpoint falls below this score, steering instructs the Agent to continue; range 0–1.',
+  'field.autoTrackCompletionThreshold.help': 'When the newest track checkpoint falls below this score, steering instructs the Agent to continue; earlier checkpoints are shown only; range 0–1.',
   'field.autoRouteMaxItemChars.title': 'Max Chars per Route Item',
   'field.autoRouteMaxItemChars.help': 'Maximum sanitized character count allowed per candidate or checkpoint when sent to the judge.',
   'field.autoRouteMaxInputChars.title': 'Total Route Input Chars Cap',
@@ -326,6 +330,7 @@ export const en: I18nDict = {
   'settings.catalogFailures': 'Some model catalogs failed to load',
   'settings.saved': 'Settings saved.',
   'settings.reload': 'Reload',
+  'settings.unsaved': 'This page has unsaved changes: click Save to write them; Reload discards them.',
   'settings.save': 'Save Settings',
   'settings.saving': 'Saving…',
 
@@ -355,6 +360,7 @@ export const en: I18nDict = {
   'stats.outcome.passed': 'Passed',
   'stats.outcome.below-threshold': 'Below Threshold',
   'stats.outcome.tie': 'Tie',
+  'stats.outcome.compared': 'Compared',
   'stats.outcome.error': 'Error',
   'stats.outcome.dropped-over-budget': 'Dropped (over budget)',
   'stats.outcome.invalid-references': 'Invalid references',
@@ -362,6 +368,8 @@ export const en: I18nDict = {
   'stats.verdict.winner': 'Winner {winner}',
   'stats.verdict.scoreThreshold': 'Score {score} (threshold {threshold})',
   'stats.verdict.scoreOnly': 'Score {score}',
+  'stats.verdict.checkpoints': 'Checkpoints {scores}',
+  'stats.verdict.criteria': 'Criteria {criteria}',
 
   // Metrics
   'metric.cacheHitRate': 'Cache Hit Rate',
@@ -491,6 +499,12 @@ export interface VerdictSummary {
   phase?: string
   outcome?: string
   score?: number
+  /** Per-checkpoint progression of a `verifier_track` verdict, oldest first; absent on older records. */
+  scores?: number[]
+  /** Candidate B's score of a two-way comparison; `score` is the winning side. */
+  scoreB?: number
+  /** Per-criterion A-side scores of a session acceptance; the mean alone can hide a failed requirement. */
+  criteria?: Array<{ id: string; score: number }>
   baselineScore?: number
   winner?: 'A' | 'B' | 'tie'
   threshold?: number
@@ -505,7 +519,66 @@ export function resolveCacheDirOnSave(
   return undefined
 }
 
-/** An eight-candidate select: ring + pivot rounds (18 pairs) x three criteria, one repeat. */
+/**
+ * Deep equality for JSON-shaped settings values, insensitive to object key
+ * order and treating a missing key as `undefined`. The settings page compares a
+ * draft against a resolved view that was built from a different object shape,
+ * so identity comparison is never enough.
+ */
+export function sameSettingValue(left: unknown, right: unknown): boolean {
+  if (left === right) return true
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) return false
+    for (let index = 0; index < left.length; index += 1) {
+      if (!sameSettingValue(left[index], right[index])) return false
+    }
+    return true
+  }
+  if (Array.isArray(left) || Array.isArray(right)) return false
+  if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null) return false
+  const a = left as Record<string, unknown>
+  const b = right as Record<string, unknown>
+  for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (!sameSettingValue(a[key], b[key])) return false
+  }
+  return true
+}
+
+/**
+ * Build the user layer for one settings save.
+ *
+ * Keys this client does not own survive untouched and every draft field is
+ * written, but a field that only repeats the base composition is *dropped*
+ * rather than pinned. Pinning is what makes a shipped default change
+ * unreachable: the budget fields once defaulted to 48/160, and a section that
+ * stored those numbers kept overriding 64/240 and then 96/240 forever. `base`
+ * is the descriptor's composition base (the resolved plugin config), so the
+ * stored section keeps exactly what the user really overrode.
+ *
+ * An explicit `undefined` draft value means "clear this override": it deletes
+ * the stored key instead of pinning a valueless one, which is how the form
+ * removes a judge label, a reasoning effort or a cache directory.
+ *
+ * A host that reports no `base` cannot be pruned against and keeps the old
+ * write-everything behavior.
+ */
+export function sectionForSave(
+  user: Record<string, unknown>,
+  draft: Record<string, unknown>,
+  base: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  const section: Record<string, unknown> = { ...user }
+  for (const [key, value] of Object.entries(draft)) {
+    if (value === undefined || (base !== undefined && sameSettingValue(value, base[key]))) {
+      delete section[key]
+      continue
+    }
+    section[key] = value
+  }
+  return section
+}
+
+/** An eight-candidate select: ring + pivot rounds (18 pairs) x three criteria, one round (the per-pair orientation removes the slot bias). */
 export const WORST_CASE_ROUTE_CALLS_PER_JUDGE = 54
 /** Final acceptance: three criteria x the default two repeats (one per A/B position). */
 export const WORST_CASE_FINAL_CALLS_PER_JUDGE = 6
@@ -568,6 +641,8 @@ export function formatVerdictDetails(
   outcomeText?: string
   phaseText?: string
   scoreText?: string
+  checkpointsText?: string
+  criteriaText?: string
   winnerText?: string
   isFailed: boolean
 } {
@@ -589,12 +664,26 @@ export function formatVerdictDetails(
     }
   }
 
+  // One track verdict carries a whole progression; showing only the newest score
+  // hides why the route decided to continue.
+  let checkpointsText: string | undefined
+  if (Array.isArray(verdict.scores) && verdict.scores.length > 1) {
+    checkpointsText = tFormat(t['stats.verdict.checkpoints'], { scores: verdict.scores.map(formatPercentage).join(' → ') })
+  }
+
+  // The acceptance mean can hide a requirement that failed on its own, so the breakdown
+  // is what tells the reader which one is holding the task back.
+  let criteriaText: string | undefined
+  if (Array.isArray(verdict.criteria) && verdict.criteria.length > 0) {
+    criteriaText = tFormat(t['stats.verdict.criteria'], { criteria: verdict.criteria.map(criterion => criterion.id + ' ' + formatPercentage(criterion.score)).join(' · ') })
+  }
+
   let winnerText: string | undefined
   if (verdict.winner) {
     const winnerValue = verdict.winner === 'tie' ? t['stats.winner.tie'] : verdict.winner
     winnerText = tFormat(t['stats.verdict.winner'], { winner: winnerValue })
   }
 
-  return { outcomeText, phaseText, scoreText, winnerText, isFailed }
+  return { outcomeText, phaseText, scoreText, checkpointsText, criteriaText, winnerText, isFailed }
 }
 

package/src/client.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest'
 import { zh, en, toolLabels, tFormat, detectLanguage, compact, dateTime } from './client-i18n.ts'
 import {
   resolveCacheDirOnSave,
+  sameSettingValue,
+  sectionForSave,
   WORST_CASE_ROUTE_CALLS_PER_JUDGE,
   WORST_CASE_FINAL_CALLS_PER_JUDGE,
   WORST_CASE_TASK_PER_JUDGE,
@@ -365,9 +367,94 @@ describe('resolveCacheDirOnSave rule', () => {
   })
 })
 
+describe('sameSettingValue', () => {
+  it('treats a missing key and an explicit undefined as the same value', () => {
+    expect(sameSettingValue({ reasoningEffort: undefined }, {})).toBe(true)
+    expect(sameSettingValue({}, { reasoningEffort: undefined })).toBe(true)
+  })
+
+  it('ignores object key order but not array order', () => {
+    expect(sameSettingValue({ a: 1, b: { c: 2, d: 3 } }, { b: { d: 3, c: 2 }, a: 1 })).toBe(true)
+    expect(sameSettingValue([1, 2], [1, 2])).toBe(true)
+    expect(sameSettingValue([1, 2], [2, 1])).toBe(false)
+    expect(sameSettingValue([1, 2], [1, 2, 3])).toBe(false)
+  })
+
+  it('never equates an absent value with null, 0 or false', () => {
+    expect(sameSettingValue(null, undefined)).toBe(false)
+    expect(sameSettingValue(0, undefined)).toBe(false)
+    expect(sameSettingValue(false, undefined)).toBe(false)
+    expect(sameSettingValue(0, false)).toBe(false)
+    expect(sameSettingValue('0', 0)).toBe(false)
+  })
+
+  it('compares nested judge drafts', () => {
+    const judge = { provider: 'deepseek-official', model: 'deepseek-flash', maxTokens: 32768 }
+    expect(sameSettingValue([judge], [{ maxTokens: 32768, model: 'deepseek-flash', provider: 'deepseek-official' }])).toBe(true)
+    expect(sameSettingValue([judge], [{ ...judge, maxTokens: 4096 }])).toBe(false)
+  })
+})
+
+describe('settings save layer', () => {
+  const BASE = {
+    autoMaxModelCallsPerTask: 96,
+    autoMaxModelCallsPerSession: 240,
+    enabled: true,
+    autoVerifyMaxPerSession: 8,
+    extraJudges: [] as unknown[],
+  }
+
+  it('drops every field that only repeats the base composition', () => {
+    expect(sectionForSave({}, { enabled: true, autoMaxModelCallsPerTask: 96, extraJudges: [] }, BASE)).toEqual({})
+  })
+
+  it('keeps a field whose value differs from the base', () => {
+    expect(sectionForSave({}, { enabled: true, autoMaxModelCallsPerTask: 54 }, BASE))
+      .toEqual({ autoMaxModelCallsPerTask: 54 })
+  })
+
+  it('prunes a stored copy of a value the base already supplies', () => {
+    // The shape this plugin used to write: every field pinned, including the
+    // budget values that later moved 48 -> 64 -> 96 in the plugin defaults.
+    const stored = { enabled: true, autoVerifyMaxPerSession: 8, autoMaxModelCallsPerTask: 54 }
+    const draft = { enabled: true, autoVerifyMaxPerSession: 8, autoMaxModelCallsPerTask: 54 }
+    expect(sectionForSave(stored, draft, BASE)).toEqual({ autoMaxModelCallsPerTask: 54 })
+  })
+
+  it('keeps user-layer keys this client does not own', () => {
+    expect(sectionForSave({ futureKey: 'keep-me' }, { enabled: true }, BASE)).toEqual({ futureKey: 'keep-me' })
+  })
+
+  it('writes every draft field when the host reports no base', () => {
+    expect(sectionForSave({}, { enabled: true, autoMaxModelCallsPerTask: 96 }, undefined))
+      .toEqual({ enabled: true, autoMaxModelCallsPerTask: 96 })
+  })
+
+  it('never stores an undefined override but keeps a key the base omits', () => {
+    expect(sectionForSave({}, { reasoningEffort: undefined, autoVerifyThreshold: 0.65 }, BASE))
+      .toEqual({ autoVerifyThreshold: 0.65 })
+  })
+
+  it('clears a stored override the draft no longer carries', () => {
+    const stored = { label: 'old judge', cacheDir: 'legacy-cache', reasoningEffort: 'high' }
+    expect(sectionForSave(stored, { label: undefined, cacheDir: undefined, reasoningEffort: undefined }, BASE))
+      .toEqual({})
+  })
+
+  it('clears a stored override even when the host reports no base', () => {
+    expect(sectionForSave({ label: 'old judge' }, { label: undefined }, undefined)).toEqual({})
+  })
+
+  it('keeps an extra judge whose base counterpart differs', () => {
+    const judge = { provider: 'antigravity', model: 'gemini-3.8-flash' }
+    expect(sectionForSave({}, { extraJudges: [judge] }, BASE)).toEqual({ extraJudges: [judge] })
+  })
+})
+
 describe('budget worst case and sanity warnings', () => {
   it('defines correct constants for worst case calls per judge', () => {
-    // Routing (54) plus the final acceptance (3 criteria x 2 repeats) per judge.
+    // Routing (18 pairs x 3 criteria, one round per pair) plus the final acceptance
+    // (3 criteria x 2 repeats) per judge.
     expect(WORST_CASE_ROUTE_CALLS_PER_JUDGE).toBe(54)
     expect(WORST_CASE_FINAL_CALLS_PER_JUDGE).toBe(6)
     expect(WORST_CASE_TASK_PER_JUDGE).toBe(60)
@@ -394,14 +481,14 @@ describe('budget worst case and sanity warnings', () => {
   })
 
   it('returns null when budgets meet or exceed worst case requirements', () => {
-    // 1 judge (0 extra): task worst case 60, session worst case 160
+    // 1 judge (0 extra): task worst case 60, session worst case 160 — the shipped
+    // defaults (96 / 240) clear both.
     expect(evaluateBudgetWarning('smart', 0, 96, 240)).toBeNull()
     // 2 judges (1 extra): task worst case 120, session worst case 320
     expect(evaluateBudgetWarning('smart', 1, 120, 320)).toBeNull()
   })
 
   it('warns on task budget below worst case requirement', () => {
-    // 2 judges (1 extra): task worst case 120, session worst case 320
     const warning = evaluateBudgetWarning('smart', 1, 64, 350)
     expect(warning).not.toBeNull()
     expect(warning?.warnTask).toBe(true)
@@ -505,6 +592,50 @@ describe('verdict dashboard helpers', () => {
       expect(res.phaseText).toBe('两项对比')
     })
 
+    it('renders the track checkpoint progression', () => {
+      const verdict: VerdictSummary = {
+        phase: 'track',
+        outcome: 'below-threshold',
+        score: 0.7894736842105262,
+        scores: [0, 0.10526315789473684, 0.7894736842105262],
+        threshold: 0.8,
+      }
+      expect(formatVerdictDetails(verdict, zh).checkpointsText).toBe('检查点 0.0% → 10.5% → 78.9%')
+      expect(formatVerdictDetails(verdict, en).checkpointsText).toBe('Checkpoints 0.0% → 10.5% → 78.9%')
+    })
+
+    it('localizes the compared outcome and omits a threshold a comparison never had', () => {
+      const verdict: VerdictSummary = { phase: 'compare', outcome: 'compared', score: 0.9, scoreB: 0.2, winner: 'B' }
+      const zhRes = formatVerdictDetails(verdict, zh)
+      expect(zhRes.outcomeText).toBe('已比较')
+      expect(zhRes.scoreText).toBe('得分 90.0%')
+      expect(zhRes.winnerText).toBe('胜方 B')
+      expect(zhRes.isFailed).toBe(false)
+      expect(formatVerdictDetails(verdict, en).outcomeText).toBe('Compared')
+      // A record written by an older build still renders.
+      expect(formatVerdictDetails({ phase: 'compare', outcome: 'below-threshold', score: 0.2, threshold: 0.65 }, zh).isFailed).toBe(true)
+    })
+
+    it('renders the per-criterion breakdown of a session acceptance', () => {
+      const verdict: VerdictSummary = {
+        phase: 'final',
+        outcome: 'below-threshold',
+        score: 0.6667,
+        baselineScore: 0,
+        criteria: [{ id: 'specification', score: 1 }, { id: 'error_signals', score: 0 }],
+        winner: 'A',
+        threshold: 0.65,
+      }
+      expect(formatVerdictDetails(verdict, zh).criteriaText).toBe('标准 specification 100.0% · error_signals 0.0%')
+      expect(formatVerdictDetails(verdict, en).criteriaText).toBe('Criteria specification 100.0% · error_signals 0.0%')
+      expect(formatVerdictDetails({ outcome: 'passed', score: 1 }, zh).criteriaText).toBeUndefined()
+    })
+
+    it('omits the progression for a single checkpoint', () => {
+      expect(formatVerdictDetails({ outcome: 'below-threshold', score: 0, scores: [0] }, zh).checkpointsText).toBeUndefined()
+      expect(formatVerdictDetails({ outcome: 'below-threshold', score: 0 }, zh).checkpointsText).toBeUndefined()
+    })
+
     it('formats tie winner localized in zh and en', () => {
       const verdict: VerdictSummary = {
         outcome: 'tie',

package/src/client.tsx

@@ -8,7 +8,7 @@ import { useEffect, useMemo, useRef, useState } from 'react'
 import {
   zh, en, dictionaries, toolLabels, tFormat, useLanguage, detectLanguage,
   compact, money, duration, dateTime, type I18nDict,
-  type VerdictSummary, resolveCacheDirOnSave,
+  type VerdictSummary, resolveCacheDirOnSave, sameSettingValue, sectionForSave,
   WORST_CASE_ROUTE_CALLS_PER_JUDGE, WORST_CASE_FINAL_CALLS_PER_JUDGE, WORST_CASE_TASK_PER_JUDGE, WORST_CASE_SESSION_PER_JUDGE,
   computeJudgeCount, computeWorstCaseBudget, type BudgetWarningState,
   evaluateBudgetWarning, isVerdictFailed, formatPercentage, formatVerdictDetails,
@@ -26,7 +26,7 @@ import {
 
 export {
   zh, en, dictionaries, toolLabels, tFormat, useLanguage, detectLanguage, compact, money, duration, dateTime, type I18nDict,
-  type VerdictSummary, resolveCacheDirOnSave, WORST_CASE_ROUTE_CALLS_PER_JUDGE, WORST_CASE_FINAL_CALLS_PER_JUDGE, WORST_CASE_TASK_PER_JUDGE, WORST_CASE_SESSION_PER_JUDGE,
+  type VerdictSummary, resolveCacheDirOnSave, sameSettingValue, sectionForSave, WORST_CASE_ROUTE_CALLS_PER_JUDGE, WORST_CASE_FINAL_CALLS_PER_JUDGE, WORST_CASE_TASK_PER_JUDGE, WORST_CASE_SESSION_PER_JUDGE,
   computeJudgeCount, computeWorstCaseBudget, type BudgetWarningState, evaluateBudgetWarning, isVerdictFailed,
   formatPercentage, formatVerdictDetails,
 }
@@ -105,6 +105,37 @@ export function VerifierSettings({ remote }: VerifierSettingsProps) {
   const [loaded,setLoaded]=useState<Loaded|null>(null); const [draft,setDraft]=useState<Values|null>(null); const [busy,setBusy]=useState(false); const [error,setError]=useState<string|null>(null); const [saved,setSaved]=useState(false); const [editing,setEditing]=useState<Record<string,string>>({})
   const load=async()=>{setError(null);try{const [m,s]=await Promise.all([remote.session.modelCatalog(),remote.settings.describe()]);if(!m.ok)throw new Error(m.error.message);if(!s.ok)throw new Error(s.error.message);const view=s.value.namespaces.find((x:SettingsNamespaceView)=>x.ns===NS);if(!view)throw new Error(t['settings.nsUnregistered']);const next={groups:m.value.groups,settings:view,writable:s.value.writable,failures:m.value.failures.map((f: { id?: string; provider?: string; name?: string; message: string })=>(f.id??f.provider??f.name??'unknown')+': '+f.message)};setLoaded(next);setDraft(values(view));setEditing({})}catch(e){setError(message(e))}}
   useEffect(()=>{void load()},[])
+  const dirty=useMemo(()=>loaded!==null&&draft!==null&&!sameSettingValue(draft,values(loaded.settings)),[loaded,draft])
+  // Another writer — the settings shell's reset, a second window, an edit to
+  // settings.yaml — can move this namespace under a page that never re-reads
+  // it, and the stale draft would then be written straight back on the next
+  // save. Re-read whenever the page regains focus, but only while the draft
+  // holds no unsaved edit: a pending edit belongs to the user, and the
+  // revision check on save still rejects a write that raced a moved namespace.
+  const latest=useRef({loaded,draft})
+  latest.current={loaded,draft}
+  useEffect(()=>{
+    const sync=()=>{
+      if(document.visibilityState==='hidden')return
+      const {loaded:at,draft:local}=latest.current
+      if(!at||!local)return
+      if(!sameSettingValue(local,values(at.settings)))return
+      void (async()=>{
+        try{
+          const s=await remote.settings.describe()
+          if(!s.ok)return
+          const view=s.value.namespaces.find((x:SettingsNamespaceView)=>x.ns===NS)
+          if(!view||view.revision===at.settings.revision)return
+          const next:Loaded={...at,settings:view,writable:s.value.writable}
+          latest.current={loaded:next,draft:values(view)}
+          setLoaded(next);setDraft(values(view));setEditing({});setSaved(false)
+        }catch{/* keep the last good view; the reload button still forces a read */}
+      })()
+    }
+    window.addEventListener('focus',sync)
+    document.addEventListener('visibilitychange',sync)
+    return ()=>{window.removeEventListener('focus',sync);document.removeEventListener('visibilitychange',sync)}
+  },[remote])
   const models=useMemo(()=>loaded?.groups.find(g=>g.id===draft?.provider)?.models??[],[loaded,draft?.provider])
   const selected=models.find(m=>m.id===draft?.model); const efforts=selected?.reasoning?.efforts??[]
   const patch=<K extends keyof Values>(key:K,value:Values[K])=>{setSaved(false);setDraft(v=>v?{...v,[key]:value}:v)}
@@ -141,7 +172,30 @@ export function VerifierSettings({ remote }: VerifierSettingsProps) {
       draft.autoMaxModelCallsPerSession,
     )
   }, [draft?.autoVerifyMode, draft?.extraJudges.length, draft?.autoMaxModelCallsPerTask, draft?.autoMaxModelCallsPerSession])
-  const save=async()=>{if(!loaded||!draft||conflict)return;setBusy(true);setSaved(false);setError(null);try{const section={...record(loaded.settings.user),...draft,extraJudges:serializeExtraJudges(draft.extraJudges)};if(!draft.reasoningEffort)delete section.reasoningEffort;if(!draft.label||!draft.label.trim())delete section.label;else section.label=draft.label.trim();const resolvedCacheDir=resolveCacheDirOnSave(draft.cacheDir,values(loaded.settings).cacheDir);if(!resolvedCacheDir)delete (section as {cacheDir?:string}).cacheDir;else section.cacheDir=resolvedCacheDir;const res=await remote.settings.update(NS,section as never,loaded.settings.revision);if(!res.ok)throw new Error(res.error.message);setLoaded(v=>v?{...v,settings:res.value}:v);setDraft(values(res.value));setEditing({});setSaved(true)}catch(e){setError(message(e))}finally{setBusy(false)}}
+  // The saved section holds only real overrides: a draft field equal to the
+  // composition base is dropped so a later plugin default still reaches this
+  // install (see sectionForSave).
+  const save=async()=>{
+    if(!loaded||!draft||conflict)return
+    setBusy(true);setSaved(false);setError(null)
+    try{
+      // An explicit undefined means "clear the stored override": sectionForSave
+      // starts from the previous user layer, so simply omitting a key would let
+      // the stale override outlive the save that cleared it.
+      const editable:Record<string,unknown>={
+        ...draft,
+        extraJudges:serializeExtraJudges(draft.extraJudges),
+        reasoningEffort:draft.reasoningEffort||undefined,
+        label:draft.label?.trim()||undefined,
+        cacheDir:resolveCacheDirOnSave(draft.cacheDir,values(loaded.settings).cacheDir),
+      }
+      const base=loaded.settings.base===undefined?undefined:record(loaded.settings.base)
+      const section=sectionForSave(record(loaded.settings.user),editable,base)
+      const res=await remote.settings.update(NS,section as never,loaded.settings.revision)
+      if(!res.ok)throw new Error(res.error.message)
+      setLoaded(v=>v?{...v,settings:res.value}:v);setDraft(values(res.value));setEditing({});setSaved(true)
+    }catch(e){setError(message(e))}finally{setBusy(false)}
+  }
   if(!loaded||!draft)return <div style={shell}><h2 style={settingsHeading}>{t['settings.title']}</h2><p style={settingsIntro}>{error??t['settings.loading']}</p>{error&&<div><Button variant="outline" onClick={()=>void load()}>{t['settings.retry']}</Button></div>}</div>
   // Fractional settings are typed character by character, so the raw text is
   // kept while the field has focus: a controlled type="number" input rewrites
@@ -275,7 +329,8 @@ export function VerifierSettings({ remote }: VerifierSettingsProps) {
     </section>
 
     {loaded.failures.length>0&&<div style={{padding:'10px 12px',borderRadius:8,background:'var(--dsw-alias-state-warn-bg)',color:'var(--dsw-alias-state-warn-label)',fontSize:12,lineHeight:'18px'}}><div style={{fontWeight:500,marginBottom:3}}>{t['settings.catalogFailures']}</div>{loaded.failures.map(x=><div key={x}>{x}</div>)}</div>}
-    {error&&<p style={{margin:0,fontSize:12,lineHeight:'18px',color:'var(--dsw-alias-state-error-primary)'}}>{error}</p>}{saved&&<p style={{margin:0,fontSize:12,lineHeight:'18px',color:'var(--dsw-alias-state-success-primary)'}}>{t['settings.saved']}</p>}
+    {error&&<p style={{margin:0,fontSize:12,lineHeight:'18px',color:'var(--dsw-alias-state-error-primary)'}}>{error}</p>}{saved&&!dirty&&<p style={{margin:0,fontSize:12,lineHeight:'18px',color:'var(--dsw-alias-state-success-primary)'}}>{t['settings.saved']}</p>}
+    {dirty&&<p style={{margin:0,fontSize:12,lineHeight:'18px',color:'var(--dsw-alias-state-warn-label)'}}>{t['settings.unsaved']}</p>}
     <div style={{display:'flex',justifyContent:'flex-end',gap:8,paddingTop:4}}><Button variant="outline" disabled={busy} onClick={()=>void load()}>{t['settings.reload']}</Button><Button variant="primary" disabled={busy||!loaded.writable||Boolean(conflict)} onClick={()=>void save()}>{busy?t['settings.saving']:t['settings.save']}</Button></div>
   </div>
 }
@@ -447,6 +502,8 @@ export function StatisticsPage({ sessionId, rpc, isGlobal }: StatisticsPageProps
                   {verdictInfo.outcomeText && <span style={{ padding: '1px 5px', borderRadius: 4, fontWeight: 500, fontSize: 11, background: verdictInfo.isFailed ? 'rgba(231,101,101,.16)' : item.verdict.outcome === 'tie' ? 'rgba(227,189,99,.16)' : 'rgba(89,201,133,.16)', color: verdictInfo.isFailed ? '#e76565' : item.verdict.outcome === 'tie' ? '#e3bd63' : '#77d49b', border: `1px solid ${verdictInfo.isFailed ? 'rgba(231,101,101,.3)' : item.verdict.outcome === 'tie' ? 'rgba(227,189,99,.3)' : 'rgba(89,201,133,.3)'}` }}>{verdictInfo.outcomeText}</span>}
                   {verdictInfo.phaseText && <span style={{ padding: '1px 5px', borderRadius: 4, background: 'var(--dsw-surface-sunken)', color: 'var(--dsw-text-secondary)', border: '1px solid var(--dsw-alias-border-l2, rgba(255,255,255,.1))' }}>{verdictInfo.phaseText}</span>}
                   {verdictInfo.scoreText && <span style={{ color: (typeof item.verdict.threshold === 'number' && typeof item.verdict.score === 'number' && item.verdict.score < item.verdict.threshold) ? '#e76565' : 'var(--dsw-text-primary)' }}>{verdictInfo.scoreText}</span>}
+                  {verdictInfo.checkpointsText && <span style={{ color: 'var(--dsw-text-secondary)' }}>{verdictInfo.checkpointsText}</span>}
+                  {verdictInfo.criteriaText && <span style={{ color: 'var(--dsw-text-secondary)' }}>{verdictInfo.criteriaText}</span>}
                   {verdictInfo.winnerText && <span style={{ color: 'var(--dsw-text-secondary)' }}>{verdictInfo.winnerText}</span>}
                 </div>}
               </div>

package/src/config.test.ts

@@ -411,8 +411,9 @@ describe('config - temperature', () => {
 describe('config - automatic verification repeats and budget', () => {
   it('scores routing once and the final acceptance twice by default', () => {
     const resolved = resolveConfig({})
-    // Routing stays a cheap single round; the gate that decides turn completion runs
-    // two rounds so the second one swaps A/B positions and cancels position bias.
+    // Routing stays a cheap single round in the config; only compare is rounded up to an
+    // even count at run time (it judges a single pair, so an odd count would leave the
+    // A/B order uncorrected). select and track keep the configured round.
     expect(resolved.autoVerifyRepeats).toBe(1)
     expect(resolved.autoVerifyFinalRepeats).toBe(2)
   })
@@ -427,7 +428,9 @@ describe('config - automatic verification repeats and budget', () => {
   })
 
   it('leaves headroom in the task model-call budget for the final acceptance', () => {
-    // 54 calls for an eight-candidate tournament + 6 for the final acceptance per judge.
+    // 54 calls for an eight-candidate tournament (one round; the engine orients each
+    // pair instead of doubling the rounds) + 6 for the final acceptance per judge.
     expect(resolveConfig({}).autoMaxModelCallsPerTask).toBe(96)
+    expect(resolveConfig({}).autoMaxModelCallsPerSession).toBe(240)
   })
 })

package/src/engine.test.ts

@@ -4,7 +4,8 @@ import { join } from 'node:path'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { VerifierClientConfig } from './caller.ts'
 import { ScoreCache, SingleFlight, type CachedPairScore } from './cache.ts'
-import { VerifierEngine } from './engine.ts'
+import { VerifierEngine, orientRoundPairs } from './engine.ts'
+import { pivotRoundPairs } from './core.ts'
 import { TopLogprobCapabilityCache } from './top-logprobs.ts'
 
 function chunks(text: string) { return [{ type: 'block-start', index: 0, blockType: 'text' }, { type: 'text-delta', index: 0, text }, { type: 'block-end', index: 0, block: { type: 'text', text } }, { type: 'usage', usage: { inputTokens: 7, cacheReadTokens: 3, outputTokens: 4, reasoningTokens: 2 } }, { type: 'finish', reason: { kind: 'stop' } }] as any[] }
@@ -72,6 +73,44 @@ describe('VerifierEngine tournament', () => {
   })
 })
 
+describe('pivot round orientation', () => {
+  it('gives every ring leader both slots instead of always trajectory B', () => {
+    // Regression: the pivot round emitted [candidate, pivot] for every edge, so the ring
+    // leaders sat in trajectory B in ALL their extra matches — a judge that merely
+    // prefers slot A then averaged 0.36 for the pivots against 0.60 for everyone else
+    // and pushed the leaders to the bottom of the final ranking.
+    const key = ([a, b]: readonly [number, number]) => (a < b ? a + ',' + b : b + ',' + a)
+    for (const count of [4, 5, 6, 8]) {
+      const pivots = [0, 1]
+      const raw = pivotRoundPairs(count, pivots)
+      const oriented = orientRoundPairs(raw)
+      // Same unordered pairs — only the presentation order may change.
+      expect(oriented).toHaveLength(raw.length)
+      expect(oriented.map(key).sort()).toEqual(raw.map(key).sort())
+      expect(new Set(oriented.map(key)).size).toBe(oriented.length)
+      const slotA = new Map<number, number>()
+      const slotB = new Map<number, number>()
+      for (const [a, b] of oriented) {
+        slotA.set(a, (slotA.get(a) ?? 0) + 1)
+        slotB.set(b, (slotB.get(b) ?? 0) + 1)
+      }
+      for (const pivot of pivots) {
+        const a = slotA.get(pivot) ?? 0
+        const b = slotB.get(pivot) ?? 0
+        expect(a, 'count=' + count + ' pivot=' + pivot + ' must not always sit in slot B').toBeGreaterThan(0)
+        expect(Math.abs(a - b), 'count=' + count + ' pivot=' + pivot + ' slot balance').toBeLessThanOrEqual(1)
+      }
+    }
+  })
+
+  it('leaves a two-candidate select with exactly one match', () => {
+    // The orientation must not invent or duplicate matches.
+    const oriented = orientRoundPairs([[0, 1]])
+    expect(oriented).toHaveLength(1)
+    expect([oriented[0]![0], oriented[0]![1]].sort()).toEqual([0, 1])
+  })
+})
+
 describe('VerifierEngine cache identity', () => {
   it('does not reuse an explicit-tag cache entry for top-logprobs scoring', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'dsh-verifier-engine-'))

package/src/engine.ts

@@ -60,6 +60,56 @@ function median(values: readonly number[]): number {
 function blankStats(): RunStats { return { ...emptyUsage(), cacheHits: 0, cacheMisses: 0, estimatedCostUsd: 0, topLogprobScores: 0, explicitTagScores: 0 } }
 function unorderedPair(a: number, b: number): string { return a < b ? a + ',' + b : b + ',' + a }
 
+/**
+ * Deterministic A/B slot for one pivot-round pair, balanced by construction.
+ *
+ * The round used to emit `[candidate, pivot]` for every edge, so the ring leaders sat
+ * in trajectory B in all of their extra matches: with a judge that merely prefers slot A
+ * the pivots averaged 0.36 against 0.60 for everyone else and sank in the final ranking.
+ * Alternating on the sum of the two RANKS — not the raw indices: the pivot set is
+ * selected by score, so its indices can share a parity and a parity rule would then
+ * handicap half the field — gives every pivot and every candidate both slots within one
+ * edge of each other, without a second model call.
+ *
+ * Deliberately NOT in core.ts: `pivotRoundPairs` is compared against the upstream Python
+ * reference in `parity.test.ts`, so the orientation stays an orchestration-side decision.
+ * @param pair - one unordered pair from the pivot round.
+ * @param pivotRanks - pivot index → its rank among the pivots.
+ * @param nonPivotRanks - candidate index → its rank among the non-pivots.
+ * @returns The pair in the order it should be presented.
+ */
+export function orientRoundPairs(pairs: readonly (readonly [number, number])[]): Array<[number, number]> {
+  const balance = new Map<number, number>()
+  return pairs.map(([a, b]) => {
+    const first = balance.get(a) ?? 0
+    const second = balance.get(b) ?? 0
+    // Slot A goes to whichever endpoint has held it less often; an equal count keeps the
+    // incoming order, so the result is deterministic for a given pair sequence.
+    const [x, y] = second < first ? [b, a] : [a, b]
+    balance.set(x, (balance.get(x) ?? 0) + 1)
+    balance.set(y, (balance.get(y) ?? 0) - 1)
+    return [x, y] as [number, number]
+  })
+}
+
+/**
+ * Arbitrary but fixed A/B slot for the single pair of a two-candidate select.
+ *
+ * There is only one match, so nothing can cancel a preference; the mix at least stops
+ * candidate 0 from always sitting in slot A. Real comparisons go through `compare`,
+ * where `routedRepeats` runs an even number of rounds instead.
+ * @param a - first candidate index of the pair.
+ * @param b - second candidate index of the pair.
+ * @returns The pair in the order it should be presented.
+ */
+function orientPair(a: number, b: number): [number, number] {
+  const lo = Math.min(a, b)
+  const hi = Math.max(a, b)
+  let mixed = Math.imul(lo + 1, 0x9e3779b1) ^ Math.imul(hi + 1, 0x85ebca77)
+  mixed = Math.imul(mixed ^ (mixed >>> 15), 0x2545f491)
+  return ((mixed ^ (mixed >>> 13)) & 1) === 0 ? [a, b] : [b, a]
+}
+
 function judgeLabel(client: VerifierClientConfig): string {
   return client.label?.trim() || client.provider + '/' + client.model
 }
@@ -422,10 +472,12 @@ export class VerifierEngine {
       return { index: 0, best: options.candidates[0]!, scores: [1], ranking: [0], pivots: [0], comparisons: 0, calls: 0, stats: blankStats(), judges }
     }
     if (options.candidates.length === 2) {
-      // ringCycle(2) would judge the single unordered pair in both directions; play it once.
-      const { rewards, judgeRewards, judgeOk, judgeErrors, judgeCalls, stats } = await this.scorePairs(options, [[0, 1]], signal)
+      // ringCycle(2) would judge the single unordered pair in both directions; play it
+      // once, in the orientation orientPair() picks so the slot is not always candidate 0.
+      const single = orientPair(0, 1)
+      const { rewards, judgeRewards, judgeOk, judgeErrors, judgeCalls, stats } = await this.scorePairs(options, [single], signal)
       const wins = [0, 0]; const counts = [0, 0]
-      accumulatePairs([[0, 1]], rewards, wins, counts)
+      accumulatePairs([single], rewards, wins, counts)
       const ranked = rankScores(wins, counts); const index = ranked[0]!.index
       const judges: JudgeScore[] = this.clients.map((client, k) => {
         const isOk = judgeOk[k]!
@@ -464,7 +516,7 @@ export class VerifierEngine {
     // pivot→neighbour edges). Dropping those duplicates keeps each unordered pair to a
     // single match so wins/counts are not double-weighted and no pair is judged twice.
     const ringPairs = new Set(ring.map(pair => unorderedPair(pair[0], pair[1])))
-    const rounds = pivotRoundPairs(options.candidates.length, pivots).filter(pair => !ringPairs.has(unorderedPair(pair[0], pair[1])))
+    const rounds = orientRoundPairs(pivotRoundPairs(options.candidates.length, pivots).filter(pair => !ringPairs.has(unorderedPair(pair[0], pair[1]))))
     const roundScores = await this.scorePairs(options, rounds, signal)
     const allRewards = new Map([...ringScores.rewards, ...roundScores.rewards])
     const wins = new Array<number>(options.candidates.length).fill(0)