copilot-metrics 0.1.3 → 0.1.5

package/src/reports.js

@@ -19,6 +19,10 @@ function formatCredits(value) {
   return n(value).toFixed(6);
 }
 
+function usageStatus(row) {
+  return n(row.usage_records) > 0 ? 'usage' : 'evidence-only';
+}
+
 function table(headers, rows) {
   const widths = headers.map((header, index) => Math.max(
     header.length,
@@ -48,6 +52,10 @@ SELECT
     WHEN (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) = 0 THEN 'hook-only'
     ELSE 'token-bearing'
   END AS token_status,
+  CASE
+    WHEN (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) = 0 THEN 'evidence-only'
+    ELSE 'usage'
+  END AS usage_status,
   (SELECT MIN(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS first_seen,
   (SELECT MAX(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS last_seen,
   (SELECT MAX(estimate_label) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)) AS estimate_label
@@ -73,6 +81,10 @@ SELECT
     WHEN (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) = 0 THEN 'hook-only'
     ELSE 'token-bearing'
   END AS token_status,
+  CASE
+    WHEN (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) = 0 THEN 'evidence-only'
+    ELSE 'usage'
+  END AS usage_status,
   (SELECT MIN(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS first_seen,
   (SELECT MAX(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS last_seen,
   (SELECT MAX(estimate_label) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)) AS estimate_label
@@ -80,6 +92,30 @@ FROM (SELECT DISTINCT label FROM label_evidence WHERE label = ?) labels`, [canon
   return rows[0] || null;
 }
 
+async function labelModelBreakdown(dbPath, label) {
+  await initStore(dbPath);
+  return queryRows(dbPath, `
+SELECT
+  COALESCE(ur.resolved_model, ur.requested_model, 'unknown') AS model,
+  COUNT(DISTINCT ur.id) AS usage_records,
+  COUNT(DISTINCT ur.session_id) AS sessions,
+  SUM(ur.input_tokens) AS input_tokens,
+  SUM(ur.output_tokens) AS output_tokens,
+  SUM(ur.cache_read_tokens) AS cache_read_tokens,
+  SUM(ur.cache_creation_tokens) AS cache_creation_tokens,
+  SUM(ur.reasoning_tokens) AS reasoning_tokens,
+  SUM(COALESCE(ur.estimated_ai_credits, 0)) AS estimated_ai_credits,
+  MAX(ur.estimate_label) AS estimate_label
+FROM usage_records ur
+WHERE ur.id IN (
+  SELECT DISTINCT usage_record_id
+  FROM label_evidence
+  WHERE label = ? AND usage_record_id IS NOT NULL
+)
+GROUP BY COALESCE(ur.resolved_model, ur.requested_model, 'unknown')
+ORDER BY estimated_ai_credits DESC, model`, [canonicalLabel(label)]);
+}
+
 async function labelDetails(dbPath, label) {
   await initStore(dbPath);
   return queryRows(dbPath, `
@@ -173,7 +209,7 @@ ORDER BY ur.timestamp, ur.id`);
 function formatLabels(rows) {
   return [
     table(
-      ['Label', 'Sessions', 'Usage', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'Credits', 'Status', 'Evidence', 'Last seen'],
+      ['Label', 'Sessions', 'Usage', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'AI Credits est.', 'Usage status', 'Evidence', 'Last seen'],
       rows.map((row) => [
         row.label,
         row.sessions,
@@ -184,39 +220,57 @@ function formatLabels(rows) {
         formatNumber(row.cache_creation_tokens),
         formatNumber(row.reasoning_tokens),
         formatCredits(row.estimated_ai_credits),
-        row.token_status,
+        usageStatus(row),
         row.evidence_count,
         row.last_seen || '',
       ]),
     ),
     '',
-    `Costs are estimates (${estimateLabel(rows)}).`,
+    `AI Credits are estimates (${estimateLabel(rows)}). 1 AI Credit is treated as $0.01 for local estimates.`,
   ].join('\n');
 }
 
-function formatLabelSummary(summary, details = null) {
+function formatLabelSummary(summary) {
   if (!summary) return 'No usage found for label.';
-  const lines = [
-    table(
-      ['Label', 'Sessions', 'Usage', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'Credits', 'Status', 'Evidence'],
-      [[
-        summary.label,
-        summary.sessions,
-        summary.usage_records,
-        formatNumber(summary.input_tokens),
-        formatNumber(summary.output_tokens),
-        formatNumber(summary.cache_read_tokens),
-        formatNumber(summary.cache_creation_tokens),
-        formatNumber(summary.reasoning_tokens),
-        formatCredits(summary.estimated_ai_credits),
-        summary.token_status,
-        summary.evidence_count,
-      ]],
-    ),
-  ];
+  return table(
+    ['Label', 'Sessions', 'Usage', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'AI Credits est.', 'Usage status', 'Evidence'],
+    [[
+      summary.label,
+      summary.sessions,
+      summary.usage_records,
+      formatNumber(summary.input_tokens),
+      formatNumber(summary.output_tokens),
+      formatNumber(summary.cache_read_tokens),
+      formatNumber(summary.cache_creation_tokens),
+      formatNumber(summary.reasoning_tokens),
+      formatCredits(summary.estimated_ai_credits),
+      usageStatus(summary),
+      summary.evidence_count,
+    ]],
+  );
+}
+
+function formatLabelReport(summary, models, details = null) {
+  const output = [formatLabelSummary(summary)];
+  if (models && models.length > 0) {
+    output.push('', table(
+      ['Model', 'Sessions', 'Usage', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'AI Credits est.'],
+      models.map((row) => [
+        row.model,
+        row.sessions,
+        row.usage_records,
+        formatNumber(row.input_tokens),
+        formatNumber(row.output_tokens),
+        formatNumber(row.cache_read_tokens),
+        formatNumber(row.cache_creation_tokens),
+        formatNumber(row.reasoning_tokens),
+        formatCredits(row.estimated_ai_credits),
+      ]),
+    ));
+  }
   if (details) {
-    lines.push('', table(
-      ['Source', 'Field', 'Session', 'Model', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'Credits', 'Value'],
+    output.push('', table(
+      ['Source', 'Field', 'Session', 'Model', 'Input', 'Output', 'Cache read', 'Cache create', 'Reasoning', 'AI Credits est.', 'Value'],
       details.map((row) => [
         row.source_type,
         row.source_field,
@@ -232,52 +286,54 @@ function formatLabelSummary(summary, details = null) {
       ]),
     ));
   }
-  lines.push('', `Costs are estimates (${summary.estimate_label || 'estimate:unknown'}).`);
-  return lines.join('\n');
+  output.push('', `AI Credits are estimates (${summary?.estimate_label || estimateLabel(models || [])}). 1 AI Credit is treated as $0.01 for local estimates.`);
+  return output.join('\n');
 }
 
 function formatModels(rows) {
   return [
     table(
-      ['Model', 'Records', 'Input', 'Output', 'Credits'],
+      ['Model', 'Records', 'Input', 'Output', 'AI Credits est.'],
       rows.map((row) => [row.model, row.usage_records, formatNumber(row.input_tokens), formatNumber(row.output_tokens), formatCredits(row.estimated_ai_credits)]),
     ),
     '',
-    `Costs are estimates (${estimateLabel(rows)}).`,
+    `AI Credits are estimates (${estimateLabel(rows)}). 1 AI Credit is treated as $0.01 for local estimates.`,
   ].join('\n');
 }
 
 function formatRepos(rows) {
   return [
     table(
-      ['Repo', 'CWD', 'Sessions', 'Input', 'Output', 'Credits'],
+      ['Repo', 'CWD', 'Sessions', 'Input', 'Output', 'AI Credits est.'],
       rows.map((row) => [row.repo, row.cwd, row.sessions, formatNumber(row.input_tokens), formatNumber(row.output_tokens), formatCredits(row.estimated_ai_credits)]),
     ),
     '',
-    `Costs are estimates (${estimateLabel(rows)}).`,
+    `AI Credits are estimates (${estimateLabel(rows)}). 1 AI Credit is treated as $0.01 for local estimates.`,
   ].join('\n');
 }
 
 function formatUnattributed(rows) {
   return [
     table(
-      ['ID', 'Source', 'Session', 'Repo', 'Branch', 'CWD', 'Model', 'Credits'],
+      ['ID', 'Source', 'Session', 'Repo', 'Branch', 'CWD', 'Model', 'AI Credits est.'],
       rows.map((row) => [row.id, row.source, row.session_id || '', row.repo || '', row.branch || '', row.cwd || '', row.resolved_model || '', formatCredits(row.estimated_ai_credits)]),
     ),
     '',
-    `Costs are estimates (${estimateLabel(rows)}).`,
+    `AI Credits are estimates (${estimateLabel(rows)}). 1 AI Credit is treated as $0.01 for local estimates.`,
   ].join('\n');
 }
 
 module.exports = {
   labelOverview,
   labelSummary,
+  labelModelBreakdown,
   labelDetails,
   modelReport,
   repoReport,
   unattributedReport,
   formatLabels,
   formatLabelSummary,
+  formatLabelReport,
   formatModels,
   formatRepos,
   formatUnattributed,

package/src/setup.js

@@ -34,6 +34,22 @@ function writePrivateFile(file, data) {
   fs.writeFileSync(file, data, { mode: 0o600 });
 }
 
+function readJsonFile(file) {
+  if (!fs.existsSync(file)) return {};
+  const text = fs.readFileSync(file, 'utf8');
+  try {
+    return JSON.parse(text);
+  } catch {
+    return JSON.parse(stripJsonComments(text).replace(/,\s*([}\]])/g, '$1'));
+  }
+}
+
+function stripJsonComments(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|[^:])\/\/.*$/gm, '$1');
+}
+
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
@@ -43,29 +59,45 @@ function ensureDataDirs(paths) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   }
 
-  if (!fs.existsSync(paths.configJson)) {
-    writePrivateFile(paths.configJson, `${JSON.stringify({
-      version: 1,
-      dataHome: paths.home,
-      contentCapture: false,
-      telemetry: {
-        vscode: paths.vscodeOtelJsonl,
-        copilotCli: paths.copilotCliOtelJsonl,
+  const defaultConfig = {
+    version: 1,
+    dataHome: paths.home,
+    contentCapture: false,
+    telemetry: {
+      vscode: paths.vscodeOtelJsonl,
+      copilotCli: paths.copilotCliOtelJsonl,
+    },
+    sources: {
+      vscode: {
+        telemetry: paths.vscodeOtelJsonl,
+        hooks: paths.hookEventsJsonl,
       },
-      sources: {
-        vscode: {
-          telemetry: paths.vscodeOtelJsonl,
-          hooks: paths.hookEventsJsonl,
-        },
-        copilotCli: {
-          telemetry: paths.copilotCliOtelJsonl,
-          hooks: paths.hookEventsJsonl,
-          sessions: paths.copilotSessionStateDir,
-        },
+      copilotCli: {
+        telemetry: paths.copilotCliOtelJsonl,
+        hooks: paths.hookEventsJsonl,
+        sessions: paths.copilotSessionStateDir,
       },
-      labelExtractors: [],
-    }, null, 2)}\n`);
+    },
+    labelExtractors: [],
+  };
+
+  if (!fs.existsSync(paths.configJson)) {
+    writePrivateFile(paths.configJson, `${JSON.stringify(defaultConfig, null, 2)}\n`);
+    return;
   }
+
+  const current = readJsonFile(paths.configJson);
+  const next = {
+    ...defaultConfig,
+    ...current,
+    telemetry: { ...defaultConfig.telemetry, ...(current.telemetry || {}) },
+    sources: {
+      vscode: { ...defaultConfig.sources.vscode, ...(current.sources?.vscode || {}) },
+      copilotCli: { ...defaultConfig.sources.copilotCli, ...(current.sources?.copilotCli || {}) },
+    },
+    labelExtractors: current.labelExtractors || defaultConfig.labelExtractors,
+  };
+  writePrivateFile(paths.configJson, `${JSON.stringify(next, null, 2)}\n`);
 }
 
 function vscodeSettings(paths) {
@@ -77,6 +109,44 @@ function vscodeSettings(paths) {
   };
 }
 
+function defaultVscodeSettingsTargets(options = {}) {
+  const env = options.env || process.env;
+  const home = env.HOME || process.env.HOME;
+  if (!home) return [];
+  if (process.platform === 'darwin') {
+    return [
+      path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+      path.join(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'settings.json'),
+    ];
+  }
+  if (process.platform === 'win32') {
+    const appData = env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    return [
+      path.join(appData, 'Code', 'User', 'settings.json'),
+      path.join(appData, 'Code - Insiders', 'User', 'settings.json'),
+    ];
+  }
+  return [
+    path.join(home, '.config', 'Code', 'User', 'settings.json'),
+    path.join(home, '.config', 'Code - Insiders', 'User', 'settings.json'),
+  ];
+}
+
+function installVscodeSettings(paths, options = {}) {
+  const settings = vscodeSettings(paths);
+  const explicitTarget = options.target;
+  const candidates = explicitTarget ? [explicitTarget] : defaultVscodeSettingsTargets(options);
+  const existingTargets = candidates.filter((target) => fs.existsSync(target));
+  const targets = existingTargets.length > 0 ? existingTargets : candidates.slice(0, 1);
+  const results = [];
+  for (const target of targets) {
+    const current = readJsonFile(target);
+    writePrivateFile(target, `${JSON.stringify({ ...current, ...settings }, null, 2)}\n`);
+    results.push({ target, settings });
+  }
+  return results;
+}
+
 function copilotCliEnvironment(paths) {
   return {
     COPILOT_OTEL_ENABLED: 'true',
@@ -110,7 +180,8 @@ function isEphemeralPackageShim(command) {
 }
 
 function hookEventsForSurface(surface) {
-  if (surface === 'copilot-cli' || surface === 'both') return COPILOT_CLI_HOOK_EVENTS;
+  if (surface === 'both') return Array.from(new Set([...COPILOT_CLI_HOOK_EVENTS, ...VSCODE_HOOK_EVENTS]));
+  if (surface === 'copilot-cli') return COPILOT_CLI_HOOK_EVENTS;
   if (surface === 'vscode') return VSCODE_HOOK_EVENTS;
   throw new Error(`Unknown hook surface "${surface}". Use "both", "copilot-cli", or "vscode".`);
 }
@@ -188,11 +259,20 @@ function installHook(paths, options = {}) {
 function setupSnapshot(options = {}) {
   const paths = resolvePaths(options);
   ensureDataDirs(paths);
+  const vscodeInstalled = options.install === true ? installVscodeSettings(paths, options) : [];
+  const hooksInstalled = options.install === true ? installHook(paths, {
+    cwd: options.cwd,
+    scope: options.scope || 'local',
+    surface: options.surface || 'both',
+    command: options.command,
+  }) : null;
   return {
     paths,
     vscode: vscodeSettings(paths),
+    vscodeInstalled,
     copilotCli: copilotCliEnvironment(paths),
     hooks: hookConfig(paths, options),
+    hooksInstalled,
   };
 }
 
@@ -201,7 +281,9 @@ module.exports = {
   COPILOT_CLI_HOOK_EVENTS,
   VSCODE_HOOK_EVENTS,
   ensureDataDirs,
+  defaultVscodeSettingsTargets,
   vscodeSettings,
+  installVscodeSettings,
   copilotCliEnvironment,
   shellExports,
   shellQuote,

package/src/sqlite-store.js

@@ -141,6 +141,7 @@ function lastInsertId(db) {
 }
 
 function insertLabelEvidence(db, importedAt, evidenceRows) {
+  if (!evidenceRows.length) return;
   runPrepared(
     db,
     `INSERT INTO label_evidence (
@@ -183,6 +184,16 @@ async function existingRawFingerprints(dbPath, source, sourceFile, fingerprints)
   return existing;
 }
 
+async function importedLineHighWater(dbPath, source, sourceFile) {
+  await initStore(dbPath);
+  const rows = await queryRows(
+    dbPath,
+    'SELECT COALESCE(MAX(line), 0) AS line FROM raw_records WHERE source = ? AND source_file = ?',
+    [source, sourceFile],
+  );
+  return Number(rows[0]?.line || 0);
+}
+
 async function insertImport(dbPath, source, sourceFile, rawRecords, usageRecords, hookEvents, warnings) {
   await initStore(dbPath);
   const db = await openDatabase(dbPath);
@@ -273,6 +284,7 @@ async function insertImport(dbPath, source, sourceFile, rawRecords, usageRecords
             repo: event.repo,
             branch: event.branch,
             cwd: event.cwd,
+            timestamp: event.timestamp,
           });
         }
       }
@@ -297,6 +309,188 @@ async function insertImport(dbPath, source, sourceFile, rawRecords, usageRecords
   persistDatabase(dbPath, db);
 }
 
+async function attachVscodeChatLabelEvidence(dbPath, mappings) {
+  await initStore(dbPath);
+  if (!mappings.length) {
+    return { matched_usage_records: 0, label_evidence: 0 };
+  }
+
+  const db = await openDatabase(dbPath);
+  const importedAt = new Date().toISOString();
+  let matchedUsageRecords = 0;
+  let labelEvidence = 0;
+
+  const usageStatement = db.prepare(`
+    SELECT id, session_id, repo, branch, cwd, timestamp
+    FROM usage_records
+    WHERE source = 'vscode' AND span_id = ?
+  `);
+  const existingStatement = db.prepare(`
+    SELECT 1
+    FROM label_evidence
+    WHERE label = ?
+      AND source_type = 'usage'
+      AND source_field = 'vscode_chat_response'
+      AND source_value = ?
+      AND usage_record_id = ?
+    LIMIT 1
+  `);
+  const insertStatement = db.prepare(`
+    INSERT INTO label_evidence (
+      imported_at, label, source_type, source_field, source_value, confidence,
+      usage_record_id, hook_event_id, session_id, repo, branch, cwd, timestamp
+    ) VALUES (?, ?, 'usage', 'vscode_chat_response', ?, ?, ?, NULL, ?, ?, ?, ?, ?)
+  `);
+
+  db.run('BEGIN');
+  try {
+    for (const mapping of mappings) {
+      usageStatement.bind([mapping.responseId]);
+      const usageRows = [];
+      while (usageStatement.step()) usageRows.push(usageStatement.getAsObject());
+      usageStatement.reset();
+      matchedUsageRecords += usageRows.length;
+
+      for (const usage of usageRows) {
+        for (const evidence of mapping.label_evidence || []) {
+          existingStatement.bind([evidence.label, mapping.responseId, usage.id]);
+          const exists = existingStatement.step();
+          existingStatement.reset();
+          if (exists) continue;
+
+          insertStatement.run([
+            importedAt,
+            evidence.label,
+            mapping.responseId,
+            evidence.confidence || 0.95,
+            usage.id,
+            mapping.sessionId || usage.session_id || null,
+            usage.repo || null,
+            usage.branch || null,
+            usage.cwd || null,
+            usage.timestamp || null,
+          ]);
+          labelEvidence += 1;
+        }
+      }
+    }
+    db.run('COMMIT');
+  } catch (error) {
+    db.run('ROLLBACK');
+    throw error;
+  } finally {
+    usageStatement.free();
+    existingStatement.free();
+    insertStatement.free();
+  }
+
+  persistDatabase(dbPath, db);
+  return { matched_usage_records: matchedUsageRecords, label_evidence: labelEvidence };
+}
+
+async function vscodeRawRecordsNeedingResponseBackfill(dbPath, sourceFile) {
+  await initStore(dbPath);
+  return queryRows(dbPath, `
+    SELECT rr.line, rr.payload_json
+    FROM raw_records rr
+    WHERE rr.source = 'vscode'
+      AND rr.source_file = ?
+      AND EXISTS (
+        SELECT 1
+        FROM usage_records ur
+        WHERE ur.source = 'vscode'
+          AND ur.raw_line = rr.line
+          AND ur.span_id IS NULL
+      )
+  `, [sourceFile]);
+}
+
+async function updateVscodeUsageResponseIds(dbPath, updates) {
+  await initStore(dbPath);
+  if (!updates.length) return 0;
+
+  const db = await openDatabase(dbPath);
+  const statement = db.prepare(`
+    UPDATE usage_records
+    SET span_id = ?,
+        session_id = COALESCE(session_id, ?),
+        timestamp = COALESCE(timestamp, ?)
+    WHERE source = 'vscode'
+      AND raw_line = ?
+      AND span_id IS NULL
+      AND input_tokens = ?
+      AND output_tokens = ?
+      AND cache_read_tokens = ?
+      AND cache_creation_tokens = ?
+      AND reasoning_tokens = ?
+      AND COALESCE(resolved_model, requested_model, '') = COALESCE(?, '')
+  `);
+  let updated = 0;
+  db.run('BEGIN');
+  try {
+    for (const update of updates) {
+      statement.run([
+        update.span_id,
+        update.session_id || null,
+        update.timestamp || null,
+        update.raw_line,
+        update.input_tokens,
+        update.output_tokens,
+        update.cache_read_tokens,
+        update.cache_creation_tokens,
+        update.reasoning_tokens,
+        update.resolved_model || update.requested_model || '',
+      ]);
+      updated += typeof db.getRowsModified === 'function' ? db.getRowsModified() : 0;
+    }
+    db.run('COMMIT');
+  } catch (error) {
+    db.run('ROLLBACK');
+    throw error;
+  } finally {
+    statement.free();
+  }
+
+  persistDatabase(dbPath, db);
+  return updated;
+}
+
+async function updateUsageCostEstimates(dbPath, updates) {
+  await initStore(dbPath);
+  if (!updates.length) return 0;
+
+  const db = await openDatabase(dbPath);
+  const statement = db.prepare(`
+    UPDATE usage_records
+    SET estimated_usd = ?,
+        estimated_ai_credits = ?,
+        warnings_json = ?
+    WHERE id = ?
+  `);
+  let updated = 0;
+  db.run('BEGIN');
+  try {
+    for (const update of updates) {
+      statement.run([
+        update.estimated_usd,
+        update.estimated_ai_credits,
+        JSON.stringify(update.warnings || []),
+        update.id,
+      ]);
+      updated += typeof db.getRowsModified === 'function' ? db.getRowsModified() : 0;
+    }
+    db.run('COMMIT');
+  } catch (error) {
+    db.run('ROLLBACK');
+    throw error;
+  } finally {
+    statement.free();
+  }
+
+  persistDatabase(dbPath, db);
+  return updated;
+}
+
 async function queryOne(dbPath, sql) {
   const db = await openDatabase(dbPath);
   const result = db.exec(sql);
@@ -319,9 +513,14 @@ async function queryRows(dbPath, sql, params = []) {
 }
 
 module.exports = {
+  attachVscodeChatLabelEvidence,
   existingRawFingerprints,
+  importedLineHighWater,
   initStore,
   insertImport,
   queryOne,
   queryRows,
+  updateUsageCostEstimates,
+  updateVscodeUsageResponseIds,
+  vscodeRawRecordsNeedingResponseBackfill,
 };