@link-assistant/hive-mind 1.34.8 → 1.35.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @link-assistant/hive-mind
 
+## 1.35.1
+
+### Patch Changes
+
+- Fix misleading "Retry after: 0s" message in /limits command when Claude Usage API returns 429. Now shows "Try again later." for zero/missing retry-after values, or proper reset time format (e.g., "Resets in 5m (Mar 19, 8:00pm UTC)") for meaningful values. Also caches 429 errors to prevent repeated requests to rate-limited endpoint, and adds full request/response verbose logging for debugging.
+
+  improve Solution Draft Log comment formatting for better readability (issue #1448)
+
+## 1.35.0
+
+### Minor Changes
+
+- f3de781: Add handlers for agent task lifecycle events (task_started, task_progress, task_notification) and rate_limit_event in interactive mode, reducing PR comment noise by ~30%
+
 ## 1.34.8
 
 ### Patch Changes

package/package.json

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

package/src/github.lib.mjs

@@ -22,7 +22,7 @@ const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) =
   const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
   const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
   if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
-  let costInfo = '\n\n💰 **Cost estimation:**';
+  let costInfo = '\n\n### 💰 **Cost estimation:**';
   if (pricingInfo?.modelName) {
     costInfo += `\n- Model: ${pricingInfo.modelName}`;
     if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
@@ -557,7 +557,7 @@ ${logContent}
       logComment = `## ⚠️ Solution Draft Finished with Errors
 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.
+> **Note**: The session encountered errors during execution, but some work may have been completed. Please review the changes carefully.
 
 <details>
 <summary>Click to expand solution draft log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -714,8 +714,8 @@ ${resumeCommand}
 
             logUploadComment += `${modelInfoString}
 
-📎 **Execution log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete execution log](${logUrl})
+### 📎 **Execution log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+- [View complete execution log](${logUrl})
 
 ---
 *This session was interrupted due to usage limits. You can resume once the limit resets.*`;
@@ -726,8 +726,10 @@ 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})
+
+### 📎 **Failure log uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+- [View complete failure log](${logUrl})
+
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           } else if (errorDuringExecution) {
@@ -736,10 +738,11 @@ ${errorMessage}
             logUploadComment = `## ⚠️ Solution Draft Finished with Errors
 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.
+> **Note**: The session encountered errors during execution, but some work may have been completed. Please review the changes carefully.
+
+### 📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+- [View complete solution draft log](${logUrl})
 
-📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
-🔗 [View complete solution draft log](${logUrl})
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           } else {
@@ -761,8 +764,10 @@ This log file contains the complete execution trace of the AI ${targetType === '
             }
             logUploadComment = `## ${title}
 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})
+${sessionNote}
+### 📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+- [View complete solution draft log](${logUrl})
+
 ---
 *Now working session is ended, feel free to review and add any feedback on the solution draft.*`;
           }

package/src/interactive-mode.lib.mjs

@@ -7,10 +7,14 @@
  *
  * Supported JSON event types:
  * - system.init: Session initialization
+ * - system.task_started: Agent subtask started (Issue #1450)
+ * - system.task_progress: Agent subtask progress update (Issue #1450)
+ * - system.task_notification: Agent subtask completed/failed (Issue #1450)
  * - assistant (text): AI text responses
  * - assistant (tool_use): Tool invocations
  * - user (tool_result): Tool execution results
  * - result: Session completion
+ * - rate_limit_event: Rate limit info (silently logged, Issue #1450)
  * - unrecognized: Any unknown event types
  *
  * Features:
@@ -213,6 +217,7 @@ const getToolIcon = toolName => {
     WebSearch: '🔍',
     TodoWrite: '📋',
     Task: '🎯',
+    Agent: '🤖',
     NotebookEdit: '📓',
     default: '🔧',
   };
@@ -253,6 +258,9 @@ export const createInteractiveHandler = options => {
     // Simple map of tool_use_id -> { toolName, toolIcon } for standalone tool results
     // This is preserved even after pendingToolCalls entry is deleted
     toolUseRegistry: new Map(),
+    // Track active agent tasks for progress update deduplication
+    // Map of task_id -> { commentId, toolUseId, description, commentIdPromise, resolveCommentId }
+    pendingTasks: new Map(),
   };
 
   /**
@@ -809,6 +817,232 @@ ${createRawJsonSection(data)}`;
     }
   };
 
+  /**
+   * Handle system.task_started event (Agent subtask started)
+   * Creates a progress comment that will be updated by task_progress events
+   * @param {Object} data - Event data
+   */
+  const handleTaskStarted = async data => {
+    const taskId = data.task_id;
+    const toolUseId = data.tool_use_id || '';
+    const description = data.description || 'Agent task';
+    const taskType = data.task_type || 'unknown';
+
+    // Create a promise for the comment ID (handles queued comments)
+    let resolveCommentId;
+    const commentIdPromise = new Promise(resolve => {
+      resolveCommentId = resolve;
+    });
+
+    // Build prompt preview if available
+    let promptSection = '';
+    if (data.prompt) {
+      const truncatedPrompt = truncateMiddle(data.prompt, { maxLines: 15, keepStart: 6, keepEnd: 6 });
+      promptSection = '\n\n' + createCollapsible('📝 Task prompt', truncatedPrompt);
+    }
+
+    const comment = `## 🤖 Agent task: ${escapeMarkdown(description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId || 'unknown'}\` |
+| **Type** | \`${taskType}\` |
+| **Status** | ⏳ Running... |
+${promptSection}
+
+---
+
+${createRawJsonSection(data)}`;
+
+    // Track this task BEFORE posting
+    state.pendingTasks.set(taskId, {
+      commentId: null,
+      commentIdPromise,
+      resolveCommentId,
+      toolUseId,
+      description,
+      lastProgressDescription: description,
+      progressCount: 0,
+      allEvents: [data],
+    });
+
+    const commentId = await postComment(comment, null);
+
+    if (commentId) {
+      const pendingTask = state.pendingTasks.get(taskId);
+      if (pendingTask) {
+        pendingTask.commentId = commentId;
+        resolveCommentId(commentId);
+      }
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Agent task started - ${description} (task: ${taskId})`, { verbose: true });
+    }
+  };
+
+  /**
+   * Handle system.task_progress event (Agent subtask progress update)
+   * Updates the existing task comment instead of creating a new one
+   * @param {Object} data - Event data
+   */
+  const handleTaskProgress = async data => {
+    const taskId = data.task_id;
+    const description = data.description || 'Working...';
+    const lastToolName = data.last_tool_name || '';
+    const usage = data.usage || {};
+
+    const pendingTask = state.pendingTasks.get(taskId);
+
+    if (pendingTask) {
+      pendingTask.progressCount++;
+      pendingTask.lastProgressDescription = description;
+      pendingTask.allEvents.push(data);
+
+      let commentId = pendingTask.commentId;
+
+      // Wait for comment ID if not yet available
+      if (!commentId && pendingTask.commentIdPromise) {
+        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 15000));
+        commentId = await Promise.race([pendingTask.commentIdPromise, timeoutPromise]);
+      }
+
+      if (commentId) {
+        // Build progress steps list from accumulated events
+        const progressSteps = pendingTask.allEvents
+          .filter(e => e.subtype === 'task_progress')
+          .map(e => {
+            const toolIcon = e.last_tool_name ? getToolIcon(e.last_tool_name) : '🔄';
+            return `- ${toolIcon} ${e.description || 'Working...'}`;
+          })
+          .join('\n');
+
+        const durationText = usage.duration_ms ? formatDuration(usage.duration_ms) : '';
+        const toolUsesText = usage.tool_uses ? `${usage.tool_uses} tool calls` : '';
+        const statsText = [durationText, toolUsesText].filter(Boolean).join(' | ');
+
+        const updatedComment = `## 🤖 Agent task: ${escapeMarkdown(pendingTask.description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId}\` |
+| **Status** | ⏳ Running... |
+| **Progress** | ${pendingTask.progressCount} updates |
+${statsText ? `| **Stats** | ${statsText} |\n` : ''}
+${createCollapsible(`📋 Progress steps (${pendingTask.progressCount})`, progressSteps, true)}
+
+---
+
+${createRawJsonSection(pendingTask.allEvents.slice(-3))}`;
+
+        await editComment(commentId, updatedComment);
+      }
+    } else {
+      // No pending task found - this can happen if task_started was missed
+      // Just log it silently rather than creating an unrecognized comment
+      if (verbose) {
+        await log(`🤖 Interactive mode: Task progress for unknown task ${taskId}: ${description}`, { verbose: true });
+      }
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Task progress - ${description} (task: ${taskId}, tool: ${lastToolName})`, { verbose: true });
+    }
+  };
+
+  /**
+   * Handle system.task_notification event (Agent subtask completed/failed)
+   * Updates the existing task comment with final status
+   * @param {Object} data - Event data
+   */
+  const handleTaskNotification = async data => {
+    const taskId = data.task_id;
+    const status = data.status || 'unknown';
+    const summary = data.summary || data.description || 'Task finished';
+    const usage = data.usage || {};
+    const isCompleted = status === 'completed';
+    const statusIcon = isCompleted ? '✅' : '❌';
+    const statusText = isCompleted ? 'Completed' : status.charAt(0).toUpperCase() + status.slice(1);
+
+    const pendingTask = state.pendingTasks.get(taskId);
+
+    if (pendingTask) {
+      pendingTask.allEvents.push(data);
+
+      let commentId = pendingTask.commentId;
+
+      // Wait for comment ID if not yet available
+      if (!commentId && pendingTask.commentIdPromise) {
+        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 15000));
+        commentId = await Promise.race([pendingTask.commentIdPromise, timeoutPromise]);
+      }
+
+      if (commentId) {
+        // Build final progress steps list
+        const progressSteps = pendingTask.allEvents
+          .filter(e => e.subtype === 'task_progress')
+          .map(e => {
+            const toolIcon = e.last_tool_name ? getToolIcon(e.last_tool_name) : '🔄';
+            return `- ${toolIcon} ${e.description || 'Working...'}`;
+          })
+          .join('\n');
+
+        const durationText = usage.duration_ms ? formatDuration(usage.duration_ms) : '';
+        const toolUsesText = usage.tool_uses ? `${usage.tool_uses} tool calls` : '';
+        const tokensText = usage.total_tokens ? `${usage.total_tokens.toLocaleString()} tokens` : '';
+        const statsText = [durationText, toolUsesText, tokensText].filter(Boolean).join(' | ');
+
+        const updatedComment = `## 🤖 Agent task: ${escapeMarkdown(pendingTask.description)}
+
+| Property | Value |
+|----------|-------|
+| **Task ID** | \`${taskId}\` |
+| **Status** | ${statusIcon} ${statusText} |
+| **Summary** | ${escapeMarkdown(summary)} |
+${statsText ? `| **Stats** | ${statsText} |\n` : ''}
+${progressSteps ? createCollapsible(`📋 Progress steps (${pendingTask.progressCount})`, progressSteps) : ''}
+
+---
+
+${createRawJsonSection([pendingTask.allEvents[0], data])}`;
+
+        await editComment(commentId, updatedComment);
+      }
+
+      // Clean up
+      state.pendingTasks.delete(taskId);
+    } else {
+      // Post as standalone if no pending task
+      const comment = `## 🤖 Agent task ${statusIcon} ${statusText}
+
+**Summary:** ${escapeMarkdown(summary)}
+
+---
+
+${createRawJsonSection(data)}`;
+
+      await postComment(comment);
+    }
+
+    if (verbose) {
+      await log(`🤖 Interactive mode: Task ${statusText.toLowerCase()} - ${summary} (task: ${taskId})`, {
+        verbose: true,
+      });
+    }
+  };
+
+  /**
+   * Handle rate_limit_event (silently logged, no comment created)
+   * @param {Object} data - Event data
+   */
+  const handleRateLimitEvent = async data => {
+    // Rate limit events are internal/informational - log but don't create a PR comment
+    if (verbose) {
+      const info = data.rate_limit_info || {};
+      await log(`⏱️ Interactive mode: Rate limit event - status: ${info.status || 'unknown'}, type: ${info.rateLimitType || 'unknown'}`, { verbose: true });
+    }
+  };
+
   /**
    * Handle unrecognized event types
    * @param {Object} data - Event data
@@ -851,12 +1085,22 @@ ${createRawJsonSection(data)}`;
       case 'system':
         if (data.subtype === 'init') {
           await handleSystemInit(data);
+        } else if (data.subtype === 'task_started') {
+          await handleTaskStarted(data);
+        } else if (data.subtype === 'task_progress') {
+          await handleTaskProgress(data);
+        } else if (data.subtype === 'task_notification') {
+          await handleTaskNotification(data);
         } else {
           // Unknown system subtype
           await handleUnrecognized(data);
         }
         break;
 
+      case 'rate_limit_event':
+        await handleRateLimitEvent(data);
+        break;
+
       case 'assistant':
         if (data.message && data.message.content) {
           const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
@@ -923,6 +1167,10 @@ ${createRawJsonSection(data)}`;
       handleToolUse,
       handleToolResult,
       handleResult,
+      handleTaskStarted,
+      handleTaskProgress,
+      handleTaskNotification,
+      handleRateLimitEvent,
       handleUnrecognized,
     },
   };

package/src/limits.lib.mjs

@@ -61,6 +61,63 @@ async function readCredentials(credentialsPath = DEFAULT_CREDENTIALS_PATH, verbo
   }
 }
 
+/**
+ * Format a retry-after value into a user-friendly message.
+ * The retry-after header can be either a number of seconds or an HTTP-date.
+ * Handles edge cases like 0, missing, or negative values gracefully.
+ *
+ * @param {string|null} retryAfter - Value of the retry-after header
+ * @returns {string} Formatted message part (e.g., " Resets in 2m 30s (Mar 19, 8:00pm UTC)" or " Try again later.")
+ * @see https://github.com/link-assistant/hive-mind/issues/1446
+ */
+export function formatRetryAfterMessage(retryAfter) {
+  if (retryAfter === null || retryAfter === undefined) {
+    return ' Try again later.';
+  }
+
+  // Try to parse as number of seconds first
+  const seconds = Number(retryAfter);
+  if (!Number.isNaN(seconds) && seconds > 0) {
+    // Calculate reset time from now + seconds
+    const resetAt = dayjs().add(seconds, 'second').utc();
+    const resetTimeStr = resetAt.format('MMM D, h:mma');
+
+    // Format relative time
+    const totalMinutes = Math.floor(seconds / 60);
+    const remainingSeconds = Math.round(seconds % 60);
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+
+    let relativeStr;
+    if (hours > 0) {
+      relativeStr = `${hours}h ${minutes}m`;
+    } else if (minutes > 0) {
+      relativeStr = remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    } else {
+      relativeStr = `${remainingSeconds}s`;
+    }
+
+    return ` Resets in ${relativeStr} (${resetTimeStr} UTC)`;
+  }
+
+  // Try to parse as HTTP-date (e.g., "Wed, 21 Oct 2015 07:28:00 GMT")
+  const retryDate = dayjs(retryAfter);
+  if (retryDate.isValid()) {
+    const diffMs = retryDate.diff(dayjs());
+    if (diffMs > 0) {
+      const totalMinutes = Math.floor(diffMs / (1000 * 60));
+      const hours = Math.floor(totalMinutes / 60);
+      const minutes = totalMinutes % 60;
+      const relativeStr = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+      const resetTimeStr = retryDate.utc().format('MMM D, h:mma');
+      return ` Resets in ${relativeStr} (${resetTimeStr} UTC)`;
+    }
+  }
+
+  // Fallback for 0, negative, or unparseable values - don't show misleading info
+  return ' Try again later.';
+}
+
 /**
  * Format an ISO date string to a human-readable reset time using dayjs
  *
@@ -534,31 +591,47 @@ export async function getClaudeUsageLimits(verbose = false, credentialsPath = DE
       };
     }
 
+    const requestHeaders = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'User-Agent': 'claude-code/2.0.55',
+      Authorization: `Bearer ${accessToken}`,
+      'anthropic-beta': 'oauth-2025-04-20',
+    };
+
     if (verbose) {
       console.log('[VERBOSE] /limits fetching usage from API...');
+      console.log(`[VERBOSE] /limits API request: GET ${USAGE_API_ENDPOINT}`);
+      // Log request headers with sanitized Authorization (show only last 8 chars)
+      const sanitizedHeaders = { ...requestHeaders };
+      if (sanitizedHeaders.Authorization) {
+        const token = sanitizedHeaders.Authorization;
+        sanitizedHeaders.Authorization = `Bearer ...${token.slice(-8)}`;
+      }
+      console.log('[VERBOSE] /limits API request headers:', JSON.stringify(sanitizedHeaders, null, 2));
     }
 
     // Call the Anthropic OAuth usage API
     const response = await fetch(USAGE_API_ENDPOINT, {
       method: 'GET',
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-        'User-Agent': 'claude-code/2.0.55',
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-beta': 'oauth-2025-04-20',
-      },
+      headers: requestHeaders,
     });
 
-    // Log HTTP response status for debugging (always, not just on error)
+    // Log HTTP response status and headers for debugging (always in verbose mode, not just on error)
     if (verbose) {
       console.log(`[VERBOSE] /limits API HTTP status: ${response.status} ${response.statusText}`);
+      // Log all response headers for debugging
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      console.log('[VERBOSE] /limits API response headers:', JSON.stringify(responseHeaders, null, 2));
     }
 
     if (!response.ok) {
       const errorText = await response.text();
       if (verbose) {
-        console.error('[VERBOSE] /limits API error:', response.status, errorText);
+        console.error('[VERBOSE] /limits API error body:', errorText);
       }
 
       // Check for specific error conditions
@@ -574,7 +647,7 @@ export async function getClaudeUsageLimits(verbose = false, credentialsPath = DE
         const retryAfter = response.headers.get('retry-after');
         return {
           success: false,
-          error: `Rate limited by Claude Usage API. ${retryAfter ? `Retry after: ${retryAfter}s` : 'Try again later.'}`,
+          error: `Claude Usage API access has reached rate limit.${formatRetryAfterMessage(retryAfter)}`,
         };
       }
 
@@ -587,7 +660,7 @@ export async function getClaudeUsageLimits(verbose = false, credentialsPath = DE
     const data = await response.json();
 
     if (verbose) {
-      console.log('[VERBOSE] /limits API response:', JSON.stringify(data, null, 2));
+      console.log('[VERBOSE] /limits API response body:', JSON.stringify(data, null, 2));
     }
 
     // Parse the API response
@@ -971,9 +1044,23 @@ export async function getCachedClaudeLimits(verbose = false) {
     if (verbose) console.log('[VERBOSE] /limits-cache: Using cached Claude limits (TTL: ' + Math.round(CACHE_TTL.USAGE_API / 60000) + ' minutes)');
     return cached;
   }
+  // Also check if we have a cached rate-limit error to avoid hammering a 429'd endpoint
+  const cachedError = cache.get('claude-rate-limited', CACHE_TTL.USAGE_API);
+  if (cachedError) {
+    if (verbose) console.log('[VERBOSE] /limits-cache: Using cached rate-limit error (avoiding repeated 429 requests)');
+    return cachedError;
+  }
   if (verbose) console.log('[VERBOSE] /limits-cache: Cache miss for Claude limits, fetching from API...');
   const result = await getClaudeUsageLimits(verbose);
-  if (result.success) cache.set('claude', result, CACHE_TTL.USAGE_API);
+  if (result.success) {
+    cache.set('claude', result, CACHE_TTL.USAGE_API);
+  } else if (result.error && result.error.includes('Rate limited')) {
+    // Cache rate-limit errors to prevent hammering the API
+    // Use the same 20-minute TTL as successful responses
+    // See: https://github.com/link-assistant/hive-mind/issues/1446
+    cache.set('claude-rate-limited', result, CACHE_TTL.USAGE_API);
+    if (verbose) console.log('[VERBOSE] /limits-cache: Cached rate-limit error for ' + Math.round(CACHE_TTL.USAGE_API / 60000) + ' minutes');
+  }
   return result;
 }
 
@@ -1040,6 +1127,7 @@ export default {
   getProgressBar,
   calculateTimePassedPercentage,
   formatUsageMessage,
+  formatRetryAfterMessage,
   // Threshold constants for progress bar visualization
   DISPLAY_THRESHOLDS,
   // Cache management

package/src/model-info.lib.mjs

@@ -179,7 +179,7 @@ export const buildModelInfoString = ({ requestedModel = null, tool = null, prici
 
   if (!hasRequested && !hasModelsUsed && !hasModelInfo && !hasPricingModel) return '';
 
-  let info = '\n\n🤖 **Models used:**';
+  let info = '\n\n### 🤖 **Models used:**';
 
   // Display tool name
   if (tool) {
@@ -201,26 +201,26 @@ export const buildModelInfoString = ({ requestedModel = null, tool = null, prici
 
     // Build main model line
     const mainModelName = mainModelMeta?.name || mainModelId;
-    const mainModelProvider = mainModelMeta?.provider || null;
-    const mainModelKnowledge = mainModelMeta?.knowledge || null;
+
+    // Use "Model" label when only one model, "Main model" when multiple
+    const modelLabel = supportingEntries.length > 0 ? 'Main model' : 'Model';
 
     if (mainMatches) {
-      info += `\n- **Main model: ${mainModelName}** (ID: \`${mainModelId}\`${mainModelProvider ? `, ${mainModelProvider}` : ''}${mainModelKnowledge ? `, cutoff: ${mainModelKnowledge}` : ''})`;
+      info += `\n- **${modelLabel}: ${mainModelName}** (\`${mainModelId}\`)`;
     } else {
       // Main model doesn't match requested - show warning
-      info += `\n- **Main model: ${mainModelName}** (ID: \`${mainModelId}\`${mainModelProvider ? `, ${mainModelProvider}` : ''}${mainModelKnowledge ? `, cutoff: ${mainModelKnowledge}` : ''})`;
+      info += `\n- **${modelLabel}: ${mainModelName}** (\`${mainModelId}\`)`;
       if (hasRequested) {
         info += `\n- ⚠️ **Warning**: Main model \`${mainModelId}\` does not match requested model \`${requestedModel}\``;
       }
     }
 
-    // Display supporting models
+    // Display additional models
     if (supportingEntries.length > 0) {
-      info += '\n- Supporting models:';
+      info += '\n- **Additional 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}` : ''})`;
+        info += `\n  *  **${name}** (\`${entry.modelId}\`)`;
       }
     }
   } else if (hasModelInfo) {