@link-assistant/hive-mind 1.23.0 → 1.23.2

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @link-assistant/hive-mind
 
+## 1.23.2
+
+### Patch Changes
+
+- 241ce36: Fix false error categorization and missing log upload for `--tool agent` auto-restart
+  - Fix `isUsageLimitError()` "resets" pattern causing false positives when scanning code output
+    - Changed from substring match to regex that requires time-like content after "resets"
+    - Prevents ordinary English words like "loads a shell and resets" from triggering usage limit detection
+  - Fix agent fallback pattern matching running after agent successfully recovered from errors
+    - Skip fallback when exitCode=0 and agentCompletedSuccessfully to prevent false error detection
+  - Upload failure logs when auto-restart iteration fails for `--tool agent` with `--attach-logs`
+  - Add comprehensive tests for false positive scenarios (Issue #1290)
+
+## 1.23.1
+
+### Patch Changes
+
+- 5c635fc: Fix agent tool error handling: upload failure logs to PR even when sessionId is not available
+  - Remove overly strict sessionId requirement for failure log upload in solve.mjs
+  - Add FreeUsageLimitError pattern detection for Agent/OpenCode Zen rate limits
+  - Improve rate limit detection by checking multiple sources (lastMessage, errorMatch, fullOutput)
+  - Add comprehensive case study documentation for issue #1287
+  - Add tests for FreeUsageLimitError detection
+
 ## 1.23.0
 
 ### Minor Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -784,7 +784,10 @@ export const executeAgentCommand = async params => {
       // Issue #1258: Fallback pattern match for error detection
       // When JSON parsing fails (e.g., multi-line pretty-printed JSON in logs),
       // we need to detect error patterns in the raw output string
-      if (!outputError.detected && !streamingErrorDetected) {
+      // Issue #1290: Skip fallback when agent completed successfully with exit code 0
+      // The fallback can cause false positives when error events (like AI_JSONParseError)
+      // appear in the output but the agent recovered and completed successfully
+      if (!outputError.detected && !streamingErrorDetected && !(exitCode === 0 && agentCompletedSuccessfully)) {
         // Check for error type patterns in raw output (handles pretty-printed JSON)
         const errorTypePatterns = [
           { pattern: '"type": "error"', type: 'AgentError' },
@@ -848,7 +851,18 @@ export const executeAgentCommand = async params => {
         };
 
         // Check for usage limit errors first (more specific)
-        const limitInfo = detectUsageLimit(lastMessage);
+        // Issue #1287: Check multiple sources for usage limit detection:
+        // 1. lastMessage (the last chunk of output)
+        // 2. errorMatch (the extracted error message from JSON output)
+        // 3. fullOutput (complete output - fallback)
+        let limitInfo = detectUsageLimit(lastMessage);
+        if (!limitInfo.isUsageLimit && outputError.match) {
+          limitInfo = detectUsageLimit(outputError.match);
+        }
+        if (!limitInfo.isUsageLimit) {
+          // Fallback: scan fullOutput for usage limit patterns
+          limitInfo = detectUsageLimit(fullOutput);
+        }
         if (limitInfo.isUsageLimit) {
           limitReached = true;
           limitResetTime = limitInfo.resetTime;

package/src/solve.mjs

@@ -1112,7 +1112,9 @@ try {
     }
 
     // If --attach-logs is enabled and we have a PR, attach failure logs before exiting
-    if (shouldAttachLogs && sessionId && global.createdPR && global.createdPR.number) {
+    // Note: sessionId is not required - logs should be uploaded even if agent failed before establishing a session
+    // This aligns with the pattern in handleFailure() in solve.error-handlers.lib.mjs
+    if (shouldAttachLogs && global.createdPR && global.createdPR.number) {
       await log('\n📄 Attaching failure logs to Pull Request...');
       try {
         // Build Claude CLI resume command
@@ -1365,7 +1367,10 @@ try {
 
     // Attach updated logs to PR after auto-restart completes
     // Issue #1154: Skip if logs were already uploaded by verifyResults() to prevent duplicates
-    if (shouldAttachLogs && prNumber && !logsAlreadyUploaded) {
+    // Issue #1290: Always upload if auto-restart ran but last iteration's logs weren't uploaded
+    //   This ensures final logs are uploaded even when the last iteration failed
+    const autoRestartRanButNotUploaded = watchResult?.autoRestartIterationsRan && !watchResult?.lastIterationLogUploaded;
+    if (shouldAttachLogs && prNumber && (!logsAlreadyUploaded || autoRestartRanButNotUploaded)) {
       await log('📎 Uploading working session logs to Pull Request...');
       try {
         const logUploadSuccess = await attachLogToGitHub({
@@ -1392,8 +1397,8 @@ try {
       } catch (uploadError) {
         await log(`⚠️  Error uploading logs: ${uploadError.message}`, { level: 'warning' });
       }
-    } else if (logsAlreadyUploaded) {
-      await log('ℹ️  Logs already uploaded by verifyResults, skipping duplicate upload', { verbose: true });
+    } else if (logsAlreadyUploaded && !autoRestartRanButNotUploaded) {
+      await log('ℹ️  Logs already uploaded by verifyResults, skipping duplicate upload');
       logsAttached = true;
     }
   }

package/src/solve.watch.lib.mjs

@@ -51,6 +51,11 @@ export const watchForFeedback = async params => {
   let latestSessionId = null;
   let latestAnthropicCost = null;
 
+  // Issue #1290: Track whether auto-restart iterations actually ran and whether logs were uploaded
+  // This helps solve.mjs decide whether to upload final logs
+  let autoRestartIterationsRan = false;
+  let lastIterationLogUploaded = false;
+
   // Track consecutive API errors for retry limit
   const MAX_API_ERROR_RETRIES = 3;
   let consecutiveApiErrors = 0;
@@ -168,6 +173,8 @@ export const watchForFeedback = async params => {
 
           // Increment auto-restart counter and log restart number
           autoRestartCount++;
+          autoRestartIterationsRan = true; // Issue #1290: Mark that auto-restart iterations ran
+          lastIterationLogUploaded = false; // Reset log upload tracking for new iteration
           const restartLabel = firstIterationInTemporaryMode ? 'Initial restart' : `Restart ${autoRestartCount}/${maxAutoRestartIterations}`;
           await log(formatAligned('🔄', `${restartLabel}:`, `Running ${argv.tool.toUpperCase()} to handle uncommitted changes...`));
 
@@ -257,6 +264,60 @@ export const watchForFeedback = async params => {
             currentBackoffSeconds = watchInterval;
             await log(formatAligned('⚠️', `${argv.tool.toUpperCase()} execution failed`, 'Will retry in next check', 2));
           }
+
+          // Issue #1290: Upload failure logs for auto-restart iterations when --attach-logs is enabled
+          // This ensures that failed auto-restart sessions still report their logs
+          const shouldAttachLogs = argv.attachLogs || argv['attach-logs'];
+          if (isTemporaryWatch && prNumber && shouldAttachLogs) {
+            await log('');
+            await log(formatAligned('📎', 'Uploading auto-restart failure log...', ''));
+            try {
+              const logFile = getLogFile();
+              if (logFile) {
+                // Use "Auto-restart X/Y Failure Log" format to distinguish from success logs
+                const customTitle = `⚠️ Auto-restart ${autoRestartCount}/${maxAutoRestartIterations} Failure Log`;
+                const logUploadSuccess = await attachLogToGitHub({
+                  logFile,
+                  targetType: 'pr',
+                  targetNumber: prNumber,
+                  owner,
+                  repo,
+                  $,
+                  log,
+                  sanitizeLogContent,
+                  verbose: argv.verbose,
+                  customTitle,
+                  sessionId: toolResult.sessionId || latestSessionId,
+                  tempDir,
+                  // Include error information in the log upload
+                  errorMessage: toolResult.errorInfo?.message || toolResult.result || `${argv.tool.toUpperCase()} execution failed`,
+                  // Include pricing data if available from failed attempt
+                  publicPricingEstimate: toolResult.publicPricingEstimate,
+                  pricingInfo: toolResult.pricingInfo,
+                  // Mark if this was a usage limit failure
+                  isUsageLimit: toolResult.limitReached,
+                  limitResetTime: toolResult.limitResetTime,
+                });
+
+                if (logUploadSuccess) {
+                  await log(formatAligned('', '✅ Auto-restart failure log uploaded to PR', '', 2));
+                  lastIterationLogUploaded = true; // Issue #1290: Mark that logs were uploaded
+                } else {
+                  await log(formatAligned('', '⚠️  Could not upload auto-restart failure log', '', 2));
+                }
+              }
+            } catch (logUploadError) {
+              reportError(logUploadError, {
+                context: 'attach_auto_restart_failure_log',
+                prNumber,
+                owner,
+                repo,
+                autoRestartCount,
+                operation: 'upload_failure_log',
+              });
+              await log(formatAligned('', `⚠️  Log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
+            }
+          }
         } else {
           // Success - reset error counters
           consecutiveApiErrors = 0;
@@ -306,6 +367,7 @@ export const watchForFeedback = async params => {
 
                 if (logUploadSuccess) {
                   await log(formatAligned('', '✅ Auto-restart session log uploaded to PR', '', 2));
+                  lastIterationLogUploaded = true; // Issue #1290: Mark that logs were uploaded
                 } else {
                   await log(formatAligned('', '⚠️  Could not upload auto-restart session log', '', 2));
                 }
@@ -368,9 +430,12 @@ export const watchForFeedback = async params => {
   }
 
   // Return latest session data for accurate pricing in log uploads
+  // Issue #1290: Include flags to help solve.mjs decide whether to upload final logs
   return {
     latestSessionId,
     latestAnthropicCost,
+    autoRestartIterationsRan, // True if any auto-restart iterations actually ran
+    lastIterationLogUploaded, // True if the last iteration's logs were uploaded
   };
 };
 

package/src/usage-limit.lib.mjs

@@ -33,6 +33,7 @@ export function isUsageLimitError(message) {
   const lowerMessage = message.toLowerCase();
 
   // Check for specific usage limit patterns
+  // Supports both plain string patterns (checked via .includes()) and RegExp patterns
   const patterns = [
     // Generic
     "you've hit your usage limit",
@@ -44,7 +45,7 @@ export function isUsageLimitError(message) {
     'rate limit exceeded',
     'limit reached',
     'limit has been reached',
-    // Provider-specific phrasings we’ve seen in the wild
+    // Provider-specific phrasings we've seen in the wild
     'session limit reached', // Claude
     'weekly limit reached', // Claude
     'daily limit reached',
@@ -52,10 +53,21 @@ export function isUsageLimitError(message) {
     'billing hard limit',
     'please try again at', // Codex/OpenCode style
     'available again at',
-    'resets', // Claude shows: “∙ resets 5am”
+    // Claude shows: "∙ resets 5am" or "resets Jan 15, 8am"
+    // Issue #1290: Use regex to avoid false positives when "resets" appears in code output
+    // (e.g., "loads a shell and resets", "Also resets drag start")
+    // Only match "resets" when followed by a time-like pattern (digit or month name)
+    /resets\s+(?:(?:at\s+)?[0-9]|(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))/i,
+    // Agent/OpenCode Zen specific - issue #1287
+    'freeusagelimiterror', // Agent JSON error type
   ];
 
-  return patterns.some(pattern => lowerMessage.includes(pattern));
+  return patterns.some(pattern => {
+    if (pattern instanceof RegExp) {
+      return pattern.test(lowerMessage);
+    }
+    return lowerMessage.includes(pattern);
+  });
 }
 
 /**