chore(versioning): bump version to 0.3.3

Author: Jannchie

package.json

@@ -1,7 +1,7 @@
 {
   "name": "codetime-cli-workspace",
   "type": "module",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "private": true,
   "packageManager": "pnpm@11.1.2",
   "scripts": {

packages/cli/package.json

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

packages/cli/src/adapters/codex.ts

@@ -2,6 +2,13 @@ import type { CanonicalEvent } from '@codetime/shared'
 import type { AdapterEnv, AgentAdapter, InstallEntry } from './types.js'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+// Codex's fast/priority service_tier costs ~2× standard, so we encode the tier
+// into the model name (e.g. `gpt-5-codex-fast`) so the backend pricing table
+// resolves to the tier-specific entry. We only trust per-turn evidence inside
+// the session file itself — never the current `config.toml`. The old behavior
+// (read CODEX_HOME/config.toml once, stamp every historical model.usage with
+// `-fast`) caused false positives whenever a user enabled fast later, because
+// every old session would be retroactively re-classified on the next backfill.
 import {
   AGENT_TIME_SCHEMA_VERSION,
   createStableHash,
@@ -36,13 +43,14 @@ async function parseCodexSessionFile(
   const text = await readFile(filePath, 'utf8')
   const lines = text.split('\n').filter(Boolean)
   const sourcePathHash = `sha256:${createStableHash(filePath)}`
-  // service_tier=fast|priority encoded into model name (see rewriteCodexModelForTier).
-  const serviceTier = await resolveCodexServiceTier(filePath)
   const events: CanonicalEvent[] = []
   let sessionId = sessionIdFromFilePath(filePath, 'codex')
   let cwd: string | undefined
   let project: string | undefined
   let model: string | undefined
+  // Per-turn service tier. Updated whenever a turn_context (or future per-turn
+  // event) carries an explicit service_tier; never inferred from config.toml.
+  let serviceTier: string | undefined
   let currentTurnId: string | undefined
   let lastTurnIdForComplete: string | undefined
   // Track the turn_id that was active when the previous user_message arrived. Older Codex
@@ -104,6 +112,14 @@ async function parseCodexSessionFile(
       cwd = stringField(payload, 'cwd') || cwd
       project = cwd ? path.basename(cwd) : project
       model = stringField(payload, 'model') || model
+      // Codex hasn't shipped service_tier inside turn_context yet, but the field
+      // is the natural per-turn location and the upstream protocol allows it.
+      // Honor it when present so future Codex builds get accurate fast/priority
+      // attribution without another parser change.
+      const tier = stringField(payload, 'service_tier')
+      if (tier) {
+        serviceTier = tier.toLowerCase()
+      }
       continue
     }
 
@@ -168,6 +184,13 @@ async function parseCodexSessionFile(
         break
       }
       case 'token_count': {
+        // Some Codex builds carry service_tier alongside last_token_usage, so
+        // pick it up here too as a secondary per-turn signal.
+        const info = objectField(payload, 'info')
+        const tierFromInfo = stringField(info, 'service_tier') || stringField(payload, 'service_tier')
+        if (tierFromInfo) {
+          serviceTier = tierFromInfo.toLowerCase()
+        }
         const usage = tokenUsageFromPayload(payload)
         if (usage) {
           const usageKey = [
@@ -399,59 +422,6 @@ async function parseCodexSessionFile(
 
 // ── Codex-specific helpers ──
 
-// Module-level cache: a single backfill run touches many session files under
-// the same CODEX_HOME — read config.toml once per home, not per file.
-const codexServiceTierCache = new Map<string, string | null>()
-
-async function resolveCodexServiceTier(sessionFilePath: string): Promise<string | undefined> {
-  const home = inferCodexHomeFromSessionPath(sessionFilePath)
-  if (!home) {
-    return undefined
-  }
-  if (!codexServiceTierCache.has(home)) {
-    codexServiceTierCache.set(home, await readCodexServiceTier(home))
-  }
-  return codexServiceTierCache.get(home) ?? undefined
-}
-
-// Codex session files live at <CODEX_HOME>/sessions/<...>/<file>.jsonl or
-// <CODEX_HOME>/history.jsonl. Walk parents until we hit the `sessions/` segment
-// or land on the history file's parent — either points at CODEX_HOME.
-function inferCodexHomeFromSessionPath(sessionFilePath: string): string | undefined {
-  if (path.basename(sessionFilePath) === 'history.jsonl') {
-    return path.dirname(sessionFilePath)
-  }
-  let dir = path.dirname(sessionFilePath)
-  for (let depth = 0; depth < 10; depth += 1) {
-    const parent = path.dirname(dir)
-    if (parent === dir) {
-      return undefined
-    }
-    if (path.basename(dir) === 'sessions') {
-      return parent
-    }
-    dir = parent
-  }
-  return undefined
-}
-
-async function readCodexServiceTier(codexHomePath: string): Promise<string | null> {
-  try {
-    const text = await readFile(path.join(codexHomePath, 'config.toml'), 'utf8')
-    // Match `service_tier = "fast"` / `service_tier='priority'` / `service_tier=fast`
-    // anywhere in the file. ccusage uses a similar regex for the same purpose.
-    const match = text.match(/(?:^|\n)\s*service_tier\s*=\s*["']?([a-z_]+)["']?/i)
-    return match ? match[1].toLowerCase() : null
-  }
-  catch {
-    return null
-  }
-}
-
-// Codex's fast/priority service_tier costs ~2× standard. Like Claude Code's
-// `-fast` Opus suffix, we encode the tier into the model name so the backend
-// pricing table (which keys on model only) resolves to the tier-specific
-// entry without plumbing extra fields through SessionModelRollup.
 function rewriteCodexModelForTier(model: string | undefined, serviceTier: string | undefined): string | undefined {
   if (!model) {
     return model

packages/cli/src/lib/types.ts

@@ -30,12 +30,14 @@ export interface BackfillSourceFile {
 // Bump `BACKFILL_STATE_SCHEMA_VERSION` whenever the offline parsers
 // change in a way that invalidates already-uploaded rollups (e.g. the
 // Claude assistant-message dedup added in v2, the Codex fast/priority
-// model-name rewrite added in v3). The CLI compares the constant against
-// the on-disk schema; on a mismatch it drops every watermark so the next
-// sync silently re-parses all jsonl from scratch and upserts the rebuilt
-// rollups (`replace: true` is already set). Users get the fix
-// transparently the next time their agent runs.
-export const BACKFILL_STATE_SCHEMA_VERSION = 3
+// model-name rewrite added in v3, and the v4 fix that stops inferring
+// Codex fast/priority from CODEX_HOME/config.toml — it now requires
+// per-turn evidence inside the session itself). The CLI compares the
+// constant against the on-disk schema; on a mismatch it drops every
+// watermark so the next sync silently re-parses all jsonl from scratch
+// and upserts the rebuilt rollups (`replace: true` is already set).
+// Users get the fix transparently the next time their agent runs.
+export const BACKFILL_STATE_SCHEMA_VERSION = 4
 
 export interface BackfillIncrementalState {
   version: typeof BACKFILL_STATE_SCHEMA_VERSION

packages/cli/test/cli.test.ts

@@ -1253,7 +1253,11 @@ const SAMPLE_CODEX_SESSION = [
   }),
 ].join('\n')
 
-test('codex parser appends -fast to model when config.toml has service_tier="fast"', async () => {
+test('codex parser does NOT append -fast when config.toml has service_tier="fast" but the session has no per-turn evidence', async () => {
+  // Regression: prior versions read CODEX_HOME/config.toml once per backfill
+  // and stamped every historical model.usage with -fast, which retroactively
+  // re-classified old standard-tier sessions as fast whenever the user later
+  // enabled fast. Only per-turn evidence inside the session counts now.
   const codexHome = await mkdtemp(path.join(tmpdir(), 'codex-home-'))
   const sessionsDir = path.join(codexHome, 'sessions', 'p')
   await mkdir(sessionsDir, { recursive: true })
@@ -1264,20 +1268,62 @@ test('codex parser appends -fast to model when config.toml has service_tier="fas
   const events = await createCodexAdapter().parseSessionFile!(sessionPath, { _: [] })
   const usage = events.filter(event => event.type === 'model.usage')
   assert.ok(usage.length > 0, 'expected at least one model.usage')
+  for (const event of usage) {
+    assert.equal(event.model, 'gpt-5-codex')
+  }
+})
+
+test('codex parser appends -fast when turn_context carries service_tier="fast"', async () => {
+  const codexHome = await mkdtemp(path.join(tmpdir(), 'codex-home-'))
+  const sessionsDir = path.join(codexHome, 'sessions', 'p')
+  await mkdir(sessionsDir, { recursive: true })
+  const sessionPath = path.join(sessionsDir, 'session.jsonl')
+  await writeFile(sessionPath, [
+    JSON.stringify({ timestamp: '2026-05-13T09:00:00.000Z', type: 'turn_context', payload: { model: 'gpt-5-codex', service_tier: 'fast' } }),
+    JSON.stringify({
+      timestamp: '2026-05-13T09:01:00.000Z',
+      type: 'event_msg',
+      payload: {
+        type: 'token_count',
+        info: {
+          model: 'gpt-5-codex',
+          last_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+          total_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+        },
+      },
+    }),
+  ].join('\n'), 'utf8')
+
+  const events = await createCodexAdapter().parseSessionFile!(sessionPath, { _: [] })
+  const usage = events.filter(event => event.type === 'model.usage')
+  assert.ok(usage.length > 0)
   for (const event of usage) {
     assert.equal(event.model, 'gpt-5-codex-fast')
   }
 })
 
-test('codex parser maps service_tier="priority" to the -fast model variant', async () => {
-  // Codex's "priority" is the second flavor of fast inference; ccusage maps both
-  // to its single "fast" speed bucket. We do the same so backend pricing stays simple.
+test('codex parser maps per-turn service_tier="priority" to the -fast model variant', async () => {
+  // Codex's "priority" is the second flavor of fast inference; ccusage maps
+  // both to its single "fast" speed bucket. Backend pricing keys on model only.
   const codexHome = await mkdtemp(path.join(tmpdir(), 'codex-home-'))
   const sessionsDir = path.join(codexHome, 'sessions', 'p')
   await mkdir(sessionsDir, { recursive: true })
-  await writeFile(path.join(codexHome, 'config.toml'), 'service_tier = "priority"\n', 'utf8')
   const sessionPath = path.join(sessionsDir, 'session.jsonl')
-  await writeFile(sessionPath, SAMPLE_CODEX_SESSION, 'utf8')
+  await writeFile(sessionPath, [
+    JSON.stringify({ timestamp: '2026-05-13T09:00:00.000Z', type: 'turn_context', payload: { model: 'gpt-5-codex', service_tier: 'priority' } }),
+    JSON.stringify({
+      timestamp: '2026-05-13T09:01:00.000Z',
+      type: 'event_msg',
+      payload: {
+        type: 'token_count',
+        info: {
+          model: 'gpt-5-codex',
+          last_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+          total_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+        },
+      },
+    }),
+  ].join('\n'), 'utf8')
 
   const events = await createCodexAdapter().parseSessionFile!(sessionPath, { _: [] })
   const usage = events.filter(event => event.type === 'model.usage')
@@ -1287,14 +1333,29 @@ test('codex parser maps service_tier="priority" to the -fast model variant', asy
   }
 })
 
-test('codex parser keeps bare model name when config.toml omits service_tier', async () => {
+test('codex parser ignores config.toml fast when the turn explicitly says default', async () => {
+  // Mixed scenario: user has fast on now (config.toml), but an old turn
+  // explicitly recorded service_tier="default". The turn wins — no -fast.
   const codexHome = await mkdtemp(path.join(tmpdir(), 'codex-home-'))
   const sessionsDir = path.join(codexHome, 'sessions', 'p')
   await mkdir(sessionsDir, { recursive: true })
-  // config.toml exists but has no service_tier — must NOT append -fast.
-  await writeFile(path.join(codexHome, 'config.toml'), 'model = "gpt-5-codex"\n', 'utf8')
+  await writeFile(path.join(codexHome, 'config.toml'), 'service_tier = "fast"\n', 'utf8')
   const sessionPath = path.join(sessionsDir, 'session.jsonl')
-  await writeFile(sessionPath, SAMPLE_CODEX_SESSION, 'utf8')
+  await writeFile(sessionPath, [
+    JSON.stringify({ timestamp: '2026-05-13T09:00:00.000Z', type: 'turn_context', payload: { model: 'gpt-5-codex', service_tier: 'default' } }),
+    JSON.stringify({
+      timestamp: '2026-05-13T09:01:00.000Z',
+      type: 'event_msg',
+      payload: {
+        type: 'token_count',
+        info: {
+          model: 'gpt-5-codex',
+          last_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+          total_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, reasoning_output_tokens: 5, total_tokens: 150 },
+        },
+      },
+    }),
+  ].join('\n'), 'utf8')
 
   const events = await createCodexAdapter().parseSessionFile!(sessionPath, { _: [] })
   const usage = events.filter(event => event.type === 'model.usage')
@@ -1304,8 +1365,7 @@ test('codex parser keeps bare model name when config.toml omits service_tier', a
   }
 })
 
-test('codex parser handles missing config.toml gracefully', async () => {
-  // No config.toml at all — common when CODEX_HOME is fresh.
+test('codex parser keeps bare model name when neither config.toml nor session evidence is present', async () => {
   const codexHome = await mkdtemp(path.join(tmpdir(), 'codex-home-'))
   const sessionsDir = path.join(codexHome, 'sessions', 'p')
   await mkdir(sessionsDir, { recursive: true })

packages/shared/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codetime/shared",
   "type": "module",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "private": true,
   "description": "Shared event types for codetime CLI. Inlined into the published `codetime` bundle — not published independently.",
   "license": "MIT",