@link-assistant/hive-mind 2.0.14 → 2.0.16

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- 0d2f2bb: Fix "Cannot read properties of null (reading 'type')" crash that aborted Codex (and other agent) runs when the tool echoed a stream line that parsed to a bare `null` or non-object JSON primitive. All NDJSON stream parsers (Codex, Claude, Agent, OpenCode) now ignore non-object lines instead of dereferencing them.
+
 ## 2.0.14
 
 ### Patch Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -542,6 +542,9 @@ export const executeAgentCommand = async params => {
             if (!line.trim()) continue;
             try {
               const data = sanitizeObjectStrings(JSON.parse(line));
+              // Issue #1968: a bare `null`/primitive NDJSON line must not abort
+              // event processing (any data.X access would throw on null).
+              if (data === null || typeof data !== 'object') continue;
               // Output formatted JSON
               await log(JSON.stringify(data, null, 2));
               // Capture session ID from the first message
@@ -616,6 +619,8 @@ export const executeAgentCommand = async params => {
               if (!stderrLine.trim()) continue;
               try {
                 const stderrData = sanitizeObjectStrings(JSON.parse(stderrLine));
+                // Issue #1968: skip bare `null`/primitive lines (see stdout handler above).
+                if (stderrData === null || typeof stderrData !== 'object') continue;
                 // Output formatted JSON (same formatting as stdout)
                 await log(JSON.stringify(stderrData, null, 2));
                 // Capture session ID from stderr too (agent sends it via stderr)
@@ -695,6 +700,9 @@ export const executeAgentCommand = async params => {
           try {
             const msg = sanitizeObjectStrings(JSON.parse(line));
 
+            // Issue #1968: ignore bare `null`/primitive lines (msg.type would throw on null).
+            if (msg === null || typeof msg !== 'object') continue;
+
             // Check for explicit error message types from agent
             if (msg.type === 'error' || msg.type === 'step_error') {
               return { detected: true, type: 'AgentError', match: msg.message || msg.error || line.substring(0, 100) };

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
@@ -872,6 +836,7 @@ export const executeClaudeCommand = async params => {
             if (!line.trim()) continue;
             try {
               const data = sanitizeObjectStrings(JSON.parse(line));
+              if (data === null || typeof data !== 'object') continue; // Issue #1968: skip bare null/primitive NDJSON lines
               // Issue #1510: Track last event time for all modes (not just interactive)
               // so activity timeout can report accurate idle duration
               lastEventTime = Date.now();
@@ -902,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
@@ -1022,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)
@@ -1110,12 +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
-            // for accumulation (see the 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)}`;
+};

package/src/codex.lib.mjs

@@ -470,6 +470,16 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
       continue;
     }
 
+    // Issue #1968: a stream line that parses to a bare `null` (or any non-object
+    // JSON primitive such as a number/string/boolean) must not crash the parser.
+    // Codex echoes the stdout of every command it runs back into its own NDJSON
+    // stream (see issue #1955), so a target repo that prints a standalone `null`
+    // line surfaces here as `JSON.parse('null') === null`. Accessing `data.type`
+    // on that null threw "Cannot read properties of null (reading 'type')" and
+    // aborted the entire solve. Real Codex events are always JSON objects, so any
+    // non-object line is safely ignored.
+    if (data === null || typeof data !== 'object') continue;
+
     const eventType = typeof data.type === 'string' ? data.type : 'unknown';
     nextState.eventCounts[eventType] = (nextState.eventCounts[eventType] || 0) + 1;
 
@@ -1044,6 +1054,9 @@ export const executeCodexCommand = async params => {
               if (!line) continue;
               try {
                 const data = sanitizeObjectStrings(JSON.parse(line));
+                // Issue #1968: skip bare `null`/primitive lines so the handlers
+                // below never receive a non-object event (see parseCodexExecJsonOutput).
+                if (data === null || typeof data !== 'object') continue;
                 if (interactiveHandler) await interactiveHandler.processEvent(data);
                 if (progressMonitor) await progressMonitor.processStreamEvent(data);
               } catch {

package/src/opencode.lib.mjs

@@ -342,6 +342,9 @@ export const executeOpenCodeCommand = async params => {
             for (const line of lines) {
               if (!line.trim()) continue;
               const data = sanitizeObjectStrings(JSON.parse(line));
+              // Issue #1968: a bare `null`/primitive NDJSON line must not abort the
+              // rest of the chunk (data.type access would throw on null).
+              if (data === null || typeof data !== 'object') continue;
               accumulateAgentStepFinishUsage(streamingTokenUsage, data);
               // Track text content for result summary
               // OpenCode outputs text via 'text', 'assistant', 'message', or 'result' type events
@@ -385,6 +388,8 @@ export const executeOpenCodeCommand = async params => {
               for (const line of lines) {
                 if (!line.trim()) continue;
                 const data = sanitizeObjectStrings(JSON.parse(line));
+                // Issue #1968: skip bare `null`/primitive lines (see stdout handler above).
+                if (data === null || typeof data !== 'object') continue;
                 accumulateAgentStepFinishUsage(streamingTokenUsage, data);
                 if (data.type === 'text' && data.text) {
                   lastTextContent = data.text;