@link-assistant/hive-mind 1.38.1 → 1.38.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @link-assistant/hive-mind
 
+## 1.38.2
+
+### Patch Changes
+
+- 290139f: fix: correct cost and token/context budget calculations (#1501)
+  - Deduplicate JSONL session entries by message ID to fix inflated token counts caused by upstream anthropics/claude-code#6805
+  - Show peak context window usage (max single-request fill) instead of cumulative sum which produced nonsensical percentages like 7516%
+  - Add "Total tokens processed" as a separate cumulative metric for session throughput visibility
+  - Add verbose logging for JSONL deduplication stats and peak context values
+
 ## 1.38.1
 
 ### Patch Changes

package/package.json

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

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

@@ -14,6 +14,8 @@ export const createEmptySubSessionUsage = () => ({
   cacheReadTokens: 0,
   outputTokens: 0,
   messageCount: 0,
+  peakContextUsage: 0,
+  peakOutputUsage: 0,
 });
 
 /**
@@ -136,173 +138,161 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
 /**
  * Display token budget statistics (context window usage and ratios)
  * @param {Object} usage - Usage data for a model
+ * @param {Object} tokenUsage - Full token usage data (with subSessions)
  * @param {Function} log - Logging function
  */
-export const displayBudgetStats = async (usage, log) => {
+export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const modelInfo = usage.modelInfo;
   if (!modelInfo?.limit) {
     await log('\n      ⚠️  Budget stats not available (no model limits found)');
     return;
   }
 
-  await log('\n      📊 Token Budget Statistics:');
+  await log('\n      📊 Context and tokens usage:');
 
-  // Context window usage
-  if (modelInfo.limit.context) {
-    const contextLimit = modelInfo.limit.context;
-    // Input tokens include regular input + cache creation + cache read
-    const totalInputUsed = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-    const contextUsageRatio = totalInputUsed / contextLimit;
-    const contextUsagePercent = (contextUsageRatio * 100).toFixed(2);
+  const contextLimit = modelInfo.limit.context;
+  const outputLimit = modelInfo.limit.output;
+  const subSessions = tokenUsage?.subSessions || [];
+  const hasMultipleSubSessions = subSessions.length > 1;
 
-    await log('        Context window:');
-    await log(`          Used: ${formatNumber(totalInputUsed)} tokens`);
-    await log(`          Limit: ${formatNumber(contextLimit)} tokens`);
-    await log(`          Ratio: ${contextUsageRatio.toFixed(4)} (${contextUsagePercent}%)`);
-  }
-
-  // Output tokens usage
-  if (modelInfo.limit.output) {
-    const outputLimit = modelInfo.limit.output;
-    const outputUsageRatio = usage.outputTokens / outputLimit;
-    const outputUsagePercent = (outputUsageRatio * 100).toFixed(2);
-
-    await log('        Output tokens:');
-    await log(`          Used: ${formatNumber(usage.outputTokens)} tokens`);
-    await log(`          Limit: ${formatNumber(outputLimit)} tokens`);
-    await log(`          Ratio: ${outputUsageRatio.toFixed(4)} (${outputUsagePercent}%)`);
-  }
-
-  // Total session tokens (input + cache_creation + output)
-  const totalSessionTokens = usage.inputTokens + usage.cacheCreationTokens + usage.outputTokens;
-  await log(`        Total session tokens: ${formatNumber(totalSessionTokens)}`);
-};
-
-/**
- * Display sub-session breakdown when compactification events occurred (Issue #1491)
- * @param {Object} tokenUsage - Token usage data with subSessions and compactifications
- * @param {Object} modelInfo - Model info with context/output limits
- * @param {Function} log - Logging function
- */
-export const displaySubSessionStats = async (tokenUsage, modelInfo, log) => {
-  if (!tokenUsage.subSessions || !tokenUsage.compactifications) return;
-
-  const contextLimit = modelInfo?.limit?.context;
-  await log(`\n      🔄 Compactification events: ${tokenUsage.compactifications.length}`);
-
-  for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-    const sub = tokenUsage.subSessions[i];
-    const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-    const label = i === 0 ? 'Initial session' : `After compactification #${i}`;
-
-    await log(`        Sub-session ${i + 1} (${label}):`);
-    await log(`          Messages: ${sub.messageCount}`);
-    await log(`          Context used: ${formatNumber(totalInput)} tokens`);
+  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`;
+      }
+      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`;
+      }
+      await log(line);
+    }
+  } else {
+    // Single sub-session: simplified format
+    const peakContext = usage.peakContextUsage || 0;
     if (contextLimit) {
-      const pct = ((totalInput / contextLimit) * 100).toFixed(2);
-      await log(`          Context usage: ${pct}% of ${formatNumber(contextLimit)}`);
+      if (peakContext > 0) {
+        const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+        await log(`        Max context window: ${formatNumber(peakContext)} / ${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}%)`);
     }
-    await log(`          Output: ${formatNumber(sub.outputTokens)} tokens`);
   }
 
-  // Show compactification details
-  for (let i = 0; i < tokenUsage.compactifications.length; i++) {
-    const comp = tokenUsage.compactifications[i];
-    let detail = `        Compactification #${i + 1}: trigger=${comp.trigger}`;
-    if (comp.preTokens) detail += `, pre-compaction tokens=${formatNumber(comp.preTokens)}`;
-    await log(detail);
-  }
+  // Cumulative totals
+  const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
+  const cachedTokens = usage.cacheReadTokens;
+  let totalLine = `        Total input tokens: ${formatNumber(totalInputNonCached)}`;
+  if (cachedTokens > 0) totalLine += ` + ${formatNumber(cachedTokens)} cached`;
+  await log(totalLine);
+  await log(`        Total output tokens: ${formatNumber(usage.outputTokens)}`);
 };
 
 /**
- * Display stream vs JSONL token comparison (Issue #1491)
- * Shows independent calculation from stream events vs JSONL session file
- * @param {Object} streamTokenUsage - Token usage accumulated from stream JSON events
- * @param {Object} jsonlTokenUsage - Token usage calculated from JSONL session file
- * @param {Function} log - Logging function
+ * Format a token count with K/M suffix for compact display
+ * @param {number} tokens - Token count
+ * @returns {string} Formatted string like "850K" or "1.5M"
  */
-export const displayTokenComparison = async (streamTokenUsage, jsonlTokenUsage, log) => {
-  if (!streamTokenUsage || !jsonlTokenUsage) return;
-
-  const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-  const jsonlTotal = jsonlTokenUsage.inputTokens + jsonlTokenUsage.cacheCreationTokens + jsonlTokenUsage.outputTokens;
-
-  await log('\n      🔍 Token calculation comparison:');
-  await log(`        Stream JSON events: ${formatNumber(streamTotal)} tokens (${streamTokenUsage.eventCount} events)`);
-  await log(`        JSONL session file: ${formatNumber(jsonlTotal)} tokens`);
-
-  if (streamTotal !== jsonlTotal) {
-    const diff = jsonlTotal - streamTotal;
-    const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-    await log(`        Difference: ${formatNumber(Math.abs(diff))} tokens (${diff > 0 ? '+' : ''}${pct}%)`);
-  } else {
-    await log('        Match: calculations are consistent');
-  }
+const formatTokensCompact = tokens => {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(tokens % 1000000 === 0 ? 0 : 1)}M`;
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(tokens % 1000 === 0 ? 0 : 1)}K`;
+  return tokens.toLocaleString();
 };
 
 /**
- * Build budget stats string for GitHub PR comments (Issue #1491)
- * Similar to buildCostInfoString but for token budget statistics
+ * Build budget stats string for GitHub PR comments (Issue #1491, #1501)
+ * Format requested by user: sub-sessions between compactification events,
+ * per-model breakdown, cumulative totals with cached tokens shown separately.
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens
- * @param {Object|null} streamTokenUsage - Token usage from stream JSON events
+ * @param {Object|null} streamTokenUsage - Token usage from stream JSON events (used for comparison, not displayed)
  * @returns {string} Formatted markdown string for PR comment
  */
-export const buildBudgetStatsString = (tokenUsage, streamTokenUsage) => {
+export const buildBudgetStatsString = tokenUsage => {
   if (!tokenUsage) return '';
 
-  let stats = '\n\n### 📊 **Token budget statistics:**';
+  let stats = '\n\n### 📊 **Context and tokens usage:**';
 
   // Per-model breakdown
   if (tokenUsage.modelUsage) {
     const modelIds = Object.keys(tokenUsage.modelUsage);
+    const isMultiModel = modelIds.length > 1;
+
     for (const modelId of modelIds) {
       const usage = tokenUsage.modelUsage[modelId];
       const modelName = usage.modelName || modelId;
       const contextLimit = usage.modelInfo?.limit?.context;
       const outputLimit = usage.modelInfo?.limit?.output;
-      const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
 
-      if (modelIds.length > 1) stats += `\n- **${modelName}**:`;
+      if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
-      if (contextLimit) {
-        const contextPct = ((totalInput / contextLimit) * 100).toFixed(2);
-        stats += `\n- Context window: ${totalInput.toLocaleString()} / ${contextLimit.toLocaleString()} tokens (${contextPct}%)`;
-      } else {
-        stats += `\n- Context tokens used: ${totalInput.toLocaleString()}`;
-      }
+      // Sub-session display (Issue #1501: show per sub-session stats)
+      const subSessions = tokenUsage.subSessions || [];
+      const hasMultipleSubSessions = subSessions.length > 1;
 
-      if (outputLimit) {
-        const outputPct = ((usage.outputTokens / outputLimit) * 100).toFixed(2);
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()} / ${outputLimit.toLocaleString()} tokens (${outputPct}%)`;
+      if (hasMultipleSubSessions) {
+        // Multiple sub-sessions: show numbered list
+        stats += '\n\nSub sessions (between compact events):';
+        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`;
+          }
+          stats += line;
+        }
       } else {
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()}`;
+        // Single sub-session (or no sub-sessions): simplified format
+        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}%)`;
+        }
       }
-    }
-  }
 
-  // Sub-session breakdown if compactification occurred
-  if (tokenUsage.subSessions && tokenUsage.compactifications) {
-    stats += `\n- Compactifications: ${tokenUsage.compactifications.length}`;
-    for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-      const sub = tokenUsage.subSessions[i];
-      const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-      const label = i === 0 ? 'initial' : `after compactification #${i}`;
-      stats += `\n  - Sub-session ${i + 1} (${label}): ${totalInput.toLocaleString()} context, ${sub.outputTokens.toLocaleString()} output, ${sub.messageCount} messages`;
+      // Cumulative totals: input tokens + cached shown separately
+      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`;
     }
   }
 
-  // Stream vs JSONL comparison
-  if (streamTokenUsage) {
-    const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-    const jsonlTotal = tokenUsage.inputTokens + tokenUsage.cacheCreationTokens + tokenUsage.outputTokens;
-    stats += `\n- Own calculation (stream): ${streamTotal.toLocaleString()} tokens (${streamTokenUsage.eventCount} events)`;
-    stats += `\n- JSONL calculation: ${jsonlTotal.toLocaleString()} tokens`;
-    if (streamTotal !== jsonlTotal) {
-      const diff = jsonlTotal - streamTotal;
-      const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-      stats += ` (diff: ${diff > 0 ? '+' : ''}${pct}%)`;
-    }
-  }
+  // 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;
 };

package/src/claude.lib.mjs

@@ -12,7 +12,7 @@ import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToToke
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { displayBudgetStats, displaySubSessionStats, displayTokenComparison, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
+import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } 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
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
@@ -497,6 +497,15 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
   }
   // Initialize per-model usage tracking
   const modelUsage = {};
+  // Issue #1501: Deduplicate JSONL entries by message ID (upstream: anthropics/claude-code#6805)
+  // Claude Code's stream-json mode splits single API responses with multiple content blocks
+  // into separate JSONL entries, each with the same message ID and identical usage stats.
+  const seenMessageIds = new Set();
+  let duplicateCount = 0;
+  // Issue #1501: Track peak context usage per request (not cumulative)
+  // The context window limit is per-request, so we track the max single-request fill.
+  const peakContextByModel = {};
+  let globalPeakContext = 0;
   // Issue #1491: Track sub-sessions between compactification events
   const subSessions = [];
   let currentSubSession = createEmptySubSessionUsage();
@@ -524,14 +533,39 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
           continue;
         }
         if (entry.message && entry.message.usage && entry.message.model) {
+          // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
+          const msgId = entry.message.id;
+          if (msgId) {
+            if (seenMessageIds.has(msgId)) {
+              duplicateCount++;
+              continue; // Skip — already counted this message's usage
+            }
+            seenMessageIds.add(msgId);
+          }
           accumulateModelUsage(modelUsage, entry);
-          // Issue #1491: Also track per-sub-session usage
+          // Issue #1501: Track peak context usage per single API request
           const usage = entry.message.usage;
+          const requestContext = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+          const model = entry.message.model;
+          if (requestContext > (peakContextByModel[model] || 0)) {
+            peakContextByModel[model] = requestContext;
+          }
+          if (requestContext > globalPeakContext) {
+            globalPeakContext = requestContext;
+          }
+          // Issue #1491: Also track per-sub-session usage
           if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
           if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
           if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
           if (usage.output_tokens) currentSubSession.outputTokens += usage.output_tokens;
           currentSubSession.messageCount++;
+          // Issue #1501: Track peak context and output per sub-session
+          if (requestContext > currentSubSession.peakContextUsage) {
+            currentSubSession.peakContextUsage = requestContext;
+          }
+          if ((usage.output_tokens || 0) > currentSubSession.peakOutputUsage) {
+            currentSubSession.peakOutputUsage = usage.output_tokens || 0;
+          }
         }
       } catch {
         // Skip lines that aren't valid JSON
@@ -561,6 +595,8 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     // Calculate cost for each model and store all characteristics
     for (const [modelId, usage] of Object.entries(modelUsage)) {
       const modelInfo = modelInfoMap[modelId];
+      // Issue #1501: Attach peak context usage per model
+      usage.peakContextUsage = peakContextByModel[modelId] || 0;
       // Calculate cost using pricing API
       if (modelInfo) {
         const costData = calculateModelCost(usage, modelInfo, true);
@@ -604,8 +640,11 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
       outputTokens: totalOutputTokens,
       totalTokens,
       totalCostUSD: hasCostData ? totalCostUSD : null,
-      // Issue #1491: Sub-session and compactification data
-      subSessions: subSessions.length > 1 ? subSessions : null, // Only include if compactification occurred
+      // Issue #1501: Peak context usage (max single-request fill) and dedup stats
+      peakContextUsage: globalPeakContext,
+      duplicateEntriesSkipped: duplicateCount,
+      // Issue #1491/#1501: Sub-session and compactification data (always include for display)
+      subSessions,
       compactifications: compactifications.length > 0 ? compactifications : null,
     };
   } catch (readError) {
@@ -1248,6 +1287,13 @@ export const executeClaudeCommand = async params => {
         try {
           const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
           if (tokenUsage) {
+            // Issue #1501: Log deduplication stats in verbose mode
+            if (tokenUsage.duplicateEntriesSkipped > 0) {
+              await log(`\n⚠️  JSONL deduplication: skipped ${tokenUsage.duplicateEntriesSkipped} duplicate entries (upstream: anthropics/claude-code#6805)`, { verbose: true });
+            }
+            if (tokenUsage.peakContextUsage > 0) {
+              await log(`📊 Peak single-request context: ${formatNumber(tokenUsage.peakContextUsage)} tokens`, { verbose: true });
+            }
             await log('\n💰 Token Usage Summary:');
             // Display per-model breakdown
             if (tokenUsage.modelUsage) {
@@ -1258,18 +1304,9 @@ export const executeClaudeCommand = async params => {
                 await displayModelUsage(usage, log);
                 // Display budget stats if flag is enabled
                 if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
-                  await displayBudgetStats(usage, log);
+                  await displayBudgetStats(usage, tokenUsage, log);
                 }
               }
-              // Issue #1491: Display sub-session breakdown if compactification occurred
-              if (argv.tokensBudgetStats && tokenUsage.subSessions) {
-                const primaryModelInfo = Object.values(tokenUsage.modelUsage).find(u => u.modelInfo?.limit)?.modelInfo;
-                await displaySubSessionStats(tokenUsage, primaryModelInfo, log);
-              }
-              // Issue #1491: Display stream vs JSONL token comparison
-              if (argv.tokensBudgetStats && streamTokenUsage.eventCount > 0) {
-                await displayTokenComparison(streamTokenUsage, tokenUsage, log);
-              }
               // Show totals if multiple models were used
               if (modelIds.length > 1) {
                 await log('\n   📈 Total across all models:');

package/src/github.lib.mjs

@@ -368,7 +368,7 @@ export async function attachLogToGitHub(options) {
     resultModelUsage = null, // Issue #1454
     budgetStatsData = null, // Issue #1491: budget stats for comment
   } = options;
-  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage, budgetStatsData.streamTokenUsage) : '';
+  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage) : '';
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
   try {