@link-assistant/hive-mind 2.0.15 → 2.0.16

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.0.16
+
+### Patch Changes
+
+- a448b3d: Detect incomplete Claude stream-json runs that exit without a terminal result event, capture nested Claude tool/error events, and preserve compaction summaries for diagnostics.
+
 ## 2.0.15
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -31,37 +31,11 @@ import { resolveSubSessionSize } from './sub-session-size.lib.mjs'; // Issue #17
 import { withAgentsMdAsClaudeMd } from './agents-md-claude-support.lib.mjs';
 import { deployHandoffSkill } from './handoff-skill.lib.mjs'; // Issue #1877
 import { createThinkingBlockRecovery } from './claude.thinking-block-recovery.lib.mjs'; // Issue #1834 (PR #1835 feedback)
+import { buildMissingClaudeResultMessage, collectClaudeStreamEventFacts, getClaudeMessageContent, shouldFailClaudeStreamWithoutResult } from './claude.stream-events.lib.mjs';
+import { formatNumber, mapModelToId, checkModelVisionCapability } from './claude.model-utils.lib.mjs';
+import { showResumeCommand } from './claude.resume-output.lib.mjs';
 export { availableModels, fetchModelInfo }; // Re-export for backward compatibility
-const showResumeCommand = async (sessionId, tempDir, claudePath, model, log, argv = null) => {
-  if (!sessionId || !tempDir) return;
-  await log(`\n💡 To continue this session:\n`);
-  await log(`   Interactive mode:    ${buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
-  await log(`   Autonomous mode:     ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
-  // Issue #942: 3rd option - restart the entire /solve flow, not just the claude session.
-  if (argv && argv.url) await log(`   Solve resume mode:   ${buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: argv.tool || 'claude', model: argv.model, fallbackModel: argv.fallbackModel, tempDir })}\n`);
-};
-/** Format numbers with spaces as thousands separator (no commas) */
-export const formatNumber = num => {
-  if (num === null || num === undefined) return 'N/A';
-  const parts = num.toString().split('.');
-  const integerPart = parts[0];
-  const decimalPart = parts[1];
-  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  return decimalPart !== undefined ? `${formattedInteger}.${decimalPart}` : formattedInteger;
-};
-// Model mapping to translate aliases to full model IDs
-// Supports [1m] suffix for 1 million token context (Issue #1221)
-export const mapModelToId = model => {
-  if (!model || typeof model !== 'string') return model;
-  // Check for [1m] suffix (case-insensitive)
-  const match = model.match(/^(.+?)\[1m\]$/i);
-  if (match) {
-    const baseModel = match[1];
-    const mappedBase = availableModels[baseModel] || baseModel;
-    return `${mappedBase}[1m]`;
-  }
-  return availableModels[model] || model;
-};
+export { formatNumber, mapModelToId, checkModelVisionCapability };
 // Function to validate Claude CLI connection with retry logic
 export const validateClaudeConnection = async (model = 'haiku') => {
   // Map model alias to full ID
@@ -377,17 +351,6 @@ export const executeClaude = async params => {
     })
   );
 };
-/** Check if a model supports vision (image input) using models.dev API @returns {Promise<boolean>} */
-export const checkModelVisionCapability = async modelId => {
-  try {
-    const modelInfo = await fetchModelInfo(modelId);
-    if (!modelInfo) return false;
-    const inputModalities = modelInfo.modalities?.input || [];
-    return inputModalities.includes('image');
-  } catch {
-    return false;
-  }
-};
 // Issue #1710: calculateModelCost extracted to ./claude.cost.lib.mjs to keep
 // this file under the 1500-line repo cap (see check-file-line-limits CI job).
 import { calculateModelCost } from './claude.cost.lib.mjs';
@@ -652,6 +615,7 @@ export const executeClaudeCommand = async params => {
     let errorDuringExecution = false;
     let resultSummary = null;
     let resultModelUsage = null;
+    let lastToolResultError = null;
     // Issue #1590: Track sub-agent calls (Agent tool invocations) for per-call stats
     const subAgentCalls = [];
     // Issue #1590: Map tool_use_id -> subAgentCalls index for accumulating per-call usage from parent_tool_use_id events
@@ -903,8 +867,19 @@ export const executeClaudeCommand = async params => {
                   await log(`⚠️ Could not rename log file: ${renameError.message}`, { verbose: true });
                 }
               }
-              if (data.type === 'message') messageCount++;
-              else if (data.type === 'tool_use') toolUseCount++;
+              const eventFacts = collectClaudeStreamEventFacts(data);
+              messageCount += eventFacts.messageCountDelta;
+              toolUseCount += eventFacts.toolUseCountDelta;
+              if (eventFacts.lastText) lastMessage = eventFacts.lastText;
+              if (!resultSummary && eventFacts.compactionSummary) {
+                resultSummary = eventFacts.compactionSummary;
+                await log('📝 Captured fallback summary from Claude compaction context', { verbose: true });
+              }
+              if (eventFacts.toolResultError) {
+                lastToolResultError = eventFacts.toolResultError;
+                lastMessage = eventFacts.toolResultError;
+                await log(`⚠️ Tool result error detected: ${eventFacts.toolResultError.substring(0, 200)}`, { verbose: true });
+              }
               // Issue #1708: signal busy/idle to the bidirectional handler so
               // queue-comments-to-input mode can hold frames until the AI is
               // idle. Any assistant/tool_use/system event means the AI is
@@ -1023,7 +998,7 @@ export const executeClaudeCommand = async params => {
                 }
               }
               if (data.type === 'assistant' && data.message && data.message.content) {
-                const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
+                const content = getClaudeMessageContent(data);
                 for (const item of content) {
                   if (item.type === 'text' && item.text) {
                     // Check for the specific 500/529 overload error pattern (Issue #1439: 529 is also an overload)
@@ -1111,11 +1086,26 @@ export const executeClaudeCommand = async params => {
         try {
           const data = sanitizeObjectStrings(JSON.parse(stdoutLineBuffer));
           await log(JSON.stringify(data, null, 2));
-          if (data?.type === 'result' && data.subtype === 'success' && data.total_cost_usd != null) {
-            anthropicTotalCostUSD = data.total_cost_usd;
-          } else if (data?.type === 'result' && data.total_cost_usd != null) {
-            // Issue #1886: keep a non-success terminal result's cost as a fallback (see streaming branch above).
-            anthropicCostFromAnyResult = data.total_cost_usd;
+          const eventFacts = collectClaudeStreamEventFacts(data);
+          messageCount += eventFacts.messageCountDelta;
+          toolUseCount += eventFacts.toolUseCountDelta;
+          if (eventFacts.lastText) lastMessage = eventFacts.lastText;
+          if (!resultSummary && eventFacts.compactionSummary) resultSummary = eventFacts.compactionSummary;
+          if (eventFacts.toolResultError) {
+            lastToolResultError = eventFacts.toolResultError;
+            lastMessage = eventFacts.toolResultError;
+          }
+          if (data?.type === 'result') {
+            resultEventReceived = true;
+            if (data.subtype === 'success') {
+              resultSuccessReceived = true;
+              if (data.result && typeof data.result === 'string') resultSummary = data.result;
+              if (data.modelUsage) resultModelUsage = data.modelUsage;
+            }
+            if (data.total_cost_usd != null) {
+              if (data.subtype === 'success') anthropicTotalCostUSD = data.total_cost_usd;
+              else anthropicCostFromAnyResult = data.total_cost_usd;
+            }
           }
           // Issue #1472: Forward remaining buffer event to interactive handler (was previously missed)
           if (interactiveHandler) {
@@ -1303,6 +1293,11 @@ export const executeClaudeCommand = async params => {
           .join('\n');
         await log(`\n\n❌ Command failed: No messages processed and errors detected in stderr\nStderr errors:\n${errorsPreview}`, { level: 'error' });
       }
+      if (shouldFailClaudeStreamWithoutResult({ commandFailed, streamingInput, resultEventReceived })) {
+        commandFailed = true;
+        lastMessage = buildMissingClaudeResultMessage({ lastToolResultError, lastMessage });
+        await log(`\n\n❌ Command failed: ${lastMessage}`, { level: 'error' });
+      }
       if (commandFailed) {
         // Take resource snapshot after failure
         const resourcesAfter = await getResourceSnapshot();

package/src/claude.model-utils.lib.mjs

@@ -0,0 +1,32 @@
+import { CLAUDE_MODELS as availableModels } from './models/index.mjs';
+import { fetchModelInfo } from './model-info.lib.mjs';
+
+export const formatNumber = num => {
+  if (num === null || num === undefined) return 'N/A';
+  const parts = num.toString().split('.');
+  const integerPart = parts[0];
+  const decimalPart = parts[1];
+  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  return decimalPart !== undefined ? `${formattedInteger}.${decimalPart}` : formattedInteger;
+};
+
+export const mapModelToId = model => {
+  if (!model || typeof model !== 'string') return model;
+  const match = model.match(/^(.+?)\[1m\]$/i);
+  if (match) {
+    const baseModel = match[1];
+    const mappedBase = availableModels[baseModel] || baseModel;
+    return `${mappedBase}[1m]`;
+  }
+  return availableModels[model] || model;
+};
+
+export const checkModelVisionCapability = async modelId => {
+  try {
+    const modelInfo = await fetchModelInfo(modelId);
+    const inputModalities = modelInfo?.modalities?.input || [];
+    return inputModalities.includes('image');
+  } catch {
+    return false;
+  }
+};

package/src/claude.resume-output.lib.mjs

@@ -0,0 +1,10 @@
+import { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand } from './claude.command-builder.lib.mjs';
+import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs';
+
+export const showResumeCommand = async (sessionId, tempDir, claudePath, model, log, argv = null) => {
+  if (!sessionId || !tempDir) return;
+  await log(`\n💡 To continue this session:\n`);
+  await log(`   Interactive mode:    ${buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
+  await log(`   Autonomous mode:     ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
+  if (argv && argv.url) await log(`   Solve resume mode:   ${buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: argv.tool || 'claude', model: argv.model, fallbackModel: argv.fallbackModel, tempDir })}\n`);
+};

package/src/claude.stream-events.lib.mjs

@@ -0,0 +1,61 @@
+const asArray = value => (Array.isArray(value) ? value : value ? [value] : []);
+
+export const getClaudeMessageContent = data => {
+  if (!data || typeof data !== 'object') return [];
+  return asArray(data.message?.content).filter(item => item && typeof item === 'object');
+};
+
+const normalizeToolResultError = value => {
+  if (typeof value === 'string')
+    return value
+      .replace(/^<tool_use_error>/, '')
+      .replace(/<\/tool_use_error>$/, '')
+      .trim();
+  if (value === null || value === undefined) return null;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+export const collectClaudeStreamEventFacts = data => {
+  const facts = {
+    messageCountDelta: 0,
+    toolUseCountDelta: 0,
+    lastText: null,
+    toolResultError: null,
+    compactionSummary: null,
+  };
+  if (!data || typeof data !== 'object') return facts;
+
+  if (data.type === 'message' || data.type === 'assistant' || data.type === 'user') facts.messageCountDelta = 1;
+  if (data.type === 'tool_use') facts.toolUseCountDelta = 1;
+
+  for (const item of getClaudeMessageContent(data)) {
+    if (item.type === 'tool_use') facts.toolUseCountDelta++;
+    if (item.type === 'text' && typeof item.text === 'string' && item.text.trim()) {
+      facts.lastText = item.text;
+      if (data.type === 'user' && data.isSynthetic === true && item.text.includes('This session is being continued from a previous conversation') && item.text.includes('Summary:')) {
+        facts.compactionSummary = item.text;
+      }
+    }
+    if (item.type === 'tool_result' && item.is_error === true) facts.toolResultError = normalizeToolResultError(item.content);
+  }
+
+  if (!facts.toolResultError && typeof data.tool_use_result === 'string' && data.tool_use_result.trim().startsWith('Error:')) {
+    facts.toolResultError = data.tool_use_result.trim();
+  }
+
+  return facts;
+};
+
+export const shouldFailClaudeStreamWithoutResult = ({ commandFailed, streamingInput, resultEventReceived }) => {
+  return !commandFailed && !streamingInput && !resultEventReceived;
+};
+
+export const buildMissingClaudeResultMessage = ({ lastToolResultError, lastMessage }) => {
+  const detail = lastToolResultError || lastMessage;
+  if (!detail) return 'Claude stream ended without a terminal result event';
+  return `Claude stream ended without a terminal result event after: ${String(detail).slice(0, 500)}`;
+};