@link-assistant/hive-mind 1.78.2 → 1.78.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- b346808: Use the latest gh-upload-log package for attached log uploads and rely on its default auto mode/shared repository fallback instead of passing explicit strategy flags.
+
 ## 1.78.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.78.2",
+  "version": "1.78.4",
   "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/github.lib.mjs

@@ -631,7 +631,7 @@ ${logContent}
         // Use the original sanitized content for upload since it's a plain text file
         await fs.writeFile(tempLogFile, await sanitizeLogContent(rawLogContent));
 
-        // Use gh-upload-log to upload the log file
+        // Use gh-upload-log default auto mode and shared repository fallback.
         const uploadDescription = `Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}`;
         const uploadResult = await uploadLogWithGhUploadLog({
           logFile: tempLogFile,

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/log-upload.lib.mjs

@@ -28,6 +28,63 @@ const summarizeCommandOutput = value => {
   return text.length > 500 ? `${text.slice(0, 500)}... [truncated ${text.length - 500} chars]` : text;
 };
 
+export const buildGhUploadLogArgs = ({ logFile, isPublic, description, verbose = false }) => {
+  if (!logFile) {
+    throw new Error('logFile is required for gh-upload-log');
+  }
+
+  const args = [logFile, isPublic ? '--public' : '--private'];
+
+  if (description) {
+    args.push('--description', description);
+  }
+  if (verbose) {
+    args.push('--verbose');
+  }
+
+  return args;
+};
+
+const quoteShellArg = value => {
+  const text = String(value);
+  if (/^[A-Za-z0-9_./:=@+-]+$/u.test(text)) return text;
+  return `"${text.replace(/(["\\$`])/gu, '\\$1')}"`;
+};
+
+const formatGhUploadLogCommand = args => `gh-upload-log ${args.map(quoteShellArg).join(' ')}`;
+
+const runGhUploadLogCommand = async args => {
+  const { spawn } = await use('child_process');
+
+  return new Promise(resolve => {
+    const child = spawn('gh-upload-log', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const settle = value => {
+      if (!settled) {
+        settled = true;
+        resolve(value);
+      }
+    };
+
+    child.stdout?.on('data', chunk => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on('data', chunk => {
+      stderr += chunk.toString();
+    });
+    child.on('error', error => {
+      const errorText = stderr ? `${stderr}\n${error.message}` : error.message;
+      settle({ code: error.code === 'ENOENT' ? 127 : 1, stdout, stderr: errorText });
+    });
+    child.on('close', code => {
+      settle({ code: code ?? 1, stdout, stderr });
+    });
+  });
+};
+
 export const parseGhUploadLogOutput = outputValue => {
   const output = outputValue?.toString?.() || '';
   const parsed = {
@@ -89,30 +146,18 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
   const result = { success: false, url: null, rawUrl: null, type: null, chunks: 1 };
 
   try {
-    // Build command flags
-    // IMPORTANT: When using command-stream's $ template tag, each ${} interpolation is treated
-    // as a single argument. DO NOT use commandArgs.join(' ') as it will make all flags part
-    // of the first positional argument, causing "File does not exist" errors.
-    // See case study: docs/case-studies/issue-1096/README.md
-    const publicFlag = isPublic ? '--public' : '--private';
+    const commandArgs = buildGhUploadLogArgs({
+      logFile,
+      isPublic,
+      description,
+      verbose,
+    });
 
     if (verbose) {
-      const descDisplay = description ? ` --description "${description}"` : '';
-      await log(`  📤 Running: gh-upload-log "${logFile}" ${publicFlag}${descDisplay} --verbose`, { verbose: true });
+      await log(`  📤 Running: ${formatGhUploadLogCommand(commandArgs)}`, { verbose: true });
     }
 
-    // Execute command with separate interpolations for each argument
-    // Each ${} is properly passed as a separate argument to the shell
-    let uploadResult;
-    if (description && verbose) {
-      uploadResult = await $`gh-upload-log ${logFile} ${publicFlag} --description ${description} --verbose`;
-    } else if (description) {
-      uploadResult = await $`gh-upload-log ${logFile} ${publicFlag} --description ${description}`;
-    } else if (verbose) {
-      uploadResult = await $`gh-upload-log ${logFile} ${publicFlag} --verbose`;
-    } else {
-      uploadResult = await $`gh-upload-log ${logFile} ${publicFlag}`;
-    }
+    const uploadResult = await runGhUploadLogCommand(commandArgs);
     const output = (uploadResult.stdout?.toString() || '') + (uploadResult.stderr?.toString() || '');
 
     if (uploadResult.code !== 0) {
@@ -252,5 +297,6 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
 // Export all functions as default object too
 export default {
   parseGhUploadLogOutput,
+  buildGhUploadLogArgs,
   uploadLogWithGhUploadLog,
 };

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/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');