@ipv9/tokentracker-cli 0.39.51 → 0.39.52

package/src/lib/rollout.js

@@ -4,7 +4,7 @@ const path = require("node:path");
 const readline = require("node:readline");
 
 const crypto = require("node:crypto");
-const { ensureDir } = require("./fs");
+const { ensureDir, writeFileAtomic } = require("./fs");
 const {
   readSqliteJsonRows,
   readSqliteJsonRowsWithStatus,
@@ -460,6 +460,7 @@ async function parseOpencodeIncremental({
   onProgress,
   source,
   publicRepoResolver,
+  nowMs = Date.now(),
 }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
@@ -555,6 +556,7 @@ async function parseOpencodeIncremental({
       projectTouchedBuckets,
       projectRef,
       projectKey,
+      nowMs: mtimeMs || nowMs,
     });
 
     cursors.files[key] = {
@@ -1178,6 +1180,7 @@ async function parseOpencodeMessageFile({
   projectTouchedBuckets,
   projectRef,
   projectKey,
+  nowMs = Date.now(),
 }) {
   const fallbackKey =
     typeof fallbackMessageKey === "string" && fallbackMessageKey.trim()
@@ -1227,9 +1230,10 @@ async function parseOpencodeMessageFile({
   if (!delta || isAllZeroUsage(delta)) {
     return { messageKey, lastTotals: currentTotals, eventsAggregated: 0, shouldUpdate: true };
   }
-  delta.conversation_count = 1;
+  delta.conversation_count = lastTotals ? 0 : 1;
 
-  const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+  const sourceTimestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+  const timestampMs = lastTotals ? nowMs : sourceTimestampMs;
   if (!timestampMs) {
     return {
       messageKey,
@@ -1437,6 +1441,7 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
             total_tokens: totals.total_tokens,
             billable_total_tokens: totals.billable_total_tokens ?? totals.total_tokens,
             conversation_count: totals.conversation_count,
+            ...queueCostFields(group.source, totals),
           }),
         );
         bucket.queuedKey = key;
@@ -1813,6 +1818,10 @@ function getHourlyBucket(state, source, model, hourStart) {
   let bucket = buckets[key];
   if (!bucket || typeof bucket !== "object") {
     bucket = { totals: initTotals(), queuedKey: null };
+    if (normalizedSource === "hermes") {
+      bucket.totals.actual_cost_usd = 0;
+      bucket.totals.actual_cost_complete = true;
+    }
     buckets[key] = bucket;
     return bucket;
   }
@@ -1820,6 +1829,13 @@ function getHourlyBucket(state, source, model, hourStart) {
   if (!bucket.totals || typeof bucket.totals !== "object") {
     bucket.totals = initTotals();
   }
+  if (normalizedSource === "hermes" && !Object.hasOwn(bucket.totals, "actual_cost_complete")) {
+    // Existing queues predate authoritative Hermes-cost support. Their past
+    // token rows retain estimation rather than being relabelled actual when a
+    // later delta lands in the same bucket.
+    bucket.totals.actual_cost_usd = 0;
+    bucket.totals.actual_cost_complete = false;
+  }
 
   if (bucket.queuedKey != null && typeof bucket.queuedKey !== "string") {
     bucket.queuedKey = null;
@@ -1898,9 +1914,26 @@ function totalsKey(totals) {
     totals.total_tokens || 0,
     totals.billable_total_tokens ?? totals.total_tokens ?? 0,
     totals.conversation_count || 0,
+    totals.actual_cost_complete === true ? "hermes-actual" : "",
+    totals.actual_cost_complete === true ? totals.actual_cost_usd || 0 : "",
   ].join("|");
 }
 
+function queueCostFields(source, totals) {
+  if (
+    source === "hermes" &&
+    totals?.actual_cost_complete === true &&
+    Number.isFinite(Number(totals.actual_cost_usd)) &&
+    Number(totals.actual_cost_usd) >= 0
+  ) {
+    return {
+      actual_cost_usd: Number(totals.actual_cost_usd),
+      cost_provenance: "hermes-actual",
+    };
+  }
+  return {};
+}
+
 function toUtcHalfHourStart(ts) {
   const dt = new Date(ts);
   if (!Number.isFinite(dt.getTime())) return null;
@@ -2617,6 +2650,7 @@ async function parseOpencodeDbIncremental({
   source,
   cursorKey,
   publicRepoResolver,
+  nowMs = Date.now(),
 }) {
   await ensureDir(path.dirname(queuePath));
   let messagesProcessed = 0;
@@ -2683,9 +2717,13 @@ async function parseOpencodeDbIncremental({
       }
       continue;
     }
-    delta.conversation_count = 1;
+    delta.conversation_count = lastTotals ? 0 : 1;
 
-    const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+    const sourceTimestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+    const rowUpdatedMs = coerceEpochMs(entry.timeUpdated || entry.time_updated);
+    const timestampMs = lastTotals
+      ? (rowUpdatedMs || nowMs)
+      : sourceTimestampMs;
     if (!timestampMs) {
       messagesProcessed += 1;
       continue;
@@ -3325,6 +3363,23 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
     "first_seen",
     "last_seen",
   ].every((column) => modelUsageColumns.has(column));
+  const hasModelUsageCosts = [
+    "estimated_cost_usd",
+    "actual_cost_usd",
+    "cost_status",
+    "cost_source",
+  ].every((column) => modelUsageColumns.has(column));
+  const modelUsageCostSelect = hasModelUsageCosts
+    ? `SUM(u.estimated_cost_usd) AS estimated_cost_usd,
+              SUM(u.actual_cost_usd) AS actual_cost_usd,
+              CASE WHEN SUM(CASE WHEN LOWER(COALESCE(u.cost_status, '')) = 'actual' THEN 0 ELSE 1 END) = 0
+                   THEN 'actual' ELSE NULL END AS cost_status,
+              CASE WHEN SUM(CASE WHEN LOWER(COALESCE(u.cost_status, '')) = 'actual' THEN 0 ELSE 1 END) = 0
+                   THEN MAX(u.cost_source) ELSE NULL END AS cost_source,`
+    : `NULL AS estimated_cost_usd,
+              NULL AS actual_cost_usd,
+              NULL AS cost_status,
+              NULL AS cost_source,`;
   const sql = hasModelUsage
     ? `WITH eligible_sessions AS (
          SELECT * FROM sessions WHERE ${eligible}
@@ -3338,6 +3393,7 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
               SUM(u.api_call_count) AS message_count,
               MIN(u.first_seen) AS first_seen,
               MAX(u.last_seen) AS last_seen,
+              ${modelUsageCostSelect}
               1 AS per_model
        FROM eligible_sessions s
        JOIN session_model_usage u ON u.session_id = s.id
@@ -3347,7 +3403,9 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
        SELECT s.id, s.model, s.model AS session_model, s.started_at, s.ended_at,
               s.input_tokens, s.output_tokens, s.cache_read_tokens,
               s.cache_write_tokens, s.reasoning_tokens, s.message_count,
-              NULL AS first_seen, NULL AS last_seen, 0 AS per_model
+              NULL AS first_seen, NULL AS last_seen,
+              NULL AS estimated_cost_usd, NULL AS actual_cost_usd,
+              NULL AS cost_status, NULL AS cost_source, 0 AS per_model
        FROM eligible_sessions s
        WHERE NOT EXISTS (
          SELECT 1 FROM session_model_usage u
@@ -3359,7 +3417,9 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
     : `SELECT id, model, model AS session_model, started_at, ended_at,
               input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
               reasoning_tokens, message_count, NULL AS first_seen,
-              NULL AS last_seen, 0 AS per_model
+              NULL AS last_seen, NULL AS estimated_cost_usd,
+              NULL AS actual_cost_usd, NULL AS cost_status,
+              NULL AS cost_source, 0 AS per_model
        FROM sessions
        WHERE ${eligible}
          AND (input_tokens > 0 OR output_tokens > 0 OR cache_read_tokens > 0 OR cache_write_tokens > 0 OR reasoning_tokens > 0)
@@ -3377,6 +3437,257 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
   }
 }
 
+const HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY = "hermesMixedModelReconciliationV1";
+const HERMES_TOKEN_TOTAL_FIELDS = [
+  "input_tokens",
+  "cached_input_tokens",
+  "cache_creation_input_tokens",
+  "output_tokens",
+  "reasoning_output_tokens",
+  "total_tokens",
+  "billable_total_tokens",
+];
+
+function hermesRowTotals(row) {
+  const inputTokens = toNonNegativeInt(row.input_tokens);
+  const outputTokens = toNonNegativeInt(row.output_tokens);
+  const cacheRead = toNonNegativeInt(row.cache_read_tokens);
+  const cacheWrite = toNonNegativeInt(row.cache_write_tokens);
+  const reasoning = toNonNegativeInt(row.reasoning_tokens);
+  return {
+    input_tokens: inputTokens,
+    cached_input_tokens: cacheRead,
+    cache_creation_input_tokens: cacheWrite,
+    output_tokens: outputTokens,
+    reasoning_output_tokens: reasoning,
+    total_tokens: inputTokens + outputTokens + cacheRead + cacheWrite + reasoning,
+    billable_total_tokens: inputTokens + outputTokens + cacheRead + cacheWrite + reasoning,
+    conversation_count: toNonNegativeInt(row.message_count),
+  };
+}
+
+function sameHermesTokenTotals(left, right) {
+  return HERMES_TOKEN_TOTAL_FIELDS.every(
+    (field) => Number(left?.[field] || 0) === Number(right?.[field] || 0),
+  );
+}
+
+function hermesBucketStartForRow(row, updatedAt) {
+  const perModel = Number(row.per_model) === 1;
+  const lastSeen = row.last_seen == null ? null : Number(row.last_seen);
+  const endedAt = row.ended_at == null ? null : Number(row.ended_at);
+  const startedAt = Number(row.started_at);
+  const epochSec = perModel && Number.isFinite(lastSeen) && lastSeen > 0
+    ? lastSeen
+    : endedAt ?? (Number.isFinite(startedAt) ? startedAt : Date.parse(updatedAt) / 1000);
+  if (!epochSec || !Number.isFinite(epochSec)) return null;
+  return toUtcHalfHourStart(new Date(epochSec * 1000).toISOString());
+}
+
+function prepareHermesProfileState(rows, previousState, updatedAt) {
+  const state = previousState && typeof previousState === "object" ? { ...previousState } : {};
+  const snapshots = {};
+  const unfinishedSessionIds = new Set();
+  let maxCompletedStartedAt = 0;
+  let oldestUnfinishedStartedAt = Infinity;
+
+  for (const row of rows) {
+    const totals = hermesRowTotals(row);
+    if (totals.total_tokens === 0) continue;
+    const perModel = Number(row.per_model) === 1;
+    const model = normalizeModelInput(row.model) || "hermes-agent";
+    const snapshotKey = perModel ? JSON.stringify([String(row.id || ""), model]) : row.id;
+    snapshots[snapshotKey] = {
+      in: totals.input_tokens,
+      out: totals.output_tokens,
+      cacheRead: totals.cached_input_tokens,
+      cacheWrite: totals.cache_creation_input_tokens,
+      reasoning: totals.reasoning_output_tokens,
+      message_count: totals.conversation_count,
+    };
+    const startedAt = Number(row.started_at);
+    const endedAt = row.ended_at == null ? null : Number(row.ended_at);
+    if (endedAt == null) {
+      if (row.id && Number.isFinite(startedAt)) {
+        unfinishedSessionIds.add(row.id);
+        oldestUnfinishedStartedAt = Math.min(oldestUnfinishedStartedAt, startedAt);
+      }
+    } else if (Number.isFinite(startedAt)) {
+      maxCompletedStartedAt = Math.max(maxCompletedStartedAt, startedAt);
+    }
+  }
+
+  const nextLastCompletedStartedAt = Number.isFinite(oldestUnfinishedStartedAt)
+    ? Math.min(maxCompletedStartedAt, oldestUnfinishedStartedAt)
+    : maxCompletedStartedAt;
+  return {
+    ...state,
+    lastStartedAt: nextLastCompletedStartedAt,
+    lastCompletedStartedAt: nextLastCompletedStartedAt,
+    unfinishedSessionIds: Array.from(unfinishedSessionIds),
+    snapshots,
+    modelUsageVersion: 1,
+    updatedAt,
+  };
+}
+
+async function appendHermesReconciliationRows({ queuePath, queueStatePath, canonicalRows, updatedAt }) {
+  if (typeof queueStatePath !== "string" || !queueStatePath) {
+    throw new Error("Hermes reconciliation requires queueStatePath to append corrected rows after the upload cursor");
+  }
+
+  let rawQueue = "";
+  try {
+    rawQueue = await fs.readFile(queuePath, "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+
+  let state = {};
+  try {
+    const rawState = await fs.readFile(queueStatePath, "utf8");
+    const parsed = JSON.parse(rawState);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) state = parsed;
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+
+  const offset = Number(state.offset);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > Buffer.byteLength(rawQueue, "utf8")) {
+    throw new Error("Hermes reconciliation requires a valid queue upload offset");
+  }
+
+  const append = `${canonicalRows.join("\n")}\n`;
+  await ensureDir(path.dirname(queuePath));
+  await fs.appendFile(queuePath, append, "utf8");
+  state.updatedAt = updatedAt;
+  state.note = "hermes_mixed_model_reconciliation_v1_appended_corrections";
+  try {
+    await writeFileAtomic(queueStatePath, JSON.stringify(state, null, 2) + "\n");
+  } catch (error) {
+    await fs.truncate(queuePath, Buffer.byteLength(rawQueue, "utf8"));
+    throw error;
+  }
+}
+
+// One-time, fail-closed correction for the v0.39.48 adoption gate. That gate
+// intentionally avoided replaying legacy aggregate snapshots, which preserved
+// the grand total but left already-counted mixed-model usage on sessions.model.
+// Rebuild only when the authoritative Hermes model rows have exactly the same
+// token total as the existing Hermes accumulator; otherwise leave data intact
+// and let the normal incremental path catch up before retrying next sync.
+async function reconcileHermesMixedModelUsage({ dbPaths, cursors, queuePath, queueStatePath, hermesState, updatedAt, sqliteOptions }) {
+  if (!cursors || typeof cursors !== "object") return { status: "invalid_cursor" };
+  const migrations = cursors.migrations && typeof cursors.migrations === "object" ? cursors.migrations : {};
+  const previous = migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY];
+  if (previous?.status === "applied") return previous;
+
+  const sources = [];
+  if (dbPaths.default) sources.push({ profileName: null, dbPath: dbPaths.default });
+  for (const [profileName, dbPath] of Object.entries(dbPaths.profiles || {})) {
+    sources.push({ profileName, dbPath });
+  }
+  if (sources.length === 0) return { status: "no_source" };
+
+  const rowsBySource = [];
+  for (const source of sources) {
+    const rows = readHermesSessions(source.dbPath, 0, [], sqliteOptions);
+    rowsBySource.push({ ...source, rows });
+  }
+  if (!rowsBySource.some(({ rows }) => rows.some((row) => Number(row.per_model) === 1))) {
+    cursors.migrations ||= {};
+    cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY] = {
+      status: "not_applicable",
+      updatedAt,
+    };
+    return cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY];
+  }
+
+  const hourlyState = normalizeHourlyState(cursors.hourly);
+  const existingTotals = initTotals();
+  for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+    if (parseBucketKey(key).source === "hermes") addTotals(existingTotals, bucket?.totals);
+  }
+
+  const canonicalBuckets = {};
+  const authoritativeTotals = initTotals();
+  for (const { rows } of rowsBySource) {
+    for (const row of rows) {
+      const totals = hermesRowTotals(row);
+      if (totals.total_tokens === 0) continue;
+      const hourStart = hermesBucketStartForRow(row, updatedAt);
+      if (!hourStart) continue;
+      const model = normalizeModelInput(row.model) || "hermes-agent";
+      const key = bucketKey("hermes", model, hourStart);
+      const bucket = canonicalBuckets[key] ||= { totals: initTotals(), queuedKey: null };
+      addTotals(bucket.totals, totals);
+      addTotals(authoritativeTotals, totals);
+    }
+  }
+
+  if (!sameHermesTokenTotals(existingTotals, authoritativeTotals)) {
+    cursors.migrations ||= {};
+    cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY] = {
+      status: "blocked_total_mismatch",
+      updatedAt,
+      existingTotalTokens: existingTotals.total_tokens,
+      authoritativeTotalTokens: authoritativeTotals.total_tokens,
+    };
+    return cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY];
+  }
+
+  for (const key of Object.keys(hourlyState.buckets || {})) {
+    if (parseBucketKey(key).source === "hermes") delete hourlyState.buckets[key];
+  }
+  for (const key of Object.keys(hourlyState.groupQueued || {})) {
+    if (key.startsWith("hermes|")) delete hourlyState.groupQueued[key];
+  }
+  const canonicalRows = [];
+  for (const [key, bucket] of Object.entries(canonicalBuckets)) {
+    const { model, hourStart } = parseBucketKey(key);
+    bucket.queuedKey = totalsKey(bucket.totals);
+    hourlyState.buckets[key] = bucket;
+    canonicalRows.push(JSON.stringify({
+      source: "hermes",
+      model,
+      hour_start: hourStart,
+      ...bucket.totals,
+    }));
+  }
+
+  await appendHermesReconciliationRows({
+    queuePath,
+    queueStatePath,
+    canonicalRows,
+    updatedAt,
+  });
+
+  const nextHermesState = hermesState && typeof hermesState === "object" ? hermesState : {};
+  for (const { profileName, rows } of rowsBySource) {
+    if (profileName == null) {
+      Object.assign(nextHermesState, prepareHermesProfileState(rows, nextHermesState, updatedAt));
+    } else {
+      nextHermesState.profiles = nextHermesState.profiles && typeof nextHermesState.profiles === "object"
+        ? nextHermesState.profiles
+        : {};
+      nextHermesState.profiles[profileName] = prepareHermesProfileState(
+        rows,
+        nextHermesState.profiles[profileName],
+        updatedAt,
+      );
+    }
+  }
+  cursors.hourly = hourlyState;
+  cursors.migrations ||= {};
+  cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY] = {
+    status: "applied",
+    appliedAt: updatedAt,
+    totalTokens: authoritativeTotals.total_tokens,
+    bucketsRebuilt: canonicalRows.length,
+  };
+  return cursors.migrations[HERMES_MIXED_MODEL_RECONCILIATION_MIGRATION_KEY];
+}
+
 function hasLegacyHermesDefaultState(hermesState) {
   return (
     typeof hermesState.lastStartedAt === "number" ||
@@ -3385,7 +3696,16 @@ function hasLegacyHermesDefaultState(hermesState) {
   );
 }
 
-async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath, onProgress, sqliteOptions } = {}) {
+async function parseHermesIncremental({
+  hermesPath,
+  dbPath,
+  cursors,
+  queuePath,
+  queueStatePath,
+  onProgress,
+  sqliteOptions,
+  reconcileHistorical = false,
+} = {}) {
   await ensureDir(path.dirname(queuePath));
   const hermesState = cursors.hermes && typeof cursors.hermes === "object" ? cursors.hermes : {};
 
@@ -3398,6 +3718,27 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
   const hourlyState = normalizeHourlyState(cursors?.hourly);
   const cb = typeof onProgress === "function" ? onProgress : null;
   const updatedAt = new Date().toISOString();
+  if (reconcileHistorical) {
+    const reconciliation = await reconcileHermesMixedModelUsage({
+      dbPaths,
+      cursors,
+      queuePath,
+      queueStatePath,
+      hermesState,
+      updatedAt,
+      sqliteOptions,
+    });
+    if (reconciliation?.status === "applied") {
+      hermesState.updatedAt = updatedAt;
+      cursors.hermes = hermesState;
+      return {
+        recordsProcessed: 0,
+        eventsAggregated: 0,
+        bucketsQueued: 0,
+        reconciliation,
+      };
+    }
+  }
   let recordsProcessed = 0;
   let eventsAggregated = 0;
   const touchedBuckets = new Set();
@@ -3451,6 +3792,11 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
       const perModel = Number(row.per_model) === 1;
       const model = normalizeModelInput(row.model) || "hermes-agent";
       const snapshotKey = perModel ? JSON.stringify([String(row.id || ""), model]) : row.id;
+      const actualCost = Number(row.actual_cost_usd);
+      const hasAuthoritativeCost =
+        String(row.cost_status || "").toLowerCase() === "actual" &&
+        Number.isFinite(actualCost) &&
+        actualCost >= 0;
       const currentSnapshot = {
         in: inputTokens,
         out: outputTokens,
@@ -3458,6 +3804,7 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
         cacheWrite,
         reasoning,
         message_count: messageCount,
+        actual_cost_usd: hasAuthoritativeCost ? actualCost : null,
       };
       // Save current snapshot for next sync. Mixed-model sessions are keyed by
       // both session and model so later growth is attributed independently.
@@ -3481,12 +3828,19 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
       const prev = adoptingPerModelState && perModel && legacySessionSnapshot
         ? currentSnapshot
         : prevSnapshots[snapshotKey];
+      const previousActualCost = Number(prev?.actual_cost_usd);
+      const hasPreviousActualCost =
+        typeof prev?.actual_cost_usd === "number" &&
+        Number.isFinite(previousActualCost) &&
+        previousActualCost >= 0;
+      const isActualCostTransition = hasAuthoritativeCost && Boolean(prev) && !hasPreviousActualCost;
       let dInput = inputTokens;
       let dOutput = outputTokens;
       let dCacheRead = cacheRead;
       let dCacheWrite = cacheWrite;
       let dReasoning = reasoning;
       let dMessageCount = messageCount;
+      let dActualCost = hasAuthoritativeCost ? actualCost : 0;
       if (prev) {
         dInput = Math.max(0, inputTokens - (prev.in || 0));
         dOutput = Math.max(0, outputTokens - (prev.out || 0));
@@ -3494,9 +3848,13 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
         dCacheWrite = Math.max(0, cacheWrite - (prev.cacheWrite || 0));
         dReasoning = Math.max(0, reasoning - (prev.reasoning || 0));
         dMessageCount = Math.max(0, messageCount - (prev.message_count || 0));
+        dActualCost = hasAuthoritativeCost
+          ? (hasPreviousActualCost ? Math.max(0, actualCost - previousActualCost) : 0)
+          : 0;
       }
-      // Skip if delta is zero (session unchanged since last sync)
-      if (dInput === 0 && dOutput === 0 && dCacheRead === 0 && dCacheWrite === 0 && dReasoning === 0) continue;
+      const hasTokenDelta =
+        dInput > 0 || dOutput > 0 || dCacheRead > 0 || dCacheWrite > 0 || dReasoning > 0;
+      const hasActualCostDelta = hasAuthoritativeCost && hasPreviousActualCost && dActualCost > 0;
 
       // Per-model rows carry the authoritative last API-call timestamp. Older
       // Hermes schemas fall back to the session-level start/end policy.
@@ -3506,8 +3864,18 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
         : endedAt ?? (prev ? Date.parse(updatedAt) / 1000 : startedAt);
       if (!epochSec || !Number.isFinite(epochSec)) continue;
       const tsIso = new Date(epochSec * 1000).toISOString();
-      const bucketStart = toUtcHalfHourStart(tsIso);
-      if (!bucketStart) continue;
+      const observedBucketStart = toUtcHalfHourStart(tsIso);
+      if (!observedBucketStart) continue;
+      currentSnapshot.bucket_start = observedBucketStart;
+      // A status transition establishes a cost baseline but cannot safely
+      // relabel already-ingested token rows. A pure later cost update belongs
+      // with the prior observed bucket; otherwise it would create a zero-token
+      // current bucket that the dashboard cannot attribute to the usage.
+      if (!hasTokenDelta && !hasActualCostDelta) continue;
+      const bucketStart =
+        !hasTokenDelta && hasActualCostDelta && typeof prev?.bucket_start === "string"
+          ? prev.bucket_start
+          : observedBucketStart;
 
       const delta = {
         input_tokens: dInput,
@@ -3521,6 +3889,11 @@ async function parseHermesIncremental({ hermesPath, dbPath, cursors, queuePath,
 
       const bucket = getHourlyBucket(hourlyState, "hermes", model, bucketStart);
       addTotals(bucket.totals, delta);
+      if (hasAuthoritativeCost && !isActualCostTransition && bucket.totals.actual_cost_complete === true) {
+        bucket.totals.actual_cost_usd += dActualCost;
+      } else if (!hasAuthoritativeCost || isActualCostTransition) {
+        bucket.totals.actual_cost_complete = false;
+      }
       touchedBuckets.add(bucketKey("hermes", model, bucketStart));
       eventsAggregated++;
 
@@ -4027,7 +4400,15 @@ function kiroWatermarkFloor(cell, field, fallback) {
   return value;
 }
 
-async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onProgress, env, sqliteOptions } = {}) {
+async function parseKiroCliIncremental({
+  sessionFiles,
+  cursors,
+  queuePath,
+  onProgress,
+  env,
+  sqliteOptions,
+  nowMs = Date.now(),
+} = {}) {
   await ensureDir(path.dirname(queuePath));
   const kiroCliState =
     cursors.kiroCli && typeof cursors.kiroCli === "object" ? cursors.kiroCli : {};
@@ -4396,7 +4777,14 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
 
     if (!dInput && !dOutput && !dConv) continue;
 
-    const bucket = getHourlyBucket(hourlyState, "kiro", want.model, want.bucketStart);
+    // A mutable request has no authoritative mutation timestamp in Kiro's
+    // SQLite schema. Its initial contribution belongs to request start; later
+    // positive growth is observed now and must not be backdated across midnight.
+    const bucketStart = prior && (dInput > 0 || dOutput > 0)
+      ? toUtcHalfHourStart(new Date(nowMs).toISOString())
+      : want.bucketStart;
+    if (!bucketStart) continue;
+    const bucket = getHourlyBucket(hourlyState, "kiro", want.model, bucketStart);
     addTotals(bucket.totals, {
       input_tokens: dInput,
       cached_input_tokens: 0,
@@ -4406,7 +4794,7 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
       total_tokens: dInput + dOutput,
       conversation_count: dConv,
     });
-    touchedBuckets.add(bucketKey("kiro", want.model, want.bucketStart));
+    touchedBuckets.add(bucketKey("kiro", want.model, bucketStart));
     eventsAggregated += 1;
   }
 
@@ -7534,6 +7922,7 @@ async function parseCraftIncremental({
   onProgress,
   env,
   defaultModel,
+  nowMs = Date.now(),
 } = {}) {
   await ensureDir(path.dirname(queuePath));
   const craftState = cursors.craft && typeof cursors.craft === "object" ? cursors.craft : {};
@@ -7644,7 +8033,15 @@ async function parseCraftIncremental({
     const dCacheWrite = Math.max(0, totalCacheWrite - prev.cacheWrite);
     const dTotal = Math.max(0, totalReported - prev.total);
 
-    const nowMs = Date.now();
+    const activityCandidates = [header.lastMessageAt, header.lastUsedAt];
+    let activityMs = null;
+    for (const cand of activityCandidates) {
+      if (Number.isFinite(Number(cand)) && Number(cand) > 0) {
+        activityMs = Number(cand);
+        break;
+      }
+    }
+    const observedNowMs = nowMs;
 
     if (dInput === 0 && dOutput === 0 && dCacheRead === 0 && dCacheWrite === 0) {
       // No new usage since last parse — but still update the snapshot in case
@@ -7656,21 +8053,25 @@ async function parseCraftIncremental({
         cacheRead: totalCacheRead,
         cacheWrite: totalCacheWrite,
         total: totalReported,
-        lastSeenAt: nowMs,
+        activityMs,
+        lastSeenAt: observedNowMs,
       };
       continue;
     }
 
-    // Bucket on lastMessageAt (preferred) or createdAt — both ms epoch.
-    let tsMs = null;
-    const tsCandidates = [header.lastMessageAt, header.lastUsedAt, header.createdAt];
-    for (const cand of tsCandidates) {
-      if (Number.isFinite(Number(cand)) && Number(cand) > 0) {
-        tsMs = Number(cand);
-        break;
-      }
+    // Initial totals use the source activity timestamp (then createdAt/file
+    // mtime). Cumulative growth must not be pinned to an old createdAt: use a
+    // newer trustworthy activity time when present, otherwise this sync's
+    // observation time.
+    let firstSeenTimestampMs = activityMs;
+    if (firstSeenTimestampMs == null && Number.isFinite(Number(header.createdAt)) && Number(header.createdAt) > 0) {
+      firstSeenTimestampMs = Number(header.createdAt);
     }
-    if (tsMs == null) tsMs = stat.mtimeMs;
+    if (firstSeenTimestampMs == null) firstSeenTimestampMs = stat.mtimeMs;
+    const growthHasNewActivity = activityMs != null && activityMs > Number(prev.activityMs || 0);
+    const tsMs = prev.total > 0
+      ? (growthHasNewActivity ? activityMs : observedNowMs)
+      : firstSeenTimestampMs;
     if (!Number.isFinite(tsMs) || tsMs <= 0) continue;
 
     const tsIso = new Date(tsMs).toISOString();
@@ -7704,7 +8105,8 @@ async function parseCraftIncremental({
       cacheRead: totalCacheRead,
       cacheWrite: totalCacheWrite,
       total: totalReported,
-      lastSeenAt: nowMs,
+      activityMs,
+      lastSeenAt: observedNowMs,
     };
 
     if (cb) {