tokentracker-cli 0.93.6 → 0.94.0

package/src/lib/rollout.js

@@ -3285,6 +3285,7 @@ function normalizeOpencodeState(raw) {
   const messages = state.messages && typeof state.messages === "object" ? state.messages : {};
   return {
     messages,
+    dbCursor: state.dbCursor && typeof state.dbCursor === "object" ? state.dbCursor : null,
     updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : null,
   };
 }
@@ -3362,13 +3363,20 @@ function deriveOpencodeMessageFingerprint({ msg, totals, source }) {
 // Rebuilt per parse run. Pre-#426 entries are fingerprinted as they are read;
 // the first claims ownership and later cross-session matches are retracted from
 // persisted buckets once. Tombstoned copies never claim ownership themselves.
-function buildOpencodeFingerprintIndex(messageIndex) {
+function buildOpencodeFingerprintIndex(messageIndex, wantedFingerprints = null) {
   const byFingerprint = new Map();
   if (!messageIndex || typeof messageIndex !== "object") return byFingerprint;
-  for (const [key, entry] of Object.entries(messageIndex)) {
+  for (const key in messageIndex) {
+    const entry = messageIndex[key];
     if (entry?.dedupedForkCopy === true) continue;
     const fingerprint = entry && typeof entry.fingerprint === "string" ? entry.fingerprint : null;
-    if (fingerprint && !byFingerprint.has(fingerprint)) byFingerprint.set(fingerprint, key);
+    if (
+      fingerprint &&
+      (!wantedFingerprints || wantedFingerprints.has(fingerprint)) &&
+      !byFingerprint.has(fingerprint)
+    ) {
+      byFingerprint.set(fingerprint, key);
+    }
   }
   return byFingerprint;
 }
@@ -3393,6 +3401,52 @@ function isOpencodeForkCopy(fingerprintIndex, fingerprint, messageKey) {
   return ownerSession !== session;
 }
 
+function normalizeOpencodeAttribution(raw) {
+  if (typeof raw === "string") {
+    const [bucketStart = "", model = "", projectKey = "", projectRef = ""] = raw.split("\t");
+    if (!bucketStart || !model) return null;
+    return {
+      bucketStart,
+      model,
+      projectKey: projectKey || null,
+      projectRef: projectRef || null,
+    };
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const bucketStart = typeof raw.bucketStart === "string" ? raw.bucketStart : "";
+  const model = typeof raw.model === "string" ? raw.model : "";
+  if (!bucketStart || !model) return null;
+  return {
+    bucketStart,
+    model,
+    projectKey: typeof raw.projectKey === "string" ? raw.projectKey : null,
+    projectRef: typeof raw.projectRef === "string" ? raw.projectRef : null,
+  };
+}
+
+function encodeOpencodeAttribution(raw) {
+  const attribution = normalizeOpencodeAttribution(raw);
+  if (!attribution) return null;
+  return [
+    attribution.bucketStart,
+    attribution.model,
+    attribution.projectKey || "",
+    attribution.projectRef || "",
+  ].join("\t");
+}
+
+function sameOpencodeAttribution(a, b) {
+  const left = normalizeOpencodeAttribution(a);
+  const right = normalizeOpencodeAttribution(b);
+  if (!left || !right) return left === right;
+  return (
+    left.bucketStart === right.bucketStart &&
+    left.model === right.model &&
+    left.projectKey === right.projectKey &&
+    left.projectRef === right.projectRef
+  );
+}
+
 // Persist a message's snapshot + fingerprint and claim the fingerprint for it.
 // Writes only when something actually changed so a steady-state sync leaves the
 // cursor untouched. A falsy `fingerprint` means "unknown" and preserves whatever
@@ -3404,6 +3458,7 @@ function recordOpencodeMessage({
   messageKey,
   totals,
   fingerprint,
+  attribution,
   dedupedForkCopy = false,
 }) {
   if (!messageIndex || !messageKey) return;
@@ -3411,10 +3466,13 @@ function recordOpencodeMessage({
   const prevTotals = prev && typeof prev.lastTotals === "object" ? prev.lastTotals : null;
   const prevFingerprint = prev && typeof prev.fingerprint === "string" ? prev.fingerprint : null;
   const nextFingerprint = fingerprint || prevFingerprint;
+  const prevAttribution = normalizeOpencodeAttribution(prev?.attribution);
+  const nextAttribution = normalizeOpencodeAttribution(attribution) || prevAttribution;
   const prevDeduped = prev?.dedupedForkCopy === true;
   if (
     sameGeminiTotals(totals, prevTotals) &&
     prevFingerprint === nextFingerprint &&
+    sameOpencodeAttribution(prevAttribution, nextAttribution) &&
     prevDeduped === Boolean(dedupedForkCopy)
   ) return;
 
@@ -3425,6 +3483,7 @@ function recordOpencodeMessage({
   }
   const entry = { lastTotals: totals, updatedAt: new Date().toISOString() };
   if (nextFingerprint) entry.fingerprint = nextFingerprint;
+  if (nextAttribution) entry.attribution = encodeOpencodeAttribution(nextAttribution);
   if (dedupedForkCopy) entry.dedupedForkCopy = true;
   messageIndex[messageKey] = entry;
   if (
@@ -3437,41 +3496,79 @@ function recordOpencodeMessage({
   }
 }
 
-function repairCountedOpencodeForkCopy({
-  msg,
+function subtractCountedOpencodeMessage({
+  attribution,
   totals,
   source,
   hourlyState,
   touchedBuckets,
   projectState,
   projectTouchedBuckets,
-  projectRef,
-  projectKey,
 }) {
-  const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
-  if (!timestampMs) return false;
-  const bucketStart = toUtcHalfHourStart(new Date(timestampMs).toISOString());
-  if (!bucketStart) return false;
-  const { modelId: repairModelId } = normalizeOpencodeModelFields(msg);
-  const model = repairModelId || DEFAULT_MODEL;
+  const countedAt = normalizeOpencodeAttribution(attribution);
+  if (!countedAt) return false;
   const counted = { ...totals, conversation_count: 1 };
-  const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+  const bucket = getHourlyBucket(
+    hourlyState,
+    source,
+    countedAt.model,
+    countedAt.bucketStart,
+  );
   subtractTotals(bucket.totals, counted);
-  touchedBuckets.add(bucketKey(source, model, bucketStart));
-  if (projectKey && projectState && projectTouchedBuckets) {
+  touchedBuckets.add(bucketKey(source, countedAt.model, countedAt.bucketStart));
+  if (countedAt.projectKey && projectState && projectTouchedBuckets) {
     const projectBucket = getProjectBucket(
       projectState,
-      projectKey,
+      countedAt.projectKey,
       source,
-      bucketStart,
-      projectRef,
+      countedAt.bucketStart,
+      countedAt.projectRef,
     );
     subtractTotals(projectBucket.totals, counted);
-    projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+    projectTouchedBuckets.add(
+      projectBucketKey(countedAt.projectKey, source, countedAt.bucketStart),
+    );
   }
   return true;
 }
 
+function repairCountedOpencodeForkCopy({
+  msg,
+  attribution,
+  totals,
+  source,
+  hourlyState,
+  touchedBuckets,
+  projectState,
+  projectTouchedBuckets,
+  projectRef,
+  projectKey,
+}) {
+  let countedAt = normalizeOpencodeAttribution(attribution);
+  if (!countedAt) {
+    const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+    if (!timestampMs) return false;
+    const bucketStart = toUtcHalfHourStart(new Date(timestampMs).toISOString());
+    if (!bucketStart) return false;
+    const { modelId: repairModelId } = normalizeOpencodeModelFields(msg);
+    countedAt = {
+      bucketStart,
+      model: repairModelId || DEFAULT_MODEL,
+      projectKey,
+      projectRef,
+    };
+  }
+  return subtractCountedOpencodeMessage({
+    attribution: countedAt,
+    totals,
+    source,
+    hourlyState,
+    touchedBuckets,
+    projectState,
+    projectTouchedBuckets,
+  });
+}
+
 function getHourlyBucket(state, source, model, hourStart) {
   const buckets = state.buckets;
   const normalizedSource = normalizeSourceInput(source) || DEFAULT_SOURCE;
@@ -4185,10 +4282,6 @@ function diffGeminiTotals(current, previous) {
   const totalReset = (current.total_tokens || 0) < (previous.total_tokens || 0);
   if (totalReset) return current;
 
-  // Must include cache_creation_input_tokens in both the equality check and
-  // the delta — OpenCode routes through this diff and its cache.write number
-  // would otherwise be permanently reported as zero. Gemini itself always
-  // emits cache_creation=0 so the extra field is a no-op for Gemini.
   const delta = {
     input_tokens: Math.max(0, (current.input_tokens || 0) - (previous.input_tokens || 0)),
     cached_input_tokens: Math.max(
@@ -4210,6 +4303,29 @@ function diffGeminiTotals(current, previous) {
   return isAllZeroUsage(delta) ? null : delta;
 }
 
+// OpenCode rows are authoritative snapshots of one message and can be
+// corrected downward or move tokens between cache/output columns. Signed
+// deltas replace the prior contribution instead of treating a correction as a
+// fresh cumulative reset. Gemini keeps its provider-specific reset behavior.
+function diffOpencodeTotals(current, previous) {
+  if (!current || typeof current !== "object") return null;
+  if (!previous || typeof previous !== "object") return current;
+  if (sameGeminiTotals(current, previous)) return null;
+
+  const delta = {};
+  for (const key of [
+    "input_tokens",
+    "cached_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens",
+    "total_tokens",
+  ]) {
+    delta[key] = Number(current[key] || 0) - Number(previous[key] || 0);
+  }
+  return isAllZeroUsage(delta) ? null : delta;
+}
+
 function extractTokenCount(obj) {
   const payload = obj?.payload;
   if (!payload) return null;
@@ -4391,15 +4507,73 @@ async function walkOpencodeMessages(dir, out) {
 // both "is there v2 data?" and "which session table exists?" in one round-trip.
 // ---------------------------------------------------------------------------
 
-const OPENCODE_DB_V1_MESSAGE_SQL =
-  `SELECT id, session_id, time_updated, data FROM message ` +
-  `WHERE json_extract(data, '$.role') = 'assistant' ORDER BY time_created ASC`;
+const OPENCODE_DB_CURSOR_VERSION = 1;
+
+function normalizeOpencodeDbWatermark(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const maxRowId = Math.max(0, Math.floor(Number(raw.maxRowId) || 0));
+  const maxUpdatedAt = Math.max(0, Math.floor(Number(raw.maxUpdatedAt) || 0));
+  const anchor = typeof raw.anchor === "string" && raw.anchor ? raw.anchor : null;
+  return maxRowId || maxUpdatedAt ? { maxRowId, maxUpdatedAt, anchor } : null;
+}
+
+function opencodeDbIdentity(dbPath) {
+  try {
+    const stat = fssync.statSync(dbPath);
+    const resolved = path.resolve(dbPath);
+    return {
+      pathHash: crypto.createHash("sha256").update(resolved).digest("hex"),
+      dev: String(stat.dev || 0),
+      ino: String(stat.ino || 0),
+    };
+  } catch (_e) {
+    return null;
+  }
+}
+
+function sameOpencodeDbIdentity(a, b) {
+  return Boolean(
+    a &&
+    b &&
+    a.pathHash === b.pathHash &&
+    a.dev === b.dev &&
+    a.ino === b.ino,
+  );
+}
+
+function opencodeDbRowAnchor(row) {
+  if (!row || typeof row !== "object") return null;
+  const rowId = Math.max(0, Math.floor(Number(row.row_id) || 0));
+  const id = typeof row.id === "string" ? row.id : "";
+  const created = Math.max(0, Math.floor(Number(row.time_created) || 0));
+  if (!rowId || !id) return null;
+  return crypto.createHash("sha256").update(`${rowId}\0${id}\0${created}`).digest("base64url");
+}
+
+function opencodeDbIncrementalPredicate(alias, watermark) {
+  const cursor = normalizeOpencodeDbWatermark(watermark);
+  if (!cursor) return "";
+  const clauses = [];
+  if (cursor.maxRowId) clauses.push(`${alias}rowid > ${cursor.maxRowId}`);
+  // Re-read the boundary timestamp so simultaneous updates cannot fall through
+  // a strict greater-than watermark. The duplicate is removed by messageIndex.
+  if (cursor.maxUpdatedAt) clauses.push(`${alias}time_updated >= ${cursor.maxUpdatedAt}`);
+  return clauses.length > 0 ? ` AND (${clauses.join(" OR ")})` : "";
+}
+
+function buildV1Sql(watermark = null) {
+  return (
+    `SELECT rowid AS row_id, id, session_id, time_updated, data FROM message ` +
+    `WHERE json_extract(data, '$.role') = 'assistant'` +
+    `${opencodeDbIncrementalPredicate("", watermark)} ORDER BY time_created ASC`
+  );
+}
 
 // Build the v2 query. When a session table exists the LEFT JOIN restores the
 // project directory for downstream attribution; when it does not (type B
 // without session_v2, or an exotic fork) the join and directory column are
 // omitted and tokens are counted as-is.
-function buildV2Sql(sessionTable) {
+function buildV2Sql(sessionTable, watermark = null) {
   const joinClause = sessionTable
     ? `LEFT JOIN ${sessionTable} s ON s.id = sm.session_id `
     : "";
@@ -4407,10 +4581,11 @@ function buildV2Sql(sessionTable) {
     ? `s.directory AS directory, `
     : "";
   return (
-    `SELECT sm.id AS id, sm.session_id AS session_id, sm.time_updated AS time_updated, ` +
+    `SELECT sm.rowid AS row_id, sm.id AS id, sm.session_id AS session_id, sm.time_updated AS time_updated, ` +
     `${directorySelect}sm.data AS data ` +
     `FROM session_message sm ${joinClause}` +
-    `WHERE sm.type = 'assistant' ORDER BY sm.time_created ASC`
+    `WHERE sm.type = 'assistant'` +
+    `${opencodeDbIncrementalPredicate("sm.", watermark)} ORDER BY sm.time_created ASC`
   );
 }
 
@@ -4447,8 +4622,13 @@ function opencodeMessageProvider(data) {
   return data?.providerID || data?.model?.providerID || "";
 }
 
-function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
-  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return { messages: [], cursor: null };
+
+  const identity = opencodeDbIdentity(dbPath);
+  const canResume =
+    previousCursor?.version === OPENCODE_DB_CURSOR_VERSION &&
+    sameOpencodeDbIdentity(previousCursor.identity, identity);
 
   let snapshot = null;
   let effectiveDbPath = dbPath;
@@ -4483,7 +4663,9 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
       const hasTokens =
         toNonNegativeInt(tokens.input) > 0 ||
         toNonNegativeInt(tokens.output) > 0 ||
-        toNonNegativeInt(tokens.reasoning) > 0;
+        toNonNegativeInt(tokens.reasoning) > 0 ||
+        toNonNegativeInt(tokens.cache?.read) > 0 ||
+        toNonNegativeInt(tokens.cache?.write) > 0;
       if (!hasTokens) continue;
       if (isV2 && typeof row.directory === "string" && row.directory.trim()) {
         data.path = { ...(typeof data.path === "object" && data.path ? data.path : {}), cwd: row.directory };
@@ -4512,6 +4694,74 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
     }
   };
 
+  const readMaxRowId = (table) => {
+    const rows = readGeneration(`SELECT MAX(rowid) AS max_row_id FROM ${table}`);
+    if (!rows) return null;
+    return Math.max(0, Math.floor(Number(rows[0]?.max_row_id) || 0));
+  };
+
+  const readRowAnchor = (table, rowId) => {
+    if (!rowId) return null;
+    const rows = readGeneration(
+      `SELECT rowid AS row_id, id, time_created FROM ${table} WHERE rowid = ${rowId}`,
+    );
+    return rows ? opencodeDbRowAnchor(rows[0]) : null;
+  };
+
+  const readCursorGeneration = ({ table, isV2, sql }) => {
+    const previous = canResume
+      ? normalizeOpencodeDbWatermark(previousCursor?.[isV2 ? "v2" : "v1"])
+      : null;
+    let forceReplay = false;
+    let lastRows = [];
+
+    // Each query uses a separate SQLite reader. Verify the same immutable head
+    // row before and after the data query so an in-place database replacement
+    // cannot make us persist a cursor from a generation we did not read.
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const currentMaxRowId = readMaxRowId(table);
+      if (currentMaxRowId === null) return null;
+      const currentAnchor = readRowAnchor(table, currentMaxRowId);
+      const previousAnchor = previous
+        ? readRowAnchor(table, previous.maxRowId)
+        : null;
+      const watermark =
+        !forceReplay &&
+        previous?.anchor &&
+        currentMaxRowId >= previous.maxRowId &&
+        previousAnchor === previous.anchor
+          ? previous
+          : null;
+      const rows = readGeneration(sql(watermark));
+      if (!rows) return null;
+      lastRows = rows;
+
+      if (readRowAnchor(table, currentMaxRowId) !== currentAnchor) {
+        forceReplay = true;
+        continue;
+      }
+
+      let maxUpdatedAt = watermark?.maxUpdatedAt || 0;
+      for (const row of rows) {
+        maxUpdatedAt = Math.max(maxUpdatedAt, Math.floor(Number(row?.time_updated) || 0));
+      }
+      return {
+        rows,
+        // Advance only to the head whose anchor bracketed this query. Rows
+        // appended concurrently may be returned now and harmlessly reread on
+        // the next sync; advancing to them would require an unverified anchor.
+        cursor: {
+          maxRowId: currentMaxRowId,
+          maxUpdatedAt,
+          anchor: currentAnchor,
+        },
+      };
+    }
+
+    // Keep parsed usage but refuse to advance while the database is unstable.
+    return { rows: lastRows, cursor: null };
+  };
+
   try {
     // Combined probe drives the orchestration: v1 always runs (it is the
     // baseline every database carries or degrades to), v2 runs only when the
@@ -4519,21 +4769,48 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
     // against a non-existent session table on type-A databases.
     const probe = detectOpencodeMessageLayout(effectiveDbPath, sqliteOptions);
     const out = [];
+    const nextCursor = {
+      version: OPENCODE_DB_CURSOR_VERSION,
+      identity,
+      v1: null,
+      v2: null,
+    };
 
-    const rows1 = readGeneration(OPENCODE_DB_V1_MESSAGE_SQL);
-    if (rows1) appendRows(rows1, false, out);
+    const v1 = readCursorGeneration({
+      table: "message",
+      isV2: false,
+      sql: buildV1Sql,
+    });
+    if (v1) {
+      appendRows(v1.rows, false, out);
+      nextCursor.v1 = v1.cursor;
+    }
 
     if (probe?.hasRows) {
-      const rows2 = readGeneration(buildV2Sql(probe.sessionTable));
-      if (rows2) appendRows(rows2, true, out);
+      const v2 = readCursorGeneration({
+        table: "session_message",
+        isV2: true,
+        sql: (watermark) => buildV2Sql(probe.sessionTable, watermark),
+      });
+      if (v2) {
+        appendRows(v2.rows, true, out);
+        nextCursor.v2 = v2.cursor;
+      }
     }
 
-    return out;
+    return {
+      messages: out,
+      cursor: nextCursor.v1 || nextCursor.v2 ? nextCursor : null,
+    };
   } finally {
     if (snapshot) snapshot.cleanup();
   }
 }
 
+function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
+  return readOpencodeDbMessagesIncremental(dbPath, null, sqliteOptions).messages;
+}
+
 // mimocode mirrors the user's Claude Code + claude-mem history into its own
 // `message` table — via an explicit `claude_import` AND a live observer /
 // session sync — so the overwhelming majority of rows are anthropic-endpoint
@@ -4791,6 +5068,7 @@ function readZcodeDbMessages(dbPath, sqliteOptions = {}) {
 async function parseOpencodeDbIncremental({
   dbMessages,
   dbPath,
+  dbCursor,
   cursors,
   queuePath,
   projectQueuePath,
@@ -4815,9 +5093,20 @@ async function parseOpencodeDbIncremental({
   const cursorNamespace = typeof cursorKey === "string" && cursorKey.length > 0 ? cursorKey : "opencode";
   const opencodeState = normalizeOpencodeState(cursors?.[cursorNamespace]);
   const messageIndex = opencodeState.messages;
-  const fingerprintIndex = buildOpencodeFingerprintIndex(messageIndex);
   const touchedBuckets = new Set();
   const defaultSource = normalizeSourceInput(source) || "opencode";
+  const candidateFingerprints = new Set();
+  for (const entry of messages) {
+    const totals = normalizeOpencodeTokens(entry?.data?.tokens);
+    const fingerprint = totals
+      ? deriveOpencodeMessageFingerprint({ msg: entry.data, totals, source: defaultSource })
+      : null;
+    if (fingerprint) candidateFingerprints.add(fingerprint);
+  }
+  // A hook-triggered sync normally carries one changed row. Restrict the
+  // historical fingerprint map to fingerprints that can actually match this
+  // batch instead of duplicating the whole long-lived message index in memory.
+  const fingerprintIndex = buildOpencodeFingerprintIndex(messageIndex, candidateFingerprints);
 
   for (let idx = 0; idx < messages.length; idx++) {
     const entry = messages[idx];
@@ -4867,6 +5156,7 @@ async function parseOpencodeDbIncremental({
       if (lastTotals && prev?.dedupedForkCopy !== true) {
         repairCountedOpencodeForkCopy({
           msg,
+          attribution: prev?.attribution,
           totals: lastTotals,
           source: defaultSource,
           hourlyState,
@@ -4890,17 +5180,58 @@ async function parseOpencodeDbIncremental({
     }
 
     const effectiveLastTotals = prev?.dedupedForkCopy === true ? null : lastTotals;
-    const delta = diffGeminiTotals(currentTotals, effectiveLastTotals);
-    if (!delta || isAllZeroUsage(delta)) {
+    const delta = diffOpencodeTotals(currentTotals, effectiveLastTotals);
+    const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+    if (!timestampMs) {
+      messagesProcessed += 1;
+      continue;
+    }
+
+    const tsIso = new Date(timestampMs).toISOString();
+    const bucketStart = toUtcHalfHourStart(tsIso);
+    if (!bucketStart) {
+      messagesProcessed += 1;
+      continue;
+    }
+
+    const { modelId: dbModelId } = normalizeOpencodeModelFields(msg);
+    const model = dbModelId || DEFAULT_MODEL;
+    const projectContext = projectEnabled
+      ? await resolveProjectContextForDb({
+          msg,
+          dbPath,
+          projectMetaCache,
+          publicRepoCache,
+          publicRepoResolver,
+          projectState,
+        })
+      : null;
+    const attribution = {
+      bucketStart,
+      model,
+      projectKey: projectContext?.projectKey || null,
+      projectRef: projectContext?.projectRef || null,
+    };
+
+    const previousAttribution = effectiveLastTotals
+      ? normalizeOpencodeAttribution(prev?.attribution)
+      : null;
+    const moved = Boolean(
+      effectiveLastTotals &&
+      previousAttribution &&
+      !sameOpencodeAttribution(previousAttribution, attribution),
+    );
+    if ((!delta || isAllZeroUsage(delta)) && !moved) {
       // Refresh the index even without a delta: normalization may have changed,
-      // and pre-#426 entries need their fingerprint backfilled so a fork taken
-      // from an old session is still recognised.
+      // and pre-#426 entries need their fingerprint backfilled. Preserve an
+      // existing contribution location without bloating every legacy cursor.
       recordOpencodeMessage({
         messageIndex,
         fingerprintIndex,
         messageKey,
         totals: currentTotals,
         fingerprint,
+        attribution: prev?.attribution ? attribution : null,
         dedupedForkCopy: false,
       });
       messagesProcessed += 1;
@@ -4915,49 +5246,37 @@ async function parseOpencodeDbIncremental({
       }
       continue;
     }
-    delta.conversation_count = 1;
-
-    const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
-    if (!timestampMs) {
-      messagesProcessed += 1;
-      continue;
-    }
 
-    const tsIso = new Date(timestampMs).toISOString();
-    const bucketStart = toUtcHalfHourStart(tsIso);
-    if (!bucketStart) {
-      messagesProcessed += 1;
-      continue;
+    if (moved) {
+      subtractCountedOpencodeMessage({
+        attribution: previousAttribution,
+        totals: effectiveLastTotals,
+        source: defaultSource,
+        hourlyState,
+        touchedBuckets,
+        projectState,
+        projectTouchedBuckets,
+      });
     }
-
-    const { modelId: dbModelId } = normalizeOpencodeModelFields(msg);
-    const model = dbModelId || DEFAULT_MODEL;
+    const contribution = moved
+      ? { ...currentTotals, conversation_count: 1 }
+      : { ...delta, conversation_count: effectiveLastTotals ? 0 : 1 };
     const bucket = getHourlyBucket(hourlyState, defaultSource, model, bucketStart);
-    addTotals(bucket.totals, delta);
+    addTotals(bucket.totals, contribution);
     touchedBuckets.add(bucketKey(defaultSource, model, bucketStart));
 
-    if (projectEnabled) {
-      const projectContext = await resolveProjectContextForDb({
-        msg,
-        dbPath,
-        projectMetaCache,
-        publicRepoCache,
-        publicRepoResolver,
+    if (attribution.projectKey && projectState && projectTouchedBuckets) {
+      const projectBucket = getProjectBucket(
         projectState,
-      });
-      const projectRef = projectContext?.projectRef || null;
-      const projectKey = projectContext?.projectKey || null;
-      if (projectKey && projectState && projectTouchedBuckets) {
-        const projectBucket = getProjectBucket(
-          projectState,
-          projectKey,
-          defaultSource,
-          bucketStart,
-          projectRef,
-        );
-        addTotals(projectBucket.totals, delta);
-        projectTouchedBuckets.add(projectBucketKey(projectKey, defaultSource, bucketStart));
-      }
+        attribution.projectKey,
+        defaultSource,
+        bucketStart,
+        attribution.projectRef,
+      );
+      addTotals(projectBucket.totals, contribution);
+      projectTouchedBuckets.add(
+        projectBucketKey(attribution.projectKey, defaultSource, bucketStart),
+      );
     }
 
     recordOpencodeMessage({
@@ -4966,10 +5285,11 @@ async function parseOpencodeDbIncremental({
       messageKey,
       totals: currentTotals,
       fingerprint,
+      attribution,
       dedupedForkCopy: false,
     });
     messagesProcessed += 1;
-    eventsAggregated += 1;
+    if (delta && !isAllZeroUsage(delta)) eventsAggregated += 1;
 
     if (cb) {
       cb({
@@ -4988,6 +5308,7 @@ async function parseOpencodeDbIncremental({
     : 0;
   hourlyState.updatedAt = new Date().toISOString();
   cursors.hourly = hourlyState;
+  if (dbCursor && typeof dbCursor === "object") opencodeState.dbCursor = dbCursor;
   opencodeState.updatedAt = new Date().toISOString();
   cursors[cursorNamespace] = opencodeState;
   if (projectState) {
@@ -13542,7 +13863,7 @@ async function parseCraftIncremental({
 //   COPILOT_OTEL_ENABLED=true
 //   COPILOT_OTEL_EXPORTER_TYPE=file
 //   COPILOT_OTEL_FILE_EXPORTER_PATH=$HOME/.copilot/otel/copilot-otel-...jsonl
-// We scan the default directory plus the env-overridden path.
+// We scan both known default directories plus the env-overridden path.
 // ─────────────────────────────────────────────────────────────────────────────
 
 function resolveCopilotOtelPaths(env = process.env) {
@@ -13557,12 +13878,19 @@ function resolveCopilotOtelPaths(env = process.env) {
     } catch (_e) {}
   };
   if (process.platform !== "win32" || wsl.shouldProbeNative(env)) {
-    scanDir(path.join(home, ".copilot", "otel"));
+    for (const dir of [
+      path.join(home, ".copilot", "otel"),
+      path.join(home, ".copilot-otel"),
+    ]) {
+      scanDir(dir);
+    }
   }
   if (process.platform === "win32") {
     if (wsl.shouldProbeWsl(env)) {
-      const wslDir = wsl.discoverWslHome(".copilot/otel", { env });
-      if (wslDir) scanDir(wslDir);
+      for (const providerDir of [".copilot/otel", ".copilot-otel"]) {
+        const wslDir = wsl.discoverWslHome(providerDir, { env });
+        if (wslDir) scanDir(wslDir);
+      }
     }
   }
   const explicit = env.COPILOT_OTEL_FILE_EXPORTER_PATH;
@@ -13604,7 +13932,7 @@ function pickCopilotModel(attrs) {
   return null;
 }
 
-const COPILOT_PARSER_VERSION = 2;
+const COPILOT_PARSER_VERSION = 3;
 const COPILOT_USAGE_CLAIM_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 const COPILOT_USAGE_CLAIM_MAX_ENTRIES = 10_000;
 
@@ -13661,14 +13989,168 @@ function incrementMapCount(map, key, amount = 1) {
   map.set(key, (map.get(key) || 0) + amount);
 }
 
-function getCopilotDedupKey(record, attrs = record?.attributes || {}) {
+function getCopilotResponseId(attrs = {}) {
+  const responseId = attrs["gen_ai.response.id"];
+  return typeof responseId === "string" && responseId.trim() ? responseId.trim() : "";
+}
+
+// v2 preferred spanContext for every OTEL envelope. Chat-extension LogRecords
+// can share that nested context across several model requests, so keep the old
+// key only for the one envelope that owns top-level traceId/spanId: CLI spans.
+function getCopilotLegacyDedupKey(record, attrs = record?.attributes || {}) {
   const traceId = record?.traceId || record?.spanContext?.traceId || "";
   const spanId = record?.spanId || record?.spanContext?.spanId || "";
-  const responseId =
-    typeof attrs["gen_ai.response.id"] === "string" ? attrs["gen_ai.response.id"] : "";
+  const responseId = getCopilotResponseId(attrs);
   return traceId && spanId ? `${traceId}:${spanId}` : responseId ? `resp:${responseId}` : null;
 }
 
+function getCopilotDedupKey(record, attrs = record?.attributes || {}) {
+  const responseId = getCopilotResponseId(attrs);
+  if (!isCopilotV1ChatSpan(record)) {
+    return responseId ? `resp:${responseId}` : null;
+  }
+
+  const traceId = record?.traceId || "";
+  const spanId = record?.spanId || "";
+  return traceId && spanId
+    ? `${traceId}:${spanId}`
+    : responseId
+      ? `resp:${responseId}`
+      : null;
+}
+
+function copilotOtelAggregateKey(model, bucketStart) {
+  return JSON.stringify([model, bucketStart]);
+}
+
+function addCopilotOtelAggregate(aggregates, model, bucketStart, delta) {
+  const key = copilotOtelAggregateKey(model, bucketStart);
+  let totals = aggregates.get(key);
+  if (!totals) {
+    totals = initTotals();
+    aggregates.set(key, totals);
+  }
+  addTotals(totals, delta);
+}
+
+function copilotTotalsCover(existing, required) {
+  if (!existing || typeof existing !== "object") return false;
+  for (const field of [
+    "input_tokens",
+    "cached_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens",
+    "total_tokens",
+    "billable_total_tokens",
+    "conversation_count",
+  ]) {
+    const actual = Number(existing[field] || 0);
+    const needed = Number(required?.[field] || 0);
+    if (!Number.isFinite(actual) || !Number.isFinite(needed) || actual < needed) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function extractCopilotOtelUsage(record) {
+  if (!isCopilotChatSpan(record)) return null;
+
+  const attrs = record.attributes || {};
+  const inputRaw = toNonNegativeInt(attrs["gen_ai.usage.input_tokens"]);
+  const output = toNonNegativeInt(attrs["gen_ai.usage.output_tokens"]);
+  const cacheRead = toNonNegativeInt(
+    attrs["gen_ai.usage.cache_read.input_tokens"] ??
+      attrs["gen_ai.usage.cache_read_input_tokens"] ??
+      attrs["gen_ai.usage.cached_input_tokens"],
+  );
+  // Copilot CLI: cache_write.input_tokens; Copilot Chat extension: cache_creation.input_tokens
+  const cacheWrite = toNonNegativeInt(
+    attrs["gen_ai.usage.cache_write.input_tokens"] ??
+      attrs["gen_ai.usage.cache_creation.input_tokens"] ??
+      attrs["gen_ai.usage.cache_write_input_tokens"] ??
+      attrs["gen_ai.usage.cache_creation_input_tokens"],
+  );
+  // Copilot CLI: reasoning.output_tokens; Copilot Chat extension: reasoning_tokens
+  const reasoning = toNonNegativeInt(
+    attrs["gen_ai.usage.reasoning.output_tokens"] ??
+      attrs["gen_ai.usage.reasoning_tokens"] ??
+      attrs["gen_ai.usage.reasoning_output_tokens"],
+  );
+  const reasoningClamped = Math.min(reasoning, output);
+  const outputWithoutReasoning = Math.max(0, output - reasoningClamped);
+  const cliSpan = isCopilotV1ChatSpan(record);
+  // CLI input includes both cache reads and writes. Chat-extension LogRecords
+  // expose cache creation separately, so preserve their existing input-minus-read semantics.
+  const cacheReadClamped = Math.min(cacheRead, inputRaw);
+  const cacheWriteClamped = Math.min(
+    cacheWrite,
+    Math.max(0, inputRaw - cacheReadClamped),
+  );
+  const cacheWriteForAccounting = cliSpan ? cacheWriteClamped : cacheWrite;
+  const input = Math.max(
+    0,
+    inputRaw - cacheReadClamped - (cliSpan ? cacheWriteClamped : 0),
+  );
+  const totalInteresting =
+    input +
+    outputWithoutReasoning +
+    cacheReadClamped +
+    cacheWriteForAccounting +
+    reasoningClamped;
+  if (totalInteresting === 0) return null;
+
+  // CLI Span uses endTime/startTime; Chat extension LogRecord uses hrTime/hrTimeObserved.
+  const tsMs =
+    copilotOtelTimeToMs(record.endTime) ||
+    copilotOtelTimeToMs(record.startTime) ||
+    copilotOtelTimeToMs(record.hrTime) ||
+    copilotOtelTimeToMs(record.hrTimeObserved);
+  if (!tsMs) return null;
+  const bucketStart = toUtcHalfHourStart(new Date(tsMs).toISOString());
+  if (!bucketStart) return null;
+
+  const model =
+    normalizeCopilotAppModel(pickCopilotModel(attrs)) ||
+    COPILOT_APP_DEFAULT_MODEL;
+  const cliSessionId =
+    typeof attrs["gen_ai.conversation.id"] === "string"
+      ? attrs["gen_ai.conversation.id"].trim()
+      : "";
+  const matchBase = {
+    sessionId: cliSessionId,
+    model,
+    output: outputWithoutReasoning,
+    cacheRead: cacheReadClamped,
+    cacheWrite: cacheWriteClamped,
+    reasoning: reasoningClamped,
+    tsMs,
+  };
+  return {
+    bucketStart,
+    cliSpan,
+    cliSessionId,
+    delta: {
+      input_tokens: input,
+      cached_input_tokens: cacheReadClamped,
+      cache_creation_input_tokens: cacheWriteForAccounting,
+      output_tokens: outputWithoutReasoning,
+      reasoning_output_tokens: reasoningClamped,
+      total_tokens:
+        input +
+        outputWithoutReasoning +
+        cacheReadClamped +
+        cacheWriteForAccounting +
+        reasoningClamped,
+      conversation_count: 1,
+    },
+    matchBase,
+    model,
+    tsMs,
+  };
+}
+
 function copilotUsageMatchKey({
   sessionId,
   model,
@@ -13728,6 +14210,141 @@ function createCopilotStoreUsageMatcher(events) {
   };
 }
 
+// v2 may already have advanced the file cursor while collapsing several Chat
+// extension LogRecords that shared one nested spanContext. Recompute only that
+// envelope's historical contribution and apply the delta to the existing
+// Copilot buckets. CLI spans are deliberately left alone: their v2 key was the
+// correct top-level traceId:spanId key, and session-store adoption can coexist
+// with the OTEL parser.
+async function migrateCopilotChatLogRecordDedup({
+  files,
+  fileOffsets,
+  hourlyState,
+  touchedBuckets,
+  seenIds,
+} = {}) {
+  const trackedFiles = Object.keys(fileOffsets || {}).filter(
+    (filePath) => Number(fileOffsets[filePath]?.size) > 0,
+  );
+  if (trackedFiles.length === 0) {
+    return { applied: true, changed: false };
+  }
+
+  const availableFiles = new Set(Array.isArray(files) ? files : []);
+  if (trackedFiles.some((filePath) => !availableFiles.has(filePath))) {
+    return { applied: false, reason: "a previously parsed OTEL file is unavailable" };
+  }
+
+  const oldSeen = new Set();
+  const newSeen = new Set();
+  const oldTotals = new Map();
+  const newTotals = new Map();
+
+  for (const filePath of files) {
+    if (!Object.prototype.hasOwnProperty.call(fileOffsets, filePath)) continue;
+    const prevEntry = fileOffsets[filePath] || {};
+    const prevSize = Number(prevEntry.size) || 0;
+    if (prevSize <= 0) continue;
+
+    let stat;
+    try {
+      stat = fssync.statSync(filePath);
+    } catch (_e) {
+      return { applied: false, reason: "a previously parsed OTEL file is unreadable" };
+    }
+    if (
+      stat.size < prevSize ||
+      (typeof prevEntry.ino === "number" && stat.ino !== prevEntry.ino)
+    ) {
+      return { applied: false, reason: "a previously parsed OTEL file changed during migration" };
+    }
+
+    let stream;
+    try {
+      stream = fssync.createReadStream(filePath, {
+        encoding: "utf8",
+        start: 0,
+        end: prevSize - 1,
+      });
+      const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      try {
+        for await (const line of rl) {
+          if (!line || !line.trim()) continue;
+          let record;
+          try {
+            record = JSON.parse(line);
+          } catch (_e) {
+            continue;
+          }
+          const usage = extractCopilotOtelUsage(record);
+          if (!usage || usage.cliSpan) continue;
+
+          const oldKey = getCopilotLegacyDedupKey(record, record.attributes || {});
+          const oldDuplicate = oldKey && oldSeen.has(oldKey);
+          if (oldKey) oldSeen.add(oldKey);
+          if (!oldDuplicate) {
+            addCopilotOtelAggregate(
+              oldTotals,
+              usage.model,
+              usage.bucketStart,
+              usage.delta,
+            );
+          }
+
+          const newKey = getCopilotDedupKey(record, record.attributes || {});
+          const newDuplicate = newKey && newSeen.has(newKey);
+          if (newKey) newSeen.add(newKey);
+          if (!newDuplicate) {
+            addCopilotOtelAggregate(
+              newTotals,
+              usage.model,
+              usage.bucketStart,
+              usage.delta,
+            );
+          }
+        }
+      } finally {
+        rl.close();
+      }
+    } catch (_e) {
+      return { applied: false, reason: "an OTEL file could not be scanned" };
+    } finally {
+      stream?.destroy();
+    }
+  }
+
+  const keys = new Set([...oldTotals.keys(), ...newTotals.keys()]);
+  for (const key of keys) {
+    const [model, bucketStart] = JSON.parse(key);
+    const oldUsage = oldTotals.get(key) || initTotals();
+    if (!copilotTotalsCover(
+      hourlyState.buckets[bucketKey("copilot", model, bucketStart)]?.totals,
+      oldUsage,
+    )) {
+      return {
+        applied: false,
+        reason: "existing Copilot buckets do not cover the old OTEL contribution",
+      };
+    }
+  }
+
+  let changed = false;
+  for (const key of keys) {
+    const [model, bucketStart] = JSON.parse(key);
+    const oldUsage = oldTotals.get(key) || initTotals();
+    const newUsage = newTotals.get(key) || initTotals();
+    if (totalsKey(oldUsage) === totalsKey(newUsage)) continue;
+    const bucket = getHourlyBucket(hourlyState, "copilot", model, bucketStart);
+    subtractTotals(bucket.totals, oldUsage);
+    addTotals(bucket.totals, newUsage);
+    touchedBuckets.add(bucketKey("copilot", model, bucketStart));
+    changed = true;
+  }
+
+  for (const id of newSeen) seenIds.add(id);
+  return { applied: true, changed };
+}
+
 // Migration helper: stream the bytes v1 already saw (0 -> prevSize), classify
 // whether the file contains old CLI spans v1 processed, and whether it also
 // contains v2-only chat records v1 skipped. Mixed files must be replayed, but
@@ -13841,12 +14458,18 @@ async function parseCopilotIncremental({
     seenIds.size > 0 || Object.keys(fileOffsetsRaw).length > 0;
   let usageClaimsComplete =
     copilotState.usageClaimsComplete === true || !hadPriorUsageHistory;
+  const files = Array.isArray(otelPaths) && otelPaths.length > 0
+    ? otelPaths
+    : resolveCopilotOtelPaths(env || process.env);
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
   const migrationSkipLineHashes = new Map();
+  let cursorVersion = COPILOT_PARSER_VERSION;
   // One-shot v1->v2 migration:
   // - pure v2-only files: clear offset and re-read all skipped Chat records
   // - pure v1 CLI files: preserve offset to avoid replaying history beyond seenIds
   // - mixed files: clear offset, but skip old v1 CLI lines by hash during replay
-  if (priorVersion < COPILOT_PARSER_VERSION) {
+  if (priorVersion < 2) {
     for (const filePath of Object.keys(fileOffsets)) {
       const prevSize = Number(fileOffsets[filePath]?.size) || 0;
       const scan = await scanCopilotV1MigrationFile(filePath, prevSize);
@@ -13859,13 +14482,33 @@ async function parseCopilotIncremental({
     }
   }
 
-  const files = Array.isArray(otelPaths) && otelPaths.length > 0
-    ? otelPaths
-    : resolveCopilotOtelPaths(env || process.env);
+  // v2 used spanContext as the fallback key for Chat-extension LogRecords.
+  // Those records can share one context across multiple model requests, so
+  // repair the already-counted file prefix before switching to response.id.
+  // If the prefix cannot be verified, leave the cursor at v2 and retry on the
+  // next sync rather than replaying it with a different deduplication scheme.
+  if (priorVersion === 2) {
+    const migration = await migrateCopilotChatLogRecordDedup({
+      files,
+      fileOffsets,
+      hourlyState,
+      touchedBuckets,
+      seenIds,
+    });
+    if (!migration.applied) {
+      return {
+        recordsProcessed: 0,
+        eventsAggregated: 0,
+        bucketsQueued: 0,
+        usageClaims: recentOtelUsageEvents,
+      };
+    }
+  }
+
   if (files.length === 0) {
     cursors.copilot = {
       ...copilotState,
-      version: COPILOT_PARSER_VERSION,
+      version: cursorVersion,
       seenIds: Array.from(seenIds),
       fileOffsets,
       recentUsageEvents: recentOtelUsageEvents,
@@ -13879,9 +14522,6 @@ async function parseCopilotIncremental({
       usageClaims: recentOtelUsageEvents,
     };
   }
-
-  const hourlyState = normalizeHourlyState(cursors?.hourly);
-  const touchedBuckets = new Set();
   const cb = typeof onProgress === "function" ? onProgress : null;
   let recordsProcessed = 0;
   let eventsAggregated = 0;
@@ -13941,117 +14581,39 @@ async function parseCopilotIncremental({
       // gen_ai.response.id is per-LLM-call unique.
       const dedupKey = getCopilotDedupKey(record, attrs);
       if (dedupKey && seenIds.has(dedupKey)) continue;
-      if (skipCliSpans && isCopilotV1ChatSpan(record)) {
+      const cliSpan = isCopilotV1ChatSpan(record);
+      if (skipCliSpans && cliSpan) {
         if (dedupKey) seenIds.add(dedupKey);
         continue;
       }
 
-      const inputRaw = toNonNegativeInt(attrs["gen_ai.usage.input_tokens"]);
-      const output = toNonNegativeInt(attrs["gen_ai.usage.output_tokens"]);
-      const cacheRead = toNonNegativeInt(
-        attrs["gen_ai.usage.cache_read.input_tokens"] ??
-          attrs["gen_ai.usage.cache_read_input_tokens"] ??
-          attrs["gen_ai.usage.cached_input_tokens"],
-      );
-      // Copilot CLI: cache_write.input_tokens; Copilot Chat extension: cache_creation.input_tokens
-      const cacheWrite = toNonNegativeInt(
-        attrs["gen_ai.usage.cache_write.input_tokens"] ??
-          attrs["gen_ai.usage.cache_creation.input_tokens"] ??
-          attrs["gen_ai.usage.cache_write_input_tokens"] ??
-          attrs["gen_ai.usage.cache_creation_input_tokens"],
-      );
-      // Copilot CLI: reasoning.output_tokens; Copilot Chat extension: reasoning_tokens
-      const reasoning = toNonNegativeInt(
-        attrs["gen_ai.usage.reasoning.output_tokens"] ??
-          attrs["gen_ai.usage.reasoning_tokens"] ??
-          attrs["gen_ai.usage.reasoning_output_tokens"],
-      );
-      const reasoningClamped = Math.min(reasoning, output);
-      const outputWithoutReasoning = Math.max(0, output - reasoningClamped);
-      const cliSpan = isCopilotV1ChatSpan(record);
-      // CLI input includes both cache reads and writes. Chat-extension
-      // LogRecords expose cache creation separately, so preserve their existing
-      // input-minus-read semantics.
-      const cacheReadClamped = Math.min(cacheRead, inputRaw);
-      const cacheWriteClamped = Math.min(
-        cacheWrite,
-        Math.max(0, inputRaw - cacheReadClamped),
-      );
-      const cacheWriteForAccounting = cliSpan ? cacheWriteClamped : cacheWrite;
-      const input = Math.max(
-        0,
-        inputRaw - cacheReadClamped - (cliSpan ? cacheWriteClamped : 0),
-      );
-      const totalInteresting =
-        input +
-        outputWithoutReasoning +
-        cacheReadClamped +
-        cacheWriteForAccounting +
-        reasoningClamped;
-      if (totalInteresting === 0) continue;
-
-      // CLI Span uses endTime/startTime; Chat extension LogRecord uses hrTime/hrTimeObserved.
-      const tsMs =
-        copilotOtelTimeToMs(record.endTime) ||
-        copilotOtelTimeToMs(record.startTime) ||
-        copilotOtelTimeToMs(record.hrTime) ||
-        copilotOtelTimeToMs(record.hrTimeObserved);
-      if (!tsMs) continue;
-      const tsIso = new Date(tsMs).toISOString();
-      const bucketStart = toUtcHalfHourStart(tsIso);
-      if (!bucketStart) continue;
-
-      const model =
-        normalizeCopilotAppModel(pickCopilotModel(attrs)) ||
-        COPILOT_APP_DEFAULT_MODEL;
-      const cliSessionId =
-        typeof attrs["gen_ai.conversation.id"] === "string"
-          ? attrs["gen_ai.conversation.id"].trim()
-          : "";
-      if (cliSpan && !cliSessionId) usageClaimsComplete = false;
-      const matchBase = {
-        sessionId: cliSessionId,
-        model,
-        output: outputWithoutReasoning,
-        cacheRead: cacheReadClamped,
-        cacheWrite: cacheWriteClamped,
-        reasoning: reasoningClamped,
-        tsMs,
-      };
+      const usage = extractCopilotOtelUsage(record);
+      if (!usage) continue;
+      if (usage.cliSpan && !usage.cliSessionId) usageClaimsComplete = false;
       const matchedStoreUsage =
-        isCopilotV1ChatSpan(record) &&
+        usage.cliSpan &&
         storeUsageMatcher.consume({
-          ...matchBase,
-          input,
+          ...usage.matchBase,
+          input: usage.delta.input_tokens,
         });
       if (matchedStoreUsage) {
         if (dedupKey) seenIds.add(dedupKey);
         continue;
       }
 
-      const delta = {
-        input_tokens: input,
-        cached_input_tokens: cacheReadClamped,
-        cache_creation_input_tokens: cacheWriteForAccounting,
-        output_tokens: outputWithoutReasoning,
-        reasoning_output_tokens: reasoningClamped,
-        total_tokens:
-          input +
-          outputWithoutReasoning +
-          cacheReadClamped +
-          cacheWriteForAccounting +
-          reasoningClamped,
-        conversation_count: 1,
-      };
-
-      const bucket = getHourlyBucket(hourlyState, "copilot", model, bucketStart);
-      addTotals(bucket.totals, delta);
-      touchedBuckets.add(bucketKey("copilot", model, bucketStart));
+      const bucket = getHourlyBucket(
+        hourlyState,
+        "copilot",
+        usage.model,
+        usage.bucketStart,
+      );
+      addTotals(bucket.totals, usage.delta);
+      touchedBuckets.add(bucketKey("copilot", usage.model, usage.bucketStart));
       eventsAggregated++;
-      if (cliSpan && cliSessionId) {
+      if (usage.cliSpan && usage.cliSessionId) {
         recentOtelUsageEvents.push({
-          ...matchBase,
-          input,
+          ...usage.matchBase,
+          input: usage.delta.input_tokens,
           firstSeenAtMs: claimNowMs,
         });
       }
@@ -14093,7 +14655,7 @@ async function parseCopilotIncremental({
   cursors.hourly = hourlyState;
   cursors.copilot = {
     ...copilotState,
-    version: COPILOT_PARSER_VERSION,
+    version: cursorVersion,
     seenIds: cappedSeen,
     fileOffsets,
     recentUsageEvents: retainedRecentOtelUsageEvents,
@@ -18281,6 +18843,7 @@ module.exports = {
   listGeminiSessionFiles,
   listOpencodeMessageFiles,
   readOpencodeDbMessages,
+  readOpencodeDbMessagesIncremental,
   readMimoDbMessages,
   readZcodeDbMessages,
   hasZcodeNativeUsageSchema,