@link-assistant/hive-mind 2.13.4 → 2.13.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 2.13.5
+
+### Patch Changes
+
+- 0d0b96a: Fix every error and warning reported by CI/CD (issue #2175).
+
+  - The release job now lands the version bump through a pull request when a
+    repository ruleset rejects the direct push to `main` (GH013), instead of
+    retrying it as a lost race and failing the release.
+  - The release gate asks the npm registry, not the `.changeset` folder, whether
+    the current version is published, so an interrupted release self-heals on the
+    next push instead of being silently skipped.
+  - Release assets are uploaded with the `gh` CLI, removing the last action
+    pinned to the deprecated Node 20 runtime.
+  - Eight source files that had drifted into the 1350-line warning band were
+    reduced by extracting cohesive modules; behaviour is unchanged.
+
+- 3422f03: Retry transient GitHub and git failures instead of aborting the run. A `gh pr create` died 3.1 seconds after it was issued on `GraphQL: Something went wrong while executing your query …` without a single retry: GitHub reports internal GraphQL faults as **HTTP 200 with an `errors[]` payload**, and the transient-error classifier only knew about TCP/TLS faults and the literal strings `http 502`/`503`/`504`, so the failure was treated as permanent. Classification now lives in one place (`src/transient-errors.lib.mjs`), recognises the GraphQL 200-with-errors family, gets its own larger budget (`HIVE_MIND_MAX_GITHUB_TRANSIENT_RETRIES`, default 6), and logs _why_ an error was or was not retried — including GitHub's support reference id, which was previously discarded. Network git commands (`push`/`fetch`/`pull`/`ls-remote`) are now retried too: the wrapper is installed on command-stream's `$` tag rather than at each of the ~36 call sites, `gh pr create` recovers the existing PR URL when a retry hits "a pull request already exists", and a new `gh-rate-limit/no-unretried-git-network` ESLint rule fails the build on any future unguarded git network call in `src/`.
+
 ## 2.13.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.13.4",
+  "version": "2.13.5",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/agent.lib.mjs

@@ -8,7 +8,11 @@ if (typeof globalThis.use === 'undefined') {
   await ensureUseM();
 }
 
-const { $ } = await use('command-stream');
+const { $: __rawDollar$ } = await use('command-stream');
+// Issue #2168: retry transient git network failures (push/fetch/pull) the same
+// way `gh` calls are retried, for every command run through this module's `$`.
+const { wrapDollarWithGitRetry } = await import('./git-retry.lib.mjs');
+const $ = wrapDollarWithGitRetry(__rawDollar$);
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 const os = (await use('os')).default;

package/src/claude.lib.mjs

@@ -14,8 +14,7 @@ import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { setupBidirectionalHandler, finalizeBidirectionalHandler, validateBidirectionalModeConfig, attachStreamingInput } from './bidirectional-interactive.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import Decimal from 'decimal.js-light';
-import { createEmptySubSessionUsage, accumulateModelUsage, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage, getRawRequestInputTokens, displaySessionTokenUsage } from './claude.budget-stats.lib.mjs';
+import { createSubAgentCallEntry, accumulateSubAgentUsage, displaySessionTokenUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand } from './claude.command-builder.lib.mjs';
 import { beginAnthropicCostScope, seedCumulativeAnthropicCost, addAnthropicRunCost, captureAnthropicResultCost } from './anthropic-cost-accumulator.lib.mjs'; // Issues #1886, #2056, #2119
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
@@ -152,162 +151,10 @@ export const executeClaude = async params => {
 // this file under the 1500-line repo cap (see check-file-line-limits CI job).
 import { calculateModelCost } from './claude.cost.lib.mjs';
 export { calculateModelCost };
-export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsage = null, options = {}) => {
-  const os = (await use('os')).default;
-  const homeDir = options.homeDir || os.homedir();
-  const fetchModelInfoForUsage = options.fetchModelInfo || fetchModelInfo;
-  const projectDirName = tempDir.replace(/\//g, '-');
-  const sessionFile = path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
-  try {
-    await fs.access(sessionFile);
-  } catch {
-    return null;
-  }
-  const modelUsage = {};
-  // Issue #1501: Deduplicate JSONL entries by message ID (stream-json splits responses)
-  const seenMessageIds = new Set();
-  let duplicateCount = 0;
-  const peakContextByModel = {};
-  let globalPeakContext = 0;
-  const subSessions = [];
-  let currentSubSession = createEmptySubSessionUsage();
-  const compactifications = [];
-  try {
-    const fileContent = await fs.readFile(sessionFile, 'utf8');
-    const lines = fileContent.trim().split('\n');
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const entry = JSON.parse(line);
-        if (entry.type === 'system' && entry.subtype === 'compact_boundary') {
-          if (currentSubSession.messageCount > 0) {
-            subSessions.push(currentSubSession);
-          }
-          compactifications.push({
-            timestamp: entry.timestamp || null,
-            preTokens: entry.compactMetadata?.preTokens || null,
-            trigger: entry.compactMetadata?.trigger || 'unknown',
-          });
-          currentSubSession = createEmptySubSessionUsage();
-          continue;
-        }
-        if (entry.message && entry.message.usage && entry.message.model) {
-          // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
-          const msgId = entry.message.id;
-          if (msgId) {
-            if (seenMessageIds.has(msgId)) {
-              duplicateCount++;
-              continue;
-            }
-            seenMessageIds.add(msgId);
-          }
-          accumulateModelUsage(modelUsage, entry);
-          // Issue #1737: Track peak restored-context input per request.
-          // Anthropic splits a request's input into input_tokens,
-          // cache_creation_input_tokens, and cache_read_input_tokens; all three
-          // count toward "how much context will be restored if I resume here".
-          const usage = entry.message.usage;
-          const requestContext = getRawRequestInputTokens(usage);
-          const model = entry.message.model;
-          if (requestContext > (peakContextByModel[model] || 0)) {
-            peakContextByModel[model] = requestContext;
-          }
-          if (requestContext > globalPeakContext) {
-            globalPeakContext = requestContext;
-          }
-          if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
-          if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
-          if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
-          if (usage.output_tokens) currentSubSession.outputTokens += usage.output_tokens;
-          currentSubSession.messageCount++;
-          // Issue #1501: Track peak context and output per sub-session
-          if (requestContext > currentSubSession.peakContextUsage) {
-            currentSubSession.peakContextUsage = requestContext;
-          }
-          if ((usage.output_tokens || 0) > currentSubSession.peakOutputUsage) {
-            currentSubSession.peakOutputUsage = usage.output_tokens || 0;
-          }
-        }
-      } catch {
-        // Skip lines that aren't valid JSON
-        continue;
-      }
-    }
-    if (currentSubSession.messageCount > 0) {
-      subSessions.push(currentSubSession);
-    }
-    mergeResultModelUsage(modelUsage, resultModelUsage);
-    if (Object.keys(modelUsage).length === 0) {
-      return null;
-    }
-    const modelInfoPromises = Object.keys(modelUsage).map(async modelId => {
-      const modelInfo = await fetchModelInfoForUsage(modelId);
-      return { modelId, modelInfo };
-    });
-    const modelInfoResults = await Promise.all(modelInfoPromises);
-    const modelInfoMap = {};
-    for (const { modelId, modelInfo } of modelInfoResults) {
-      if (modelInfo) {
-        modelInfoMap[modelId] = modelInfo;
-      }
-    }
-    for (const [modelId, usage] of Object.entries(modelUsage)) {
-      const modelInfo = modelInfoMap[modelId];
-      // Issue #1501: Attach peak context usage per model
-      usage.peakContextUsage = peakContextByModel[modelId] || 0;
-      // Calculate cost using pricing API
-      if (modelInfo) {
-        const costData = calculateModelCost(usage, modelInfo, true);
-        usage.costUSD = costData.total;
-        usage.costBreakdown = costData.breakdown;
-        usage.modelName = modelInfo.name || modelId;
-        usage.modelInfo = modelInfo;
-      } else {
-        usage.costUSD = usage._resultCostUSD ?? null;
-        usage.costBreakdown = null;
-        usage.modelName = modelId;
-        // Issue #1539: Use contextWindow/maxOutputTokens from result JSON as fallback model limits
-        const ctx = usage._resultContextWindow,
-          out = usage._resultMaxOutputTokens;
-        usage.modelInfo = ctx || out ? { limit: { context: ctx || null, output: out || null } } : null;
-      }
-    }
-    let totalInputTokens = 0;
-    let totalCacheCreationTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCostDecimal = new Decimal(0);
-    let hasCostData = false;
-    for (const usage of Object.values(modelUsage)) {
-      totalInputTokens += usage.inputTokens;
-      totalCacheCreationTokens += usage.cacheCreationTokens;
-      totalCacheReadTokens += usage.cacheReadTokens;
-      totalOutputTokens += usage.outputTokens;
-      if (usage.costUSD !== null) {
-        totalCostDecimal = totalCostDecimal.plus(new Decimal(usage.costUSD));
-        hasCostData = true;
-      }
-    }
-    const totalTokens = totalInputTokens + totalCacheCreationTokens + totalOutputTokens;
-    return {
-      modelUsage,
-      inputTokens: totalInputTokens,
-      cacheCreationTokens: totalCacheCreationTokens,
-      cacheReadTokens: totalCacheReadTokens,
-      outputTokens: totalOutputTokens,
-      totalTokens,
-      totalCostUSD: hasCostData ? totalCostDecimal.toNumber() : null,
-      // Issue #1501: Peak context usage (max single-request fill) and dedup stats
-      peakContextUsage: globalPeakContext,
-      duplicateEntriesSkipped: duplicateCount,
-      // Issue #1491/#1501: Sub-session and compactification data (always include for display)
-      subSessions,
-      compactifications: compactifications.length > 0 ? compactifications : null,
-    };
-  } catch (readError) {
-    throw new Error(`Failed to read session file: ${readError.message}`, { cause: readError });
-  }
-};
+// Issue #2175: session token accounting lives in claude.session-tokens.lib.mjs
+// so this file stays under the 1350-line early-warning threshold (issue #1593).
+import { calculateSessionTokens } from './claude.session-tokens.lib.mjs';
+export { calculateSessionTokens };
 // Extracted to claude.stderr.lib.mjs (Issue #477, #1337)
 import { isStderrError } from './claude.stderr.lib.mjs';
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';

package/src/claude.session-tokens.lib.mjs

@@ -0,0 +1,180 @@
+/**
+ * Per-session token/cost accounting for Claude sessions.
+ *
+ * Reads the Claude Code session JSONL (`~/.claude/projects/<dir>/<id>.jsonl`),
+ * deduplicates the stream-json entries, splits the transcript into sub-sessions
+ * at each compact boundary, and prices the result through the model info API.
+ *
+ * Extracted from claude.lib.mjs (issue #2175) so that file stays under the
+ * 1350-line early-warning threshold of the CI file-headroom check (long files
+ * cause concurrent PR merge conflicts — issue #1593). Behaviour is unchanged;
+ * claude.lib.mjs re-exports this function.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2175
+ */
+
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import Decimal from 'decimal.js-light';
+
+import { accumulateModelUsage, createEmptySubSessionUsage, getRawRequestInputTokens, mergeResultModelUsage } from './claude.budget-stats.lib.mjs';
+import { calculateModelCost } from './claude.cost.lib.mjs';
+import { fetchModelInfo } from './model-info.lib.mjs';
+
+export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsage = null, options = {}) => {
+  const homeDir = options.homeDir || os.homedir();
+  const fetchModelInfoForUsage = options.fetchModelInfo || fetchModelInfo;
+  const projectDirName = tempDir.replace(/\//g, '-');
+  const sessionFile = path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
+  try {
+    await fs.access(sessionFile);
+  } catch {
+    return null;
+  }
+  const modelUsage = {};
+  // Issue #1501: Deduplicate JSONL entries by message ID (stream-json splits responses)
+  const seenMessageIds = new Set();
+  let duplicateCount = 0;
+  const peakContextByModel = {};
+  let globalPeakContext = 0;
+  const subSessions = [];
+  let currentSubSession = createEmptySubSessionUsage();
+  const compactifications = [];
+  try {
+    const fileContent = await fs.readFile(sessionFile, 'utf8');
+    const lines = fileContent.trim().split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'system' && entry.subtype === 'compact_boundary') {
+          if (currentSubSession.messageCount > 0) {
+            subSessions.push(currentSubSession);
+          }
+          compactifications.push({
+            timestamp: entry.timestamp || null,
+            preTokens: entry.compactMetadata?.preTokens || null,
+            trigger: entry.compactMetadata?.trigger || 'unknown',
+          });
+          currentSubSession = createEmptySubSessionUsage();
+          continue;
+        }
+        if (entry.message && entry.message.usage && entry.message.model) {
+          // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
+          const msgId = entry.message.id;
+          if (msgId) {
+            if (seenMessageIds.has(msgId)) {
+              duplicateCount++;
+              continue;
+            }
+            seenMessageIds.add(msgId);
+          }
+          accumulateModelUsage(modelUsage, entry);
+          // Issue #1737: Track peak restored-context input per request.
+          // Anthropic splits a request's input into input_tokens,
+          // cache_creation_input_tokens, and cache_read_input_tokens; all three
+          // count toward "how much context will be restored if I resume here".
+          const usage = entry.message.usage;
+          const requestContext = getRawRequestInputTokens(usage);
+          const model = entry.message.model;
+          if (requestContext > (peakContextByModel[model] || 0)) {
+            peakContextByModel[model] = requestContext;
+          }
+          if (requestContext > globalPeakContext) {
+            globalPeakContext = requestContext;
+          }
+          if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
+          if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
+          if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
+          if (usage.output_tokens) currentSubSession.outputTokens += usage.output_tokens;
+          currentSubSession.messageCount++;
+          // Issue #1501: Track peak context and output per sub-session
+          if (requestContext > currentSubSession.peakContextUsage) {
+            currentSubSession.peakContextUsage = requestContext;
+          }
+          if ((usage.output_tokens || 0) > currentSubSession.peakOutputUsage) {
+            currentSubSession.peakOutputUsage = usage.output_tokens || 0;
+          }
+        }
+      } catch {
+        // Skip lines that aren't valid JSON
+        continue;
+      }
+    }
+    if (currentSubSession.messageCount > 0) {
+      subSessions.push(currentSubSession);
+    }
+    mergeResultModelUsage(modelUsage, resultModelUsage);
+    if (Object.keys(modelUsage).length === 0) {
+      return null;
+    }
+    const modelInfoPromises = Object.keys(modelUsage).map(async modelId => {
+      const modelInfo = await fetchModelInfoForUsage(modelId);
+      return { modelId, modelInfo };
+    });
+    const modelInfoResults = await Promise.all(modelInfoPromises);
+    const modelInfoMap = {};
+    for (const { modelId, modelInfo } of modelInfoResults) {
+      if (modelInfo) {
+        modelInfoMap[modelId] = modelInfo;
+      }
+    }
+    for (const [modelId, usage] of Object.entries(modelUsage)) {
+      const modelInfo = modelInfoMap[modelId];
+      // Issue #1501: Attach peak context usage per model
+      usage.peakContextUsage = peakContextByModel[modelId] || 0;
+      // Calculate cost using pricing API
+      if (modelInfo) {
+        const costData = calculateModelCost(usage, modelInfo, true);
+        usage.costUSD = costData.total;
+        usage.costBreakdown = costData.breakdown;
+        usage.modelName = modelInfo.name || modelId;
+        usage.modelInfo = modelInfo;
+      } else {
+        usage.costUSD = usage._resultCostUSD ?? null;
+        usage.costBreakdown = null;
+        usage.modelName = modelId;
+        // Issue #1539: Use contextWindow/maxOutputTokens from result JSON as fallback model limits
+        const ctx = usage._resultContextWindow,
+          out = usage._resultMaxOutputTokens;
+        usage.modelInfo = ctx || out ? { limit: { context: ctx || null, output: out || null } } : null;
+      }
+    }
+    let totalInputTokens = 0;
+    let totalCacheCreationTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCostDecimal = new Decimal(0);
+    let hasCostData = false;
+    for (const usage of Object.values(modelUsage)) {
+      totalInputTokens += usage.inputTokens;
+      totalCacheCreationTokens += usage.cacheCreationTokens;
+      totalCacheReadTokens += usage.cacheReadTokens;
+      totalOutputTokens += usage.outputTokens;
+      if (usage.costUSD !== null) {
+        totalCostDecimal = totalCostDecimal.plus(new Decimal(usage.costUSD));
+        hasCostData = true;
+      }
+    }
+    const totalTokens = totalInputTokens + totalCacheCreationTokens + totalOutputTokens;
+    return {
+      modelUsage,
+      inputTokens: totalInputTokens,
+      cacheCreationTokens: totalCacheCreationTokens,
+      cacheReadTokens: totalCacheReadTokens,
+      outputTokens: totalOutputTokens,
+      totalTokens,
+      totalCostUSD: hasCostData ? totalCostDecimal.toNumber() : null,
+      // Issue #1501: Peak context usage (max single-request fill) and dedup stats
+      peakContextUsage: globalPeakContext,
+      duplicateEntriesSkipped: duplicateCount,
+      // Issue #1491/#1501: Sub-session and compactification data (always include for display)
+      subSessions,
+      compactifications: compactifications.length > 0 ? compactifications : null,
+    };
+  } catch (readError) {
+    throw new Error(`Failed to read session file: ${readError.message}`, { cause: readError });
+  }
+};

package/src/codex.diagnostics.lib.mjs

@@ -0,0 +1,135 @@
+/**
+ * Codex diagnostic-line parsing and sub-session reconstruction.
+ *
+ * Extracted from src/codex.lib.mjs (issue #2175) so that file stays under the
+ * 1350-line early-warning threshold that protects concurrent merges (#1593).
+ * Behaviour is unchanged.
+ *
+ * Codex emits its context window, auto-compact limit and successful
+ * `/responses/compact` calls only as `codex_otel.log_only:` diagnostic lines on
+ * stderr (with RUST_LOG=debug). Those lines are the only evidence that a
+ * compactification happened, which is what lets the token usage of a single
+ * Codex run be split back into the sub-sessions the user actually experienced.
+ */
+
+import { getCumulativeContextInputTokens } from './context-fill.lib.mjs';
+
+const CODEX_COMPACT_API_ENDPOINT = '/responses/compact';
+const escapeRegExp = value => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getCodexDiagnosticValue = (line, key) => {
+  const match = line.match(new RegExp(`${escapeRegExp(key)}=(?:"([^"]*)"|([^\\s")]+))`));
+  return match?.[1] ?? match?.[2] ?? null;
+};
+const getCodexDiagnosticInteger = (line, key) => {
+  const value = getCodexDiagnosticValue(line, key);
+  if (value === null) return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+const getCodexDiagnosticTimestamp = line => {
+  const eventTimestamp = getCodexDiagnosticValue(line, 'event.timestamp');
+  if (eventTimestamp) return eventTimestamp;
+  const logPrefixMatch = line.match(/^\[(\d{4}-\d{2}-\d{2}T[^\]]+Z)\]/u);
+  return logPrefixMatch?.[1] ?? null;
+};
+const isSuccessfulCodexCompactRequestLine = line => {
+  if (!line.includes('codex_otel.log_only:')) return false;
+  if (!line.includes('event.name="codex.api_request"')) return false;
+  if (!line.includes(`endpoint="${CODEX_COMPACT_API_ENDPOINT}"`)) return false;
+  const statusCode = getCodexDiagnosticInteger(line, 'http.response.status_code');
+  return statusCode === null || (statusCode >= 200 && statusCode < 300);
+};
+
+const splitTokenCountEvenly = (total, partCount) => {
+  const safeTotal = Math.max(0, Math.round(total || 0));
+  const safePartCount = Math.max(1, Math.round(partCount || 1));
+  const base = Math.floor(safeTotal / safePartCount);
+  let remainder = safeTotal % safePartCount;
+  return Array.from({ length: safePartCount }, () => {
+    const value = base + (remainder > 0 ? 1 : 0);
+    if (remainder > 0) remainder--;
+    return value;
+  });
+};
+const splitCodexSubSessionInputTokens = (total, partCount, autoCompactTokenLimit = null) => {
+  const safeTotal = Math.max(0, Math.round(total || 0));
+  const safePartCount = Math.max(1, Math.round(partCount || 1));
+  const safeLimit = Number.isFinite(autoCompactTokenLimit) && autoCompactTokenLimit > 0 ? Math.round(autoCompactTokenLimit) : null;
+  if (safePartCount <= 1) return [safeTotal];
+  if (safeLimit && safeTotal > safeLimit * (safePartCount - 1)) {
+    const chunks = [];
+    let remaining = safeTotal;
+    for (let i = 0; i < safePartCount - 1; i++) {
+      const chunk = Math.min(safeLimit, remaining);
+      chunks.push(chunk);
+      remaining -= chunk;
+    }
+    chunks.push(Math.max(0, remaining));
+    return chunks;
+  }
+  return splitTokenCountEvenly(safeTotal, safePartCount);
+};
+const splitTokenCountByWeights = (total, weights) => {
+  const safeTotal = Math.max(0, Math.round(total || 0));
+  const safeWeights = Array.isArray(weights) && weights.length > 0 ? weights.map(weight => Math.max(0, weight || 0)) : [1];
+  const weightTotal = safeWeights.reduce((sum, weight) => sum + weight, 0);
+  if (weightTotal <= 0) return splitTokenCountEvenly(safeTotal, safeWeights.length);
+  let allocated = 0;
+  return safeWeights.map((weight, index) => {
+    if (index === safeWeights.length - 1) return Math.max(0, safeTotal - allocated);
+    const value = Math.floor((safeTotal * weight) / weightTotal);
+    allocated += value;
+    return value;
+  });
+};
+export const rebuildCodexSubSessionsFromCompactifications = tokenUsage => {
+  const compactifications = Array.isArray(tokenUsage.compactifications) ? tokenUsage.compactifications : [];
+  if (compactifications.length === 0 || (tokenUsage.stepCount || 0) === 0) {
+    tokenUsage.subSessions = Array.isArray(tokenUsage.subSessions) ? tokenUsage.subSessions : [];
+    return;
+  }
+
+  const subSessionCount = compactifications.length + 1;
+  const inputChunks = splitCodexSubSessionInputTokens(tokenUsage.inputTokens || 0, subSessionCount, tokenUsage.autoCompactTokenLimit);
+  const cacheWriteChunks = splitTokenCountByWeights(tokenUsage.cacheWriteTokens || 0, inputChunks);
+  const cacheReadChunks = splitTokenCountByWeights(tokenUsage.cacheReadTokens || 0, inputChunks);
+  const outputChunks = splitTokenCountByWeights(tokenUsage.outputTokens || 0, inputChunks);
+  tokenUsage.subSessions = inputChunks.map((inputTokens, index) => {
+    const cacheCreationTokens = cacheWriteChunks[index] || 0;
+    const outputTokens = outputChunks[index] || 0;
+    return {
+      inputTokens,
+      cacheCreationTokens,
+      cacheReadTokens: cacheReadChunks[index] || 0,
+      outputTokens,
+      messageCount: null,
+      peakContextUsage: getCumulativeContextInputTokens({ inputTokens, cacheCreationTokens }),
+      peakOutputUsage: outputTokens,
+      estimated: true,
+      source: 'codex.compact-diagnostics',
+      compactBoundaryBefore: index === 0 ? null : compactifications[index - 1] || null,
+    };
+  });
+};
+const recordCodexCompactification = (line, tokenUsage) => {
+  if (!isSuccessfulCodexCompactRequestLine(line)) return;
+  const timestamp = getCodexDiagnosticTimestamp(line);
+  const conversationId = getCodexDiagnosticValue(line, 'conversation.id');
+  const existing = tokenUsage.compactifications.find(compact => compact.timestamp === timestamp && compact.conversationId === conversationId);
+  if (existing) return;
+  tokenUsage.compactifications.push({
+    timestamp,
+    preTokens: null,
+    trigger: 'auto',
+    source: 'codex.responses.compact',
+    conversationId: conversationId || null,
+  });
+};
+export const parseCodexDiagnosticLine = (line, tokenUsage) => {
+  const contextLimit = getCodexDiagnosticInteger(line, 'context_window') ?? getCodexDiagnosticInteger(line, 'model_context_window');
+  if (contextLimit !== null) tokenUsage.contextLimit = contextLimit;
+
+  const autoCompactTokenLimit = getCodexDiagnosticInteger(line, 'auto_compact_token_limit') ?? getCodexDiagnosticInteger(line, 'model_auto_compact_token_limit');
+  if (autoCompactTokenLimit !== null) tokenUsage.autoCompactTokenLimit = autoCompactTokenLimit;
+  recordCodexCompactification(line, tokenUsage);
+};