@link-assistant/hive-mind 1.78.5 → 1.78.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.78.6
+
+### Patch Changes
+
+- cf85feb: Fix Codex sub-session budget display by parsing compact diagnostics and preserving compact-derived sub-session rows.
+
 ## 1.78.5
 
 ### Patch Changes

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -548,10 +548,16 @@ export const buildCumulativeInputPhrase = ({ input, cacheWrites, cacheReads, for
  */
 const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
   let result = '';
+  let hasEstimatedRows = false;
   for (let i = 0; i < subSessions.length; i++) {
     const sub = subSessions[i];
+    if (sub.estimated) hasEstimatedRows = true;
     const subPeakContext = sub.peakContextUsage || 0;
-    result += formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `);
+    const line = formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `);
+    result += sub.estimated ? line.replace(`\n${i + 1}. `, `\n${i + 1}. ~`) : line;
+  }
+  if (hasEstimatedRows) {
+    result += '\n\n_Sub-session values are estimates from observed compact events; the Total line remains exact._';
   }
   return result;
 };
@@ -847,6 +853,7 @@ export const buildAgentBudgetStats = (tokenUsage, pricingInfo) => {
   const contextLimit = tokenUsage.contextLimit || pricingInfo?.modelInfo?.limit?.context || null;
   const outputLimit = tokenUsage.outputLimit || pricingInfo?.modelInfo?.limit?.output || null;
   const contextFillInputTokens = getExplicitContextFillInputTokens(tokenUsage) ?? getCumulativeContextInputTokens({ inputTokens, cacheWriteTokens });
+  const subSessions = Array.isArray(tokenUsage.subSessions) ? tokenUsage.subSessions : [];
 
   const modelUsageEntry = {
     inputTokens,
@@ -862,7 +869,8 @@ export const buildAgentBudgetStats = (tokenUsage, pricingInfo) => {
 
   return {
     modelUsage: { [modelId]: modelUsageEntry },
-    subSessions: [],
+    subSessions,
+    compactifications: Array.isArray(tokenUsage.compactifications) ? tokenUsage.compactifications : tokenUsage.compactifications || null,
     inputTokens,
     cacheCreationTokens: cacheWriteTokens,
     cacheReadTokens,

package/src/codex.lib.mjs

@@ -33,8 +33,9 @@ import { getCumulativeContextInputTokens } from './context-fill.lib.mjs';
 import { deployHandoffSkill } from './handoff-skill.lib.mjs'; // Issue #1877
 import Decimal from 'decimal.js-light';
 
-const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
+const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'reasoning_output_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
 const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
+const CODEX_COMPACT_API_ENDPOINT = '/responses/compact';
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -76,7 +77,139 @@ const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => has
 
 const CODEX_CACHE_READ_USAGE_PATHS = ['cached_input_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens'];
 const CODEX_CACHE_WRITE_USAGE_PATHS = ['cache_write_tokens', 'cache_creation_input_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens'];
-const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'output_tokens_details.reasoning_tokens'];
+const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'reasoning_output_tokens', 'output_tokens_details.reasoning_tokens'];
+
+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;
+  });
+};
+
+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,
+  });
+};
+
+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);
+};
 
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
@@ -90,8 +223,11 @@ export const createCodexTokenUsage = requestedModelId => ({
   respondedModelId: requestedModelId || null,
   contextLimit: null,
   outputLimit: null,
+  autoCompactTokenLimit: null,
   contextFillInputTokens: 0,
   peakContextUsage: 0,
+  subSessions: [],
+  compactifications: [],
   tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
@@ -285,12 +421,17 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
   };
 
   nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
+  if (!Array.isArray(nextState.tokenUsage.subSessions)) nextState.tokenUsage.subSessions = [];
+  if (!Array.isArray(nextState.tokenUsage.compactifications)) nextState.tokenUsage.compactifications = [];
+  nextState.tokenUsage.autoCompactTokenLimit ??= null;
   const observedModelPaths = new Set(nextState.observedModelDiagnosticPaths);
 
   for (const rawLine of output.split('\n')) {
     const line = rawLine.trim();
     if (!line) continue;
 
+    parseCodexDiagnosticLine(line, nextState.tokenUsage);
+
     let data;
     try {
       data = sanitizeObjectStrings(JSON.parse(line));
@@ -405,6 +546,7 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     }
   }
 
+  rebuildCodexSubSessionsFromCompactifications(nextState.tokenUsage);
   nextState.observedModelDiagnosticPaths = [...observedModelPaths];
   return nextState;
 };
@@ -901,6 +1043,7 @@ export const executeCodexCommand = async params => {
           if (errorOutput && argv.verbose) {
             await log(errorOutput, { stream: 'stderr' });
           }
+          codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel);
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
         }