@link-assistant/hive-mind 1.71.1 → 1.72.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @link-assistant/hive-mind
 
+## 1.72.1
+
+### Patch Changes
+
+- 249646e: Fix: Move Claude CLI resume command from GitHub comment to logs
+
+  When usage limit is reached, the GitHub comment now only mentions the
+  `--auto-continue-on-limit-reset` option instead of showing bash commands.
+  This is more user-friendly for Telegram bot users who don't use CLI commands directly.
+
+  The Claude CLI resume command is still available in the logs (in the collapsed
+  block or gist link), allowing advanced users to resume manually if needed:
+
+  ```bash
+  (cd "/tmp/gh-issue-solver-..." && claude --resume session-id)
+  ```
+
+  Changes:
+  - GitHub comments now only suggest using the `--auto-continue-on-limit-reset` option
+  - Resume commands are kept in logs only (not in the visible comment)
+  - Session ID is still shown for reference
+
+  Fixes #942
+
+## 1.72.0
+
+### Minor Changes
+
+- fffdfbf: Add experimental `--resume-on-auto-restart` support for resuming Claude auto-restart sessions with a minimal uncommitted-change prompt.
+
 ## 1.71.1
 
 ### Patch Changes

package/package.json

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

package/src/claude.command-builder.lib.mjs

@@ -52,6 +52,43 @@ export const buildClaudeResumeCommand = ({ tempDir, sessionId, claudePath = 'cla
   return `(cd "${tempDir}" && ${claudePath} ${args})`;
 };
 
+/**
+ * Build the Claude CLI autonomous resume command
+ *
+ * This generates a fully autonomous command that includes all flags needed to run
+ * without user interaction. The user can copy-paste this command and it will
+ * continue the session autonomously.
+ *
+ * The command includes:
+ * - --resume <sessionId>: Resume from the specified session
+ * - --output-format stream-json: For streaming output
+ * - --dangerously-skip-permissions: Skip interactive permission prompts
+ * - --model <model>: Use the same model as the original session
+ * - -p "Continue.": Simple prompt to continue the work
+ *
+ * Note: This function is specifically designed for Claude CLI (--tool claude)
+ * and should only be used when the tool is 'claude' or undefined (defaults to claude).
+ *
+ * @param {Object} options - Options for building the command
+ * @param {string} options.tempDir - The working directory (e.g., /tmp/gh-issue-solver-...)
+ * @param {string} options.sessionId - The session ID to resume
+ * @param {string} options.claudePath - Path to the claude CLI binary (defaults to 'claude')
+ * @param {string} [options.model] - The model to use (e.g., 'sonnet', 'opus', 'claude-sonnet-4-20250514')
+ * @returns {string} - The full autonomous resume command
+ */
+export const buildClaudeAutonomousResumeCommand = ({ tempDir, sessionId, claudePath = 'claude', model }) => {
+  let args = `--resume ${sessionId} --output-format stream-json --dangerously-skip-permissions`;
+
+  if (model) {
+    args += ` --model ${model}`;
+  }
+
+  // Add a simple "Continue." prompt to continue the autonomous work
+  args += ` -p "Continue."`;
+
+  return `(cd "${tempDir}" && ${claudePath} ${args})`;
+};
+
 /**
  * Build the Claude CLI initial command with the (cd ... && claude ...) pattern
  *
@@ -85,5 +122,6 @@ export const buildClaudeInitialCommand = ({ tempDir, claudePath = 'claude', mode
 // Export default object for compatibility
 export default {
   buildClaudeResumeCommand,
+  buildClaudeAutonomousResumeCommand,
   buildClaudeInitialCommand,
 };

package/src/claude.lib.mjs

@@ -16,7 +16,8 @@ import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import Decimal from 'decimal.js-light';
 import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage, getRawRequestInputTokens } from './claude.budget-stats.lib.mjs';
-import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
+import { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand } from './claude.command-builder.lib.mjs';
+import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments.lib.mjs'; // Issue #1625
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
@@ -27,13 +28,14 @@ import { fetchModelInfo } from './model-info.lib.mjs';
 import { classifyRetryableError, maybeSwitchToFallbackModel } from './tool-retry.lib.mjs';
 import { resolveSubSessionSize } from './sub-session-size.lib.mjs'; // Issue #1706
 import { withAgentsMdAsClaudeMd } from './agents-md-claude-support.lib.mjs';
-export { availableModels }; // Re-export for backward compatibility
-export { fetchModelInfo };
-const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
+export { availableModels, fetchModelInfo }; // Re-export for backward compatibility
+const showResumeCommand = async (sessionId, tempDir, claudePath, model, log, argv = null) => {
   if (!sessionId || !tempDir) return;
-  const cmd = buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model });
-  await log('\n💡 To continue this session in Claude Code interactive mode:\n');
-  await log(`   ${cmd}\n`);
+  await log(`\n💡 To continue this session:\n`);
+  await log(`   Interactive mode:    ${buildClaudeResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
+  await log(`   Autonomous mode:     ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, claudePath, model })}\n`);
+  // Issue #942: 3rd option - restart the entire /solve flow, not just the claude session.
+  if (argv && argv.url) await log(`   Solve resume mode:   ${buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: argv.tool || 'claude', model: argv.model, fallbackModel: argv.fallbackModel, tempDir })}\n`);
 };
 /** Format numbers with spaces as thousands separator (no commas) */
 export const formatNumber = num => {
@@ -1238,25 +1240,24 @@ export const executeClaudeCommand = async params => {
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
           limitTimezone = limitInfo.timezone;
-
-          // Format and display user-friendly message
+          const hasSession = tempDir && sessionId;
+          // Issue #942: include all 3 resume options (interactive/autonomous/solve).
           const messageLines = formatUsageLimitMessage({
             tool: 'Anthropic Claude Code',
             resetTime: limitInfo.resetTime,
             sessionId,
-            resumeCommand: argv.url ? `${process.argv[0]} ${process.argv[1]} --auto-continue ${argv.url}` : null,
+            interactiveResumeCommand: hasSession ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : null,
+            autonomousResumeCommand: hasSession ? buildClaudeAutonomousResumeCommand({ tempDir, sessionId, model: argv.model }) : null,
+            solveResumeCommand: hasSession && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: argv.tool || 'claude', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null,
           });
-          for (const line of messageLines) {
-            await log(line, { level: 'warning' });
-          }
+          for (const line of messageLines) await log(line, { level: 'warning' });
         } else if (lastMessage.includes('context_length_exceeded')) {
           await log('\n\n❌ Context length exceeded. Try with a smaller issue or split the work.', { level: 'error' });
         } else {
           await log(`\n\n❌ Claude command failed with exit code ${exitCode}`, { level: 'error' });
-          if (sessionId && !argv.resume) {
-            await log(`📌 Session ID for resuming: ${sessionId}`);
-            await log('\nTo resume this session, run:');
-            await log(`   ${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}`);
+          if (sessionId && !argv.resume && tempDir) {
+            await log(`📌 Session ID: ${sessionId}`);
+            await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log, argv);
           }
         }
       }
@@ -1275,7 +1276,7 @@ export const executeClaudeCommand = async params => {
         await log('\n📈 System resources after execution:', { verbose: true });
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
-        await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log);
+        await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log, argv);
         return {
           success: false,
           sessionId,
@@ -1361,7 +1362,7 @@ export const executeClaudeCommand = async params => {
           await log(`   ⚠️ Could not calculate token usage: ${tokenError.message}`, { verbose: true });
         }
       }
-      await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log);
+      await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log, argv);
       return {
         success: true,
         sessionId,

package/src/claude.prompts.lib.mjs

@@ -17,6 +17,11 @@ import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 export const buildUserPrompt = params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, owner, repo, argv, contributingGuidelines, claudeVersion } = params;
 
+  if (argv?.minimalRestartContext && argv.resume) {
+    const lines = feedbackLines && feedbackLines.length > 0 ? feedbackLines : ['Continue the auto-restart from the previous resumed session.'];
+    return `${lines.join('\n')}\n`;
+  }
+
   const promptLines = [];
 
   // Issue or PR reference
@@ -87,6 +92,10 @@ export const buildUserPrompt = params => {
 export const buildSystemPrompt = params => {
   const { owner, repo, issueNumber, prNumber, branchName, workspaceTmpDir, argv, modelSupportsVision, forkedRepo } = params;
 
+  if (argv?.minimalRestartContext && argv.resume) {
+    return '';
+  }
+
   // When in fork mode, screenshots are pushed to the fork, not the original repo
   const screenshotRepoPath = argv?.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
 

package/src/codex.lib.mjs

@@ -17,6 +17,8 @@ import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
+import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
+const __codexBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'codex', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
@@ -1011,11 +1013,13 @@ export const executeCodexCommand = async params => {
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
 
+          // Issue #942: build proper solve resume command (preserves tool/model/dir).
+          const solveResumeCmd = __codexBuildSolveResumeCmd(argv, sessionId, tempDir);
           const messageLines = formatUsageLimitMessage({
             tool: 'OpenAI Codex',
             resetTime: limitInfo.resetTime,
             sessionId,
-            resumeCommand: sessionId ? `${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}` : null,
+            solveResumeCommand: solveResumeCmd,
           });
 
           for (const line of messageLines) {
@@ -1096,11 +1100,13 @@ export const executeCodexCommand = async params => {
           limitResetTime = limitInfo.resetTime;
 
           // Format and display user-friendly message
+          // Issue #942: build proper solve resume command (preserves tool/model/dir).
+          const solveResumeCmd = __codexBuildSolveResumeCmd(argv, sessionId, tempDir);
           const messageLines = formatUsageLimitMessage({
             tool: 'OpenAI Codex',
             resetTime: limitInfo.resetTime,
             sessionId,
-            resumeCommand: sessionId ? `${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId}` : null,
+            solveResumeCommand: solveResumeCmd,
           });
 
           for (const line of messageLines) {

package/src/gemini.lib.mjs

@@ -13,6 +13,8 @@ import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
+import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
+const __geminiBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'gemini', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { defaultModels, geminiModels } from './models/index.mjs';
 import { checkPlaywrightMcpPackageAvailability } from './playwright-mcp.lib.mjs';
@@ -539,11 +541,13 @@ export const executeGeminiCommand = async params => {
           limitReached = true;
           limitResetTime = limitInfo.resetTime;
 
+          // Issue #942: build proper solve resume command (preserves tool/model/dir).
+          const solveResumeCmd = __geminiBuildSolveResumeCmd(argv, sessionId, tempDir);
           const messageLines = formatUsageLimitMessage({
             tool: 'Gemini CLI',
             resetTime: limitInfo.resetTime,
             sessionId,
-            resumeCommand: sessionId ? `${process.argv[0]} ${process.argv[1]} ${argv.url} --resume ${sessionId} --tool gemini` : null,
+            solveResumeCommand: solveResumeCmd,
           });
 
           for (const line of messageLines) {

package/src/solve.config.lib.mjs

@@ -187,6 +187,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Maximum number of auto-restart iterations before stopping (default: 5, 0 = unlimited)',
     default: 5,
   },
+  'resume-on-auto-restart': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Resume the previous Claude session on uncommitted-change auto-restart and send only a minimal restart prompt. Disabled by default.',
+    default: false,
+  },
   'auto-resume-max-iterations': {
     type: 'number',
     description: 'Maximum number of automatic resume/restart continuations after usage-limit resets (default: 5, 0 = unlimited)',

package/src/solve.minimal-restart-prompt.lib.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Generate minimal prompt for auto-restart with session resume
+ * This module provides functions to create lightweight prompts for auto-restart
+ * that assume the AI has full context from the previous session
+ *
+ * Part of the cost optimization feature for issue #661
+ * @see case-studies/issue-661-session-resume-cost-optimization/
+ */
+
+// Note: This module does not import $ directly
+// Functions receive $ as a parameter from the calling module
+// This ensures consistent command executor usage across the codebase
+
+/**
+ * Generate minimal prompt for auto-restart with session resume
+ * This prompt assumes the AI has full context from the previous session
+ * Target: ~500 tokens (compared to 50k-200k in full context)
+ *
+ * @param {string} tempDir - Working directory
+ * @param {object} $ - Command executor
+ * @returns {Promise<string>} Minimal restart prompt
+ */
+export const generateMinimalRestartPrompt = async (tempDir, $) => {
+  // Get uncommitted changes
+  const gitStatus = await $({ cwd: tempDir })`git status --porcelain`;
+  const uncommittedFiles = gitStatus.stdout.toString().trim();
+
+  // Get brief diff summaries (not full diffs to keep the prompt minimal)
+  const gitDiffStat = await $({ cwd: tempDir })`git diff --stat`;
+  const unstagedDiffSummary = gitDiffStat.stdout.toString().trim();
+  const gitCachedDiffStat = await $({ cwd: tempDir })`git diff --cached --stat`;
+  const stagedDiffSummary = gitCachedDiffStat.stdout.toString().trim();
+  const summarySections = [];
+  if (unstagedDiffSummary) summarySections.push(`Unstaged changes:\n${unstagedDiffSummary}`);
+  if (stagedDiffSummary) summarySections.push(`Staged changes:\n${stagedDiffSummary}`);
+  const diffSummary = summarySections.join('\n\n') || 'No tracked-file diff summary available.';
+
+  // Count changes
+  const fileCount = uncommittedFiles.split('\n').filter(line => line.trim()).length;
+
+  return `🔄 Auto-restart: resume the previous session and handle its uncommitted changes.
+
+Uncommitted files (${fileCount}):
+${uncommittedFiles}
+
+Changes summary:
+${diffSummary}
+
+Please review these changes and commit them with an appropriate commit message.
+Follow the repository's commit message conventions from previous commits.`;
+};
+
+/**
+ * Generate full context prompt (fallback when resume fails or not enabled)
+ * This is used when session resume is not available or failed
+ *
+ * @param {string} issueUrl - Issue URL
+ * @param {string} issueBody - Issue description
+ * @param {number} prNumber - PR number
+ * @param {Array<string>} feedbackLines - Feedback from reviewers
+ * @param {string} tempDir - Working directory
+ * @param {object} $ - Command executor
+ * @returns {Promise<string>} Full restart prompt
+ */
+export const generateFullRestartPrompt = async (issueUrl, issueBody, prNumber, feedbackLines, tempDir, $) => {
+  // Get uncommitted changes with full diff
+  const gitStatus = await $({ cwd: tempDir })`git status --porcelain`;
+  const uncommittedFiles = gitStatus.stdout.toString().trim();
+
+  const gitDiff = await $({ cwd: tempDir })`git diff`;
+  const fullDiff = gitDiff.stdout.toString();
+
+  let prompt = `
+Continuing work on issue: ${issueUrl}
+
+Previous session completed but left uncommitted changes.
+  `.trim();
+
+  if (feedbackLines && feedbackLines.length > 0) {
+    prompt += `\n\nFeedback from reviewers:\n${feedbackLines.join('\n')}`;
+  }
+
+  prompt += `\n\nUncommitted changes:\n${uncommittedFiles}\n\nFull diff:\n${fullDiff}`;
+
+  prompt += '\n\nPlease review these changes and commit them appropriately.';
+
+  return prompt;
+};

package/src/solve.mjs

@@ -31,7 +31,7 @@ const { processAutoContinueForIssue } = autoContinue;
 const repository = await import('./solve.repository.lib.mjs');
 const { setupTempDirectory, cleanupTempDirectory } = repository;
 const results = await import('./solve.results.lib.mjs');
-const { cleanupClaudeFile, showSessionSummary, verifyResults, buildClaudeResumeCommand, buildSolveResumeCommand, maybeAttachWorkingSessionSummary, verifyPullRequestIssueLinkAfterAutoRestart } = results;
+const { cleanupClaudeFile, showSessionSummary, verifyResults, buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand, buildSolveResumeCommand, maybeAttachWorkingSessionSummary, verifyPullRequestIssueLinkAfterAutoRestart } = results;
 const claudeLib = await import('./claude.lib.mjs');
 const { executeClaude, checkPlaywrightMcpAvailability } = claudeLib;
 const githubLinking = await import('./github-linking.lib.mjs');
@@ -826,6 +826,13 @@ try {
   limitReached = toolResult.limitReached;
   cleanupContext.limitReached = limitReached;
 
+  if (sessionId && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart'])) {
+    global.previousSessionId = sessionId;
+    if (argv.verbose) {
+      await log(`Session ID stored for auto-restart resume: ${sessionId}`, { verbose: true });
+    }
+  }
+
   // Capture limit reset time and timezone globally for downstream handlers (auto-continue, cleanup decisions)
   if (toolResult && toolResult.limitResetTime) {
     global.limitResetTime = toolResult.limitResetTime;
@@ -861,16 +868,14 @@ try {
           await log(`⏰ Limit resets at: ${formattedResetTime}`);
         }
         await log('');
-        // Show claude resume command only for --tool claude (or default)
-        // Uses the (cd ... && claude --resume ...) pattern for a fully copyable, executable command
-        const toolForResume = argv.tool || 'claude';
-        if (toolForResume === 'claude') {
-          const claudeResumeCmd = buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model });
-          await log('💡 To continue this session in Claude Code interactive mode:');
-          await log('');
-          await log(`   ${claudeResumeCmd}`);
+        // Show dual resume commands (interactive + autonomous) only for --tool claude
+        if ((argv.tool || 'claude') === 'claude') {
+          await log('💡 To continue this session:');
+          await log(`   Interactive mode: ${buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model })}`);
+          await log(`   Autonomous mode:  ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, model: argv.model })}`);
           await log('');
         } else if (argv.url) {
+          const toolForResume = argv.tool || 'claude';
           const solveResumeCmd = buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: toolForResume, model: argv.model, fallbackModel: argv.fallbackModel, tempDir });
           await log(`💡 To continue this ${toolForResume} session with solve:`);
           await log('');
@@ -919,13 +924,13 @@ try {
           await log(`  ⚠️  Error uploading logs: ${uploadError.message}`);
         }
       } else if (prNumber) {
-        // Fallback: Post simple failure comment if logs are not attached
+        // Fallback: Post simple failure comment (no CLI commands in GitHub comments, only mention option)
         try {
           const resetTime = global.limitResetTime;
-          // Build Claude CLI resume command
-          const tool = argv.tool || 'claude';
-          const resumeCmd = tool === 'claude' ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : sessionId ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool, model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null;
-          const resumeSection = resumeCmd ? `To resume after the limit resets, use:\n\`\`\`bash\n${resumeCmd}\n\`\`\`` : `Session ID: \`${sessionId}\``;
+          // Issue #942: do not embed CLI commands in GitHub comments. Users
+          // interact via the Telegram bot, not the CLI. The full resume
+          // commands (interactive/autonomous/solve) live in the attached logs.
+          const resumeSection = sessionId ? `Session ID: \`${sessionId}\`\n\nUse the \`--auto-resume-on-limit-reset\` or \`--auto-restart-on-limit-reset\` option to automatically resume when the limit resets.` : 'Use the `--auto-resume-on-limit-reset` or `--auto-restart-on-limit-reset` option to automatically resume when the limit resets.';
           // Format the reset time with relative time and UTC conversion if available
           const timezone = global.limitTimezone || null;
           const formattedResetTime = resetTime ? formatResetTimeWithRelative(resetTime, timezone) : null;
@@ -1032,21 +1037,22 @@ try {
   // Skip failure exit if limit reached with auto-resume (continues to showSessionSummary/autoContinueWhenLimitResets)
   const shouldSkipFailureExitForAutoLimitContinue = limitReached && argv.autoResumeOnLimitReset;
   if (!success && !shouldSkipFailureExitForAutoLimitContinue) {
-    // Show claude resume command only for --tool claude (or default) on failure
+    // Issue #942: show all three resume options on failure for richer guidance.
+    //   1. Interactive claude  - opens Claude Code interactively (claude only)
+    //   2. Autonomous claude   - one-shot claude --resume w/ --dangerously-skip-permissions -p (claude only)
+    //   3. Solve resume        - re-enters solve.mjs with --resume, preserving tool/model/dir
     const toolForFailure = argv.tool || 'claude';
-    if (sessionId && toolForFailure === 'claude') {
-      const claudeResumeCmd = buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model });
+    if (sessionId) {
       await log('');
-      await log('💡 To continue this session in Claude Code interactive mode:');
-      await log('');
-      await log(`   ${claudeResumeCmd}`);
-      await log('');
-    } else if (sessionId && argv.url) {
-      const solveResumeCmd = buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: toolForFailure, model: argv.model, fallbackModel: argv.fallbackModel, tempDir });
-      await log('');
-      await log(`💡 To continue this ${toolForFailure} session with solve:`);
-      await log('');
-      await log(`   ${solveResumeCmd}`);
+      await log('💡 To continue this session:');
+      if (toolForFailure === 'claude') {
+        await log(`   Interactive mode:    ${buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model })}`);
+        await log(`   Autonomous mode:     ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, model: argv.model })}`);
+      }
+      if (argv.url) {
+        const solveResumeCmd = buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: toolForFailure, model: argv.model, fallbackModel: argv.fallbackModel, tempDir });
+        await log(`   Solve resume mode:   ${solveResumeCmd}`);
+      }
       await log('');
     }
 

package/src/solve.results.lib.mjs

@@ -43,48 +43,16 @@ const { autoContinueWhenLimitResets } = autoContinue;
 // Import Claude-specific command builders
 // These are used to generate copy-pasteable Claude CLI resume commands for users
 // Pattern: (cd "/tmp/gh-issue-solver-..." && claude --resume <session-id>)
+// Two types of resume commands are supported:
+// 1. Interactive resume: Short command that opens interactive mode
+// 2. Autonomous resume: Full command with all flags to run autonomously
 const claudeCommandBuilder = await import('./claude.command-builder.lib.mjs');
-export const { buildClaudeResumeCommand, buildClaudeInitialCommand } = claudeCommandBuilder;
+export const { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand, buildClaudeInitialCommand } = claudeCommandBuilder;
 
-/**
- * Build a solve.mjs resume command for tools that do not have a first-party interactive
- * resume CLI flow like Claude Code. This keeps the invocation within hive-mind so the
- * original tool selection and working directory can be preserved.
- *
- * @param {Object} options
- * @param {string} options.issueUrl - The issue URL passed to solve.mjs
- * @param {string} options.sessionId - The session ID to resume
- * @param {string|null} [options.tool] - Tool name (codex, opencode, agent, gemini)
- * @param {string|null} [options.model] - Model name to preserve
- * @param {string|null} [options.fallbackModel] - Explicit fallback model to preserve
- * @param {string|null} [options.tempDir] - Working directory to preserve
- * @param {string} [options.nodePath] - Node binary path
- * @param {string} [options.scriptPath] - solve.mjs path
- * @returns {string}
- */
-export const buildSolveResumeCommand = ({ issueUrl, sessionId, tool = null, model = null, fallbackModel = null, tempDir = null, nodePath = process.argv[0], scriptPath = process.argv[1] }) => {
-  const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
-
-  const args = [shellQuote(scriptPath), shellQuote(issueUrl), '--resume', shellQuote(sessionId)];
-
-  if (tool && tool !== 'claude') {
-    args.push('--tool', shellQuote(tool));
-  }
-
-  if (model) {
-    args.push('--model', shellQuote(model));
-  }
-
-  if (fallbackModel) {
-    args.push('--fallback-model', shellQuote(fallbackModel));
-  }
-
-  if (tempDir) {
-    args.push('--working-directory', shellQuote(tempDir));
-  }
-
-  return `${shellQuote(nodePath)} ${args.join(' ')}`;
-};
+// Issue #942: buildSolveResumeCommand lives in its own module so it can be safely
+// imported from tool libraries (claude/codex/gemini) without circular imports.
+import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs';
+export { buildSolveResumeCommand };
 
 // Import error handling functions
 // const errorHandlers = await import('./solve.error-handlers.lib.mjs'); // Not currently used
@@ -605,23 +573,23 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
     const absoluteLogPath = path.resolve(getLogFile());
     await log(`✅ Complete log file: ${absoluteLogPath}`);
 
+    // Show three resume options:
+    //   1. Interactive claude  - opens Claude Code interactively (claude only)
+    //   2. Autonomous claude   - one-shot claude --resume w/ --dangerously-skip-permissions -p (claude only)
+    //   3. Solve resume        - re-enters solve.mjs with --resume so the full flow continues
+    //                            (works for every supported tool, including codex/gemini/etc.)
     const tool = argv.tool || 'claude';
+    await log('');
+    await log('💡 To continue this session:');
     if (tool === 'claude') {
-      const claudeResumeCmd = buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model });
-
-      await log('');
-      await log('💡 To continue this session in Claude Code interactive mode:');
-      await log('');
-      await log(`   ${claudeResumeCmd}`);
-      await log('');
-    } else if (issueUrl) {
+      await log(`   Interactive mode:    ${buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model })}`);
+      await log(`   Autonomous mode:     ${buildClaudeAutonomousResumeCommand({ tempDir, sessionId, model: argv.model })}`);
+    }
+    if (issueUrl) {
       const solveResumeCmd = buildSolveResumeCommand({ issueUrl, sessionId, tool, model: argv.model, fallbackModel: argv.fallbackModel, tempDir });
-      await log('');
-      await log(`💡 To continue this ${tool} session with solve:`);
-      await log('');
-      await log(`   ${solveResumeCmd}`);
-      await log('');
+      await log(`   Solve resume mode:   ${solveResumeCmd}`);
     }
+    await log('');
 
     if (limitReached) {
       await log('⏰ LIMIT REACHED DETECTED!');

package/src/solve.resume-command.lib.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * Build a solve.mjs resume command for tools that do not have a first-party interactive
+ * resume CLI flow like Claude Code. This keeps the invocation within hive-mind so the
+ * original tool selection and working directory can be preserved.
+ *
+ * Lives in its own module (not solve.results.lib.mjs) so it can be imported from
+ * claude.lib.mjs / codex.lib.mjs / gemini.lib.mjs without creating a circular import.
+ * See issue #942.
+ *
+ * @param {Object} options
+ * @param {string} options.issueUrl - The issue URL passed to solve.mjs
+ * @param {string} options.sessionId - The session ID to resume
+ * @param {string|null} [options.tool] - Tool name (codex, opencode, agent, gemini)
+ * @param {string|null} [options.model] - Model name to preserve
+ * @param {string|null} [options.fallbackModel] - Explicit fallback model to preserve
+ * @param {string|null} [options.tempDir] - Working directory to preserve
+ * @param {string} [options.nodePath] - Node binary path
+ * @param {string} [options.scriptPath] - solve.mjs path
+ * @returns {string}
+ */
+export const buildSolveResumeCommand = ({ issueUrl, sessionId, tool = null, model = null, fallbackModel = null, tempDir = null, nodePath = process.argv[0], scriptPath = process.argv[1] }) => {
+  const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+  const args = [shellQuote(scriptPath), shellQuote(issueUrl), '--resume', shellQuote(sessionId)];
+  if (tool && tool !== 'claude') args.push('--tool', shellQuote(tool));
+  if (model) args.push('--model', shellQuote(model));
+  if (fallbackModel) args.push('--fallback-model', shellQuote(fallbackModel));
+  if (tempDir) args.push('--working-directory', shellQuote(tempDir));
+  return `${shellQuote(nodePath)} ${args.join(' ')}`;
+};

package/src/solve.watch.lib.mjs

@@ -290,6 +290,38 @@ export const watchForFeedback = async params => {
         // to comments posted during *this* iteration only, not across the whole watch loop.
         const iterationStartTime = new Date();
 
+        let restartFeedbackLines = feedbackLines;
+        let restartArgv = argv;
+        const shouldUseSessionResume = Boolean(isTemporaryWatch && (firstIterationInTemporaryMode || hasUncommittedInTempMode) && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart']) && (argv.tool === 'claude' || !argv.tool) && global.previousSessionId);
+
+        if (shouldUseSessionResume) {
+          await log(formatAligned('', 'Experimental session resume: using minimal auto-restart prompt', '', 2));
+          await log(formatAligned('', `Resuming session: ${global.previousSessionId}`, '', 2));
+
+          if (argv.verbose) {
+            try {
+              const { calculateSessionTokens } = await import('./claude.lib.mjs');
+              const tokenUsage = await calculateSessionTokens(global.previousSessionId, tempDir);
+              if (tokenUsage?.totalTokens) {
+                await log(formatAligned('', `Previous session tokens: ${tokenUsage.totalTokens.toLocaleString()}`, '', 2));
+              }
+            } catch {
+              await log(formatAligned('', 'Could not read previous session token usage', '', 2));
+            }
+          }
+
+          const { generateMinimalRestartPrompt } = await import('./solve.minimal-restart-prompt.lib.mjs');
+          const minimalPrompt = await generateMinimalRestartPrompt(tempDir, $);
+          restartFeedbackLines = [minimalPrompt];
+          restartArgv = {
+            ...argv,
+            resume: global.previousSessionId,
+            minimalRestartContext: true,
+          };
+
+          await log(formatAligned('', `Minimal restart prompt size: ${minimalPrompt.length} characters`, '', 2));
+        }
+
         // Execute tool using shared utility
         const toolResult = await executeToolIteration({
           issueUrl,
@@ -300,10 +332,14 @@ export const watchForFeedback = async params => {
           branchName: prBranch || branchName,
           tempDir,
           mergeStateStatus,
-          feedbackLines,
-          argv,
+          feedbackLines: restartFeedbackLines,
+          argv: restartArgv,
         });
 
+        if (toolResult.sessionId && (argv.resumeOnAutoRestart || argv['resume-on-auto-restart'])) {
+          global.previousSessionId = toolResult.sessionId;
+        }
+
         if (!toolResult.success) {
           // Check if this is an API error using shared utility
           if (isApiError(toolResult)) {

package/src/usage-limit.lib.mjs

@@ -394,10 +394,14 @@ export function formatResetTimeWithRelative(resetTime, timezone = null) {
  * @param {string} options.tool - Tool name (claude, codex, opencode, agent, gemini)
  * @param {string|null} options.resetTime - Time when limit resets
  * @param {string|null} options.sessionId - Session ID for resuming
- * @param {string|null} options.resumeCommand - Command to resume session
+ * @param {string|null} options.resumeCommand - Interactive resume command (legacy, for backward compatibility)
+ * @param {string|null} options.interactiveResumeCommand - Command to resume in interactive mode (claude)
+ * @param {string|null} options.autonomousResumeCommand - Command to resume in autonomous mode (claude)
+ * @param {string|null} options.solveResumeCommand - Command to resume the full solve.mjs flow
+ *   (works for every supported tool, including codex/gemini/etc.)
  * @returns {string[]} - Array of formatted message lines
  */
-export function formatUsageLimitMessage({ tool, resetTime, sessionId, resumeCommand }) {
+export function formatUsageLimitMessage({ tool, resetTime, sessionId, resumeCommand, interactiveResumeCommand, autonomousResumeCommand, solveResumeCommand }) {
   const lines = ['', '⏳ Usage Limit Reached!', '', `Your ${tool || 'AI tool'} usage limit has been reached.`];
 
   if (resetTime) {
@@ -406,12 +410,29 @@ export function formatUsageLimitMessage({ tool, resetTime, sessionId, resumeComm
     lines.push('Please wait for the limit to reset.');
   }
 
-  if (sessionId && resumeCommand) {
+  // Support both new (dual command) and legacy (single command) formats
+  const interactiveCmd = interactiveResumeCommand || resumeCommand;
+
+  if (sessionId && (interactiveCmd || autonomousResumeCommand || solveResumeCommand)) {
     lines.push('');
     lines.push(`📌 Session ID: ${sessionId}`);
     lines.push('');
-    lines.push('To resume this session after the limit resets, run:');
-    lines.push(`   ${resumeCommand}`);
+    lines.push('To resume this session after the limit resets:');
+    if (interactiveCmd) {
+      lines.push('');
+      lines.push('   Interactive mode (opens Claude Code for user interaction):');
+      lines.push(`   ${interactiveCmd}`);
+    }
+    if (autonomousResumeCommand) {
+      lines.push('');
+      lines.push('   Autonomous mode (continues work without user interaction):');
+      lines.push(`   ${autonomousResumeCommand}`);
+    }
+    if (solveResumeCommand) {
+      lines.push('');
+      lines.push('   Solve resume mode (re-enters the full solve flow, preserves tool/model/dir):');
+      lines.push(`   ${solveResumeCommand}`);
+    }
   }
 
   lines.push('');

package/CLAUDE.md

@@ -1,5 +0,0 @@
-Issue to solve: https://github.com/link-assistant/hive-mind/issues/962
-Your prepared branch: issue-962-7502f60e53a0
-Your prepared working directory: /tmp/gh-issue-solver-1766423610256
-
-Proceed.