ai-lens 0.8.119 → 0.8.121

package/.commithash

@@ -1 +1 @@
-8674f71
+9775c12

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 History of changes to the `ai-lens` CLI package on npm. New entries go on top. Format: `## X.Y.Z — YYYY-MM-DD`, followed by user-facing bullets.
 
+## 0.8.121 — 2026-07-21
+- fix(codex): Codex token usage no longer double-counts — some Codex versions re-emit an identical usage record without advancing their own running counter, and those duplicates were inflating token totals; they are now dropped (including duplicates that land in a later session update)
+
+## 0.8.120 — 2026-07-03
+- fix: session events are no longer misattributed to an unrelated repository when a tool touches a file outside the project — project refinement now only follows genuine nested sub-repos, so the `projects` filter and per-project stats stay correct
+- feat(codex): Codex sessions now report per-call token usage, matching Claude Code / Cursor granularity
+- feat(codex): Codex sessions now capture per-message assistant text for dialogue and search
+
 ## 0.8.119 — 2026-07-02
 - feat: team-memory injection now fires only on genuinely relevant prompts — the trigger matches distinctive terms of the memory title instead of an absolute score, cutting noise ~20x while keeping real matches
 - feat: the full team memory pool is delivered to the session cache (previously most team-tier memories could never surface), server-gated to clients on this version and newer

package/README.md

@@ -345,13 +345,15 @@ Stored in `~/.ai-lens/`:
 ## Development
 
 ```bash
-npm test               # Run all tests (vitest, 683 tests)
+npm test               # Run all tests (vitest)
 npm run test:watch     # Watch mode
 npm run dev:dashboard  # Dashboard dev server
 ```
 
 Tests require PostgreSQL — set `DATABASE_URL` or use `docker compose up postgres -d` (test DB `ailens_test` is created automatically).
 
+Test files run in parallel, each worker against its own database: `test/global-setup.js` migrates a template once and clones it into `ailens_test_w1..wN`. Set `AI_LENS_TEST_WORKERS` to change the worker count (default 6).
+
 Architecture decisions are recorded under [`docs/adr/`](docs/adr/) — e.g. [ADR 0001 — Canonical metric predicates](docs/adr/0001-canonical-metric-predicates.md).
 
 ## Deployment

package/cli/hooks.js

@@ -733,6 +733,27 @@ export function getClaudeCodeToolConfig(projectRoot, label = 'Claude Code (proje
   };
 }
 
+/**
+ * The per-machine Claude Code overlay as a tool config: same tool, but pointed at
+ * `<project>/.claude/settings.local.json`.
+ *
+ * This file is where `init` ACTUALLY writes project hooks (cli/init.js — gitignored,
+ * per-machine, HELP-1539), so anything that inspects "the project's Claude hooks" and
+ * reads only `settings.json` is looking at the wrong file. It has its own label
+ * because consumers key on `tool.name`: `status`'s capture test emits one `[<name>]`
+ * block per tested tool and the server parses those blocks into a Map — two entries
+ * sharing a name would silently overwrite each other.
+ *
+ * `Claude Code (project local overlay)` is the canonical string (already used by
+ * `cli/remove.js` and already mapped to the `claude_code` source in
+ * `server/models/client-reports.js`). Do not invent a variant.
+ */
+export function getClaudeCodeLocalToolConfig(projectRoot, label = 'Claude Code (project local overlay)', ctx = null) {
+  const base = getClaudeCodeToolConfig(projectRoot, label, ctx);
+  if (!base) return null;
+  return { ...base, configPath: claudeLocalSettingsPath(base), sharedConfig: true };
+}
+
 export function getCodexToolConfig(projectRoot, label = 'Codex (project)', ctx = null) {
   const base = TOOL_CONFIGS.find(t => t.name === 'Codex');
   if (!base) return null;
@@ -1226,9 +1247,7 @@ export function detectAiLensInstallScope(projectRoot) {
   // (per-machine, gitignored); the committed `--use-repo-path` form lands in
   // settings.json — check BOTH so neither install style is missed.
   const claudeProject = getClaudeCodeToolConfig(projectRoot);
-  const claudeProjectLocal = claudeProject
-    ? { ...claudeProject, configPath: claudeLocalSettingsPath(claudeProject) }
-    : null;
+  const claudeProjectLocal = getClaudeCodeLocalToolConfig(projectRoot);
   const projectTools = [
     claudeProject,
     claudeProjectLocal,

package/cli/status.js

@@ -7,7 +7,7 @@ import tls from 'node:tls';
 
 import { TLS_TRUST_CODES, tlsCodeOf, tlsVerdictSummary, issuerName } from '../client/tls-trust.js';
 
-import { getVersionInfo, readLensConfig, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, getCodexToolConfig, analyzeToolHooks, checkHooksDisabled, verifyCodexHookTrust, CAPTURE_PATH, TOOL_CONFIGS, isClaudeProjectDirCommand, analyzeClaudeLocalOverlay, extractProjectDirRelPath, globalClaudeHooksActive, CONHOST_HEADLESS_PREFIX_RE } from './hooks.js';
+import { getVersionInfo, readLensConfig, detectInstalledTools, getCursorToolConfig, getClaudeCodeToolConfig, getCodexToolConfig, getClaudeCodeLocalToolConfig, analyzeToolHooks, checkHooksDisabled, verifyCodexHookTrust, CAPTURE_PATH, TOOL_CONFIGS, isClaudeProjectDirCommand, isWrongPlatformProjectDirCommand, analyzeClaudeLocalOverlay, extractProjectDirRelPath, globalClaudeHooksActive, CONHOST_HEADLESS_PREFIX_RE } from './hooks.js';
 import { DATA_DIR, PENDING_DIR, SENDING_DIR, SESSION_PATHS_DIR, LOG_PATH, CAPTURE_LOG_PATH, LAST_STATUS_REPORT_PATH, getGitIdentity, getMonitoredProjects } from '../client/config.js';
 import { recoverMojibake } from '../client/mojibake-fix.js';
 import { isProjectMonitored } from '../client/capture.js';
@@ -234,17 +234,49 @@ function validateHookCommandPaths(tool) {
 }
 
 /**
- * Global tools (detectInstalledTools) plus project-level tools when cwd has .cursor/hooks.json
- * or .claude/settings.json. Status is assumed to be run from the project root where hooks live.
+ * Global tools (detectInstalledTools) plus the project-level tools found under
+ * `projectRoot`. Status is assumed to be run from the project root where hooks live.
+ *
+ * Claude Code contributes up to TWO entries, and both halves matter:
+ *
+ *  - `settings.local.json` (the OVERLAY) is where `init` actually writes project
+ *    hooks — per-machine, gitignored (HELP-1539). Reading only `settings.json` is
+ *    how this check used to report `no hook command found` for a perfectly healthy
+ *    install, while the per-tool line in the SAME report said the overlay was fine.
+ *
+ *  - the committed `settings.json` is tested only when its hooks can actually fire
+ *    HERE. When `analyzeClaudeLocalOverlay` says an overlay is `applicable`, that
+ *    means by definition "this file carries the other OS's syntax and never fires on
+ *    this machine" — running such a command through the shell yields exit 127 and
+ *    would report `capture failed` for someone whose capture works via the overlay.
+ *    Testing a command the OS cannot execute proves nothing; skipping it makes this
+ *    check agree with the per-tool line instead of contradicting it.
+ *
+ * @param {string} [projectRoot] — defaults to cwd; a parameter so this is testable
+ *   without chdir (it had no coverage precisely because it took none).
+ * @param {{platform?: string, tracked?: boolean}} [opts] — overlay-analysis
+ *   overrides, forwarded to analyzeClaudeLocalOverlay (tests only).
  */
-function getToolsForCaptureTest() {
+export function getToolsForCaptureTest(projectRoot = process.cwd(), opts = {}) {
   const global = detectInstalledTools();
-  const projectRoot = process.cwd();
   const projectTools = [];
   const cursorProject = getCursorToolConfig(projectRoot);
   if (cursorProject && existsSync(cursorProject.configPath)) projectTools.push(cursorProject);
+
   const claudeProject = getClaudeCodeToolConfig(projectRoot);
-  if (claudeProject && existsSync(claudeProject.configPath)) projectTools.push(claudeProject);
+  if (claudeProject && existsSync(claudeProject.configPath)) {
+    const overlay = analyzeClaudeLocalOverlay(claudeProject, opts);
+    // `applicable` ⇔ wrong-platform syntax AND git-tracked. The untracked variant is
+    // just as unrunnable, so check the command form directly too.
+    const wrongForm = isWrongPlatformProjectDirCommand(
+      extractHookCommand(claudeProject) ?? '', opts.platform ?? process.platform,
+    );
+    if (!overlay.applicable && !wrongForm) projectTools.push(claudeProject);
+  }
+
+  const claudeLocal = getClaudeCodeLocalToolConfig(projectRoot);
+  if (claudeLocal && existsSync(claudeLocal.configPath)) projectTools.push(claudeLocal);
+
   const codexProject = getCodexToolConfig(projectRoot);
   if (codexProject && existsSync(codexProject.configPath)) projectTools.push(codexProject);
   return [...global, ...projectTools];
@@ -260,7 +292,22 @@ function checkCaptureRun(installedTools) {
   }
 
   if (toolCommands.length === 0) {
-    return { ok: null, summary: 'no hook command found', detail: 'Could not find an AI Lens hook command in any tool config' };
+    // Say WHERE we looked. Project hooks are discovered relative to cwd, so running
+    // status from outside the project produces this result on a perfectly healthy
+    // install — and the bare old wording ("no hook command found") read as "capture is
+    // dead". Three developers currently sit in exactly this state while their own
+    // report shows capture happening seconds earlier.
+    const looked = installedTools.map(t => t.configPath);
+    return {
+      ok: null,
+      summary: looked.length
+        ? `no hook command found in the configs checked here (${looked.length}) — project hooks may live in another directory`
+        : 'no tool configs found to check',
+      detail: 'Could not find an AI Lens hook command in any tool config.\n'
+        + `Checked:\n${looked.map(p => `  ${p}`).join('\n') || '  (none)'}\n\n`
+        + 'Project hooks are looked up relative to the current directory. If your hooks are\n'
+        + 'installed per-project, re-run `ai-lens status` from that project root.',
+    };
   }
 
   const defaultCaptureScript = join(homedir(), '.ai-lens', 'client', 'capture.js');

package/client/capture.js

@@ -297,45 +297,20 @@ function maybeCleanStaleTranscriptOffsets() {
 }
 
 /**
- * Incrementally read only the NEW bytes appended to a Claude Code transcript
- * since the last time this function was called for that transcript, and
- * return ONE entry per real (non-synthetic) assistant API call in the delta.
+ * Read the NEW bytes appended to a JSONL transcript since the last call for
+ * this path, returning the complete newline-terminated lines in that delta.
+ * The intricate byte-offset / rotation / partial-line handling lives HERE, in
+ * one place, shared by the Claude Code (assistant-line) and Codex (token_count)
+ * token extractors so the two can't silently diverge.
  *
- * Each entry corresponds to a single Anthropic API call: a single assistant
- * line in the JSONL with its own usage record. A single user->agent turn can
- * produce many of these (tool-use loops), and the caller is expected to emit
- * one unified TokenUsage event per entry — symmetric with Cursor's per-call
- * AgentResponse rows and Codex's per-call TokenUsage rows.
- *
- * Returns { calls, commitOffset }:
- *   - `calls` is Array<{usage, model, timestamp, uuid}>:
- *     • `usage` has Anthropic-named keys (input_tokens, output_tokens,
- *       cache_read_input_tokens, cache_creation_input_tokens) for
- *       buildTokenUsageRaw.
- *     • `model` is the model from that specific assistant line.
- *     • `timestamp` is the assistant line's own ISO timestamp if present, else
- *       null (caller falls back to the Stop event's timestamp).
- *     • `uuid` is the assistant line's `uuid` field (Claude Code transcripts
- *       always include one). Used by the caller to derive a stable event_id
- *       so concurrent Stop hook invocations can't double-emit a single API call.
- *   - `commitOffset` is a no-arg function the caller MUST invoke ONLY after
- *     successfully writing every TokenUsage event derived from `calls` into
- *     the spool. If spool writes fail (or the caller never calls it), the
- *     transcript cursor stays put and the next Stop re-reads the same delta —
- *     the server-side ON CONFLICT on the deterministic event_id then dedups
- *     whichever rows did land. This is what makes the pipeline crash-safe:
- *     we never mark transcript bytes "consumed" until we know the rows they
- *     produced are durably queued.
- *
- * Returns an empty `calls` array (and a no-op `commitOffset`) if nothing new
- * in the delta or no real assistant lines are found.
- *
- * Partial-line handling: a Stop hook can fire while Claude Code is mid-write,
- * so the delta may end before a trailing '\n'. We detect this, ignore the
- * partial tail, and persist the offset at the byte right after the LAST
- * complete '\n' so the next Stop re-reads the partial line once it's finished.
+ * Returns { lines, commitOffset }:
+ *   - `lines` — raw JSONL lines in the processable region (empty on nothing-new
+ *     or any I/O failure).
+ *   - `commitOffset` — a no-arg fn the caller MUST invoke ONLY after it has
+ *     durably consumed every line (advancing the cursor eagerly would drop rows
+ *     if a later spool write fails).
  */
-function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
+function readNewTranscriptDelta(transcriptPath) {
   // Run the rate-limited stale-offset cleanup at most once per 24h. Wrapped in
   // try/catch so a cleanup failure never prevents the token read.
   try { maybeCleanStaleTranscriptOffsets(); } catch { /* best-effort */ }
@@ -345,7 +320,7 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
   const noopCommit = () => {};
 
   if (!transcriptPath || typeof transcriptPath !== 'string') {
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   const offsetFile = join(TRANSCRIPT_OFFSETS_DIR, encodeURIComponent(transcriptPath));
@@ -358,7 +333,7 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
     currentMtime = st.mtimeMs;
   } catch (err) {
     captureLog({ msg: 'transcript-offset-error', stage: 'stat', path: transcriptPath, error: err?.message });
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   const savedState = readTranscriptOffsetState(offsetFile);
@@ -377,7 +352,7 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
 
   // Nothing new — just a stat, super cheap.
   if (currentSize === startOffset) {
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   let buffer = null;
@@ -395,13 +370,13 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
     // Read failed before we got any bytes — leave the cursor unchanged so the
     // next Stop retries. (Old behavior advanced past the unread bytes; that
     // silently dropped data on transient I/O errors.)
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   if (!buffer || buffer.length === 0) {
     // Defensive: shouldn't happen because of the currentSize === startOffset
     // early return above. Don't advance the cursor.
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   // Find the LAST complete newline. CRITICAL: search the BYTE buffer, not a
@@ -416,7 +391,7 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
   if (lastNewlineIndex === -1) {
     // The entire chunk is a partial trailing line — leave the cursor unchanged
     // so the next Stop re-reads the line once it's finished.
-    return { calls: [], commitOffset: noopCommit };
+    return { lines: [], commitOffset: noopCommit };
   }
 
   // Process only the bytes up to (and including) the last '\n'. The new
@@ -426,14 +401,47 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
   const processable = buffer.slice(0, lastNewlineIndex).toString('utf-8');
   const newOffset = startOffset + lastNewlineIndex + 1;
   const nextState = { offset: newOffset, size: currentSize, mtime_ms: currentMtime };
-  const commitOffset = () => writeTranscriptOffsetState(offsetFile, nextState);
+  // `extra` lets a caller persist source-specific cursor state (e.g. Codex's
+  // running cumulative token total, ANL-1343) atomically WITH the byte offset —
+  // so on a crash-before-commit both roll back together and nothing drifts.
+  const commitOffset = (extra) => writeTranscriptOffsetState(
+    offsetFile,
+    extra ? { ...nextState, ...extra } : nextState,
+  );
+
+  // `savedState` is the offset state as it stood BEFORE this delta (may carry
+  // extra fields a prior commit persisted). Exposed so a source-specific
+  // extractor can seed cross-delta state without re-reading the offset file.
+  return { lines: processable.split('\n'), commitOffset, savedState };
+}
+
+/**
+ * Incrementally read only the NEW bytes appended to a Claude Code transcript
+ * since the last time this function was called for that transcript, and
+ * return ONE entry per real (non-synthetic) assistant API call in the delta.
+ *
+ * Each entry corresponds to a single Anthropic API call: a single assistant
+ * line in the JSONL with its own usage record. A single user->agent turn can
+ * produce many of these (tool-use loops), and the caller is expected to emit
+ * one unified TokenUsage event per entry — symmetric with Cursor's per-call
+ * AgentResponse rows and Codex's per-call TokenUsage rows.
+ *
+ * Returns { calls, commitOffset } (see readNewTranscriptDelta for the
+ * commit-offset crash-safety contract): `calls` is Array<{usage, model,
+ * timestamp, uuid}> with Anthropic-named usage keys for buildTokenUsageRaw,
+ * the model + ISO timestamp from that specific assistant line, and the line's
+ * `uuid` (used by the caller to derive a stable event_id so concurrent Stop
+ * hook invocations can't double-emit a single API call).
+ */
+function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
+  const { lines, commitOffset } = readNewTranscriptDelta(transcriptPath);
+  if (!lines.length) return { calls: [], commitOffset };
 
   // Iterate lines in the processable region. Defensive parse-tolerance is
   // still useful for the rare case where a single line in the middle is
   // malformed (we skip it rather than dropping the whole delta).
   const calls = [];
   try {
-    const lines = processable.split('\n');
     for (const rawLine of lines) {
       const line = rawLine && rawLine.trim();
       if (!line) continue;
@@ -493,7 +501,7 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
     // to spool in this path, so it's safe to commit immediately (no risk of
     // losing events).
     commitOffset();
-    return { calls: [], commitOffset: noopCommit };
+    return { calls: [], commitOffset: () => {} };
   }
 
   // IMPORTANT: do NOT persist the offset here. The caller is responsible for
@@ -504,6 +512,195 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
   return { calls, commitOffset };
 }
 
+/**
+ * Codex analogue of extractNewClaudeApiCallsFromTranscript: read the NEW bytes
+ * appended to a Codex rollout transcript (`rollout-*.jsonl`) since the last
+ * call and, in a SINGLE delta pass, return both the per-call token usage
+ * (`calls`) and the assistant's dialogue text (`messages`).
+ *
+ * A single pass is mandatory: `readNewTranscriptDelta` advances a per-path byte
+ * cursor that is committed only after the caller spools everything, so a second
+ * independent read would re-consume the same bytes. Claude's extractor folds
+ * text into each `call` (usage + content share one assistant line); Codex keeps
+ * them separate because usage and text live in DIFFERENT interleaved records.
+ *
+ * TOKEN USAGE (`calls`) — Codex records per-call usage as `event_msg`/
+ * `token_count` records whose `payload.info.last_token_usage` is the DELTA for
+ * that single call (the sibling `total_token_usage` is the running cumulative
+ * sum). The rollout is OpenAI-shaped, so field names differ from Claude's and
+ * we normalize them to the Anthropic convention that buildTokenUsageRaw + the
+ * dashboard SQL expect:
+ *   - Codex `cached_input_tokens` ⊆ `input_tokens` (a subset), so we split them
+ *     into non-overlapping `input_tokens` (fresh) + `cache_read_input_tokens`
+ *     (cached), matching Claude where `input_tokens` excludes the cache read.
+ *   - Codex has no prompt-cache-creation notion → `cache_creation_input_tokens`
+ *     is always 0.
+ *   - `output_tokens` already includes `reasoning_output_tokens`, mirroring
+ *     Claude's output convention, so it passes through unchanged.
+ * Records whose call delta is all-zero (input+output == 0, e.g. the residual
+ * token_count emitted around a compaction) are skipped so we never spool an
+ * empty TokenUsage row.
+ *
+ * ASSISTANT TEXT (`messages`, ANL-1239) — the assistant's visible dialogue
+ * lives in `response_item`/`message` records with `role === 'assistant'`; we
+ * concatenate their `content[]` `output_text` blocks. The dedup key is
+ * `${timestamp}:${payload.id | sha(text)}`: current Codex writes a durable
+ * `msg_…` id on every assistant message (hard version cutoff ~2026-06-26; older
+ * rollouts have none), so we prefer it and fall back to a text fingerprint —
+ * mirroring how the token path synthesizes a stable key from records that lack
+ * a per-record uuid. The
+ * caller emits these as AssistantText events, metric-neutral server-side
+ * (ASSISTANT_CONTENT_TYPES). NOTE: there is deliberately no AssistantThinking
+ * analogue (unlike Claude). Current Codex emits no plaintext reasoning: the
+ * full chain-of-thought lives only in `response_item`/`reasoning`
+ * `encrypted_content`, and the short plaintext `summary` those records once
+ * carried was dropped ~2026-04 (verified on real rollouts: 91% of Feb reasoning
+ * records had a summary, 0% from April on). Since AI Lens captures live/current
+ * Codex, no recoverable thinking text exists.
+ *
+ * The model isn't on the token_count / message record; it lives on the nearest
+ * preceding `turn_context` record. We track the last-seen turn_context model
+ * within the delta and fall back to `fallbackModel` (the Stop event's model)
+ * when the governing turn_context landed in an earlier delta.
+ *
+ * @param {string} transcriptPath  Path to the Codex rollout JSONL.
+ * @param {string|null} fallbackModel  Model from the Stop event, used when no
+ *                                     turn_context precedes a record in this
+ *                                     delta.
+ * @returns {{calls: Array<{usage, model, timestamp, uuid}>,
+ *            messages: Array<{text, model, timestamp, uuid}>,
+ *            commitOffset: function}}
+ */
+function extractNewCodexRecordsFromTranscript(transcriptPath, fallbackModel) {
+  const { lines, commitOffset, savedState } = readNewTranscriptDelta(transcriptPath);
+  if (!lines.length) return { calls: [], messages: [], commitOffset };
+
+  const calls = [];
+  const messages = [];
+  let currentModel = fallbackModel || null;
+  // Highest cumulative token total already counted for this transcript, seeded
+  // from the persisted offset state so it survives across Stop deltas. Codex
+  // sometimes re-emits an identical token_count without advancing its
+  // cumulative counter (`total_token_usage.total_tokens`); the duplicate carries
+  // a fresh timestamp, so its event_id differs and the server dedup never
+  // collapses it — double-counting tokens (ANL-1343). We drop any token_count
+  // whose cumulative does not advance past this max. The cumulative is monotonic
+  // and never resets (verified across compactions on 22k+ real records), so a
+  // single running max is a complete, false-positive-free signal.
+  let maxTotal = toNumberOrNull(savedState?.codex_last_total) ?? 0;
+  try {
+    for (const rawLine of lines) {
+      const line = rawLine && rawLine.trim();
+      if (!line) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      // A turn_context record carries the model for the records that follow it.
+      if (parsed?.type === 'turn_context' && typeof parsed.payload?.model === 'string' && parsed.payload.model) {
+        currentModel = parsed.payload.model;
+        continue;
+      }
+      const payload = parsed?.payload;
+      if (!payload) continue;
+      const ts = typeof parsed.timestamp === 'string' ? parsed.timestamp : null;
+
+      // Assistant dialogue text — response_item/message with role 'assistant'.
+      if (parsed.type === 'response_item' && payload.type === 'message' && payload.role === 'assistant') {
+        let text = '';
+        if (Array.isArray(payload.content)) {
+          for (const block of payload.content) {
+            if (!block || typeof block !== 'object') continue;
+            // Assistant content is 'output_text'; accept 'text' too, defensively.
+            if ((block.type === 'output_text' || block.type === 'text') && typeof block.text === 'string' && block.text) {
+              text += (text ? '\n' : '') + block.text;
+            }
+          }
+        }
+        if (text) {
+          // Stable per-message dedup key: `${timestamp}:${id | sha(text)}`.
+          // Current Codex writes a durable `msg_…` id on every assistant
+          // message (verified: 100% from the 2026-06-26 build onward; older
+          // rollouts, ≤ mid-May in local data, carry none — a hard version
+          // cutoff, not a gradual mix). Live capture only ever sees current
+          // rollouts, so the id is normally present; the text-hash fallback is
+          // defensive insurance for a pre-cutoff / downgraded client. Either
+          // way the key is unique per record and identical across two Stop
+          // hooks reading the same bytes (main() re-hashes source_uuid into the
+          // event_id). Prefer the durable id so the key stays human-traceable.
+          const idPart = typeof payload.id === 'string' && payload.id
+            ? payload.id
+            : createHash('sha256').update(text).digest('hex').slice(0, 16);
+          const uuid = `${ts || ''}:${idPart}`;
+          messages.push({
+            text,
+            model: currentModel,
+            timestamp: ts,
+            uuid,
+          });
+        }
+        continue;
+      }
+
+      if (payload.type !== 'token_count') continue;
+      const info = payload.info;
+      const last = info?.last_token_usage;
+      if (!last || typeof last !== 'object') continue;
+
+      const rawInput = toNumberOrNull(last.input_tokens) ?? 0;
+      const cached = toNumberOrNull(last.cached_input_tokens) ?? 0;
+      const output = toNumberOrNull(last.output_tokens) ?? 0;
+      // Skip all-zero deltas (residual token_count around a compaction).
+      if (rawInput + output <= 0) continue;
+
+      // cached_input_tokens is a SUBSET of input_tokens — split into
+      // non-overlapping fresh-input + cache-read to match Claude's convention.
+      const cacheRead = Math.min(cached, rawInput);
+      const freshInput = Math.max(0, rawInput - cacheRead);
+
+      // Stable per-call fingerprint for the dedup event_id. The token_count
+      // record has no per-record uuid, so we key on the record timestamp + the
+      // cumulative total (monotonic across calls) — unique per token_count
+      // record and identical across two concurrent Stop hooks reading the same
+      // bytes.
+      const cum = toNumberOrNull(info?.total_token_usage?.total_tokens);
+      // Phantom-duplicate guard (ANL-1343): skip a token_count whose cumulative
+      // total does not advance past the max already counted for this transcript.
+      // Every such record is a byte-identical re-emission (verified: 100% literal
+      // duplicates, 0 false positives). cum-less records (older Codex without a
+      // total) fall through unchanged and rely on the existing dedup.
+      if (cum != null) {
+        if (cum <= maxTotal) continue;
+        maxTotal = cum;
+      }
+      const uuid = `${ts || ''}:${cum != null ? cum : ''}`;
+
+      calls.push({
+        usage: {
+          input_tokens: freshInput,
+          output_tokens: output,
+          cache_read_input_tokens: cacheRead,
+          cache_creation_input_tokens: 0,
+        },
+        model: currentModel,
+        timestamp: ts,
+        uuid: uuid === ':' ? null : uuid,
+      });
+    }
+  } catch (err) {
+    captureLog({ msg: 'transcript-offset-error', stage: 'parse-codex', path: transcriptPath, error: err?.message });
+    commitOffset({ codex_last_total: maxTotal });
+    return { calls: [], messages: [], commitOffset: () => {} };
+  }
+
+  // Persist the advanced cumulative max together with the byte offset, so the
+  // next Stop delta seeds `maxTotal` correctly and cross-delta duplicates are
+  // still caught. Deferred: the caller invokes this only AFTER spooling.
+  return { calls, messages, commitOffset: () => commitOffset({ codex_last_total: maxTotal }) };
+}
+
 // =============================================================================
 // Source Detection
 // =============================================================================
@@ -524,10 +721,19 @@ export function detectSource(event) {
   // Codex writes its rollout transcript as `.../sessions/.../rollout-<ts>-<id>.jsonl`
   // (codex-rs session naming); Claude Code uses `~/.claude/projects/<dir>/<uuid>.jsonl`.
   // The `rollout-*.jsonl` basename is the reliable Codex signal for SessionStart.
+  // But some Codex SessionStart events carry an EMPTY transcript_path (no rollout yet) and
+  // no turn_id, so they'd fall through to claude_code — which mislabeled the whole session
+  // downstream ([0132]). Those events carry `model: "gpt-5.x…"`; Claude Code never emits a
+  // `gpt-*` model, so it's a safe Codex tie-breaker — but ONLY for the claude-code-shaped
+  // envelope: Cursor also emits `gpt-*` models, so gate the model signal behind "no Cursor
+  // signal present" (conversation_id/cursor_version), which the Cursor branch below keys on.
   const transcriptPath = typeof event.transcript_path === 'string' ? event.transcript_path : '';
+  const model = typeof event.model === 'string' ? event.model : '';
+  const gptModelNoCursor = /^gpt[-.]/i.test(model) && !event.conversation_id && !event.cursor_version;
   if (event.codex_version || event.source === 'codex' || event.hook_source === 'codex'
     || typeof event.turn_id === 'string'
-    || /(^|[\\/])rollout-[^\\/]*\.jsonl$/.test(transcriptPath)) return 'codex';
+    || /(^|[\\/])rollout-[^\\/]*\.jsonl$/.test(transcriptPath)
+    || gptModelNoCursor) return 'codex';
   if (event.conversation_id || event.cursor_version) return 'cursor';
   if (event.session_id || event.transcript_path) return 'claude_code';
   return 'unknown';
@@ -687,7 +893,14 @@ function refineProjectPath(event, projectPath, sessionId) {
   const filePath = extractFilePath(toolInput);
   if (!filePath) return projectPath;
   const gitRoot = findGitRoot(filePath);
-  if (gitRoot && (!projectPath || gitRoot.length > projectPath.length)) {
+  // Refine ONLY downward — into the current project itself or a real sub-repo
+  // of it (nested repos like etl-pipelines/bk-reports-automation/). Never flip
+  // to an unrelated repo just because its path string happens to be longer:
+  // a session running in one project that touches a file in a sibling/foreign
+  // repo would otherwise get misattributed there (and mis-filtered against the
+  // `projects` config). `pathContains` handles the nesting check plus Windows
+  // backslash/drive-letter/case normalization for free.
+  if (gitRoot && (!projectPath || pathContains(projectPath, gitRoot))) {
     if (sessionId) cacheSessionPath(sessionId, gitRoot);
     return gitRoot;
   }
@@ -1369,7 +1582,7 @@ function normalizeCodex(event) {
     projectPath = refineProjectPath({ tool_input: codexToolInput(event), input: codexToolInput(event) }, projectPath, sessionId);
   }
 
-  return [{
+  const primary = {
     event_id: null,
     source: 'codex',
     session_id: sessionId,
@@ -1378,7 +1591,59 @@ function normalizeCodex(event) {
     timestamp,
     data,
     raw: event,
-  }];
+  };
+
+  // On Stop (end of a Codex agent turn), read the rollout delta once and emit
+  // one TokenUsage event per real API call PLUS one AssistantText event per
+  // assistant message (ANL-1239) — giving Codex the same row-per-call
+  // granularity as Claude Code and Cursor. The rollout path arrives as
+  // `transcript_path` (the same field detectSource keys on for `rollout-*`).
+  if (hookType === 'Stop') {
+    const transcriptPath = event.transcript_path || null;
+    const fallbackModel = typeof event.model === 'string' ? event.model : null;
+    const { calls, messages, commitOffset } = extractNewCodexRecordsFromTranscript(transcriptPath, fallbackModel);
+    const tokenEvents = calls.map(call => ({
+      event_id: null, // assigned in main() from a stable hash of call.uuid
+      source: 'codex',
+      session_id: sessionId,
+      type: 'TokenUsage',
+      project_path: projectPath,
+      timestamp: call.timestamp || timestamp,
+      data: {
+        model: call.model,
+        input_tokens: call.usage.input_tokens,
+        output_tokens: call.usage.output_tokens,
+      },
+      raw: buildTokenUsageRaw({ source_uuid: call.uuid }, call.usage, call.model),
+    }));
+    // Assistant dialogue text (ANL-1239). Stored for dialogue/search;
+    // metric-neutral server-side (ASSISTANT_CONTENT_TYPES). data.text is
+    // truncated for display; raw.text keeps the full text (redacted
+    // server-side). Codex has NO plaintext thinking, so there is no
+    // AssistantThinking counterpart (unlike the Claude Code Stop path).
+    const contentEvents = messages.map(msg => ({
+      event_id: null, // assigned in main() from a stable hash of msg.uuid
+      source: 'codex',
+      session_id: sessionId,
+      type: 'AssistantText',
+      project_path: projectPath,
+      timestamp: msg.timestamp || timestamp,
+      data: { text: truncate(msg.text, TRUNCATION_LIMITS.agentResponse), model: msg.model },
+      raw: { source_uuid: msg.uuid, model: msg.model, text: msg.text },
+    }));
+    const result = [primary, ...tokenEvents, ...contentEvents];
+    // Attach the commit callback as a non-enumerable property so it survives
+    // through normalizeEvent()/writeToSpool without leaking into iteration or
+    // length assertions — mirrors the Claude Code Stop path.
+    Object.defineProperty(result, 'commitTranscriptOffset', {
+      value: commitOffset,
+      enumerable: false,
+      writable: false,
+    });
+    return result;
+  }
+
+  return [primary];
 }
 
 // =============================================================================
@@ -2142,7 +2407,7 @@ async function main() {
       : ev.type === 'AssistantThinking' ? 'assistantthinking'
         : 'tokenusage';
     if (sourceUuid) {
-      ev.event_id = deterministicEventId(`claude_code:${kind}:${sourceUuid}`);
+      ev.event_id = deterministicEventId(`${ev.source}:${kind}:${sourceUuid}`);
     } else {
       // Fallback: stdin hash + per-event index. Should never be needed because
       // Claude Code transcripts always include uuid per record.

package/client/redact.js

@@ -90,6 +90,10 @@ const PATTERNS = [
   // Meilisearch master/API key (mc_ + 32+ hex chars)
   { type: 'MEILISEARCH_KEY', re: /\bmc_[0-9a-f]{32,}\b/g },
 
+  // Cursor Admin API key (crsr_ + 64 hex chars as issued today; 32+ to stay
+  // ahead of a longer future format)
+  { type: 'CURSOR_ADMIN_KEY', re: /\bcrsr_[0-9a-f]{32,}\b/g },
+
   // Connection string password (://user:password@host) — redacts password only.
   // Tightened: exclude JSON structural chars from the user/password classes so
   // a stringified JSON payload (e.g. MCP `tool_response` kept as a single

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.119",
+  "version": "0.8.121",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {