token-studio 4.8.0

package/test/import-budget.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  applyBudgetTemplate,
+  buildCcusageBridgeCommand,
+  defaultResetAnchor
+} from '../src/client/dashboard/import-budget.js';
+
+test('ccusage bridge command builder only emits explicit local CLI commands', () => {
+  assert.equal(
+    buildCcusageBridgeCommand({ report: 'blocks' }),
+    'npx token-studio import-usage --format=ccusage-cli --report=blocks --dry-run --yes'
+  );
+  assert.equal(
+    buildCcusageBridgeCommand({ report: 'weekly', apply: true }),
+    'npx token-studio import-usage --format=ccusage-cli --report=weekly --apply --yes'
+  );
+  assert.equal(
+    buildCcusageBridgeCommand({ report: 'unknown' }),
+    'npx token-studio import-usage --format=ccusage-cli --report=session --dry-run --yes'
+  );
+});
+
+test('budget templates fill editable fixed-window guardrail fields', () => {
+  const reset = defaultResetAnchor(new Date('2026-06-17T02:13:45Z'));
+  assert.equal(reset, '2026-06-17T02:13');
+
+  const next = applyBudgetTemplate(
+    { tokenBudget: '500000' },
+    { label: 'Codex 5h', source: 'Codex CLI', windowType: 'fixed', windowMinutes: 300, warningThreshold: 0.7 },
+    new Date('2026-06-17T02:13:45Z')
+  );
+  assert.equal(next.source, 'Codex CLI');
+  assert.equal(next.label, 'Codex 5h');
+  assert.equal(next.windowType, 'fixed');
+  assert.equal(next.windowMinutes, 300);
+  assert.equal(next.warningThreshold, 0.7);
+  assert.equal(next.resetAnchor, '2026-06-17T02:13');
+  assert.equal(next.tokenBudget, '500000');
+});

package/test/live.test.mjs

@@ -0,0 +1,256 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildLiveGuardrails, buildLiveSnapshot } from '../src/live.mjs';
+import { openDb, upsertTokenEvent } from '../src/db.mjs';
+
+test('live snapshot uses recent token events for burn rate and cache hit', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    windowMinutes: 15,
+    sessions: [{
+      device: 'demo',
+      source: 'Codex CLI',
+      sessionId: 'old',
+      lastActivity: '2026-06-17T01:00:00Z',
+      totalTokens: 99999
+    }],
+    tokenEvents: [{
+      eventId: 'e1',
+      device: 'demo',
+      source: 'Cursor',
+      sessionId: 's1',
+      timestamp: '2026-06-17T02:10:00Z',
+      model: 'gpt-5.3-codex',
+      inputTokens: 1000,
+      outputTokens: 250,
+      cacheReadTokens: 500
+    }]
+  });
+  assert.equal(snapshot.status, 'active');
+  assert.equal(snapshot.totals.totalTokens, 1750);
+  assert.equal(snapshot.totals.burnRateTokensPerHour, 7000);
+  assert.equal(snapshot.bySource[0].key, 'Cursor');
+  assert.equal(snapshot.activeSessions.length, 0);
+  assert.ok(snapshot.totals.cacheHitRate > 0);
+});
+
+test('live snapshot reports idle empty state', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    sessions: [],
+    tokenEvents: []
+  });
+  assert.equal(snapshot.status, 'idle');
+  assert.equal(snapshot.totals.totalTokens, 0);
+  assert.deepEqual(snapshot.byModel, []);
+});
+
+test('live guardrails warn on burn rate, low cache hit, low output/input and unpriced models', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    windowMinutes: 15,
+    tokenEvents: [{
+      eventId: 'e1',
+      device: 'demo',
+      source: 'Codex CLI',
+      sessionId: 's1',
+      timestamp: '2026-06-17T02:10:00Z',
+      model: 'gpt-5.3-codex-spark',
+      inputTokens: 20_000,
+      outputTokens: 500,
+      cacheReadTokens: 0
+    }]
+  });
+  const types = snapshot.warnings.map(item => item.type).sort();
+  assert.deepEqual(types, [
+    'high-burn-rate',
+    'low-cache-hit',
+    'low-output-input-ratio',
+    'unpriced-model-active'
+  ].sort());
+  assert.equal(snapshot.guardrails.tokenBudgetPerHour, 50_000);
+});
+
+test('live guardrail thresholds can be overridden', () => {
+  const warnings = buildLiveGuardrails({
+    totals: {
+      inputTokens: 20_000,
+      outputTokens: 500,
+      cacheReadTokens: 0,
+      totalTokens: 20_500,
+      burnRateTokensPerHour: 60_000,
+      cacheHitRate: 50
+    },
+    byModel: [{ key: 'gpt-5.3-codex', totalTokens: 20_500 }]
+  }, {
+    tokenBudgetPerHour: 100_000,
+    minCacheHitRate: 0.1,
+    minOutputInputRatio: 0.01,
+    highInputTokens: 10_000
+  });
+  assert.deepEqual(warnings, []);
+});
+
+test('live snapshot builds budget windows and budget warnings', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    windowMinutes: 15,
+    budgetProfiles: [{
+      id: 1,
+      source: 'Codex CLI',
+      label: 'Codex 15m',
+      windowMinutes: 15,
+      tokenBudget: 10_000,
+      costBudgetUSD: 0,
+      enabled: true
+    }],
+    tokenEvents: [{
+      eventId: 'e1',
+      device: 'demo',
+      source: 'Codex CLI',
+      sessionId: 's1',
+      timestamp: '2026-06-17T02:10:00Z',
+      model: 'gpt-5.3-codex',
+      inputTokens: 9_000,
+      outputTokens: 1_000
+    }]
+  });
+  assert.equal(snapshot.budgetWindows.length, 1);
+  assert.equal(snapshot.budgetWindows[0].status, 'exceeded');
+  assert.ok(snapshot.warnings.some(item => item.type === 'budget-exceeded'));
+});
+
+test('live snapshot warns when current pace will exceed custom budget', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    windowMinutes: 15,
+    budgetProfiles: [{
+      id: 1,
+      source: 'Codex CLI',
+      label: 'Codex 15m',
+      windowMinutes: 15,
+      tokenBudget: 12_000,
+      enabled: true
+    }],
+    tokenEvents: [{
+      eventId: 'e1',
+      device: 'demo',
+      source: 'Codex CLI',
+      sessionId: 's1',
+      timestamp: '2026-06-17T02:12:00Z',
+      model: 'gpt-5.3-codex',
+      inputTokens: 8_000,
+      outputTokens: 1_000
+    }]
+  });
+  assert.equal(snapshot.budgetWindows[0].status, 'over-pace');
+  assert.ok(snapshot.warnings.some(item => item.type === 'over-budget-pace'));
+});
+
+test('live snapshot supports fixed budget reset windows and custom near threshold', () => {
+  const snapshot = buildLiveSnapshot({
+    now: new Date('2026-06-17T02:15:00Z'),
+    windowMinutes: 15,
+    budgetProfiles: [{
+      id: 1,
+      source: 'Codex CLI',
+      label: 'Codex fixed hour',
+      windowType: 'fixed',
+      windowMinutes: 60,
+      resetAnchor: '2026-06-17T00:00:00Z',
+      warningThreshold: 0.2,
+      tokenBudget: 10_000,
+      enabled: true
+    }],
+    tokenEvents: [{
+      eventId: 'e1',
+      device: 'demo',
+      source: 'Codex CLI',
+      sessionId: 's1',
+      timestamp: '2026-06-17T02:10:00Z',
+      model: 'gpt-5.3-codex',
+      inputTokens: 1_800,
+      outputTokens: 400
+    }]
+  });
+  const window = snapshot.budgetWindows[0];
+  assert.equal(window.windowType, 'fixed');
+  assert.equal(window.windowStart, '2026-06-17T02:00:00.000Z');
+  assert.equal(window.windowEnd, '2026-06-17T03:00:00.000Z');
+  assert.equal(window.resetInMinutes, 45);
+  assert.equal(window.warningThreshold, 0.2);
+  assert.equal(window.status, 'near-limit');
+  assert.ok(snapshot.warnings.some(item => item.type === 'near-budget-limit'));
+});
+
+
+test('live API returns guardrails and warnings from temporary SQLite', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-live-api-'));
+  const dbPath = join(dir, 'usage.sqlite');
+  const port = 6100 + Math.floor(Math.random() * 1000);
+  const db = openDb(dbPath);
+  try {
+    upsertTokenEvent(db, {
+      eventId: 'live-api-warning',
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 's1',
+      timestamp: new Date().toISOString(),
+      model: 'gpt-5.3-codex-spark',
+      inputTokens: 20_000,
+      outputTokens: 100
+    });
+  } finally {
+    db.close();
+  }
+
+  const child = spawn(process.execPath, ['src/server.mjs'], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PORT: String(port),
+      DB_PATH: dbPath,
+      SCHEDULED_COLLECT_ENABLED: 'false'
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+
+  try {
+    await waitForLiveApi(port);
+    const response = await fetch(`http://127.0.0.1:${port}/api/live`);
+    if (!response.ok) assert.fail(await response.text());
+    const body = await response.json();
+    assert.equal(body.guardrails.tokenBudgetPerHour, 50_000);
+    assert.ok(body.warnings.some(item => item.type === 'high-burn-rate'));
+  } finally {
+    await stopChild(child);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+async function waitForLiveApi(port) {
+  const start = Date.now();
+  while (Date.now() - start < 5000) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/api/live`);
+      if (response.ok) return;
+    } catch {
+      // Retry while the server starts.
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('live API did not start in time');
+}
+
+function stopChild(child) {
+  if (child.exitCode != null) return Promise.resolve();
+  return new Promise(resolve => {
+    child.once('close', resolve);
+    child.kill();
+  });
+}

package/test/markdown-report.test.mjs

@@ -0,0 +1,193 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildMarkdownReviewReport,
+  buildModelRows,
+  buildReviewReportFilename
+} from '../src/client/review/markdown-report.js';
+
+const period = {
+  pretty: '2026 年 6 月',
+  start: '2026-06-01',
+  end: '2026-06-12'
+};
+
+test('buildMarkdownReviewReport renders the fixed weekly review structure', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [],
+    sessions: [],
+    roiAdvice: [],
+    generatedAt: new Date(2026, 5, 12, 9, 30)
+  });
+
+  assert.match(report, /^# Token Studio Weekly Review/);
+  assert.match(report, /## 1\. 本期总览/);
+  assert.match(report, /## 8\. 本周行动状态/);
+  assert.match(report, /## 10\. 口径说明/);
+  assert.match(report, /## 6\. 节省模拟/);
+  assert.match(report, /官方公开 token 单价换算，不是供应商账单/);
+  assert.match(report, /不读取、不导出对话正文/);
+});
+
+test('buildMarkdownReviewReport includes advisor action workflow status', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [],
+    sessions: [],
+    advisorActions: [{
+      periodStart: '2026-06-01',
+      periodEnd: '2026-06-12',
+      status: 'done',
+      category: '节省模拟',
+      title: '测试验证改用轻量模型',
+      action: '下周测试验证默认先用轻量模型',
+      sourceRule: 'savings:test'
+    }]
+  });
+
+  assert.match(report, /已完成 \| 节省模拟 \| 测试验证改用轻量模型 \| 下周测试验证默认先用轻量模型/);
+  assert.match(report, /不证明真实因果节省/);
+});
+
+test('buildMarkdownReviewReport includes unattributed work and advisor actions', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [{
+      usageDate: '2026-06-10',
+      source: 'Codex CLI',
+      model: 'gpt-5.5',
+      totalTokens: 1000,
+      inputTokens: 800,
+      outputTokens: 100,
+      cacheReadTokens: 50,
+      costUSD: 1
+    }],
+    sessions: [{
+      sessionId: 's1',
+      projectPath: 'D:\\AIResume',
+      taskType: '未分类',
+      outputStatus: '未标注',
+      totalTokens: 1000,
+      costUSD: 1
+    }],
+    roiAdvice: [{
+      title: '先补齐高成本会话',
+      category: '补标注',
+      impact: '高',
+      recommendation: '补用途和价值',
+      reason: '缺少归因字段',
+      evidence: '1 个 session 未归因',
+      action: '先标注最高成本 session'
+    }],
+    generatedAt: new Date(2026, 5, 12, 9, 30)
+  });
+
+  assert.match(report, /未归因 session \| 1/);
+  assert.match(report, /建议分类：补标注/);
+  assert.match(report, /先标注最高成本 session/);
+  assert.match(report, /补齐 D:\\AIResume 的 session 标注/);
+});
+
+test('buildMarkdownReviewReport lists highest-cost review attribution gaps first', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [],
+    sessions: [
+      {
+        sessionId: 'low-cost-gap',
+        projectAlias: 'Low Cost',
+        taskType: '未分类',
+        outputStatus: '未标注',
+        totalTokens: 100,
+        costUSD: 0.02,
+        lastActivity: '2026-06-09'
+      },
+      {
+        sessionId: 'high-cost-gap',
+        projectAlias: 'Token Studio',
+        taskType: '功能开发',
+        outputStatus: '已完成',
+        workPurpose: '未说明',
+        workStage: '未说明',
+        valueLevel: '未评估',
+        totalTokens: 5000,
+        costUSD: 2.5,
+        lastActivity: '2026-06-12'
+      }
+    ]
+  });
+
+  const highIndex = report.indexOf('high-cost-gap');
+  const lowIndex = report.indexOf('low-cost-gap');
+  assert.match(report, /### 高成本待补齐归因/);
+  assert.ok(highIndex > -1);
+  assert.ok(lowIndex > -1);
+  assert.ok(highIndex < lowIndex);
+  assert.match(report, /工作目的、工作阶段、产出价值/);
+  assert.match(report, /Token Studio \| high-cost-gap \| 工作目的、工作阶段、产出价值 \| missing \| 5,000 \| \$2\.50 \| 2026-06-12/);
+});
+
+test('buildMarkdownReviewReport includes published output links without fetching content', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [],
+    sessions: [{
+      sessionId: 'published',
+      projectAlias: 'Token Studio',
+      taskType: '功能开发',
+      outputStatus: '已发布',
+      outputType: 'PR',
+      outputLabel: 'v3.1 PR',
+      outputUrl: 'https://example.com/pr/1',
+      totalTokens: 100,
+      costUSD: 0.1
+    }]
+  });
+
+  assert.match(report, /已发布 \| PR \| v3\.1 PR \| Token Studio \| \[v3\.1 PR\]\(https:\/\/example.com\/pr\/1\)/);
+});
+
+test('buildMarkdownReviewReport keeps unpriced model wording and escapes spreadsheet formula prefixes', () => {
+  const report = buildMarkdownReviewReport({
+    period,
+    daily: [{
+      usageDate: '2026-06-10',
+      source: 'Codex CLI',
+      model: '=IMPORTXML("https://example.com")',
+      totalTokens: 100,
+      inputTokens: 80,
+      outputTokens: 20,
+      cacheReadTokens: 0,
+      costUSD: 0
+    }],
+    sessions: [{
+      sessionId: 's1',
+      projectAlias: '+cmd|danger',
+      taskType: '功能开发',
+      outputStatus: '已完成',
+      totalTokens: 100,
+      costUSD: 0
+    }]
+  });
+
+  assert.match(report, /未定价\/无官方价/);
+  assert.match(report, /'\=IMPORTXML/);
+  assert.match(report, /'\+cmd\\\|danger/);
+});
+
+test('buildModelRows aggregates by model and source', () => {
+  const rows = buildModelRows([
+    { source: 'Codex CLI', model: 'gpt-5.5', totalTokens: 100, costUSD: 1 },
+    { source: 'Codex CLI', model: 'gpt-5.5', totalTokens: 50, costUSD: 0.5 },
+    { source: 'Claude Code', model: 'claude-sonnet', totalTokens: 25, costUSD: 0.1 }
+  ]);
+
+  assert.equal(rows[0].model, 'gpt-5.5');
+  assert.equal(rows[0].totalTokens, 150);
+  assert.equal(rows[0].share, 150 / 175);
+});
+
+test('buildReviewReportFilename uses the active period end date', () => {
+  assert.equal(buildReviewReportFilename(period), 'token-studio-review-2026-06-12.md');
+});

package/test/model-policy.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildModelPolicy, formatModelPolicy, formatModelPolicyMarkdown } from '../src/model-policy.mjs';
+
+test('model policy builds executable local rules without LLM calls', () => {
+  const policy = buildModelPolicy({
+    generatedAt: new Date('2026-06-17T00:00:00Z'),
+    sessions: [
+      { workPurpose: '测试验证', workStage: '验证', valueLevel: '中', outputStatus: '已完成', totalTokens: 1200 },
+      { workPurpose: '功能开发', workStage: '实现', valueLevel: '高', outputStatus: '已发布', totalTokens: 5000 }
+    ]
+  });
+  assert.equal(policy.rules.length, 3);
+  const markdown = formatModelPolicyMarkdown(policy);
+  assert.match(markdown, /Token Studio Model Policy/);
+  assert.match(markdown, /Testing|测试|light/i);
+  assert.doesNotMatch(markdown, /prompt|response body/i);
+});
+
+test('model policy formats Claude and AGENTS snippets without writing files', () => {
+  const policy = buildModelPolicy({
+    generatedAt: new Date('2026-06-17T00:00:00Z'),
+    sessions: [
+      { workPurpose: '上下文整理', workStage: '探索', valueLevel: '低', outputStatus: '进行中', totalTokens: 3000 }
+    ]
+  });
+  const claude = formatModelPolicy(policy, 'claude-md');
+  const agents = formatModelPolicy(policy, 'agents-md');
+  assert.match(claude, /Claude Code/);
+  assert.match(claude, /lightweight models/);
+  assert.match(agents, /Agent Policy/);
+  assert.match(agents, /Do not automatically edit/);
+  assert.doesNotMatch(`${claude}\n${agents}`, /secret prompt|private response|actual transcript/i);
+});

package/test/model-strategy.test.mjs

@@ -0,0 +1,116 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildModelRowsFromSessions,
+  buildModelStrategy,
+  hasStrategyAnnotation
+} from '../src/client/review/model-strategy.js';
+
+const sessions = [
+  {
+    sessionId: 'explore-heavy',
+    model: 'gpt-5.5',
+    taskType: '技术调研',
+    workStage: '探索',
+    valueLevel: '中',
+    outputStatus: '进行中',
+    totalTokens: 1000,
+    costUSD: 10,
+    pricingStatus: 'priced'
+  },
+  {
+    sessionId: 'ship-light',
+    model: 'deepseek-v4-pro',
+    taskType: '功能开发',
+    workStage: '发布',
+    valueLevel: '关键',
+    outputStatus: '已发布',
+    totalTokens: 500,
+    costUSD: 0.1,
+    pricingStatus: 'priced'
+  },
+  {
+    sessionId: 'waste-mid',
+    model: 'claude-sonnet-4-6',
+    taskType: '技术调研',
+    workStage: '验证',
+    valueLevel: '低',
+    outputStatus: '已废弃',
+    totalTokens: 400,
+    costUSD: 2,
+    pricingStatus: 'priced'
+  },
+  {
+    sessionId: 'unlabeled',
+    model: 'gpt-5.3-codex-spark',
+    taskType: '未分类',
+    workStage: '未说明',
+    valueLevel: '未评估',
+    outputStatus: '未标注',
+    totalTokens: 300,
+    costUSD: 0,
+    pricingStatus: 'unpriced'
+  }
+];
+
+test('hasStrategyAnnotation requires at least one strategy field', () => {
+  assert.equal(hasStrategyAnnotation(sessions[0]), true);
+  assert.equal(hasStrategyAnnotation(sessions[3]), false);
+});
+
+test('buildModelRowsFromSessions aggregates model usage and risk shares', () => {
+  const rows = buildModelRowsFromSessions(sessions);
+  const heavy = rows.find(row => row.model === 'gpt-5.5');
+  const risky = rows.find(row => row.model === 'claude-sonnet-4-6');
+
+  assert.equal(rows[0].model, 'gpt-5.5');
+  assert.equal(heavy.tier, 'heavy');
+  assert.equal(heavy.totalTokens, 1000);
+  assert.equal(risky.riskShare, 1);
+});
+
+test('buildModelStrategy groups by task stage and value', () => {
+  const strategy = buildModelStrategy({ sessions });
+
+  assert.equal(strategy.coverage.sessionCount, 4);
+  assert.equal(strategy.coverage.annotatedSessionCount, 3);
+  assert.equal(strategy.byTaskType[0].key, '技术调研');
+  assert.equal(strategy.byTaskType[0].topModel, 'gpt-5.5');
+  assert.equal(strategy.byStage.some(row => row.key === '发布'), true);
+  assert.equal(strategy.byValue.some(row => row.key === '关键'), true);
+});
+
+test('buildModelStrategy builds a light mid heavy model playbook from annotations', () => {
+  const strategy = buildModelStrategy({ sessions });
+
+  assert.equal(strategy.playbook.length, 3);
+  const light = strategy.playbook.find(row => row.id === 'light-default');
+  const mid = strategy.playbook.find(row => row.id === 'mid-implementation');
+  const heavy = strategy.playbook.find(row => row.id === 'heavy-review');
+
+  assert.equal(light.label, '轻量默认');
+  assert.equal(light.evidenceState, '已观察');
+  assert.equal(light.sessionCount, 2);
+  assert.equal(light.topModel, 'gpt-5.5');
+  assert.equal(mid.label, '中模型实现');
+  assert.equal(mid.sessionCount, 1);
+  assert.equal(heavy.label, '重模型审查');
+  assert.equal(heavy.sessionCount, 1);
+  assert.match(heavy.action, /关键发布/);
+});
+
+test('buildModelStrategy emits model policy recommendations', () => {
+  const strategy = buildModelStrategy({ sessions });
+  const ids = strategy.recommendations.map(item => item.id);
+
+  assert.equal(ids.includes('light-model-for-exploration'), true);
+  assert.equal(ids.includes('keep-high-value-pattern'), true);
+  assert.equal(ids.some(id => id.startsWith('risk-claude-sonnet')), true);
+});
+
+test('buildModelStrategy asks for labels when coverage is low', () => {
+  const strategy = buildModelStrategy({ sessions: [sessions[3], { ...sessions[3], sessionId: 'u2' }] });
+  assert.equal(strategy.coverage.annotatedSessionCount, 0);
+  assert.equal(strategy.playbook[0].evidenceState, '待标注验证');
+  assert.equal(strategy.recommendations[0].id, 'label-before-model-policy');
+});