@link-assistant/hive-mind 1.46.3 → 1.46.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 1.46.5
+
+### Patch Changes
+
+- c900fb8: Usage stats improvements for Agent CLI and Claude Code CLI (Issue #1526)
+  - Fix context window 288% bug by skipping display when peakContextUsage is 0
+  - Add Agent CLI "Context and tokens usage" section with model/context parsing
+  - Shorter output format combining context window and output tokens on single line
+  - Consolidated Total line with cost information
+  - Sub-sessions use numbered Context window lines directly
+
+## 1.46.4
+
+### Patch Changes
+
+- a3bdea6: Fix CI/CD false positive for .gitkeep files using positive matching (Issue #1528).
+
+  Use consistent positive matching in detect-code-changes.mjs: "Files considered as code changes" now only shows files matching codePattern, so unknown file types like .gitkeep are naturally excluded without explicit exclusion rules. Add 40 unit tests covering the full detection pipeline.
+
 ## 1.46.3
 
 ### Patch Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -40,6 +40,12 @@ export const parseAgentTokenUsage = output => {
     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)
@@ -71,6 +77,24 @@ export const parseAgentTokenUsage = output => {
         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
@@ -560,6 +584,12 @@ export const executeAgentCommand = async params => {
         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 => {
@@ -576,6 +606,20 @@ export const executeAgentCommand = async params => {
           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;
+            }
+          }
         }
       };
 

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

@@ -141,6 +141,9 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
  * @param {Object} tokenUsage - Full token usage data (with subSessions)
  * @param {Function} log - Logging function
  */
+/**
+ * Issue #1526: Updated to use single-line context+output format.
+ */
 export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const modelInfo = usage.modelInfo;
   if (!modelInfo?.limit) {
@@ -156,48 +159,50 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const hasMultipleSubSessions = subSessions.length > 1;
 
   if (hasMultipleSubSessions) {
-    await log('        Sub sessions (between compact events):');
     for (let i = 0; i < subSessions.length; i++) {
       const sub = subSessions[i];
       const subPeak = sub.peakContextUsage || 0;
-      let line = `          ${i + 1}. `;
-      if (contextLimit && subPeak > 0) {
-        const pct = ((subPeak / contextLimit) * 100).toFixed(0);
-        line += `${formatNumber(subPeak)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`;
-      } else {
-        const subTotal = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-        line += `${formatNumber(subTotal)} input tokens`;
+      const subCumulative = (sub.inputTokens || 0) + (sub.cacheCreationTokens || 0) + (sub.cacheReadTokens || 0);
+      const contextValue = subPeak > 0 ? subPeak : subCumulative;
+      const parts = [];
+      if (contextLimit && contextValue > 0) {
+        const pct = ((contextValue / contextLimit) * 100).toFixed(0);
+        parts.push(`${formatNumber(contextValue)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
       }
       if (outputLimit) {
         const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
-        line += `; ${formatNumber(sub.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`;
-      } else {
-        line += `; ${formatNumber(sub.outputTokens)} output tokens`;
+        parts.push(`${formatNumber(sub.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`);
+      }
+      if (parts.length > 0) {
+        await log(`        ${i + 1}. Context window: ${parts.join(', ')}`);
       }
-      await log(line);
     }
   } else {
-    // Single sub-session: simplified format
+    // Single sub-session: single-line format
     const peakContext = usage.peakContextUsage || 0;
-    if (contextLimit) {
-      if (peakContext > 0) {
-        const pct = ((peakContext / contextLimit) * 100).toFixed(0);
-        await log(`        Max context window: ${formatNumber(peakContext)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
-      }
+    const cumulativeContext = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+    const contextValue = peakContext > 0 ? peakContext : cumulativeContext;
+    const parts = [];
+    if (contextLimit && contextValue > 0) {
+      const pct = ((contextValue / contextLimit) * 100).toFixed(0);
+      parts.push(`${formatNumber(contextValue)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
     }
     if (outputLimit) {
       const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
-      await log(`        Max output tokens: ${formatNumber(usage.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`);
+      parts.push(`${formatNumber(usage.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`);
+    }
+    if (parts.length > 0) {
+      await log(`        Context window: ${parts.join(', ')}`);
     }
   }
 
-  // Cumulative totals
+  // Cumulative totals — single line
   const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
   const cachedTokens = usage.cacheReadTokens;
-  let totalLine = `        Total input tokens: ${formatNumber(totalInputNonCached)}`;
+  let totalLine = `${formatNumber(totalInputNonCached)}`;
   if (cachedTokens > 0) totalLine += ` + ${formatNumber(cachedTokens)} cached`;
-  await log(totalLine);
-  await log(`        Total output tokens: ${formatNumber(usage.outputTokens)}`);
+  totalLine += ` input tokens, ${formatNumber(usage.outputTokens)} output tokens`;
+  await log(`        Total: ${totalLine}`);
 };
 
 /**
@@ -261,39 +266,64 @@ const formatTokensCompact = tokens => {
  * @param {number|null} outputLimit - Output token limit for the model
  * @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%)"
+ */
 const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
-  let result = '\n\nSub sessions (between compact events):';
+  let result = '';
   for (let i = 0; i < subSessions.length; i++) {
     const sub = subSessions[i];
     const subPeakContext = sub.peakContextUsage || 0;
-    const subTotalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-    let line = `\n${i + 1}. `;
-    if (contextLimit && subPeakContext > 0) {
-      const pct = ((subPeakContext / contextLimit) * 100).toFixed(0);
-      line += `${formatTokensCompact(subPeakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
-    } else {
-      line += `${formatTokensCompact(subTotalInput)} input tokens`;
-    }
-    if (outputLimit) {
-      const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
-      line += `; ${formatTokensCompact(sub.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
-    } else {
-      line += `; ${formatTokensCompact(sub.outputTokens)} output tokens`;
-    }
-    result += line;
+    // Cumulative fallback: inputTokens + cacheCreationTokens + cacheReadTokens for this sub-session
+    const subCumulative = (sub.inputTokens || 0) + (sub.cacheCreationTokens || 0) + (sub.cacheReadTokens || 0);
+    result += formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `, subCumulative);
   }
   return result;
 };
 
 /**
- * Build budget stats string for GitHub PR comments (Issue #1491, #1501, #1508)
+ * Issue #1526: Build a single-line context window + output tokens string.
+ * Format: "- Context window: X / Y input tokens (Z%), A / B output tokens (W%)"
+ * When only one of context or output limits is available, shows just that part.
+ * @param {number} peakContext - Peak context usage (0 if unknown)
+ * @param {number} contextLimit - Context window limit (null if unknown)
+ * @param {number} outputTokens - Output tokens used
+ * @param {number} outputLimit - Output token limit (null if unknown)
+ * @param {string} [prefix='- '] - Line prefix
+ * @returns {string} Formatted line or empty string
+ */
+const formatContextOutputLine = (peakContext, contextLimit, outputTokens, outputLimit, prefix = '- ', cumulativeContext = 0) => {
+  const parts = [];
+  if (contextLimit) {
+    // Use peakContextUsage when available (per-request peak from JSONL tracking).
+    // Fall back to cumulative total (inputTokens + cacheCreationTokens + cacheReadTokens)
+    // when peak is unknown (e.g., model only from result JSON, not in JSONL).
+    // Issue #1526: Never skip context display — always show what data we have.
+    const contextValue = peakContext > 0 ? peakContext : cumulativeContext;
+    if (contextValue > 0) {
+      const pct = ((contextValue / contextLimit) * 100).toFixed(0);
+      parts.push(`${formatTokensCompact(contextValue)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`);
+    }
+  }
+  if (outputLimit) {
+    const outPct = ((outputTokens / outputLimit) * 100).toFixed(0);
+    parts.push(`${formatTokensCompact(outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`);
+  }
+  if (parts.length === 0) return '';
+  return `\n${prefix}Context window: ${parts.join(', ')}`;
+};
+
+/**
+ * Build budget stats string for GitHub PR comments (Issue #1491, #1501, #1508, #1526)
  * Format requested by user: sub-sessions between compactification events,
  * per-model breakdown, cumulative totals with cached tokens shown separately.
  * Issue #1508: When multiple models are used, token and context usage is now split by model.
  * Sub-sessions are shown as a global section (not duplicated per model) since JSONL
  * sub-session tracking is global across all models.
- * @param {Object} tokenUsage - Token usage data from calculateSessionTokens
- * @param {Object|null} streamTokenUsage - Token usage from stream JSON events (used for comparison, not displayed)
+ * Issue #1526: Shorter output format — context window + output tokens on single line.
+ * Fix: exclude cacheReadTokens from context window fallback calculation (cumulative ≠ per-request).
+ * @param {Object} tokenUsage - Token usage data from calculateSessionTokens or buildAgentBudgetStats
  * @returns {string} Formatted markdown string for PR comment
  */
 export const buildBudgetStatsString = tokenUsage => {
@@ -329,61 +359,73 @@ export const buildBudgetStatsString = tokenUsage => {
       if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
       if (!isMultiModel && hasMultipleSubSessions) {
-        // Single-model + multiple sub-sessions: show sub-sessions under that model
+        // Single-model + multiple sub-sessions: show numbered sub-sessions under that model
         stats += formatSubSessionsList(subSessions, contextLimit, outputLimit);
-      } else if (!isMultiModel && !hasMultipleSubSessions) {
-        // Single-model + single sub-session: simplified format with context/output limits
-        const peakContext = usage.peakContextUsage || 0;
-        if (contextLimit) {
-          if (peakContext > 0) {
-            const pct = ((peakContext / contextLimit) * 100).toFixed(0);
-            stats += `\n- Max context window: ${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
-          } else {
-            const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-            const pct = ((totalInput / contextLimit) * 100).toFixed(0);
-            stats += `\n- Context window: ${formatTokensCompact(totalInput)} / ${formatTokensCompact(contextLimit)} tokens (${pct}%)`;
-          }
-        }
-        if (outputLimit) {
-          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
-          stats += `\n- Max output tokens: ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
-        }
       } else {
-        // Multi-model (single or multiple sub-sessions): show per-model context/output limits
-        // Issue #1508: Context window and max output tokens should be split by model
+        // Issue #1526: Single line format for context window + output tokens
+        // Use peakContextUsage when available; fall back to cumulative total when peak is unknown
+        // (e.g., for result-JSON-sourced sub-agent models where only cumulative totals are available)
         const peakContext = usage.peakContextUsage || 0;
-        if (contextLimit) {
-          if (peakContext > 0) {
-            const pct = ((peakContext / contextLimit) * 100).toFixed(0);
-            stats += `\n- Max context window: ${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
-          } else {
-            const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-            const pct = ((totalInput / contextLimit) * 100).toFixed(0);
-            stats += `\n- Context window: ${formatTokensCompact(totalInput)} / ${formatTokensCompact(contextLimit)} tokens (${pct}%)`;
-          }
-        }
-        if (outputLimit) {
-          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
-          stats += `\n- Max output tokens: ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
-        }
+        const cumulativeContext = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+        stats += formatContextOutputLine(peakContext, contextLimit, usage.outputTokens, outputLimit, '- ', cumulativeContext);
       }
 
       // Cumulative totals per model: input tokens + cached shown separately
+      // Issue #1526: Shorter format — single "Total:" line
       const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
       const cachedTokens = usage.cacheReadTokens;
-      stats += `\n\nTotal input tokens: ${formatTokensCompact(totalInputNonCached)}`;
-      if (cachedTokens > 0) stats += ` + ${formatTokensCompact(cachedTokens)} cached`;
-      stats += `\nTotal output tokens: ${formatTokensCompact(usage.outputTokens)} output`;
+      let totalLine = `${formatTokensCompact(totalInputNonCached)}`;
+      if (cachedTokens > 0) totalLine += ` + ${formatTokensCompact(cachedTokens)} cached`;
+      totalLine += ` input tokens, ${formatTokensCompact(usage.outputTokens)} output tokens`;
 
       // Issue #1508: Show per-model cost when available
       if (usage.costUSD !== null && usage.costUSD !== undefined) {
-        stats += `\nCost: $${usage.costUSD.toFixed(6)}`;
+        totalLine += `, $${usage.costUSD.toFixed(6)} cost`;
       }
+
+      stats += `\n\nTotal: ${totalLine}`;
     }
   }
 
-  // Stream vs JSONL comparison — kept for internal diagnostics only in verbose/debug mode
-  // Not shown to users per feedback (Issue #1501 PR comment)
-
   return stats;
 };
+
+/**
+ * Issue #1526: Build budget stats data from Agent CLI token/context information.
+ * Converts Agent CLI parsed data into the same format used by calculateSessionTokens
+ * so that buildBudgetStatsString can render it uniformly.
+ * @param {Object} tokenUsage - Token usage from parseAgentTokenUsage (with context/model info)
+ * @param {Object|null} pricingInfo - Pricing info from calculateAgentPricing
+ * @returns {Object|null} Budget stats data compatible with buildBudgetStatsString, or null if no data
+ */
+export const buildAgentBudgetStats = (tokenUsage, pricingInfo) => {
+  if (!tokenUsage || tokenUsage.stepCount === 0) return null;
+
+  const modelName = pricingInfo?.modelName || tokenUsage.respondedModelId || tokenUsage.requestedModelId || 'Unknown';
+  const modelId = tokenUsage.respondedModelId || tokenUsage.requestedModelId || pricingInfo?.modelId || 'unknown';
+
+  // Use context limits from step_finish events if available, otherwise from pricing model info
+  const contextLimit = tokenUsage.contextLimit || pricingInfo?.modelInfo?.limit?.context || null;
+  const outputLimit = tokenUsage.outputLimit || pricingInfo?.modelInfo?.limit?.output || null;
+
+  const modelUsageEntry = {
+    inputTokens: tokenUsage.inputTokens,
+    cacheCreationTokens: tokenUsage.cacheWriteTokens || 0,
+    cacheReadTokens: tokenUsage.cacheReadTokens || 0,
+    outputTokens: tokenUsage.outputTokens,
+    modelName,
+    modelInfo: contextLimit || outputLimit ? { limit: { context: contextLimit, output: outputLimit } } : null,
+    peakContextUsage: tokenUsage.peakContextUsage || 0,
+    costUSD: pricingInfo?.totalCostUSD ?? null,
+  };
+
+  return {
+    modelUsage: { [modelId]: modelUsageEntry },
+    subSessions: [],
+    inputTokens: tokenUsage.inputTokens,
+    cacheCreationTokens: tokenUsage.cacheWriteTokens || 0,
+    cacheReadTokens: tokenUsage.cacheReadTokens || 0,
+    outputTokens: tokenUsage.outputTokens,
+    totalTokens: tokenUsage.inputTokens + (tokenUsage.cacheWriteTokens || 0) + tokenUsage.outputTokens,
+  };
+};

package/src/solve.results.lib.mjs

@@ -497,7 +497,7 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
 export const verifyResults = async (owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart = false, sessionId = null, tempDir = null, anthropicTotalCostUSD = null, publicPricingEstimate = null, pricingInfo = null, errorDuringExecution = false, sessionType = 'new', resultModelUsage = null, streamTokenUsage = null) => {
   await log('\n🔍 Searching for created pull requests or comments...');
 
-  // Issue #1491: Build budget stats data for GitHub comment (computed once, used in both PR and issue paths)
+  // Issue #1491, #1526: Build budget stats data for GitHub comment (computed once, used in both PR and issue paths)
   let budgetStatsData = null;
   if (argv.tokensBudgetStats && sessionId && tempDir) {
     try {
@@ -510,6 +510,18 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
       if (argv.verbose) await log(`  ⚠️  Could not calculate budget stats: ${budgetError.message}`, { verbose: true });
     }
   }
+  // Issue #1526: Build budget stats from Agent CLI token/context data when no JSONL session available
+  if (!budgetStatsData && argv.tokensBudgetStats && pricingInfo?.tokenUsage) {
+    try {
+      const { buildAgentBudgetStats } = await import('./claude.budget-stats.lib.mjs');
+      const agentBudgetData = buildAgentBudgetStats(pricingInfo.tokenUsage, pricingInfo);
+      if (agentBudgetData) {
+        budgetStatsData = { tokenUsage: agentBudgetData };
+      }
+    } catch (agentBudgetError) {
+      if (argv.verbose) await log(`  ⚠️  Could not build agent budget stats: ${agentBudgetError.message}`, { verbose: true });
+    }
+  }
 
   try {
     // Get the current user's GitHub username