codetime-cli 0.5.0 → 0.7.0

package/bin/codetime.mjs

@@ -160,6 +160,7 @@ import { fileURLToPath } from "node:url";
 // ../shared/src/index.ts
 import { createHash } from "node:crypto";
 var AGENT_TIME_SCHEMA_VERSION = "2026-04-29";
+var AGENT_ROLLUP_SCHEMA_VERSION = 3;
 var TELEMETRY_EVENT_TYPES = [
   "session.started",
   "session.ended",
@@ -973,11 +974,12 @@ import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import path2 from "node:path";
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.5.0" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.7.0" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
 var ROLLUP_BUCKET_MS = 15 * 60 * 1e3;
+var TURN_GAP_CLAMP_MS = 5 * 60 * 1e3;
 var DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS = 60;
 
 // src/lib/fields.ts
@@ -1930,16 +1932,29 @@ function claudeUsageFromMessage(message) {
   const outputTokens = numberField(usage, "output_tokens") || 0;
   const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
   const totalInputTokens = inputTokens + cachedInputTokens;
+  const cacheCreationSplit = claudeCacheCreationSplit(usage);
   return {
     tokensInput: totalInputTokens || void 0,
     tokensCachedInput: cachedInputTokens || void 0,
     tokensCacheCreationInput: cacheCreationInputTokens || void 0,
+    tokensCacheCreation5mInput: cacheCreationSplit?.fiveMinute,
+    tokensCacheCreation1hInput: cacheCreationSplit?.oneHour,
     tokensCacheReadInput: cacheReadInputTokens || void 0,
     tokensOutput: outputTokens || void 0,
     tokensTotal: totalInputTokens + outputTokens || void 0,
     modelCalls: 1
   };
 }
+function claudeCacheCreationSplit(usage) {
+  const breakdown = usage.cache_creation;
+  if (!isPlainObject(breakdown)) {
+    return void 0;
+  }
+  return {
+    fiveMinute: numberField(breakdown, "ephemeral_5m_input_tokens") || 0,
+    oneHour: numberField(breakdown, "ephemeral_1h_input_tokens") || 0
+  };
+}
 function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
   const usage = objectField(toolResult, "usage");
   const inputTokens = numberField(usage, "input_tokens") || 0;
@@ -1948,6 +1963,7 @@ function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
   const outputTokens = numberField(usage, "output_tokens") || 0;
   const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
   const totalInputTokens = inputTokens + cachedInputTokens;
+  const cacheCreationSplit = claudeCacheCreationSplit(usage);
   const durationMs = numberField(toolResult, "totalDurationMs") || fallbackDurationMs;
   return {
     durationMs,
@@ -1956,6 +1972,8 @@ function claudeSubagentMetrics(toolResult, fallbackDurationMs) {
     tokensInput: totalInputTokens || void 0,
     tokensCachedInput: cachedInputTokens || void 0,
     tokensCacheCreationInput: cacheCreationInputTokens || void 0,
+    tokensCacheCreation5mInput: cacheCreationSplit?.fiveMinute,
+    tokensCacheCreation1hInput: cacheCreationSplit?.oneHour,
     tokensCacheReadInput: cacheReadInputTokens || void 0,
     tokensOutput: outputTokens || void 0,
     tokensTotal: numberField(toolResult, "totalTokens") || totalInputTokens + outputTokens || void 0
@@ -2243,6 +2261,23 @@ async function parseCodexSessionFile(filePath, options) {
   let sessionMetaLocked = false;
   let lastTokenUsageKey;
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  const turnLastEventAt = /* @__PURE__ */ new Map();
+  const turnStartedAt = /* @__PURE__ */ new Map();
+  const closedTurnIds = /* @__PURE__ */ new Set();
+  const pushEvent = (event, refs) => {
+    const turnId = event.turnId;
+    if (turnId && event.ts) {
+      if (!turnStartedAt.has(turnId)) {
+        turnStartedAt.set(turnId, event.ts);
+      }
+      const prev = turnLastEventAt.get(turnId);
+      if (!prev || event.ts > prev) {
+        turnLastEventAt.set(turnId, event.ts);
+      }
+    }
+    events.push(withBackfillRefs(event, refs));
+  };
+  const turnCloseTs = (turnId) => turnLastEventAt.get(turnId) || turnStartedAt.get(turnId) || (/* @__PURE__ */ new Date()).toISOString();
   for (const [index, line] of lines.entries()) {
     const lineNumber = index + 1;
     const raw = parseJsonLine(line);
@@ -2299,23 +2334,23 @@ async function parseCodexSessionFile(filePath, options) {
         const eventModel = parsedModel || model || "gpt-5";
         const headlessTs = headlessCodexTimestamp(raw) || ts;
         if (!sessionStartEmitted) {
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts: headlessTs,
             type: "session.started",
             sessionId,
             model: eventModel,
             confidence: "derived"
-          }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "session", options }));
+          }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "session", options });
           sessionStartEmitted = true;
         }
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts: headlessTs,
           type: "model.usage",
           sessionId,
           model: eventModel,
           confidence: "partial",
           metrics: usage
-        }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "headless", options }));
+        }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "headless", options });
       }
       continue;
     }
@@ -2325,7 +2360,7 @@ async function parseCodexSessionFile(filePath, options) {
     switch (payloadType) {
       case "task_started": {
         currentTurnId = stringField(payload, "turn_id") || currentTurnId;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "turn.started",
           sessionId,
@@ -2334,14 +2369,15 @@ async function parseCodexSessionFile(filePath, options) {
           project,
           model,
           confidence: "exact"
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "user_message": {
         const message = stringField(payload, "message") || "";
-        if (currentTurnId && currentTurnId !== turnIdAtLastUserMessage && lastTurnIdForComplete) {
-          events.push(withBackfillRefs(baseCodexEvent({
-            ts,
+        if (currentTurnId && currentTurnId !== turnIdAtLastUserMessage && lastTurnIdForComplete && !closedTurnIds.has(lastTurnIdForComplete)) {
+          closedTurnIds.add(lastTurnIdForComplete);
+          pushEvent(baseCodexEvent({
+            ts: turnCloseTs(lastTurnIdForComplete),
             type: "turn.completed",
             sessionId,
             turnId: lastTurnIdForComplete,
@@ -2349,14 +2385,14 @@ async function parseCodexSessionFile(filePath, options) {
             project,
             model,
             confidence: "derived"
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         if (!currentTurnId || currentTurnId === turnIdAtLastUserMessage) {
           currentTurnId = `turn_${createStableHash([sessionId, lineNumber, ts]).slice(0, 24)}`;
         }
         lastTurnIdForComplete = currentTurnId;
         turnIdAtLastUserMessage = currentTurnId;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "prompt.submitted",
           sessionId,
@@ -2372,7 +2408,7 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             promptHash: message ? `sha256:${createStableHash(message)}` : void 0
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "token_count": {
@@ -2394,7 +2430,7 @@ async function parseCodexSessionFile(filePath, options) {
             break;
           }
           lastTokenUsageKey = usageKey;
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts,
             type: "model.usage",
             sessionId,
@@ -2407,13 +2443,13 @@ async function parseCodexSessionFile(filePath, options) {
             model: rewriteCodexModelForTier(model, serviceTier),
             confidence: "partial",
             metrics: usage
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         break;
       }
       case "agent_message": {
         const message = stringField(payload, "message") || "";
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "agent.operation",
           operation: "agent message",
@@ -2426,7 +2462,7 @@ async function parseCodexSessionFile(filePath, options) {
           metrics: {
             agentMessageChars: message.length
           }
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "function_call":
@@ -2438,7 +2474,7 @@ async function parseCodexSessionFile(filePath, options) {
         if (callId) {
           pendingToolCalls.set(callId, { tool, startedAt: ts, turnId: currentTurnId });
         }
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "tool.started",
           operation: `${tool} started`,
@@ -2455,9 +2491,9 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: callId
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         if (fileActivities.length > 0) {
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts,
             type: eventTypeFromFileActivities(fileActivities),
             operation: `${tool} file activity`,
@@ -2473,7 +2509,7 @@ async function parseCodexSessionFile(filePath, options) {
             refs: stringRefs({
               sourceId: callId
             })
-          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+          }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         }
         break;
       }
@@ -2485,7 +2521,7 @@ async function parseCodexSessionFile(filePath, options) {
           pendingToolCalls.delete(callId);
         }
         const durationMs = pending ? durationMsBetween(pending.startedAt, ts) : void 0;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "tool.completed",
           operation: pending ? `${pending.tool} completed` : "tool completed",
@@ -2503,13 +2539,13 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: callId
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "exec_command_end": {
         const durationMs = durationObjectToMs(objectField(payload, "duration"));
         const success = Number(payload.exit_code) === 0;
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: success ? "command.completed" : "command.failed",
           operation: "command completed",
@@ -2530,7 +2566,7 @@ async function parseCodexSessionFile(filePath, options) {
             sourceId: stringField(payload, "call_id"),
             commandHash: createStableHash(payload.command)
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "patch_apply_end": {
@@ -2540,7 +2576,7 @@ async function parseCodexSessionFile(filePath, options) {
           cwd,
           displayFilePath2
         );
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "file.changed",
           operation: "apply patch",
@@ -2557,15 +2593,19 @@ async function parseCodexSessionFile(filePath, options) {
           refs: stringRefs({
             sourceId: stringField(payload, "call_id")
           })
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
       case "task_complete": {
-        events.push(withBackfillRefs(baseCodexEvent({
+        const completedTurnId = stringField(payload, "turn_id") || currentTurnId;
+        if (completedTurnId) {
+          closedTurnIds.add(completedTurnId);
+        }
+        pushEvent(baseCodexEvent({
           ts,
           type: "turn.completed",
           sessionId,
-          turnId: stringField(payload, "turn_id") || currentTurnId,
+          turnId: completedTurnId,
           cwd,
           project,
           model,
@@ -2573,15 +2613,15 @@ async function parseCodexSessionFile(filePath, options) {
           metrics: {
             durationMs: numberField(payload, "duration_ms")
           }
-        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
+        }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options });
         break;
       }
     }
   }
-  if (lastTurnIdForComplete) {
-    const lastTs = events.length > 0 ? events.at(-1).ts : (/* @__PURE__ */ new Date()).toISOString();
-    events.push(withBackfillRefs(baseCodexEvent({
-      ts: lastTs,
+  if (lastTurnIdForComplete && !closedTurnIds.has(lastTurnIdForComplete)) {
+    closedTurnIds.add(lastTurnIdForComplete);
+    pushEvent(baseCodexEvent({
+      ts: turnCloseTs(lastTurnIdForComplete),
       type: "turn.completed",
       sessionId,
       turnId: lastTurnIdForComplete,
@@ -2589,7 +2629,7 @@ async function parseCodexSessionFile(filePath, options) {
       project,
       model,
       confidence: "derived"
-    }), { filePath, sourcePathHash, lineNumber: lines.length, topType: "event_msg", payloadType: "turn.completed", options }));
+    }), { filePath, sourcePathHash, lineNumber: lines.length, topType: "event_msg", payloadType: "turn.completed", options });
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
@@ -2628,10 +2668,11 @@ function headlessCodexUsage(raw) {
   if (input === 0 && cached === 0 && output === 0 && reasoning === 0 && total === 0) {
     return;
   }
+  const billableOutput = output + reasoning;
   return {
     tokensInput: input || void 0,
     tokensCachedInput: cached || void 0,
-    tokensOutput: output || void 0,
+    tokensOutput: billableOutput || void 0,
     tokensReasoningOutput: reasoning || void 0,
     tokensTotal: total,
     modelCalls: 1
@@ -2992,9 +3033,10 @@ async function parseGeminiSessionFile(filePath, options) {
   let lastTs = usages[0].ts;
   for (const [index, usage] of usages.entries()) {
     lastTs = usage.ts;
+    const billableOutput = usage.tokensOutput + usage.tokensReasoning;
     const metrics = {
       tokensInput: usage.tokensInput || void 0,
-      tokensOutput: usage.tokensOutput || void 0,
+      tokensOutput: billableOutput || void 0,
       tokensCachedInput: usage.tokensCacheRead || void 0,
       tokensCacheReadInput: usage.tokensCacheRead || void 0,
       tokensReasoningOutput: usage.tokensReasoning || void 0,
@@ -3439,13 +3481,14 @@ function opencodeUsageFromInfo(info) {
   const cacheRead = Math.max(0, numberField(cache, "read") || 0);
   const cacheWrite = Math.max(0, numberField(cache, "write") || 0);
   const totalInput = input + cacheRead + cacheWrite;
-  const total = Math.max(0, numberField(tokensObj, "total") || totalInput + output + reasoning);
+  const billableOutput = output + reasoning;
+  const total = Math.max(0, numberField(tokensObj, "total") || totalInput + billableOutput);
   if (total <= 0) {
     return void 0;
   }
   return {
     tokensInput: totalInput || void 0,
-    tokensOutput: output || void 0,
+    tokensOutput: billableOutput || void 0,
     tokensReasoningOutput: reasoning || void 0,
     tokensCachedInput: cacheRead + cacheWrite || void 0,
     tokensCacheReadInput: cacheRead || void 0,
@@ -4110,9 +4153,11 @@ function buildSessionRollup(rollupKey, events) {
   const lastEventAt = ordered.at(-1)?.ts || startedAt;
   const timeBuckets = /* @__PURE__ */ new Map();
   const modelRollups = /* @__PURE__ */ new Map();
+  const modelBuckets = /* @__PURE__ */ new Map();
   const toolRollups = /* @__PURE__ */ new Map();
   const fileRollups = /* @__PURE__ */ new Map();
   const turnRollups = /* @__PURE__ */ new Map();
+  const turnEventTimes = /* @__PURE__ */ new Map();
   let promptCount = 0;
   let turnCount = 0;
   let toolCallCount = 0;
@@ -4130,6 +4175,8 @@ function buildSessionRollup(rollupKey, events) {
     const eventInputTokens = Math.max(0, event.metrics?.tokensInput || 0);
     const eventCachedInputTokens = Math.max(0, event.metrics?.tokensCachedInput || 0);
     const eventCacheCreationInputTokens = Math.max(0, event.metrics?.tokensCacheCreationInput || 0);
+    const eventCacheCreation5mInputTokens = Math.max(0, event.metrics?.tokensCacheCreation5mInput || 0);
+    const eventCacheCreation1hInputTokens = Math.max(0, event.metrics?.tokensCacheCreation1hInput || 0);
     const eventCacheReadInputTokens = Math.max(0, event.metrics?.tokensCacheReadInput || 0);
     const eventOutputTokens = Math.max(0, event.metrics?.tokensOutput || 0);
     const eventReasoningOutputTokens = Math.max(0, event.metrics?.tokensReasoningOutput || 0);
@@ -4210,6 +4257,12 @@ function buildSessionRollup(rollupKey, events) {
       turnRollup.outputTokens += eventOutputTokens;
       turnRollup.totalTokens += eventTotalTokens;
       turnRollups.set(event.turnId, turnRollup);
+      const times = turnEventTimes.get(event.turnId);
+      if (times) {
+        times.push(event.ts);
+      } else {
+        turnEventTimes.set(event.turnId, [event.ts]);
+      }
     }
     inputTokens += eventInputTokens;
     cachedInputTokens += eventCachedInputTokens;
@@ -4244,6 +4297,8 @@ function buildSessionRollup(rollupKey, events) {
         inputTokens: 0,
         cachedInputTokens: 0,
         cacheCreationInputTokens: 0,
+        cacheCreation5mInputTokens: 0,
+        cacheCreation1hInputTokens: 0,
         cacheReadInputTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
@@ -4254,12 +4309,40 @@ function buildSessionRollup(rollupKey, events) {
       modelRollup.inputTokens += eventInputTokens;
       modelRollup.cachedInputTokens += eventCachedInputTokens;
       modelRollup.cacheCreationInputTokens += eventCacheCreationInputTokens;
+      modelRollup.cacheCreation5mInputTokens += eventCacheCreation5mInputTokens;
+      modelRollup.cacheCreation1hInputTokens += eventCacheCreation1hInputTokens;
       modelRollup.cacheReadInputTokens += eventCacheReadInputTokens;
       modelRollup.outputTokens += eventOutputTokens;
       modelRollup.reasoningOutputTokens += eventReasoningOutputTokens;
       modelRollup.totalTokens += eventTotalTokens;
       modelRollup.estimatedCostUsd += eventCostUsd;
       modelRollups.set(modelKey, modelRollup);
+      const modelBucketKey = `${bucketTs}\0${modelKey}`;
+      const modelBucket = modelBuckets.get(modelBucketKey) || {
+        ts: bucketTs,
+        model: modelKey,
+        callCount: 0,
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheCreation5mInputTokens: 0,
+        cacheCreation1hInputTokens: 0,
+        cacheReadInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0
+      };
+      modelBucket.callCount += 1;
+      modelBucket.inputTokens += eventInputTokens;
+      modelBucket.cachedInputTokens += eventCachedInputTokens;
+      modelBucket.cacheCreationInputTokens += eventCacheCreationInputTokens;
+      modelBucket.cacheCreation5mInputTokens += eventCacheCreation5mInputTokens;
+      modelBucket.cacheCreation1hInputTokens += eventCacheCreation1hInputTokens;
+      modelBucket.cacheReadInputTokens += eventCacheReadInputTokens;
+      modelBucket.outputTokens += eventOutputTokens;
+      modelBucket.reasoningOutputTokens += eventReasoningOutputTokens;
+      modelBucket.totalTokens += eventTotalTokens;
+      modelBuckets.set(modelBucketKey, modelBucket);
     }
     if (event.type === "tool.started") {
       bucket.toolCalls += 1;
@@ -4327,6 +4410,13 @@ function buildSessionRollup(rollupKey, events) {
   const baseRollup = {
     rollupKey,
     payloadHash: "",
+    // v3 schema: v2 (gap-clamped turn durations + billable-output token
+    // convention) plus per-model cache-creation TTL split and modelBuckets. Set on
+    // baseRollup (not after) so it participates in payloadHash: every historical
+    // rollup's hash changes, and a re-backfill (uploaded with replace=true by
+    // default) cleanly refreshes all data onto the new convention. This
+    // full-refresh churn is intentional.
+    schemaVersion: AGENT_ROLLUP_SCHEMA_VERSION,
     source: first.source,
     project,
     sessionId,
@@ -4350,11 +4440,16 @@ function buildSessionRollup(rollupKey, events) {
     durationMs: Math.max(0, Date.parse(lastEventAt) - Date.parse(startedAt)),
     timeBuckets: [...timeBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts)),
     modelRollups: [...modelRollups.values()].sort((a, b) => b.callCount - a.callCount || a.model.localeCompare(b.model)),
+    // Sorted ts ascending, then model lexicographically (wire contract).
+    modelBuckets: [...modelBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts) || a.model.localeCompare(b.model)),
     toolRollups: [...toolRollups.values()].sort((a, b) => b.callCount - a.callCount || a.tool.localeCompare(b.tool)),
     fileRollups: [...fileRollups.values()].sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.displayPath.localeCompare(b.displayPath)),
     turnRollups: [...turnRollups.values()].map((rollup) => ({
       ...rollup,
-      durationMs: Math.max(0, Date.parse(rollup.lastEventAt) - Date.parse(rollup.startedAt))
+      // Gap-clamped active duration: startedAt/lastEventAt/completedAt keep their
+      // real timestamps, but durationMs only counts active intervals so lazy
+      // completed_at timestamps and long in-turn silences don't inflate it.
+      durationMs: gapClampedTurnDurationMs(rollup, turnEventTimes.get(rollup.turnId) || [])
     })).sort((a, b) => a.startedAt.localeCompare(b.startedAt))
   };
   return {
@@ -4362,6 +4457,22 @@ function buildSessionRollup(rollupKey, events) {
     payloadHash: createPayloadHash(baseRollup)
   };
 }
+function gapClampedTurnDurationMs(rollup, eventTimes) {
+  const millis = [
+    rollup.promptSubmittedAt,
+    rollup.startedAt,
+    ...eventTimes
+  ].map((ts) => ts ? Date.parse(ts) : Number.NaN).filter((ms) => Number.isFinite(ms));
+  const unique = [...new Set(millis)].sort((a, b) => a - b);
+  if (unique.length < 2) {
+    return 0;
+  }
+  let duration = 0;
+  for (let i = 1; i < unique.length; i += 1) {
+    duration += Math.min(unique[i] - unique[i - 1], TURN_GAP_CLAMP_MS);
+  }
+  return Math.max(0, duration);
+}
 function floorRollupBucket(ts) {
   const ms = Date.parse(ts);
   if (!Number.isFinite(ms)) {
@@ -4374,7 +4485,7 @@ function totalTokensFromEvent(event) {
   if (typeof explicit === "number" && explicit > 0) {
     return explicit;
   }
-  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0) + Math.max(0, event.metrics?.tokensReasoningOutput || 0);
+  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0);
 }
 function lineStatsFromEvent(event) {
   const files = event.fileActivities || [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codetime-cli",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {