@link-assistant/hive-mind 1.52.0 → 1.52.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.52.1
+
+### Patch Changes
+
+- d5d3762: Fix calculation bugs and format unification for budget stats using decimal.js-light for precision.
+
 ## 1.52.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.52.0",
+  "version": "1.52.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -70,6 +70,7 @@
     "@sentry/node": "^10.15.0",
     "@sentry/profiling-node": "^10.15.0",
     "dayjs": "^1.11.19",
+    "decimal.js-light": "^2.5.1",
     "secretlint": "^11.2.5",
     "semver": "^7.7.3"
   },

package/src/agent-token-usage.lib.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import Decimal from 'decimal.js-light';
+import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+
+export const createTokenFieldAvailability = () => ({
+  inputTokens: false,
+  outputTokens: false,
+  reasoningTokens: false,
+  cacheReadTokens: false,
+  cacheWriteTokens: false,
+});
+
+export const createAgentTokenUsage = () => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  reasoningTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  totalCost: 0,
+  stepCount: 0,
+  requestedModelId: null,
+  respondedModelId: null,
+  contextLimit: null,
+  outputLimit: null,
+  peakContextUsage: 0,
+  tokenFieldAvailability: createTokenFieldAvailability(),
+});
+
+const addObservedTokenValue = (usage, source, sourceFieldName, targetFieldName) => {
+  if (!source || !Object.hasOwn(source, sourceFieldName)) return;
+  usage.tokenFieldAvailability ||= createTokenFieldAvailability();
+  usage.tokenFieldAvailability[targetFieldName] = true;
+  const value = source[sourceFieldName];
+  if (Number.isFinite(value)) usage[targetFieldName] = (usage[targetFieldName] || 0) + value;
+};
+
+const getTokenCount = value => (Number.isFinite(value) ? value : 0);
+
+export const accumulateAgentStepFinishUsage = (usage, data) => {
+  if (!usage || data?.type !== 'step_finish' || !data.part?.tokens) return false;
+
+  const tokens = data.part.tokens;
+  usage.stepCount = (usage.stepCount || 0) + 1;
+  usage.tokenFieldAvailability ||= createTokenFieldAvailability();
+
+  addObservedTokenValue(usage, tokens, 'input', 'inputTokens');
+  addObservedTokenValue(usage, tokens, 'output', 'outputTokens');
+  addObservedTokenValue(usage, tokens, 'reasoning', 'reasoningTokens');
+  if (tokens.cache) {
+    addObservedTokenValue(usage, tokens.cache, 'read', 'cacheReadTokens');
+    addObservedTokenValue(usage, tokens.cache, 'write', 'cacheWriteTokens');
+  }
+
+  if (Number.isFinite(data.part.cost)) {
+    usage.totalCost = new Decimal(usage.totalCost || 0).plus(data.part.cost).toNumber();
+  }
+
+  if (data.part.model) {
+    if (data.part.model.requestedModelID) usage.requestedModelId = data.part.model.requestedModelID;
+    if (data.part.model.respondedModelID) usage.respondedModelId = data.part.model.respondedModelID;
+  }
+
+  if (data.part.context) {
+    if (data.part.context.contextLimit) usage.contextLimit = data.part.context.contextLimit;
+    if (data.part.context.outputLimit) usage.outputLimit = data.part.context.outputLimit;
+    const stepContextUsage = getTokenCount(tokens.input) + getTokenCount(tokens.cache?.read);
+    if (stepContextUsage > (usage.peakContextUsage || 0)) {
+      usage.peakContextUsage = stepContextUsage;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Parse Agent/OpenCode NDJSON output to extract token usage from step_finish events.
+ * @param {string} output - Raw JSONL output from the command
+ * @returns {Object} Aggregated token usage and cost data
+ */
+export const parseAgentTokenUsage = output => {
+  const usage = createAgentTokenUsage();
+
+  for (const rawLine of output.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || !line.startsWith('{')) continue;
+
+    try {
+      accumulateAgentStepFinishUsage(usage, sanitizeObjectStrings(JSON.parse(line)));
+    } catch {
+      continue;
+    }
+  }
+
+  return usage;
+};

package/src/agent.lib.mjs

@@ -18,93 +18,17 @@ import { reportError } from './sentry.lib.mjs';
 import { timeouts } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import Decimal from 'decimal.js-light';
 import { agentModels, defaultModels, freeToBaseModelMap } from './models/index.mjs';
+import { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage } from './agent-token-usage.lib.mjs';
+
+export { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage };
 
 // Import pricing functions from claude.lib.mjs
 // We reuse fetchModelInfo and checkModelVisionCapability to get data from models.dev API
 const claudeLib = await import('./claude.lib.mjs');
 const { fetchModelInfo, checkModelVisionCapability } = claudeLib;
 
-/**
- * Parse agent JSON output to extract token usage from step_finish events
- * Agent outputs NDJSON (newline-delimited JSON) with step_finish events containing token data
- * @param {string} output - Raw stdout output from agent command
- * @returns {Object} Aggregated token usage and cost data
- */
-export const parseAgentTokenUsage = output => {
-  const usage = {
-    inputTokens: 0,
-    outputTokens: 0,
-    reasoningTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    totalCost: 0,
-    stepCount: 0,
-    // Issue #1526: Track model and context info from step_finish events
-    requestedModelId: null,
-    respondedModelId: null,
-    contextLimit: null,
-    outputLimit: null,
-    peakContextUsage: 0, // Track peak context usage across steps
-  };
-
-  // Try to parse each line as JSON (agent outputs NDJSON format)
-  const lines = output.split('\n');
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine || !trimmedLine.startsWith('{')) continue;
-
-    try {
-      const parsed = sanitizeObjectStrings(JSON.parse(trimmedLine));
-
-      // Look for step_finish events which contain token usage
-      if (parsed.type === 'step_finish' && parsed.part?.tokens) {
-        const tokens = parsed.part.tokens;
-        usage.stepCount++;
-
-        // Add token counts
-        if (tokens.input) usage.inputTokens += tokens.input;
-        if (tokens.output) usage.outputTokens += tokens.output;
-        if (tokens.reasoning) usage.reasoningTokens += tokens.reasoning;
-
-        // Handle cache tokens (can be in different formats)
-        if (tokens.cache) {
-          if (tokens.cache.read) usage.cacheReadTokens += tokens.cache.read;
-          if (tokens.cache.write) usage.cacheWriteTokens += tokens.cache.write;
-        }
-
-        // Add cost from step_finish (usually 0 for free models like grok-code)
-        if (parsed.part.cost !== undefined) {
-          usage.totalCost += parsed.part.cost;
-        }
-
-        // Issue #1526: Extract model info from step_finish events
-        if (parsed.part.model) {
-          if (parsed.part.model.requestedModelID) usage.requestedModelId = parsed.part.model.requestedModelID;
-          if (parsed.part.model.respondedModelID) usage.respondedModelId = parsed.part.model.respondedModelID;
-        }
-
-        // Issue #1526: Extract context limits and track peak context usage
-        if (parsed.part.context) {
-          if (parsed.part.context.contextLimit) usage.contextLimit = parsed.part.context.contextLimit;
-          if (parsed.part.context.outputLimit) usage.outputLimit = parsed.part.context.outputLimit;
-          // Track peak context usage: input_tokens (current request) is the context usage for this step
-          // The actual context used per request = input tokens + cache_read tokens for that request
-          const stepContextUsage = (tokens.input || 0) + (tokens.cache?.read || 0);
-          if (stepContextUsage > usage.peakContextUsage) {
-            usage.peakContextUsage = stepContextUsage;
-          }
-        }
-      }
-    } catch {
-      // Skip lines that aren't valid JSON
-      continue;
-    }
-  }
-
-  return usage;
-};
-
 /**
  * Helper function to get original provider name from provider identifier
  * Used for calculating public pricing estimates based on original provider prices
@@ -221,13 +145,29 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
       // Calculate public pricing estimate based on original provider prices
       // Prices are per 1M tokens, so divide by 1,000,000
       // All priced components from models.dev: input, output, cache_read, cache_write, reasoning
-      const inputCost = (tokenUsage.inputTokens * (cost.input || 0)) / 1_000_000;
-      const outputCost = (tokenUsage.outputTokens * (cost.output || 0)) / 1_000_000;
-      const cacheReadCost = (tokenUsage.cacheReadTokens * (cost.cache_read || 0)) / 1_000_000;
-      const cacheWriteCost = (tokenUsage.cacheWriteTokens * (cost.cache_write || 0)) / 1_000_000;
-      const reasoningCost = (tokenUsage.reasoningTokens * (cost.reasoning || 0)) / 1_000_000;
-
-      const totalCost = inputCost + outputCost + cacheReadCost + cacheWriteCost + reasoningCost;
+      const million = new Decimal(1_000_000);
+      const inputCost = new Decimal(tokenUsage.inputTokens)
+        .mul(cost.input || 0)
+        .div(million)
+        .toNumber();
+      const outputCost = new Decimal(tokenUsage.outputTokens)
+        .mul(cost.output || 0)
+        .div(million)
+        .toNumber();
+      const cacheReadCost = new Decimal(tokenUsage.cacheReadTokens)
+        .mul(cost.cache_read || 0)
+        .div(million)
+        .toNumber();
+      const cacheWriteCost = new Decimal(tokenUsage.cacheWriteTokens)
+        .mul(cost.cache_write || 0)
+        .div(million)
+        .toNumber();
+      const reasoningCost = new Decimal(tokenUsage.reasoningTokens)
+        .mul(cost.reasoning || 0)
+        .div(million)
+        .toNumber();
+
+      const totalCost = new Decimal(inputCost).plus(outputCost).plus(cacheReadCost).plus(cacheWriteCost).plus(reasoningCost).toNumber();
 
       // Determine if this is a free model from OpenCode Zen or Kilo Gateway
       // Models accessed via OpenCode Zen or Kilo Gateway are free, regardless of original provider pricing
@@ -576,52 +516,8 @@ export const executeAgentCommand = async params => {
       let agentCompletedSuccessfully = false;
       // Issue #1250: Accumulate token usage during streaming instead of parsing fullOutput later
       // This fixes the issue where NDJSON lines get concatenated without newlines, breaking JSON.parse
-      const streamingTokenUsage = {
-        inputTokens: 0,
-        outputTokens: 0,
-        reasoningTokens: 0,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-        totalCost: 0,
-        stepCount: 0,
-        // Issue #1526: Track model and context info from step_finish events
-        requestedModelId: null,
-        respondedModelId: null,
-        contextLimit: null,
-        outputLimit: null,
-        peakContextUsage: 0,
-      };
-      // Helper to accumulate tokens from step_finish events during streaming
-      const accumulateTokenUsage = data => {
-        if (data.type === 'step_finish' && data.part?.tokens) {
-          const tokens = data.part.tokens;
-          streamingTokenUsage.stepCount++;
-          if (tokens.input) streamingTokenUsage.inputTokens += tokens.input;
-          if (tokens.output) streamingTokenUsage.outputTokens += tokens.output;
-          if (tokens.reasoning) streamingTokenUsage.reasoningTokens += tokens.reasoning;
-          if (tokens.cache) {
-            if (tokens.cache.read) streamingTokenUsage.cacheReadTokens += tokens.cache.read;
-            if (tokens.cache.write) streamingTokenUsage.cacheWriteTokens += tokens.cache.write;
-          }
-          if (data.part.cost !== undefined) {
-            streamingTokenUsage.totalCost += data.part.cost;
-          }
-          // Issue #1526: Extract model info from step_finish events
-          if (data.part.model) {
-            if (data.part.model.requestedModelID) streamingTokenUsage.requestedModelId = data.part.model.requestedModelID;
-            if (data.part.model.respondedModelID) streamingTokenUsage.respondedModelId = data.part.model.respondedModelID;
-          }
-          // Issue #1526: Extract context limits and track peak context usage
-          if (data.part.context) {
-            if (data.part.context.contextLimit) streamingTokenUsage.contextLimit = data.part.context.contextLimit;
-            if (data.part.context.outputLimit) streamingTokenUsage.outputLimit = data.part.context.outputLimit;
-            const stepContextUsage = (tokens.input || 0) + (tokens.cache?.read || 0);
-            if (stepContextUsage > streamingTokenUsage.peakContextUsage) {
-              streamingTokenUsage.peakContextUsage = stepContextUsage;
-            }
-          }
-        }
-      };
+      const streamingTokenUsage = createAgentTokenUsage();
+      const accumulateTokenUsage = data => accumulateAgentStepFinishUsage(streamingTokenUsage, data);
 
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
@@ -980,8 +876,10 @@ export const executeAgentCommand = async params => {
         if (tokenUsage.reasoningTokens > 0) {
           await log(`      Reasoning tokens: ${tokenUsage.reasoningTokens.toLocaleString()}`);
         }
-        if (tokenUsage.cacheReadTokens > 0 || tokenUsage.cacheWriteTokens > 0) {
+        if (tokenUsage.cacheReadTokens > 0 || tokenUsage.tokenFieldAvailability?.cacheReadTokens) {
           await log(`      Cache read:       ${tokenUsage.cacheReadTokens.toLocaleString()}`);
+        }
+        if (tokenUsage.cacheWriteTokens > 0 || tokenUsage.tokenFieldAvailability?.cacheWriteTokens) {
           await log(`      Cache write:      ${tokenUsage.cacheWriteTokens.toLocaleString()}`);
         }
 

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

@@ -3,6 +3,7 @@
 // Extracted from claude.lib.mjs to maintain file line limits
 
 import { formatNumber } from './claude.lib.mjs';
+import Decimal from 'decimal.js-light';
 
 /**
  * Helper: creates a fresh sub-session usage object for tracking tokens between compactification events
@@ -105,11 +106,11 @@ export const displayModelUsage = async (usage, log) => {
     ];
     for (const { key, label } of types) {
       if (breakdown[key].tokens > 0) {
-        await log(`        ${label}: ${formatNumber(breakdown[key].tokens)} tokens × $${breakdown[key].costPerMillion}/M = $${breakdown[key].cost.toFixed(6)}`);
+        await log(`        ${label}: ${formatNumber(breakdown[key].tokens)} tokens × $${breakdown[key].costPerMillion}/M = $${new Decimal(breakdown[key].cost).toFixed(6)}`);
       }
     }
     await log('        ─────────────────────────────────');
-    await log(`        Total: $${usage.costUSD.toFixed(6)}`);
+    await log(`        Total: $${new Decimal(usage.costUSD).toFixed(6)}`);
   } else if (usage.modelInfo === null) {
     await log('');
     await log('      Cost: Not available (could not fetch pricing)');
@@ -126,18 +127,19 @@ export const displayModelUsage = async (usage, log) => {
 export const displayCostComparison = async (publicCost, anthropicCost, log) => {
   const hasPublic = publicCost !== null && publicCost !== undefined;
   const hasAnthropic = anthropicCost !== null && anthropicCost !== undefined;
-  // Issue #1557: When both costs match, show simplified format
-  if (hasPublic && hasAnthropic && publicCost.toFixed(6) === anthropicCost.toFixed(6)) {
-    await log(`\n   💰 Cost: $${anthropicCost.toFixed(6)}`);
+  const publicDec = hasPublic ? new Decimal(publicCost) : null;
+  const anthropicDec = hasAnthropic ? new Decimal(anthropicCost) : null;
+  if (publicDec && anthropicDec && publicDec.toFixed(6) === anthropicDec.toFixed(6)) {
+    await log(`\n   💰 Cost: $${anthropicDec.toFixed(6)}`);
     return;
   }
   await log('\n   💰 Cost estimation:');
-  await log(`      Public pricing estimate: ${hasPublic ? `$${publicCost.toFixed(6)}` : 'unknown'}`);
-  await log(`      Calculated by Anthropic: ${hasAnthropic ? `$${anthropicCost.toFixed(6)}` : 'unknown'}`);
-  if (hasPublic && hasAnthropic) {
-    const difference = anthropicCost - publicCost;
-    const percentDiff = publicCost > 0 ? (difference / publicCost) * 100 : 0;
-    await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff > 0 ? '+' : ''}${percentDiff.toFixed(2)}%)`);
+  await log(`      Public pricing estimate: ${publicDec ? `$${publicDec.toFixed(6)}` : 'unknown'}`);
+  await log(`      Calculated by Anthropic: ${anthropicDec ? `$${anthropicDec.toFixed(6)}` : 'unknown'}`);
+  if (publicDec && anthropicDec) {
+    const difference = anthropicDec.minus(publicDec);
+    const percentDiff = publicDec.gt(0) ? difference.div(publicDec).mul(100) : new Decimal(0);
+    await log(`      Difference:              $${difference.toFixed(6)} (${percentDiff.gt(0) ? '+' : ''}${percentDiff.toFixed(2)}%)`);
   } else {
     await log('      Difference:              unknown');
   }
@@ -169,11 +171,10 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const peakContext = usage.peakContextUsage || 0;
 
   if (hasMultipleSubSessions) {
+    // Issue #1600: Unified format — numbered list without "Context window:" prefix
     for (let i = 0; i < subSessions.length; i++) {
       const sub = subSessions[i];
       const subPeak = sub.peakContextUsage || 0;
-      // Issue #1539: Only use peak per-request context for context window display.
-      // Issue #1547: Percentage before unit label: X / Y (Z%) input tokens
       const parts = [];
       if (contextLimit && subPeak > 0) {
         const pct = ((subPeak / contextLimit) * 100).toFixed(0);
@@ -184,12 +185,10 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
         parts.push(`${formatNumber(sub.outputTokens)} / ${formatNumber(outputLimit)} (${outPct}%) output tokens`);
       }
       if (parts.length > 0) {
-        await log(`        ${i + 1}. Context window: ${parts.join(', ')}`);
+        await log(`        ${i + 1}. ${parts.join(', ')}`);
       }
     }
   } else if (peakContext > 0) {
-    // Single sub-session with known peak: single-line format
-    // Issue #1547: Percentage before unit label
     const parts = [];
     if (contextLimit) {
       const pct = ((peakContext / contextLimit) * 100).toFixed(0);
@@ -200,11 +199,9 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
       parts.push(`${formatNumber(usage.outputTokens)} / ${formatNumber(outputLimit)} (${outPct}%) output tokens`);
     }
     if (parts.length > 0) {
-      await log(`        Context window: ${parts.join(', ')}`);
+      await log(`        - ${parts.join(', ')}`);
     }
   }
-  // Issue #1539: When peakContextUsage is unknown, skip context window line entirely.
-  // Cumulative totals are shown on the Total line below — no duplication needed.
 
   // Cumulative totals — single line
   // Issue #1547: Parenthesized cached format and consistent output format
@@ -303,14 +300,13 @@ const formatTokensCompact = tokens => {
  * @returns {string} Formatted sub-sessions string
  */
 /**
- * Issue #1526: Format sub-sessions list using numbered single-line format.
- * Each sub-session gets: "N. Context window: X / Y input tokens (Z%), A / B output tokens (W%)"
+ * Issue #1600: Format sub-sessions list using numbered single-line format.
+ * Each sub-session gets: "N. X / Y (Z%) input tokens, A / B (W%) output tokens"
  */
 const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
   let result = '';
   for (let i = 0; i < subSessions.length; i++) {
     const sub = subSessions[i];
-    // Issue #1539: Only use peak per-request context; skip context display when unknown
     const subPeakContext = sub.peakContextUsage || 0;
     result += formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `);
   }
@@ -318,10 +314,7 @@ const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
 };
 
 /**
- * Issue #1526: Build a single-line context window + output tokens string.
- * Issue #1539: Only show context window when peakContext > 0 (per-request peak known).
- * When peakContext is 0 (unknown), context part is omitted to avoid misleading percentages.
- * Format: "- Context window: X / Y input tokens (Z%), A / B output tokens (W%)"
+ * Issue #1600: Build a single-line context + output tokens string (unified format, no "Context window:" prefix).
  * @param {number} peakContext - Peak context usage (0 if unknown — context display skipped)
  * @param {number} contextLimit - Context window limit (null if unknown)
  * @param {number} outputTokens - Output tokens used
@@ -331,22 +324,16 @@ const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
  */
 const formatContextOutputLine = (peakContext, contextLimit, outputTokens, outputLimit, prefix = '- ') => {
   const parts = [];
-  if (contextLimit) {
-    // Issue #1539: Only use peak per-request context for context window display.
-    // When peak is unknown (e.g., model only from result JSON, not in JSONL),
-    // skip context display. Cumulative totals across all requests are not valid
-    // context window metrics and produce impossible percentages (e.g. 250%).
-    if (peakContext > 0) {
-      const pct = ((peakContext / contextLimit) * 100).toFixed(0);
-      parts.push(`${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} (${pct}%) input tokens`);
-    }
+  if (contextLimit && peakContext > 0) {
+    const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+    parts.push(`${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} (${pct}%) input tokens`);
   }
   if (outputLimit) {
     const outPct = ((outputTokens / outputLimit) * 100).toFixed(0);
     parts.push(`${formatTokensCompact(outputTokens)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`);
   }
   if (parts.length === 0) return '';
-  return `\n${prefix}Context window: ${parts.join(', ')}`;
+  return `\n${prefix}${parts.join(', ')}`;
 };
 
 /**
@@ -445,31 +432,37 @@ export const buildBudgetStatsString = (tokenUsage, subAgentCalls = null) => {
 
       // Issue #1590: Check if this model was used as a sub-agent
       const callCount = getSubAgentCallCount(modelId, subAgentCallCounts);
+      const isPrimaryModel = !isMultiModel || modelId === modelIds[0];
+      const showSubSessions = hasMultipleSubSessions && isPrimaryModel;
 
       if (isMultiModel) {
         // Issue #1590: Show sub-agent call count alongside model name
+        // Issue #1600: Show session segment count for primary model
         if (callCount > 1) {
           stats += `\n\n**${modelName}:** (${callCount} sub-agent calls)`;
+        } else if (showSubSessions) {
+          stats += `\n\n**${modelName}:** (${subSessions.length} session segments)`;
         } else {
           stats += `\n\n**${modelName}:**`;
         }
+      } else if (showSubSessions) {
+        stats += `\n\n**${modelName}:** (${subSessions.length} session segments)`;
       }
 
       const peakContext = usage.peakContextUsage || 0;
 
-      if (hasMultipleSubSessions && (!isMultiModel || modelId === modelIds[0])) {
-        // Issue #1547: Show sub-sessions under the primary model heading (not globally).
-        // For single-model sessions, show under that model. For multi-model, under the first model.
+      if (showSubSessions) {
+        // Issue #1600: Unified format — no "Context window:" prefix, same format as sub-agent calls
         stats += formatSubSessionsList(subSessions, contextLimit, outputLimit);
       } else if (peakContext > 0) {
-        // Issue #1526: Single line format for context window + output tokens
         stats += formatContextOutputLine(peakContext, contextLimit, usage.outputTokens, outputLimit, '- ');
+      } else if (outputLimit && callCount <= 1) {
+        // Issue #1600: Show output-only detalization for sub-agent single sessions
+        const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+        stats += `\n- ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`;
       }
-      // Issue #1539: When peakContextUsage is unknown, skip context window line entirely.
-      // Cumulative totals are shown on the Total line below — no duplication needed.
 
       // Cumulative totals per model: input tokens + cached shown separately
-      // Issue #1547: Parenthesized cached format: (X + Y cached) input tokens
       const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
       const cachedTokens = usage.cacheReadTokens;
       let totalLine;
@@ -479,36 +472,25 @@ export const buildBudgetStatsString = (tokenUsage, subAgentCalls = null) => {
         totalLine = `${formatTokensCompact(totalInputNonCached)} input tokens`;
       }
 
-      // Issue #1547: Consistent output format — use X / Y (Z%) output tokens when limit known
-      // Issue #1590: When multiple sub-agent calls exist, show total output without misleading
-      // per-call percentage (e.g., 530% is sum across 12 calls, not a single call)
-      if (peakContext === 0 && outputLimit) {
-        if (callCount > 1) {
-          // Show total output without percentage (percentage is misleading for aggregated sub-agent calls)
-          totalLine += `, ${formatTokensCompact(usage.outputTokens)} output tokens`;
-        } else {
-          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
-          totalLine += `, ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} (${outPct}%) output tokens`;
-        }
+      // Issue #1600: Output tokens on Total line — skip percentage if already shown above or aggregated
+      if (callCount > 1) {
+        totalLine += `, ${formatTokensCompact(usage.outputTokens)} output tokens`;
       } else {
         totalLine += `, ${formatTokensCompact(usage.outputTokens)} output tokens`;
       }
 
-      // Issue #1508: Show per-model cost when available
+      // Issue #1600: Use Decimal for cost display precision
       if (usage.costUSD !== null && usage.costUSD !== undefined) {
-        totalLine += `, $${usage.costUSD.toFixed(6)} cost`;
+        totalLine += `, $${new Decimal(usage.costUSD).toFixed(6)} cost`;
       }
 
       // Issue #1590: Show individual sub-agent call list when multiple calls exist
-      // Total line appears AFTER the sub-agent calls list (not before)
       if (callCount > 1) {
         const matchingCalls = getSubAgentCallsForModel(modelId, validSubAgentCalls);
-        // Issue #1590: Check if actual per-call usage data is available from parent_tool_use_id tracking
         const hasActualUsage = matchingCalls.some(c => c.usage && (c.usage.inputTokens > 0 || c.usage.outputTokens > 0 || c.usage.cacheReadTokens > 0 || c.usage.cacheCreationTokens > 0));
 
         stats += `\n\nSub-agent calls:`;
         if (hasActualUsage) {
-          // Show actual per-call usage with limits and percentages (same format as sub-sessions)
           for (let i = 0; i < matchingCalls.length; i++) {
             const call = matchingCalls[i];
             const cu = call.usage || {};
@@ -530,7 +512,6 @@ export const buildBudgetStatsString = (tokenUsage, subAgentCalls = null) => {
             stats += `\n${i + 1}. ${parts.join(', ')}`;
           }
         } else {
-          // Fallback: show estimates with limits and percentages when actual per-call data is not available
           const avgInput = Math.round((totalInputNonCached + cachedTokens) / callCount);
           const avgOutput = Math.round(usage.outputTokens / callCount);
           for (let i = 0; i < matchingCalls.length; i++) {
@@ -549,7 +530,6 @@ export const buildBudgetStatsString = (tokenUsage, subAgentCalls = null) => {
             }
             stats += `\n${i + 1}. ${parts.join(', ')}`;
           }
-          // Note about estimates only when using fallback
           stats += `\n\n_Per-call values are estimates (total ÷ ${callCount}). Exact per-call breakdown requires [upstream support](https://github.com/anthropics/claude-code/issues/46520)._`;
         }
       }

package/src/claude.lib.mjs

@@ -13,6 +13,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import Decimal from 'decimal.js-light';
 import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
@@ -429,51 +430,48 @@ export const checkModelVisionCapability = async modelId => {
     return false;
   }
 };
-/** Calculate USD cost for a model's usage with detailed breakdown */
+/** Calculate USD cost for a model's usage with detailed breakdown (Issue #1600: uses Decimal for precision) */
 export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) => {
   if (!modelInfo || !modelInfo.cost) {
     return includeBreakdown ? { total: 0, breakdown: null } : 0;
   }
   const cost = modelInfo.cost;
+  const million = new Decimal(1000000);
   const breakdown = {
     input: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheWrite: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheRead: { tokens: 0, costPerMillion: 0, cost: 0 },
     output: { tokens: 0, costPerMillion: 0, cost: 0 },
   };
-  // Input tokens cost (per million tokens)
   if (usage.inputTokens && cost.input) {
     breakdown.input = {
       tokens: usage.inputTokens,
       costPerMillion: cost.input,
-      cost: (usage.inputTokens / 1000000) * cost.input,
+      cost: new Decimal(usage.inputTokens).div(million).mul(new Decimal(cost.input)).toNumber(),
     };
   }
-  // Cache creation tokens cost
   if (usage.cacheCreationTokens && cost.cache_write) {
     breakdown.cacheWrite = {
       tokens: usage.cacheCreationTokens,
       costPerMillion: cost.cache_write,
-      cost: (usage.cacheCreationTokens / 1000000) * cost.cache_write,
+      cost: new Decimal(usage.cacheCreationTokens).div(million).mul(new Decimal(cost.cache_write)).toNumber(),
     };
   }
-  // Cache read tokens cost
   if (usage.cacheReadTokens && cost.cache_read) {
     breakdown.cacheRead = {
       tokens: usage.cacheReadTokens,
       costPerMillion: cost.cache_read,
-      cost: (usage.cacheReadTokens / 1000000) * cost.cache_read,
+      cost: new Decimal(usage.cacheReadTokens).div(million).mul(new Decimal(cost.cache_read)).toNumber(),
     };
   }
-  // Output tokens cost
   if (usage.outputTokens && cost.output) {
     breakdown.output = {
       tokens: usage.outputTokens,
       costPerMillion: cost.output,
-      cost: (usage.outputTokens / 1000000) * cost.output,
+      cost: new Decimal(usage.outputTokens).div(million).mul(new Decimal(cost.output)).toNumber(),
     };
   }
-  const totalCost = breakdown.input.cost + breakdown.cacheWrite.cost + breakdown.cacheRead.cost + breakdown.output.cost;
+  const totalCost = new Decimal(breakdown.input.cost).plus(breakdown.cacheWrite.cost).plus(breakdown.cacheRead.cost).plus(breakdown.output.cost).toNumber();
   if (includeBreakdown) {
     return {
       total: totalCost,
@@ -619,7 +617,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
     let totalCacheCreationTokens = 0;
     let totalCacheReadTokens = 0;
     let totalOutputTokens = 0;
-    let totalCostUSD = 0;
+    let totalCostDecimal = new Decimal(0);
     let hasCostData = false;
     for (const usage of Object.values(modelUsage)) {
       totalInputTokens += usage.inputTokens;
@@ -627,7 +625,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       totalCacheReadTokens += usage.cacheReadTokens;
       totalOutputTokens += usage.outputTokens;
       if (usage.costUSD !== null) {
-        totalCostUSD += usage.costUSD;
+        totalCostDecimal = totalCostDecimal.plus(new Decimal(usage.costUSD));
         hasCostData = true;
       }
     }
@@ -642,7 +640,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       cacheReadTokens: totalCacheReadTokens,
       outputTokens: totalOutputTokens,
       totalTokens,
-      totalCostUSD: hasCostData ? totalCostUSD : null,
+      totalCostUSD: hasCostData ? totalCostDecimal.toNumber() : null,
       // Issue #1501: Peak context usage (max single-request fill) and dedup stats
       peakContextUsage: globalPeakContext,
       duplicateEntriesSkipped: duplicateCount,

package/src/codex.lib.mjs

@@ -22,7 +22,7 @@ import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.m
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 
-const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens'];
+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 getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -32,6 +32,40 @@ const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['message.model', data => data?.message?.model],
 ];
 
+const createCodexTokenFieldAvailability = () => ({
+  inputTokens: false,
+  outputTokens: false,
+  reasoningTokens: false,
+  cacheReadTokens: false,
+  cacheWriteTokens: false,
+});
+
+const hasOwnPath = (object, pathName) => {
+  let cursor = object;
+  for (const part of pathName.split('.')) {
+    if (!cursor || typeof cursor !== 'object' || !Object.hasOwn(cursor, part)) return false;
+    cursor = cursor[part];
+  }
+  return true;
+};
+
+const getPathValue = (object, pathName) => pathName.split('.').reduce((cursor, part) => cursor?.[part], object);
+
+const getFirstObservedNumber = (object, pathNames) => {
+  for (const pathName of pathNames) {
+    if (!hasOwnPath(object, pathName)) continue;
+    const value = getPathValue(object, pathName);
+    return Number.isFinite(value) ? value : 0;
+  }
+  return 0;
+};
+
+const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => hasOwnPath(object, pathName));
+
+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'];
+
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
   outputTokens: 0,
@@ -42,6 +76,7 @@ export const createCodexTokenUsage = requestedModelId => ({
   stepCount: 0,
   requestedModelId: requestedModelId || null,
   respondedModelId: requestedModelId || null,
+  tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
 const createEmptyCodexItemUsage = () => ({
@@ -162,6 +197,7 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     observedModelDiagnosticPaths: state.observedModelDiagnosticPaths || [],
   };
 
+  nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
   const observedModelPaths = new Set(nextState.observedModelDiagnosticPaths);
 
   for (const rawLine of output.split('\n')) {
@@ -205,17 +241,28 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     }
 
     if (eventType === 'turn.completed' && data.usage && typeof data.usage === 'object') {
-      const inputTokens = Number.isFinite(data.usage.input_tokens) ? data.usage.input_tokens : 0;
-      const cachedInputTokens = Number.isFinite(data.usage.cached_input_tokens) ? data.usage.cached_input_tokens : 0;
-      const outputTokens = Number.isFinite(data.usage.output_tokens) ? data.usage.output_tokens : 0;
+      const inputTokens = getFirstObservedNumber(data.usage, ['input_tokens']);
+      const cachedInputTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_READ_USAGE_PATHS);
+      const cacheWriteTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS);
+      const outputTokens = getFirstObservedNumber(data.usage, ['output_tokens']);
+      const reasoningTokens = getFirstObservedNumber(data.usage, CODEX_REASONING_USAGE_PATHS);
+
+      if (hasOwnPath(data.usage, 'input_tokens')) nextState.tokenUsage.tokenFieldAvailability.inputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_READ_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheReadTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheWriteTokens = true;
+      if (hasOwnPath(data.usage, 'output_tokens')) nextState.tokenUsage.tokenFieldAvailability.outputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_REASONING_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.reasoningTokens = true;
+
       const nonCachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
       nextState.tokenUsage.inputTokens += nonCachedInputTokens;
       nextState.tokenUsage.cacheReadTokens += cachedInputTokens;
+      nextState.tokenUsage.cacheWriteTokens += cacheWriteTokens;
       nextState.tokenUsage.outputTokens += outputTokens;
+      nextState.tokenUsage.reasoningTokens += reasoningTokens;
       nextState.tokenUsage.totalTokens = nextState.tokenUsage.inputTokens + nextState.tokenUsage.cacheReadTokens + nextState.tokenUsage.outputTokens + nextState.tokenUsage.cacheWriteTokens;
       nextState.tokenUsage.stepCount += 1;
 
-      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => Object.hasOwn(data.usage, fieldName));
+      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => hasOwnPath(data.usage, fieldName));
       if (usageFieldSet.length > 0) nextState.observedUsageFieldSets.push(usageFieldSet);
     }
 

package/src/github-cost-info.lib.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import Decimal from 'decimal.js-light';
+
+const formatTokenCount = value => (Number.isFinite(value) ? value : 0).toLocaleString();
+
+const isObservedTokenField = (usage, fieldName) => {
+  const value = usage?.[fieldName];
+  if (Number.isFinite(value) && value > 0) return true;
+  if (usage?.tokenFieldAvailability?.[fieldName] === true) return true;
+  if (Array.isArray(usage?.availableTokenFields) && usage.availableTokenFields.includes(fieldName)) return true;
+  return false;
+};
+
+const buildTokenUsageString = tokenUsage => {
+  const parts = [`${formatTokenCount(tokenUsage.inputTokens)} input`, `${formatTokenCount(tokenUsage.outputTokens)} output`];
+  if (isObservedTokenField(tokenUsage, 'reasoningTokens')) parts.push(`${formatTokenCount(tokenUsage.reasoningTokens)} reasoning`);
+  if (isObservedTokenField(tokenUsage, 'cacheReadTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheReadTokens)} cache read`);
+  if (isObservedTokenField(tokenUsage, 'cacheWriteTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheWriteTokens)} cache write`);
+  return `\n- Token usage: ${parts.join(', ')}`;
+};
+
+/** Build cost estimation string for log comments (Issue #1250, Issue #1557, Issue #1600: Decimal precision) */
+export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
+  const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
+  const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
+  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
+  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
+  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
+  const publicDec = hasPublic ? new Decimal(totalCostUSD) : null;
+  const anthropicDec = hasAnthropic ? new Decimal(anthropicTotalCostUSD) : null;
+  if (publicDec && anthropicDec && publicDec.toFixed(6) === anthropicDec.toFixed(6)) return `\n\n### 💰 Cost: **$${anthropicDec.toFixed(6)}**`;
+  let costInfo = '\n\n### 💰 **Cost estimation:**';
+  if (pricingInfo?.modelName) {
+    costInfo += `\n- Model: ${pricingInfo.modelName}`;
+    if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
+  }
+  if (hasPublic) {
+    if (pricingInfo?.isFreeModel && publicDec.eq(0) && !pricingInfo?.baseModelName) {
+      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
+    } else {
+      let pricingRef = '';
+      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
+      } else if (pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
+      }
+      costInfo += `\n- Public pricing estimate: $${publicDec.toFixed(6)}${pricingRef}`;
+    }
+  } else if (hasPricing) {
+    costInfo += '\n- Public pricing estimate: unknown';
+  }
+  if (hasOpencodeCost) {
+    if (pricingInfo.isOpencodeFreeModel) {
+      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
+    } else {
+      costInfo += `\n- Calculated by OpenCode Zen: $${new Decimal(pricingInfo.opencodeCost).toFixed(6)}`;
+    }
+  }
+  if (pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
+  if (hasAnthropic) {
+    costInfo += `\n- Calculated by Anthropic: $${anthropicDec.toFixed(6)}`;
+    if (hasPublic) {
+      const diff = anthropicDec.minus(publicDec);
+      const pct = publicDec.gt(0) ? diff.div(publicDec).mul(100) : new Decimal(0);
+      costInfo += `\n- Difference: $${diff.toFixed(6)} (${pct.gt(0) ? '+' : ''}${pct.toFixed(2)}%)`;
+    }
+  }
+  return costInfo;
+};

package/src/github.lib.mjs

@@ -14,60 +14,8 @@ import { formatResetTimeWithRelative } from './usage-limit.lib.mjs'; // See: htt
 import { getToolDisplayName, getModelInfoForComment } from './models/index.mjs';
 export { getToolDisplayName }; // Re-export for use by other modules
 import { buildBudgetStatsString } from './claude.budget-stats.lib.mjs';
-
-/** Build cost estimation string for log comments (Issue #1250, Issue #1557) */
-const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
-  const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
-  const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
-  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
-  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
-  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
-  // Issue #1557: Simplified display when public and Anthropic costs match
-  if (hasPublic && hasAnthropic && totalCostUSD.toFixed(6) === anthropicTotalCostUSD.toFixed(6)) return `\n\n### 💰 Cost: **$${anthropicTotalCostUSD.toFixed(6)}**`;
-  let costInfo = '\n\n### 💰 **Cost estimation:**';
-  if (pricingInfo?.modelName) {
-    costInfo += `\n- Model: ${pricingInfo.modelName}`;
-    if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
-  }
-  if (hasPublic) {
-    if (pricingInfo?.isFreeModel && totalCostUSD === 0 && !pricingInfo?.baseModelName) {
-      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
-    } else {
-      let pricingRef = '';
-      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
-        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
-      } else if (pricingInfo?.originalProvider) {
-        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
-      }
-      costInfo += `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)}${pricingRef}`;
-    }
-  } else if (hasPricing) {
-    costInfo += '\n- Public pricing estimate: unknown';
-  }
-  if (hasOpencodeCost) {
-    if (pricingInfo.isOpencodeFreeModel) {
-      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
-    } else {
-      costInfo += `\n- Calculated by OpenCode Zen: $${pricingInfo.opencodeCost.toFixed(6)}`;
-    }
-  }
-  if (pricingInfo?.tokenUsage) {
-    const u = pricingInfo.tokenUsage;
-    let tokenInfo = `\n- Token usage: ${u.inputTokens?.toLocaleString() || 0} input, ${u.outputTokens?.toLocaleString() || 0} output`;
-    if (u.reasoningTokens > 0) tokenInfo += `, ${u.reasoningTokens.toLocaleString()} reasoning`;
-    if (u.cacheReadTokens > 0 || u.cacheWriteTokens > 0) tokenInfo += `, ${u.cacheReadTokens?.toLocaleString() || 0} cache read, ${u.cacheWriteTokens?.toLocaleString() || 0} cache write`;
-    costInfo += tokenInfo;
-  }
-  if (hasAnthropic) {
-    costInfo += `\n- Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)}`;
-    if (hasPublic) {
-      const diff = anthropicTotalCostUSD - totalCostUSD;
-      const pct = totalCostUSD > 0 ? (diff / totalCostUSD) * 100 : 0;
-      costInfo += `\n- Difference: $${diff.toFixed(6)} (${pct > 0 ? '+' : ''}${pct.toFixed(2)}%)`;
-    }
-  }
-  return costInfo;
-};
+import { buildCostInfoString } from './github-cost-info.lib.mjs';
+export { buildCostInfoString };
 export const maskGitHubToken = maskToken; // Alias for backward compatibility
 export const escapeCodeBlocksInLog = logContent => logContent.replace(/```/g, '\\`\\`\\`'); // Escape ``` in logs
 export const checkFileInBranch = async (owner, repo, fileName, branchName) => {

package/src/opencode.lib.mjs

@@ -19,6 +19,10 @@ import { timeouts } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { opencodeModels, defaultModels } from './models/index.mjs';
+import { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage as parseOpenCodeTokenUsage } from './agent-token-usage.lib.mjs';
+import { calculateAgentPricing } from './agent.lib.mjs';
+
+export { parseOpenCodeTokenUsage };
 
 // Model mapping to translate aliases to full model IDs for OpenCode
 // Issue #1473: Uses centralized opencodeModels from models/index.mjs (single source of truth)
@@ -242,6 +246,7 @@ export const executeOpenCodeCommand = async params => {
 
     // Map model alias to full ID
     const mappedModel = mapModelToId(argv.model);
+    const streamingTokenUsage = createAgentTokenUsage();
 
     // Build opencode command arguments
     let opencodeArgs = `run --format json --model ${mappedModel}`;
@@ -268,6 +273,15 @@ export const executeOpenCodeCommand = async params => {
     await log(`${fullCommand}`);
     await log('');
 
+    const buildPricingInfo = async () => {
+      const tokenUsage = streamingTokenUsage;
+      if (tokenUsage.stepCount === 0) {
+        return { tokenUsage, pricingInfo: null, publicPricingEstimate: null };
+      }
+      const pricingInfo = await calculateAgentPricing(mappedModel, tokenUsage);
+      return { tokenUsage, pricingInfo, publicPricingEstimate: pricingInfo?.totalCostUSD ?? null };
+    };
+
     try {
       // Pipe the prompt file to opencode via stdin
       if (argv.resume) {
@@ -313,6 +327,7 @@ export const executeOpenCodeCommand = async params => {
             for (const line of lines) {
               if (!line.trim()) continue;
               const data = sanitizeObjectStrings(JSON.parse(line));
+              accumulateAgentStepFinishUsage(streamingTokenUsage, data);
               // Track text content for result summary
               // OpenCode outputs text via 'text', 'assistant', 'message', or 'result' type events
               if (data.type === 'text' && data.text) {
@@ -355,6 +370,7 @@ export const executeOpenCodeCommand = async params => {
               for (const line of lines) {
                 if (!line.trim()) continue;
                 const data = sanitizeObjectStrings(JSON.parse(line));
+                accumulateAgentStepFinishUsage(streamingTokenUsage, data);
                 if (data.type === 'text' && data.text) {
                   lastTextContent = data.text;
                 } else if (data.type === 'assistant' && data.message?.content) {
@@ -427,12 +443,14 @@ export const executeOpenCodeCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
 
+        const pricingResult = await buildPricingInfo();
         return {
           success: false,
           sessionId,
           limitReached: false,
           limitResetTime: null,
           permissionPromptDetected: true,
+          ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
         };
       }
@@ -466,17 +484,41 @@ export const executeOpenCodeCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
 
+        const pricingResult = await buildPricingInfo();
         return {
           success: false,
           sessionId,
           limitReached,
           limitResetTime,
+          ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
         };
       }
 
       await log('\n\n✅ OpenCode command completed');
 
+      const pricingResult = await buildPricingInfo();
+      if (pricingResult.tokenUsage.stepCount > 0) {
+        await log('\n💰 Token Usage Summary:');
+        await log(`   📊 ${pricingResult.pricingInfo?.modelName || mappedModel} (${pricingResult.tokenUsage.stepCount} steps):`);
+        await log(`      Input tokens:     ${pricingResult.tokenUsage.inputTokens.toLocaleString()}`);
+        await log(`      Output tokens:    ${pricingResult.tokenUsage.outputTokens.toLocaleString()}`);
+        if (pricingResult.tokenUsage.reasoningTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.reasoningTokens) {
+          await log(`      Reasoning tokens: ${pricingResult.tokenUsage.reasoningTokens.toLocaleString()}`);
+        }
+        if (pricingResult.tokenUsage.cacheReadTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.cacheReadTokens) {
+          await log(`      Cache read:       ${pricingResult.tokenUsage.cacheReadTokens.toLocaleString()}`);
+        }
+        if (pricingResult.tokenUsage.cacheWriteTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.cacheWriteTokens) {
+          await log(`      Cache write:      ${pricingResult.tokenUsage.cacheWriteTokens.toLocaleString()}`);
+        }
+        if (pricingResult.pricingInfo?.totalCostUSD !== null && pricingResult.pricingInfo?.totalCostUSD !== undefined) {
+          await log(`      Public pricing estimate: $${pricingResult.pricingInfo.totalCostUSD.toFixed(6)}`);
+        } else {
+          await log('      Cost: Not available (could not fetch pricing)');
+        }
+      }
+
       // Issue #1263: Log if result summary was captured
       if (lastTextContent) {
         await log('📝 Captured result summary from OpenCode output', { verbose: true });
@@ -487,6 +529,7 @@ export const executeOpenCodeCommand = async params => {
         sessionId,
         limitReached,
         limitResetTime,
+        ...pricingResult,
         resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
       };
     } catch (error) {
@@ -510,6 +553,9 @@ export const executeOpenCodeCommand = async params => {
         sessionId: null,
         limitReached: false,
         limitResetTime: null,
+        tokenUsage: streamingTokenUsage.stepCount > 0 ? streamingTokenUsage : null,
+        pricingInfo: null,
+        publicPricingEstimate: null,
         resultSummary: null, // Issue #1263: No result summary available on error
       };
     }
@@ -610,4 +656,5 @@ export default {
   executeOpenCode,
   executeOpenCodeCommand,
   checkForUncommittedChanges,
+  parseOpenCodeTokenUsage,
 };