@link-assistant/hive-mind 1.32.3 → 1.34.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- f7a2fdd: Add --auto-init-repository option to automatically initialize empty repositories by creating a simple README.md file, enabling branch creation and pull request workflows on repositories with no commits
+
 ## 1.32.3
 
 ### Patch Changes

package/README.md

@@ -341,12 +341,13 @@ solve <issue-url> [options]
 
 **Other useful options:**
 
-| Option          | Alias | Description                                      | Default |
-| --------------- | ----- | ------------------------------------------------ | ------- |
-| `--tool`        |       | AI tool (claude, opencode, codex, agent)         | claude  |
-| `--verbose`     | `-v`  | Enable verbose logging                           | false   |
-| `--attach-logs` |       | Attach logs to PR (⚠️ may expose sensitive data) | false   |
-| `--help`        | `-h`  | Show all available options                       | -       |
+| Option                   | Alias | Description                                      | Default |
+| ------------------------ | ----- | ------------------------------------------------ | ------- |
+| `--tool`                 |       | AI tool (claude, opencode, codex, agent)         | claude  |
+| `--verbose`              | `-v`  | Enable verbose logging                           | false   |
+| `--attach-logs`          |       | Attach logs to PR (⚠️ may expose sensitive data) | false   |
+| `--auto-init-repository` |       | Auto-initialize empty repos (creates README.md)  | false   |
+| `--help`                 | `-h`  | Show all available options                       | -       |
 
 > **📖 Full options list**: See [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options) for all available options including forking, auto-continue, watch mode, and experimental features.
 

package/package.json

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

@@ -215,6 +215,7 @@ const KNOWN_OPTION_NAMES = [
   'prompt-examples-folder',
   'session-type',
   'working-directory',
+  'auto-init-repository',
   'prompt-ensure-all-requirements-are-met',
   'finalize',
   'finalize-model',

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.branch-errors.lib.mjs

@@ -232,15 +232,35 @@ export async function handleBranchCreationError({ branchName, errorOutput, tempD
     await log(`     ${line}`);
   }
   await log('');
-  await log('  💡 Possible causes:');
-  await log('     • Branch name already exists');
-  await log('     • Uncommitted changes in repository');
-  await log('     • Git configuration issues');
-  await log('');
-  await log('  🔧 How to fix:');
-  await log('     1. Try running the command again (uses random names)');
-  await log(`     2. Check git status: cd ${tempDir} && git status`);
-  await log(`     3. View existing branches: cd ${tempDir} && git branch -a`);
+
+  // Check if this is an empty repository error (no commits to branch from)
+  const isEmptyRepoError = errorOutput.includes('is not a commit') || errorOutput.includes('not a valid object name') || errorOutput.includes('unknown revision');
+  if (isEmptyRepoError) {
+    await log('  💡 Root cause:');
+    await log('     The repository appears to be empty (no commits).');
+    await log('     Cannot create a branch from a non-existent commit.');
+    await log('');
+    await log('  🔧 How to fix:');
+    await log('     Use the --auto-init-repository flag to automatically initialize the repository:');
+    if (owner && repo) {
+      await log(`       solve https://github.com/${owner}/${repo}/issues/<number> --auto-init-repository`);
+    } else {
+      await log('       solve <issue-url> --auto-init-repository');
+    }
+    await log('');
+    await log('     This will create a simple README.md file to make the repository non-empty,');
+    await log('     allowing branch creation and pull request workflows to proceed.');
+  } else {
+    await log('  💡 Possible causes:');
+    await log('     • Branch name already exists');
+    await log('     • Uncommitted changes in repository');
+    await log('     • Git configuration issues');
+    await log('');
+    await log('  🔧 How to fix:');
+    await log('     1. Try running the command again (uses random names)');
+    await log(`     2. Check git status: cd ${tempDir} && git status`);
+    await log(`     3. View existing branches: cd ${tempDir} && git branch -a`);
+  }
 }
 
 export async function handleBranchVerificationError({ isContinueMode, branchName, actualBranch, prNumber, owner, repo, tempDir, formatAligned, log, $ }) {

package/src/solve.config.lib.mjs

@@ -362,6 +362,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Guide Claude to use agent-commander CLI (start-agent) instead of native Task tool for subagent delegation. Allows using any supported agent type (claude, opencode, codex, agent) with unified API. Only works with --tool claude and requires agent-commander to be installed.',
     default: false,
   },
+  'auto-init-repository': {
+    type: 'boolean',
+    description: 'Automatically initialize empty repositories by creating a simple README.md file. Only works when you have write access to the repository. This allows branch creation and pull request workflows to proceed on repositories that have no commits.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI solution summary (from the result field) as a comment to the PR/issue after completion. The summary is extracted from the AI tool JSON output and posted under a "Solution summary" header.',

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)
@@ -534,11 +523,16 @@ try {
   });
 
   // Verify default branch and status using the new module
+  // Pass argv, owner, repo, issueUrl for empty repository auto-initialization (--auto-init-repository)
   const defaultBranch = await verifyDefaultBranchAndStatus({
     tempDir,
     log,
     formatAligned,
     $,
+    argv,
+    owner,
+    repo,
+    issueUrl,
   });
   // Create or checkout branch using the new module
   const branchName = await createOrCheckoutBranch({
@@ -939,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) {
@@ -999,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) {
@@ -1094,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) {
@@ -1351,6 +1351,8 @@ try {
           sessionId,
           tempDir,
           anthropicTotalCostUSD,
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
         });
 
         if (logUploadSuccess) {

package/src/solve.repo-setup.lib.mjs

@@ -56,7 +56,7 @@ async function setupPrForkRemote(tempDir, argv, prForkOwner, repo, isContinueMod
   return await setupPrForkFn(tempDir, argv, prForkOwner, repo, isContinueMode, owner);
 }
 
-export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned, $ }) {
+export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned, $, argv, owner, repo, issueUrl }) {
   // Verify we're on the default branch and get its name
   const defaultBranchResult = await $({ cwd: tempDir })`git branch --show-current`;
 
@@ -66,27 +66,128 @@ export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned
     throw new Error('Failed to get current branch');
   }
 
-  const defaultBranch = defaultBranchResult.stdout.toString().trim();
+  let defaultBranch = defaultBranchResult.stdout.toString().trim();
   if (!defaultBranch) {
-    await log('');
-    await log(`${formatAligned('❌', 'DEFAULT BRANCH DETECTION FAILED', '')}`, { level: 'error' });
-    await log('');
-    await log('  🔍 What happened:');
-    await log("     Unable to determine the repository's default branch.");
-    await log('');
-    await log('  💡 This might mean:');
-    await log('     • Repository is empty (no commits)');
-    await log('     • Unusual repository configuration');
-    await log('     • Git command issues');
-    await log('');
-    await log('  🔧 How to fix:');
-    await log('     1. Check repository status');
-    await log(`     2. Verify locally: cd ${tempDir} && git branch`);
-    await log(`     3. Check remote: cd ${tempDir} && git branch -r`);
-    await log('');
-    throw new Error('Default branch detection failed');
+    // Repository is likely empty (no commits) - detect and handle
+    const isEmptyRepo = await detectEmptyRepository(tempDir, $);
+
+    if (isEmptyRepo && argv && argv.autoInitRepository && owner && repo) {
+      // --auto-init-repository is enabled, try to initialize
+      await log('');
+      await log(`${formatAligned('⚠️', 'EMPTY REPOSITORY', 'detected')}`, { level: 'warn' });
+      await log(`${formatAligned('', '', `Repository ${owner}/${repo} contains no commits`)}`);
+      await log(`${formatAligned('', '', '--auto-init-repository is enabled, attempting initialization...')}`);
+      await log('');
+
+      const repository = await import('./solve.repository.lib.mjs');
+      const { tryInitializeEmptyRepository } = repository;
+      const initialized = await tryInitializeEmptyRepository(owner, repo);
+
+      if (initialized) {
+        await log('');
+        await log(`${formatAligned('🔄', 'Re-fetching:', 'Pulling initialized repository...')}`);
+        // Wait for GitHub to process the new file
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        // Re-fetch the origin to get the new commit
+        const fetchResult = await $({ cwd: tempDir })`git fetch origin`;
+        if (fetchResult.code !== 0) {
+          await log(`${formatAligned('❌', 'Fetch failed:', 'Could not fetch after initialization')}`, { level: 'error' });
+          throw new Error('Failed to fetch after empty repository initialization');
+        }
+
+        // Determine default branch name from the remote
+        const remoteHeadResult = await $({ cwd: tempDir })`git remote show origin`;
+        let remoteBranch = 'main'; // default fallback
+        if (remoteHeadResult.code === 0) {
+          const remoteOutput = remoteHeadResult.stdout.toString();
+          const headMatch = remoteOutput.match(/HEAD branch:\s*(\S+)/);
+          if (headMatch) {
+            remoteBranch = headMatch[1];
+          }
+        }
+
+        // Checkout the remote branch locally
+        const checkoutResult = await $({ cwd: tempDir })`git checkout -b ${remoteBranch} origin/${remoteBranch}`;
+        if (checkoutResult.code !== 0) {
+          // Try alternative: maybe the branch already exists locally somehow
+          const altResult = await $({ cwd: tempDir })`git checkout ${remoteBranch}`;
+          if (altResult.code !== 0) {
+            await log(`${formatAligned('❌', 'Checkout failed:', `Could not checkout ${remoteBranch} after initialization`)}`, { level: 'error' });
+            throw new Error('Failed to checkout branch after empty repository initialization');
+          }
+        }
+
+        defaultBranch = remoteBranch;
+        await log(`${formatAligned('✅', 'Repository initialized:', `Now on branch ${defaultBranch}`)}`);
+        await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
+      } else {
+        // Auto-init failed - provide helpful message with --auto-init-repository context
+        await log('');
+        await log(`${formatAligned('❌', 'AUTO-INIT FAILED', '')}`, { level: 'error' });
+        await log('');
+        await log('  🔍 What happened:');
+        await log(`     Repository ${owner}/${repo} is empty (no commits).`);
+        await log('     --auto-init-repository was enabled but initialization failed.');
+        await log('     You may not have write access to create files in the repository.');
+        await log('');
+        await log('  💡 How to fix:');
+        await log('     Option 1: Ask repository owner to add initial content');
+        await log('              Even a simple README.md file would allow branch creation');
+        await log('');
+        await log(`     Option 2: Manually initialize: gh api repos/${owner}/${repo}/contents/README.md \\`);
+        await log('                --method PUT --field message="Initialize repository" \\');
+        await log('                --field content="$(echo "# repo" | base64)"');
+        await log('');
+
+        // Post a comment on the issue informing about the empty repository
+        await tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ });
+
+        throw new Error('Empty repository auto-initialization failed');
+      }
+    } else if (isEmptyRepo) {
+      // Empty repo detected but --auto-init-repository is not enabled
+      await log('');
+      await log(`${formatAligned('❌', 'EMPTY REPOSITORY DETECTED', '')}`, { level: 'error' });
+      await log('');
+      await log('  🔍 What happened:');
+      await log(`     The repository${owner && repo ? ` ${owner}/${repo}` : ''} is empty (no commits).`);
+      await log('     Cannot create branches or pull requests on an empty repository.');
+      await log('');
+      await log('  💡 How to fix:');
+      await log('     Option 1: Use --auto-init-repository flag to automatically create a README.md');
+      await log(`              solve <issue-url> --auto-init-repository`);
+      await log('');
+      await log('     Option 2: Ask repository owner to add initial content');
+      await log('              Even a simple README.md file would allow branch creation');
+      await log('');
+
+      // Post a comment on the issue informing about the empty repository
+      await tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ });
+
+      throw new Error('Empty repository detected - use --auto-init-repository to initialize');
+    } else {
+      // Not an empty repo, some other issue with branch detection
+      await log('');
+      await log(`${formatAligned('❌', 'DEFAULT BRANCH DETECTION FAILED', '')}`, { level: 'error' });
+      await log('');
+      await log('  🔍 What happened:');
+      await log("     Unable to determine the repository's default branch.");
+      await log('');
+      await log('  💡 This might mean:');
+      await log('     • Unusual repository configuration');
+      await log('     • Git command issues');
+      await log('');
+      await log('  🔧 How to fix:');
+      await log('     1. Check repository status');
+      await log(`     2. Verify locally: cd ${tempDir} && git branch`);
+      await log(`     3. Check remote: cd ${tempDir} && git branch -r`);
+      await log('');
+      throw new Error('Default branch detection failed');
+    }
+  } else {
+    await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
   }
-  await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
 
   // Ensure we're on a clean default branch
   const statusResult = await $({ cwd: tempDir })`git status --porcelain`;
@@ -106,3 +207,79 @@ export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned
 
   return defaultBranch;
 }
+
+/**
+ * Try to post a comment on the issue informing the user about the empty repository.
+ * This is a non-critical operation - errors are silently ignored.
+ * When --auto-init-repository succeeds, no comment is posted (no action needed from the user).
+ */
+async function tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ }) {
+  if (!issueUrl) return;
+
+  try {
+    const issueMatch = issueUrl.match(/\/issues\/(\d+)/);
+    if (!issueMatch) return;
+
+    const issueNumber = issueMatch[1];
+    await log(`${formatAligned('💬', 'Creating comment:', 'Informing about empty repository...')}`);
+
+    const commentBody = `## ⚠️ Repository Initialization Required
+
+Hello! I attempted to work on this issue, but encountered a problem:
+
+**Issue**: The repository is empty (no commits) and branches cannot be created.
+**Reason**: Git cannot create branches in a repository with no commits.
+
+### 🔧 How to resolve:
+
+**Option 1: Use \`--auto-init-repository\` flag**
+Re-run the solver with the \`--auto-init-repository\` flag to automatically create a simple README.md:
+\`\`\`
+solve ${issueUrl} --auto-init-repository
+\`\`\`
+
+**Option 2: Initialize the repository yourself**
+Please add initial content to the repository. Even a simple README.md (even if it is empty or contains just the title) file would make it possible to create branches and work on this issue.
+
+Once the repository contains at least one commit with any file, I'll be able to proceed with solving this issue.
+
+Thank you!`;
+
+    const commentResult = await $`gh issue comment ${issueNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+    if (commentResult.code === 0) {
+      await log(`${formatAligned('✅', 'Comment created:', `Posted to issue #${issueNumber}`)}`);
+    } else {
+      await log(`${formatAligned('⚠️', 'Note:', 'Could not post comment to issue (this is not critical)')}`);
+    }
+  } catch {
+    // Silently ignore comment creation errors - not critical to the process
+    await log(`${formatAligned('⚠️', 'Note:', 'Could not post comment to issue (this is not critical)')}`);
+  }
+}
+
+/**
+ * Detect if a cloned repository is empty (has no commits).
+ * An empty repository has no branches and no commits.
+ */
+async function detectEmptyRepository(tempDir, $) {
+  // Check if there are any commits in the repository
+  const logResult = await $({ cwd: tempDir })`git rev-parse HEAD 2>&1`;
+  if (logResult.code !== 0) {
+    // git rev-parse HEAD fails when there are no commits
+    const output = (logResult.stdout || logResult.stderr || '').toString();
+    if (output.includes('unknown revision') || output.includes('bad default revision') || output.includes('does not have any commits')) {
+      return true;
+    }
+  }
+
+  // Also check if there are any remote branches
+  const remoteBranchResult = await $({ cwd: tempDir })`git branch -r`;
+  if (remoteBranchResult.code === 0) {
+    const branches = remoteBranchResult.stdout.toString().trim();
+    if (!branches) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/solve.repository.lib.mjs

@@ -317,8 +317,9 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
 };
 
 // Try to initialize an empty repository by creating a simple README.md
-// This makes the repository forkable
-const tryInitializeEmptyRepository = async (owner, repo) => {
+// This makes the repository forkable and allows branch creation
+// Exported for use in solve.repo-setup.lib.mjs (direct access path for empty repos)
+export const tryInitializeEmptyRepository = async (owner, repo) => {
   try {
     await log(`${formatAligned('🔧', 'Auto-fix:', 'Attempting to initialize empty repository...')}`);
 

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) {