token-studio 4.8.0

package/test/db-annotations.test.mjs

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  applyAutoSessionAnnotations,
+  deleteSessionAnnotation,
+  openDb,
+  undoAutoSessionAnnotations,
+  upsertSession,
+  upsertSessionAnnotation
+} from '../src/db.mjs';
+
+function withDb(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-db-'));
+  const db = openDb(join(dir, 'usage.sqlite'));
+  try {
+    upsertSession(db, {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'local:codex:D:\\Project:codex-mini',
+      lastActivity: '2026-06-10T01:00:00.000Z',
+      projectPath: 'D:\\Project',
+      inputTokens: 100,
+      outputTokens: 30,
+      cacheCreationTokens: 10,
+      cacheReadTokens: 20,
+      reasoningOutputTokens: 5,
+      totalTokens: 165,
+      costUSD: 0.01
+    });
+    fn(db);
+  } finally {
+    db.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test('session annotation upsert stores normalized values', () => withDb((db) => {
+  const saved = upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    projectAlias: '  AI 选题雷达  ',
+    taskType: '功能开发',
+    outputStatus: '已完成',
+    workPurpose: '方案设计',
+    workStage: '实现',
+    valueLevel: '高',
+    note: '  首版归因  UI  '
+  });
+
+  assert.equal(saved.projectAlias, 'AI 选题雷达');
+  assert.equal(saved.taskType, '功能开发');
+  assert.equal(saved.outputStatus, '已完成');
+  assert.equal(saved.workPurpose, '方案设计');
+  assert.equal(saved.workStage, '实现');
+  assert.equal(saved.valueLevel, '高');
+  assert.equal(saved.note, '首版归因 UI');
+  assert.equal(saved.annotationSource, 'manual');
+  assert.equal(saved.annotationConfidence, 100);
+  assert.ok(saved.annotationUpdatedAt);
+}));
+
+test('session annotation defaults stay explicit', () => withDb((db) => {
+  const saved = upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    projectAlias: '',
+    note: ''
+  });
+
+  assert.equal(saved.projectAlias, null);
+  assert.equal(saved.taskType, '未分类');
+  assert.equal(saved.outputStatus, '未标注');
+  assert.equal(saved.workPurpose, '未说明');
+  assert.equal(saved.workStage, '未说明');
+  assert.equal(saved.valueLevel, '未评估');
+  assert.equal(saved.note, null);
+  assert.equal(saved.annotationSource, 'manual');
+  assert.equal(saved.annotationConfidence, 100);
+}));
+
+test('session annotation validates enums and length', () => withDb((db) => {
+  assert.throws(() => upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    taskType: '随便填'
+  }), /taskType must be one of/);
+
+  assert.throws(() => upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    valueLevel: '爆款'
+  }), /valueLevel must be one of/);
+
+  assert.throws(() => upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    note: 'x'.repeat(501)
+  }), /note must be 500 characters or less/);
+
+  assert.throws(() => upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    annotationSource: 'guessed'
+  }), /annotationSource must be one of/);
+
+  assert.throws(() => upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    annotationSource: 'auto',
+    annotationConfidence: 101
+  }), /annotationConfidence must be an integer/);
+}));
+
+test('session annotation delete is scoped by identity', () => withDb((db) => {
+  upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    taskType: '问题修复'
+  });
+
+  const deleted = deleteSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini'
+  });
+
+  assert.equal(deleted, 1);
+  const remaining = db.prepare('SELECT COUNT(*) AS total FROM session_annotations').get();
+  assert.equal(remaining.total, 0);
+}));
+
+test('auto annotations write provenance, protect manual rows, and undo by run id', () => withDb((db) => {
+  const first = applyAutoSessionAnnotations(db, [{
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    values: {
+      projectAlias: 'Project',
+      taskType: '功能开发',
+      outputStatus: '已完成',
+      workPurpose: '功能开发',
+      workStage: '实现',
+      valueLevel: '中'
+    },
+    annotationConfidence: 85,
+    annotationReason: '路径和产出链接命中',
+    autoVersion: 'v3.15.0'
+  }], { runId: 'auto-test', threshold: 80 });
+
+  assert.equal(first.applied, 1);
+  const auto = db.prepare('SELECT annotation_source AS source, annotation_confidence AS confidence, auto_run_id AS runId FROM session_annotations').get();
+  assert.equal(auto.source, 'auto');
+  assert.equal(auto.confidence, 85);
+  assert.equal(auto.runId, 'auto-test');
+
+  upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    taskType: '问题修复'
+  });
+
+  const protectedResult = applyAutoSessionAnnotations(db, [{
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'local:codex:D:\\Project:codex-mini',
+    values: { taskType: '功能开发' },
+    annotationConfidence: 90
+  }], { runId: 'auto-test-2', threshold: 80 });
+  assert.equal(protectedResult.applied, 0);
+  assert.equal(protectedResult.skippedProtected, 1);
+
+  assert.equal(undoAutoSessionAnnotations(db, { runId: 'auto-test' }), 0);
+  assert.equal(db.prepare('SELECT task_type AS taskType, annotation_source AS source FROM session_annotations').get().taskType, '问题修复');
+}));

package/test/db-v2.test.mjs

@@ -0,0 +1,200 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  batchUpsertSessionAnnotations,
+  deleteProjectAliasRule,
+  deleteSessionOutput,
+  exportAnnotationData,
+  importAnnotationData,
+  listProjectAliasRules,
+  matchProjectAliasRule,
+  openDb,
+  upsertProjectAliasRule,
+  upsertSession,
+  upsertSessionAnnotation,
+  upsertSessionOutput
+} from '../src/db.mjs';
+
+function withDb(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-v2-db-'));
+  const dbPath = join(dir, 'usage.sqlite');
+  const db = openDb(dbPath);
+  try {
+    seedSessions(db);
+    fn(db, dbPath);
+  } finally {
+    db.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function seedSessions(db) {
+  for (const row of [
+    {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'codex:one',
+      lastActivity: '2026-06-10T01:00:00.000Z',
+      projectPath: 'D:\\HighROIProjects\\TokenStudio',
+      totalTokens: 500,
+      costUSD: 0.05
+    },
+    {
+      device: 'devbox',
+      source: 'Claude Code',
+      sessionId: 'claude:two',
+      lastActivity: '2026-06-10T02:00:00.000Z',
+      projectPath: 'D:\\HighROIProjects\\Other',
+      totalTokens: 100,
+      costUSD: 0.01
+    }
+  ]) {
+    upsertSession(db, row);
+  }
+}
+
+test('v2 schema migration is repeatable', () => withDb((db, dbPath) => {
+  const reopened = openDb(dbPath);
+  try {
+    const tables = reopened.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type = 'table' AND name IN ('project_alias_rules', 'session_outputs')
+      ORDER BY name
+    `).all().map(row => row.name);
+    assert.deepEqual(tables, ['project_alias_rules', 'session_outputs']);
+    const annotationColumns = reopened.prepare('PRAGMA table_info(session_annotations)').all().map(row => row.name);
+    const outputColumns = reopened.prepare('PRAGMA table_info(session_outputs)').all().map(row => row.name);
+    assert.equal(annotationColumns.includes('work_purpose'), true);
+    assert.equal(annotationColumns.includes('work_stage'), true);
+    assert.equal(annotationColumns.includes('value_level'), true);
+    assert.equal(outputColumns.includes('output_type'), true);
+  } finally {
+    reopened.close();
+  }
+}));
+
+test('project alias rules match by prefix and can be disabled', () => withDb((db) => {
+  const rule = upsertProjectAliasRule(db, {
+    pattern: 'D:\\HighROIProjects\\TokenStudio',
+    matchType: 'prefix',
+    projectAlias: 'Token Studio',
+    enabled: true
+  });
+
+  assert.equal(matchProjectAliasRule('D:\\HighROIProjects\\TokenStudio\\src', [rule]), 'Token Studio');
+
+  const disabled = upsertProjectAliasRule(db, { ...rule, enabled: false });
+  assert.equal(matchProjectAliasRule('D:\\HighROIProjects\\TokenStudio\\src', [disabled]), null);
+  assert.equal(listProjectAliasRules(db)[0].enabled, false);
+
+  assert.equal(deleteProjectAliasRule(db, { id: rule.id }), 1);
+}));
+
+test('session outputs upsert and delete by session identity', () => withDb((db) => {
+  const saved = upsertSessionOutput(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex:one',
+    outputUrl: 'https://github.com/example/repo/pull/42',
+    outputLabel: 'PR #42',
+    outputType: 'PR'
+  });
+
+  assert.equal(saved.outputUrl, 'https://github.com/example/repo/pull/42');
+  assert.equal(saved.outputLabel, 'PR #42');
+  assert.equal(saved.outputType, 'PR');
+  assert.throws(() => upsertSessionOutput(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex:one',
+    outputUrl: 'file:///secret.txt'
+  }), /http or https/);
+
+  assert.equal(deleteSessionOutput(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex:one'
+  }), 1);
+}));
+
+test('batch annotation only changes selected sessions', () => withDb((db) => {
+  const result = batchUpsertSessionAnnotations(db, {
+    sessions: [{ device: 'devbox', source: 'Codex CLI', sessionId: 'codex:one' }],
+    values: { taskType: '功能开发', outputStatus: '已完成', workPurpose: '调试修复', workStage: '验证', valueLevel: '中', note: '批量标注' }
+  });
+  assert.equal(result.updated, 1);
+
+  const rows = db.prepare(`
+    SELECT source, task_type AS taskType, output_status AS outputStatus,
+      work_purpose AS workPurpose, work_stage AS workStage, value_level AS valueLevel, note
+    FROM session_annotations
+    ORDER BY source
+  `).all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].source, 'Codex CLI');
+  assert.equal(rows[0].taskType, '功能开发');
+  assert.equal(rows[0].outputStatus, '已完成');
+  assert.equal(rows[0].workPurpose, '调试修复');
+  assert.equal(rows[0].workStage, '验证');
+  assert.equal(rows[0].valueLevel, '中');
+  assert.equal(rows[0].note, '批量标注');
+}));
+
+test('annotation export and import round-trip v3 data', () => withDb((db) => {
+  upsertSessionAnnotation(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex:one',
+    projectAlias: 'Token Studio',
+    taskType: '功能开发',
+    outputStatus: '已发布',
+    workPurpose: '功能开发',
+    workStage: '发布',
+    valueLevel: '关键'
+  });
+  upsertSessionOutput(db, {
+    device: 'devbox',
+    source: 'Codex CLI',
+    sessionId: 'codex:one',
+    outputUrl: 'https://example.com/token-studio',
+    outputLabel: 'Demo',
+    outputType: '部署'
+  });
+  upsertProjectAliasRule(db, {
+    pattern: 'D:\\HighROIProjects\\TokenStudio',
+    matchType: 'prefix',
+    projectAlias: 'Token Studio',
+    enabled: true
+  });
+
+  const exported = exportAnnotationData(db);
+  assert.equal(exported.version, 3);
+  assert.equal(exported.sessionAnnotations.length, 1);
+  assert.equal(exported.sessionAnnotations[0].workPurpose, '功能开发');
+  assert.equal(exported.sessionAnnotations[0].workStage, '发布');
+  assert.equal(exported.sessionAnnotations[0].valueLevel, '关键');
+  assert.equal(exported.sessionOutputs.length, 1);
+  assert.equal(exported.sessionOutputs[0].outputType, '部署');
+  assert.equal(exported.projectAliasRules.length, 1);
+
+  db.prepare('DELETE FROM session_annotations').run();
+  db.prepare('DELETE FROM session_outputs').run();
+  db.prepare('DELETE FROM project_alias_rules').run();
+
+  const imported = importAnnotationData(db, exported);
+  assert.deepEqual(imported, {
+    sessionAnnotations: 1,
+    sessionOutputs: 1,
+    projectAliasRules: 1
+  });
+  assert.equal(db.prepare('SELECT COUNT(*) AS total FROM session_outputs').get().total, 1);
+  const importedAnnotation = db.prepare('SELECT work_purpose AS workPurpose, work_stage AS workStage, value_level AS valueLevel FROM session_annotations').get();
+  const importedOutput = db.prepare('SELECT output_type AS outputType FROM session_outputs').get();
+  assert.equal(importedAnnotation.workPurpose, '功能开发');
+  assert.equal(importedAnnotation.workStage, '发布');
+  assert.equal(importedAnnotation.valueLevel, '关键');
+  assert.equal(importedOutput.outputType, '部署');
+}));

package/test/db-v4.test.mjs

@@ -0,0 +1,178 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  deleteAdvisorAction,
+  deleteBudgetProfile,
+  listAdvisorActions,
+  listBudgetProfiles,
+  linkWorkItemSessions,
+  listTokenEvents,
+  listWorkItems,
+  openDb,
+  upsertAdvisorAction,
+  upsertBudgetProfile,
+  upsertSession,
+  upsertTokenEvent,
+  upsertWorkItem
+} from '../src/db.mjs';
+
+function tempDb() {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-roi-v4-'));
+  return openDb(join(dir, 'usage.sqlite'));
+}
+
+test('token_events upsert is idempotent and privacy bounded', () => {
+  const db = tempDb();
+  upsertTokenEvent(db, {
+    eventId: 'evt-1',
+    device: 'demo',
+    source: 'Codex CLI',
+    sessionId: 's1',
+    timestamp: '2026-06-17T00:00:00Z',
+    model: 'codex-mini',
+    inputTokens: 10,
+    outputTokens: 3,
+    toolCategory: 'edit',
+    fileExtension: '.js',
+    repoPathHash: 'abc',
+    privacyLevel: 'hashed'
+  });
+  upsertTokenEvent(db, {
+    eventId: 'evt-1',
+    device: 'demo',
+    source: 'Codex CLI',
+    sessionId: 's1',
+    timestamp: '2026-06-17T00:00:00Z',
+    model: 'codex-mini',
+    inputTokens: 20,
+    outputTokens: 5,
+    privacyLevel: 'safe'
+  });
+  const rows = listTokenEvents(db);
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].inputTokens, 20);
+  assert.equal(rows[0].privacyLevel, 'safe');
+  db.close();
+});
+
+test('work items can be created and linked to sessions', () => {
+  const db = tempDb();
+  upsertSession(db, {
+    device: 'demo',
+    source: 'Codex CLI',
+    sessionId: 's1',
+    lastActivity: '2026-06-17',
+    totalTokens: 100
+  });
+  const item = upsertWorkItem(db, {
+    title: 'Ship Token Studio ROI',
+    projectAlias: 'Token Studio ROI',
+    workType: '功能开发',
+    status: '已发布',
+    valueLevel: '高',
+    outputUrl: 'https://example.com/pr/1',
+    outputType: 'PR'
+  });
+  const linked = linkWorkItemSessions(db, {
+    workItemId: item.id,
+    sessions: [{ device: 'demo', source: 'Codex CLI', sessionId: 's1' }]
+  });
+  assert.equal(linked.linked, 1);
+  const items = listWorkItems(db);
+  assert.equal(items.length, 1);
+  assert.equal(items[0].sessions.length, 1);
+  db.close();
+});
+
+test('budget profiles validate custom local budgets', () => {
+  const db = tempDb();
+  const profile = upsertBudgetProfile(db, {
+    source: 'claude',
+    label: 'Claude 5h',
+    windowMinutes: 300,
+    tokenBudget: 500000
+  });
+  assert.equal(profile.source, 'claude');
+  assert.equal(profile.enabled, true);
+  assert.equal(listBudgetProfiles(db).length, 1);
+  assert.throws(() => upsertBudgetProfile(db, {
+    source: 'codex',
+    label: 'invalid',
+    windowMinutes: 0,
+    tokenBudget: 100
+  }), /windowMinutes/);
+  assert.equal(deleteBudgetProfile(db, { id: profile.id }), 1);
+  db.close();
+});
+
+test('budget profiles support fixed reset windows and warning thresholds', () => {
+  const db = tempDb();
+  const profile = upsertBudgetProfile(db, {
+    source: 'Codex CLI',
+    label: 'Codex fixed 5h',
+    windowType: 'fixed',
+    windowMinutes: 300,
+    resetAnchor: '2026-06-17T00:00:00Z',
+    warningThreshold: 0.6,
+    tokenBudget: 100000
+  });
+  assert.equal(profile.windowType, 'fixed');
+  assert.equal(profile.resetAnchor, '2026-06-17T00:00:00.000Z');
+  assert.equal(profile.warningThreshold, 0.6);
+
+  const rolling = upsertBudgetProfile(db, {
+    id: profile.id,
+    source: 'Codex CLI',
+    label: 'Codex rolling',
+    windowType: 'rolling',
+    windowMinutes: 60,
+    resetAnchor: '2026-06-17T00:00:00Z',
+    warningThreshold: 0.75,
+    tokenBudget: 100000
+  });
+  assert.equal(rolling.windowType, 'rolling');
+  assert.equal(rolling.resetAnchor, null);
+  assert.throws(() => upsertBudgetProfile(db, {
+    source: 'Codex CLI',
+    label: 'bad threshold',
+    windowType: 'fixed',
+    windowMinutes: 300,
+    resetAnchor: '2026-06-17T00:00:00Z',
+    warningThreshold: 1.5,
+    tokenBudget: 1000
+  }), /warningThreshold/);
+  db.close();
+});
+
+test('advisor actions upsert by period and source rule', () => {
+  const db = tempDb();
+  const first = upsertAdvisorAction(db, {
+    periodStart: '2026-06-01',
+    periodEnd: '2026-06-07',
+    category: '节省模拟',
+    title: '测试验证换轻量模型',
+    action: '下周测试验证默认先用轻量模型',
+    evidence: '2 sessions',
+    sourceRule: 'savings:test',
+    status: 'open'
+  });
+  const updated = upsertAdvisorAction(db, {
+    periodStart: '2026-06-01',
+    periodEnd: '2026-06-07',
+    category: '节省模拟',
+    title: '测试验证换轻量模型',
+    action: '下周测试验证默认先用轻量模型',
+    evidence: '2 sessions',
+    sourceRule: 'savings:test',
+    status: 'done'
+  });
+  assert.equal(updated.id, first.id);
+  assert.equal(updated.status, 'done');
+  assert.ok(updated.completedAt);
+  assert.equal(listAdvisorActions(db, { periodStart: '2026-06-01', periodEnd: '2026-06-07' }).length, 1);
+  assert.equal(deleteAdvisorAction(db, { id: updated.id }), 1);
+  db.close();
+});

package/test/experimental-collectors.test.mjs

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { auditStructuredUsage, collectStructuredUsage, normalizeUsageRecord } from '../src/collectors/structured-usage.mjs';
+
+const EXPERIMENTAL = ['cursor', 'copilot', 'qwen', 'kimi', 'goose'];
+
+test('experimental collector fixtures contain no transcript or full path fields', () => {
+  for (const id of EXPERIMENTAL) {
+    const text = readFileSync(join('test', 'fixtures', 'collectors', id, 'usage.jsonl'), 'utf8');
+    assert.equal(/prompt|response|content|diff|transcript|messages/i.test(text), false, `${id} fixture contains conversation-like fields`);
+    assert.equal(/[A-Z]:[\\/]|\/Users\/|\/home\//.test(text), false, `${id} fixture contains full local paths`);
+  }
+});
+
+test('experimental structured collector imports explicit token rows only', async () => {
+  for (const id of EXPERIMENTAL) {
+    const result = await collectStructuredUsage({
+      clientKey: id,
+      roots: [join(process.cwd(), 'test', 'fixtures', 'collectors', id)]
+    });
+    assert.equal(result.modelsJson.entries.length, 1, `${id} should skip missing-token fixture rows`);
+    assert.equal(result.tokenEvents.length, 1, `${id} should emit one token event`);
+    assert.equal(result.tokenEvents[0].source, id);
+    assert.ok(result.tokenEvents[0].inputTokens + result.tokenEvents[0].outputTokens > 0);
+  }
+});
+
+test('structured usage normalizer rejects conversation-shaped rows', () => {
+  assert.deepEqual(normalizeUsageRecord({
+    sessionId: 'unsafe',
+    model: 'gpt-5.3-codex',
+    prompt: 'do not ingest this',
+    inputTokens: 100,
+    outputTokens: 20
+  }), []);
+});
+
+test('structured usage audit counts usable, no-token and conversation-like records', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-audit-'));
+  try {
+    writeFileSync(join(dir, 'usage.jsonl'), [
+      JSON.stringify({ eventId: 'ok', sessionId: 's1', model: 'gpt-5.3-codex', inputTokens: 100, outputTokens: 20 }),
+      JSON.stringify({ eventId: 'no-token', sessionId: 's2', model: 'gpt-5.3-codex' }),
+      JSON.stringify({ eventId: 'unsafe', sessionId: 's3', model: 'gpt-5.3-codex', prompt: 'do not read', inputTokens: 100 })
+    ].join('\n'), 'utf8');
+
+    const audit = await auditStructuredUsage({ roots: [dir] });
+    assert.equal(audit.candidateFiles, 1);
+    assert.equal(audit.usableTokenRecords, 1);
+    assert.equal(audit.skippedNoTokenRecords, 1);
+    assert.equal(audit.skippedConversationLikeRecords, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('collectors audit CLI emits safe summary without full paths', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-cli-audit-'));
+  const configPath = join(dir, 'collectors.json');
+  const root = join(process.cwd(), 'test', 'fixtures', 'collectors');
+  writeFileSync(configPath, JSON.stringify({
+    collectors: Object.fromEntries(EXPERIMENTAL.map(id => [id, { roots: [join(root, id)] }]))
+  }), 'utf8');
+
+  try {
+    const result = await runCli(['collectors', '--audit', '--json'], {
+      TOKEN_STUDIO_CONFIG: configPath
+    });
+    assert.equal(result.code, 0, result.stderr);
+    const json = JSON.parse(result.stdout);
+    assert.equal(json.collectors.length, EXPERIMENTAL.length);
+    assert.equal(json.totals.usableTokenRecords, EXPERIMENTAL.length);
+    assert.equal(json.totals.skippedNoTokenRecords, EXPERIMENTAL.length);
+    assert.equal(json.totals.skippedConversationLikeRecords, 0);
+    assert.equal(result.stdout.includes(root), false);
+    assert.equal(/[A-Z]:[\\/].*fixtures/.test(result.stdout), false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function runCli(argv, env = {}) {
+  return new Promise(resolve => {
+    const child = spawn(process.execPath, ['src/cli.mjs', ...argv], {
+      cwd: process.cwd(),
+      env: { ...process.env, ...env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('close', code => resolve({ code, stdout, stderr }));
+    child.on('error', error => resolve({ code: 1, stdout, stderr: `${stderr}${error.message}` }));
+  });
+}

package/test/fixtures/collectors/copilot/usage.jsonl

@@ -0,0 +1,2 @@
+{"eventId":"copilot-1","sessionId":"copilot-session-1","timestamp":"2026-06-17T02:04:00Z","model":"gpt-5.3-codex","project":"token-studio-roi","input_tokens":900,"output_tokens":210,"cache_read_tokens":120,"toolCategory":"terminal","fileExtension":".md"}
+{"eventId":"copilot-skip-no-tokens","sessionId":"copilot-session-2","timestamp":"2026-06-17T02:05:00Z","model":"gpt-5.3-codex","project":"token-studio-roi"}

package/test/fixtures/collectors/cursor/usage.jsonl

@@ -0,0 +1,2 @@
+{"eventId":"cursor-1","sessionId":"cursor-session-1","timestamp":"2026-06-17T02:00:00Z","model":"gpt-5.3-codex","project":"token-studio-roi","tokens":{"input":1200,"output":340,"cacheRead":800},"toolCategory":"edit","fileExtension":".js"}
+{"eventId":"cursor-skip-no-tokens","sessionId":"cursor-session-2","timestamp":"2026-06-17T02:02:00Z","model":"gpt-5.3-codex","project":"token-studio-roi"}

package/test/fixtures/collectors/goose/usage.jsonl

@@ -0,0 +1,2 @@
+{"eventId":"goose-1","sessionId":"goose-session-1","timestamp":"2026-06-17T02:10:00Z","model":"claude-sonnet","project":"token-studio-roi","tokens":{"input":1800,"output":260,"cacheRead":500},"toolCategory":"agent","fileExtension":".ts"}
+{"eventId":"goose-skip-no-tokens","sessionId":"goose-session-2","timestamp":"2026-06-17T02:11:00Z","model":"claude-sonnet","project":"token-studio-roi"}

package/test/fixtures/collectors/kimi/usage.jsonl

@@ -0,0 +1,2 @@
+{"eventId":"kimi-1","sessionId":"kimi-session-1","timestamp":"2026-06-17T02:08:00Z","model":"kimi-k2","project":"token-studio-roi","inputTokens":1100,"outputTokens":380,"cacheCreationTokens":70,"toolCategory":"review","fileExtension":".jsx"}
+{"eventId":"kimi-skip-no-tokens","sessionId":"kimi-session-2","timestamp":"2026-06-17T02:09:00Z","model":"kimi-k2","project":"token-studio-roi"}

package/test/fixtures/collectors/qwen/usage.jsonl

@@ -0,0 +1,2 @@
+{"eventId":"qwen-1","sessionId":"qwen-session-1","timestamp":"2026-06-17T02:06:00Z","model":"qwen3-coder","project":"token-studio-roi","usage":{"inputTokens":1500,"outputTokens":420,"reasoningTokens":60},"toolCategory":"research","fileExtension":".json"}
+{"eventId":"qwen-skip-no-tokens","sessionId":"qwen-session-2","timestamp":"2026-06-17T02:07:00Z","model":"qwen3-coder","project":"token-studio-roi"}