token-studio 4.8.0

package/src/client/review/roi-advisor.js

@@ -0,0 +1,255 @@
+const DEFAULT_TASK_TYPE = '未分类';
+const DEFAULT_OUTPUT_STATUS = '未标注';
+const DEFAULT_WORK_PURPOSE = '未说明';
+const DEFAULT_WORK_STAGE = '未说明';
+const DEFAULT_VALUE_LEVEL = '未评估';
+
+const HEAVY_MODEL_PATTERNS = [/^gpt-5\.5/i, /claude-opus/i];
+const MID_MODEL_PATTERNS = [/^gpt-5\.3-codex$/i, /claude-sonnet/i];
+const LIGHT_MODEL_PATTERNS = [/claude-haiku/i, /deepseek/i, /mimo/i];
+const EXPLORATION_PURPOSES = new Set(['测试验证', '上下文整理']);
+const EXPLORATION_STAGES = new Set(['探索', '验证']);
+const PRODUCTIVE_STATUSES = new Set(['已完成', '已发布']);
+const LOW_VALUE_LEVELS = new Set(['低']);
+const HIGH_VALUE_LEVELS = new Set(['高', '关键']);
+
+export function buildRoiAdvisor({ sessions = [], daily = [] } = {}) {
+  const total = aggregateRows(sessions.length ? sessions : daily);
+  const suggestions = [
+    buildAttributionSuggestion(sessions, total),
+    buildHeavyModelExplorationSuggestion(sessions, total),
+    buildWasteSuggestion(sessions, total),
+    buildHighValueKeepSuggestion(sessions, total),
+    buildInputRatioSuggestion(sessions, daily, total),
+    buildCacheSuggestion(sessions, daily, total),
+    buildUnpricedSuggestion(sessions, daily, total)
+  ].filter(Boolean);
+
+  return suggestions
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 5)
+    .map(({ score, ...suggestion }) => suggestion);
+}
+
+export function modelTier(model, pricingStatus = '') {
+  const name = String(model || '').trim();
+  if (!name || name === '<synthetic>' || pricingStatus === 'unpriced') return 'unpriced';
+  if (HEAVY_MODEL_PATTERNS.some(pattern => pattern.test(name))) return 'heavy';
+  if (MID_MODEL_PATTERNS.some(pattern => pattern.test(name))) return 'mid';
+  if (LIGHT_MODEL_PATTERNS.some(pattern => pattern.test(name))) return 'light';
+  return 'unknown';
+}
+
+export function isRoiUnattributed(session = {}) {
+  return (session.taskType || DEFAULT_TASK_TYPE) === DEFAULT_TASK_TYPE
+    || (session.outputStatus || DEFAULT_OUTPUT_STATUS) === DEFAULT_OUTPUT_STATUS
+    || (session.workPurpose || DEFAULT_WORK_PURPOSE) === DEFAULT_WORK_PURPOSE
+    || (session.workStage || DEFAULT_WORK_STAGE) === DEFAULT_WORK_STAGE
+    || (session.valueLevel || DEFAULT_VALUE_LEVEL) === DEFAULT_VALUE_LEVEL;
+}
+
+function buildAttributionSuggestion(sessions, total) {
+  const rows = sessions.filter(isRoiUnattributed)
+    .sort(compareCostThenTokens);
+  if (!rows.length) return null;
+  const aggregate = aggregateRows(rows);
+  const top = rows[0];
+  return suggestion({
+    id: 'attribute-high-cost-work',
+    category: '补标注',
+    impact: '高',
+    tone: 'risk',
+    title: '先补齐高成本会话的用途和价值',
+    recommendation: '把当前最高成本的未归因 session 标上主要目的、工作阶段和产出价值。',
+    reason: '没有用途和价值字段时，系统只能知道花了多少 token，无法判断这笔投入是否值得继续。',
+    evidence: withAttributionEvidence(`${rows.length} 个 session 仍缺少任务/状态/目的/阶段/价值标注，占本期 ${pct(aggregate.totalTokens, total.totalTokens)} tokens；最高一条是 ${labelSession(top)}，官方价 ${money(top.costUSD)}。`, rows),
+    action: '在看板按模型或项目筛选后使用“批量归因当前筛选”，先处理 token 最高的前 5 条。',
+    score: 100 + shareScore(aggregate.totalTokens, total.totalTokens)
+  });
+}
+
+function buildHeavyModelExplorationSuggestion(sessions, total) {
+  const rows = sessions.filter(session => {
+    const tier = modelTier(session.model || session.pricingModel, session.pricingStatus);
+    return tier === 'heavy'
+      && (EXPLORATION_PURPOSES.has(session.workPurpose) || EXPLORATION_STAGES.has(session.workStage));
+  }).sort(compareCostThenTokens);
+  if (!rows.length) return null;
+  const aggregate = aggregateRows(rows);
+  return suggestion({
+    id: 'use-light-model-for-exploration',
+    category: '模型切换',
+    impact: aggregate.costUSD > total.costUSD * 0.1 ? '高' : '中',
+    tone: 'optimize',
+    title: '测试和探索阶段优先改用轻量模型',
+    recommendation: '把测试验证、上下文整理和探索阶段默认切到 Haiku、DeepSeek 或 MiMo，确认方向后再升级到重模型。',
+    reason: '这些任务通常需要快速试错，不需要一开始就使用最高单价模型。',
+    evidence: withAttributionEvidence(`${rows.length} 个探索/验证类 session 使用了重模型，合计 ${compact(aggregate.totalTokens)} tokens、官方价 ${money(aggregate.costUSD)}。`, rows),
+    action: '把这类任务的默认模型改成轻量模型；只有进入实现收口、复杂调试或发布前审查时再切回重模型。',
+    score: 88 + shareScore(aggregate.costUSD, total.costUSD)
+  });
+}
+
+function buildWasteSuggestion(sessions, total) {
+  const rows = sessions.filter(session =>
+    session.outputStatus === '已废弃' || LOW_VALUE_LEVELS.has(session.valueLevel)
+  ).sort(compareCostThenTokens);
+  if (!rows.length) return null;
+  const aggregate = aggregateRows(rows);
+  return suggestion({
+    id: 'stop-loss-low-value-work',
+    category: '止损',
+    impact: aggregate.costUSD > total.costUSD * 0.15 ? '高' : '中',
+    tone: 'risk',
+    title: '低价值或废弃任务要先轻量试错',
+    recommendation: '对低价值和可能废弃的方向设置 token 止损线，先用轻量模型验证可行性。',
+    reason: '这类投入即使完成，也不一定转化为长期产出；重模型成本应该留给高价值实现和审查。',
+    evidence: withAttributionEvidence(`${rows.length} 个低价值/废弃 session 合计 ${compact(aggregate.totalTokens)} tokens、官方价 ${money(aggregate.costUSD)}。`, rows),
+    action: '后续同类任务先用轻量模型做 1-2 轮方案验证，再决定是否进入实现阶段。',
+    score: 82 + shareScore(aggregate.costUSD, total.costUSD)
+  });
+}
+
+function buildHighValueKeepSuggestion(sessions, total) {
+  const rows = sessions.filter(session => {
+    const tier = modelTier(session.model || session.pricingModel, session.pricingStatus);
+    return HIGH_VALUE_LEVELS.has(session.valueLevel)
+      && PRODUCTIVE_STATUSES.has(session.outputStatus)
+      && isLowCostSession(session, total)
+      && ['light', 'mid'].includes(tier);
+  }).sort(compareCostThenTokens);
+  if (!rows.length) return null;
+  const aggregate = aggregateRows(rows);
+  return suggestion({
+    id: 'keep-high-value-low-cost-pattern',
+    category: '保留策略',
+    impact: '中',
+    tone: 'good',
+    title: '保留高价值低成本的模型策略',
+    recommendation: '这类高价值产出已经能用中轻量模型完成，后续相似任务优先复用同样模型组合。',
+    reason: 'ROI 最高的模式不是最便宜，而是能稳定交付高价值产出且成本可控。',
+    evidence: withAttributionEvidence(`${rows.length} 个高价值且已完成/已发布 session 使用中轻量模型，合计官方价 ${money(aggregate.costUSD)}。`, rows),
+    action: '把这些 session 的项目、任务类型和模型作为后续默认模板。',
+    score: 60 + shareScore(aggregate.totalTokens, total.totalTokens)
+  });
+}
+
+function isLowCostSession(session, total) {
+  const cost = session.costUSD || 0;
+  return cost <= 1 || (total.costUSD > 0 && cost / total.costUSD <= 0.05);
+}
+
+function buildInputRatioSuggestion(sessions, daily, total) {
+  const aggregate = aggregateRows(sessions.length ? sessions : daily);
+  const ratio = aggregate.outputTokens ? aggregate.inputTokens / aggregate.outputTokens : 0;
+  if (ratio < 4 || aggregate.inputTokens < 100_000) return null;
+  return suggestion({
+    id: 'reduce-context-bloat',
+    category: '上下文压缩',
+    impact: ratio >= 8 ? '高' : '中',
+    tone: 'optimize',
+    title: '压缩上下文，减少大段输入',
+    recommendation: '把长上下文改成“目标 + 相关文件 + 约束 + 验收标准”，不要每轮重复喂全部背景。',
+    reason: 'Input / Output 比过高通常说明输入上下文过大，模型在读材料上消耗了大量 token。',
+    evidence: withAttributionEvidence(`本期 Input / Output 比为 ${ratio.toFixed(1)}:1，输入 ${compact(aggregate.inputTokens)}，输出 ${compact(aggregate.outputTokens)}。`, sessions),
+    action: '为高频项目沉淀 README/任务摘要；每轮只附与当前问题直接相关的文件和错误信息。',
+    score: 76 + Math.min(20, ratio)
+  });
+}
+
+function buildCacheSuggestion(sessions, daily, total) {
+  const aggregate = aggregateRows(sessions.length ? sessions : daily);
+  const cacheRate = aggregate.totalTokens ? aggregate.cacheReadTokens / aggregate.totalTokens : 0;
+  if (cacheRate > 0.2 || aggregate.inputTokens < 100_000) return null;
+  return suggestion({
+    id: 'improve-cache-and-task-continuity',
+    category: '上下文压缩',
+    impact: '中',
+    tone: 'optimize',
+    title: '提高上下文连续性，减少重新读项目',
+    recommendation: '把同一项目的相关任务集中处理，减少频繁开新上下文。',
+    reason: 'cache 命中低且输入高，说明模型经常重新读取类似背景。',
+    evidence: withAttributionEvidence(`本期 cache 命中约 ${(cacheRate * 100).toFixed(1)}%，输入 ${compact(aggregate.inputTokens)} tokens。`, sessions),
+    action: '同一项目尽量连续完成“方案-实现-验证”，并用项目摘要替代重复粘贴长上下文。',
+    score: 70
+  });
+}
+
+function buildUnpricedSuggestion(sessions, daily, total) {
+  const rows = (sessions.length ? sessions : daily).filter(row =>
+    row.totalTokens > 0 && (row.pricingStatus === 'unpriced' || modelTier(row.model || row.pricingModel, row.pricingStatus) === 'unpriced')
+  );
+  if (!rows.length) return null;
+  const aggregate = aggregateRows(rows);
+  const models = Array.from(new Set(rows.map(row => row.model || row.pricingModel).filter(Boolean))).slice(0, 3);
+  return suggestion({
+    id: 'keep-unpriced-models-out-of-cost-decisions',
+    category: '未定价模型',
+    impact: '中',
+    tone: 'neutral',
+    title: '未定价模型不要参与成本决策',
+    recommendation: '把未公开官方美元价的模型单独标记，只用 token 量观察，不把 $0 当成免费。',
+    reason: '没有官方公开单价时，强行换算会污染 ROI 判断。',
+    evidence: withAttributionEvidence(`${models.join('、')} 等模型合计 ${compact(aggregate.totalTokens)} tokens，目前没有纳入官方价成本。`, rows),
+    action: '涉及未定价模型时，用产出状态和价值判断是否继续，而不是用账单金额排序。',
+    score: 58 + shareScore(aggregate.totalTokens, total.totalTokens)
+  });
+}
+
+function suggestion(value) {
+  return value;
+}
+
+function withAttributionEvidence(text, rows = []) {
+  const autoCount = rows.filter(row => row.annotationSource === 'auto').length;
+  if (!autoCount) return text;
+  return `${text} 其中 ${autoCount} 条基于自动归因，建议抽查高成本项。`;
+}
+
+function aggregateRows(rows = []) {
+  return rows.reduce((acc, row) => {
+    acc.sessionCount += 1;
+    acc.inputTokens += row.inputTokens || 0;
+    acc.outputTokens += row.outputTokens || 0;
+    acc.cacheReadTokens += row.cacheReadTokens || 0;
+    acc.totalTokens += row.totalTokens || 0;
+    acc.costUSD += row.costUSD || 0;
+    return acc;
+  }, {
+    sessionCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    totalTokens: 0,
+    costUSD: 0
+  });
+}
+
+function compareCostThenTokens(a, b) {
+  return (b.costUSD || 0) - (a.costUSD || 0)
+    || (b.totalTokens || 0) - (a.totalTokens || 0);
+}
+
+function labelSession(session = {}) {
+  return session.projectAlias || session.projectPath || session.sessionId || '未命名会话';
+}
+
+function shareScore(value, total) {
+  return Math.round(Math.min(30, total ? (value / total) * 100 : 0));
+}
+
+function pct(value, total) {
+  return total ? `${((value / total) * 100).toFixed(1)}%` : '0%';
+}
+
+function money(value) {
+  return `$${Number(value || 0).toFixed(value && value < 1 ? 4 : 2)}`;
+}
+
+function compact(value) {
+  const v = Number(value || 0);
+  const abs = Math.abs(v);
+  if (abs >= 1e8) return `${(v / 1e8).toFixed(2).replace(/\.?0+$/, '')} 亿`;
+  if (abs >= 1e4) return `${(v / 1e4).toFixed(1).replace(/\.0$/, '')} 万`;
+  return String(Math.round(v));
+}

package/src/client/review/roi-evidence.js

@@ -0,0 +1,78 @@
+const MISSING_TASK = '未分类';
+const MISSING_STATUS = '未标注';
+const MISSING_PURPOSE = '未说明';
+const MISSING_STAGE = '未说明';
+const MISSING_VALUE = '未评估';
+
+export function buildRoiEvidence({ sessions = [], workItems = [] } = {}) {
+  const sessionCount = sessions.length;
+  const totalTokens = sum(sessions, 'totalTokens');
+  const officialCostUSD = sum(sessions, 'costUSD');
+  const manualConfirmed = sessions.filter(isManual).length;
+  const withOutput = sessions.filter(session => Boolean(session.outputUrl)).length;
+  const complete = sessions.filter(isEvidenceComplete).length;
+  const incompleteCostUSD = sum(sessions.filter(session => !isEvidenceComplete(session)), 'costUSD');
+  const highCostGaps = sessions
+    .filter(session => !isEvidenceComplete(session))
+    .sort((a, b) => (b.costUSD || b.totalTokens || 0) - (a.costUSD || a.totalTokens || 0))
+    .slice(0, 5)
+    .map(session => ({
+      project: session.projectAlias || session.projectPath || '未归属项目',
+      sessionId: session.sessionId,
+      totalTokens: session.totalTokens || 0,
+      costUSD: session.costUSD || 0,
+      missing: missingFields(session)
+    }));
+  const evidenceScore = sessionCount
+    ? Math.round((
+      (complete / sessionCount) * 0.45
+      + (manualConfirmed / sessionCount) * 0.25
+      + (withOutput / sessionCount) * 0.20
+      + (workItems.length ? 0.10 : 0)
+    ) * 100)
+    : 0;
+
+  return {
+    evidenceScore,
+    sessionCount,
+    totalTokens,
+    officialCostUSD,
+    manualConfirmed,
+    autoOrMissing: Math.max(0, sessionCount - manualConfirmed),
+    withOutput,
+    complete,
+    workItemCount: workItems.length,
+    incompleteCostUSD,
+    highCostGaps
+  };
+}
+
+function isEvidenceComplete(session = {}) {
+  return Boolean(session.projectAlias || session.projectPath)
+    && (session.taskType || MISSING_TASK) !== MISSING_TASK
+    && (session.outputStatus || MISSING_STATUS) !== MISSING_STATUS
+    && (session.workPurpose || MISSING_PURPOSE) !== MISSING_PURPOSE
+    && (session.workStage || MISSING_STAGE) !== MISSING_STAGE
+    && (session.valueLevel || MISSING_VALUE) !== MISSING_VALUE
+    && isManual(session);
+}
+
+function isManual(session = {}) {
+  return session.annotationSource === 'manual' || session.annotationSource === 'imported';
+}
+
+function missingFields(session = {}) {
+  const fields = [];
+  if (!session.projectAlias && !session.projectPath) fields.push('项目');
+  if ((session.taskType || MISSING_TASK) === MISSING_TASK) fields.push('任务');
+  if ((session.outputStatus || MISSING_STATUS) === MISSING_STATUS) fields.push('产出状态');
+  if ((session.workPurpose || MISSING_PURPOSE) === MISSING_PURPOSE) fields.push('目的');
+  if ((session.workStage || MISSING_STAGE) === MISSING_STAGE) fields.push('阶段');
+  if ((session.valueLevel || MISSING_VALUE) === MISSING_VALUE) fields.push('价值');
+  if (!isManual(session)) fields.push('人工确认');
+  return fields;
+}
+
+function sum(rows, field) {
+  return rows.reduce((acc, row) => acc + Number(row[field] || 0), 0);
+}

package/src/client/review/savings-simulator.js

@@ -0,0 +1,252 @@
+import { calculateOfficialCost } from '../../pricing.mjs';
+import { modelTier } from './roi-advisor.js';
+
+const PRODUCTIVE_STATUSES = new Set(['已完成', '已发布']);
+const HIGH_VALUE_LEVELS = new Set(['高', '关键']);
+const LOW_VALUE_LEVELS = new Set(['低']);
+const EXPLORATION_PURPOSES = new Set(['需求澄清', '技术调研', '测试验证', '上下文整理']);
+const EXPLORATION_STAGES = new Set(['探索', '验证']);
+const CONTEXT_PURPOSES = new Set(['上下文整理']);
+const TARGET_MODELS = {
+  light: [
+    { model: 'deepseek-v4-flash', provider: 'deepseek', label: 'DeepSeek V4 Flash' },
+    { model: 'mimo-v2.5', provider: 'xiaomi', label: 'MiMo v2.5' },
+    { model: 'claude-haiku-4-5', provider: 'anthropic', label: 'Claude Haiku 4.5' }
+  ],
+  mid: [
+    { model: 'gpt-5.3-codex', provider: 'openai', label: 'GPT-5.3 Codex' },
+    { model: 'claude-sonnet-4-6', provider: 'anthropic', label: 'Claude Sonnet 4.6' },
+    { model: 'deepseek-v4-pro', provider: 'deepseek', label: 'DeepSeek V4 Pro' },
+    { model: 'mimo-v2.5-pro', provider: 'xiaomi', label: 'MiMo v2.5 Pro' }
+  ]
+};
+
+export function buildSavingsSimulation({ sessions = [], daily = [], pricingMeta = null } = {}) {
+  const rows = sessions.length ? sessions : daily;
+  const totalCostUSD = rows.reduce((sum, row) => sum + pricedCost(row), 0);
+  const totalTokens = rows.reduce((sum, row) => sum + tokensFor(row).total, 0);
+  const unpricedSessions = rows
+    .filter(row => isUnpriced(row) && tokensFor(row).total > 0)
+    .map(row => ({
+      sessionId: row.sessionId || row.id || '',
+      model: row.model || row.pricingModel || 'unknown',
+      totalTokens: tokensFor(row).total,
+      reason: row.pricingReason || '未配置官方公开美元价'
+    }))
+    .sort((a, b) => b.totalTokens - a.totalTokens);
+
+  const grouped = new Map();
+  for (const row of rows) {
+    const candidate = classifyCandidate(row);
+    if (!candidate) continue;
+
+    const currentCostUSD = pricedCost(row);
+    if (currentCostUSD <= 0 || isUnpriced(row)) continue;
+
+    const simulated = simulateTargetCost(row, candidate.targetTier);
+    if (!simulated || simulated.costUSD >= currentCostUSD) continue;
+
+    const key = candidate.id;
+    if (!grouped.has(key)) {
+      grouped.set(key, {
+        ...candidate,
+        sessionCount: 0,
+        totalTokens: 0,
+        currentCostUSD: 0,
+        simulatedCostUSD: 0,
+        savingsUSD: 0,
+        targetModels: new Map(),
+        sampleSessions: []
+      });
+    }
+
+    const target = grouped.get(key);
+    const tokens = tokensFor(row);
+    target.sessionCount += 1;
+    target.totalTokens += tokens.total;
+    target.currentCostUSD += currentCostUSD;
+    target.simulatedCostUSD += simulated.costUSD;
+    target.savingsUSD += currentCostUSD - simulated.costUSD;
+    target.targetModels.set(simulated.model, simulated.label);
+    if (target.sampleSessions.length < 3) {
+      target.sampleSessions.push({
+        sessionId: row.sessionId || row.id || '',
+        project: projectLabel(row),
+        model: row.model || row.pricingModel || 'unknown',
+        totalTokens: tokens.total,
+        costUSD: currentCostUSD
+      });
+    }
+  }
+
+  const suggestions = Array.from(grouped.values())
+    .map(row => ({
+      id: row.id,
+      title: row.title,
+      recommendation: row.recommendation,
+      currentTier: row.currentTier,
+      suggestedTier: row.targetTier,
+      suggestedModels: Array.from(row.targetModels.values()),
+      sessionCount: row.sessionCount,
+      totalTokens: row.totalTokens,
+      currentCostUSD: row.currentCostUSD,
+      simulatedCostUSD: row.simulatedCostUSD,
+      savingsUSD: row.savingsUSD,
+      savingsShare: row.currentCostUSD ? row.savingsUSD / row.currentCostUSD : 0,
+      why: row.why,
+      action: row.action,
+      sampleSessions: row.sampleSessions,
+      score: row.savingsUSD * 100 + row.totalTokens / 1000 + row.priority
+    }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 5);
+
+  return {
+    generatedAt: new Date().toISOString(),
+    mode: 'official-price-simulation',
+    totalCostUSD,
+    totalTokens,
+    potentialSavingsUSD: suggestions.reduce((sum, row) => sum + row.savingsUSD, 0),
+    suggestions,
+    unpriced: {
+      sessionCount: unpricedSessions.length,
+      totalTokens: unpricedSessions.reduce((sum, row) => sum + row.totalTokens, 0),
+      models: Array.from(new Set(unpricedSessions.map(row => row.model))).slice(0, 8),
+      sampleSessions: unpricedSessions.slice(0, 5)
+    },
+    pricingMeta
+  };
+}
+
+function classifyCandidate(row = {}) {
+  const currentTier = modelTier(row.model || row.pricingModel, row.pricingStatus);
+  if (!['heavy', 'mid'].includes(currentTier)) return null;
+  if (isHighValueProductive(row)) return null;
+
+  if (isLowValueOrWaste(row)) {
+    return {
+      id: `${currentTier}-low-value-to-light`,
+      currentTier,
+      targetTier: 'light',
+      priority: currentTier === 'heavy' ? 90 : 70,
+      title: '低价值或废弃任务先切轻量模型',
+      recommendation: '把低价值、已废弃或高不确定性的工作先用轻量模型试错，再决定是否升级。',
+      why: '这类 session 的产出价值或状态已经显示风险，继续使用高单价模型会放大沉没成本。',
+      action: '为同类任务设置轻量模型默认值和 token 止损线，确认方向后再升级。'
+    };
+  }
+
+  if (isExplorationOrValidation(row)) {
+    return {
+      id: `${currentTier}-exploration-to-light`,
+      currentTier,
+      targetTier: 'light',
+      priority: currentTier === 'heavy' ? 82 : 62,
+      title: '探索、测试和上下文整理优先轻量化',
+      recommendation: '需求澄清、技术调研、测试验证、上下文整理默认使用轻量模型。',
+      why: '这些工作更像快速判断方向，不应该一开始就使用重模型完整推理。',
+      action: '把探索/验证阶段的默认模型切到轻量层；进入复杂实现或发布审查再升级。'
+    };
+  }
+
+  if (currentTier === 'heavy' && row.workStage === '实现') {
+    return {
+      id: 'heavy-implementation-to-mid',
+      currentTier,
+      targetTier: 'mid',
+      priority: 45,
+      title: '普通实现阶段先用中模型承接',
+      recommendation: '非关键价值的实现任务先用中模型，关键审查和复杂收口再上重模型。',
+      why: '实现阶段通常需要稳定代码能力，但不一定每轮都需要最高成本模型。',
+      action: '把普通功能开发默认切到中模型；只在关键产出、架构风险或发布审查时使用重模型。'
+    };
+  }
+
+  if (currentTier === 'heavy' && CONTEXT_PURPOSES.has(row.workPurpose)) {
+    return {
+      id: 'heavy-context-to-light',
+      currentTier,
+      targetTier: 'light',
+      priority: 75,
+      title: '上下文整理不要占用重模型预算',
+      recommendation: '上下文整理、摘要和文件筛选先交给轻量模型完成。',
+      why: '整理材料的目标是减少后续上下文，不应本身成为高成本入口。',
+      action: '把项目摘要、文件清单、错误归纳沉淀为轻量模型任务。'
+    };
+  }
+
+  return null;
+}
+
+function simulateTargetCost(row, tier) {
+  const tokens = tokensFor(row);
+  const candidates = orderedTargetModels(tier, row)
+    .map(candidate => ({
+      ...candidate,
+      costUSD: calculateOfficialCost(candidate.model, tokens, { provider: candidate.provider }).totalUSD
+    }))
+    .filter(candidate => candidate.costUSD > 0)
+    .sort((a, b) => a.costUSD - b.costUSD);
+  return candidates[0] || null;
+}
+
+function orderedTargetModels(tier, row = {}) {
+  const candidates = TARGET_MODELS[tier] || [];
+  const provider = String(row.pricingProvider || providerFromSource(row.source) || '').toLowerCase();
+  const preferred = candidates.filter(candidate => candidate.provider === provider);
+  const rest = candidates.filter(candidate => candidate.provider !== provider);
+  return [...preferred, ...rest];
+}
+
+function tokensFor(row = {}) {
+  const input = positive(row.inputTokens ?? row.input_tokens);
+  const output = positive(row.outputTokens ?? row.output_tokens);
+  const cacheRead = positive(row.cacheReadTokens ?? row.cache_read_tokens);
+  const cacheWrite = positive(row.cacheCreationTokens ?? row.cache_creation_tokens);
+  const reasoning = positive(row.reasoningOutputTokens ?? row.reasoningTokens ?? row.reasoning_output_tokens);
+  const total = positive(row.totalTokens ?? row.total_tokens)
+    || input + output + cacheRead + cacheWrite + reasoning;
+  return { input, output, cacheRead, cacheWrite, reasoning, total };
+}
+
+function pricedCost(row = {}) {
+  const value = Number(row.costUSD ?? row.cost_usd ?? 0);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+function isUnpriced(row = {}) {
+  return row.pricingStatus === 'unpriced'
+    || modelTier(row.model || row.pricingModel, row.pricingStatus) === 'unpriced';
+}
+
+function isHighValueProductive(row = {}) {
+  return HIGH_VALUE_LEVELS.has(row.valueLevel)
+    && PRODUCTIVE_STATUSES.has(row.outputStatus);
+}
+
+function isLowValueOrWaste(row = {}) {
+  return row.outputStatus === '已废弃' || LOW_VALUE_LEVELS.has(row.valueLevel);
+}
+
+function isExplorationOrValidation(row = {}) {
+  return EXPLORATION_PURPOSES.has(row.workPurpose)
+    || EXPLORATION_STAGES.has(row.workStage);
+}
+
+function projectLabel(row = {}) {
+  return row.projectAlias || row.projectPath || row.sessionId || row.source || 'unknown';
+}
+
+function providerFromSource(source) {
+  const value = String(source || '').toLowerCase();
+  if (value.includes('claude') || value.includes('anthropic')) return 'anthropic';
+  if (value.includes('codex') || value.includes('openai')) return 'openai';
+  if (value.includes('deepseek')) return 'deepseek';
+  if (value.includes('mimo') || value.includes('xiaomi')) return 'xiaomi';
+  return null;
+}
+
+function positive(value) {
+  const number = Number(value ?? 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}