@link-assistant/hive-mind 1.11.5 → 1.12.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @link-assistant/hive-mind
 
+## 1.12.0
+
+### Minor Changes
+
+- 8393f99: Improve auto-resume-on-limit-reset functionality
+  - Add 5-minute buffer after limit reset to account for server time differences (configurable via HIVE_MIND_LIMIT_RESET_BUFFER_MS)
+  - Add --auto-restart-on-limit-reset option for fresh start without previous session context
+  - Remove CLI commands from GitHub comments when auto-resume is active (less confusing for users)
+  - Differentiate work session comments: "Auto Resume (on limit reset)" vs "Auto Restart (on limit reset)"
+  - Differentiate solution draft log comments based on session type
+  - Improve reset time formatting with relative time + UTC (e.g., "in 1h 23m (Jan 15, 7:00 AM UTC)")
+
+## 1.11.6
+
+### Patch Changes
+
+- 5eef9e4: Skip Claude API limits for --tool agent tasks in queue
+  - Agent tools (Grok Code, OpenCode Zen) use different backends with their own rate limits
+  - Add tool parameter to canStartCommand() and checkApiLimits() functions
+  - Skip Claude-specific limits (5-hour session, weekly) when tool is 'agent'
+  - Consumer loop now passes next queue item's tool to limit checks
+  - Add 7 new tests for tool-specific limit handling
+  - Add case study documentation
+
+  Fixes #1159
+
 ## 1.11.5
 
 ### Patch Changes

package/package.json

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

package/src/config.lib.mjs

@@ -56,6 +56,14 @@ export const autoContinue = {
   ageThresholdHours: parseIntWithDefault('HIVE_MIND_AUTO_CONTINUE_AGE_HOURS', 24),
 };
 
+// Auto-resume on limit reset configurations
+// See: https://github.com/link-assistant/hive-mind/issues/1152
+export const limitReset = {
+  // Buffer time to wait after limit reset (in milliseconds)
+  // Default: 5 minutes - accounts for server time differences
+  bufferMs: parseIntWithDefault('HIVE_MIND_LIMIT_RESET_BUFFER_MS', 5 * 60 * 1000),
+};
+
 // GitHub API limits
 export const githubLimits = {
   commentMaxSize: parseIntWithDefault('HIVE_MIND_GITHUB_COMMENT_MAX_SIZE', 65536),

package/src/github.lib.mjs

@@ -377,6 +377,13 @@ export async function attachLogToGitHub(options) {
     limitResetTime = null,
     toolName = 'AI tool',
     resumeCommand = null,
+    // Whether auto-resume/auto-restart is enabled (determines if CLI commands should be shown)
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
+    isAutoResumeEnabled = false,
+    autoResumeMode = 'resume', // 'resume' or 'restart'
+    // Session type for differentiating solution draft log comments
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
+    sessionType = 'new', // 'new', 'resume', 'auto-resume', 'auto-restart'
     // New parameters for agent tool pricing support
     publicPricingEstimate = null,
     pricingInfo = null,
@@ -457,21 +464,35 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 
       logComment += '\n\n### 🔄 How to Continue\n';
 
-      if (limitResetTime) {
-        logComment += `Once the limit resets at **${limitResetTime}**, `;
+      // If auto-resume/auto-restart is enabled, show automatic continuation message instead of CLI commands
+      // See: https://github.com/link-assistant/hive-mind/issues/1152
+      if (isAutoResumeEnabled) {
+        const modeName = autoResumeMode === 'restart' ? 'restart' : 'resume';
+        const modeDescription = autoResumeMode === 'restart' ? 'The session will automatically restart (fresh start) when the limit resets.' : 'The session will automatically resume (with context preserved) when the limit resets.';
+
+        if (limitResetTime) {
+          logComment += `**Auto-${modeName} is enabled.** ${modeDescription}`;
+        } else {
+          logComment += `**Auto-${modeName} is enabled.** ${modeDescription}`;
+        }
       } else {
-        logComment += 'Once the limit resets, ';
-      }
+        // Manual resume mode - show CLI commands
+        if (limitResetTime) {
+          logComment += `Once the limit resets at **${limitResetTime}**, `;
+        } else {
+          logComment += 'Once the limit resets, ';
+        }
 
-      if (resumeCommand) {
-        logComment += `you can resume this session by running:
+        if (resumeCommand) {
+          logComment += `you can resume this session by running:
 \`\`\`bash
 ${resumeCommand}
 \`\`\``;
-      } else if (sessionId) {
-        logComment += `you can resume this session using session ID: \`${sessionId}\``;
-      } else {
-        logComment += 'you can retry the operation.';
+        } else if (sessionId) {
+          logComment += `you can resume this session using session ID: \`${sessionId}\``;
+        } else {
+          logComment += 'you can retry the operation.';
+        }
       }
 
       logComment += `
@@ -528,8 +549,22 @@ ${logContent}
     } else {
       // Success log format - use helper function for cost info
       const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
-      logComment = `## ${customTitle}
-This log file contains the complete execution trace of the AI ${targetType === 'pr' ? 'solution draft' : 'analysis'} process.${costInfo}
+      // Determine title based on session type
+      // See: https://github.com/link-assistant/hive-mind/issues/1152
+      let title = customTitle;
+      let sessionNote = '';
+      if (sessionType === 'auto-resume') {
+        title = '🔄 Draft log of auto resume (on limit reset)';
+        sessionNote = '\n\n**Note**: This session was automatically resumed after a usage limit reset, with the previous context preserved.';
+      } else if (sessionType === 'auto-restart') {
+        title = '🔄 Draft log of auto restart (on limit reset)';
+        sessionNote = '\n\n**Note**: This session was automatically restarted after a usage limit reset (fresh start).';
+      } else if (sessionType === 'resume') {
+        title = '🔄 Solution Draft Log (Resumed)';
+        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}
 
 <details>
 <summary>Click to expand solution draft log (${Math.round(logStats.size / 1024)}KB)</summary>
@@ -622,21 +657,31 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 
             logUploadComment += '\n\n### 🔄 How to Continue\n';
 
-            if (limitResetTime) {
-              logUploadComment += `Once the limit resets at **${limitResetTime}**, `;
-            } else {
-              logUploadComment += 'Once the limit resets, ';
-            }
+            // If auto-resume/auto-restart is enabled, show automatic continuation message instead of CLI commands
+            // See: https://github.com/link-assistant/hive-mind/issues/1152
+            if (isAutoResumeEnabled) {
+              const modeName = autoResumeMode === 'restart' ? 'restart' : 'resume';
+              const modeDescription = autoResumeMode === 'restart' ? 'The session will automatically restart (fresh start) when the limit resets.' : 'The session will automatically resume (with context preserved) when the limit resets.';
 
-            if (resumeCommand) {
-              logUploadComment += `you can resume this session by running:
+              logUploadComment += `**Auto-${modeName} is enabled.** ${modeDescription}`;
+            } else {
+              // Manual resume mode - show CLI commands
+              if (limitResetTime) {
+                logUploadComment += `Once the limit resets at **${limitResetTime}**, `;
+              } else {
+                logUploadComment += 'Once the limit resets, ';
+              }
+
+              if (resumeCommand) {
+                logUploadComment += `you can resume this session by running:
 \`\`\`bash
 ${resumeCommand}
 \`\`\``;
-            } else if (sessionId) {
-              logUploadComment += `you can resume this session using session ID: \`${sessionId}\``;
-            } else {
-              logUploadComment += 'you can retry the operation.';
+              } else if (sessionId) {
+                logUploadComment += `you can resume this session using session ID: \`${sessionId}\``;
+              } else {
+                logUploadComment += 'you can retry the operation.';
+              }
             }
 
             logUploadComment += `
@@ -672,9 +717,23 @@ This log file contains the complete execution trace of the AI ${targetType === '
           } else {
             // Success log format - use helper function for cost info
             const costInfo = buildCostInfoString(totalCostUSD, anthropicTotalCostUSD, pricingInfo);
-            logUploadComment = `## ${customTitle}
+            // Determine title based on session type
+            // See: https://github.com/link-assistant/hive-mind/issues/1152
+            let title = customTitle;
+            let sessionNote = '';
+            if (sessionType === 'auto-resume') {
+              title = '🔄 Draft log of auto resume (on limit reset)';
+              sessionNote = '\n**Note**: This session was automatically resumed after a usage limit reset, with the previous context preserved.\n';
+            } else if (sessionType === 'auto-restart') {
+              title = '🔄 Draft log of auto restart (on limit reset)';
+              sessionNote = '\n**Note**: This session was automatically restarted after a usage limit reset (fresh start).\n';
+            } else if (sessionType === 'resume') {
+              title = '🔄 Solution Draft Log (Resumed)';
+              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}
-📎 **Log file uploaded as ${uploadTypeLabel}${chunkInfo}** (${Math.round(logStats.size / 1024)}KB)
+${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/solve.auto-continue.lib.mjs

@@ -33,6 +33,11 @@ const { checkFileInBranch } = githubLib;
 // Import validation functions for time parsing
 const validation = await import('./solve.validation.lib.mjs');
 
+// Import usage limit formatting functions
+// See: https://github.com/link-assistant/hive-mind/issues/1152
+const usageLimitLib = await import('./usage-limit.lib.mjs');
+const { formatResetTimeWithRelative } = usageLimitLib;
+
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
@@ -42,7 +47,7 @@ const githubLinking = await import('./github-linking.lib.mjs');
 const { extractLinkedIssueNumber } = githubLinking;
 
 // Import configuration
-import { autoContinue } from './config.lib.mjs';
+import { autoContinue, limitReset } from './config.lib.mjs';
 
 const { calculateWaitTime } = validation;
 
@@ -67,13 +72,27 @@ const formatWaitTime = ms => {
 // Auto-continue function that waits until limit resets
 // tempDir parameter is required for passing --working-directory to the resumed session
 // (Claude Code sessions are stored per-working-directory, so resume must use same directory)
-export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs, tempDir = null) => {
+// isRestart parameter distinguishes between resume (maintains context) and restart (fresh start)
+// See: https://github.com/link-assistant/hive-mind/issues/1152
+export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs, tempDir = null, isRestart = false) => {
   try {
     const resetTime = global.limitResetTime;
-    const waitMs = calculateWaitTime(resetTime);
-
-    await log(`\n⏰ Waiting until ${resetTime} for limit to reset...`);
-    await log(`   Wait time: ${formatWaitTime(waitMs)}`);
+    const timezone = global.limitTimezone || null;
+    const baseWaitMs = calculateWaitTime(resetTime);
+
+    // Add buffer time after limit reset to account for server time differences
+    // Default: 5 minutes (configurable via HIVE_MIND_LIMIT_RESET_BUFFER_MS)
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
+    const bufferMs = limitReset.bufferMs;
+    const waitMs = baseWaitMs + bufferMs;
+    const bufferMinutes = Math.round(bufferMs / 60000);
+
+    // Format reset time with relative time and UTC for better user understanding
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
+    const formattedResetTime = formatResetTimeWithRelative(resetTime, timezone);
+
+    await log(`\n⏰ Waiting until ${formattedResetTime} + ${bufferMinutes} min buffer for limit to reset...`);
+    await log(`   Wait time: ${formatWaitTime(waitMs)} (includes ${bufferMinutes} min buffer for server time differences)`);
     await log(`   Current time: ${new Date().toLocaleTimeString()}`);
 
     // Show countdown every 30 minutes for long waits, every minute for short waits
@@ -83,7 +102,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     const countdownTimer = setInterval(async () => {
       remainingMs -= countdownInterval;
       if (remainingMs > 0) {
-        await log(`⏳ Time remaining: ${formatWaitTime(remainingMs)} until ${resetTime}`);
+        await log(`⏳ Time remaining: ${formatWaitTime(remainingMs)} until ${formattedResetTime}`);
       }
     }, countdownInterval);
 
@@ -91,25 +110,42 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     await new Promise(resolve => setTimeout(resolve, waitMs));
     clearInterval(countdownTimer);
 
-    await log('\n✅ Limit reset time reached! Resuming session...');
+    const actionType = isRestart ? 'Restarting' : 'Resuming';
+    await log(`\n✅ Limit reset time reached (+ ${bufferMinutes} min buffer)! ${actionType} session...`);
     await log(`   Current time: ${new Date().toLocaleTimeString()}`);
 
-    // Recursively call the solve script with --resume
-    // We need to reconstruct the command with appropriate flags
+    // Recursively call the solve script
+    // For resume: use --resume with session ID to maintain context
+    // For restart: don't use --resume to start fresh
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
     const childProcess = await import('child_process');
 
-    // Build the resume command
+    // Build the resume/restart command
     const resumeArgs = [
       process.argv[1], // solve.mjs path
       issueUrl,
-      '--resume',
-      sessionId,
     ];
 
-    // Preserve auto-resume flag
+    // Only include --resume if this is a true resume (not a restart)
+    if (!isRestart && sessionId) {
+      resumeArgs.push('--resume', sessionId);
+      await log(`🔄 Session will be RESUMED with session ID: ${sessionId}`);
+    } else {
+      await log(`🔄 Session will be RESTARTED (fresh start without previous context)`);
+    }
+
+    // Preserve auto-resume/auto-restart flag for subsequent limit hits
     if (argv.autoResumeOnLimitReset) {
       resumeArgs.push('--auto-resume-on-limit-reset');
     }
+    if (argv.autoRestartOnLimitReset) {
+      resumeArgs.push('--auto-restart-on-limit-reset');
+    }
+
+    // Pass session type for proper comment differentiation
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
+    const sessionType = isRestart ? 'auto-restart' : 'auto-resume';
+    resumeArgs.push('--session-type', sessionType);
 
     // Preserve other flags from original invocation
     if (argv.model !== 'sonnet') resumeArgs.push('--model', argv.model);
@@ -123,7 +159,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     if (tempDir) {
       resumeArgs.push('--working-directory', tempDir);
       await log(`📂 Using working directory for session continuity: ${tempDir}`);
-    } else {
+    } else if (!isRestart) {
       await log(`⚠️  Warning: No working directory specified - session resume may fail`);
       await log(`   Claude Code sessions are stored per-directory, consider using --working-directory`);
     }

package/src/solve.config.lib.mjs

@@ -160,9 +160,21 @@ export const createYargsConfig = yargsInstance => {
       })
       .option('auto-resume-on-limit-reset', {
         type: 'boolean',
-        description: 'Automatically resume when AI tool limit resets (calculates reset time and waits)',
+        description: 'Automatically resume when AI tool limit resets (maintains session context with --resume flag)',
         default: false,
       })
+      .option('auto-restart-on-limit-reset', {
+        type: 'boolean',
+        description: 'Automatically restart when AI tool limit resets (fresh start without --resume flag)',
+        default: false,
+      })
+      .option('session-type', {
+        type: 'string',
+        description: 'Internal: Session type for comment differentiation (new, resume, auto-resume, auto-restart)',
+        choices: ['new', 'resume', 'auto-resume', 'auto-restart'],
+        default: 'new',
+        hidden: true,
+      })
       .option('auto-resume-on-errors', {
         type: 'boolean',
         description: 'Automatically resume on network errors (503, etc.) with exponential backoff',

package/src/solve.mjs

@@ -85,7 +85,7 @@ 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 } = sessionLib;
+const { startWorkSession, endWorkSession, SESSION_TYPES } = sessionLib;
 const preparationLib = await import('./solve.preparation.lib.mjs');
 const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions } = preparationLib;
 
@@ -688,6 +688,16 @@ try {
   // This includes PR URL (if created) and comment info (if in continue mode)
 
   // Start work session using the new module
+  // Determine session type based on command line flags
+  // See: https://github.com/link-assistant/hive-mind/issues/1152
+  let sessionType = SESSION_TYPES.NEW;
+  if (argv.sessionType) {
+    // Session type was explicitly set (e.g., by auto-resume/auto-restart spawning a new process)
+    sessionType = argv.sessionType;
+  } else if (isContinueMode) {
+    // Continue mode is a manual resume via PR URL
+    sessionType = SESSION_TYPES.RESUME;
+  }
   await startWorkSession({
     isContinueMode,
     prNumber,
@@ -695,6 +705,7 @@ try {
     log,
     formatAligned,
     $,
+    sessionType,
   });
 
   // Prepare feedback and timestamps using the new module
@@ -910,21 +921,29 @@ try {
 
   // Handle limit reached scenario
   if (limitReached) {
+    // Check for both auto-resume (maintains context) and auto-restart (fresh start)
+    // See: https://github.com/link-assistant/hive-mind/issues/1152
     const shouldAutoResumeOnReset = argv.autoResumeOnLimitReset;
+    const shouldAutoRestartOnReset = argv.autoRestartOnLimitReset;
+    const shouldAutoContinueOnReset = shouldAutoResumeOnReset || shouldAutoRestartOnReset;
 
-    // If limit was reached but auto-resume-on-limit-reset is NOT enabled, fail immediately
-    if (!shouldAutoResumeOnReset) {
+    // If limit was reached but neither auto-resume nor auto-restart is enabled, fail immediately
+    if (!shouldAutoContinueOnReset) {
       await log('\n❌ USAGE LIMIT REACHED!');
       await log('   The AI tool has reached its usage limit.');
 
       // Always show manual resume command in console so users can resume after limit resets
       if (sessionId) {
         const resetTime = global.limitResetTime;
+        const timezone = global.limitTimezone || null;
         await log('');
         await log(`📁 Working directory: ${tempDir}`);
         await log(`📌 Session ID: ${sessionId}`);
         if (resetTime) {
-          await log(`⏰ Limit resets at: ${resetTime}`);
+          // Format reset time with relative time and UTC for better user understanding
+          // See: https://github.com/link-assistant/hive-mind/issues/1152
+          const formattedResetTime = formatResetTimeWithRelative(resetTime, timezone);
+          await log(`⏰ Limit resets at: ${formattedResetTime}`);
         }
         await log('');
         // Show claude resume command only for --tool claude (or default)
@@ -993,15 +1012,17 @@ try {
         }
       }
 
-      await safeExit(1, 'Usage limit reached - use --auto-resume-on-limit-reset to wait for reset');
+      await safeExit(1, 'Usage limit reached - use --auto-resume-on-limit-reset or --auto-restart-on-limit-reset to wait for reset');
     } else {
-      // auto-resume-on-limit-reset is enabled - attach logs and/or post waiting comment
+      // auto-resume-on-limit-reset or auto-restart-on-limit-reset is enabled - attach logs and/or post waiting comment
+      // Determine the mode type for comment formatting
+      const limitContinueMode = shouldAutoRestartOnReset ? 'restart' : 'resume';
       if (prNumber && global.limitResetTime) {
         // If --attach-logs is enabled, upload logs with usage limit details
         if (shouldAttachLogs && sessionId) {
           await log('\n📄 Attaching logs to Pull Request (auto-continue mode)...');
           try {
-            // Build Claude CLI resume command
+            // Build Claude CLI resume command (only for logging, not shown to users when auto-resume is enabled)
             const tool = argv.tool || 'claude';
             const resumeCommand = tool === 'claude' ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : null;
             const logUploadSuccess = await attachLogToGitHub({
@@ -1019,6 +1040,10 @@ try {
               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',
               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,
             });
 
             if (logUploadSuccess) {
@@ -1048,10 +1073,11 @@ try {
               return `${days}:${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
             };
 
-            // Build Claude CLI resume command
-            const tool = argv.tool || 'claude';
-            const resumeCmd = tool === 'claude' ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : null;
-            const waitingComment = `⏳ **Usage Limit Reached - Waiting to Continue**\n\nThe AI tool has reached its usage limit. Auto-resume is enabled with \`--auto-resume-on-limit-reset\`.\n\n**Reset time:** ${global.limitResetTime}\n**Wait time:** ${formatWaitTime(waitMs)} (days:hours:minutes:seconds)\n\nThe session will automatically resume when the limit resets.\n\nSession ID: \`${sessionId}\`${resumeCmd ? `\n\nTo resume manually:\n\`\`\`bash\n${resumeCmd}\n\`\`\`` : ''}`;
+            // For waiting comments, don't show CLI commands since auto-continue will handle it automatically
+            // See: https://github.com/link-assistant/hive-mind/issues/1152
+            const continueModeName = limitContinueMode === 'restart' ? 'auto-restart' : 'auto-resume';
+            const continueDescription = limitContinueMode === 'restart' ? 'The session will automatically restart (fresh start) when the limit resets.' : 'The session will automatically resume (with context preserved) when the limit resets.';
+            const waitingComment = `⏳ **Usage Limit Reached - Waiting to ${limitContinueMode === 'restart' ? 'Restart' : 'Continue'}**\n\nThe AI tool has reached its usage limit. ${continueModeName} is enabled.\n\n**Reset time:** ${global.limitResetTime}\n**Wait time:** ${formatWaitTime(waitMs)} (days:hours:minutes:seconds)\n\n${continueDescription}\n\nSession ID: \`${sessionId}\``;
 
             const commentResult = await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${waitingComment}`;
             if (commentResult.code === 0) {
@@ -1159,8 +1185,9 @@ try {
   // Pass shouldRestart to prevent early exit when auto-restart is needed
   // Include agent tool pricing data when available (publicPricingEstimate, pricingInfo)
   // Issue #1088: Pass errorDuringExecution for "Finished with errors" state
+  // Issue #1152: Pass sessionType for differentiated log comments
   // Issue #1154: Track if logs were already uploaded to prevent duplicates
-  const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution);
+  const verifyResult = await verifyResults(owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart, sessionId, tempDir, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo, errorDuringExecution, sessionType);
   const logsAlreadyUploaded = verifyResult?.logUploadSuccess || false;
 
   // Start watch mode if enabled OR if we need to handle uncommitted changes

package/src/solve.results.lib.mjs

@@ -416,7 +416,7 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
 };
 
 // Verify results by searching for new PRs and comments
-export const verifyResults = async (owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart = false, sessionId = null, tempDir = null, anthropicTotalCostUSD = null, publicPricingEstimate = null, pricingInfo = null, errorDuringExecution = false) => {
+export const verifyResults = async (owner, repo, branchName, issueNumber, prNumber, prUrl, referenceTime, argv, shouldAttachLogs, shouldRestart = false, sessionId = null, tempDir = null, anthropicTotalCostUSD = null, publicPricingEstimate = null, pricingInfo = null, errorDuringExecution = false, sessionType = 'new') => {
   await log('\n🔍 Searching for created pull requests or comments...');
 
   try {
@@ -549,6 +549,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
             pricingInfo,
             // Issue #1088: Pass errorDuringExecution for "Finished with errors" state
             errorDuringExecution,
+            // Issue #1152: Pass sessionType for differentiated log comments
+            sessionType,
           });
         }
 
@@ -615,6 +617,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
           pricingInfo,
           // Issue #1088: Pass errorDuringExecution for "Finished with errors" state
           errorDuringExecution,
+          // Issue #1152: Pass sessionType for differentiated log comments
+          sessionType,
         });
       }
 

package/src/solve.session.lib.mjs

@@ -3,7 +3,67 @@
  * Handles starting and ending work sessions, PR status changes, and session comments
  */
 
-export async function startWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $ }) {
+/**
+ * Session type definitions for different work session contexts
+ * See: https://github.com/link-assistant/hive-mind/issues/1152
+ */
+export const SESSION_TYPES = {
+  NEW: 'new', // New work session (first time working on PR)
+  RESUME: 'resume', // Manual resume (--resume flag)
+  AUTO_RESUME: 'auto-resume', // Auto resume on limit reset (maintains context)
+  AUTO_RESTART: 'auto-restart', // Auto restart on limit reset (fresh start)
+};
+
+/**
+ * Get session comment header and description based on session type
+ * @param {string} sessionType - One of SESSION_TYPES values
+ * @param {Date} timestamp - Session start timestamp
+ * @returns {Object} - { emoji, header, description }
+ */
+function getSessionCommentContent(sessionType, timestamp) {
+  const isoTime = timestamp.toISOString();
+
+  switch (sessionType) {
+    case SESSION_TYPES.RESUME:
+      return {
+        emoji: '🔄',
+        header: 'AI Work Session Resumed',
+        description: `Resuming automated work session at ${isoTime}\n\nThis session continues from a previous session using the \`--resume\` flag.\n\nThe PR has been converted to draft mode while work is in progress.\n\n_This comment marks the resumption of an AI work session. Please wait for the session to finish, and provide your feedback._`,
+      };
+    case SESSION_TYPES.AUTO_RESUME:
+      return {
+        emoji: '⏰',
+        header: 'Auto Resume (on limit reset)',
+        description: `Auto-resuming automated work session at ${isoTime}\n\nThis session automatically resumed after the usage limit reset, continuing with the previous context preserved.\n\nThe PR has been converted to draft mode while work is in progress.\n\n_This is an auto-resumed session. Please wait for the session to finish, and provide your feedback._`,
+      };
+    case SESSION_TYPES.AUTO_RESTART:
+      return {
+        emoji: '🔄',
+        header: 'Auto Restart (on limit reset)',
+        description: `Auto-restarting automated work session at ${isoTime}\n\nThis session automatically restarted after the usage limit reset (fresh start without previous context).\n\nThe PR has been converted to draft mode while work is in progress.\n\n_This is a fresh restart after limit reset. Please wait for the session to finish, and provide your feedback._`,
+      };
+    case SESSION_TYPES.NEW:
+    default:
+      return {
+        emoji: '🤖',
+        header: 'AI Work Session Started',
+        description: `Starting automated work session at ${isoTime}\n\nThe PR has been converted to draft mode while work is in progress.\n\n_This comment marks the beginning of an AI work session. Please wait for the session to finish, and provide your feedback._`,
+      };
+  }
+}
+
+/**
+ * Start a work session and post appropriate comment
+ * @param {Object} options - Session options
+ * @param {boolean} options.isContinueMode - Whether this is a continue mode session
+ * @param {number} options.prNumber - PR number
+ * @param {Object} options.argv - Command line arguments
+ * @param {Function} options.log - Logging function
+ * @param {Function} options.formatAligned - Alignment formatting function
+ * @param {Function} options.$ - Command execution function
+ * @param {string} [options.sessionType='new'] - One of SESSION_TYPES values
+ */
+export async function startWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $, sessionType = SESSION_TYPES.NEW }) {
   // Record work start time and convert PR to draft if in continue/watch mode
   const workStartTime = new Date();
   if (isContinueMode && prNumber && (argv.watch || argv.autoContinue)) {
@@ -37,12 +97,13 @@ export async function startWorkSession({ isContinueMode, prNumber, argv, log, fo
       await log('Warning: Could not check/convert PR draft status', { level: 'warning' });
     }
 
-    // Post a comment marking the start of work session
+    // Post a comment marking the start of work session with appropriate header based on session type
     try {
-      const startComment = `🤖 **AI Work Session Started**\n\nStarting automated work session at ${workStartTime.toISOString()}\n\nThe PR has been converted to draft mode while work is in progress.\n\n_This comment marks the beginning of an AI work session. Please wait working session to finish, and provide your feedback._`;
+      const { emoji, header, description } = getSessionCommentContent(sessionType, workStartTime);
+      const startComment = `${emoji} **${header}**\n\n${description}`;
       const commentResult = await $`gh pr comment ${prNumber} --repo ${global.owner}/${global.repo} --body ${startComment}`;
       if (commentResult.code === 0) {
-        await log(formatAligned('💬', 'Posted:', 'Work session start comment', 2));
+        await log(formatAligned('💬', 'Posted:', `${header} comment`, 2));
       }
     } catch (error) {
       const sentryLib = await import('./sentry.lib.mjs');

package/src/telegram-bot.mjs

@@ -1102,7 +1102,7 @@ bot.command(/^solve$/i, async ctx => {
     return;
   }
 
-  const check = await solveQueue.canStartCommand();
+  const check = await solveQueue.canStartCommand({ tool: solveTool }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
   if (check.canStart && queueStats.queued === 0) {
     const startingMessage = await ctx.reply(`🚀 Starting solve command...\n\n${infoBlock}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });