refactor(model-signals): drop legacy signal field shims

Author: LyleMi

frontend/src/api/demo.ts

@@ -940,11 +940,8 @@ function signalRatesFor(group: Session[], groupToolCalls: ToolCall[]): ModelSign
 
   return {
     outputExpansionRate: safeRate(outputTokens, inputTokens),
-    generationTokenOverhead: safeRate(outputTokens, inputTokens),
     reasoningTokenShare: safeRate(reasoningOutputTokens, outputTokens),
     reasoningOverheadRate: safeRate(reasoningOutputTokens, Math.max(0, outputTokens - reasoningOutputTokens)),
-    reasoningTokenOverhead: safeRate(reasoningOutputTokens, outputTokens),
-    reasoningOutputShare: safeRate(reasoningOutputTokens, outputTokens),
     cacheMissRate: clampRate(safeRate(inputTokens - cachedInputTokens, inputTokens)),
     modelThroughputTokensPerSecond: safeRate(totalTokens, modelDurationSeconds),
     modelThroughputOutputTokensPerSecond: safeRate(outputTokens, modelDurationSeconds),
@@ -995,6 +992,8 @@ function metricSetFromTotals(totals: MetricTotals): ModelSignalMetricSet {
   const failurePressure = safeRate((totals.failedModelCalls || 0) + totals.failedToolCalls, totals.sessionCount)
   const avgModelCallsPerSession = safeRate(totals.modelCalls, totals.sessionCount)
   const outputExpansionRate = safeRate(totals.outputTokens, totals.inputTokens)
+  const visibleOutputTokens = Math.max(0, totals.outputTokens - totals.reasoningOutputTokens)
+  const billableOutputTokens = totals.outputTokens
   const reasoningOverheadRate = safeRate(totals.reasoningOutputTokens, Math.max(0, totals.outputTokens - totals.reasoningOutputTokens))
   const cacheMissRate = clampRate(safeRate(totals.inputTokens - totals.cachedInputTokens, totals.inputTokens))
   const modelThroughputOutputTokensPerSecond = safeRate(totals.outputTokens, modelDurationSeconds)
@@ -1012,6 +1011,8 @@ function metricSetFromTotals(totals: MetricTotals): ModelSignalMetricSet {
     cachedInputTokens: totals.cachedInputTokens,
     outputTokens: totals.outputTokens,
     reasoningOutputTokens: totals.reasoningOutputTokens,
+    visibleOutputTokens,
+    billableOutputTokens,
     modelDurationMs: totals.modelDurationMs,
     wallDurationMs,
     activeDurationMs,
@@ -1041,11 +1042,8 @@ function metricSetFromTotals(totals: MetricTotals): ModelSignalMetricSet {
     }),
     avgModelCallsPerSession,
     outputExpansionRate,
-    generationTokenOverhead: outputExpansionRate,
     reasoningTokenShare: safeRate(totals.reasoningOutputTokens, totals.outputTokens),
     reasoningOverheadRate,
-    reasoningTokenOverhead: safeRate(totals.reasoningOutputTokens, totals.outputTokens),
-    reasoningOutputShare: safeRate(totals.reasoningOutputTokens, totals.outputTokens),
     cacheMissRate,
     modelThroughputTokensPerSecond,
     modelThroughputOutputTokensPerSecond,
@@ -1161,8 +1159,8 @@ function relativeDecrease(current: number, baseline: number): number {
   return (baseline - current) / baseline
 }
 
-function reasoningOverhead(metric: Pick<ModelSignalRates, 'reasoningTokenShare' | 'reasoningOverheadRate' | 'reasoningTokenOverhead' | 'reasoningOutputShare'>): number {
-  return metric.reasoningOverheadRate ?? metric.reasoningTokenOverhead ?? metric.reasoningOutputShare ?? metric.reasoningTokenShare
+function reasoningOverhead(metric: Pick<ModelSignalRates, 'reasoningOverheadRate'>): number {
+  return metric.reasoningOverheadRate
 }
 
 function modelSignalDriftFor(current: ModelSignalMetricSet, baseline: ModelSignalMetricSet): ModelSignalDrift {
@@ -1586,13 +1584,11 @@ function anomalySessionsFor(items: Session[], scopedToolCalls: ToolCall[]): Mode
     const reasons: string[] = []
     if (rates.toolFailureRate > 0) reasons.push('Tool failure in session')
     if (reasoningOverhead(rates) >= 0.25) reasons.push('High reasoning overhead')
-    if ((rates.generationTokenOverhead ?? rates.outputExpansionRate) >= 0.2) reasons.push('Generation overhead relative to input')
+    if (rates.outputExpansionRate >= 0.2) reasons.push('Generation overhead relative to input')
     if (rates.cacheMissRate >= 0.85) reasons.push('Low cache reuse')
     if (rates.modelThroughputTokensPerSecond > 0 && rates.modelThroughputTokensPerSecond < 85) reasons.push('Low model token throughput')
     if (!reasons.length) continue
     anomalies.push({
-      session,
-      id: session.id,
       sessionId: session.id,
       sessionKey: session.sessionKey,
       codexSessionId: session.codexSessionId,
@@ -1601,22 +1597,25 @@ function anomalySessionsFor(items: Session[], scopedToolCalls: ToolCall[]): Mode
       rawSourcePath: session.rawSourcePath,
       agentKind: session.agentKind,
       agentName: session.agentName,
-      sourceId: session.sourceId,
-      sourceKey: session.sourceKey,
-      sourceLabel: session.sourceLabel,
-      sourceRootPath: session.sourceRootPath,
-      sourceSessionsPath: session.sourceSessionsPath,
+      sourceId: session.sourceId || 0,
+      sourceKey: session.sourceKey || '',
+      sourceLabel: session.sourceLabel || session.agentName,
+      sourceRootPath: session.sourceRootPath || '',
+      sourceSessionsPath: session.sourceSessionsPath || '',
       model: session.model,
+      modelCalls: modelCallsForSession(session),
       totalTokens: session.tokenUsage.totalTokens,
       inputTokens: session.tokenUsage.inputTokens,
+      cachedInputTokens: session.tokenUsage.cachedInputTokens,
       outputTokens: session.tokenUsage.outputTokens,
       reasoningOutputTokens: session.tokenUsage.reasoningOutputTokens,
+      visibleOutputTokens: Math.max(0, session.tokenUsage.outputTokens - session.tokenUsage.reasoningOutputTokens),
+      billableOutputTokens: session.tokenUsage.outputTokens,
       toolCalls: sessionToolCalls.length,
       failedToolCalls: sessionToolCalls.filter((call) => !isSuccessfulToolStatus(call.status)).length,
       modelDurationMs: session.modelDurationMs,
-      severity: reasons.length > 1 ? 'high' : 'medium',
-      signal: reasons[0],
       reasons,
+      score: clampRate(reasons.length / 5),
       ...rates
     })
   }
@@ -1635,6 +1634,8 @@ function modelSignals(filters: UsageScopeFilters = {}): ModelSignals {
   const scopedToolCalls = filteredToolCalls({ agent: filters.agent, project: filters.project, from: filters.from, to: filters.to })
     .filter((call) => sessionIds.has(call.sessionId))
   const rates = signalRatesFor(scoped, scopedToolCalls)
+  const outputTokens = sum(scoped, (session) => session.tokenUsage.outputTokens)
+  const reasoningOutputTokens = sum(scoped, (session) => session.tokenUsage.reasoningOutputTokens)
   const cohorts = modelSignalCohortsFor(scoped, scopedToolCalls)
   return {
     totalSessions: scoped.length,
@@ -1646,6 +1647,9 @@ function modelSignals(filters: UsageScopeFilters = {}): ModelSignals {
     avgModelCallsPerSession: safeRate(sum(scoped, modelCallsForSession), scoped.length),
     outputExpansionRate: rates.outputExpansionRate,
     reasoningTokenShare: rates.reasoningTokenShare,
+    reasoningOverheadRate: rates.reasoningOverheadRate,
+    visibleOutputTokens: Math.max(0, outputTokens - reasoningOutputTokens),
+    billableOutputTokens: outputTokens,
     cacheMissRate: rates.cacheMissRate,
     modelThroughputTokensPerSecond: rates.modelThroughputTokensPerSecond,
     modelThroughputOutputTokensPerSecond: rates.modelThroughputOutputTokensPerSecond,

frontend/src/api/types.ts

@@ -279,11 +279,8 @@ export interface TokenAnalytics {
 
 export interface ModelSignalRates {
   outputExpansionRate: number
-  generationTokenOverhead?: number
   reasoningTokenShare: number
-  reasoningOverheadRate?: number
-  reasoningTokenOverhead?: number
-  reasoningOutputShare?: number
+  reasoningOverheadRate: number
   cacheMissRate: number
   modelThroughputTokensPerSecond: number
   modelThroughputOutputTokensPerSecond: number
@@ -303,8 +300,8 @@ export interface ModelSignalMetricSet extends ModelSignalRates {
   outputTokens: number
   reasoningOutputTokens: number
   contextCompressionTokens?: number
-  visibleOutputTokens?: number
-  billableOutputTokens?: number
+  visibleOutputTokens: number
+  billableOutputTokens: number
   modelDurationMs: number
   wallDurationMs?: number
   activeDurationMs?: number
@@ -464,43 +461,41 @@ export interface ModelSignalsProjectMetric extends ModelSignalMetricSet {
 }
 
 export interface ModelSignalAnomalySession {
-  id?: number
-  sessionId?: number
-  session?: Session
-  sessionKey?: string
+  sessionId: number
+  sourceId: number
+  sourceKey: string
+  sourceLabel: string
+  sourceRootPath: string
+  sourceSessionsPath: string
+  sessionKey: string
   codexSessionId?: string
-  startedAt?: string
-  projectPath?: string
-  rawSourcePath?: string
-  agentKind?: string
-  agentName?: string
-  sourceId?: number
-  sourceKey?: string
-  sourceLabel?: string
-  sourceRootPath?: string
-  sourceSessionsPath?: string
-  model?: string
-  totalTokens?: number
-  inputTokens?: number
-  outputTokens?: number
-  reasoningOutputTokens?: number
+  projectPath: string
+  model: string
+  startedAt: string
+  rawSourcePath: string
+  agentKind: string
+  agentName: string
+  modelCalls: number
+  toolCalls: number
+  failedToolCalls: number
+  totalTokens: number
+  inputTokens: number
+  cachedInputTokens: number
+  outputTokens: number
+  reasoningOutputTokens: number
   contextCompressionTokens?: number
-  toolCalls?: number
-  failedToolCalls?: number
-  modelDurationMs?: number
-  outputExpansionRate?: number
-  reasoningTokenShare?: number
-  cacheMissRate?: number
-  modelThroughputTokensPerSecond?: number
-  toolFailureRate?: number
-  toolDependencyRate?: number
-  severity?: string
-  signal?: string
-  reasonLabels?: string[] | string
-  reasons?: string[] | string
-  signalReasons?: string[] | string
-  reason?: string
-  [key: string]: unknown
+  visibleOutputTokens: number
+  billableOutputTokens: number
+  modelDurationMs: number
+  outputExpansionRate: number
+  reasoningTokenShare: number
+  reasoningOverheadRate: number
+  cacheMissRate: number
+  modelThroughputTokensPerSecond: number
+  modelThroughputOutputTokensPerSecond: number
+  toolFailureRate: number
+  reasons: string[]
+  score: number
 }
 
 export interface ModelSignals {
@@ -513,9 +508,9 @@ export interface ModelSignals {
   avgModelCallsPerSession: number
   outputExpansionRate: number
   reasoningTokenShare: number
-  reasoningOverheadRate?: number
-  visibleOutputTokens?: number
-  billableOutputTokens?: number
+  reasoningOverheadRate: number
+  visibleOutputTokens: number
+  billableOutputTokens: number
   cacheMissRate: number
   modelThroughputTokensPerSecond: number
   modelThroughputOutputTokensPerSecond: number

frontend/src/components/model-signals/chartMetrics.ts

@@ -414,11 +414,11 @@ function finiteNumber(value?: number) {
 }
 
 function reasoningOverhead(metric?: ModelSignalMetricSet) {
-  return firstFinite(metric?.reasoningOverheadRate, metric?.reasoningTokenOverhead, metric?.reasoningOutputShare, metric?.reasoningTokenShare)
+  return finiteNumber(metric?.reasoningOverheadRate)
 }
 
 function generationOverhead(metric?: ModelSignalMetricSet) {
-  return firstFinite(metric?.generationTokenOverhead, metric?.outputExpansionRate)
+  return finiteNumber(metric?.outputExpansionRate)
 }
 
 function safeRate(numerator?: number, denominator?: number) {

frontend/src/presentation/tokenRatios.ts

@@ -4,8 +4,6 @@ export interface TokenRatioInput {
   outputTokens?: number | null
   reasoningOutputTokens?: number | null
   reasoningOverheadRate?: number | null
-  reasoningTokenOverhead?: number | null
-  reasoningOutputShare?: number | null
 }
 
 export interface TokenRatioShares {
@@ -21,12 +19,7 @@ export function tokenRatioShares(input: TokenRatioInput): TokenRatioShares {
   const outputTokens = positiveNumber(input.outputTokens)
   const reasoningOutputTokens = positiveNumber(input.reasoningOutputTokens)
   const mainTotal = inputTokens + outputTokens
-  const reasoningOutput = firstRatio(
-    input.reasoningOverheadRate,
-    input.reasoningTokenOverhead,
-    input.reasoningOutputShare,
-    outputTokens > 0 ? reasoningOutputTokens / outputTokens : undefined
-  )
+  const reasoningOutput = firstRatio(input.reasoningOverheadRate, outputTokens > 0 ? reasoningOutputTokens / outputTokens : undefined)
 
   return {
     input: mainTotal > 0 ? inputTokens / mainTotal : 0,

frontend/src/views/ModelSignals.vue

@@ -813,12 +813,12 @@ onMounted(load)
                 <template v-else-if="column.key === 'signal'">
                   <ReasonTags
                     :reasons="record.reasons"
-                    :color="record.severity === 'high' ? 'warning' : 'processing'"
+                    :color="record.failedToolCalls > 0 || record.score >= 0.45 ? 'warning' : 'processing'"
                     :empty-text="t('fallback.noReason')"
                   />
                 </template>
                 <template v-else-if="column.key === 'outputExpansion'"><span class="number-cell">{{ formatPercent(record.outputExpansionRate) }}</span></template>
-                <template v-else-if="column.key === 'reasoning'"><span class="number-cell">{{ formatPercent(record.reasoningTokenShare) }}</span></template>
+                <template v-else-if="column.key === 'reasoning'"><span class="number-cell">{{ formatPercent(record.reasoningOverheadRate) }}</span></template>
                 <template v-else-if="column.key === 'cacheMiss'"><span class="number-cell">{{ formatPercent(record.cacheMissRate) }}</span></template>
                 <template v-else-if="column.key === 'failedTools'">
                   <span class="number-cell" :class="{ 'status-error': record.failedToolCalls > 0 }">{{ formatNumber(record.failedToolCalls) }}</span>

frontend/src/views/model-signals/columns.ts

@@ -90,7 +90,7 @@ export function buildAnomalyColumns(t: ModelSignalsTranslate) {
     { title: t('column.model'), dataIndex: 'model', key: 'model', width: 170 },
     { title: t('column.signal'), dataIndex: 'reasons', key: 'signal', width: 260 },
     { title: t('column.outputExpansion'), dataIndex: 'outputExpansionRate', key: 'outputExpansion', width: 112, align: 'right' },
-    { title: t('column.reasoning'), dataIndex: 'reasoningTokenShare', key: 'reasoning', width: 100, align: 'right' },
+    { title: t('column.reasoning'), dataIndex: 'reasoningOverheadRate', key: 'reasoning', width: 100, align: 'right' },
     { title: t('column.cacheMiss'), dataIndex: 'cacheMissRate', key: 'cacheMiss', width: 120, align: 'right' },
     { title: t('column.failedTools'), dataIndex: 'failedToolCalls', key: 'failedTools', width: 90, align: 'right' },
     { title: t('column.throughput'), dataIndex: 'modelThroughputTokensPerSecond', key: 'throughput', width: 100, align: 'right' },

frontend/src/views/model-signals/display.ts

@@ -13,8 +13,7 @@ import {
   type ModelSignals,
   type ModelSignalsHealthSummary,
   type ModelSignalsProjectMetric,
-  type ModelSignalsWindow,
-  type Session
+  type ModelSignalsWindow
 } from '../../api'
 import { sourceDisplay } from '../../presentation/sourceIdentity'
 import {
@@ -190,7 +189,7 @@ export function createModelSignalsDisplay(t: ModelSignalsTranslate) {
   }
 
   function anomalyRowClass(record: NormalizedAnomalySession) {
-    return { class: record.failedToolCalls > 0 || record.severity === 'high' ? 'model-signals-warning-row' : '' }
+    return { class: record.failedToolCalls > 0 || record.score >= 0.45 ? 'model-signals-warning-row' : '' }
   }
 
   function reasonText(row: string): string {
@@ -269,59 +268,32 @@ export function createModelSignalsDisplay(t: ModelSignalsTranslate) {
     return record.projectPath || `${record.modelCount}:${record.sourceCount}:${record.totalTokens}`
   }
 
-  function anomalyReasons(row: ModelSignalAnomalySession): string[] {
-    const candidates = [row.reasons, row.reasonLabels, row.signalReasons, row.reason, row.signal]
-    const values = candidates.flatMap((value) => {
-      if (Array.isArray(value)) return value
-      if (typeof value === 'string') return [value]
-      return []
-    })
-    return [...new Set(values.map((value) => value.trim()).filter(Boolean))]
-  }
-
   function normalizeAnomaly(row: ModelSignalAnomalySession): NormalizedAnomalySession {
-    const session = row.session || ({} as Partial<Session>)
     return {
-      id: numberField(row, ['id', 'sessionId']) || session.id || 0,
-      sessionKey: stringField(row, ['sessionKey']) || session.sessionKey,
-      codexSessionId: stringField(row, ['codexSessionId']) || session.codexSessionId,
-      startedAt: stringField(row, ['startedAt']) || session.startedAt,
-      projectPath: stringField(row, ['projectPath']) || session.projectPath,
-      rawSourcePath: stringField(row, ['rawSourcePath']) || session.rawSourcePath,
-      agentKind: stringField(row, ['agentKind']) || session.agentKind,
-      agentName: stringField(row, ['agentName']) || session.agentName,
-      sourceId: numberField(row, ['sourceId']) || session.sourceId,
-      sourceKey: stringField(row, ['sourceKey']) || session.sourceKey,
-      sourceLabel: stringField(row, ['sourceLabel']) || session.sourceLabel,
-      sourceRootPath: stringField(row, ['sourceRootPath']) || session.sourceRootPath,
-      sourceSessionsPath: stringField(row, ['sourceSessionsPath']) || session.sourceSessionsPath,
-      model: stringField(row, ['model']) || session.model,
-      totalTokens: numberField(row, ['totalTokens']) || session.tokenUsage?.totalTokens || 0,
-      outputExpansionRate: numberField(row, ['generationTokenOverhead', 'outputExpansionRate']),
-      reasoningTokenShare: numberField(row, ['reasoningOverheadRate', 'reasoningTokenOverhead', 'reasoningOutputShare', 'reasoningTokenShare']),
-      cacheMissRate: numberField(row, ['cacheMissRate']),
-      modelThroughputTokensPerSecond: numberField(row, ['modelThroughputTokensPerSecond']),
-      failedToolCalls: numberField(row, ['failedToolCalls']),
-      modelDurationMs: numberField(row, ['modelDurationMs']) || session.modelDurationMs || 0,
-      severity: stringField(row, ['severity']),
-      reasons: anomalyReasons(row)
-    }
-  }
-
-  function stringField(row: ModelSignalAnomalySession, keys: string[]) {
-    for (const key of keys) {
-      const value = row[key]
-      if (typeof value === 'string' && value.trim()) return value.trim()
+      id: row.sessionId,
+      sessionKey: row.sessionKey,
+      codexSessionId: row.codexSessionId,
+      startedAt: row.startedAt,
+      projectPath: row.projectPath,
+      rawSourcePath: row.rawSourcePath,
+      agentKind: row.agentKind,
+      agentName: row.agentName,
+      sourceId: row.sourceId,
+      sourceKey: row.sourceKey,
+      sourceLabel: row.sourceLabel,
+      sourceRootPath: row.sourceRootPath,
+      sourceSessionsPath: row.sourceSessionsPath,
+      model: row.model,
+      totalTokens: row.totalTokens,
+      outputExpansionRate: row.outputExpansionRate,
+      reasoningOverheadRate: row.reasoningOverheadRate,
+      cacheMissRate: row.cacheMissRate,
+      modelThroughputTokensPerSecond: row.modelThroughputTokensPerSecond,
+      failedToolCalls: row.failedToolCalls,
+      modelDurationMs: row.modelDurationMs,
+      score: row.score,
+      reasons: row.reasons
     }
-    return undefined
-  }
-
-  function numberField(row: ModelSignalAnomalySession, keys: string[]) {
-    for (const key of keys) {
-      const value = row[key]
-      if (typeof value === 'number' && Number.isFinite(value)) return value
-    }
-    return 0
   }
 
   function sessionInfo(record: NormalizedAnomalySession) {