@ljwei-stak/model-router-galgame 0.4.30 → 0.4.32

package/.dsh-plugin/index.mjs

@@ -6,6 +6,7 @@ import {
   DEFAULT_ROUTER_SETTINGS,
   MODEL_ROUTER_SETTINGS_NAMESPACE,
   nextCollaborationStage,
+  selectReasoningEffort,
   textFromMessages,
 } from './shared/router.mjs'
 import { formatErrorChain } from './shared/error-diagnostics.mjs'
@@ -116,6 +117,7 @@ function stateFor(agent) {
       directoryPromise: null,
       turn: null,
       failedModels: new Set(),
+      routeCooldowns: new Map(),
       lastTarget: null,
       lastStep: 0,
       collaboration: null,
@@ -158,14 +160,29 @@ async function discover(ctx, state) {
       }
       try {
         const models = await ctx.llm.listModels(provider.id)
-        for (const model of models) {
-          const inputModalities = model.inputModalities ?? model.input ?? []
-          routes.push({
+        const resolvedRoutes = await Promise.all(models.map(async model => {
+          let resolved
+          try {
+            resolved = typeof ctx.llm.resolveModelInfo === 'function'
+              ? await ctx.llm.resolveModelInfo(provider.id, model.id)
+              : undefined
+          } catch (error) {
+            ctx.logger?.debug?.(`model-router: reasoning metadata unavailable for ${provider.id}/${model.id}: ${String(error)}`)
+          }
+          const inputModalities = resolved?.inputModalities ?? model.inputModalities ?? model.input ?? []
+          const reasoning = resolved?.reasoning
+          return {
             provider: provider.id,
             model: model.id,
             inputModalities: Array.isArray(inputModalities) ? [...inputModalities] : [],
-          })
-        }
+            ...(resolved === undefined ? {} : {
+              reasoningKnown: true,
+              reasoningEfforts: Array.isArray(reasoning?.efforts) ? reasoning.efforts.map(effort => effort.id) : [],
+              ...(reasoning?.defaultEffort === undefined ? {} : { defaultReasoningEffort: reasoning.defaultEffort }),
+            }),
+          }
+        }))
+        routes.push(...resolvedRoutes)
       } catch (error) {
         ctx.logger?.debug?.(`model-router: model discovery failed for ${provider.id}: ${String(error)}`)
       }
@@ -290,8 +307,8 @@ function analysisMessage(plan) {
     '[Model Router 路由分析]',
     `任务类型：${plan.taskType}；复杂度：${plan.complexity?.band ?? 'unknown'}（${Math.round((plan.complexity?.value ?? 0) * 100)}%）`,
     Array.isArray(plan.taskTypes) && plan.taskTypes.length > 1 ? `业务方向：${plan.taskTypes.join('、')}（分别建立执行工作包）` : '',
-    `本轮权重：质量 ${Math.round((weights.quality ?? 0) * 100)}%，成本 ${Math.round((weights.cost ?? 0) * 100)}%，延迟 ${Math.round((weights.latency ?? 0) * 100)}%，专长 ${Math.round((weights.specialty ?? 0) * 100)}%，风险 ${Math.round((weights.risk ?? 0) * 100)}%`,
-    `质量下限：${Math.round(Number(plan.optimization?.qualityFloor ?? 0) * 100)}%；首选路由：${selected}`,
+    `本轮权重：质量 ${Math.round((weights.quality ?? 0) * 100)}%，成本 ${Math.round((weights.cost ?? 0) * 100)}%，推理等级 ${Math.round((weights.reasoning ?? 0) * 100)}%，延迟 ${Math.round((weights.latency ?? 0) * 100)}%，专长 ${Math.round((weights.specialty ?? 0) * 100)}%，风险 ${Math.round((weights.risk ?? 0) * 100)}%`,
+    `质量下限：${Math.round(Number(plan.optimization?.qualityFloor ?? 0) * 100)}%；首选路由：${selected}${plan.selected?.reasoningEffort ? `；推理等级：${plan.selected.reasoningEffort}` : '；推理等级：提供方默认'}`,
     `预计总费用：$${Number(plan.estimatedCost ?? 0).toFixed(6)}；相对全高质量基线节省：$${Number((plan.optimization?.baselineAllStrongCost ?? 0) - (plan.estimatedCost ?? 0)).toFixed(6)}`,
     `缓存计费比例：读取 ${Math.round(Number(plan.optimization?.cacheReadRatio ?? 0) * 100)}%，写入 ${Math.round(Number(plan.optimization?.cacheWriteRatio ?? 0) * 100)}%（未填写时按普通输入计费）`,
     Number(plan.optimization?.budgetUsd ?? 0) > 0 ? `预算上限：$${Number(plan.optimization.budgetUsd).toFixed(6)}；${plan.optimization.budgetExceeded ? '仍超预算，已在质量下限内尽量压缩' : '满足预算约束'}` : '',
@@ -327,17 +344,43 @@ function routeKey(provider, model) {
 }
 
 function modelFallbackError(failure) {
-  const text = `${String(failure?.code ?? '')} ${String(failure?.message ?? '')}`.toLowerCase()
-  return /region|not available|not supported|freeusagelimit|rate limit|too many requests|\b(?:403|404|429)\b/.test(text)
+  const text = `${String(failure?.code ?? '')} ${String(failure?.message ?? '')} ${formatErrorChain(failure)}`.toLowerCase()
+  return /unsupported[_ -]reasoning[_ -]effort|no[_ -]adapter|invalid[_ -]model|invalid[_ -]credential|missing[_ -]credential|auth(?:entication|orization)?|api key|quota|region|not available|not supported|unsupported provider stream event|provider protocol|invalid (?:stream|event)|codex\.rate_limits|freeusagelimit|rate limit|too many requests|\b(?:401|403|404|429)\b/.test(text)
+}
+
+function failureCooldownMs(failure) {
+  const text = `${String(failure?.code ?? '')} ${String(failure?.message ?? '')} ${formatErrorChain(failure)}`.toLowerCase()
+  const requested = Number(failure?.retryAfterMs)
+  if (Number.isFinite(requested) && requested > 0) return Math.min(Math.max(requested, 30000), 30 * 60 * 1000)
+  if (/auth|api key|credential|\b401\b/.test(text)) return 30 * 60 * 1000
+  if (/unsupported provider stream event|provider protocol|codex\.rate_limits/.test(text)) return 10 * 60 * 1000
+  return 2 * 60 * 1000
+}
+
+function routeTemporarilyUnavailable(state, key) {
+  if (state.failedModels.has(key)) return true
+  const deadline = Number(state.routeCooldowns.get(key) ?? 0)
+  if (deadline <= Date.now()) {
+    state.routeCooldowns.delete(key)
+    return false
+  }
+  return true
 }
 
-function nextAvailableTarget(state) {
+function nextAvailableTarget(state, step = state.lastStep) {
   const candidates = Array.isArray(state.plan?.candidates) ? state.plan.candidates : []
+  const assignment = state.plan?.subtasks?.[Math.max(0, Number(step || 1) - 1)]
+  const preferredEffort = assignment?.preferredReasoningEffort ?? assignment?.recommendedReasoningEffort ?? 'medium'
   for (const candidate of candidates) {
     const key = routeKey(candidate.provider, candidate.model)
-    if (state.failedModels.has(key)) continue
+    if (routeTemporarilyUnavailable(state, key)) continue
     const route = state.available.find(entry => entry.provider === candidate.provider && entry.model === candidate.model)
-    if (route !== undefined) return route
+    if (route !== undefined) {
+      return {
+        ...route,
+        reasoningEffort: selectReasoningEffort(route.reasoningEfforts, preferredEffort),
+      }
+    }
   }
   return null
 }
@@ -542,6 +585,7 @@ export function apply(ctx) {
   ctx.on('llm/adapters-updated', () => {
     for (const state of allStates) {
       state.directoryPromise = null
+      state.routeCooldowns.clear()
     }
     void scheduleOpenCodeRepair()
   })
@@ -593,9 +637,11 @@ export function apply(ctx) {
       await routerSettingsPromise
       state.taskText = inputText(messages)
       const liveBench = await liveBenchFor(ctx, state)
+      const readyRoutes = available.filter(route => !routeTemporarilyUnavailable(state, routeKey(route.provider, route.model)))
+      const routable = readyRoutes.length > 0 ? readyRoutes : available
       const plan = buildPlan({
         text: state.taskText,
-        available,
+        available: routable,
         mode: state.mode,
         pricing: routerSettings.pricing,
         liveBench,
@@ -614,7 +660,7 @@ export function apply(ctx) {
           failSafe: true,
         },
       }
-      state.collaboration = shouldCollaborate(state.plan, available)
+      state.collaboration = shouldCollaborate(state.plan, routable)
         ? { lastStep: 0, queuedStep: null }
         : null
     }
@@ -656,7 +702,7 @@ export function apply(ctx) {
       const assignedRoute = state.available.find(route => route.provider === assignment?.recommendedProvider && route.model === assignment?.recommended)
         ?? state.available.find(route => route.model === assignment?.recommended)
       if (assignedRoute !== undefined) {
-        target = { provider: assignedRoute.provider, model: assignedRoute.model, estimatedCost: target.estimatedCost }
+        target = { provider: assignedRoute.provider, model: assignedRoute.model, reasoningEffort: assignment?.recommendedReasoningEffort, estimatedCost: target.estimatedCost }
       }
       // The final subtask is the public answer synthesis. Prefer the user's
       // requested DeepSeek V4 Pro when it is actually available; otherwise the
@@ -665,14 +711,14 @@ export function apply(ctx) {
       if (assignment?.purpose === 'synthesis' && synthesis?.provider && synthesis?.model) {
         const synthesisRoute = state.available.find(route => route.provider === synthesis.provider && route.model === synthesis.model)
         if (synthesisRoute !== undefined) {
-          target = { provider: synthesisRoute.provider, model: synthesisRoute.model, estimatedCost: target.estimatedCost }
+          target = { provider: synthesisRoute.provider, model: synthesisRoute.model, reasoningEffort: synthesis.reasoningEffort, estimatedCost: target.estimatedCost }
         }
       }
     }
-    if (state.failedModels.has(routeKey(target.provider, target.model))) {
-      const fallback = nextAvailableTarget(state)
+    if (routeTemporarilyUnavailable(state, routeKey(target.provider, target.model))) {
+      const fallback = nextAvailableTarget(state, step)
       if (fallback !== null) {
-        target = { provider: fallback.provider, model: fallback.model, estimatedCost: target.estimatedCost }
+        target = { provider: fallback.provider, model: fallback.model, reasoningEffort: fallback.reasoningEffort, estimatedCost: target.estimatedCost }
       }
     }
     const plannedProvider = target.provider
@@ -682,12 +728,15 @@ export function apply(ctx) {
       visionBridges: state.visionBridges,
       hasImageBlocks: state.hasImageBlocks,
     })
-    state.lastTarget = { provider: target.provider, model: target.model, plannedProvider }
+    state.lastTarget = { provider: target.provider, model: target.model, reasoningEffort: target.reasoningEffort, plannedProvider }
     state.lastStep = step
     // Keep all non-routing request fields intact. If a route disappeared after
     // discovery, the LLM runtime will validate the proposal and the original
     // model remains available on the next step.
-    return { ...proposed, provider: target.provider, model: target.model }
+    const routed = { ...proposed, provider: target.provider, model: target.model }
+    if (target.reasoningEffort === undefined) delete routed.reasoningEffort
+    else routed.reasoningEffort = target.reasoningEffort
+    return routed
   })
 
   // A completed work step would normally close the turn immediately. Queue the
@@ -710,23 +759,29 @@ export function apply(ctx) {
   ctx.on('agent/request-error', async ({ agent, provider, failure, signal }, next) => {
     const state = stateFor(agent)
     if (signal?.aborted || state.mode !== 'collective' || !modelFallbackError(failure)) return next()
-    const failed = state.lastTarget?.provider === provider ? state.lastTarget : null
+    const failed = state.lastTarget !== null && (provider === undefined || provider === null || state.lastTarget.provider === provider) ? state.lastTarget : null
     if (failed === null) return next()
-    state.failedModels.add(routeKey(failed.plannedProvider ?? failed.provider, failed.model))
-    const fallback = nextAvailableTarget(state)
+    const failedKey = routeKey(failed.plannedProvider ?? failed.provider, failed.model)
+    state.failedModels.add(failedKey)
+    state.routeCooldowns.set(failedKey, Date.now() + failureCooldownMs(failure))
+    const fallback = nextAvailableTarget(state, state.lastStep)
     if (fallback === null) return next()
     if (state.plan !== null) {
       const plan = state.plan
       const failedStage = plan.subtasks?.[Math.max(0, state.lastStep - 1)]
+      const failedStageIndex = Math.max(0, state.lastStep - 1)
       const isSynthesisFailure = failedStage?.purpose === 'synthesis'
+      const subtasks = Array.isArray(plan.subtasks)
+        ? plan.subtasks.map((task, index) => index === failedStageIndex
+          ? { ...task, recommendedProvider: fallback.provider, recommended: fallback.model, recommendedReasoningEffort: fallback.reasoningEffort }
+          : task)
+        : plan.subtasks
       state.plan = {
         ...plan,
-        ...(plan.selected === null ? {} : { selected: { ...plan.selected, provider: fallback.provider, model: fallback.model } }),
+        ...(plan.selected === null ? {} : { selected: { ...plan.selected, provider: fallback.provider, model: fallback.model, reasoningEffort: fallback.reasoningEffort } }),
+        subtasks,
         ...(isSynthesisFailure ? {
-          synthesizer: { provider: fallback.provider, model: fallback.model },
-          subtasks: plan.subtasks.map((task, index) => index === plan.subtasks.length - 1
-            ? { ...task, recommendedProvider: fallback.provider, recommended: fallback.model }
-            : task),
+          synthesizer: { provider: fallback.provider, model: fallback.model, reasoningEffort: fallback.reasoningEffort },
         } : {}),
       }
     }

package/.dsh-plugin/shared/gal-story-v2-phase3.mjs

@@ -293,10 +293,10 @@ const CHAPTER_MUSIC = Object.freeze({
   prologue: 'title-city',
   'open-day': 'commons-atelier',
   laurel: 'claude-poem',
-  'bridges-night': 'bridge-anomaly',
+  'bridges-night': 'kimi-flute',
   'three-harbors': 'harbor-shift',
   'open-dome-hearing': 'glass-dome',
-  'protocol-composition': 'bridge-anomaly',
+  'protocol-composition': 'glass-dome',
   'six-endings': 'title-city',
 })
 
@@ -317,16 +317,20 @@ function routeForNode(node) {
 export function storyPresentationFor(node) {
   const route = routeForNode(node)
   const backgroundId = route?.backgroundId || node.chapterId
-  const musicTheme = route?.musicTheme || CHAPTER_MUSIC[node.chapterId] || 'title-city'
+  const bridgeCrisis = node.chapterId === 'bridges-night' && /^(incident|cut|isolate|evidence|trace|report)-/.test(node.id)
+  const bridgeAftercare = node.chapterId === 'bridges-night' && /^after-/.test(node.id)
+  const compositionAudit = node.chapterId === 'protocol-composition' && /^composition-audit-/.test(node.id)
+  const musicTheme = route?.musicTheme
+    || (bridgeCrisis || compositionAudit ? 'bridge-anomaly' : bridgeAftercare ? 'claude-poem' : null)
+    || CHAPTER_MUSIC[node.chapterId]
+    || 'title-city'
   let soundCue = null
   const text = typeof node.text === 'string' ? node.text : ''
-  if (node.chapterId === 'bridges-night') {
-    soundCue = Object.freeze({ id: 'bridge-anomaly', label: '节奏异常', description: '节拍与回执时间没有对齐；这处不协和可能属于千桥事故证据链。' })
-  } else if (node.speaker === 'kimi' || /长笛|完整录音|缺拍/.test(text)) {
+  if (node.speaker === 'kimi' || /长笛|完整录音|缺拍/.test(text)) {
     soundCue = Object.freeze({ id: 'kimi-flute', label: '长笛线索', description: '同一段长笛再次出现；留意旋律中的停顿和它前后的语境。' })
   } else if (node.speaker === 'claude' && /桥|诗|下一行|署名|空白/.test(text)) {
     soundCue = Object.freeze({ id: 'claude-verse', label: '诗句线索', description: 'Claude 的未完成诗句再次出现；这次由她自己决定下一行是否存在。' })
-  } else if (/事故录音|第九秒|节拍|拍号冲突|时钟/.test(text)) {
+  } else if (bridgeCrisis || /事故录音|第九秒|节拍|拍号冲突|时钟/.test(text)) {
     soundCue = Object.freeze({ id: 'bridge-anomaly', label: '节奏异常', description: '节拍与回执时间没有对齐；这处不协和可能属于千桥事故证据链。' })
   }
   return Object.freeze({ backgroundId, musicTheme, soundCue })

package/.dsh-plugin/shared/router.mjs

@@ -9,9 +9,22 @@
 import { liveBenchRow } from './livebench.mjs'
 
 export const OBJECTIVE_WEIGHTS = Object.freeze({
-  simple: Object.freeze({ quality: 0.30, cost: 0.50, latency: 0.14, specialty: 0.04, risk: 0.02 }),
-  balanced: Object.freeze({ quality: 0.45, cost: 0.30, latency: 0.10, specialty: 0.10, risk: 0.05 }),
-  complex: Object.freeze({ quality: 0.55, cost: 0.16, latency: 0.06, specialty: 0.16, risk: 0.07 }),
+  simple: Object.freeze({ quality: 0.28, cost: 0.45, latency: 0.14, specialty: 0.04, reasoning: 0.07, risk: 0.02 }),
+  balanced: Object.freeze({ quality: 0.40, cost: 0.26, latency: 0.10, specialty: 0.09, reasoning: 0.10, risk: 0.05 }),
+  complex: Object.freeze({ quality: 0.48, cost: 0.14, latency: 0.06, specialty: 0.14, reasoning: 0.11, risk: 0.07 }),
+})
+
+/** Canonical order used only to compare adapter-owned opaque effort ids. */
+export const REASONING_EFFORT_ORDER = Object.freeze(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
+const REASONING_EFFORT_MULTIPLIERS = Object.freeze({
+  off: Object.freeze({ output: 0.78, latency: 0.75 }),
+  minimal: Object.freeze({ output: 0.86, latency: 0.82 }),
+  low: Object.freeze({ output: 0.93, latency: 0.90 }),
+  medium: Object.freeze({ output: 1, latency: 1 }),
+  high: Object.freeze({ output: 1.16, latency: 1.15 }),
+  xhigh: Object.freeze({ output: 1.34, latency: 1.30 }),
+  max: Object.freeze({ output: 1.58, latency: 1.50 }),
 })
 
 /** Quality floor for a task node before a cost-saving substitution is allowed. */
@@ -328,6 +341,7 @@ function taskTokenBudget(text, task, complexity, cacheReadRatio = 0, cacheWriteR
     synthesis: { input: 1.65, output: 1.30 },
   }
   const multiplier = multipliers[task.purpose] ?? { input: 1, output: 1 }
+  const effortMultiplier = reasoningEffortMultiplier(task.reasoningEffort)
   const totalInputTokens = Math.max(80, Math.round(inputTokens * multiplier.input))
   const ratios = normalizedCacheRatios(cacheReadRatio, cacheWriteRatio)
   const cacheReadTokens = Math.min(totalInputTokens, Math.max(0, Math.round(totalInputTokens * ratios.read)))
@@ -336,7 +350,7 @@ function taskTokenBudget(text, task, complexity, cacheReadRatio = 0, cacheWriteR
     inputTokens: totalInputTokens,
     cacheReadTokens,
     cacheWriteTokens,
-    outputTokens: Math.max(220, Math.round(900 * multiplier.output)),
+    outputTokens: Math.max(220, Math.round(900 * multiplier.output * effortMultiplier.output)),
   }
 }
 
@@ -349,12 +363,12 @@ function taskQualityFloor(band, task) {
 
 function taskPackages(taskType, text, band) {
   if (band !== 'complex') {
-    const task = { id: 'execution', name: '直接回答与必要校验', type: taskType, purpose: 'execution', criticality: 0.65, dependsOn: [] }
+    const task = { id: 'execution', name: '直接回答与必要校验', type: taskType, purpose: 'execution', criticality: 0.65, dependsOn: [], preferredReasoningEffort: band === 'simple' ? 'low' : 'medium' }
     return [{ ...task, qualityFloor: taskQualityFloor(band, task) }]
   }
   const value = String(text ?? '')
   const packages = [
-    { id: 'analysis', name: '问题建模与约束提取', type: 'reasoning', purpose: 'analysis', criticality: 0.92, dependsOn: [] },
+    { id: 'analysis', name: '问题建模与约束提取', type: 'reasoning', purpose: 'analysis', criticality: 0.92, dependsOn: [], preferredReasoningEffort: 'high' },
   ]
   const domains = [...new Set([...(detectTaskTypes(text)), taskType].filter(type => type !== 'general'))]
   for (const type of domains.length > 0 ? domains : [taskType]) {
@@ -365,6 +379,7 @@ function taskPackages(taskType, text, band) {
       purpose: 'execution',
       criticality: domains.length > 1 ? 0.80 : 0.78,
       dependsOn: ['analysis'],
+      preferredReasoningEffort: 'high',
     })
   }
   if (/(测试|验证|评估|对比|benchmark|test|verify|audit)/i.test(value)) {
@@ -375,6 +390,7 @@ function taskPackages(taskType, text, band) {
       purpose: 'verification',
       criticality: 0.88,
       dependsOn: packages.filter(task => task.purpose === 'execution').map(task => task.id),
+      preferredReasoningEffort: 'high',
     })
   }
   packages.push({
@@ -384,11 +400,12 @@ function taskPackages(taskType, text, band) {
     purpose: 'synthesis',
     criticality: 1,
     dependsOn: packages.filter(task => task.purpose !== 'analysis').map(task => task.id),
+    preferredReasoningEffort: 'xhigh',
   })
   return packages.map(task => ({ ...task, qualityFloor: taskQualityFloor(band, task) }))
 }
 
-const SYNTHESIS_WEIGHTS = Object.freeze({ quality: 0.70, cost: 0.10, latency: 0.04, specialty: 0.10, risk: 0.06 })
+const SYNTHESIS_WEIGHTS = Object.freeze({ quality: 0.58, cost: 0.08, latency: 0.04, specialty: 0.08, reasoning: 0.16, risk: 0.06 })
 const ROUTING_BEAM_WIDTH = 256
 const ROUTING_CANDIDATE_LIMIT = 12
 
@@ -406,22 +423,78 @@ function compareRowsStable(left, right) {
   return compareText(routeKey(left.provider, left.model), routeKey(right.provider, right.model))
 }
 
+function reasoningEffortRank(effort) {
+  const normalized = String(effort ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '')
+  const aliases = { none: 'off', disabled: 'off', extra: 'xhigh', extrahigh: 'xhigh', maximum: 'max' }
+  const canonical = aliases[normalized] ?? normalized
+  const index = REASONING_EFFORT_ORDER.indexOf(canonical)
+  return index < 0 ? REASONING_EFFORT_ORDER.indexOf('medium') : index
+}
+
+function reasoningEffortMultiplier(effort) {
+  const normalized = String(effort ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '')
+  const aliases = { none: 'off', disabled: 'off', extra: 'xhigh', extrahigh: 'xhigh', maximum: 'max' }
+  return REASONING_EFFORT_MULTIPLIERS[aliases[normalized] ?? normalized] ?? REASONING_EFFORT_MULTIPLIERS.medium
+}
+
+/** Pick the closest exact effort id exposed by an adapter. */
+export function selectReasoningEffort(efforts, preferred = 'medium') {
+  const exact = Array.isArray(efforts)
+    ? [...new Set(efforts.map(effort => String(effort?.id ?? effort ?? '')).filter(Boolean))]
+    : []
+  if (exact.length === 0) return undefined
+  const preferredRank = reasoningEffortRank(preferred)
+  return exact.slice().sort((left, right) => {
+    const distance = Math.abs(reasoningEffortRank(left) - preferredRank) - Math.abs(reasoningEffortRank(right) - preferredRank)
+    if (distance !== 0) return distance
+    return reasoningEffortRank(left) - reasoningEffortRank(right) || compareText(left, right)
+  })[0]
+}
+
+function reasoningDecision(row, task) {
+  const preferred = String(task.preferredReasoningEffort ?? 'medium')
+  const efforts = Array.isArray(row.reasoningEfforts) ? row.reasoningEfforts : []
+  if (efforts.length === 0) {
+    const knownUnsupported = row.reasoningKnown === true
+    const preferredRank = reasoningEffortRank(preferred)
+    return {
+      reasoningEffort: undefined,
+      reasoningFit: knownUnsupported ? clamp(0.78 - preferredRank * 0.08) : 0.55,
+      preferredReasoningEffort: preferred,
+      multiplier: REASONING_EFFORT_MULTIPLIERS.medium,
+    }
+  }
+  const preferredRank = reasoningEffortRank(preferred)
+  // On an equal distance the shared selector prefers the lower effort to
+  // avoid unnecessary latency and output-token cost.
+  const chosen = selectReasoningEffort(efforts, preferred)
+  const distance = Math.abs(reasoningEffortRank(chosen) - preferredRank)
+  return {
+    reasoningEffort: chosen,
+    reasoningFit: clamp(1 - distance / (REASONING_EFFORT_ORDER.length - 1)),
+    preferredReasoningEffort: preferred,
+    multiplier: reasoningEffortMultiplier(chosen),
+  }
+}
+
 function candidateUtility(row, task, weights, maxCost, usedRoutes, cacheReadRatio = 0, cacheWriteRatio = 0) {
   const quality = qualityForTask(row, task.type)
   const floor = Number(task.qualityFloor ?? taskQualityFloor('complex', task))
   const qualityGap = Math.max(0, floor - quality)
   const duplicatePenalty = usedRoutes.has(routeKey(row.provider, row.model)) ? 0.08 : 0
   const synthesisPreference = task.purpose === 'synthesis' && /deepseek[- ]?v4[- ]?pro/i.test(row.model) ? 0.025 : 0
-  const cost = costScore(row.pricing, maxCost, cacheReadRatio, cacheWriteRatio)
+  const reasoning = reasoningDecision(row, task)
+  const cost = clamp(costScore(row.pricing, maxCost, cacheReadRatio, cacheWriteRatio) / Math.sqrt(reasoning.multiplier.output))
   const score = weights.quality * quality
     + weights.cost * cost
-    + weights.latency * (1 - clamp(row.latency))
+    + weights.latency * (1 - clamp(row.latency * reasoning.multiplier.latency))
     + weights.specialty * specialtyForTask(row, task.type)
+    + (weights.reasoning ?? 0) * reasoning.reasoningFit
     - weights.risk * row.risk
     - duplicatePenalty
     - qualityGap * (task.criticality ?? 0.75)
     + synthesisPreference
-  return { score, floor, qualityGap }
+  return { score, floor, qualityGap, ...reasoning }
 }
 
 function chooseAssignment(rows, task, weights, maxCost, usedRoutes, preferred, cacheReadRatio = 0, cacheWriteRatio = 0) {
@@ -437,7 +510,8 @@ function chooseAssignment(rows, task, weights, maxCost, usedRoutes, preferred, c
 }
 
 function taskCost(row, task, text, complexity, cacheReadRatio = 0, cacheWriteRatio = 0) {
-  const tokens = taskTokenBudget(text, task, complexity, cacheReadRatio, cacheWriteRatio)
+  const decision = row === null ? null : reasoningDecision(row, task)
+  const tokens = taskTokenBudget(text, { ...task, reasoningEffort: decision?.reasoningEffort }, complexity, cacheReadRatio, cacheWriteRatio)
   return row === null
     ? 0
     : (((tokens.inputTokens - tokens.cacheReadTokens - tokens.cacheWriteTokens) * row.pricing.input)
@@ -447,29 +521,35 @@ function taskCost(row, task, text, complexity, cacheReadRatio = 0, cacheWriteRat
 }
 
 function dominates(left, right, task, text, complexity, cacheReadRatio, cacheWriteRatio) {
+  const leftReasoning = reasoningDecision(left, task)
+  const rightReasoning = reasoningDecision(right, task)
   const leftValues = {
     quality: qualityForTask(left, task.type),
     cost: taskCost(left, task, text, complexity, cacheReadRatio, cacheWriteRatio),
-    latency: clamp(left.latency),
+    latency: clamp(left.latency * leftReasoning.multiplier.latency),
     specialty: specialtyForTask(left, task.type),
+    reasoning: leftReasoning.reasoningFit,
     risk: clamp(left.risk),
   }
   const rightValues = {
     quality: qualityForTask(right, task.type),
     cost: taskCost(right, task, text, complexity, cacheReadRatio, cacheWriteRatio),
-    latency: clamp(right.latency),
+    latency: clamp(right.latency * rightReasoning.multiplier.latency),
     specialty: specialtyForTask(right, task.type),
+    reasoning: rightReasoning.reasoningFit,
     risk: clamp(right.risk),
   }
   const noWorse = leftValues.quality >= rightValues.quality
     && leftValues.cost <= rightValues.cost
     && leftValues.latency <= rightValues.latency
     && leftValues.specialty >= rightValues.specialty
+    && leftValues.reasoning >= rightValues.reasoning
     && leftValues.risk <= rightValues.risk
   const strictlyBetter = leftValues.quality > rightValues.quality
     || leftValues.cost < rightValues.cost
     || leftValues.latency < rightValues.latency
     || leftValues.specialty > rightValues.specialty
+    || leftValues.reasoning > rightValues.reasoning
     || leftValues.risk < rightValues.risk
   return noWorse && strictlyBetter
 }
@@ -504,7 +584,7 @@ function candidatePool(rows, task, weights, maxCost, text, complexity, cacheRead
 }
 
 function stateSignature(state) {
-  return state.assignments.map(assignment => routeKey(assignment.row?.provider, assignment.row?.model)).join('|')
+  return state.assignments.map(assignment => `${routeKey(assignment.row?.provider, assignment.row?.model)}@${assignment.decision?.reasoningEffort ?? 'provider-default'}`).join('|')
 }
 
 function compareUtilityStates(left, right) {
@@ -585,7 +665,17 @@ export function buildPlan({ text = '', available = [], mode = 'collective', pric
   const taskType = classifyTask(text)
   const weights = OBJECTIVE_WEIGHTS[complexity.band]
   const discovered = Array.isArray(available)
-    ? available.map(entry => ({ provider: String(entry.provider ?? ''), model: String(entry.model ?? '') }))
+    ? available.map(entry => {
+        const rawEfforts = Array.isArray(entry.reasoningEfforts) ? entry.reasoningEfforts : []
+        const reasoningEfforts = rawEfforts.map(effort => String(effort?.id ?? effort ?? '')).filter(Boolean)
+        return {
+          provider: String(entry.provider ?? ''),
+          model: String(entry.model ?? ''),
+          reasoningEfforts: [...new Set(reasoningEfforts)],
+          defaultReasoningEffort: entry.defaultReasoningEffort === undefined ? undefined : String(entry.defaultReasoningEffort),
+          reasoningKnown: entry.reasoningKnown === true || Array.isArray(entry.reasoningEfforts),
+        }
+      })
     : []
   const rows = []
   const normalizedPrices = normalizePricing(pricing)
@@ -618,6 +708,9 @@ export function buildPlan({ text = '', available = [], mode = 'collective', pric
       latency: metadata.latency,
       risk: metadata.risk,
       specialty,
+      reasoningEfforts: route.reasoningEfforts,
+      defaultReasoningEffort: route.defaultReasoningEffort,
+      reasoningKnown: route.reasoningKnown,
       pricing: pricingRow,
       score: 0,
       estimatedCost: estimateCost(metadata, text, 900, normalizedPrices, cacheReadRatio, cacheWriteRatio),
@@ -671,27 +764,36 @@ export function buildPlan({ text = '', available = [], mode = 'collective', pric
     row.score = candidateUtility(row, taskNodes[0] ?? { type: taskType, qualityFloor: QUALITY_FLOORS[complexity.band] }, weights, maxCost, new Set(), cacheReadRatio, cacheWriteRatio).score
   }
   rows.sort((left, right) => right.score - left.score || compareRowsStable(left, right))
-  const selected = assignments[0]?.row ?? rows[0] ?? null
-  const synthesizer = assignments.at(-1)?.row ?? rows.find(row => /deepseek/i.test(row.model)) ?? rows[0]
-  const subtasks = assignments.map(({ task, row }) => ({
+  const selectedAssignment = assignments[0]
+  const selected = selectedAssignment?.row ?? rows[0] ?? null
+  const synthesizerAssignment = assignments.at(-1)
+  const synthesizer = synthesizerAssignment?.row ?? rows.find(row => /deepseek/i.test(row.model)) ?? rows[0]
+  const subtasks = assignments.map(({ task, row, decision }) => ({
     id: task.id,
     name: task.name,
     type: task.type,
     recommended: row?.model ?? '待发现模型',
     recommendedProvider: row?.provider ?? '',
+    recommendedReasoningEffort: decision?.reasoningEffort,
+    preferredReasoningEffort: decision?.preferredReasoningEffort ?? task.preferredReasoningEffort,
+    reasoningFit: Number(Number(decision?.reasoningFit ?? 0).toFixed(3)),
     purpose: task.purpose,
     criticality: task.criticality,
     qualityFloor: Number(task.qualityFloor.toFixed(3)),
     dependsOn: [...(task.dependsOn ?? [])],
   }))
-  const costBreakdown = assignments.map(({ task, row, estimatedCost, handoffPenalty }, index) => {
-    const tokens = taskTokenBudget(text, task, complexity.band, cacheReadRatio, cacheWriteRatio)
+  const costBreakdown = assignments.map(({ task, row, decision, estimatedCost, handoffPenalty }, index) => {
+    const tokens = taskTokenBudget(text, { ...task, reasoningEffort: decision?.reasoningEffort }, complexity.band, cacheReadRatio, cacheWriteRatio)
     const taskEstimate = estimatedCost ?? taskCost(row, task, text, complexity.band, cacheReadRatio, cacheWriteRatio)
     return {
       stage: index + 1,
       purpose: task.purpose,
       model: row?.model ?? '待发现模型',
       provider: row?.provider ?? '',
+      reasoningEffort: decision?.reasoningEffort,
+      preferredReasoningEffort: decision?.preferredReasoningEffort,
+      reasoningFit: Number(Number(decision?.reasoningFit ?? 0).toFixed(3)),
+      reasoningOutputMultiplier: Number(Number(decision?.multiplier?.output ?? 1).toFixed(2)),
       inputTokens: tokens.inputTokens,
       cacheReadTokens: tokens.cacheReadTokens,
       cacheWriteTokens: tokens.cacheWriteTokens,
@@ -704,11 +806,7 @@ export function buildPlan({ text = '', available = [], mode = 'collective', pric
   const totalEstimate = costBreakdown.reduce((sum, row) => sum + row.estimatedCost, 0)
   const baselineCost = assignments.reduce((sum, { task }) => {
     const strongest = rows.reduce((best, row) => qualityForTask(row, task.type) > (best === null ? -1 : qualityForTask(best, task.type)) ? row : best, null)
-    const tokens = taskTokenBudget(text, task, complexity.band, cacheReadRatio, cacheWriteRatio)
-    return sum + (strongest === null ? 0 : (((tokens.inputTokens - tokens.cacheReadTokens - tokens.cacheWriteTokens) * strongest.pricing.input)
-      + (tokens.cacheReadTokens * strongest.pricing.cacheRead)
-      + (tokens.cacheWriteTokens * strongest.pricing.cacheWrite)
-      + (tokens.outputTokens * strongest.pricing.output)) / 1_000_000)
+    return sum + taskCost(strongest, task, text, complexity.band, cacheReadRatio, cacheWriteRatio)
   }, 0)
   const budgetExceeded = Number(budgetUsd) > 0 && totalEstimate > Number(budgetUsd)
   const savings = baselineCost <= 0 ? 0 : clamp((baselineCost - totalEstimate) / baselineCost)
@@ -716,17 +814,20 @@ export function buildPlan({ text = '', available = [], mode = 'collective', pric
   const minimumFeasibleCost = optimized?.minimumFeasibleCost ?? minimumCostPlan?.cost ?? 0
   const reason = selected === null
     ? '尚未发现可用模型，保留 Harness 原始模型选择。'
-    : `${complexity.band === 'simple' ? '低复杂度优先成本与响应速度' : complexity.band === 'balanced' ? '在质量、成本、延迟与风险之间平衡' : '高复杂度执行依赖感知的全局约束分配'}；任务类型为 ${taskType}，已对 ${String(subtasks.length)} 个工作包进行 Pareto 剪枝和有界组合搜索。`
+    : `${complexity.band === 'simple' ? '低复杂度优先成本、响应速度与较低推理开销' : complexity.band === 'balanced' ? '在质量、成本、推理等级、延迟与风险之间平衡' : '高复杂度执行包含推理等级的依赖感知全局约束分配'}；任务类型为 ${taskType}，已对 ${String(subtasks.length)} 个工作包进行 Pareto 剪枝和有界组合搜索。`
   return {
     mode,
     complexity: { value: Number(complexity.value.toFixed(3)), band: complexity.band },
     taskType,
     taskTypes: [...new Set(taskNodes.map(task => task.type).filter(type => type !== 'reasoning'))],
     objectiveWeights: weights,
-    candidates: rows.slice(0, 8).map(row => ({ provider: row.provider, model: row.model, score: Number(row.score.toFixed(3)), quality: Number(row.quality.toFixed(3)), specialty: Number(row.specialty.toFixed(3)), estimatedCost: Number(row.estimatedCost.toFixed(6)), inputPrice: row.pricing.input, outputPrice: row.pricing.output })),
-    selected: selected === null ? null : { provider: selected.provider, model: selected.model, estimatedCost: Number(selected.estimatedCost.toFixed(6)) },
+    candidates: rows.slice(0, 8).map(row => {
+      const decision = candidateUtility(row, taskNodes[0] ?? { type: taskType, qualityFloor: QUALITY_FLOORS[complexity.band], preferredReasoningEffort: complexity.band === 'simple' ? 'low' : 'medium' }, weights, maxCost, new Set(), cacheReadRatio, cacheWriteRatio)
+      return { provider: row.provider, model: row.model, score: Number(row.score.toFixed(3)), quality: Number(row.quality.toFixed(3)), specialty: Number(row.specialty.toFixed(3)), reasoningEffort: decision.reasoningEffort, preferredReasoningEffort: decision.preferredReasoningEffort, reasoningFit: Number(decision.reasoningFit.toFixed(3)), reasoningKnown: row.reasoningKnown, reasoningEfforts: row.reasoningEfforts, estimatedCost: Number(row.estimatedCost.toFixed(6)), inputPrice: row.pricing.input, outputPrice: row.pricing.output }
+    }),
+    selected: selected === null ? null : { provider: selected.provider, model: selected.model, reasoningEffort: selectedAssignment?.decision?.reasoningEffort, estimatedCost: Number(selected.estimatedCost.toFixed(6)) },
     subtasks,
-    synthesizer: synthesizer === undefined ? null : { provider: synthesizer.provider, model: synthesizer.model },
+    synthesizer: synthesizer === undefined ? null : { provider: synthesizer.provider, model: synthesizer.model, reasoningEffort: synthesizerAssignment?.decision?.reasoningEffort },
     estimatedCost: Number(totalEstimate.toFixed(6)),
     costBreakdown,
     optimization: {

package/GAL_GAME_PREVIEW.md

@@ -14,9 +14,9 @@ GAL 游戏作为原有「GAL视窗」内的一个模块，提供「剧情模式
 
 ## 剧情模式
 
-0.4.30 默认先显示 Galgame 首页，可继续当前存档、从序章开始、打开八章主线、进入 22 条角色支线或调整无障碍与声音。《千桥协议》现有 666 个节点、44 处两难选择、六类制度结局和 44 种支线收束；每条支线都会留下对应角色承诺与证据。主线关系尾声、制度结局和支线结局分别计算。
+0.4.32 默认先显示 Galgame 首页，可继续当前存档、从序章开始、打开八章主线、进入 22 条角色支线或调整无障碍与声音。《千桥协议》现有 666 个节点、44 处两难选择、六类制度结局和 44 种支线收束；每条支线都会留下对应角色承诺与证据。主线关系尾声、制度结局和支线结局分别计算。
 
-七套主题乐谱由 MiniMax M3 生成音高、节奏、音色和力度数据，运行时由 Web Audio 在本地合成，不再请求 MiniMax。Kimi 长笛、Claude 诗句和千桥事故异常节拍均有可关闭的文字字幕。设置还提供音乐音量、减少动态、高对比度、大号文字、易读字体和完整键盘操作。
+七套主题乐谱由 MiniMax M3 生成音高、节奏、音色和力度数据，运行时由 Web Audio 在本地合成，不再请求 MiniMax。0.4.32 按叙事段落安排主题：千桥签署先以 Kimi 长笛铺陈，事故显形才进入异常节拍，善后转入 Claude 诗句；协议组合在冲突检验前保持穹顶复核主题。主题切换采用交叉淡化，对话线索出现时自动压低背景音量。Kimi 长笛、Claude 诗句和千桥事故异常节拍均有可关闭的文字字幕。
 
 《未写完的约定》已扩展为 1,111 个台词与事件节点、28 处分支选择、5 种关系结局及各自后日谈。故事从旧城最后一周延续到迁移后的生活，包含 46 个地点与时段组合。默认选择的一条完整路线有 853 次推进、约 2.27 万字对话和旁白；其他路线长度略有不同，这不是全部分支的总字数。
 
@@ -36,7 +36,7 @@ GAL 游戏作为原有「GAL视窗」内的一个模块，提供「剧情模式
 
 ## 画面与调试
 
-两种模式的场景图片都按要求保留空白和文字描述，使用已有角色立绘及 DeepSeek 表情差分。对话框改用精细位图：DeepSeek 保留用户原框的艺术主体，另 13 位人物通过图片 API 生成各自的材质、徽章和边饰。图片由原 GAL 渲染器共用的 `DialogueBox` 呈现，设置内的「对话框图鉴」可以查看全部样式。原始素材继续保留，游戏运行时直接读取本地 WebP，不请求图片 API。详见 [对话框图片说明](output/imagegen/dialogue-frames/README.md) 和 [14 套对照图](output/imagegen/dialogue-frames/runtime-contact-sheet.png)。
+两种模式的场景图片都按要求保留空白和文字描述，使用已有角色立绘及 DeepSeek 表情差分。DeepSeek 五张差分均保留透明通道；Claude 日常使用 `Claude1.png`，只在坚定、生气和惊讶场景切换 `Claude.png`。对话框改用 22 套精细位图，每位主线与组织角色都有独立材质、徽章和边饰。图片由原 GAL 渲染器共用的 `DialogueBox` 呈现，设置内的「对话框图鉴」可以查看全部样式。原始素材继续保留，游戏运行时直接读取本地 WebP，不请求图片 API。详见 [对话框图片说明](output/imagegen/dialogue-frames/README.md) 和 [22 套对照图](output/imagegen/dialogue-frames/runtime-contact-sheet.png)。
 
 普通游玩界面只呈现场景、角色、对话、剧情选项或自由输入与轻量菜单。好感、信任、隔阂、关系阶段、情绪标签、场景完成条件、进度和判定证据都在后台运行，不以数字、标签或进度条向玩家显示；角色的台词、态度与表情承载这些变化。回忆、对话历史、存档列表和结局呈现也不显示内部判定。