@link-assistant/hive-mind 1.51.0 → 1.52.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- 5b24866: Add Claude Opus 4.7 model support with adaptive thinking, model-correct xhigh/max effort mapping, Opus 4.5/Mythos effort detection, and the --show-thinking-content option.
+
 ## 1.51.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.51.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/agent.prompts.lib.mjs

@@ -5,6 +5,7 @@
 
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
+import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
 
 /**
  * Build the user prompt for Agent
@@ -58,15 +59,9 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
-  // Add thinking instruction based on --think level
-  if (argv && argv.think) {
-    const thinkMessages = {
-      low: 'Think.',
-      medium: 'Think hard.',
-      high: 'Think harder.',
-      max: 'Ultrathink.',
-    };
-    promptLines.push(thinkMessages[argv.think]);
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'agent', argv });
+  if (thinkingPromptInstruction) {
+    promptLines.push(thinkingPromptInstruction);
   }
 
   // Final instruction

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)._`;
         }
       }