ai-native-profile 0.1.3 → 0.2.1

package/README.md

@@ -27,26 +27,34 @@ Pair this computer with your cloud profile:
 npx --yes ai-native-profile@latest connect
 ```
 
-The command prints a short-lived verification URL and code. Open the URL, sign in with GitHub, and approve the device. Then run the first sync:
+The command prints a short-lived verification URL and code. Open the URL, sign in with GitHub, and approve the device. The collector then shows the privacy boundary and asks before the first sync. You can also run a one-off sync later:
 
 ```bash
 npx --yes ai-native-profile@latest sync
 ```
 
-To keep syncing every 15 minutes while the command is running:
+For the fastest setup, sign in on the website and choose **Power up with coding activity**. The site creates a one-time command like this:
 
 ```bash
-npx --yes ai-native-profile@latest watch
+npx --yes ai-native-profile@latest connect --code ABCD1234
 ```
 
-`watch` runs in the foreground and stops when the process stops. The collector never installs a hidden background service.
+That command is already associated with the signed-in profile. It detects sources, displays the privacy boundary, asks before the first sync, and updates the open card without requiring the code to be entered again. After that first sync it offers automatic 15-minute refreshes; approving them installs a visible user-level macOS LaunchAgent or Linux systemd timer.
+
+Enable persistent 15-minute updates later:
+
+```bash
+npx --yes ai-native-profile@latest watch --install
+```
+
+Check their status with `doctor`, or disable them with `watch --uninstall`. Plain `watch` remains available for a foreground-only loop that stops with the process. The scheduled collector is copied under `~/.config/ai-native-profile/collector`; no provider credentials or source data are copied.
 
 ## Supported coding sources
 
 | Source | Collection path | Trust label |
 |---|---|---|
 | Codex | Official local App Server account usage | Official account source |
-| Claude Code | Deduplicated local session usage plus non-overlapping statistics-cache history | Local exact for retained records; partial lifetime coverage |
+| Claude Code | Deduplicated local session usage plus non-overlapping statistics-cache history | Local exact for retained records; estimated daily splits for cache-inclusive statistics history; partial lifetime coverage |
 | Cursor | Supported local database metadata | Estimated; excluded from rankings |
 | Gemini CLI | Locally retained CLI telemetry | Locally derived |
 | GitHub Copilot CLI | Locally retained CLI activity | Locally derived |
@@ -83,13 +91,15 @@ Run `preview` whenever you want to inspect the exact aggregate payload. Pairing
 | `sources` | Detect supported local coding tools |
 | `preview` | Print the exact aggregate payload without sending it |
 | `sync` | Send one approved aggregate batch |
-| `watch` | Sync immediately, then every 15 minutes until stopped |
-| `doctor` | Check local sources and pairing status |
+| `watch` | Sync every 15 minutes in the foreground |
+| `watch --install` | Enable persistent 15-minute updates after Terminal closes |
+| `watch --uninstall` | Disable persistent updates |
+| `doctor` | Check local sources, pairing, and automatic-sync status |
 | `sessions` | List deliberately published session stories |
 | `share` | Preview or publish a manually supplied sanitized story |
 | `unshare` | Revoke a published story |
 | `export` | Alias for `preview` |
-| `disconnect` | Remove the local platform pairing |
+| `disconnect` | Disable automatic updates and remove the local platform pairing |
 
 Use a self-hosted deployment instead of the managed service:
 

package/bin/anp.mjs

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 import { createHmac, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { createReadStream, existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, readdirSync, statSync } from 'node:fs';
+import { createReadStream, existsSync, readFileSync, mkdirSync, writeFileSync, rmSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { backgroundSyncStatus, installBackgroundSync, uninstallBackgroundSync } from '../src/background-sync.mjs';
 import { resolveCodexExecutable } from '../src/codex-executable.mjs';
 import { addClaudeSessionEvent, createClaudeSessionAccumulator, finalizeClaudeSessionUsage, mergeClaudeUsage, parseClaudeStatsCache } from '../src/claude-usage.mjs';
+import { discoverLocalDataFiles } from '../src/file-discovery.mjs';
 
-const VERSION = '0.1.3';
+const VERSION = '0.2.1';
 const DEFAULT_API_URL = 'https://ai-native-profile.vercel.app';
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const configDir = join(homedir(), '.config', 'ai-native-profile');
 const configFile = join(configDir, 'config.json');
 const paths = {
@@ -50,12 +54,13 @@ async function claudeAggregate() {
   const accumulator = createClaudeSessionAccumulator();
   let malformedLines = 0;
   const projectRoots = paths.claude_code.filter((path) => !path.endsWith('stats-cache.json'));
-  for (const sessionFile of localFiles(projectRoots).filter((path) => /\.jsonl$/i.test(path))) {
+  const discovery = discoverLocalDataFiles(projectRoots);
+  for (const sessionFile of discovery.files.filter((path) => /\.jsonl$/i.test(path))) {
     try {
       const lines = createInterface({ input:createReadStream(sessionFile, { encoding:'utf8' }), crlfDelay:Infinity });
       for await (const line of lines) {
         if (!line.trim()) continue;
-        try { addClaudeSessionEvent(accumulator, JSON.parse(line)); }
+        try { addClaudeSessionEvent(accumulator, JSON.parse(line), { sessionId:basename(sessionFile, '.jsonl') }); }
         catch { malformedLines += 1; }
       }
     } catch { malformedLines += 1; }
@@ -64,24 +69,14 @@ async function claudeAggregate() {
   const daily = mergeClaudeUsage(session.daily, legacy.daily);
   if (!daily.length) return null;
   const notes = ['Exact retained session records include input, output, cache-write, and cache-read tokens; local retention cannot prove complete lifetime coverage.'];
-  if (legacy.daily.length) notes.push('Older stats-cache days include combined base input/output tokens only.');
-  if (legacy.undatedCacheTokens) notes.push(`${Math.round(legacy.undatedCacheTokens)} older cache tokens lack day-level attribution and are excluded from dated totals.`);
+  if (legacy.estimatedDates) notes.push(`${legacy.estimatedDates} stats-cache day${legacy.estimatedDates === 1 ? '' : 's'} include cache and base token components allocated by reported daily model activity; covered-period totals are preserved while those daily splits are estimated.`);
+  if (discovery.truncated) notes.push('Local history exceeded the 10,000-file safety limit; the result is partial.');
   if (malformedLines) notes.push(`${malformedLines} malformed local record${malformedLines === 1 ? ' was' : 's were'} skipped.`);
   return { daily, completeness:'partial', note:notes.join(' ') };
 }
 
-function localFiles(candidates, limit = 300) {
-  const files = [];
-  const visit = (path) => {
-    if (files.length >= limit || !existsSync(path)) return;
-    let info; try { info = statSync(path); } catch { return; }
-    if (info.isFile()) { if (/\.(jsonl|json)$/i.test(path)) files.push(path); return; }
-    if (!info.isDirectory()) return;
-    let entries = []; try { entries = readdirSync(path); } catch { return; }
-    for (const entry of entries) visit(join(path, entry));
-  };
-  for (const path of candidates) visit(path);
-  return files;
+function localFiles(candidates) {
+  return discoverLocalDataFiles(candidates).files;
 }
 
 function genericLocalAggregate(source, candidates) {
@@ -181,9 +176,80 @@ function printSources() {
   console.log('\nOnly aggregate activity leaves this device. Run `anp preview` to inspect it.');
 }
 
+function confirmFirstSync() {
+  if (process.argv.includes('--yes')) return Promise.resolve(true);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return Promise.resolve(false);
+  const prompt = createInterface({ input:process.stdin, output:process.stdout });
+  return new Promise((resolve) => prompt.question('\nSync these aggregate activity counts now? [Y/n] ', (answer) => {
+    prompt.close();
+    resolve(!/^n(?:o)?$/i.test(answer.trim()));
+  }));
+}
+
+function confirmAutomaticSync() {
+  if (process.argv.includes('--yes')) return Promise.resolve(true);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return Promise.resolve(false);
+  const prompt = createInterface({ input:process.stdin, output:process.stdout });
+  return new Promise((resolve) => prompt.question('\nKeep this profile updated automatically every 15 minutes? [Y/n] ', (answer) => {
+    prompt.close();
+    resolve(!/^n(?:o)?$/i.test(answer.trim()));
+  }));
+}
+
+function printPrivacyPreview() {
+  console.log('\nMay sync: dates, provider/model IDs, token and activity counts, duration, coverage, and collector version.');
+  console.log('Never syncs: prompts, responses, source code, commands, paths, repositories, credentials, or environment variables.');
+}
+
+function enableAutomaticSync() {
+  const result = installBackgroundSync({ sourceRoot:packageRoot });
+  if (!result.installed) {
+    console.log(`\n${result.reason} Run \`anp watch\` when you want foreground updates.`);
+    return false;
+  }
+  saveConfig({ ...loadConfig(), backgroundSync: { enabled:true, platform:result.platform, intervalSeconds:result.intervalSeconds, installedAt:new Date().toISOString() } });
+  console.log('\nAutomatic sync is on. This computer will refresh your aggregates every 15 minutes, including after Terminal closes.');
+  return true;
+}
+
+async function finishConnection(connectedMessage) {
+  console.log(connectedMessage);
+  printSources();
+  printPrivacyPreview();
+  if (!(await confirmFirstSync())) {
+    console.log('\nConnected without syncing. Run `anp preview` to inspect the payload, then `anp sync` when ready.');
+    return;
+  }
+  await sync();
+  console.log('Your card is updated. Return to the browser to see it.');
+  if (await confirmAutomaticSync()) {
+    try { enableAutomaticSync(); }
+    catch (error) { console.error(`\nAutomatic sync could not be enabled: ${error instanceof Error ? error.message : String(error)}\nRun \`anp watch\` for foreground updates.`); }
+  } else {
+    console.log('\nAutomatic sync is off. Run `anp watch --install` later to enable it.');
+  }
+}
+
+async function claimWebConnection(apiUrl, userCode) {
+  const response = await fetch(`${apiUrl.replace(/\/$/, '')}/api/v1/device/claim`, {
+    method:'POST',
+    headers:{ 'content-type':'application/json' },
+    body:JSON.stringify({ userCode, deviceName:process.env.USER ?? 'Developer device', collectorVersion:VERSION }),
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok || !body.deviceToken || !body.deviceId) throw new Error(body.error ?? `Connection failed (${response.status}).`);
+  saveConfig({ apiUrl, deviceId:body.deviceId, deviceToken:body.deviceToken });
+  await finishConnection('Connected to your AI Native Profile.');
+}
+
 async function connect() {
   const apiUrl = option('api-url') ?? process.env.ANP_API_URL ?? DEFAULT_API_URL;
   if (!/^https?:\/\//.test(apiUrl)) throw new Error('The API URL must start with https:// or http://.');
+  const connectionCode = option('code');
+  if (connectionCode) {
+    await claimWebConnection(apiUrl, connectionCode);
+    return;
+  }
   const response = await fetch(`${apiUrl.replace(/\/$/, '')}/api/v1/device/pair`, { method:'POST', headers:{ 'content-type':'application/json' }, body:JSON.stringify({ deviceName:process.env.USER ?? 'Developer device', collectorVersion:VERSION }) });
   if (!response.ok) throw new Error(`Pairing failed (${response.status}).`);
   const pair = await response.json();
@@ -198,7 +264,7 @@ async function connect() {
     const tokenBody = await tokenResponse.json().catch(() => ({}));
     if (tokenResponse.ok && tokenBody.deviceToken) {
       saveConfig({ apiUrl, deviceId:pair.deviceId, deviceToken:tokenBody.deviceToken });
-      console.log('Connected. Automatic sync remains off until you run `anp watch`.');
+      await finishConnection('Connected to your AI Native Profile.');
       return;
     }
     throw new Error(tokenBody.error ?? `Pairing failed (${tokenResponse.status}).`);
@@ -216,7 +282,7 @@ async function sync() {
 }
 
 function help() {
-  console.log(`AI Native Profile collector ${VERSION}\n\nUsage: anp <command> [options]\n\n  connect      Pair this device with the cloud dashboard\n               --api-url <url> overrides the hosted dashboard\n  sources      Detect supported coding tools\n  preview      Print the exact aggregate payload\n  sync         Send one aggregate batch\n  watch        Sync every 15 minutes until stopped\n  doctor       Check configuration and sources\n  sessions     Explain selected-session sharing\n  share        Publish a selected sanitized session\n  unshare      Revoke a shared session\n  export       Alias for preview\n  disconnect   Remove the local platform pairing\n`);
+  console.log(`AI Native Profile collector ${VERSION}\n\nUsage: anp <command> [options]\n\n  connect      Pair this device with the cloud dashboard\n               --code <code> claims a command created by the signed-in website\n               --api-url <url> overrides the hosted dashboard\n               --yes approves the first sync and automatic updates without prompting\n  sources      Detect supported coding tools\n  preview      Print the exact aggregate payload\n  sync         Send one aggregate batch\n  watch        Sync every 15 minutes until stopped\n               --install enables persistent 15-minute updates\n               --uninstall disables persistent updates\n  doctor       Check configuration, sources, and automatic sync\n  sessions     Explain selected-session sharing\n  share        Publish a selected sanitized session\n  unshare      Revoke a shared session\n  export       Alias for preview\n  disconnect   Disable automatic sync and remove the local pairing\n`);
 }
 
 function option(name) { const index = process.argv.indexOf(`--${name}`); return index >= 0 ? process.argv[index + 1] : undefined; }
@@ -239,11 +305,13 @@ try {
   else if (command === 'preview' || command === 'export') console.log(JSON.stringify(await createBatch(), null, 2));
   else if (command === 'connect') await connect();
   else if (command === 'sync') await sync();
+  else if (command === 'watch' && process.argv.includes('--install')) { if (!loadConfig().deviceToken) throw new Error('Connect this device first.'); enableAutomaticSync(); }
+  else if (command === 'watch' && process.argv.includes('--uninstall')) { uninstallBackgroundSync(); saveConfig({ ...loadConfig(), backgroundSync:{ enabled:false, disabledAt:new Date().toISOString() } }); console.log('Automatic sync is off.'); }
   else if (command === 'watch') { await sync(); console.log('Watching every 15 minutes. Press Ctrl+C to stop.'); setInterval(() => sync().catch((error) => console.error(error.message)), 15 * 60 * 1000); }
-  else if (command === 'doctor') { printSources(); const config = loadConfig(); console.log(`\nCloud pairing: ${config.deviceId ? 'configured' : 'not configured'}`); }
+  else if (command === 'doctor') { printSources(); const config = loadConfig(); const automatic = backgroundSyncStatus(); console.log(`\nCloud pairing: ${config.deviceId ? 'configured' : 'not configured'}`); console.log(`Automatic sync: ${automatic.installed ? 'on (every 15 minutes)' : automatic.supported ? 'off' : 'unsupported on this operating system'}`); }
   else if (command === 'sessions') await listSessions();
   else if (command === 'share') await shareSession();
   else if (command === 'unshare') await unshareSession();
-  else if (command === 'disconnect') { rmSync(configFile, { force:true }); console.log('Removed the local platform pairing. Provider sign-ins and source data were not changed.'); }
+  else if (command === 'disconnect') { uninstallBackgroundSync(); rmSync(configFile, { force:true }); console.log('Disabled automatic sync and removed the local platform pairing. Provider sign-ins and source data were not changed.'); }
   else { console.error(`Unknown command: ${command}\n`); help(); process.exitCode = 1; }
 } catch (error) { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "ai-native-profile",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Privacy-first collector for AI Native Profile",
   "license": "MIT",
   "type": "module",
   "bin": { "anp": "bin/anp.mjs", "ai-native-profile": "bin/anp.mjs" },
-  "files": ["bin", "src/codex-app-server.ts", "src/codex-executable.mjs", "src/claude-usage.mjs", "README.md"],
+  "files": ["bin", "src/background-sync.mjs", "src/codex-app-server.ts", "src/codex-executable.mjs", "src/claude-usage.mjs", "src/file-discovery.mjs", "README.md"],
   "engines": { "node": ">=22.13.0" },
   "repository": {
     "type": "git",

package/src/background-sync.mjs

@@ -0,0 +1,179 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export const BACKGROUND_INTERVAL_SECONDS = 15 * 60;
+export const BACKGROUND_LABEL = 'dev.ainativeprofile.sync';
+
+function xml(value) {
+  return String(value).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+
+function systemdQuote(value) {
+  return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+
+export function backgroundSyncPaths({ homeDir = homedir(), platform = process.platform } = {}) {
+  const configDir = join(homeDir, '.config', 'ai-native-profile');
+  const collectorRoot = join(configDir, 'collector');
+  if (platform === 'darwin') {
+    return {
+      configDir,
+      collectorRoot,
+      definition: join(homeDir, 'Library', 'LaunchAgents', `${BACKGROUND_LABEL}.plist`),
+      log: join(configDir, 'sync.log'),
+    };
+  }
+  if (platform === 'linux') {
+    const systemdDir = join(homeDir, '.config', 'systemd', 'user');
+    return {
+      configDir,
+      collectorRoot,
+      definition: join(systemdDir, 'ai-native-profile-sync.timer'),
+      serviceDefinition: join(systemdDir, 'ai-native-profile-sync.service'),
+      log: null,
+    };
+  }
+  return { configDir, collectorRoot, definition: null, serviceDefinition: null, log: null };
+}
+
+export function renderLaunchAgent({ nodePath, cliPath, logPath, intervalSeconds = BACKGROUND_INTERVAL_SECONDS }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${BACKGROUND_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array><string>${xml(nodePath)}</string><string>${xml(cliPath)}</string><string>sync</string><string>--background</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>${intervalSeconds}</integer>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${xml(logPath)}</string>
+  <key>StandardErrorPath</key><string>${xml(logPath)}</string>
+</dict>
+</plist>
+`;
+}
+
+export function renderSystemdUnits({ nodePath, cliPath, intervalSeconds = BACKGROUND_INTERVAL_SECONDS }) {
+  const service = `[Unit]
+Description=Refresh AI Native Profile aggregates
+
+[Service]
+Type=oneshot
+ExecStart=${systemdQuote(nodePath)} ${systemdQuote(cliPath)} sync --background
+`;
+  const timer = `[Unit]
+Description=Refresh AI Native Profile every 15 minutes
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=${intervalSeconds}s
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+  return { service, timer };
+}
+
+function run(command, args, { allowFailure = false, runner = spawnSync } = {}) {
+  const result = runner(command, args, { encoding: 'utf8', stdio: 'pipe' });
+  if (!allowFailure && (result.error || result.status !== 0)) {
+    const detail = result.error?.message ?? String(result.stderr || result.stdout || `exit ${result.status}`).trim();
+    throw new Error(`${command} failed: ${detail}`);
+  }
+  return result;
+}
+
+function installCollectorBundle({ sourceRoot, collectorRoot }) {
+  const files = [
+    ['bin/anp.mjs', 'bin/anp.mjs'],
+    ['src/background-sync.mjs', 'src/background-sync.mjs'],
+    ['src/claude-usage.mjs', 'src/claude-usage.mjs'],
+    ['src/codex-executable.mjs', 'src/codex-executable.mjs'],
+    ['src/file-discovery.mjs', 'src/file-discovery.mjs'],
+  ];
+  for (const [source, destination] of files) {
+    const target = join(collectorRoot, destination);
+    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    copyFileSync(join(sourceRoot, source), target);
+  }
+  return join(collectorRoot, 'bin', 'anp.mjs');
+}
+
+export function installBackgroundSync({
+  sourceRoot,
+  homeDir = homedir(),
+  platform = process.platform,
+  nodePath = process.execPath,
+  uid = typeof process.getuid === 'function' ? process.getuid() : null,
+  runner = spawnSync,
+} = {}) {
+  if (!sourceRoot) throw new Error('The collector source directory is required.');
+  if (!['darwin', 'linux'].includes(platform)) {
+    return { installed: false, platform, reason: 'Automatic background sync currently supports macOS and Linux.' };
+  }
+  const paths = backgroundSyncPaths({ homeDir, platform });
+  const cliPath = installCollectorBundle({ sourceRoot, collectorRoot: paths.collectorRoot });
+  mkdirSync(paths.configDir, { recursive: true, mode: 0o700 });
+
+  if (platform === 'darwin') {
+    if (uid === null) throw new Error('Could not determine the current macOS user.');
+    mkdirSync(dirname(paths.definition), { recursive: true });
+    writeFileSync(paths.definition, renderLaunchAgent({ nodePath, cliPath, logPath: paths.log }), { mode: 0o600 });
+    const domain = `gui/${uid}`;
+    run('launchctl', ['bootout', `${domain}/${BACKGROUND_LABEL}`], { allowFailure: true, runner });
+    run('launchctl', ['bootstrap', domain, paths.definition], { runner });
+    return { installed: true, platform, intervalSeconds: BACKGROUND_INTERVAL_SECONDS, definition: paths.definition };
+  }
+
+  if (platform === 'linux') {
+    mkdirSync(dirname(paths.definition), { recursive: true, mode: 0o700 });
+    const units = renderSystemdUnits({ nodePath, cliPath });
+    writeFileSync(paths.serviceDefinition, units.service, { mode: 0o600 });
+    writeFileSync(paths.definition, units.timer, { mode: 0o600 });
+    run('systemctl', ['--user', 'daemon-reload'], { runner });
+    run('systemctl', ['--user', 'enable', '--now', basename(paths.definition)], { runner });
+    return { installed: true, platform, intervalSeconds: BACKGROUND_INTERVAL_SECONDS, definition: paths.definition };
+  }
+}
+
+export function uninstallBackgroundSync({
+  homeDir = homedir(),
+  platform = process.platform,
+  uid = typeof process.getuid === 'function' ? process.getuid() : null,
+  runner = spawnSync,
+} = {}) {
+  const paths = backgroundSyncPaths({ homeDir, platform });
+  if (platform === 'darwin' && paths.definition) {
+    if (uid !== null) run('launchctl', ['bootout', `gui/${uid}/${BACKGROUND_LABEL}`], { allowFailure: true, runner });
+    rmSync(paths.definition, { force: true });
+  } else if (platform === 'linux' && paths.definition) {
+    run('systemctl', ['--user', 'disable', '--now', basename(paths.definition)], { allowFailure: true, runner });
+    rmSync(paths.definition, { force: true });
+    rmSync(paths.serviceDefinition, { force: true });
+    run('systemctl', ['--user', 'daemon-reload'], { allowFailure: true, runner });
+  }
+  rmSync(paths.collectorRoot, { recursive: true, force: true });
+  return { installed: false, platform };
+}
+
+export function backgroundSyncStatus({ homeDir = homedir(), platform = process.platform } = {}) {
+  const paths = backgroundSyncPaths({ homeDir, platform });
+  if (!paths.definition) return { supported: false, installed: false, platform };
+  return {
+    supported: true,
+    installed: existsSync(paths.definition),
+    platform,
+    definition: paths.definition,
+    intervalSeconds: BACKGROUND_INTERVAL_SECONDS,
+  };
+}
+
+export function readBackgroundLog({ homeDir = homedir(), platform = process.platform } = {}) {
+  const { log } = backgroundSyncPaths({ homeDir, platform });
+  if (!log || !existsSync(log)) return '';
+  return readFileSync(log, 'utf8');
+}

package/src/claude-usage.mjs

@@ -5,16 +5,29 @@ function safeCount(value) {
   return Number.isFinite(count) && count >= 0 ? count : 0;
 }
 
-function metric(name, value, date) {
+function metric(name, value, date, provenance = 'local_exact') {
   return {
     name,
     value,
     unit: 'count',
-    provenance: 'local_exact',
+    provenance,
     source: 'claude_code',
     coverageStart: date,
     coverageEnd: date,
-    competitiveEligible: true,
+    competitiveEligible: provenance !== 'estimated',
+  };
+}
+
+function usageValue(usage, snakeName, camelName) {
+  return safeCount(usage?.[snakeName] ?? usage?.[camelName]);
+}
+
+function normalizeUsage(usage) {
+  return {
+    inputTokens: usageValue(usage, 'input_tokens', 'inputTokens'),
+    outputTokens: usageValue(usage, 'output_tokens', 'outputTokens'),
+    cacheCreationInputTokens: usageValue(usage, 'cache_creation_input_tokens', 'cacheCreationInputTokens'),
+    cacheReadInputTokens: usageValue(usage, 'cache_read_input_tokens', 'cacheReadInputTokens'),
   };
 }
 
@@ -29,10 +42,13 @@ export function createClaudeSessionAccumulator() {
   return { messages: new Map(), sessionStarts: new Map(), warnings: [] };
 }
 
-export function addClaudeSessionEvent(accumulator, event) {
+export function addClaudeSessionEvent(accumulator, event, context = {}) {
   if (!event || typeof event !== 'object') return;
-  const sessionId = String(event.sessionId ?? event.session_id ?? '');
-  const timestamp = typeof event.timestamp === 'string' ? event.timestamp : '';
+  const sessionId = String(event.sessionId ?? event.session_id ?? context.sessionId ?? '');
+  const rawTimestamp = event.timestamp ?? event.created_at ?? event.createdAt ?? event.message?.timestamp;
+  const timestamp = typeof rawTimestamp === 'string'
+    ? rawTimestamp
+    : Number.isFinite(rawTimestamp) ? new Date(rawTimestamp).toISOString() : '';
   const date = timestamp.slice(0, 10);
   if (sessionId && datePattern.test(date)) {
     const existing = accumulator.sessionStarts.get(sessionId);
@@ -42,15 +58,10 @@ export function addClaudeSessionEvent(accumulator, event) {
   const message = event.message;
   const rawUsage = message?.usage;
   if (!message || !rawUsage || !sessionId || !datePattern.test(date)) return;
-  const messageId = String(message.id ?? event.requestId ?? '');
+  const messageId = String(message.id ?? event.requestId ?? event.request_id ?? event.uuid ?? context.recordId ?? '');
   if (!messageId) return;
 
-  const usage = {
-    inputTokens: safeCount(rawUsage.input_tokens),
-    outputTokens: safeCount(rawUsage.output_tokens),
-    cacheCreationInputTokens: safeCount(rawUsage.cache_creation_input_tokens),
-    cacheReadInputTokens: safeCount(rawUsage.cache_read_input_tokens),
-  };
+  const usage = normalizeUsage(rawUsage);
   const candidate = {
     date,
     timestamp,
@@ -112,24 +123,101 @@ export function finalizeClaudeSessionUsage(accumulator) {
   return { daily, messageCount: accumulator.messages.size, warnings: accumulator.warnings };
 }
 
+function allocateInteger(total, weights) {
+  const entries = [...weights.entries()].filter(([, value]) => value > 0);
+  if (!entries.length || total <= 0) return new Map();
+  const weightTotal = entries.reduce((sum, [, value]) => sum + value, 0);
+  const rows = entries.map(([key, weight]) => {
+    const exact = total * weight / weightTotal;
+    return { key, value: Math.floor(exact), fraction: exact - Math.floor(exact) };
+  });
+  let remainder = Math.round(total) - rows.reduce((sum, row) => sum + row.value, 0);
+  rows.sort((left, right) => right.fraction - left.fraction || String(left.key).localeCompare(String(right.key)));
+  for (let index = 0; remainder > 0; index = (index + 1) % rows.length, remainder -= 1) rows[index].value += 1;
+  return new Map(rows.map(({ key, value }) => [key, value]));
+}
+
+function addAllocation(target, allocation) {
+  for (const [date, value] of allocation) target.set(date, (target.get(date) ?? 0) + value);
+}
+
 export function parseClaudeStatsCache(stats) {
-  if (!stats || typeof stats !== 'object') return { daily: [], undatedCacheTokens: 0 };
+  if (!stats || typeof stats !== 'object') return { daily: [], estimatedCacheTokens: 0, undatedCacheTokens: 0, estimatedDates: 0 };
   const activityByDate = new Map((stats.dailyActivity ?? []).filter((item) => datePattern.test(item?.date ?? '')).map((item) => [item.date, item]));
-  const tokensByDate = new Map((stats.dailyModelTokens ?? []).filter((item) => datePattern.test(item?.date ?? '')).map((item) => [item.date, Object.values(item.tokensByModel ?? {}).reduce((sum, value) => sum + safeCount(value), 0)]));
-  const dates = [...new Set([...activityByDate.keys(), ...tokensByDate.keys()])].sort();
-  const daily = dates.map((date) => {
+  const modelWeights = new Map();
+  for (const item of stats.dailyModelTokens ?? []) {
+    if (!datePattern.test(item?.date ?? '')) continue;
+    for (const [model, value] of Object.entries(item.tokensByModel ?? {})) {
+      const weights = modelWeights.get(model) ?? new Map();
+      weights.set(item.date, safeCount(value));
+      modelWeights.set(model, weights);
+    }
+  }
+  const activityWeights = new Map([...activityByDate].map(([date, activity]) => [date, Math.max(1, safeCount(activity.messageCount))]));
+  const dates = new Set([...activityByDate.keys(), ...[...modelWeights.values()].flatMap((weights) => [...weights.keys()])]);
+  const componentsByDate = new Map();
+  const modelsByDate = new Map();
+  const componentRow = (date) => {
+    const current = componentsByDate.get(date) ?? { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, combined: 0, estimated: false };
+    componentsByDate.set(date, current);
+    dates.add(date);
+    return current;
+  };
+  const addModelAllocation = (model, allocation) => {
+    for (const [date, value] of allocation) {
+      const models = modelsByDate.get(date) ?? {};
+      models[model] = (models[model] ?? 0) + value;
+      modelsByDate.set(date, models);
+    }
+  };
+  let estimatedCacheTokens = 0;
+  const seenModels = new Set();
+  for (const [model, rawUsage] of Object.entries(stats.modelUsage ?? {})) {
+    seenModels.add(model);
+    const usage = normalizeUsage(rawUsage);
+    const weights = modelWeights.get(model)?.size ? modelWeights.get(model) : activityWeights;
+    if (!weights.size) continue;
+    const input = allocateInteger(usage.inputTokens, weights);
+    const output = allocateInteger(usage.outputTokens, weights);
+    const cacheCreation = allocateInteger(usage.cacheCreationInputTokens, weights);
+    const cacheRead = allocateInteger(usage.cacheReadInputTokens, weights);
+    const combined = usage.inputTokens + usage.outputTokens > 0 ? new Map() : new Map(weights);
+    for (const [date, value] of input) { componentRow(date).input += value; componentRow(date).estimated = true; }
+    for (const [date, value] of output) { componentRow(date).output += value; componentRow(date).estimated = true; }
+    for (const [date, value] of cacheCreation) { componentRow(date).cacheCreation += value; componentRow(date).estimated = true; }
+    for (const [date, value] of cacheRead) { componentRow(date).cacheRead += value; componentRow(date).estimated = true; }
+    for (const [date, value] of combined) { componentRow(date).combined += value; componentRow(date).estimated = true; }
+    const modelTotal = new Map();
+    addAllocation(modelTotal, input); addAllocation(modelTotal, output); addAllocation(modelTotal, cacheCreation); addAllocation(modelTotal, cacheRead); addAllocation(modelTotal, combined);
+    addModelAllocation(model, modelTotal);
+    estimatedCacheTokens += usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+  }
+  for (const [model, weights] of modelWeights) {
+    if (seenModels.has(model)) continue;
+    for (const [date, value] of weights) {
+      componentRow(date).combined += value;
+      addModelAllocation(model, new Map([[date, value]]));
+    }
+  }
+  const orderedDates = [...dates].sort();
+  const daily = orderedDates.map((date) => {
     const activity = activityByDate.get(date) ?? {};
+    const components = componentsByDate.get(date) ?? { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, combined: 0, estimated: false };
+    const tokens = components.input + components.output + components.cacheCreation + components.cacheRead + components.combined;
+    const tokenProvenance = components.estimated ? 'estimated' : 'local_exact';
     const values = [
-      ['sessions', safeCount(activity.sessionCount)],
-      ['turns', safeCount(activity.messageCount)],
-      ['tool_calls', safeCount(activity.toolCallCount)],
-      ['tokens', safeCount(tokensByDate.get(date))],
+      ['sessions', safeCount(activity.sessionCount), 'local_exact'],
+      ['turns', safeCount(activity.messageCount), 'local_exact'],
+      ['tool_calls', safeCount(activity.toolCallCount), 'local_exact'],
+      ['tokens', tokens, tokenProvenance],
+      ['input_tokens', components.input, tokenProvenance],
+      ['output_tokens', components.output, tokenProvenance],
+      ['cache_creation_input_tokens', components.cacheCreation, tokenProvenance],
+      ['cache_read_input_tokens', components.cacheRead, tokenProvenance],
     ];
-    return { date, source: 'claude_code', category: 'coding', metrics: values.filter(([, value]) => value > 0).map(([name, value]) => metric(name, value, date)) };
+    return { date, source: 'claude_code', category: 'coding', metrics: values.filter(([, value]) => value > 0).map(([name, value, provenance]) => metric(name, value, date, provenance)), models: modelsByDate.get(date) };
   });
-  const modelUsage = Object.values(stats.modelUsage ?? {});
-  const undatedCacheTokens = modelUsage.reduce((sum, usage) => sum + safeCount(usage?.cacheReadInputTokens) + safeCount(usage?.cacheCreationInputTokens), 0);
-  return { daily, undatedCacheTokens };
+  return { daily, estimatedCacheTokens, undatedCacheTokens: estimatedCacheTokens, estimatedDates: daily.filter((day) => day.metrics.some((item) => item.name === 'tokens' && item.provenance === 'estimated')).length };
 }
 
 export function mergeClaudeUsage(sessionDaily, legacyDaily) {

package/src/codex-app-server.ts

@@ -31,7 +31,7 @@ export async function readCodexAccountUsage(timeoutMs = 8_000, executable = reso
   });
   try {
     await started;
-    await request(1, 'initialize', { clientInfo: { name: 'ai_native_profile', title: 'AI Native Profile', version: '0.1.3' } });
+    await request(1, 'initialize', { clientInfo: { name: 'ai_native_profile', title: 'AI Native Profile', version: '0.2.1' } });
     child.stdin.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
     return await request(2, 'account/usage/read');
   } finally {

package/src/file-discovery.mjs

@@ -0,0 +1,29 @@
+import { existsSync, lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function discoverLocalDataFiles(candidates, { maxFiles = 10_000 } = {}) {
+  const files = [];
+  const stack = [...candidates].reverse();
+  let truncated = false;
+
+  while (stack.length) {
+    const path = stack.pop();
+    if (!existsSync(path)) continue;
+    let info;
+    try { info = lstatSync(path); } catch { continue; }
+    if (info.isSymbolicLink()) continue;
+    if (info.isFile()) {
+      if (/\.(jsonl|json)$/i.test(path)) {
+        if (files.length >= maxFiles) { truncated = true; break; }
+        files.push(path);
+      }
+      continue;
+    }
+    if (!info.isDirectory()) continue;
+    let entries;
+    try { entries = readdirSync(path).sort((left, right) => left.localeCompare(right)); } catch { continue; }
+    for (let index = entries.length - 1; index >= 0; index -= 1) stack.push(join(path, entries[index]));
+  }
+
+  return { files, truncated };
+}