codetime-cli 0.5.0 → 0.6.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 = 2;
 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.6.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
@@ -2243,6 +2245,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 +2318,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 +2344,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 +2353,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 +2369,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 +2392,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 +2414,7 @@ async function parseCodexSessionFile(filePath, options) {
             break;
           }
           lastTokenUsageKey = usageKey;
-          events.push(withBackfillRefs(baseCodexEvent({
+          pushEvent(baseCodexEvent({
             ts,
             type: "model.usage",
             sessionId,
@@ -2407,13 +2427,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 +2446,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 +2458,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 +2475,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 +2493,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 +2505,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 +2523,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 +2550,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 +2560,7 @@ async function parseCodexSessionFile(filePath, options) {
           cwd,
           displayFilePath2
         );
-        events.push(withBackfillRefs(baseCodexEvent({
+        pushEvent(baseCodexEvent({
           ts,
           type: "file.changed",
           operation: "apply patch",
@@ -2557,15 +2577,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 +2597,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 +2613,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 +2652,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 +3017,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 +3465,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,
@@ -4113,6 +4140,7 @@ function buildSessionRollup(rollupKey, events) {
   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;
@@ -4210,6 +4238,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;
@@ -4327,6 +4361,12 @@ function buildSessionRollup(rollupKey, events) {
   const baseRollup = {
     rollupKey,
     payloadHash: "",
+    // v2 schema: trustworthy gap-clamped turn durations + billable-output token
+    // convention. 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,
@@ -4354,7 +4394,10 @@ function buildSessionRollup(rollupKey, events) {
     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 +4405,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 +4433,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.6.0",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {