@link-assistant/hive-mind 1.33.0 → 1.34.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.34.0
+
+### Minor Changes
+
+- 614c3d9: Add model information display in PR/issue log comments. Shows actual models used (extracted from CLI JSON output) vs requested model. Main model is bolded when it matches the request; a warning appears when it doesn't. Supporting models are listed separately. Uses models.dev API for full model name, provider, and knowledge cutoff. Replaces duplicated tool name mapping with unified getToolDisplayName() helper.
+
 ## 1.33.0
 
 ### Minor Changes

package/package.json

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

package/src/github.lib.mjs

@@ -10,26 +10,16 @@ import { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTok
 export { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeLogContent }; // Re-export for backward compatibility
 import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 import { formatResetTimeWithRelative } from './usage-limit.lib.mjs'; // See: https://github.com/link-assistant/hive-mind/issues/1236
+// Import model info helpers (Issue #1225)
+import { getToolDisplayName, getModelInfoForComment } from './model-info.lib.mjs';
+// Re-export for use by other modules
+export { getToolDisplayName };
 
-/**
- * Build cost estimation string for log comments
- * Issue #1250: Enhanced to show both public pricing estimate and actual provider cost
- *
- * @param {number|null} totalCostUSD - Public pricing estimate
- * @param {number|null} anthropicTotalCostUSD - Cost calculated by Anthropic (Claude-specific)
- * @param {Object|null} pricingInfo - Pricing info from agent tool
- *   - opencodeCost: Actual billed cost from OpenCode Zen (for agent tool)
- *   - isOpencodeFreeModel: Whether OpenCode Zen provides this model for free
- *   - originalProvider: Original provider for pricing reference
- *   - baseModelName: Base model name if pricing was derived from base model (Issue #1250)
- * @returns {string} Formatted cost info string for markdown (empty if no data available)
- */
+/** Build cost estimation string for log comments (Issue #1250) */
 const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
-  // Issue #1015: Don't show cost section when all values are unknown (clutters output)
   const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
   const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
   const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
-  // Issue #1250: Check for OpenCode Zen actual cost
   const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
   if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
   let costInfo = '\n\n💰 **Cost estimation:**';
@@ -37,15 +27,10 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
     costInfo += `\n- Model: ${pricingInfo.modelName}`;
     if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
   }
-  // Issue #1250: Show public pricing estimate based on original provider prices
   if (hasPublic) {
-    // Issue #1250: For free models accessed via OpenCode Zen, show pricing based on base model
-    // Only show as completely free if the base model also has no pricing
     if (pricingInfo?.isFreeModel && totalCostUSD === 0 && !pricingInfo?.baseModelName) {
       costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
     } else {
-      // Show actual public pricing estimate with original provider reference
-      // Issue #1250: Include base model reference when pricing comes from base model
       let pricingRef = '';
       if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
         pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
@@ -57,7 +42,6 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
   } else if (hasPricing) {
     costInfo += '\n- Public pricing estimate: unknown';
   }
-  // Issue #1250: Show actual cost from OpenCode Zen for agent tool
   if (hasOpencodeCost) {
     if (pricingInfo.isOpencodeFreeModel) {
       costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
@@ -360,26 +344,7 @@ Thank you! 🙏`;
     return false;
   }
 };
-/**
- * Attaches a log file to a GitHub PR or issue as a comment
- * @param {Object} options - Configuration options
- * @param {string} options.logFile - Path to the log file
- * @param {string} options.targetType - 'pr' or 'issue'
- * @param {number} options.targetNumber - PR or issue number
- * @param {string} options.owner - Repository owner
- * @param {string} options.repo - Repository name
- * @param {Function} options.$ - Command execution function
- * @param {Function} options.log - Logging function
- * @param {Function} options.sanitizeLogContent - Function to sanitize log content
- * @param {boolean} [options.verbose=false] - Enable verbose logging
- * @param {string} [options.errorMessage] - Error message to include in comment (for failure logs)
- * @param {string} [options.customTitle] - Custom title for the comment (defaults to "🤖 Solution Draft Log")
- * @param {boolean} [options.isUsageLimit] - Whether this is a usage limit error
- * @param {string} [options.limitResetTime] - Time when usage limit resets
- * @param {string} [options.toolName] - Name of the tool (claude, codex, opencode)
- * @param {string} [options.resumeCommand] - Command to resume the session
- * @returns {Promise<boolean>} - True if upload succeeded
- */
+/** Attaches a log file to a GitHub PR or issue as a comment. Returns true if upload succeeded. */
 export async function attachLogToGitHub(options) {
   const fs = (await use('fs')).promises;
   const {
@@ -413,6 +378,9 @@ export async function attachLogToGitHub(options) {
     pricingInfo = null,
     // Issue #1088: Track error_during_execution for "Finished with errors" state
     errorDuringExecution = false,
+    // Issue #1225: Model information for PR comments
+    requestedModel = null, // The --model flag value (e.g., "opus", "sonnet")
+    tool = null, // The tool used (e.g., "claude", "agent", "codex", "opencode")
   } = options;
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
@@ -433,6 +401,8 @@ export async function attachLogToGitHub(options) {
     // Calculate token usage if sessionId and tempDir are provided
     // For agent tool, publicPricingEstimate is already provided, so we skip Claude-specific calculation
     let totalCostUSD = publicPricingEstimate;
+    // Issue #1225: Collect actual model IDs from Claude session JSON output
+    let actualModelIds = null;
     if (totalCostUSD === null && sessionId && tempDir && !errorMessage) {
       try {
         const { calculateSessionTokens } = await import('./claude.lib.mjs');
@@ -444,6 +414,13 @@ export async function attachLogToGitHub(options) {
               await log(`  💰 Calculated cost: $${totalCostUSD.toFixed(6)}`, { verbose: true });
             }
           }
+          // Extract actual model IDs from session data (Issue #1225)
+          if (tokenUsage.modelUsage && Object.keys(tokenUsage.modelUsage).length > 0) {
+            actualModelIds = Object.keys(tokenUsage.modelUsage);
+            if (verbose) {
+              await log(`  🤖 Actual models used: ${actualModelIds.join(', ')}`, { verbose: true });
+            }
+          }
         }
       } catch (tokenError) {
         // Don't fail the entire upload if token calculation fails
@@ -452,6 +429,25 @@ export async function attachLogToGitHub(options) {
         }
       }
     }
+    // For agent tool, extract actual model ID from pricingInfo (Issue #1225)
+    if (!actualModelIds && pricingInfo?.modelId) {
+      actualModelIds = [pricingInfo.modelId];
+    }
+    // Issue #1225: Fetch model information for comment using actual models from CLI output
+    let modelInfoString = '';
+    if (requestedModel || tool || actualModelIds) {
+      try {
+        modelInfoString = await getModelInfoForComment({ requestedModel, tool, pricingInfo, actualModelIds });
+        if (verbose && modelInfoString) {
+          await log('  🤖 Model info fetched for comment', { verbose: true });
+        }
+      } catch (modelInfoError) {
+        // Non-critical: continue without model info
+        if (verbose) {
+          await log(`  ⚠️  Could not fetch model info: ${modelInfoError.message}`, { verbose: true });
+        }
+      }
+    }
     // Read and sanitize log content
     const rawLogContent = await fs.readFile(logFile, 'utf8');
     if (verbose) {
@@ -523,7 +519,7 @@ ${resumeCommand}
         }
       }
 
-      logComment += `
+      logComment += `${modelInfoString}
 
 <details>
 <summary>Click to expand execution log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -542,7 +538,7 @@ ${logContent}
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
-\`\`\`
+\`\`\`${modelInfoString}
 
 <details>
 <summary>Click to expand failure log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -559,7 +555,7 @@ ${logContent}
       // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
       const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
       logComment = `## ⚠️ Solution Draft Finished with Errors
-This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
+This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${modelInfoString}
 
 **Note**: The session encountered errors during execution, but some work may have been completed. Please review the changes carefully.
 
@@ -592,7 +588,7 @@ ${logContent}
         sessionNote = '\n\n**Note**: This session was manually resumed using the --resume flag.';
       }
       logComment = `## ${title}
-This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${sessionNote}
+This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${modelInfoString}${sessionNote}
 
 <details>
 <summary>Click to expand solution draft log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -716,7 +712,7 @@ ${resumeCommand}
               }
             }
 
-            logUploadComment += `
+            logUploadComment += `${modelInfoString}
 
 📎 **Execution log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
 🔗 [View complete execution log](${logUrl})
@@ -729,7 +725,7 @@ ${resumeCommand}
 The automated solution draft encountered an error:
 \`\`\`
 ${errorMessage}
-\`\`\`
+\`\`\`${modelInfoString}
 📎 **Failure log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
 🔗 [View complete failure log](${logUrl})
 ---
@@ -738,7 +734,7 @@ ${errorMessage}
             // Issue #1088: "Finished with errors" format - work may have been completed but errors occurred
             const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
             logUploadComment = `## ⚠️ Solution Draft Finished with Errors
-This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
+This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${modelInfoString}
 
 **Note**: The session encountered errors during execution, but some work may have been completed. Please review the changes carefully.
 
@@ -764,7 +760,7 @@ This log file contains the complete execution trace of the AI ${targetType === '
               sessionNote = '\n**Note**: This session was manually resumed using the --resume flag.\n';
             }
             logUploadComment = `## ${title}
-This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
+This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}${modelInfoString}
 ${sessionNote}📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
 🔗 [View complete solution draft log](${logUrl})
 ---
@@ -1482,6 +1478,7 @@ export default {
   checkGitHubPermissions,
   checkRepositoryWritePermission,
   attachLogToGitHub,
+  getToolDisplayName,
   uploadLogWithGhUploadLog,
   fetchAllIssuesWithPagination,
   fetchProjectIssues,

package/src/model-info.lib.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+/**
+ * Model information library for hive-mind
+ * Provides unified model display, verification, and metadata fetching
+ * for all tools (Claude, Agent, OpenCode, Codex).
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1225
+ */
+
+// Check if use is already defined (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+
+import { log } from './lib.mjs';
+
+/**
+ * Map tool identifier to user-friendly display name.
+ * Replaces duplicated ternary chains across the codebase.
+ * @param {string|null} tool - The tool identifier (claude, codex, opencode, agent)
+ * @returns {string} User-friendly display name
+ */
+export const getToolDisplayName = tool => {
+  const name = (tool || '').toString().toLowerCase();
+  switch (name) {
+    case 'claude':
+      return 'Claude';
+    case 'codex':
+      return 'Codex';
+    case 'opencode':
+      return 'OpenCode';
+    case 'agent':
+      return 'Agent';
+    default:
+      return 'AI tool';
+  }
+};
+
+/**
+ * Cached models.dev API response to avoid repeated network requests.
+ * The cache is per-process and cleared when the process exits.
+ */
+let modelsDevCache = null;
+
+/**
+ * Fetch the full models.dev API data with caching.
+ * @returns {Promise<Object|null>} The full API response or null on failure
+ */
+const fetchModelsDevApi = async () => {
+  if (modelsDevCache) return modelsDevCache;
+  try {
+    const https = (await globalThis.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 {
+              modelsDevCache = JSON.parse(data);
+              resolve(modelsDevCache);
+            } catch (parseError) {
+              reject(parseError);
+            }
+          });
+        })
+        .on('error', err => {
+          reject(err);
+        });
+    });
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Fetch model metadata from models.dev API.
+ * Returns enriched model information including name, provider, version, and knowledge cutoff.
+ * @param {string} modelId - The model ID (e.g., "claude-opus-4-6", "opencode/grok-code")
+ * @returns {Promise<Object|null>} Model metadata or null if not found
+ */
+export const fetchModelInfoForComment = async modelId => {
+  if (!modelId) return null;
+  try {
+    const apiData = await fetchModelsDevApi();
+    if (!apiData) return null;
+
+    // Normalize model ID: strip provider prefix for lookup (e.g., "anthropic/claude-3-5-sonnet" -> "claude-3-5-sonnet")
+    const lookupId = modelId.includes('/') ? modelId.split('/').pop() : modelId;
+
+    // Check Anthropic provider first (most common for Claude tools)
+    if (apiData.anthropic?.models?.[lookupId]) {
+      const modelInfo = { ...apiData.anthropic.models[lookupId] };
+      modelInfo.provider = apiData.anthropic.name || 'Anthropic';
+      return modelInfo;
+    }
+
+    // Search across all providers
+    for (const provider of Object.values(apiData)) {
+      if (provider.models && provider.models[lookupId]) {
+        const modelInfo = { ...provider.models[lookupId] };
+        modelInfo.provider = provider.name || provider.id;
+        return modelInfo;
+      }
+    }
+
+    // Try the full modelId (with provider prefix) as well
+    if (lookupId !== modelId) {
+      for (const provider of Object.values(apiData)) {
+        if (provider.models && provider.models[modelId]) {
+          const modelInfo = { ...provider.models[modelId] };
+          modelInfo.provider = provider.name || provider.id;
+          return modelInfo;
+        }
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Normalize model ID for comparison purposes (strip suffixes, lowercase).
+ * @param {string} modelId - A model ID or alias
+ * @returns {string} Normalized ID
+ */
+const normalizeForComparison = modelId => {
+  if (!modelId) return '';
+  return modelId
+    .toLowerCase()
+    .replace(/\[1m\]$/i, '')
+    .trim();
+};
+
+/**
+ * Check if a requested model alias matches an actual model ID.
+ * @param {string} requestedModel - The --model flag value (alias or full ID)
+ * @param {string} actualModelId - The actual model ID from CLI output
+ * @param {string|null} tool - The tool being used
+ * @returns {boolean}
+ */
+const doesRequestedMatchActual = (requestedModel, actualModelId, tool) => {
+  if (!requestedModel || !actualModelId) return false;
+  const resolvedRequested = resolveModelId(requestedModel, tool);
+  const normResolved = normalizeForComparison(resolvedRequested);
+  const normActual = normalizeForComparison(actualModelId);
+  // Direct match
+  if (normResolved === normActual) return true;
+  // Partial match: resolved starts with actual or vice versa (for date-suffixed IDs)
+  if (normActual.startsWith(normResolved) || normResolved.startsWith(normActual)) return true;
+  return false;
+};
+
+/**
+ * Build model information string for PR/issue comments.
+ * Displays the requested model vs actual models used from CLI JSON output.
+ * The main model is bolded if it matches the requested model.
+ * A warning is shown if the main model doesn't match the requested model.
+ *
+ * @param {Object} options - Model info options
+ * @param {string|null} options.requestedModel - The model requested via --model flag (e.g., "opus")
+ * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex)
+ * @param {Object|null} options.pricingInfo - Pricing info from tool result (agent tool provides modelId)
+ * @param {Object|null} options.modelInfo - Pre-fetched model metadata from models.dev (for first actual model)
+ * @param {Array<{modelId: string, modelInfo: Object|null}>|null} options.modelsUsed - Actual models used from CLI JSON output
+ * @returns {string} Formatted markdown string for model info section (empty if no data available)
+ */
+export const buildModelInfoString = ({ requestedModel = null, tool = null, pricingInfo = null, modelInfo = null, modelsUsed = null } = {}) => {
+  const hasRequested = requestedModel !== null && requestedModel !== undefined;
+  const hasModelsUsed = Array.isArray(modelsUsed) && modelsUsed.length > 0;
+  const hasModelInfo = modelInfo !== null;
+  const hasPricingModel = pricingInfo?.modelId || pricingInfo?.modelName;
+
+  if (!hasRequested && !hasModelsUsed && !hasModelInfo && !hasPricingModel) return '';
+
+  let info = '\n\n🤖 **Models used:**';
+
+  // Display tool name
+  if (tool) {
+    info += `\n- Tool: ${getToolDisplayName(tool)}`;
+  }
+
+  // Display requested model (--model flag value)
+  if (hasRequested) {
+    info += `\n- Requested: \`${requestedModel}\``;
+  }
+
+  if (hasModelsUsed) {
+    // The first model is considered the "main" model
+    const [mainEntry, ...supportingEntries] = modelsUsed;
+    const mainModelId = mainEntry.modelId;
+    const mainModelMeta = mainEntry.modelInfo;
+
+    const mainMatches = hasRequested ? doesRequestedMatchActual(requestedModel, mainModelId, tool) : true;
+
+    // Build main model line
+    const mainModelName = mainModelMeta?.name || mainModelId;
+    const mainModelProvider = mainModelMeta?.provider || null;
+    const mainModelKnowledge = mainModelMeta?.knowledge || null;
+
+    if (mainMatches) {
+      info += `\n- **Main model: ${mainModelName}** (ID: \`${mainModelId}\`${mainModelProvider ? `, ${mainModelProvider}` : ''}${mainModelKnowledge ? `, cutoff: ${mainModelKnowledge}` : ''})`;
+    } else {
+      // Main model doesn't match requested - show warning
+      info += `\n- **Main model: ${mainModelName}** (ID: \`${mainModelId}\`${mainModelProvider ? `, ${mainModelProvider}` : ''}${mainModelKnowledge ? `, cutoff: ${mainModelKnowledge}` : ''})`;
+      if (hasRequested) {
+        info += `\n- ⚠️ **Warning**: Main model \`${mainModelId}\` does not match requested model \`${requestedModel}\``;
+      }
+    }
+
+    // Display supporting models
+    if (supportingEntries.length > 0) {
+      info += '\n- Supporting models:';
+      for (const entry of supportingEntries) {
+        const name = entry.modelInfo?.name || entry.modelId;
+        const provider = entry.modelInfo?.provider || null;
+        info += `\n  - ${name} (\`${entry.modelId}\`${provider ? `, ${provider}` : ''})`;
+      }
+    }
+  } else if (hasModelInfo) {
+    // Fallback: single model info from models.dev (no actual CLI output data)
+    const mainModelName = modelInfo.name || (pricingInfo?.modelId ? pricingInfo.modelId : null) || 'Unknown';
+    info += `\n- Model: ${mainModelName}`;
+    if (modelInfo.id) info += ` (ID: \`${modelInfo.id}\`)`;
+    if (modelInfo.provider) info += `\n- Provider: ${modelInfo.provider}`;
+    if (modelInfo.knowledge) info += `\n- Knowledge cutoff: ${modelInfo.knowledge}`;
+  } else if (hasPricingModel) {
+    // Fallback to pricingInfo when no models.dev data
+    const modelId = pricingInfo.modelId || null;
+    const modelName = pricingInfo.modelName || modelId || 'Unknown';
+    if (modelId && modelId !== modelName) {
+      info += `\n- Model: ${modelName} (ID: \`${modelId}\`)`;
+    } else {
+      info += `\n- Model: ${modelName}`;
+    }
+    if (pricingInfo.provider) info += `\n- Provider: ${pricingInfo.provider}`;
+  }
+
+  return info;
+};
+
+/**
+ * Resolve the full model ID from a user-provided alias using the model mapping.
+ * @param {string|null} requestedModel - The model alias (e.g., "opus", "sonnet")
+ * @param {string|null} tool - The tool being used
+ * @returns {string|null} The full model ID or null
+ */
+export const resolveModelId = (requestedModel, tool) => {
+  if (!requestedModel) return null;
+
+  try {
+    // Use model-mapping.lib.mjs mappings as authoritative source
+    const modelMaps = {
+      claude: {
+        sonnet: 'claude-sonnet-4-6',
+        opus: 'claude-opus-4-5-20251101',
+        haiku: 'claude-haiku-4-5-20251001',
+        'opus-4-6': 'claude-opus-4-6',
+        'opus-4-5': 'claude-opus-4-5-20251101',
+        'sonnet-4-6': 'claude-sonnet-4-6',
+        'sonnet-4-5': 'claude-sonnet-4-5-20250929',
+        'haiku-4-5': 'claude-haiku-4-5-20251001',
+      },
+      agent: {
+        grok: 'opencode/grok-code',
+        'grok-code': 'opencode/grok-code',
+        sonnet: 'anthropic/claude-3-5-sonnet',
+        opus: 'anthropic/claude-3-opus',
+        haiku: 'anthropic/claude-3-5-haiku',
+      },
+      opencode: {
+        gpt4: 'openai/gpt-4',
+        gpt4o: 'openai/gpt-4o',
+        sonnet: 'anthropic/claude-3-5-sonnet',
+        opus: 'anthropic/claude-3-opus',
+        grok: 'opencode/grok-code',
+      },
+      codex: {
+        gpt5: 'gpt-5',
+        'gpt-5': 'gpt-5',
+        o3: 'o3',
+        gpt4: 'gpt-4',
+        gpt4o: 'gpt-4o',
+        sonnet: 'claude-3-5-sonnet',
+        opus: 'claude-3-opus',
+      },
+    };
+
+    const toolName = (tool || 'claude').toString().toLowerCase();
+    const map = modelMaps[toolName];
+    if (map) {
+      // Strip [1m] suffix if present (1M context window flag)
+      const cleanModel = requestedModel.replace(/\[1m\]$/i, '');
+      return map[cleanModel.toLowerCase()] || cleanModel;
+    }
+
+    return requestedModel;
+  } catch {
+    return requestedModel;
+  }
+};
+
+/**
+ * Fetch model info and build the complete model information string for PR comments.
+ * Uses actual models from CLI JSON output when available.
+ *
+ * @param {Object} options
+ * @param {string|null} options.requestedModel - The --model flag value
+ * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex)
+ * @param {Object|null} options.pricingInfo - Pricing info from tool result
+ * @param {Array<string>|null} options.actualModelIds - Actual model IDs from CLI JSON output
+ *   For Claude: from tokenUsage.modelUsage keys (model IDs used in session)
+ *   For Agent: from pricingInfo.modelId
+ * @returns {Promise<string>} Formatted markdown model info section
+ */
+export const getModelInfoForComment = async ({ requestedModel = null, tool = null, pricingInfo = null, actualModelIds = null } = {}) => {
+  // Determine the list of actual model IDs to display
+  // Priority: explicit actualModelIds > pricingInfo.modelId > resolve from requestedModel
+  let modelIds = [];
+
+  if (Array.isArray(actualModelIds) && actualModelIds.length > 0) {
+    modelIds = actualModelIds;
+  } else if (pricingInfo?.modelId) {
+    // Agent tool provides pricingInfo.modelId as the actual model used
+    modelIds = [pricingInfo.modelId];
+  } else if (requestedModel) {
+    // Fallback: resolve from requested model alias
+    const resolved = resolveModelId(requestedModel, tool);
+    if (resolved) modelIds = [resolved];
+  }
+
+  // Fetch model metadata from models.dev for each model ID
+  const modelsUsed = [];
+  for (const modelId of modelIds) {
+    let meta = null;
+    try {
+      meta = await fetchModelInfoForComment(modelId);
+    } catch {
+      await log('  ⚠️  Could not fetch model info from models.dev', { verbose: true });
+    }
+    modelsUsed.push({ modelId, modelInfo: meta });
+  }
+
+  // Determine which modelInfo to pass for legacy fallback (first model's metadata)
+  const firstModelInfo = modelsUsed.length > 0 ? modelsUsed[0].modelInfo : null;
+
+  return buildModelInfoString({
+    requestedModel,
+    tool,
+    pricingInfo,
+    modelInfo: modelsUsed.length === 0 ? firstModelInfo : null, // only used as fallback when no modelsUsed
+    modelsUsed: modelsUsed.length > 0 ? modelsUsed : null,
+  });
+};

package/src/solve.auto-merge.lib.mjs

@@ -790,6 +790,9 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                   anthropicTotalCostUSD: latestAnthropicCost,
                   publicPricingEstimate: toolResult.publicPricingEstimate,
                   pricingInfo: toolResult.pricingInfo,
+                  // Issue #1225: Pass model and tool info for PR comments
+                  requestedModel: argv.model,
+                  tool: argv.tool || 'claude',
                 });
                 await log(formatAligned('', '✅ Session log uploaded to PR', '', 2));
               }

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

@@ -54,6 +54,9 @@ export const handleFailure = async options => {
         sanitizeLogContent,
         verbose: argv.verbose,
         errorMessage: cleanErrorMessage(error),
+        // Issue #1225: Pass model and tool info for PR comments
+        requestedModel: argv.model,
+        tool: argv.tool || 'claude',
       });
       if (logUploadSuccess) {
         await log('📎 Failure log attached to Pull Request');

package/src/solve.execution.lib.mjs

@@ -194,6 +194,9 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
           sanitizeLogContent,
           verbose: argv.verbose || false,
           errorMessage: cleanErrorMessage(error),
+          // Issue #1225: Pass model and tool info for PR comments
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
 
         if (logUploadSuccess) {

package/src/solve.interrupt.lib.mjs

@@ -59,6 +59,9 @@ export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChan
           sanitizeLogContent,
           verbose: ctx.argv.verbose || false,
           errorMessage: 'Session interrupted by user (CTRL+C)',
+          // Issue #1225: Pass model and tool info for PR comments
+          requestedModel: ctx.argv.model,
+          tool: ctx.argv.tool || 'claude',
         });
       } catch (uploadError) {
         await log(`⚠️  Could not upload logs on interrupt: ${uploadError.message}`, {

package/src/solve.mjs

@@ -50,7 +50,7 @@ const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
 const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, getVersionInfo } = lib;
 const githubLib = await import('./github.lib.mjs');
-const { sanitizeLogContent, attachLogToGitHub } = githubLib;
+const { sanitizeLogContent, attachLogToGitHub, getToolDisplayName } = githubLib;
 const validation = await import('./solve.validation.lib.mjs');
 const { validateGitHubUrl, showAttachLogsWarning, initializeLogFile, validateUrlRequirement, validateContinueOnlyOnFeedback, performSystemChecks } = validation;
 const autoContinue = await import('./solve.auto-continue.lib.mjs');
@@ -79,26 +79,15 @@ const exitHandler = await import('./exit-handler.lib.mjs');
 const { initializeExitHandler, installGlobalExitHandlers, safeExit, logActiveHandles } = exitHandler;
 const { createInterruptWrapper } = await import('./solve.interrupt.lib.mjs');
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
-
-// Import new modular components
-const autoPrLib = await import('./solve.auto-pr.lib.mjs');
-const { handleAutoPrCreation } = autoPrLib;
-const repoSetupLib = await import('./solve.repo-setup.lib.mjs');
-const { setupRepositoryAndClone, verifyDefaultBranchAndStatus } = repoSetupLib;
-const branchLib = await import('./solve.branch.lib.mjs');
-const { createOrCheckoutBranch } = branchLib;
-const sessionLib = await import('./solve.session.lib.mjs');
-const { startWorkSession, endWorkSession, SESSION_TYPES } = sessionLib;
-const preparationLib = await import('./solve.preparation.lib.mjs');
-const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions } = preparationLib;
-
-// Import model validation library
-const modelValidation = await import('./model-validation.lib.mjs');
-const { validateAndExitOnInvalidModel } = modelValidation;
-const acceptInviteLib = await import('./solve.accept-invite.lib.mjs');
-const { autoAcceptInviteForRepo } = acceptInviteLib;
-
-// Initialize log file EARLY (use cwd initially, will be updated after argv parsing)
+const { handleAutoPrCreation } = await import('./solve.auto-pr.lib.mjs');
+const { setupRepositoryAndClone, verifyDefaultBranchAndStatus } = await import('./solve.repo-setup.lib.mjs');
+const { createOrCheckoutBranch } = await import('./solve.branch.lib.mjs');
+const { startWorkSession, endWorkSession, SESSION_TYPES } = await import('./solve.session.lib.mjs');
+const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions } = await import('./solve.preparation.lib.mjs');
+const { validateAndExitOnInvalidModel } = await import('./model-validation.lib.mjs');
+const { autoAcceptInviteForRepo } = await import('./solve.accept-invite.lib.mjs');
+
+// Initialize log file early (before argument parsing) to capture all output
 const logFile = await initializeLogFile(null);
 
 // Log version and raw command IMMEDIATELY after log file initialization (ensures they appear even if parsing fails)
@@ -944,9 +933,11 @@ try {
             // Mark this as a usage limit case for proper formatting
             isUsageLimit: true,
             limitResetTime: global.limitResetTime,
-            toolName: (argv.tool || 'AI tool').toString().toLowerCase() === 'claude' ? 'Claude' : (argv.tool || 'AI tool').toString().toLowerCase() === 'codex' ? 'Codex' : (argv.tool || 'AI tool').toString().toLowerCase() === 'opencode' ? 'OpenCode' : (argv.tool || 'AI tool').toString().toLowerCase() === 'agent' ? 'Agent' : 'AI tool',
+            toolName: getToolDisplayName(argv.tool),
             resumeCommand,
             sessionId,
+            requestedModel: argv.model,
+            tool: argv.tool || 'claude',
           });
 
           if (logUploadSuccess) {
@@ -1004,13 +995,15 @@ try {
               // Mark this as a usage limit case for proper formatting
               isUsageLimit: true,
               limitResetTime: global.limitResetTime,
-              toolName: (argv.tool || 'AI tool').toString().toLowerCase() === 'claude' ? 'Claude' : (argv.tool || 'AI tool').toString().toLowerCase() === 'codex' ? 'Codex' : (argv.tool || 'AI tool').toString().toLowerCase() === 'opencode' ? 'OpenCode' : (argv.tool || 'AI tool').toString().toLowerCase() === 'agent' ? 'Agent' : 'AI tool',
+              toolName: getToolDisplayName(argv.tool),
               resumeCommand,
               sessionId,
               // Tell attachLogToGitHub that auto-resume is enabled to suppress CLI commands in the comment
               // See: https://github.com/link-assistant/hive-mind/issues/1152
               isAutoResumeEnabled: true,
               autoResumeMode: limitContinueMode,
+              requestedModel: argv.model,
+              tool: argv.tool || 'claude',
             });
 
             if (logUploadSuccess) {
@@ -1099,12 +1092,14 @@ try {
           // For usage limit, use a dedicated comment format to make it clear and actionable
           isUsageLimit: !!limitReached,
           limitResetTime: limitReached ? toolResult.limitResetTime : null,
-          toolName: (argv.tool || 'AI tool').toString().toLowerCase() === 'claude' ? 'Claude' : (argv.tool || 'AI tool').toString().toLowerCase() === 'codex' ? 'Codex' : (argv.tool || 'AI tool').toString().toLowerCase() === 'opencode' ? 'OpenCode' : (argv.tool || 'AI tool').toString().toLowerCase() === 'agent' ? 'Agent' : 'AI tool',
+          toolName: getToolDisplayName(argv.tool),
           resumeCommand,
           // Include sessionId so the PR comment can present it
           sessionId,
           // If not a usage limit case, fall back to generic failure format
           errorMessage: limitReached ? undefined : `${argv.tool.toUpperCase()} execution failed`,
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
 
         if (logUploadSuccess) {
@@ -1356,6 +1351,8 @@ try {
           sessionId,
           tempDir,
           anthropicTotalCostUSD,
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
 
         if (logUploadSuccess) {

package/src/solve.results.lib.mjs

@@ -675,6 +675,9 @@ Fixes ${issueRef}
             errorDuringExecution,
             // Issue #1152: Pass sessionType for differentiated log comments
             sessionType,
+            // Issue #1225: Pass model and tool info for PR comments
+            requestedModel: argv.model,
+            tool: argv.tool || 'claude',
           });
         }
 
@@ -754,6 +757,9 @@ Fixes ${issueRef}
           errorDuringExecution,
           // Issue #1152: Pass sessionType for differentiated log comments
           sessionType,
+          // Issue #1225: Pass model and tool info for issue comments
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
       }
 
@@ -838,6 +844,9 @@ export const handleExecutionError = async (error, shouldAttachLogs, owner, repo,
           sanitizeLogContent,
           verbose: argv.verbose || false,
           errorMessage: cleanErrorMessage(error),
+          // Issue #1225: Pass model and tool info for PR comments
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
 
         if (logUploadSuccess) {

package/src/solve.watch.lib.mjs

@@ -297,6 +297,9 @@ export const watchForFeedback = async params => {
                   // Mark if this was a usage limit failure
                   isUsageLimit: toolResult.limitReached,
                   limitResetTime: toolResult.limitResetTime,
+                  // Issue #1225: Pass model and tool info for PR comments
+                  requestedModel: argv.model,
+                  tool: argv.tool || 'claude',
                 });
 
                 if (logUploadSuccess) {
@@ -363,6 +366,9 @@ export const watchForFeedback = async params => {
                   // Pass agent tool pricing data when available
                   publicPricingEstimate: toolResult.publicPricingEstimate,
                   pricingInfo: toolResult.pricingInfo,
+                  // Issue #1225: Pass model and tool info for PR comments
+                  requestedModel: argv.model,
+                  tool: argv.tool || 'claude',
                 });
 
                 if (logUploadSuccess) {