@link-assistant/hive-mind 1.54.3 → 1.54.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.54.5
+
+### Patch Changes
+
+- ea79845: Disable noisy Claude Code features for solve runs via merged user settings, subprocess environment variables, and Docker image defaults. Expands the quiet config to also disable fast mode, feedback surveys, mouse tracking, away summaries, Claude attribution (commit/pr), co-authored-by trailer, thinking summaries, and UI animations, sets viewMode to verbose, and caps tool-use concurrency at 4 for deterministic autonomous runs. Keeps Claude's built-in git/PR instructions on (`includeGitInstructions: true`), enables task tracking (`CLAUDE_CODE_ENABLE_TASKS=1`) and turn resume (`CLAUDE_CODE_RESUME_INTERRUPTED_TURN=1`), and makes the bypass-permissions mode audible via `permissions.defaultMode: "bypassPermissions"` + `skipDangerousModePermissionPrompt: true` (complementing the existing `--dangerously-skip-permissions` CLI flag). Adds a reusable `configure-claude` bin with an apply default and a `--verify` check-only mode so users and system administrators can reset or audit Claude Code configuration manually after installing `@link-assistant/hive-mind`. Docker release builds now wait for the npm package version to become available, pass that exact version into Docker as `HIVE_MIND_VERSION`, install `@link-assistant/hive-mind@${HIVE_MIND_VERSION}`, and invoke the published `configure-claude` bin directly instead of copying repo source files into the Docker build.
+
+## 1.54.4
+
+### Patch Changes
+
+- 2ac0a14: Notify the source issue when solve exits with a known issue but no pull request, including failure logs when `--attach-logs` is enabled.
+
 ## 1.54.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.54.3",
+  "version": "1.54.5",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -9,11 +9,12 @@
     "solve": "./src/solve.mjs",
     "task": "./src/task.mjs",
     "review": "./src/review.mjs",
+    "configure-claude": "./src/configure-claude.mjs",
     "start-screen": "./src/start-screen.mjs",
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",
@@ -25,7 +26,7 @@
     "changeset": "changeset",
     "changeset:version": "changeset version",
     "changeset:publish": "npm run build:pre && changeset publish",
-    "build:pre": "chmod +x src/hive.mjs && chmod +x src/solve.mjs",
+    "build:pre": "chmod +x src/hive.mjs && chmod +x src/solve.mjs && chmod +x src/configure-claude.mjs",
     "prepare": "husky"
   },
   "repository": {

package/src/claude-quiet-config.lib.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export const REQUIRED_CLAUDE_QUIET_ENV = Object.freeze({
+  CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+  CLAUDE_CODE_DISABLE_CRON: '1',
+  CLAUDE_CODE_DISABLE_TERMINAL_TITLE: '1',
+  CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1',
+  CLAUDE_CODE_DISABLE_FAST_MODE: '1',
+  CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY: '1',
+  CLAUDE_CODE_DISABLE_MOUSE: '1',
+  CLAUDE_CODE_ENABLE_AWAY_SUMMARY: '0',
+  CLAUDE_CODE_ENABLE_TASKS: '1',
+  CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY: '4',
+  CLAUDE_CODE_RESUME_INTERRUPTED_TURN: '1',
+  DISABLE_FEEDBACK_COMMAND: '1',
+});
+
+export const REQUIRED_CLAUDE_QUIET_SETTINGS = Object.freeze({
+  autoMemoryEnabled: false,
+  spinnerTipsEnabled: false,
+  awaySummaryEnabled: false,
+  feedbackSurveyRate: 0,
+  includeCoAuthoredBy: false,
+  includeGitInstructions: true,
+  prefersReducedMotion: true,
+  showThinkingSummaries: false,
+  skipDangerousModePermissionPrompt: true,
+  viewMode: 'verbose',
+});
+
+export const REQUIRED_CLAUDE_QUIET_ATTRIBUTION = Object.freeze({
+  commit: '',
+  pr: '',
+});
+
+export const REQUIRED_CLAUDE_QUIET_PERMISSIONS = Object.freeze({
+  defaultMode: 'bypassPermissions',
+});
+
+export const buildClaudeQuietEnv = (baseEnv = process.env) => ({
+  ...baseEnv,
+  ...REQUIRED_CLAUDE_QUIET_ENV,
+});
+
+export const formatClaudeQuietConfigSummary = () => {
+  const settings = Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)
+    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+    .join(', ');
+  const attribution = `attribution=${JSON.stringify(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)}`;
+  const permissions = `permissions=${JSON.stringify(REQUIRED_CLAUDE_QUIET_PERMISSIONS)}`;
+  const env = Object.entries(REQUIRED_CLAUDE_QUIET_ENV)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(', ');
+  return `settings[${settings}, ${attribution}, ${permissions}], env[${env}]`;
+};
+
+const isPlainObject = value => value && typeof value === 'object' && !Array.isArray(value);
+
+export const ensureClaudeQuietConfig = async ({ settingsPath, log } = {}) => {
+  const resolvedPath = settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
+  let settings = {};
+  try {
+    const content = await fs.readFile(resolvedPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    settings = isPlainObject(parsed) ? parsed : {};
+  } catch (err) {
+    if (err.code !== 'ENOENT' && log) {
+      await log(`⚠️  Could not read ${resolvedPath}: ${err.message}`, { verbose: true });
+    }
+    settings = {};
+  }
+
+  const updatedSettingsKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)) {
+    if (settings[key] !== value) {
+      settings[key] = value;
+      updatedSettingsKeys.push(key);
+    }
+  }
+
+  const existingAttribution = isPlainObject(settings.attribution) ? settings.attribution : {};
+  const updatedAttributionKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)) {
+    if (existingAttribution[key] !== value) {
+      existingAttribution[key] = value;
+      updatedAttributionKeys.push(key);
+    }
+  }
+  settings.attribution = existingAttribution;
+  if (updatedAttributionKeys.length > 0) {
+    updatedSettingsKeys.push('attribution');
+  }
+
+  const existingPermissions = isPlainObject(settings.permissions) ? settings.permissions : {};
+  const updatedPermissionsKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_PERMISSIONS)) {
+    if (existingPermissions[key] !== value) {
+      existingPermissions[key] = value;
+      updatedPermissionsKeys.push(key);
+    }
+  }
+  settings.permissions = existingPermissions;
+  if (updatedPermissionsKeys.length > 0) {
+    updatedSettingsKeys.push('permissions');
+  }
+
+  const existingEnv = isPlainObject(settings.env) ? settings.env : {};
+  const updatedEnvKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ENV)) {
+    if (existingEnv[key] !== value) {
+      existingEnv[key] = value;
+      updatedEnvKeys.push(key);
+    }
+  }
+  settings.env = existingEnv;
+
+  const changed = updatedSettingsKeys.length > 0 || updatedEnvKeys.length > 0;
+  try {
+    if (changed) {
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.writeFile(resolvedPath, JSON.stringify(settings, null, 2));
+    }
+    if (log) {
+      await log(`🧭 Claude Code quiet config ${changed ? 'updated' : 'verified'} at ${resolvedPath}: ${formatClaudeQuietConfigSummary()}`);
+    }
+  } catch (err) {
+    if (log) await log(`⚠️  Could not write ${resolvedPath}: ${err.message}`, { verbose: true });
+  }
+
+  return {
+    path: resolvedPath,
+    changed,
+    updatedSettingsKeys,
+    updatedEnvKeys,
+    updatedAttributionKeys,
+    updatedPermissionsKeys,
+    settings: { ...REQUIRED_CLAUDE_QUIET_SETTINGS },
+    attribution: { ...REQUIRED_CLAUDE_QUIET_ATTRIBUTION },
+    permissions: { ...REQUIRED_CLAUDE_QUIET_PERMISSIONS },
+    env: { ...REQUIRED_CLAUDE_QUIET_ENV },
+  };
+};

package/src/claude.lib.mjs

@@ -21,6 +21,7 @@ import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; //
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
 import { buildMcpConfigWithoutPlaywright } 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';
 export { availableModels }; // Re-export for backward compatibility
 export { fetchModelInfo };
@@ -725,6 +726,7 @@ export const executeClaudeCommand = async params => {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
     }
+    await ensureClaudeQuietConfig({ log });
     const { mcpConfigPath, disallowedToolsList } = await resolveClaudeSessionToolFlags({ argv, log, fallbackBuildMcpConfigWithoutPlaywright: buildMcpConfigWithoutPlaywright });
     if (mcpConfigPath) claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
     if (disallowedToolsList.length) claudeArgs += ` --disallowedTools ${disallowedToolsList.join(' ')}`;

package/src/config.lib.mjs

@@ -24,6 +24,7 @@ const getenv = typeof getenvModule === 'function' ? getenvModule : getenvModule.
 
 // Use semver package for version comparison (see issue #1146)
 import semver from 'semver';
+import { buildClaudeQuietEnv } from './claude-quiet-config.lib.mjs';
 
 // Import lino for parsing Links Notation format
 const { lino } = await import('./lino.lib.mjs');
@@ -419,14 +420,14 @@ export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
   const maxOutputTokens = options.model ? getMaxOutputTokensForModel(options.model) : claudeCode.maxOutputTokens;
 
-  const env = {
+  const env = buildClaudeQuietEnv({
     ...process.env,
     CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(maxOutputTokens),
     // MCP timeout configurations to prevent tool calls from hanging indefinitely
     // See: https://github.com/link-assistant/hive-mind/issues/1066
     MCP_TIMEOUT: String(claudeCode.mcpTimeout),
     MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
-  };
+  });
 
   // Opus 4.7+ always uses adaptive thinking — MAX_THINKING_TOKENS has no effect (Issue #1620)
   // For Opus 4.6 and earlier, MAX_THINKING_TOKENS controls extended thinking (Claude Code >= 2.1.12)

package/src/configure-claude.lib.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+/**
+ * Shared runner for the `configure-claude` bin command. Applies or verifies
+ * the quiet Claude Code defaults in a target `settings.json` by reusing the
+ * canonical maps and idempotent merge helpers from:
+ *   - src/claude-quiet-config.lib.mjs (quiet env + settings + attribution
+ *     + permissions)
+ *   - src/useless-tools.lib.mjs      (disallowedTools block-list)
+ *
+ * See issues #1627 and #1642.
+ */
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { REQUIRED_CLAUDE_QUIET_ENV, REQUIRED_CLAUDE_QUIET_SETTINGS, REQUIRED_CLAUDE_QUIET_ATTRIBUTION, REQUIRED_CLAUDE_QUIET_PERMISSIONS, ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
+import { buildDisallowedToolsList, ensureDisallowedToolsInSettings } from './useless-tools.lib.mjs';
+
+export const resolveSettingsPath = settingsPath => settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
+
+export const parseConfigureClaudeArgs = argv => {
+  const args = { settingsPath: null, verify: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--settings-path' || arg === '-s') {
+      args.settingsPath = argv[++i];
+    } else if (arg.startsWith('--settings-path=')) {
+      args.settingsPath = arg.slice('--settings-path='.length);
+    } else if (arg === '--verify') {
+      args.verify = true;
+    } else if (arg === '--help' || arg === '-h') {
+      args.help = true;
+    }
+  }
+  return args;
+};
+
+export const CONFIGURE_CLAUDE_HELP = `Usage: configure-claude [options]
+
+Apply or verify Hive-Mind's quiet, deterministic Claude Code defaults in
+a target ~/.claude/settings.json (env vars, settings, attribution,
+permissions.defaultMode, and the disallowedTools block-list).
+
+Options:
+  -s, --settings-path <path>  Path to settings.json (default: ~/.claude/settings.json)
+      --verify                Report configuration status without writing; exit 1 if incorrect
+  -h, --help                  Show this help and exit
+
+Examples:
+  configure-claude                           # apply defaults to ~/.claude/settings.json
+  configure-claude --verify                  # check only, non-zero exit if drift detected
+  configure-claude -s /workspace/.claude/settings.json
+
+Reference: https://github.com/link-assistant/hive-mind/issues/1642
+`;
+
+const isPlainObject = value => value && typeof value === 'object' && !Array.isArray(value);
+
+const readSettings = async settingsPath => {
+  try {
+    const content = await fs.readFile(settingsPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    return isPlainObject(parsed) ? parsed : {};
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+};
+
+export const verifyConfigureClaude = async ({ settingsPath } = {}) => {
+  const resolvedPath = resolveSettingsPath(settingsPath);
+  const settings = await readSettings(resolvedPath);
+  const missing = {
+    file: settings === null,
+    settings: [],
+    env: [],
+    attribution: [],
+    permissions: [],
+    disallowedTools: [],
+  };
+  const current = settings || {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)) {
+    if (current[key] !== value) missing.settings.push(key);
+  }
+  const envSection = isPlainObject(current.env) ? current.env : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ENV)) {
+    if (envSection[key] !== value) missing.env.push(key);
+  }
+  const attributionSection = isPlainObject(current.attribution) ? current.attribution : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)) {
+    if (attributionSection[key] !== value) missing.attribution.push(key);
+  }
+  const permissionsSection = isPlainObject(current.permissions) ? current.permissions : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_PERMISSIONS)) {
+    if (permissionsSection[key] !== value) missing.permissions.push(key);
+  }
+  const existingDisallowed = Array.isArray(current.disallowedTools) ? current.disallowedTools : [];
+  for (const required of buildDisallowedToolsList()) {
+    if (!existingDisallowed.includes(required)) missing.disallowedTools.push(required);
+  }
+  const ok = !missing.file && missing.settings.length === 0 && missing.env.length === 0 && missing.attribution.length === 0 && missing.permissions.length === 0 && missing.disallowedTools.length === 0;
+  return { ok, path: resolvedPath, missing };
+};
+
+export const runConfigureClaude = async ({ settingsPath, log } = {}) => {
+  const resolvedPath = resolveSettingsPath(settingsPath);
+  const logger = log || (async line => console.log(line));
+  const quietResult = await ensureClaudeQuietConfig({ settingsPath: resolvedPath, log: logger });
+  const disallowedResult = await ensureDisallowedToolsInSettings({ settingsPath: resolvedPath, log: logger });
+  return { quietResult, disallowedResult, path: resolvedPath };
+};
+
+export const formatVerifyReport = ({ ok, path: resolvedPath, missing }) => {
+  if (ok) {
+    return `✅ Quiet Claude Code configuration is up to date in ${resolvedPath}`;
+  }
+  const sections = [];
+  if (missing.file) sections.push('  - settings.json missing');
+  if (missing.settings.length) sections.push(`  - settings: ${missing.settings.join(', ')}`);
+  if (missing.env.length) sections.push(`  - env: ${missing.env.join(', ')}`);
+  if (missing.attribution.length) sections.push(`  - attribution: ${missing.attribution.join(', ')}`);
+  if (missing.permissions.length) sections.push(`  - permissions: ${missing.permissions.join(', ')}`);
+  if (missing.disallowedTools.length) sections.push(`  - disallowedTools: ${missing.disallowedTools.join(', ')}`);
+  return `❌ Quiet Claude Code configuration drift detected in ${resolvedPath}\n${sections.join('\n')}`;
+};

package/src/configure-claude.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+/**
+ * `configure-claude` — reusable bin that resets Hive-Mind's quiet,
+ * deterministic Claude Code defaults (env, settings, attribution,
+ * permissions.defaultMode, and the disallowedTools block-list) in a
+ * target `settings.json`, or verifies that they are already in place.
+ *
+ * Users and system administrators can run this manually after installing
+ * `@link-assistant/hive-mind` to reset Claude Code configuration. Docker
+ * images invoke this published bin after npm release, so the image baseline
+ * stays in lock-step with the package users install.
+ *
+ * See issues #1627 and #1642.
+ */
+
+import { CONFIGURE_CLAUDE_HELP, formatVerifyReport, parseConfigureClaudeArgs, resolveSettingsPath, runConfigureClaude, verifyConfigureClaude } from './configure-claude.lib.mjs';
+
+const args = parseConfigureClaudeArgs(process.argv.slice(2));
+
+if (args.help) {
+  console.log(CONFIGURE_CLAUDE_HELP);
+  process.exit(0);
+}
+
+const settingsPath = resolveSettingsPath(args.settingsPath);
+
+if (args.verify) {
+  const report = await verifyConfigureClaude({ settingsPath });
+  console.log(formatVerifyReport(report));
+  process.exit(report.ok ? 0 : 1);
+}
+
+const { quietResult, disallowedResult } = await runConfigureClaude({ settingsPath });
+console.log(`Configured quiet Claude Code defaults and ${disallowedResult.total} disallowedTools in ${quietResult.path}`);

package/src/exit-handler.lib.mjs

@@ -27,6 +27,8 @@ let logFunction = null;
 let cleanupFunction = null;
 let interruptFunction = null;
 let interruptHandlerRan = false;
+let preExitFunction = null;
+let preExitHandlerRan = false;
 
 /**
  * Initialize the exit handler with required dependencies
@@ -36,11 +38,16 @@ let interruptHandlerRan = false;
  * @param {Function} interrupt - Optional interrupt function to call on SIGINT/SIGTERM before cleanup
  *                               (e.g., auto-commit uncommitted changes, upload logs)
  */
-export const initializeExitHandler = (getLogPath, log, cleanup = null, interrupt = null) => {
+export const initializeExitHandler = (getLogPath, log, cleanup = null, interrupt = null, preExit = null) => {
   getLogPathFunction = getLogPath;
   logFunction = log;
   cleanupFunction = cleanup;
   interruptFunction = interrupt;
+  preExitFunction = preExit;
+};
+
+export const setPreExitHandler = preExit => {
+  preExitFunction = preExit;
 };
 
 /**
@@ -200,6 +207,20 @@ export const logActiveHandles = async (log = null) => {
 export const safeExit = async (code = 0, reason = 'Process completed') => {
   await showExitMessage(reason, code);
 
+  if (code !== 0 && preExitFunction && !preExitHandlerRan) {
+    preExitHandlerRan = true;
+    try {
+      await preExitFunction({ code, reason });
+    } catch (error) {
+      const message = error && error.message ? error.message : String(error);
+      if (logFunction) {
+        await logFunction(`⚠️  Pre-exit handler failed: ${message}`, { level: 'warning' });
+      } else {
+        console.warn(`⚠️  Pre-exit handler failed: ${message}`);
+      }
+    }
+  }
+
   // Issue #1431: Drain/unref active handles so the event loop exits naturally.
   // This resolves the root causes of dangling ReadStream (stdin), Socket (undici),
   // ChildProcess (command-stream), and WriteStream (stdout/stderr) handles.

package/src/solve.error-handlers.lib.mjs

@@ -70,6 +70,7 @@ export const handleFailure = async options => {
         });
         if (logUploadSuccess) {
           await log(`📎 Failure log attached to ${targetLabel}`);
+          if (!hasPR && hasIssue) global.prePullRequestFailureNotificationPosted = true;
         }
       } catch (attachError) {
         reportError(attachError, {

package/src/solve.mjs

@@ -41,6 +41,7 @@ const { formatResetTimeWithRelative } = usageLimitLib;
 
 const errorHandlers = await import('./solve.error-handlers.lib.mjs');
 const { createUncaughtExceptionHandler, createUnhandledRejectionHandler, handleMainExecutionError, handleNoPrAvailableError } = errorHandlers;
+const { notifyIssueAboutPrePullRequestFailure } = await import('./solve.pre-pr-failure-notifier.lib.mjs');
 
 const watchLib = await import('./solve.watch.lib.mjs');
 const { startWatchMode } = watchLib;
@@ -132,7 +133,7 @@ const cleanupWrapper = async () => {
   }
 };
 const interruptWrapper = createInterruptWrapper({ cleanupContext, checkForUncommittedChanges, shouldAttachLogs, attachLogToGitHub, getLogFile, sanitizeLogContent, $, log });
-initializeExitHandler(getAbsoluteLogPath, log, cleanupWrapper, interruptWrapper);
+initializeExitHandler(getAbsoluteLogPath, log, cleanupWrapper, interruptWrapper, ({ code, reason }) => notifyIssueAboutPrePullRequestFailure({ code, reason, argv, globalState: global, $, log, getLogFile, shouldAttachLogs, attachLogToGitHub, sanitizeLogContent, rawCommand }));
 installGlobalExitHandlers();
 
 // Now handle argument validation that was moved from early checks

package/src/solve.pre-pr-failure-notifier.lib.mjs

@@ -0,0 +1,107 @@
+import { getTrackedToolCommentIds, postTrackedComment, SOLUTION_DRAFT_FAILED_MARKER } from './tool-comments.lib.mjs';
+
+const truncate = (value, maxLength = 2000) => {
+  const text = value === null || value === undefined ? '' : String(value);
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 22)}\n... truncated ...`;
+};
+
+const fence = value => truncate(value || 'Unknown error').replaceAll('```', '` ` `');
+
+export function shouldNotifyIssueAboutPrePullRequestFailure({ code, globalState }) {
+  if (code === 0) return false;
+  if (!globalState?.issueNumber || !globalState?.owner || !globalState?.repo) return false;
+  if (globalState?.createdPR?.number) return false;
+  if (globalState.prePullRequestFailureNotificationPosted || globalState.prePullRequestFailureNotificationInProgress) return false;
+  return getTrackedToolCommentIds().size === 0;
+}
+
+export function buildPrePullRequestFailureComment({ reason, owner, repo, issueNumber, argv = {}, rawCommand = null, logAttachmentAttempted = false }) {
+  const tool = argv.tool || 'claude';
+  const modelLine = argv.model ? `\n- **Requested model**: \`${argv.model}\`` : '';
+  const commandBlock = rawCommand
+    ? `
+
+### Command
+\`\`\`bash
+${fence(rawCommand)}
+\`\`\``
+    : '';
+  const logLine = logAttachmentAttempted ? 'Log attachment was attempted but failed. Check the solver terminal log for the complete failure output.' : 'Logs were not attached because `--attach-logs` was not enabled.';
+
+  return `## 🚨 ${SOLUTION_DRAFT_FAILED_MARKER}
+
+The automated solver stopped before creating a pull request, so no PR was opened for this issue.
+
+### Failure
+- **Repository**: \`${owner}/${repo}\`
+- **Issue**: #${issueNumber}
+- **Tool**: \`${tool}\`${modelLine}
+
+**Reason**
+\`\`\`text
+${fence(reason)}
+\`\`\`${commandBlock}
+
+${logLine}
+
+Please resolve the reported problem and rerun the solve command.`;
+}
+
+export async function notifyIssueAboutPrePullRequestFailure(options) {
+  const { code, reason, argv = {}, globalState = globalThis, $, log = async () => {}, getLogFile, shouldAttachLogs = false, attachLogToGitHub, sanitizeLogContent, rawCommand = null, postComment = postTrackedComment } = options;
+
+  if (!shouldNotifyIssueAboutPrePullRequestFailure({ code, globalState })) {
+    return { notified: false, skipped: true };
+  }
+
+  const owner = globalState.owner;
+  const repo = globalState.repo;
+  const issueNumber = globalState.issueNumber;
+  globalState.prePullRequestFailureNotificationInProgress = true;
+
+  try {
+    if (shouldAttachLogs && getLogFile && attachLogToGitHub && sanitizeLogContent) {
+      await log(`\n📄 Notifying issue #${issueNumber} about pre-PR failure with logs...`);
+      const uploaded = await attachLogToGitHub({
+        logFile: getLogFile(),
+        targetType: 'issue',
+        targetNumber: issueNumber,
+        owner,
+        repo,
+        $,
+        log,
+        sanitizeLogContent,
+        verbose: argv.verbose,
+        errorMessage: `The solver stopped before creating a pull request.\n\nReason: ${reason || 'Unknown error'}`,
+        requestedModel: argv.model,
+        tool: argv.tool || 'claude',
+      });
+      if (uploaded) {
+        globalState.prePullRequestFailureNotificationPosted = true;
+        return { notified: true, method: 'log-upload' };
+      }
+    }
+
+    await log(`\n💬 Notifying issue #${issueNumber} about pre-PR failure...`);
+    const body = buildPrePullRequestFailureComment({
+      reason,
+      owner,
+      repo,
+      issueNumber,
+      argv,
+      rawCommand,
+      logAttachmentAttempted: shouldAttachLogs,
+    });
+    const posted = await postComment({ $, owner, repo, targetNumber: issueNumber, body });
+    if (posted.ok) {
+      globalState.prePullRequestFailureNotificationPosted = true;
+      await log(`  ✅ Pre-PR failure comment posted to issue #${issueNumber}${posted.commentId ? ` (id=${posted.commentId})` : ''}`);
+      return { notified: true, method: 'comment', commentId: posted.commentId || null };
+    }
+    await log(`  ⚠️  Could not post pre-PR failure comment: ${posted.stderr || 'unknown error'}`, { level: 'warning' });
+    return { notified: false, error: posted.stderr || 'unknown error' };
+  } finally {
+    globalState.prePullRequestFailureNotificationInProgress = false;
+  }
+}