@link-assistant/hive-mind 2.12.0 → 2.12.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @link-assistant/hive-mind
 
+## 2.12.2
+
+### Patch Changes
+
+- a33befc: Document native multi-architecture container builds, build caching, release independence, and published-manifest verification in the CI/CD guide.
+
+## 2.12.1
+
+### Patch Changes
+
+- d606c77: Restore Node 24 command execution, make runtime-loaded dependencies reproducible,
+  and strengthen CI status, security, warning, and smoke-test enforcement.
+- 098b01a: Report auto-resumed limit-reset sessions with their start marker, summary, and execution log.
+
 ## 2.12.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.12.0",
+  "version": "2.12.2",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -88,5 +88,8 @@
     "*.{js,mjs,json,md}": [
       "prettier --write"
     ]
+  },
+  "allowScripts": {
+    "@sentry/node-cpu-profiler@2.4.2": true
   }
 }

package/src/claude.connection.lib.mjs

@@ -0,0 +1,209 @@
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+if (typeof globalThis.use === 'undefined') {
+  await ensureUseM();
+}
+const { $ } = await use('command-stream');
+import { log } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+import { timeouts, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET } from './config.lib.mjs';
+import { buildAuthRemedyLines } from './formal-ai.lib.mjs';
+import { stringifyErrorValue } from './error-text.lib.mjs';
+import { mapModelToId } from './claude.model-utils.lib.mjs';
+
+export const validateClaudeConnection = async (model = 'haiku') => {
+  const mappedModel = mapModelToId(model);
+  // Issue #2130: "run claude login" is wrong advice for a Formal-AI-served model.
+  const authRemedyLines = buildAuthRemedyLines({ model, vendorRemedy: 'Please run: claude login' });
+  const maxRetries = 3;
+  const baseDelay = timeouts.retryBaseDelay;
+  let retryCount = 0;
+  const attemptValidation = async () => {
+    try {
+      if (retryCount === 0) {
+        await log('🔍 Validating Claude CLI connection...');
+      } else {
+        await log(`🔄 Retry attempt ${retryCount}/${maxRetries} for Claude CLI validation...`);
+      }
+      try {
+        const versionResult = await $`timeout ${Math.floor(timeouts.claudeCli / 6000)} claude --version`;
+        if (versionResult.code === 0) {
+          const version = versionResult.stdout?.toString().trim();
+          detectedClaudeVersion = version; // issue #1146
+          if (retryCount === 0) {
+            await log(`📦 Claude CLI version: ${version}`);
+          }
+        }
+      } catch (versionError) {
+        if (retryCount === 0) {
+          await log(`⚠️  Claude CLI version check failed (${versionError.code}), proceeding with connection test...`);
+        }
+      }
+      let result;
+      try {
+        result = await $`printf hi | claude --model ${mappedModel} -p`;
+      } catch (pipeError) {
+        await log(`⚠️  Pipe validation failed (${pipeError.code}), trying timeout approach...`);
+        try {
+          result = await $`timeout ${Math.floor(timeouts.claudeCli / 1000)} claude --model ${mappedModel} -p hi`;
+        } catch (timeoutError) {
+          if (timeoutError.code === 124) {
+            await log(`❌ Claude CLI timed out after ${Math.floor(timeouts.claudeCli / 1000)} seconds`, {
+              level: 'error',
+            });
+            await log('   💡 This may indicate Claude CLI is taking too long to respond', { level: 'error' });
+            await log(`   💡 Try running 'claude --model ${mappedModel} -p hi' manually to verify it works`, {
+              level: 'error',
+            });
+            return false;
+          }
+          throw timeoutError;
+        }
+      }
+      const stdout = result.stdout?.toString() || '';
+      const stderr = result.stderr?.toString() || '';
+      const checkForJsonError = text => {
+        try {
+          if (text.includes('"error"') && text.includes('"type"')) {
+            const jsonMatch = text.match(/\{.*"error".*\}/);
+            if (jsonMatch) {
+              const errorObj = JSON.parse(jsonMatch[0]);
+              return stringifyErrorValue(errorObj.error, { fallback: jsonMatch[0] }); // Issue #2141: the `error` field is usually an object
+            }
+          }
+        } catch (e) {
+          if (global.verboseMode) {
+            reportError(e, {
+              context: 'claude_json_error_parse',
+              level: 'debug',
+            });
+          }
+        }
+        return null;
+      };
+      const jsonError = checkForJsonError(stdout) || checkForJsonError(stderr);
+      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stdout.includes('API Error: 529') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (stderr.includes('API Error: 529') && stderr.includes('Overloaded')) || (jsonError && (jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded');
+      if (isOverloadError) {
+        if (retryCount < maxRetries) {
+          const delay = baseDelay * Math.pow(2, retryCount);
+          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
+            level: 'warning',
+          });
+          await new Promise(resolve => setTimeout(resolve, delay));
+          retryCount++;
+          return await attemptValidation();
+        } else {
+          await log(`❌ API overload error persisted after ${maxRetries} retries during validation`, {
+            level: 'error',
+          });
+          await log('   The API appears to be heavily loaded. Please try again later.', { level: 'error' });
+          return false;
+        }
+      }
+      const exitCode = result.code ?? result.exitCode ?? 0; // Bun shell compat
+      if (exitCode !== 0) {
+        if (jsonError) {
+          await log(`❌ Claude CLI authentication failed: ${jsonError.type} - ${jsonError.message}`, {
+            level: 'error',
+          });
+        } else {
+          await log(`❌ Claude CLI failed with exit code ${exitCode}`, { level: 'error' });
+          if (stderr) await log(`   Error: ${stderr.trim()}`, { level: 'error' });
+        }
+        if (stderr.includes('Please run /login') || (jsonError && jsonError.type === 'forbidden')) {
+          for (const line of authRemedyLines) await log(line, { level: 'error' });
+        }
+        return false;
+      }
+      if (jsonError) {
+        if ((jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded') {
+          if (retryCount < maxRetries) {
+            const delay = baseDelay * Math.pow(2, retryCount);
+            await log(`⚠️ API overload error in response. Retrying in ${delay / 1000} seconds...`, {
+              level: 'warning',
+            });
+            await new Promise(resolve => setTimeout(resolve, delay));
+            retryCount++;
+            return await attemptValidation();
+          } else {
+            await log(`❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
+            return false;
+          }
+        }
+        await log(`❌ Claude CLI returned error: ${jsonError.type} - ${jsonError.message}`, { level: 'error' });
+        if (jsonError.type === 'forbidden') {
+          for (const line of authRemedyLines) await log(line, { level: 'error' });
+        }
+        return false;
+      }
+      await log('✅ Claude CLI connection validated successfully');
+      return true;
+    } catch (error) {
+      const errorStr = error.message || error.toString();
+      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('API Error: 529') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded')) || (errorStr.includes('overloaded_error') && errorStr.includes('Overloaded'))) {
+        if (retryCount < maxRetries) {
+          const delay = baseDelay * Math.pow(2, retryCount);
+          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
+            level: 'warning',
+          });
+          await new Promise(resolve => setTimeout(resolve, delay));
+          retryCount++;
+          return await attemptValidation();
+        } else {
+          await log(`❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
+          return false;
+        }
+      }
+      await log(`❌ Failed to validate Claude CLI connection: ${error.message}`, { level: 'error' });
+      await log('   💡 Make sure Claude CLI is installed and accessible', { level: 'error' });
+      return false;
+    }
+  };
+  return await attemptValidation();
+};
+// Store Claude Code version globally (set during validation)
+let detectedClaudeVersion = null;
+/** Get the detected Claude Code version @returns {string|null} */
+export const getClaudeVersion = () => detectedClaudeVersion;
+/** Set the detected Claude Code version (called during validation) @param {string} version */
+export const setClaudeVersion = version => {
+  detectedClaudeVersion = version;
+};
+/** Resolve thinking settings based on --think and --thinking-budget options */
+export const resolveThinkingSettings = async (argv, log) => {
+  const minVersion = argv.thinkingBudgetClaudeMinimumVersion || '2.1.12';
+  const version = detectedClaudeVersion || '0.0.0';
+  const isNewVersion = supportsThinkingBudget(version, minVersion);
+  const maxBudget = argv.maxThinkingBudget ?? DEFAULT_MAX_THINKING_BUDGET;
+  const thinkingLevelToTokens = getThinkingLevelToTokens(maxBudget);
+  const tokensToThinkingLevel = getTokensToThinkingLevel(maxBudget);
+  let thinkingBudget = argv.thinkingBudget;
+  let thinkLevel = argv.think;
+  let translation = null;
+  if (isNewVersion) {
+    // Issue #2038: `adaptive` is provider-managed and has no explicit token
+    // budget; skip the budget translation and let the model manage thinking.
+    if (thinkLevel !== undefined && thinkLevel !== 'adaptive' && thinkingBudget === undefined) {
+      thinkingBudget = thinkingLevelToTokens[thinkLevel];
+      translation = `--think ${thinkLevel} → --thinking-budget ${thinkingBudget}`;
+      if (argv.verbose) {
+        await log(`📊 Translating for Claude Code ${version} (>= ${minVersion}):`, { verbose: true });
+        await log(`   ${translation}`, { verbose: true });
+        if (maxBudget !== DEFAULT_MAX_THINKING_BUDGET) {
+          await log(`   Using custom --max-thinking-budget: ${maxBudget}`, { verbose: true });
+        }
+      }
+    }
+  } else {
+    if (thinkingBudget !== undefined && thinkLevel === undefined) {
+      thinkLevel = tokensToThinkingLevel(thinkingBudget);
+      translation = `--thinking-budget ${thinkingBudget} → --think ${thinkLevel}`;
+      if (argv.verbose) {
+        await log(`📊 Translating for Claude Code ${version} (< ${minVersion}):`, { verbose: true });
+        await log(`   ${translation}`, { verbose: true });
+      }
+      thinkingBudget = undefined;
+    }
+  }
+  return { thinkingBudget, thinkLevel, translation, isNewVersion, maxBudget };
+};
+/** Check if Playwright MCP is available and connected to Claude @returns {Promise<boolean>} */

package/src/claude.lib.mjs

@@ -3,12 +3,11 @@ import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 if (typeof globalThis.use === 'undefined') {
   await ensureUseM();
 }
-const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
-import { log, isENOSPC, buildToolErrorMessage } from './lib.mjs';
+import { isENOSPC, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
-import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET, getMaxOutputTokensForModel } from './config.lib.mjs';
+import { timeouts, retryLimits, claudeCode, getClaudeEnv, getMaxOutputTokensForModel } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage, isUsageLimitError } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { setupBidirectionalHandler, finalizeBidirectionalHandler, validateBidirectionalModeConfig, attachStreamingInput } from './bidirectional-interactive.lib.mjs';
@@ -23,7 +22,7 @@ import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels, mapClaudeSubAgentModelToEnvValue } from './models/index.mjs'; // Issue #1221, #1978
 import { applyFormalAiPricingOverride } from './formal-ai-pricing.lib.mjs'; // Issue #2119
-import { buildAuthRemedyLines, isPrepareOnly, logPreparedToolCommand, resolveFormalAiToolExecution } from './formal-ai.lib.mjs';
+import { isPrepareOnly, logPreparedToolCommand, resolveFormalAiToolExecution } from './formal-ai.lib.mjs';
 import { buildMcpConfigWithoutPlaywright, ensureClaudePlaywrightMcpServer } from './playwright-mcp.lib.mjs';
 import { resolveClaudeSessionToolFlags } from './useless-tools.lib.mjs';
 import { ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
@@ -38,206 +37,11 @@ import { formatNumber, mapModelToId, checkModelVisionCapability } from './claude
 import { showResumeCommand } from './claude.resume-output.lib.mjs';
 import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
+import { getClaudeVersion, resolveThinkingSettings, setClaudeVersion, validateClaudeConnection } from './claude.connection.lib.mjs';
 export { availableModels, fetchModelInfo }; // Re-export for backward compatibility
 export { formatNumber, mapModelToId, checkModelVisionCapability };
-export const validateClaudeConnection = async (model = 'haiku') => {
-  const mappedModel = mapModelToId(model);
-  // Issue #2130: "run claude login" is wrong advice for a Formal-AI-served model.
-  const authRemedyLines = buildAuthRemedyLines({ model, vendorRemedy: 'Please run: claude login' });
-  const maxRetries = 3;
-  const baseDelay = timeouts.retryBaseDelay;
-  let retryCount = 0;
-  const attemptValidation = async () => {
-    try {
-      if (retryCount === 0) {
-        await log('🔍 Validating Claude CLI connection...');
-      } else {
-        await log(`🔄 Retry attempt ${retryCount}/${maxRetries} for Claude CLI validation...`);
-      }
-      try {
-        const versionResult = await $`timeout ${Math.floor(timeouts.claudeCli / 6000)} claude --version`;
-        if (versionResult.code === 0) {
-          const version = versionResult.stdout?.toString().trim();
-          detectedClaudeVersion = version; // issue #1146
-          if (retryCount === 0) {
-            await log(`📦 Claude CLI version: ${version}`);
-          }
-        }
-      } catch (versionError) {
-        if (retryCount === 0) {
-          await log(`⚠️  Claude CLI version check failed (${versionError.code}), proceeding with connection test...`);
-        }
-      }
-      let result;
-      try {
-        result = await $`printf hi | claude --model ${mappedModel} -p`;
-      } catch (pipeError) {
-        await log(`⚠️  Pipe validation failed (${pipeError.code}), trying timeout approach...`);
-        try {
-          result = await $`timeout ${Math.floor(timeouts.claudeCli / 1000)} claude --model ${mappedModel} -p hi`;
-        } catch (timeoutError) {
-          if (timeoutError.code === 124) {
-            await log(`❌ Claude CLI timed out after ${Math.floor(timeouts.claudeCli / 1000)} seconds`, {
-              level: 'error',
-            });
-            await log('   💡 This may indicate Claude CLI is taking too long to respond', { level: 'error' });
-            await log(`   💡 Try running 'claude --model ${mappedModel} -p hi' manually to verify it works`, {
-              level: 'error',
-            });
-            return false;
-          }
-          throw timeoutError;
-        }
-      }
-      const stdout = result.stdout?.toString() || '';
-      const stderr = result.stderr?.toString() || '';
-      const checkForJsonError = text => {
-        try {
-          if (text.includes('"error"') && text.includes('"type"')) {
-            const jsonMatch = text.match(/\{.*"error".*\}/);
-            if (jsonMatch) {
-              const errorObj = JSON.parse(jsonMatch[0]);
-              return stringifyErrorValue(errorObj.error, { fallback: jsonMatch[0] }); // Issue #2141: the `error` field is usually an object
-            }
-          }
-        } catch (e) {
-          if (global.verboseMode) {
-            reportError(e, {
-              context: 'claude_json_error_parse',
-              level: 'debug',
-            });
-          }
-        }
-        return null;
-      };
-      const jsonError = checkForJsonError(stdout) || checkForJsonError(stderr);
-      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stdout.includes('API Error: 529') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (stderr.includes('API Error: 529') && stderr.includes('Overloaded')) || (jsonError && (jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded');
-      if (isOverloadError) {
-        if (retryCount < maxRetries) {
-          const delay = baseDelay * Math.pow(2, retryCount);
-          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
-            level: 'warning',
-          });
-          await new Promise(resolve => setTimeout(resolve, delay));
-          retryCount++;
-          return await attemptValidation();
-        } else {
-          await log(`❌ API overload error persisted after ${maxRetries} retries during validation`, {
-            level: 'error',
-          });
-          await log('   The API appears to be heavily loaded. Please try again later.', { level: 'error' });
-          return false;
-        }
-      }
-      const exitCode = result.code ?? result.exitCode ?? 0; // Bun shell compat
-      if (exitCode !== 0) {
-        if (jsonError) {
-          await log(`❌ Claude CLI authentication failed: ${jsonError.type} - ${jsonError.message}`, {
-            level: 'error',
-          });
-        } else {
-          await log(`❌ Claude CLI failed with exit code ${exitCode}`, { level: 'error' });
-          if (stderr) await log(`   Error: ${stderr.trim()}`, { level: 'error' });
-        }
-        if (stderr.includes('Please run /login') || (jsonError && jsonError.type === 'forbidden')) {
-          for (const line of authRemedyLines) await log(line, { level: 'error' });
-        }
-        return false;
-      }
-      if (jsonError) {
-        if ((jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded') {
-          if (retryCount < maxRetries) {
-            const delay = baseDelay * Math.pow(2, retryCount);
-            await log(`⚠️ API overload error in response. Retrying in ${delay / 1000} seconds...`, {
-              level: 'warning',
-            });
-            await new Promise(resolve => setTimeout(resolve, delay));
-            retryCount++;
-            return await attemptValidation();
-          } else {
-            await log(`❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
-            return false;
-          }
-        }
-        await log(`❌ Claude CLI returned error: ${jsonError.type} - ${jsonError.message}`, { level: 'error' });
-        if (jsonError.type === 'forbidden') {
-          for (const line of authRemedyLines) await log(line, { level: 'error' });
-        }
-        return false;
-      }
-      await log('✅ Claude CLI connection validated successfully');
-      return true;
-    } catch (error) {
-      const errorStr = error.message || error.toString();
-      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('API Error: 529') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded')) || (errorStr.includes('overloaded_error') && errorStr.includes('Overloaded'))) {
-        if (retryCount < maxRetries) {
-          const delay = baseDelay * Math.pow(2, retryCount);
-          await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
-            level: 'warning',
-          });
-          await new Promise(resolve => setTimeout(resolve, delay));
-          retryCount++;
-          return await attemptValidation();
-        } else {
-          await log(`❌ API overload error persisted after ${maxRetries} retries`, { level: 'error' });
-          return false;
-        }
-      }
-      await log(`❌ Failed to validate Claude CLI connection: ${error.message}`, { level: 'error' });
-      await log('   💡 Make sure Claude CLI is installed and accessible', { level: 'error' });
-      return false;
-    }
-  };
-  return await attemptValidation();
-};
-export { handleClaudeRuntimeSwitch }; // Re-export from ./claude.runtime-switch.lib.mjs
-// Store Claude Code version globally (set during validation)
-let detectedClaudeVersion = null;
-/** Get the detected Claude Code version @returns {string|null} */
-export const getClaudeVersion = () => detectedClaudeVersion;
-/** Set the detected Claude Code version (called during validation) @param {string} version */
-export const setClaudeVersion = version => {
-  detectedClaudeVersion = version;
-};
-/** Resolve thinking settings based on --think and --thinking-budget options */
-export const resolveThinkingSettings = async (argv, log) => {
-  const minVersion = argv.thinkingBudgetClaudeMinimumVersion || '2.1.12';
-  const version = detectedClaudeVersion || '0.0.0';
-  const isNewVersion = supportsThinkingBudget(version, minVersion);
-  const maxBudget = argv.maxThinkingBudget ?? DEFAULT_MAX_THINKING_BUDGET;
-  const thinkingLevelToTokens = getThinkingLevelToTokens(maxBudget);
-  const tokensToThinkingLevel = getTokensToThinkingLevel(maxBudget);
-  let thinkingBudget = argv.thinkingBudget;
-  let thinkLevel = argv.think;
-  let translation = null;
-  if (isNewVersion) {
-    // Issue #2038: `adaptive` is provider-managed and has no explicit token
-    // budget; skip the budget translation and let the model manage thinking.
-    if (thinkLevel !== undefined && thinkLevel !== 'adaptive' && thinkingBudget === undefined) {
-      thinkingBudget = thinkingLevelToTokens[thinkLevel];
-      translation = `--think ${thinkLevel} → --thinking-budget ${thinkingBudget}`;
-      if (argv.verbose) {
-        await log(`📊 Translating for Claude Code ${version} (>= ${minVersion}):`, { verbose: true });
-        await log(`   ${translation}`, { verbose: true });
-        if (maxBudget !== DEFAULT_MAX_THINKING_BUDGET) {
-          await log(`   Using custom --max-thinking-budget: ${maxBudget}`, { verbose: true });
-        }
-      }
-    }
-  } else {
-    if (thinkingBudget !== undefined && thinkLevel === undefined) {
-      thinkLevel = tokensToThinkingLevel(thinkingBudget);
-      translation = `--thinking-budget ${thinkingBudget} → --think ${thinkLevel}`;
-      if (argv.verbose) {
-        await log(`📊 Translating for Claude Code ${version} (< ${minVersion}):`, { verbose: true });
-        await log(`   ${translation}`, { verbose: true });
-      }
-      thinkingBudget = undefined;
-    }
-  }
-  return { thinkingBudget, thinkLevel, translation, isNewVersion, maxBudget };
-};
-/** Check if Playwright MCP is available and connected to Claude @returns {Promise<boolean>} */
+export { getClaudeVersion, resolveThinkingSettings, setClaudeVersion, validateClaudeConnection };
+export { handleClaudeRuntimeSwitch };
 export const checkPlaywrightMcpAvailability = ensureClaudePlaywrightMcpServer;
 export const executeClaude = async params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, setLogFile, getLogFile, formatAligned, getResourceSnapshot, claudePath, $ } = params;