@link-assistant/hive-mind 1.54.2 → 1.54.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- 5030b04: Fix Codex pricing display by calculating OpenAI public estimates from models.dev token rates, passing Codex totals into shared budget stats, and avoiding duplicate raw token usage lines when a Total line is already shown.
+
 ## 1.54.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.54.2",
+  "version": "1.54.4",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -13,7 +13,7 @@
     "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-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-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",

package/src/claude.lib.mjs

@@ -21,7 +21,9 @@ 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 { fetchModelInfo } from './model-info.lib.mjs';
 export { availableModels }; // Re-export for backward compatibility
+export { fetchModelInfo };
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
   if (!sessionId || !tempDir) return;
   const cmd = buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model });
@@ -370,58 +372,6 @@ export const executeClaude = async params => {
     prNumber,
   });
 };
-/**
- * Fetches model information from pricing API
- * @param {string} modelId - The model ID (e.g., "claude-sonnet-4-5-20250929")
- * @returns {Promise<Object|null>} Model information or null if not found
- */
-export const fetchModelInfo = async modelId => {
-  try {
-    const https = (await use('https')).default;
-    return new Promise((resolve, reject) => {
-      https
-        .get('https://models.dev/api.json', res => {
-          let data = '';
-          res.on('data', chunk => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            try {
-              const apiData = JSON.parse(data);
-              // For public pricing calculation, prefer Anthropic provider for Claude models
-              // Check Anthropic provider first
-              if (apiData.anthropic?.models?.[modelId]) {
-                const modelInfo = apiData.anthropic.models[modelId];
-                modelInfo.provider = apiData.anthropic.name || 'Anthropic';
-                resolve(modelInfo);
-                return;
-              }
-              // Search for the model across all other providers
-              for (const provider of Object.values(apiData)) {
-                if (provider.models && provider.models[modelId]) {
-                  const modelInfo = provider.models[modelId];
-                  // Add provider info
-                  modelInfo.provider = provider.name || provider.id;
-                  resolve(modelInfo);
-                  return;
-                }
-              }
-              // Model not found
-              resolve(null);
-            } catch (parseError) {
-              reject(parseError);
-            }
-          });
-        })
-        .on('error', err => {
-          reject(err);
-        });
-    });
-  } catch {
-    // If we can't fetch model info, return null and continue without it
-    return null;
-  }
-};
 /** Check if a model supports vision (image input) using models.dev API @returns {Promise<boolean>} */
 export const checkModelVisionCapability = async modelId => {
   try {

package/src/codex.lib.mjs

@@ -22,8 +22,11 @@ import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.m
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs';
+import { fetchModelInfo } from './model-info.lib.mjs';
+import Decimal from 'decimal.js-light';
 
 const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
+const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -77,6 +80,9 @@ export const createCodexTokenUsage = requestedModelId => ({
   stepCount: 0,
   requestedModelId: requestedModelId || null,
   respondedModelId: requestedModelId || null,
+  contextLimit: null,
+  outputLimit: null,
+  peakContextUsage: 0,
   tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
@@ -262,6 +268,10 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
       nextState.tokenUsage.reasoningTokens += reasoningTokens;
       nextState.tokenUsage.totalTokens = nextState.tokenUsage.inputTokens + nextState.tokenUsage.cacheReadTokens + nextState.tokenUsage.outputTokens + nextState.tokenUsage.cacheWriteTokens;
       nextState.tokenUsage.stepCount += 1;
+      const turnContextUsage = inputTokens + cacheWriteTokens;
+      if (turnContextUsage > (nextState.tokenUsage.peakContextUsage || 0)) {
+        nextState.tokenUsage.peakContextUsage = turnContextUsage;
+      }
 
       const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => hasOwnPath(data.usage, fieldName));
       if (usageFieldSet.length > 0) nextState.observedUsageFieldSets.push(usageFieldSet);
@@ -323,12 +333,80 @@ export const buildCodexResultModelUsage = (modelId, tokenUsage, pricingInfo = nu
       outputTokens: tokenUsage.outputTokens || 0,
       modelName: pricingInfo?.modelName || modelId,
       modelInfo: pricingInfo?.modelInfo || null,
-      peakContextUsage: 0,
+      peakContextUsage: tokenUsage.peakContextUsage || 0,
       costUSD: pricingInfo?.totalCostUSD ?? null,
     },
   };
 };
 
+const toCost = (tokens, pricePerMillion) => {
+  if (!Number.isFinite(tokens) || !Number.isFinite(pricePerMillion)) return 0;
+  return new Decimal(tokens).mul(pricePerMillion).div(1_000_000).toNumber();
+};
+
+const buildCodexPricingFallback = (modelId, tokenUsage, error = null) => ({
+  modelId,
+  modelName: modelId,
+  provider: 'OpenAI',
+  tokenUsage,
+  modelInfo: null,
+  totalCostUSD: null,
+  error,
+});
+
+export const calculateCodexPricingFromModelInfo = (modelId, tokenUsage, modelInfo) => {
+  if (!modelId) return null;
+  if (!tokenUsage) return buildCodexPricingFallback(modelId, null);
+  if (!modelInfo?.cost) return buildCodexPricingFallback(modelId, tokenUsage, 'Model pricing not found in models.dev API');
+
+  const standardCost = modelInfo.cost;
+  const usesLongContextPricing = !!standardCost.context_over_200k && (tokenUsage.peakContextUsage || 0) > CODEX_LONG_CONTEXT_PRICE_THRESHOLD;
+  const cost = usesLongContextPricing ? { ...standardCost, ...standardCost.context_over_200k } : standardCost;
+
+  const pricing = {
+    inputPerMillion: cost.input || 0,
+    outputPerMillion: cost.output || 0,
+    cacheReadPerMillion: cost.cache_read || 0,
+    cacheWritePerMillion: cost.cache_write ?? cost.input ?? 0,
+    reasoningPerMillion: cost.reasoning || 0,
+  };
+
+  const breakdown = {
+    input: toCost(tokenUsage.inputTokens || 0, pricing.inputPerMillion),
+    output: toCost(tokenUsage.outputTokens || 0, pricing.outputPerMillion),
+    cacheRead: toCost(tokenUsage.cacheReadTokens || 0, pricing.cacheReadPerMillion),
+    cacheWrite: toCost(tokenUsage.cacheWriteTokens || 0, pricing.cacheWritePerMillion),
+    reasoning: toCost(tokenUsage.reasoningTokens || 0, pricing.reasoningPerMillion),
+  };
+  const totalCostUSD = Object.values(breakdown).reduce((sum, value) => new Decimal(sum).plus(value).toNumber(), 0);
+
+  tokenUsage.contextLimit = tokenUsage.contextLimit || modelInfo.limit?.context || null;
+  tokenUsage.outputLimit = tokenUsage.outputLimit || modelInfo.limit?.output || null;
+
+  return {
+    modelId,
+    modelName: modelInfo.name || modelId,
+    provider: modelInfo.provider || 'OpenAI',
+    tokenUsage,
+    modelInfo,
+    pricing,
+    breakdown,
+    totalCostUSD,
+    usesLongContextPricing,
+    longContextThreshold: usesLongContextPricing ? CODEX_LONG_CONTEXT_PRICE_THRESHOLD : null,
+  };
+};
+
+export const calculateCodexPricing = async (modelId, tokenUsage) => {
+  if (!modelId) return null;
+  try {
+    const modelInfo = await fetchModelInfo(modelId, { preferredProviderIds: ['openai'] });
+    return calculateCodexPricingFromModelInfo(modelId, tokenUsage, modelInfo);
+  } catch (error) {
+    return buildCodexPricingFallback(modelId, tokenUsage, error.message);
+  }
+};
+
 // Function to validate Codex CLI connection
 export const validateCodexConnection = async (model = 'gpt-5.4', verbose = false) => {
   // Map model alias to full ID
@@ -773,14 +851,15 @@ export const executeCodexCommand = async params => {
       }
 
       const firstActualModelId = mappedModel;
-      const pricingInfo = firstActualModelId
-        ? {
-            modelId: firstActualModelId,
-            modelName: firstActualModelId,
-            provider: 'OpenAI',
-            tokenUsage: codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null,
-          }
-        : null;
+      const pricingInfo = firstActualModelId ? await calculateCodexPricing(firstActualModelId, codexJsonState.tokenUsage.stepCount > 0 ? codexJsonState.tokenUsage : null) : null;
+      if (pricingInfo?.totalCostUSD !== null && pricingInfo?.totalCostUSD !== undefined) {
+        await log(`💰 Codex public pricing estimate: $${new Decimal(pricingInfo.totalCostUSD).toFixed(6)}`, { verbose: true });
+        if (pricingInfo.usesLongContextPricing) {
+          await log(`   Long-context pricing applied because peak prompt exceeded ${pricingInfo.longContextThreshold.toLocaleString()} input tokens`, { verbose: true });
+        }
+      } else if (pricingInfo?.error) {
+        await log(`⚠️ Codex public pricing estimate unavailable: ${pricingInfo.error}`, { level: 'warning', verbose: true });
+      }
       const resultModelUsage = pricingInfo?.tokenUsage ? buildCodexResultModelUsage(firstActualModelId, pricingInfo.tokenUsage, pricingInfo) : null;
 
       // Check for authentication errors first - these should never be retried
@@ -831,6 +910,7 @@ export const executeCodexCommand = async params => {
           limitReached,
           limitResetTime,
           pricingInfo,
+          publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
           resultModelUsage,
           subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
           codexJsonDetails: codexJsonState,
@@ -853,6 +933,7 @@ export const executeCodexCommand = async params => {
         limitReached,
         limitResetTime,
         pricingInfo,
+        publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
         resultModelUsage,
         subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
         codexJsonDetails: codexJsonState,
@@ -882,6 +963,7 @@ export const executeCodexCommand = async params => {
         limitReached: false,
         limitResetTime: null,
         pricingInfo: null,
+        publicPricingEstimate: null,
         resultSummary: null, // Issue #1263: No result summary available on error
       };
     } finally {

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/github-cost-info.lib.mjs

@@ -21,7 +21,8 @@ const buildTokenUsageString = tokenUsage => {
 };
 
 /** Build cost estimation string for log comments (Issue #1250, Issue #1557, Issue #1600: Decimal precision) */
-export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
+export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo, options = {}) => {
+  const includeTokenUsage = options.includeTokenUsage !== false;
   const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
   const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
   const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
@@ -57,7 +58,7 @@ export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricing
       costInfo += `\n- Calculated by OpenCode Zen: $${new Decimal(pricingInfo.opencodeCost).toFixed(6)}`;
     }
   }
-  if (pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
+  if (includeTokenUsage && pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
   if (hasAnthropic) {
     costInfo += `\n- Calculated by Anthropic: $${anthropicDec.toFixed(6)}`;
     if (hasPublic) {

package/src/github.lib.mjs

@@ -501,7 +501,7 @@ ${logContent}
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
     } else if (errorDuringExecution) {
       // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
-      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
       logComment = `## ⚠️ ${SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${budgetStats}${modelInfoString}
 
@@ -519,7 +519,7 @@ ${logContent}
 ---
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
     } else {
-      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+      const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
       // Determine title based on session type (Issue #1152)
       // Issue #1625: Every title variant embeds SOLUTION_DRAFT_LOG_MARKER so
       // the filter in checkForAiCreatedComments matches every variant with a
@@ -684,7 +684,7 @@ ${errorMessage}
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
           } else if (errorDuringExecution) {
             // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
-            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
             logUploadComment = `## ⚠️ ${SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER}
 This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${budgetStats}${modelInfoString}
 
@@ -697,7 +697,7 @@ This log file contains the complete execution trace of the AI ${targetType === '
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
           } else {
             // Success log format - use helper function for cost info
-            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
+            const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo, { includeTokenUsage: !budgetStats });
             // Determine title based on session type
             // See: https://github.com/link-assistant/hive-mind/issues/1152
             // Issue #1625: titles embed SOLUTION_DRAFT_LOG_MARKER (single source).

package/src/model-info.lib.mjs

@@ -0,0 +1,66 @@
+import https from 'node:https';
+
+const buildLookupIds = modelId => (modelId?.includes('/') ? [modelId.split('/').pop(), modelId] : [modelId]);
+
+const buildProviderPriority = (modelId, preferredProviderIds = []) => {
+  const inferredProviderIds = [];
+  if (modelId?.startsWith('claude-')) inferredProviderIds.push('anthropic');
+  if (modelId?.startsWith('gpt-') || modelId?.startsWith('chatgpt-')) inferredProviderIds.push('openai');
+  return [...new Set([...preferredProviderIds, ...inferredProviderIds])];
+};
+
+const findProviderModel = (apiData, providerIds, lookupIds) => {
+  for (const providerId of providerIds) {
+    const provider = apiData[providerId];
+    if (!provider?.models) continue;
+    for (const lookupId of lookupIds) {
+      if (provider.models[lookupId]) {
+        return {
+          ...provider.models[lookupId],
+          provider: provider.name || providerId,
+        };
+      }
+    }
+  }
+  return null;
+};
+
+const fetchModelsDevApi = () =>
+  new Promise((resolve, reject) => {
+    https
+      .get('https://models.dev/api.json', res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      })
+      .on('error', reject);
+  });
+
+/**
+ * Fetches model information from models.dev.
+ * @param {string} modelId - The model ID (e.g., "claude-sonnet-4-5-20250929")
+ * @param {Object} [options]
+ * @param {string[]} [options.preferredProviderIds] Provider IDs to check before the default search order.
+ * @returns {Promise<Object|null>} Model information or null if not found
+ */
+export const fetchModelInfo = async (modelId, options = {}) => {
+  if (!modelId) return null;
+  try {
+    const apiData = await fetchModelsDevApi();
+    const lookupIds = buildLookupIds(modelId);
+    const preferredProviderIds = Array.isArray(options.preferredProviderIds) ? options.preferredProviderIds : [];
+    const providerPriority = buildProviderPriority(modelId, preferredProviderIds);
+    return findProviderModel(apiData, providerPriority, lookupIds) || findProviderModel(apiData, Object.keys(apiData), lookupIds);
+  } catch {
+    // If we can't fetch model info, return null and continue without it.
+    return null;
+  }
+};

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;
+  }
+}