@link-assistant/hive-mind 2.0.4 → 2.0.6

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @link-assistant/hive-mind
 
+## 2.0.6
+
+### Patch Changes
+
+- 0c63706: Stop surfacing meaningless stream fragments as tool errors (#1941). When a tool
+  run is interrupted mid-stream (CTRL+C / SIGINT, exit code 130), the last captured
+  stdout line could be a stray structural character such as a lone `}`, which leaked
+  into the GitHub failure comment as "CLAUDE execution failed with }". A new shared
+  `isMeaningfulErrorText` helper (any error with at least one Unicode letter or digit
+  is real; pure punctuation is not) now guards the `extractToolErrorCore` chokepoint,
+  and a new `buildToolErrorMessage` helper labels interruptions explicitly
+  ("Claude command interrupted (CTRL+C)") across the Claude and OpenCode runners.
+- d4efc82: fix(playwright-mcp): do not abort the solve when the Playwright MCP preflight probe is inconclusive (#1943)
+
+  A `solve` run aborted before creating a pull request with
+  `❌ Playwright MCP preflight failed for Claude Code`. The local preflight ran
+  `timeout 5 claude mcp list`, but that command performs a live health check that
+  launches a browser and can take longer than five seconds; when the `timeout`
+  killed the probe, `ensureConnectedPlaywrightMcpServer` treated the non-zero exit
+  as a failure and stopped the whole run.
+
+  An inconclusive `mcp list` probe (timeout / crash / missing CLI) now falls back
+  to the local `@playwright/mcp` package check instead of aborting: if the package
+  is installed, the server connects on demand via Tool Search (issue #1901), so the
+  working session proceeds. The probe timeout now defaults to 30s and is overridable
+  via `PLAYWRIGHT_MCP_PREFLIGHT_TIMEOUT_SECONDS`, and the preflight emits verbose
+  diagnostics (probe exit code, matched rows, decision branch) so failures are
+  diagnosable from the log. The preflight still fails only when `@playwright/mcp`
+  is genuinely unavailable.
+
+## 2.0.5
+
+### Patch Changes
+
+- d815c7d: Treat a Claude Code `pending` Playwright MCP `system.init` status as a normal
+  still-connecting state instead of a failure (#1901). Claude Code enables Tool
+  Search by default, so the deferred `mcp__playwright__*` browser tools load on
+  demand and Claude waits for the connecting server before using them. Hive Mind
+  no longer aborts the working session on a `pending` status; only a terminal
+  `failed`/`error` status surfaces a non-blocking diagnostic in the session-start
+  comment. See `docs/case-studies/issue-1901`.
+
 ## 2.0.4
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -6,7 +6,7 @@ if (typeof globalThis.use === 'undefined') {
 const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
-import { log, isENOSPC } from './lib.mjs';
+import { log, 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 { detectUsageLimit, formatUsageLimitMessage, isUsageLimitError } from './usage-limit.lib.mjs';
@@ -1211,8 +1211,8 @@ export const executeClaudeCommand = async params => {
             is503Error,
             anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnStuckRetry, // Issue #1104/#1886
             resultSummary,
-            // Issue #1845: surface the actual error so callers can show it to users
-            errorInfo: { message: lastMessage || 'API explicitly marked error as not retryable', exitCode },
+            // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+            errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: 'API explicitly marked error as not retryable', toolLabel: 'Claude' }), exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1260,8 +1260,8 @@ export const executeClaudeCommand = async params => {
             is503Error, // preserve for callers that check this
             anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnRetriesExhausted, // Issue #1104/#1886: Include cumulative cost even on failure
             resultSummary, // Issue #1263: Include result summary
-            // Issue #1845: surface the actual error so callers can show it to users
-            errorInfo: { message: lastMessage || `Transient API error persisted after ${maxRetries} retries`, exitCode },
+            // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+            errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: `Transient API error persisted after ${maxRetries} retries`, toolLabel: 'Claude' }), exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1327,9 +1327,9 @@ export const executeClaudeCommand = async params => {
           errorDuringExecution,
           anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnFailure, // Issue #1104/#1886: cumulative cost even on failure
           resultSummary, // Issue #1263: Include result summary
-          // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content
-          // filtering policy") so users see what actually went wrong, not just a generic message.
-          errorInfo: { message: lastMessage || `Claude command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content filtering policy").
+          // Issue #1941: a lone "}" fragment at interrupt time must not become "CLAUDE execution failed with }".
+          errorInfo: { message: buildToolErrorMessage({ lastMessage, exitCode, fallback: `Claude command failed with exit code ${exitCode}`, toolLabel: 'Claude' }), exitCode },
           queuedFeedback, // Issue #817: Bidirectional mode feedback
         };
       }

package/src/gemini.lib.mjs

@@ -10,7 +10,7 @@ if (typeof globalThis.use === 'undefined') {
 
 const { $ } = await use('command-stream');
 
-import { log } from './lib.mjs';
+import { log, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -576,8 +576,8 @@ export const executeGeminiCommand = async params => {
           pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
           publicPricingEstimate: null,
           resultSummary: geminiJsonState.resultSummary || null,
-          // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: errorText || `Gemini command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: errorText, exitCode, fallback: `Gemini command failed with exit code ${exitCode}`, toolLabel: 'Gemini' }), exitCode },
         };
       }
 

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

@@ -1,21 +1,36 @@
 const PLAYWRIGHT_TOOL_PREFIX = 'mcp__playwright__';
 
-export const isUnavailableMcpStatus = status => {
+// A `pending` (or `connecting`) MCP server is still being connected/reconnected
+// in the background. It is NOT a failure: Claude Code enables Tool Search by
+// default, so MCP tools are deferred and load on demand, and Claude waits for a
+// still-connecting server before it uses one of that server's tools. See
+// https://code.claude.com/docs/en/mcp and issue #1901.
+export const isConnectingMcpStatus = status => /\b(pending|connecting)\b/i.test(String(status || ''));
+
+// Terminal/unhealthy states where the MCP client has given up (or the server is
+// turned off). Claude Code reconnects an HTTP/SSE server with exponential
+// backoff and only marks it `failed` after the attempts are exhausted; at that
+// point the server's tools never load.
+export const isFailedMcpStatus = 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);
+  return /\b(disabled|failed|error|disconnected|not[-_\s]+connected|unavailable|timed[-_\s]+out)\b|(?:^|[^a-z0-9_-])timeout(?:$|[^a-z0-9_-])/.test(normalized);
 };
 
+// Backwards-compatible umbrella: any non-connected status (still connecting OR
+// failed). Prefer the narrower helpers above when the connecting/failed
+// distinction matters (e.g. whether to warn a human reviewer).
+export const isUnavailableMcpStatus = status => isConnectingMcpStatus(status) || isFailedMcpStatus(status);
+
 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)) {
+  if (isConnectingMcpStatus(status)) {
+    displayStatus = `${status} - connecting; tools load on demand via Tool Search`;
+  } else if (isFailedMcpStatus(status)) {
     displayStatus = `${status} - MCP tools unavailable`;
   }
 
@@ -29,10 +44,16 @@ export const getInteractiveMcpDiagnostics = (mcpServers = [], tools = []) => {
   for (const server of servers) {
     const name = String(server?.name || '').toLowerCase();
     if (!name.includes('playwright')) continue;
-    if (!isUnavailableMcpStatus(server?.status)) continue;
+    // With Tool Search the deferred `mcp__playwright__*` tools are intentionally
+    // absent from system.init `tools`, so their absence is not a problem by
+    // itself. If they are already present the server is fully connected.
     if (hasPlaywrightMcpTools(tools)) continue;
+    // `pending`/`connecting` is the normal startup state — Claude waits for the
+    // server before using a browser tool — so only warn when the MCP client has
+    // actually failed to connect.
+    if (!isFailedMcpStatus(server?.status)) 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.`);
+    diagnostics.push(`⚠️ Playwright MCP server is ${server?.status || 'unknown'} (failed to connect), so no \`${PLAYWRIGHT_TOOL_PREFIX}*\` browser tools are available. Browser automation stays disabled until the MCP server connects.`);
   }
 
   return diagnostics;

package/src/lib.mjs

@@ -665,6 +665,53 @@ export const cleanErrorMessage = error => {
   return message;
 };
 
+/**
+ * Decide whether a string looks like a meaningful, human-readable error message
+ * rather than a stray structural fragment (Issue #1941).
+ *
+ * When a tool process is interrupted mid-stream (CTRL+C / SIGINT) or killed, the
+ * last captured stdout line can be a lone JSON-structural character left over
+ * from a truncated stream — for example a bare `}` or `{`. Surfacing that as the
+ * "core error" produced nonsense failure messages such as
+ * "CLAUDE execution failed with }" / "failed by {". A real error message always
+ * contains at least one letter or digit (in any script), so we treat fragments
+ * that contain none as not meaningful.
+ *
+ * @param {*} value - Candidate error string
+ * @returns {boolean} True when the value contains usable error text
+ */
+export const isMeaningfulErrorText = value => {
+  if (!value || typeof value !== 'string') return false;
+  const collapsed = value.replace(/\s+/g, ' ').trim();
+  if (!collapsed) return false;
+  // Require at least one Unicode letter or number; pure punctuation/brackets
+  // (e.g. "}", "{", "[]", ",") are stream fragments, not real errors.
+  return /[\p{L}\p{N}]/u.test(collapsed);
+};
+
+/**
+ * Build a clean tool error message for `errorInfo.message`, rejecting
+ * meaningless stream fragments (Issue #1941).
+ *
+ * Picks the tool-reported `lastMessage` only when it is meaningful; otherwise
+ * falls back to an interrupt label (exit code 130 = SIGINT/CTRL+C) or the
+ * provided generic fallback. This keeps junk like a lone `}` out of the stored
+ * error so every downstream surface (GitHub comment, terminal, retry logic)
+ * shows something honest.
+ *
+ * @param {Object} options
+ * @param {string} [options.lastMessage] - The last message captured from the tool stream
+ * @param {number} [options.exitCode] - Process exit code
+ * @param {string} [options.fallback] - Generic fallback message
+ * @param {string} [options.toolLabel='Tool'] - Human tool label for the interrupt message
+ * @returns {string} A clean, meaningful error message
+ */
+export const buildToolErrorMessage = ({ lastMessage, exitCode, fallback, toolLabel = 'Tool' } = {}) => {
+  if (isMeaningfulErrorText(lastMessage)) return lastMessage.replace(/\s+/g, ' ').trim();
+  if (exitCode === 130) return `${toolLabel} command interrupted (CTRL+C)`;
+  return fallback;
+};
+
 /**
  * Extract the core/root error string from a tool runner result (Issue #1845).
  *
@@ -675,6 +722,10 @@ export const cleanErrorMessage = error => {
  * (GitHub comments / exit message) and the terminal "Error details:" lines in
  * watch / auto-merge so they never diverge.
  *
+ * Issue #1941: a meaningless structural fragment (e.g. a lone `}` captured when
+ * a tool is interrupted mid-stream) is treated as "no usable error" so callers
+ * fall back to the generic phrase instead of "execution failed with }".
+ *
  * @param {Object} options
  * @param {Object} [options.toolResult] - Result object returned by the tool runner
  * @returns {string|null} The core error string, or null when none is available
@@ -688,6 +739,9 @@ export const extractToolErrorCore = ({ toolResult } = {}) => {
 
   if (!rawCore || typeof rawCore !== 'string') return null;
 
+  // Issue #1941: reject stray fragments with no letters/digits (e.g. "}").
+  if (!isMeaningfulErrorText(rawCore)) return null;
+
   // Collapse to a single clean line and strip noise.
   const core = rawCore.replace(/\s+/g, ' ').trim();
   return core || null;

package/src/opencode.lib.mjs

@@ -14,7 +14,7 @@ const path = (await use('path')).default;
 const os = (await use('os')).default;
 
 // Import log from general lib
-import { log } from './lib.mjs';
+import { log, isMeaningfulErrorText, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -532,7 +532,8 @@ export const executeOpenCodeCommand = async params => {
           ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
           // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: lastMessage || allOutput || `OpenCode command failed with exit code ${exitCode}`, exitCode },
+          // Issue #1941: reject meaningless stream fragments (e.g. a lone "}").
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: isMeaningfulErrorText(lastMessage) ? lastMessage : allOutput, exitCode, fallback: `OpenCode command failed with exit code ${exitCode}`, toolLabel: 'OpenCode' }), exitCode },
         };
       }
 

package/src/playwright-mcp.lib.mjs

@@ -30,44 +30,109 @@ export const hasConnectedPlaywrightMcpServer = output => {
   return rows.some(row => PLAYWRIGHT_MCP_CONNECTED_PATTERN.test(row) && !PLAYWRIGHT_MCP_UNAVAILABLE_PATTERN.test(row));
 };
 
-export const checkPlaywrightMcpPackageAvailability = async () => {
+// `claude mcp list` / `codex mcp list` perform live health checks against every
+// registered MCP server (Playwright MCP launches a browser to report status),
+// which can take noticeably longer than a couple of seconds on a cold cache or
+// a busy CI host. A too-aggressive `timeout` kills the probe before it answers,
+// which previously aborted the entire solve (issue #1943). The probe timeout is
+// therefore generous by default and overridable for slow/fast environments.
+export const PLAYWRIGHT_MCP_LIST_TIMEOUT_SECONDS_DEFAULT = 30;
+
+export const getPlaywrightMcpListTimeoutSeconds = (env = process.env) => {
+  const parsed = Number.parseInt(env?.PLAYWRIGHT_MCP_PREFLIGHT_TIMEOUT_SECONDS ?? '', 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : PLAYWRIGHT_MCP_LIST_TIMEOUT_SECONDS_DEFAULT;
+};
+
+const diagLog =
+  (log, opts = { verbose: true }) =>
+  async message => {
+    if (log) await log(message, opts);
+  };
+
+export const checkPlaywrightMcpPackageAvailability = async ({ log } = {}) => {
+  const diag = diagLog(log);
   try {
-    const result = await $`timeout 5 npx --no-install @playwright/mcp --help 2>&1`.catch(() => null);
-    if (isCommandResultSuccess(result)) return true;
-    const npmResult = await $`timeout 5 npm ls -g @playwright/mcp 2>&1`.catch(() => null);
-    return getCommandResultOutput(npmResult).includes('@playwright/mcp');
-  } catch {
+    const timeoutSeconds = getPlaywrightMcpListTimeoutSeconds();
+    const result = await $`timeout ${timeoutSeconds} npx --no-install @playwright/mcp --help 2>&1`.catch(() => null);
+    if (isCommandResultSuccess(result)) {
+      await diag('🎭 @playwright/mcp package is available via npx');
+      return true;
+    }
+    const npmResult = await $`timeout ${timeoutSeconds} npm ls -g @playwright/mcp 2>&1`.catch(() => null);
+    const available = getCommandResultOutput(npmResult).includes('@playwright/mcp');
+    await diag(`🎭 @playwright/mcp global package ${available ? 'is installed' : 'was not found'}`);
+    return available;
+  } catch (error) {
+    await diag(`⚠️  @playwright/mcp package availability check threw: ${error.message}`);
     return false;
   }
 };
 
-export const ensureConnectedPlaywrightMcpServer = async ({ list, add, hasPackage = checkPlaywrightMcpPackageAvailability }) => {
+export const ensureConnectedPlaywrightMcpServer = async ({ list, add, hasPackage = checkPlaywrightMcpPackageAvailability, log } = {}) => {
+  const diag = diagLog(log);
   try {
     const result = await list().catch(() => null);
-    if (!isCommandResultSuccess(result)) return false;
+    const code = getCommandResultCode(result);
     const output = getCommandResultOutput(result);
-    if (hasConnectedPlaywrightMcpServer(output)) return true;
-    if (getPlaywrightMcpListRows(output).length > 0) return false;
-    if (!(await hasPackage())) return false;
+    const rows = getPlaywrightMcpListRows(output);
+    await diag(`🎭 Playwright MCP probe: 'mcp list' exit=${code === null ? 'timeout/none' : code}, playwright rows=${rows.length}${rows.length ? ` [${rows.join(' | ')}]` : ''}`);
+
+    // Inconclusive probe: the `mcp list` command itself failed (timed out,
+    // crashed, or its binary is missing). That tells us NOTHING about whether
+    // Playwright MCP actually works, so it must not abort the whole solve as it
+    // did in issue #1943. A still-connecting server is normal — Tool Search
+    // loads MCP tools on demand (issue #1901) — so fall back to the local
+    // @playwright/mcp package check: if the package is installed, the server can
+    // connect on demand and the working session should proceed.
+    if (!isCommandResultSuccess(result)) {
+      const packageAvailable = await hasPackage({ log });
+      await diag(`⚠️  Playwright MCP 'mcp list' probe was inconclusive (exit=${code === null ? 'timeout' : code}); @playwright/mcp package ${packageAvailable ? 'is installed, so Tool Search can connect it on demand — preflight passes' : 'is NOT installed — preflight fails'}`);
+      return packageAvailable;
+    }
 
+    if (hasConnectedPlaywrightMcpServer(output)) {
+      await diag('🎭 Playwright MCP reported as connected by mcp list');
+      return true;
+    }
+
+    // A registration row exists but is not reported connected (pending /
+    // disabled / failed). Leave it untouched (do not overwrite an intentional
+    // or in-progress registration) and let the caller decide.
+    if (rows.length > 0) {
+      await diag('🎭 Playwright MCP is registered but not reported connected by mcp list; leaving registration unchanged');
+      return false;
+    }
+
+    // No registration at all → register the default server when the package is
+    // available, then re-probe.
+    if (!(await hasPackage({ log }))) {
+      await diag('⚠️  No Playwright MCP registration found and @playwright/mcp package is unavailable');
+      return false;
+    }
+    await diag('🎭 No Playwright MCP registration found; registering the default server...');
     await add().catch(() => null);
     const retryResult = await list().catch(() => null);
-    return isCommandResultSuccess(retryResult) && hasConnectedPlaywrightMcpServer(getCommandResultOutput(retryResult));
-  } catch {
+    const connected = isCommandResultSuccess(retryResult) && hasConnectedPlaywrightMcpServer(getCommandResultOutput(retryResult));
+    await diag(`🎭 Playwright MCP registration ${connected ? 'succeeded and is now connected' : 'did not report connected after add'}`);
+    return connected;
+  } catch (error) {
+    await diag(`⚠️  Playwright MCP preflight probe threw: ${error.message}`);
     return false;
   }
 };
 
-export const ensureClaudePlaywrightMcpServer = async () =>
+export const ensureClaudePlaywrightMcpServer = async ({ log } = {}) =>
   ensureConnectedPlaywrightMcpServer({
-    list: () => $`timeout 5 claude mcp list 2>&1`,
+    list: () => $`timeout ${getPlaywrightMcpListTimeoutSeconds()} 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`,
+    log,
   });
 
-export const ensureCodexPlaywrightMcpServer = async () =>
+export const ensureCodexPlaywrightMcpServer = async ({ log } = {}) =>
   ensureConnectedPlaywrightMcpServer({
-    list: () => $`timeout 5 codex mcp list 2>&1`,
+    list: () => $`timeout ${getPlaywrightMcpListTimeoutSeconds()} 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`,
+    log,
   });
 
 const SOLVE_PLAYWRIGHT_MCP_CHECKS = {
@@ -102,7 +167,7 @@ export const ensureSolvePlaywrightMcpReady = async ({ argv = {}, log = async ()
   await log(`🎭 Checking Playwright MCP preflight for ${label}...`, { verbose: true });
 
   try {
-    if (await checkFn()) {
+    if (await checkFn({ log })) {
       await log(`🎭 Playwright MCP ready for ${label}`, { verbose: true });
       return { ok: true, checkedTools: [tool], skipped: false };
     }

package/src/qwen.lib.mjs

@@ -13,7 +13,7 @@ const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 const os = (await use('os')).default;
 
-import { log } from './lib.mjs';
+import { log, buildToolErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -633,8 +633,8 @@ export const executeQwenCommand = async params => {
           limitResetTime: null,
           ...usageResult,
           resultSummary,
-          // Issue #1845: surface the actual error so callers can show it to users
-          errorInfo: { message: combinedErrorText || errorMessage || `Qwen Code command failed${exitCode !== 0 ? ` with exit code ${exitCode}` : ''}`, exitCode },
+          // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
+          errorInfo: { message: buildToolErrorMessage({ lastMessage: combinedErrorText || errorMessage, exitCode, fallback: `Qwen Code command failed${exitCode !== 0 ? ` with exit code ${exitCode}` : ''}`, toolLabel: 'Qwen Code' }), exitCode },
         };
       }