@link-assistant/hive-mind 1.78.3 → 1.78.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.78.5
+
+### Patch Changes
+
+- b3d6588: Remove Hive Mind's npm global prefix workaround now that use-m handles non-writable npm global roots upstream.
+
+## 1.78.4
+
+### Patch Changes
+
+- 798c352: Fix Playwright MCP availability detection so pending or unavailable server status no longer enables browser automation hints, surface pending status in interactive session comments, and harden Docker verification so Playwright MCP/CLI availability is checked instead of only grepping for a registration.
+
 ## 1.78.3
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -22,7 +22,7 @@ import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Iss
 import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments.lib.mjs'; // Issue #1625
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
-import { buildMcpConfigWithoutPlaywright } from './playwright-mcp.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';
 import { fetchModelInfo } from './model-info.lib.mjs';
@@ -268,17 +268,7 @@ export const resolveThinkingSettings = async (argv, log) => {
   return { thinkingBudget, thinkLevel, translation, isNewVersion, maxBudget };
 };
 /** Check if Playwright MCP is available and connected to Claude @returns {Promise<boolean>} */
-export const checkPlaywrightMcpAvailability = async () => {
-  try {
-    const result = await $`timeout 5 claude mcp list 2>&1`.catch(() => null);
-    if (!result || result.code !== 0) return false;
-    const output = result.stdout?.toString() || '';
-    if (output.toLowerCase().includes('playwright')) return true;
-    return false;
-  } catch {
-    return false;
-  }
-};
+export const checkPlaywrightMcpAvailability = ensureClaudePlaywrightMcpServer;
 /** Execute Claude with all prompts and settings - main entry point */
 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;

package/src/codex.lib.mjs

@@ -24,7 +24,7 @@ import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
-import { getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs';
+import { ensureCodexPlaywrightMcpServer, getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs';
 import { fetchModelInfo } from './model-info.lib.mjs';
 import { defaultModels } from './models/index.mjs';
 import { classifyRetryableError, getRetryDelayMs, maybeSwitchToFallbackModel, waitWithCountdown } from './tool-retry.lib.mjs';
@@ -573,16 +573,7 @@ export const handleCodexRuntimeSwitch = async () => {
 };
 
 /** Check if Playwright MCP is available and connected to Codex @returns {Promise<boolean>} */
-export const checkPlaywrightMcpAvailability = async () => {
-  try {
-    const result = await $`timeout 5 codex mcp list 2>&1`.catch(() => null);
-    if (!result || result.code !== 0) return false;
-    const output = `${result.stdout?.toString() || ''}${result.stderr?.toString() || ''}`;
-    return output.toLowerCase().includes('playwright');
-  } catch {
-    return false;
-  }
-};
+export const checkPlaywrightMcpAvailability = ensureCodexPlaywrightMcpServer;
 
 // Main function to execute Codex with prompts and settings
 export const executeCodex = async params => {

package/src/interactive-mcp-status.lib.mjs

@@ -0,0 +1,44 @@
+const PLAYWRIGHT_TOOL_PREFIX = 'mcp__playwright__';
+
+export const isUnavailableMcpStatus = status => {
+  const normalized = String(status || '').toLowerCase();
+  return /\b(pending|disabled|failed|error|disconnected|not[-_\s]+connected|unavailable|timed[-_\s]+out)\b|(?:^|[^a-z0-9_-])timeout(?:$|[^a-z0-9_-])/.test(normalized);
+};
+
+export const hasPlaywrightMcpTools = tools => (Array.isArray(tools) ? tools : []).some(tool => String(tool || '').startsWith(PLAYWRIGHT_TOOL_PREFIX));
+
+export const formatInteractiveMcpServerStatus = server => {
+  const name = server?.name || 'unknown';
+  const status = String(server?.status || 'unknown').trim() || 'unknown';
+  const normalizedStatus = status.toLowerCase();
+  let displayStatus = status;
+
+  if (normalizedStatus === 'pending') {
+    displayStatus = 'pending - not connected; MCP tools unavailable';
+  } else if (isUnavailableMcpStatus(status)) {
+    displayStatus = `${status} - MCP tools unavailable`;
+  }
+
+  return `\`${name}\` (${displayStatus})`;
+};
+
+export const getInteractiveMcpDiagnostics = (mcpServers = [], tools = []) => {
+  const servers = Array.isArray(mcpServers) ? mcpServers : [];
+  const diagnostics = [];
+
+  for (const server of servers) {
+    const name = String(server?.name || '').toLowerCase();
+    if (!name.includes('playwright')) continue;
+    if (!isUnavailableMcpStatus(server?.status)) continue;
+    if (hasPlaywrightMcpTools(tools)) continue;
+
+    diagnostics.push(`⚠️ Playwright MCP server is ${server?.status || 'unknown'}, but no \`${PLAYWRIGHT_TOOL_PREFIX}*\` browser tools were exposed. Browser automation hints are disabled until the MCP client reports the server as connected.`);
+  }
+
+  return diagnostics;
+};
+
+export const formatInteractiveMcpServersList = (mcpServers = []) => {
+  const servers = Array.isArray(mcpServers) ? mcpServers : [];
+  return servers.length > 0 ? servers.map(formatInteractiveMcpServerStatus).join(', ') : '_None_';
+};

package/src/interactive-mode.lib.mjs

@@ -39,6 +39,7 @@ import { createCodexEventHandlers } from './interactive-codex-events.lib.mjs';
 import { createSystemLifecycleHandlers } from './interactive-system-events.lib.mjs';
 // Issue #1843: turn base64 image tool-results into inline PR-comment images.
 import { createImageRenderer, extractImagePayload, isImageNode } from './interactive-image-render.lib.mjs';
+import { formatInteractiveMcpServersList, getInteractiveMcpDiagnostics } from './interactive-mcp-status.lib.mjs';
 // Issue #1625: track interactive-mode comment IDs so they're excluded from
 // the "did the AI post anything?" check in checkForAiCreatedComments().
 // Use the session-started marker as the single source of truth for the
@@ -411,7 +412,9 @@ export const createInteractiveHandler = options => {
 
     // Format MCP servers
     const mcpServers = data.mcp_servers || [];
-    const mcpServersList = mcpServers.length > 0 ? mcpServers.map(s => `\`${s.name}\` (${s.status || 'unknown'})`).join(', ') : '_None_';
+    const mcpServersList = formatInteractiveMcpServersList(mcpServers);
+    const mcpDiagnostics = getInteractiveMcpDiagnostics(mcpServers, tools);
+    const mcpDiagnosticsBlock = mcpDiagnostics.length > 0 ? `\n${mcpDiagnostics.map(message => `> ${message}`).join('\n')}\n` : '';
 
     // Format slash commands
     const slashCommands = data.slash_commands || [];
@@ -434,6 +437,7 @@ export const createInteractiveHandler = options => {
 | **MCP Servers** | ${mcpServersList} |
 | **Slash Commands** | ${slashCommandsList} |
 | **Agents** | ${agentsList} |
+${mcpDiagnosticsBlock}
 
 ---
 
@@ -1374,10 +1378,6 @@ export const validateInteractiveModeConfig = async (argv, log) => {
     return false;
   }
 
-  // Check PR requirement
-  // Note: This should be called after PR is created/determined
-  // The actual PR number check happens during execution
-
   await log('🔌 Interactive mode: ENABLED (experimental)', { level: 'info' });
   await log(`   ${argv.tool || 'claude'} output will be posted as PR comments in real-time.`, { level: 'info' });
 

package/src/playwright-mcp.lib.mjs

@@ -15,6 +15,21 @@ export const getCommandResultOutput = result => `${result?.stdout?.toString() ||
 
 export const isCommandResultSuccess = result => getCommandResultCode(result) === 0;
 
+export const PLAYWRIGHT_MCP_UNAVAILABLE_PATTERN = /\b(pending|disabled|failed|error|disconnected|not[-_\s]+connected|unavailable|timed[-_\s]+out)\b|(?:^|[^A-Za-z0-9_-])timeout(?:$|[^A-Za-z0-9_-])|\benabled\s*[:=]?\s*false\b/i;
+export const PLAYWRIGHT_MCP_CONNECTED_PATTERN = /\b(connected|enabled)\b|[✓✔]/i;
+
+export const getPlaywrightMcpListRows = output =>
+  String(output || '')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line.toLowerCase().includes('playwright'));
+
+export const hasConnectedPlaywrightMcpServer = output => {
+  const rows = getPlaywrightMcpListRows(output);
+  if (rows.length === 0) return false;
+  return rows.some(row => PLAYWRIGHT_MCP_CONNECTED_PATTERN.test(row) && !PLAYWRIGHT_MCP_UNAVAILABLE_PATTERN.test(row));
+};
+
 export const checkPlaywrightMcpPackageAvailability = async () => {
   try {
     const result = await $`timeout 5 npx --no-install @playwright/mcp --help 2>&1`.catch(() => null);
@@ -26,6 +41,83 @@ export const checkPlaywrightMcpPackageAvailability = async () => {
   }
 };
 
+export const ensureConnectedPlaywrightMcpServer = async ({ list, add, hasPackage = checkPlaywrightMcpPackageAvailability }) => {
+  try {
+    const result = await list().catch(() => null);
+    if (!isCommandResultSuccess(result)) return false;
+    const output = getCommandResultOutput(result);
+    if (hasConnectedPlaywrightMcpServer(output)) return true;
+    if (getPlaywrightMcpListRows(output).length > 0) return false;
+    if (!(await hasPackage())) return false;
+
+    await add().catch(() => null);
+    const retryResult = await list().catch(() => null);
+    return isCommandResultSuccess(retryResult) && hasConnectedPlaywrightMcpServer(getCommandResultOutput(retryResult));
+  } catch {
+    return false;
+  }
+};
+
+export const ensureClaudePlaywrightMcpServer = async () =>
+  ensureConnectedPlaywrightMcpServer({
+    list: () => $`timeout 5 claude mcp list 2>&1`,
+    add: () => $`claude mcp add playwright -s user -- npx -y @playwright/mcp@latest --isolated --headless --no-sandbox --timeout-action=600000 --viewport-size 1920x1080`,
+  });
+
+export const ensureCodexPlaywrightMcpServer = async () =>
+  ensureConnectedPlaywrightMcpServer({
+    list: () => $`timeout 5 codex mcp list 2>&1`,
+    add: () => $`codex mcp add playwright -- npx -y @playwright/mcp@latest --isolated --headless --no-sandbox --timeout-action=600000 --viewport-size 1920x1080`,
+  });
+
+const SOLVE_PLAYWRIGHT_MCP_CHECKS = {
+  claude: ensureClaudePlaywrightMcpServer,
+  codex: ensureCodexPlaywrightMcpServer,
+  opencode: checkPlaywrightMcpPackageAvailability,
+  agent: checkPlaywrightMcpPackageAvailability,
+  gemini: checkPlaywrightMcpPackageAvailability,
+  qwen: checkPlaywrightMcpPackageAvailability,
+};
+
+const SOLVE_PLAYWRIGHT_MCP_LABELS = {
+  claude: 'Claude Code',
+  codex: 'Codex',
+  opencode: 'OpenCode',
+  agent: 'Agent',
+  gemini: 'Gemini',
+  qwen: 'Qwen Code',
+};
+
+export const getSolvePlaywrightMcpCheckTool = (argv = {}) => argv.tool || 'claude';
+
+export const ensureSolvePlaywrightMcpReady = async ({ argv = {}, log = async () => {}, checks = SOLVE_PLAYWRIGHT_MCP_CHECKS } = {}) => {
+  if (argv.playwrightMcp === false) {
+    await log('🎭 Playwright MCP preflight skipped because --no-playwright-mcp is set', { verbose: true });
+    return { ok: true, checkedTools: [], skipped: true };
+  }
+
+  const tool = getSolvePlaywrightMcpCheckTool(argv);
+  const label = SOLVE_PLAYWRIGHT_MCP_LABELS[tool] || tool;
+  const checkFn = checks[tool] || SOLVE_PLAYWRIGHT_MCP_CHECKS[tool] || checkPlaywrightMcpPackageAvailability;
+  await log(`🎭 Checking Playwright MCP preflight for ${label}...`, { verbose: true });
+
+  try {
+    if (await checkFn()) {
+      await log(`🎭 Playwright MCP ready for ${label}`, { verbose: true });
+      return { ok: true, checkedTools: [tool], skipped: false };
+    }
+  } catch (error) {
+    await log(`⚠️  Playwright MCP preflight check threw for ${label}: ${error.message}`, { verbose: true });
+  }
+
+  await log('', { level: 'error' });
+  await log(`❌ Playwright MCP preflight failed for ${label}`, { level: 'error' });
+  await log('   Playwright support is enabled by default, so solve stops before starting an AI working session.', { level: 'error' });
+  await log('   Fix the MCP registration or run with --no-playwright-mcp only when browser automation is intentionally disabled.', { level: 'error' });
+  await log('');
+  return { ok: false, checkedTools: [tool], skipped: false };
+};
+
 export const parseCodexMcpServerNames = output =>
   output
     .split(/\r?\n/)

package/src/solve.mjs

@@ -33,7 +33,7 @@ const { setupTempDirectory, cleanupTempDirectory } = repository;
 const results = await import('./solve.results.lib.mjs');
 const { cleanupClaudeFile, showSessionSummary, verifyResults, buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand, buildSolveResumeCommand, maybeAttachWorkingSessionSummary, verifyPullRequestIssueLinkAfterAutoRestart } = results;
 const claudeLib = await import('./claude.lib.mjs');
-const { executeClaude, checkPlaywrightMcpAvailability } = claudeLib;
+const { executeClaude } = claudeLib;
 const githubLinking = await import('./github-linking.lib.mjs');
 const { extractLinkedIssueNumber } = githubLinking;
 const usageLimitLib = await import('./usage-limit.lib.mjs');
@@ -244,9 +244,20 @@ if (argv.planModel) {
 
 // Perform all system checks (skip tool connection check in dry-run or when --skip-tool-connection-check; model validation always runs)
 const skipToolConnectionCheck = argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false;
+const { cascadePlaywrightMcpDisable, ensureSolvePlaywrightMcpReady } = await import('./playwright-mcp.lib.mjs');
+await cascadePlaywrightMcpDisable(argv, log);
 if (!(await performSystemChecks(argv.minDiskSpace || 2048, skipToolConnectionCheck, argv.model, argv))) {
   await safeExit(1, 'System checks failed');
 }
+// Playwright MCP preflight is local/free and stays independent from paid tool connection checks.
+if (!argv.dryRun && argv.playwrightMcp !== false) {
+  const playwrightMcpPreflight = await ensureSolvePlaywrightMcpReady({ argv, log });
+  if (!playwrightMcpPreflight.ok) {
+    await safeExit(1, 'Playwright MCP preflight failed');
+  }
+} else if (argv.dryRun && argv.playwrightMcp !== false) {
+  await log('⏩ Skipping Playwright MCP preflight (dry-run mode)', { verbose: true });
+}
 // URL validation debug logging
 if (argv.verbose) {
   await log('📋 URL validation:', { verbose: true });
@@ -692,24 +703,6 @@ try {
     $,
   });
 
-  const { cascadePlaywrightMcpDisable } = await import('./playwright-mcp.lib.mjs');
-  await cascadePlaywrightMcpDisable(argv, log);
-
-  async function resolvePlaywrightMcp(checkFn) {
-    if (argv.playwrightMcp === false) return;
-    if (argv.promptPlaywrightMcp) {
-      const available = await checkFn();
-      if (available) {
-        await log('🎭 Playwright MCP detected - enabling browser automation hints', { verbose: true });
-      } else {
-        await log('ℹ️  Playwright MCP not detected - browser automation hints will be disabled', { verbose: true });
-        argv.promptPlaywrightMcp = false;
-      }
-    } else {
-      await log('ℹ️  Playwright MCP explicitly disabled via --no-prompt-playwright-mcp', { verbose: true });
-    }
-  }
-
   // Execute tool command with all prompts and settings
   let toolResult;
 
@@ -734,7 +727,6 @@ try {
     }
 
     await log(`\n[agent-commander] Using agent-commander for ${argv.tool || 'claude'} execution`);
-    await agentCommanderLib.resolvePlaywrightMcpForAgentCommander({ argv, log, tool: argv.tool || 'claude' });
 
     toolResult = await agentCommanderLib.executeWithAgentCommander({
       issueUrl,
@@ -768,7 +760,6 @@ try {
       qwen: { lib: './qwen.lib.mjs', execFn: 'executeQwen', envVar: 'QWEN_PATH', defaultBin: 'qwen', pathKey: 'qwenPath' },
     }[argv.tool];
     const toolLib = await import(toolDispatch.lib);
-    await resolvePlaywrightMcp(toolLib.checkPlaywrightMcpAvailability);
 
     toolResult = await toolLib[toolDispatch.execFn]({
       issueUrl,
@@ -796,9 +787,6 @@ try {
     });
   } else {
     // Default to Claude
-    if (argv.tool === 'claude' || !argv.tool) {
-      await resolvePlaywrightMcp(checkPlaywrightMcpAvailability);
-    }
     const claudeResult = await executeClaude({
       issueUrl,
       issueNumber,

package/src/use-m-bootstrap.lib.mjs

@@ -1,21 +1,16 @@
 #!/usr/bin/env node
 
-import { ensureWritableNpmGlobalPrefix } from './npm-global-prefix.lib.mjs';
-
 const defaultFetchUseMCode = async () => (await fetch('https://unpkg.com/use-m/use.js')).text();
 
 /**
- * Load the use-m bootstrap after npm's global prefix has been made safe for
- * use-m's Node resolver.
+ * Load the shared use-m bootstrap.
  *
  * @param {object} [options]
- * @param {(message: string) => void} [options.log]
  * @param {() => Promise<string>} [options.fetchUseMCode]
  * @returns {Promise<Function>} The global use-m `use` function.
  */
 export const ensureUseM = async (options = {}) => {
-  const { log = message => console.log(message), fetchUseMCode = defaultFetchUseMCode } = options;
-  await ensureWritableNpmGlobalPrefix({ log });
+  const { fetchUseMCode = defaultFetchUseMCode } = options;
   if (typeof globalThis.use === 'undefined') {
     globalThis.use = (await eval(await fetchUseMCode())).use;
   }

package/src/version-info.lib.mjs

@@ -9,6 +9,7 @@
 
 import { getVersion } from './version.lib.mjs';
 import { t } from './i18n.lib.mjs';
+import { hasConnectedPlaywrightMcpServer } from './playwright-mcp.lib.mjs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 
@@ -1221,8 +1222,8 @@ export function formatVersionMessage(versions, options = {}) {
   // Playwright MCP: show version with Claude Code and Codex connection status inline
   if (versions.playwrightMcp) {
     const mcpVersion = parseVersion('playwrightMcp', versions.playwrightMcp);
-    const claudeStatus = versions.playwrightMcpClaudeStatus ? vt('connected', {}, vOptions) : vt('not_connected', {}, vOptions);
-    const codexStatus = versions.playwrightMcpCodexStatus ? vt('connected', {}, vOptions) : vt('not_connected', {}, vOptions);
+    const claudeStatus = hasConnectedPlaywrightMcpServer(versions.playwrightMcpClaudeStatus) ? vt('connected', {}, vOptions) : vt('not_connected', {}, vOptions);
+    const codexStatus = hasConnectedPlaywrightMcpServer(versions.playwrightMcpCodexStatus) ? vt('connected', {}, vOptions) : vt('not_connected', {}, vOptions);
     browserAutoLines.push(`• Playwright MCP: \`${mcpVersion} | Claude Code: ${claudeStatus} | Codex: ${codexStatus}\``);
   }
   addVersionLine(browserAutoLines, 'Puppeteer Browsers', versions.puppeteerBrowsers, 'puppeteerBrowsers');

package/src/npm-global-prefix.lib.mjs

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Ensure npm's global install directory is writable before `use-m` runs.
- *
- * Issue #1897: `use-m` loads runtime dependencies (command-stream, getenv,
- * yargs, …) by shelling out to `npm install -g <alias>@npm:<pkg>@latest`.
- * npm installs into the global prefix reported by `npm root -g`. When the
- * CLI is launched with a system-wide Node.js whose global `node_modules`
- * directory is owned by root (e.g. `/opt/node-v24.16.0-linux-x64/lib/node_modules`),
- * the install fails with `EACCES: permission denied` and the whole process
- * crashes at the very first `use()` call with an unhandled error:
- *
- *   Error: Failed to install command-stream@latest globally.
- *     ... npm error code EACCES
- *     ... npm error syscall rename
- *     ... npm error path /opt/node-.../lib/node_modules/command-stream-v-latest
- *
- * This commonly happens when the package was installed with one runtime
- * (e.g. `bun add -g`, which writes to a user-owned `~/.bun/...`) but launched
- * under a system Node whose global prefix needs root.
- *
- * The fix mirrors npm's own documented recommendation for EACCES errors:
- * point the global prefix at a user-writable directory. We detect the
- * non-writable prefix up front and redirect `npm_config_prefix` (which both
- * `npm install -g` and `npm root -g` honour) to `~/.npm-global`, so use-m's
- * install succeeds without sudo. When the prefix is already writable we do
- * nothing — the common case stays a no-op with no extra `npm` spawn.
- */
-
-import { access, mkdir } from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { homedir } from 'node:os';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-
-/**
- * Derive the likely global `node_modules` path from the Node binary location
- * without spawning npm. For a standard POSIX layout the node binary lives at
- * `<prefix>/bin/node` and global packages at `<prefix>/lib/node_modules`.
- *
- * @param {string} execPath - Absolute path to the running node binary.
- * @returns {string} Candidate global `node_modules` directory.
- */
-export const deriveGlobalNodeModules = execPath => join(dirname(dirname(execPath)), 'lib', 'node_modules');
-
-/**
- * Check whether a directory is writable, walking up to the nearest existing
- * ancestor when the leaf does not yet exist (npm would create it on install).
- *
- * @param {string} startDir - Directory to test.
- * @param {(path: string, mode: number) => Promise<void>} accessFn - fs.access.
- * @returns {Promise<boolean>}
- */
-export const isPathWritable = async (startDir, accessFn = access) => {
-  let current = startDir;
-  for (;;) {
-    try {
-      await accessFn(current, fsConstants.W_OK);
-      return true;
-    } catch (error) {
-      if (error && error.code === 'ENOENT') {
-        const parent = dirname(current);
-        if (parent === current) return false; // reached filesystem root
-        current = parent;
-        continue;
-      }
-      // EACCES / EPERM / anything else → treat as not writable.
-      return false;
-    }
-  }
-};
-
-const queryNpmRoot = async runner => {
-  try {
-    const { stdout } = await runner('npm root -g');
-    const value = String(stdout).trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Detect a non-writable npm global prefix and, if found, redirect global
- * installs to a user-writable directory by setting `npm_config_prefix`.
- *
- * Idempotent and dependency-injectable for tests. Returns an object describing
- * what happened: `{ changed: boolean, reason: string, prefix?, previousRoot? }`.
- *
- * @param {object} [options]
- * @param {Record<string, string>} [options.env=process.env] - Environment to mutate.
- * @param {string} [options.execPath=process.execPath] - Running node binary path.
- * @param {string} [options.platform=process.platform] - OS platform.
- * @param {string} [options.home] - User home directory.
- * @param {Function} [options.accessFn=fs.access]
- * @param {Function} [options.mkdirFn=fs.mkdir]
- * @param {Function} [options.runner=execAsync] - Runs a shell command, returns {stdout}.
- * @param {(message: string) => void} [options.log] - Informational logger.
- * @returns {Promise<{changed: boolean, reason: string, prefix?: string, previousRoot?: string, error?: Error}>}
- */
-export const ensureWritableNpmGlobalPrefix = async (options = {}) => {
-  const { env = process.env, execPath = process.execPath, platform = process.platform, home = homedir(), accessFn = access, mkdirFn = mkdir, runner = execAsync, log = () => {}, isBunRuntime = typeof Bun !== 'undefined', isDenoRuntime = typeof Deno !== 'undefined' } = options;
-
-  // Windows' global layout differs (`<prefix>/node_modules`, AppData), and the
-  // EACCES scenario this guards against is POSIX-specific. Skip to avoid false
-  // positives that would needlessly relocate the prefix.
-  if (platform === 'win32') return { changed: false, reason: 'win32' };
-
-  // This workaround only protects use-m's Node/npm resolver. Bun and Deno use
-  // different install paths and should not have npm configuration changed.
-  if (isBunRuntime) return { changed: false, reason: 'bun-runtime' };
-  if (isDenoRuntime) return { changed: false, reason: 'deno-runtime' };
-
-  // Respect an explicitly configured prefix — the user (or a parent process)
-  // already chose where global installs go.
-  if (env.npm_config_prefix || env.NPM_CONFIG_PREFIX) return { changed: false, reason: 'preset' };
-
-  // Fast path: derive the likely global node_modules from the node binary and
-  // check writability without spawning npm. Most installs land here.
-  const derived = deriveGlobalNodeModules(execPath);
-  if (await isPathWritable(derived, accessFn)) {
-    return { changed: false, reason: 'writable' };
-  }
-
-  // The cheap heuristic says non-writable. Confirm against the authoritative
-  // path npm/use-m actually use before changing anything (handles custom prefixes).
-  const authoritative = (await queryNpmRoot(runner)) || derived;
-  if (await isPathWritable(authoritative, accessFn)) {
-    return { changed: false, reason: 'writable' };
-  }
-
-  // Global prefix is genuinely not writable by the current user (issue #1897).
-  if (!home) {
-    return { changed: false, reason: 'no-home' };
-  }
-
-  const prefix = join(home, '.npm-global');
-  try {
-    // npm installs into `<prefix>/lib/node_modules`; create it so the very
-    // first `npm install -g` does not have to.
-    await mkdirFn(join(prefix, 'lib', 'node_modules'), { recursive: true });
-  } catch (error) {
-    return { changed: false, reason: 'mkdir-failed', error };
-  }
-
-  env.npm_config_prefix = prefix;
-  // Make globally-installed binaries from the new prefix resolvable too.
-  const binDir = join(prefix, 'bin');
-  const pathParts = String(env.PATH || '').split(':');
-  if (!pathParts.includes(binDir)) {
-    env.PATH = env.PATH ? `${binDir}:${env.PATH}` : binDir;
-  }
-
-  log(`ℹ️  npm global directory (${authoritative}) is not writable; redirecting global installs to ${prefix} (issue #1897).`);
-  return { changed: true, reason: 'redirected', prefix, previousRoot: authoritative };
-};