token-studio 4.8.0

package/test/model-usage.test.mjs

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildModelUsageRows,
+  filterSessionsByDashboardFilters,
+  sessionModel
+} from '../src/client/dashboard/model-usage.js';
+
+const sessions = [
+  {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex-a',
+    model: 'gpt-5.5',
+    lastActivity: '2026-06-10',
+    totalTokens: 100,
+    costUSD: 0.01
+  },
+  {
+    device: 'devbox',
+    source: 'Claude Code',
+    sessionId: 'claude-a',
+    model: 'claude-opus-4-7',
+    lastActivity: '2026-06-10',
+    totalTokens: 50,
+    costUSD: 0.02
+  },
+  {
+    device: 'laptop',
+    source: 'Codex CLI',
+    sessionId: 'codex-b',
+    pricingModel: 'gpt-5.3-codex',
+    lastActivity: '2026-06-09',
+    totalTokens: 30,
+    costUSD: 0.03
+  }
+];
+
+const daily = [
+  {
+    usageDate: '2026-06-10',
+    source: 'Codex CLI',
+    model: 'gpt-5.5',
+    inputTokens: 60,
+    outputTokens: 40,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    cachedInputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 100,
+    costUSD: 0.01,
+    pricingStatus: 'priced'
+  },
+  {
+    usageDate: '2026-06-10',
+    source: 'Claude Code',
+    model: 'claude-opus-4-7',
+    inputTokens: 20,
+    outputTokens: 30,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    cachedInputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 50,
+    costUSD: 0.02,
+    pricingStatus: 'priced'
+  }
+];
+
+test('sessionModel falls back to pricingModel when API model is absent', () => {
+  assert.equal(sessionModel(sessions[2]), 'gpt-5.3-codex');
+});
+
+test('filterSessionsByDashboardFilters applies model filters to session data', () => {
+  const rows = filterSessionsByDashboardFilters(sessions, {
+    startDate: '2026-06-09',
+    endDate: '2026-06-10',
+    sources: new Set(),
+    devices: new Set(),
+    models: new Set(['gpt-5.5'])
+  });
+  assert.deepEqual(rows.map(row => row.sessionId), ['codex-a']);
+});
+
+test('buildModelUsageRows aggregates token cost and session counts by model', () => {
+  const rows = buildModelUsageRows(daily, sessions);
+  const byModel = Object.fromEntries(rows.map(row => [row.model, row]));
+
+  assert.equal(byModel['gpt-5.5'].totalTokens, 100);
+  assert.equal(byModel['gpt-5.5'].sessionCount, 1);
+  assert.equal(byModel['gpt-5.5'].dayCount, 1);
+  assert.equal(byModel['gpt-5.5'].pricingStatus, '已定价');
+
+  assert.equal(byModel['claude-opus-4-7'].totalTokens, 50);
+  assert.equal(byModel['claude-opus-4-7'].sources[0], 'Claude Code');
+
+  assert.equal(byModel['gpt-5.3-codex'].totalTokens, 30);
+  assert.equal(byModel['gpt-5.3-codex'].sessionCount, 1);
+});

package/test/official-pricing.test.mjs

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  calculateCost,
+  calculateOfficialCost,
+  resolveOfficialPricing
+} from '../src/pricing.mjs';
+
+test('calculates OpenAI API standard USD price from official per-token rates', () => {
+  const cost = calculateOfficialCost('gpt-5.5', {
+    input: 1_000_000,
+    cacheRead: 1_000_000,
+    output: 1_000_000
+  });
+
+  assert.equal(cost.priced, true);
+  assert.equal(cost.provider, 'openai');
+  assert.equal(cost.totalUSD, 35.5);
+  assert.equal(cost.ratesPerMTok.input, 5);
+  assert.equal(cost.ratesPerMTok.cachedInput, 0.5);
+  assert.equal(cost.ratesPerMTok.output, 30);
+});
+
+test('calculates Claude prompt-cache cost with official 5-minute cache write default', () => {
+  const cost = calculateOfficialCost('claude-opus-4-7', {
+    input: 1_000_000,
+    cacheWrite: 1_000_000,
+    cacheRead: 1_000_000,
+    output: 1_000_000
+  });
+
+  assert.equal(cost.priced, true);
+  assert.equal(cost.provider, 'anthropic');
+  assert.equal(cost.totalUSD, 36.75);
+  assert.equal(cost.ratesPerMTok.cacheWrite, 6.25);
+});
+
+test('supports official DeepSeek and Xiaomi cache-hit pricing', () => {
+  const deepseek = calculateOfficialCost('deepseek-v4-pro', {
+    input: 1_000_000,
+    cacheRead: 1_000_000,
+    output: 1_000_000
+  });
+  const mimo = calculateOfficialCost('mimo-v2.5-pro', {
+    input: 1_000_000,
+    cacheRead: 1_000_000,
+    output: 1_000_000
+  });
+
+  assert.equal(deepseek.totalUSD, 1.308625);
+  assert.equal(mimo.totalUSD, 1.3086);
+});
+
+test('does not invent prices for research-preview or unknown models', () => {
+  const spark = calculateOfficialCost('gpt-5.3-codex-spark', {
+    input: 1_000_000,
+    output: 1_000_000
+  });
+  const unknown = calculateCost('made-up-model', { input: 1_000_000, output: 1_000_000 });
+
+  assert.equal(spark.priced, false);
+  assert.equal(spark.totalUSD, 0);
+  assert.match(spark.reason, /research preview/);
+  assert.equal(unknown, 0);
+});
+
+test('resolves dated provider aliases without falling through to shorter model names', () => {
+  assert.equal(resolveOfficialPricing('openai/gpt-5.3-codex-spark').priced, false);
+  assert.equal(resolveOfficialPricing('claude-opus-4.7-20260420').model, 'claude-opus-4-7');
+});

package/test/onboarding.test.mjs

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildFirstRunState } from '../src/client/dashboard/onboarding.js';
+
+test('first-run state points empty databases to demo or import', () => {
+  const state = buildFirstRunState({
+    daily: [],
+    sessions: [],
+    budgetProfiles: [],
+    advisorActions: [],
+    tokenEvents: []
+  });
+  assert.equal(state.hasUsage, false);
+  assert.equal(state.shouldShow, true);
+  assert.equal(state.steps[0].status, 'todo');
+  assert.equal(state.notices[0].id, 'no-data');
+});
+
+test('first-run state asks review users to create advisor actions after usage exists', () => {
+  const state = buildFirstRunState({
+    daily: [{ usageDate: '2026-06-17', totalTokens: 100 }],
+    sessions: [{ sessionId: 's1', totalTokens: 100 }],
+    budgetProfiles: [],
+    advisorActions: [],
+    tokenEvents: []
+  });
+  assert.equal(state.hasUsage, true);
+  assert.equal(state.hasActions, false);
+  assert.ok(state.notices.some(notice => notice.id === 'no-actions'));
+});
+
+test('first-run state explains budgets without event-level live data', () => {
+  const state = buildFirstRunState({
+    daily: [{ usageDate: '2026-06-17', totalTokens: 100 }],
+    sessions: [{ sessionId: 's1', totalTokens: 100 }],
+    budgetProfiles: [{ id: 1, label: 'Codex 1h' }],
+    advisorActions: [{ id: 1, status: 'open' }],
+    tokenEvents: []
+  });
+  assert.equal(state.hasBudget, true);
+  assert.equal(state.hasLiveEvents, false);
+  assert.ok(state.notices.some(notice => notice.id === 'budget-no-live-events'));
+});
+
+test('first-run state hides when data, budgets, actions and live events exist', () => {
+  const state = buildFirstRunState({
+    daily: [{ usageDate: '2026-06-17', totalTokens: 100 }],
+    sessions: [{ sessionId: 's1', totalTokens: 100 }],
+    budgetProfiles: [{ id: 1, label: 'Codex 1h' }],
+    advisorActions: [{ id: 1, status: 'open' }],
+    tokenEvents: [{ eventId: 'e1', totalTokens: 100 }]
+  });
+  assert.equal(state.shouldShow, false);
+  assert.deepEqual(state.notices, []);
+});

package/test/privacy-check.test.mjs

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { runPrivacyCheck } from '../src/privacy-check.mjs';
+
+function gitFixture() {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-roi-privacy-'));
+  spawnSync('git', ['init'], { cwd: dir, stdio: 'ignore' });
+  return dir;
+}
+
+test('privacy check passes clean tracked docs', () => {
+  const dir = gitFixture();
+  writeFileSync(join(dir, 'README.md'), '# Demo\n\nNo private data.\n');
+  spawnSync('git', ['add', 'README.md'], { cwd: dir, stdio: 'ignore' });
+  const result = runPrivacyCheck({ cwd: dir });
+  assert.equal(result.ok, true);
+});
+
+test('privacy check blocks real db and personal paths', () => {
+  const dir = gitFixture();
+  mkdirSync(join(dir, 'data'));
+  writeFileSync(join(dir, 'data', 'usage.sqlite'), 'not a real sqlite but blocked by path');
+  writeFileSync(join(dir, 'notes.md'), 'Path: C:\\Users\\someone\\secret');
+  spawnSync('git', ['add', 'data/usage.sqlite', 'notes.md'], { cwd: dir, stdio: 'ignore' });
+  const result = runPrivacyCheck({ cwd: dir });
+  assert.equal(result.ok, false);
+  assert.equal(result.issues.some(issue => issue.id === 'sqlite-db'), true);
+  assert.equal(result.issues.some(issue => issue.id === 'personal-windows-path'), true);
+});

package/test/review-closure-progress.test.mjs

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildReviewClosureProgress,
+  hasClosureOutputLink,
+  isClosureAttributedSession
+} from '../src/client/review/closure-progress.js';
+
+const baseSession = {
+  device: 'local',
+  source: 'Codex CLI',
+  sessionId: 'session-1',
+  projectAlias: 'Token Studio',
+  taskType: '功能开发',
+  outputStatus: '已完成',
+  workPurpose: '功能开发',
+  workStage: '实现',
+  valueLevel: '高',
+  totalTokens: 1000,
+  costUSD: 1.2,
+  model: 'gpt-5.3-codex'
+};
+
+test('closure attribution requires project alias plus v3 review labels', () => {
+  assert.equal(isClosureAttributedSession(baseSession), true);
+  assert.equal(isClosureAttributedSession({ ...baseSession, projectAlias: '' }), false);
+  assert.equal(isClosureAttributedSession({ ...baseSession, valueLevel: '未评估' }), false);
+});
+
+test('closure output links only count completed or published http urls', () => {
+  assert.equal(hasClosureOutputLink({
+    ...baseSession,
+    outputStatus: '已发布',
+    outputUrl: 'https://example.com/pr/1'
+  }), true);
+  assert.equal(hasClosureOutputLink({
+    ...baseSession,
+    outputStatus: '进行中',
+    outputUrl: 'https://example.com/pr/1'
+  }), false);
+  assert.equal(hasClosureOutputLink({
+    ...baseSession,
+    outputStatus: '已完成',
+    outputUrl: 'file:///private.txt'
+  }), false);
+});
+
+test('buildReviewClosureProgress tracks P0 real-data acceptance gates', () => {
+  const completeSessions = Array.from({ length: 10 }, (_, index) => ({
+    ...baseSession,
+    sessionId: `complete-${index + 1}`,
+    totalTokens: 1000 + index,
+    costUSD: 1 + index / 10,
+    outputStatus: index < 3 ? '已发布' : '已完成',
+    outputUrl: index < 3 ? `https://example.com/output/${index + 1}` : ''
+  }));
+
+  const progress = buildReviewClosureProgress({
+    sessions: [
+      ...completeSessions,
+      {
+        ...baseSession,
+        sessionId: 'missing-project',
+        projectAlias: '',
+        totalTokens: 9000,
+        costUSD: 9
+      }
+    ],
+    roiAdvice: [
+      { id: 'attribute-high-cost-work', category: '补标注' },
+      { id: 'reduce-context-bloat', category: '上下文压缩' }
+    ]
+  });
+
+  assert.equal(progress.status, 'complete');
+  assert.equal(progress.completedChecks, 4);
+  assert.equal(progress.checks.find(check => check.id === 'real-attribution').current, 10);
+  assert.equal(progress.checks.find(check => check.id === 'lazy-auto-attribution').complete, true);
+  assert.equal(progress.checks.find(check => check.id === 'output-links').current, 3);
+  assert.equal(progress.checks.find(check => check.id === 'non-label-advice').current, 1);
+  assert.deepEqual(progress.topGaps[0].missingFields, ['项目别名']);
+});
+
+test('buildReviewClosureProgress surfaces next actions when gates are not met', () => {
+  const progress = buildReviewClosureProgress({
+    sessions: [
+      { ...baseSession, sessionId: 'missing-value', valueLevel: '未评估', totalTokens: 5000, costUSD: 5 },
+      { ...baseSession, sessionId: 'missing-project', projectAlias: '', totalTokens: 7000, costUSD: 7 }
+    ],
+    roiAdvice: [{ id: 'attribute-high-cost-work', category: '补标注' }]
+  });
+
+  assert.equal(progress.status, 'needs-work');
+  assert.equal(progress.remainingChecks, 4);
+  assert.equal(progress.topGaps[0].sessionId, 'missing-project');
+  assert.match(progress.nextActions.join('\n'), /先处理 missing-project/);
+  assert.match(progress.nextActions.join('\n'), /产出链接/);
+  assert.match(progress.nextActions.join('\n'), /ROI Advisor/);
+});

package/test/roi-advisor.test.mjs

@@ -0,0 +1,188 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildRoiAdvisor,
+  isRoiUnattributed,
+  modelTier
+} from '../src/client/review/roi-advisor.js';
+
+test('modelTier classifies heavy, mid, light and unpriced models', () => {
+  assert.equal(modelTier('gpt-5.5', 'priced'), 'heavy');
+  assert.equal(modelTier('claude-opus-4-7', 'priced'), 'heavy');
+  assert.equal(modelTier('gpt-5.3-codex', 'priced'), 'mid');
+  assert.equal(modelTier('claude-sonnet-4-6', 'priced'), 'mid');
+  assert.equal(modelTier('deepseek-v4-pro', 'priced'), 'light');
+  assert.equal(modelTier('mimo-v2.5-pro', 'priced'), 'light');
+  assert.equal(modelTier('gpt-5.3-codex-spark', 'unpriced'), 'unpriced');
+  assert.equal(modelTier('<synthetic>', ''), 'unpriced');
+});
+
+test('isRoiUnattributed requires purpose and value, not just task status', () => {
+  assert.equal(isRoiUnattributed({
+    taskType: '功能开发',
+    outputStatus: '已完成',
+    workPurpose: '功能开发',
+    workStage: '实现',
+    valueLevel: '高'
+  }), false);
+  assert.equal(isRoiUnattributed({
+    taskType: '功能开发',
+    outputStatus: '已完成',
+    workPurpose: '未说明',
+    workStage: '实现',
+    valueLevel: '高'
+  }), true);
+  assert.equal(isRoiUnattributed({
+    taskType: '功能开发',
+    outputStatus: '已完成',
+    workPurpose: '功能开发',
+    workStage: '未说明',
+    valueLevel: '高'
+  }), true);
+});
+
+test('advisor prioritizes high cost unattributed work', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      projectPath: 'D:\\AIResume',
+      model: 'gpt-5.5',
+      taskType: '未分类',
+      outputStatus: '未标注',
+      workPurpose: '未说明',
+      valueLevel: '未评估',
+      inputTokens: 800_000,
+      outputTokens: 40_000,
+      cacheReadTokens: 0,
+      totalTokens: 1_000_000,
+      costUSD: 20,
+      pricingStatus: 'priced'
+    }]
+  });
+
+  assert.equal(suggestions[0].id, 'attribute-high-cost-work');
+  assert.equal(suggestions[0].category, '补标注');
+  assert.equal(suggestions[0].impact, '高');
+  assert.match(suggestions[0].recommendation, /主要目的/);
+});
+
+test('advisor recommends light models for testing and exploration on heavy models', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      model: 'claude-opus-4-7',
+      taskType: '问题修复',
+      outputStatus: '进行中',
+      workPurpose: '测试验证',
+      workStage: '验证',
+      valueLevel: '中',
+      inputTokens: 100_000,
+      outputTokens: 20_000,
+      cacheReadTokens: 0,
+      totalTokens: 120_000,
+      costUSD: 5,
+      pricingStatus: 'priced'
+    }]
+  });
+
+  const suggestion = suggestions.find(item => item.id === 'use-light-model-for-exploration');
+  assert.ok(suggestion);
+  assert.equal(suggestion.category, '模型切换');
+});
+
+test('advisor flags discarded or low value high cost work as stop-loss risk', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      model: 'gpt-5.5',
+      taskType: '技术调研',
+      outputStatus: '已废弃',
+      workPurpose: '技术调研',
+      workStage: '探索',
+      valueLevel: '低',
+      inputTokens: 400_000,
+      outputTokens: 20_000,
+      cacheReadTokens: 0,
+      totalTokens: 500_000,
+      costUSD: 15,
+      pricingStatus: 'priced'
+    }]
+  });
+
+  const suggestion = suggestions.find(item => item.id === 'stop-loss-low-value-work');
+  assert.ok(suggestion);
+  assert.equal(suggestion.category, '止损');
+});
+
+test('advisor preserves high value completed work on light or mid models', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      model: 'deepseek-v4-pro',
+      taskType: '功能开发',
+      outputStatus: '已发布',
+      workPurpose: '功能开发',
+      workStage: '发布',
+      valueLevel: '关键',
+      inputTokens: 100_000,
+      outputTokens: 50_000,
+      cacheReadTokens: 10_000,
+      totalTokens: 160_000,
+      costUSD: 0.2,
+      pricingStatus: 'priced'
+    }]
+  });
+
+  const suggestion = suggestions.find(item => item.id === 'keep-high-value-low-cost-pattern');
+  assert.ok(suggestion);
+  assert.equal(suggestion.category, '保留策略');
+});
+
+test('advisor does not preserve high value work when the session is still high cost', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      model: 'claude-sonnet-4-6',
+      taskType: '功能开发',
+      outputStatus: '已发布',
+      workPurpose: '功能开发',
+      workStage: '发布',
+      valueLevel: '关键',
+      inputTokens: 900_000,
+      outputTokens: 100_000,
+      cacheReadTokens: 0,
+      totalTokens: 1_000_000,
+      costUSD: 20,
+      pricingStatus: 'priced'
+    }]
+  });
+
+  assert.equal(suggestions.some(item => item.id === 'keep-high-value-low-cost-pattern'), false);
+});
+
+test('advisor emits context compression and unpriced model advice without fake cost', () => {
+  const suggestions = buildRoiAdvisor({
+    sessions: [{
+      sessionId: 's1',
+      model: 'gpt-5.3-codex-spark',
+      taskType: '功能开发',
+      outputStatus: '已完成',
+      workPurpose: '功能开发',
+      workStage: '实现',
+      valueLevel: '中',
+      inputTokens: 900_000,
+      outputTokens: 50_000,
+      cacheReadTokens: 0,
+      totalTokens: 1_000_000,
+      costUSD: 0,
+      pricingStatus: 'unpriced'
+    }]
+  });
+
+  assert.equal(suggestions.some(item => item.id === 'reduce-context-bloat'), true);
+  assert.equal(suggestions.find(item => item.id === 'reduce-context-bloat')?.category, '上下文压缩');
+  const unpriced = suggestions.find(item => item.id === 'keep-unpriced-models-out-of-cost-decisions');
+  assert.ok(unpriced);
+  assert.equal(unpriced.category, '未定价模型');
+  assert.match(unpriced.recommendation, /不把 \$0 当成免费/);
+});

package/test/roi-evidence.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildRoiEvidence } from '../src/client/review/roi-evidence.js';
+
+test('ROI evidence score rewards complete manual attribution and outputs', () => {
+  const evidence = buildRoiEvidence({
+    workItems: [{ id: 1 }],
+    sessions: [
+      {
+        projectAlias: 'Token Studio ROI',
+        taskType: '功能开发',
+        outputStatus: '已发布',
+        workPurpose: '功能开发',
+        workStage: '发布',
+        valueLevel: '高',
+        annotationSource: 'manual',
+        outputUrl: 'https://example.com/pr/1',
+        totalTokens: 1000,
+        costUSD: 1
+      }
+    ]
+  });
+  assert.equal(evidence.evidenceScore, 100);
+  assert.equal(evidence.complete, 1);
+  assert.equal(evidence.withOutput, 1);
+});
+
+test('ROI evidence surfaces high cost gaps when fields are missing', () => {
+  const evidence = buildRoiEvidence({
+    sessions: [
+      {
+        projectPath: 'D:/Projects/token-studio-roi',
+        taskType: '未分类',
+        outputStatus: '未标注',
+        workPurpose: '未说明',
+        workStage: '未说明',
+        valueLevel: '未评估',
+        annotationSource: 'auto',
+        annotationConfidence: 85,
+        sessionId: 's1',
+        totalTokens: 5000,
+        costUSD: 9
+      }
+    ]
+  });
+  assert.equal(evidence.evidenceScore < 50, true);
+  assert.equal(evidence.highCostGaps[0].missing.includes('人工确认'), true);
+});

package/test/roi-summary.test.mjs

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildProjectRoiRows,
+  buildRiskDistribution,
+  buildWeeklyReview
+} from '../src/client/dashboard/attribution.js';
+
+const sessions = [
+  {
+    sessionId: 'published',
+    projectAlias: 'Token Studio',
+    taskType: '功能开发',
+    outputStatus: '已发布',
+    lastActivity: '2026-06-10',
+    totalTokens: 1000,
+    costUSD: 1,
+    outputUrl: 'https://example.com/published',
+    outputLabel: '发布页'
+  },
+  {
+    sessionId: 'completed',
+    projectAlias: 'Token Studio',
+    taskType: '问题修复',
+    outputStatus: '已完成',
+    lastActivity: '2026-06-09',
+    totalTokens: 500,
+    costUSD: 0.5
+  },
+  {
+    sessionId: 'discarded',
+    projectPath: 'D:\\Other',
+    taskType: '技术调研',
+    outputStatus: '已废弃',
+    lastActivity: '2026-06-08',
+    totalTokens: 300,
+    costUSD: 0.3
+  },
+  {
+    sessionId: 'unattributed',
+    projectPath: 'D:\\Other',
+    taskType: '未分类',
+    outputStatus: '进行中',
+    lastActivity: '2026-06-07',
+    totalTokens: 200,
+    costUSD: 0.2
+  },
+  {
+    sessionId: 'old',
+    projectAlias: 'Old Project',
+    taskType: '功能开发',
+    outputStatus: '已发布',
+    lastActivity: '2026-05-01',
+    totalTokens: 900,
+    costUSD: 0.9,
+    outputUrl: 'https://example.com/old'
+  }
+];
+
+test('buildRiskDistribution aggregates unattributed, in-progress and discarded cost shares', () => {
+  const rows = buildRiskDistribution(sessions);
+  const byId = Object.fromEntries(rows.map(row => [row.id, row]));
+
+  assert.equal(byId.unattributed.sessionCount, 1);
+  assert.equal(byId.unattributed.totalTokens, 200);
+  assert.equal(byId.inProgress.sessionCount, 1);
+  assert.equal(byId.inProgress.totalTokens, 200);
+  assert.equal(byId.discarded.sessionCount, 1);
+  assert.equal(byId.discarded.costUSD, 0.3);
+  assert.equal(Number(byId.discarded.share.toFixed(4)), Number((300 / 2900).toFixed(4)));
+});
+
+test('buildProjectRoiRows keeps project status buckets consistent with session totals', () => {
+  const rows = buildProjectRoiRows(sessions);
+  const tokenStudio = rows.find(row => row.project === 'Token Studio');
+  const other = rows.find(row => row.project === 'D:\\Other');
+
+  assert.equal(tokenStudio.sessionCount, 2);
+  assert.equal(tokenStudio.totalTokens, 1500);
+  assert.equal(tokenStudio.publishedTokens, 1000);
+  assert.equal(tokenStudio.completedTokens, 500);
+  assert.equal(tokenStudio.productiveShare, 1);
+
+  assert.equal(other.totalTokens, 500);
+  assert.equal(other.discardedTokens, 300);
+  assert.equal(other.unattributedTokens, 200);
+  assert.equal(other.riskShare, 1);
+});
+
+test('buildWeeklyReview uses the last seven days and exposes published output links', () => {
+  const weekly = buildWeeklyReview(sessions, { today: '2026-06-10' });
+
+  assert.equal(weekly.startDate, '2026-06-04');
+  assert.equal(weekly.endDate, '2026-06-10');
+  assert.equal(weekly.totals.totalTokens, 2000);
+  assert.equal(weekly.highCostProjects[0].project, 'Token Studio');
+  assert.equal(weekly.discarded.totalTokens, 300);
+  assert.deepEqual(weekly.unattributedQueue.map(row => row.sessionId), ['unattributed']);
+  assert.equal(weekly.publishedOutputs.length, 1);
+  assert.equal(weekly.publishedOutputs[0].outputLabel, '发布页');
+});