@link-assistant/hive-mind 1.78.4 → 1.78.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- b3d6588: Remove Hive Mind's npm global prefix workaround now that use-m handles non-writable npm global roots upstream.
+
 ## 1.78.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.78.4",
+  "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;
         }

package/src/use-m-bootstrap.lib.mjs

@@ -1,21 +1,16 @@
 #!/usr/bin/env node
 
-import { ensureWritableNpmGlobalPrefix } from './npm-global-prefix.lib.mjs';
-
 const defaultFetchUseMCode = async () => (await fetch('https://unpkg.com/use-m/use.js')).text();
 
 /**
- * Load the use-m bootstrap after npm's global prefix has been made safe for
- * use-m's Node resolver.
+ * Load the shared use-m bootstrap.
  *
  * @param {object} [options]
- * @param {(message: string) => void} [options.log]
  * @param {() => Promise<string>} [options.fetchUseMCode]
  * @returns {Promise<Function>} The global use-m `use` function.
  */
 export const ensureUseM = async (options = {}) => {
-  const { log = message => console.log(message), fetchUseMCode = defaultFetchUseMCode } = options;
-  await ensureWritableNpmGlobalPrefix({ log });
+  const { fetchUseMCode = defaultFetchUseMCode } = options;
   if (typeof globalThis.use === 'undefined') {
     globalThis.use = (await eval(await fetchUseMCode())).use;
   }

package/src/npm-global-prefix.lib.mjs

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Ensure npm's global install directory is writable before `use-m` runs.
- *
- * Issue #1897: `use-m` loads runtime dependencies (command-stream, getenv,
- * yargs, …) by shelling out to `npm install -g <alias>@npm:<pkg>@latest`.
- * npm installs into the global prefix reported by `npm root -g`. When the
- * CLI is launched with a system-wide Node.js whose global `node_modules`
- * directory is owned by root (e.g. `/opt/node-v24.16.0-linux-x64/lib/node_modules`),
- * the install fails with `EACCES: permission denied` and the whole process
- * crashes at the very first `use()` call with an unhandled error:
- *
- *   Error: Failed to install command-stream@latest globally.
- *     ... npm error code EACCES
- *     ... npm error syscall rename
- *     ... npm error path /opt/node-.../lib/node_modules/command-stream-v-latest
- *
- * This commonly happens when the package was installed with one runtime
- * (e.g. `bun add -g`, which writes to a user-owned `~/.bun/...`) but launched
- * under a system Node whose global prefix needs root.
- *
- * The fix mirrors npm's own documented recommendation for EACCES errors:
- * point the global prefix at a user-writable directory. We detect the
- * non-writable prefix up front and redirect `npm_config_prefix` (which both
- * `npm install -g` and `npm root -g` honour) to `~/.npm-global`, so use-m's
- * install succeeds without sudo. When the prefix is already writable we do
- * nothing — the common case stays a no-op with no extra `npm` spawn.
- */
-
-import { access, mkdir } from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { homedir } from 'node:os';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-
-/**
- * Derive the likely global `node_modules` path from the Node binary location
- * without spawning npm. For a standard POSIX layout the node binary lives at
- * `<prefix>/bin/node` and global packages at `<prefix>/lib/node_modules`.
- *
- * @param {string} execPath - Absolute path to the running node binary.
- * @returns {string} Candidate global `node_modules` directory.
- */
-export const deriveGlobalNodeModules = execPath => join(dirname(dirname(execPath)), 'lib', 'node_modules');
-
-/**
- * Check whether a directory is writable, walking up to the nearest existing
- * ancestor when the leaf does not yet exist (npm would create it on install).
- *
- * @param {string} startDir - Directory to test.
- * @param {(path: string, mode: number) => Promise<void>} accessFn - fs.access.
- * @returns {Promise<boolean>}
- */
-export const isPathWritable = async (startDir, accessFn = access) => {
-  let current = startDir;
-  for (;;) {
-    try {
-      await accessFn(current, fsConstants.W_OK);
-      return true;
-    } catch (error) {
-      if (error && error.code === 'ENOENT') {
-        const parent = dirname(current);
-        if (parent === current) return false; // reached filesystem root
-        current = parent;
-        continue;
-      }
-      // EACCES / EPERM / anything else → treat as not writable.
-      return false;
-    }
-  }
-};
-
-const queryNpmRoot = async runner => {
-  try {
-    const { stdout } = await runner('npm root -g');
-    const value = String(stdout).trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Detect a non-writable npm global prefix and, if found, redirect global
- * installs to a user-writable directory by setting `npm_config_prefix`.
- *
- * Idempotent and dependency-injectable for tests. Returns an object describing
- * what happened: `{ changed: boolean, reason: string, prefix?, previousRoot? }`.
- *
- * @param {object} [options]
- * @param {Record<string, string>} [options.env=process.env] - Environment to mutate.
- * @param {string} [options.execPath=process.execPath] - Running node binary path.
- * @param {string} [options.platform=process.platform] - OS platform.
- * @param {string} [options.home] - User home directory.
- * @param {Function} [options.accessFn=fs.access]
- * @param {Function} [options.mkdirFn=fs.mkdir]
- * @param {Function} [options.runner=execAsync] - Runs a shell command, returns {stdout}.
- * @param {(message: string) => void} [options.log] - Informational logger.
- * @returns {Promise<{changed: boolean, reason: string, prefix?: string, previousRoot?: string, error?: Error}>}
- */
-export const ensureWritableNpmGlobalPrefix = async (options = {}) => {
-  const { env = process.env, execPath = process.execPath, platform = process.platform, home = homedir(), accessFn = access, mkdirFn = mkdir, runner = execAsync, log = () => {}, isBunRuntime = typeof Bun !== 'undefined', isDenoRuntime = typeof Deno !== 'undefined' } = options;
-
-  // Windows' global layout differs (`<prefix>/node_modules`, AppData), and the
-  // EACCES scenario this guards against is POSIX-specific. Skip to avoid false
-  // positives that would needlessly relocate the prefix.
-  if (platform === 'win32') return { changed: false, reason: 'win32' };
-
-  // This workaround only protects use-m's Node/npm resolver. Bun and Deno use
-  // different install paths and should not have npm configuration changed.
-  if (isBunRuntime) return { changed: false, reason: 'bun-runtime' };
-  if (isDenoRuntime) return { changed: false, reason: 'deno-runtime' };
-
-  // Respect an explicitly configured prefix — the user (or a parent process)
-  // already chose where global installs go.
-  if (env.npm_config_prefix || env.NPM_CONFIG_PREFIX) return { changed: false, reason: 'preset' };
-
-  // Fast path: derive the likely global node_modules from the node binary and
-  // check writability without spawning npm. Most installs land here.
-  const derived = deriveGlobalNodeModules(execPath);
-  if (await isPathWritable(derived, accessFn)) {
-    return { changed: false, reason: 'writable' };
-  }
-
-  // The cheap heuristic says non-writable. Confirm against the authoritative
-  // path npm/use-m actually use before changing anything (handles custom prefixes).
-  const authoritative = (await queryNpmRoot(runner)) || derived;
-  if (await isPathWritable(authoritative, accessFn)) {
-    return { changed: false, reason: 'writable' };
-  }
-
-  // Global prefix is genuinely not writable by the current user (issue #1897).
-  if (!home) {
-    return { changed: false, reason: 'no-home' };
-  }
-
-  const prefix = join(home, '.npm-global');
-  try {
-    // npm installs into `<prefix>/lib/node_modules`; create it so the very
-    // first `npm install -g` does not have to.
-    await mkdirFn(join(prefix, 'lib', 'node_modules'), { recursive: true });
-  } catch (error) {
-    return { changed: false, reason: 'mkdir-failed', error };
-  }
-
-  env.npm_config_prefix = prefix;
-  // Make globally-installed binaries from the new prefix resolvable too.
-  const binDir = join(prefix, 'bin');
-  const pathParts = String(env.PATH || '').split(':');
-  if (!pathParts.includes(binDir)) {
-    env.PATH = env.PATH ? `${binDir}:${env.PATH}` : binDir;
-  }
-
-  log(`ℹ️  npm global directory (${authoritative}) is not writable; redirecting global installs to ${prefix} (issue #1897).`);
-  return { changed: true, reason: 'redirected', prefix, previousRoot: authoritative };
-};