@link-assistant/hive-mind 1.6.2 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @link-assistant/hive-mind
 
+## 1.7.0
+
+### Minor Changes
+
+- 5794e2f: Add `--working-directory` / `-d` option for proper session resume
+
+  Claude Code stores sessions per-directory path, so resuming a session in a different directory fails. This change:
+  1. Adds `--working-directory` / `-d` option to solve.mjs
+     - If directory exists with git repo, uses it without cloning
+     - If directory exists but empty, clones into it
+     - If directory doesn't exist, creates it and clones
+  2. Updates `--auto-resume-on-limit-reset` to pass `--working-directory`
+     - When limit resets and session auto-resumes, it uses the same directory as the original session
+     - This ensures Claude Code can find and resume the session
+  3. Improves resume error messaging
+     - Warns when resuming without --working-directory
+     - Explains that Claude Code sessions are tied to directory paths
+
+  Example usage:
+
+  ```bash
+  ./solve.mjs "<url>" --resume <session-id> --working-directory /tmp/gh-issue-solver-123
+  ```
+
+## 1.6.3
+
+### Patch Changes
+
+- Fix Anthropic cost extraction from JSON stream when session has error_during_execution
+  - Added anthropicTotalCostUSD to all failure return paths in executeClaudeCommand
+  - Changed cost capture logic to only extract from `subtype === 'success'` results
+  - This is explicit and reliable - error_during_execution results have zero cost
+  - Added case study documentation for issue #1104
+
+  Fixes #1104
+
+  Synchronize line count checks in CI/CD
+  - Add ESLint max-lines rule (1500 lines) to match CI workflow check
+  - Extract handleClaudeRuntimeSwitch to claude.runtime-switch.lib.mjs
+  - Reduce claude.lib.mjs from 1506 to 1354 lines
+  - Add case study documentation for issue #1141
+
+  Fixes #1141
+
 ## 1.6.2
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -8,7 +8,7 @@ const { $ } = await use('command-stream');
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 // Import log from general lib
-import { log, cleanErrorMessage } from './lib.mjs';
+import { log } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -16,6 +16,8 @@ import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
 // Import Claude command builder for generating resume commands
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
+// Import runtime switch module (extracted to maintain file line limits, see issue #1141)
+import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs';
 
 // Helper to display resume command at end of session
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
@@ -214,163 +216,9 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
   // Start the validation with retry logic
   return await attemptValidation();
 };
-// Function to handle Claude runtime switching between Node.js and Bun
-export const handleClaudeRuntimeSwitch = async argv => {
-  if (argv['force-claude-bun-run']) {
-    await log('\n🔧 Switching Claude runtime to bun...');
-    try {
-      try {
-        await $`which bun`;
-        await log('   ✅ Bun runtime found');
-      } catch (bunError) {
-        reportError(bunError, {
-          context: 'claude.lib.mjs - bun availability check',
-          level: 'error',
-        });
-        await log('❌ Bun runtime not found. Please install bun first: https://bun.sh/', { level: 'error' });
-        process.exit(1);
-      }
-
-      // Find Claude executable path
-      const claudePathResult = await $`which claude`;
-      const claudePath = claudePathResult.stdout.toString().trim();
-
-      if (!claudePath) {
-        await log('❌ Claude executable not found', { level: 'error' });
-        process.exit(1);
-      }
-
-      await log(`   Claude path: ${claudePath}`);
-
-      try {
-        await fs.access(claudePath, fs.constants.W_OK);
-      } catch (accessError) {
-        reportError(accessError, {
-          context: 'claude.lib.mjs - Claude executable write permission check (bun)',
-          level: 'error',
-        });
-        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
-        await log('   Try running with sudo or changing file permissions', { level: 'error' });
-        process.exit(1);
-      }
-      // Read current shebang
-      const firstLine = await $`head -1 "${claudePath}"`;
-      const currentShebang = firstLine.stdout.toString().trim();
-      await log(`   Current shebang: ${currentShebang}`);
-      if (currentShebang.includes('bun')) {
-        await log('   ✅ Claude is already configured to use bun');
-        process.exit(0);
-      }
-
-      // Create backup
-      const backupPath = `${claudePath}.nodejs-backup`;
-      await $`cp "${claudePath}" "${backupPath}"`;
-      await log(`   📦 Backup created: ${backupPath}`);
-
-      // Read file content and replace shebang
-      const content = await fs.readFile(claudePath, 'utf8');
-      const newContent = content.replace(/^#!.*node.*$/m, '#!/usr/bin/env bun');
-
-      if (content === newContent) {
-        await log('⚠️  No Node.js shebang found to replace', { level: 'warning' });
-        await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
-        process.exit(0);
-      }
-
-      await fs.writeFile(claudePath, newContent);
-      await log('   ✅ Claude shebang updated to use bun');
-      await log('   🔄 Claude will now run with bun runtime');
-    } catch (error) {
-      await log(`❌ Failed to switch Claude to bun: ${cleanErrorMessage(error)}`, { level: 'error' });
-      process.exit(1);
-    }
-
-    // Exit after switching runtime
-    process.exit(0);
-  }
-
-  if (argv['force-claude-nodejs-run']) {
-    await log('\n🔧 Restoring Claude runtime to Node.js...');
-    try {
-      try {
-        await $`which node`;
-        await log('   ✅ Node.js runtime found');
-      } catch (nodeError) {
-        reportError(nodeError, {
-          context: 'claude.lib.mjs - Node.js availability check',
-          level: 'error',
-        });
-        await log('❌ Node.js runtime not found. Please install Node.js first', { level: 'error' });
-        process.exit(1);
-      }
-
-      // Find Claude executable path
-      const claudePathResult = await $`which claude`;
-      const claudePath = claudePathResult.stdout.toString().trim();
-
-      if (!claudePath) {
-        await log('❌ Claude executable not found', { level: 'error' });
-        process.exit(1);
-      }
-
-      await log(`   Claude path: ${claudePath}`);
-
-      try {
-        await fs.access(claudePath, fs.constants.W_OK);
-      } catch (accessError) {
-        reportError(accessError, {
-          context: 'claude.lib.mjs - Claude executable write permission check (nodejs)',
-          level: 'error',
-        });
-        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
-        await log('   Try running with sudo or changing file permissions', { level: 'error' });
-        process.exit(1);
-      }
-      // Read current shebang
-      const firstLine = await $`head -1 "${claudePath}"`;
-      const currentShebang = firstLine.stdout.toString().trim();
-      await log(`   Current shebang: ${currentShebang}`);
-      if (currentShebang.includes('node') && !currentShebang.includes('bun')) {
-        await log('   ✅ Claude is already configured to use Node.js');
-        process.exit(0);
-      }
-
-      const backupPath = `${claudePath}.nodejs-backup`;
-      try {
-        await fs.access(backupPath);
-        // Restore from backup
-        await $`cp "${backupPath}" "${claudePath}"`;
-        await log(`   ✅ Restored Claude from backup: ${backupPath}`);
-      } catch (backupError) {
-        reportError(backupError, {
-          context: 'claude_restore_backup',
-          level: 'info',
-        });
-        // No backup available, manually update shebang
-        await log('   📝 No backup found, manually updating shebang...');
-        const content = await fs.readFile(claudePath, 'utf8');
-        const newContent = content.replace(/^#!.*bun.*$/m, '#!/usr/bin/env node');
-
-        if (content === newContent) {
-          await log('⚠️  No bun shebang found to replace', { level: 'warning' });
-          await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
-          process.exit(0);
-        }
-
-        await fs.writeFile(claudePath, newContent);
-        await log('   ✅ Claude shebang updated to use Node.js');
-      }
-
-      await log('   🔄 Claude will now run with Node.js runtime');
-    } catch (error) {
-      await log(`❌ Failed to restore Claude to Node.js: ${cleanErrorMessage(error)}`, { level: 'error' });
-      process.exit(1);
-    }
-
-    // Exit after restoring runtime
-    process.exit(0);
-  }
-};
+// handleClaudeRuntimeSwitch is imported from ./claude.runtime-switch.lib.mjs (see issue #1141)
+// Re-export it for backwards compatibility
+export { handleClaudeRuntimeSwitch };
 /**
  * Check if Playwright MCP is available and connected to Claude
  * @returns {Promise<boolean>} True if Playwright MCP is available, false otherwise
@@ -1038,9 +886,13 @@ export const executeClaudeCommand = async params => {
               // Handle session result type from Claude CLI (emitted when session completes)
               // Subtypes: "success", "error_during_execution" (work may have been done), etc.
               if (data.type === 'result') {
-                if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
+                // Issue #1104: Only extract cost from subtype 'success' results
+                // This is explicit and reliable - error_during_execution results have zero cost
+                if (data.subtype === 'success' && data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
                   anthropicTotalCostUSD = data.total_cost_usd;
-                  await log(`💰 Anthropic official cost captured: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
+                  await log(`💰 Anthropic official cost captured from success result: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
+                } else if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
+                  await log(`💰 Anthropic cost from ${data.subtype || 'unknown'} result ignored: $${data.total_cost_usd.toFixed(6)}`, { verbose: true });
                 }
                 if (data.is_error === true) {
                   lastMessage = data.result || JSON.stringify(data);
@@ -1170,6 +1022,7 @@ export const executeClaudeCommand = async params => {
             limitTimezone: null,
             messageCount,
             toolUseCount,
+            anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           };
         }
       }
@@ -1218,6 +1071,7 @@ export const executeClaudeCommand = async params => {
             messageCount,
             toolUseCount,
             is503Error: true,
+            anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           };
         }
       }
@@ -1296,6 +1150,7 @@ export const executeClaudeCommand = async params => {
           messageCount,
           toolUseCount,
           errorDuringExecution,
+          anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
         };
       }
       // Issue #1088: If error_during_execution occurred but command didn't fail,
@@ -1414,6 +1269,7 @@ export const executeClaudeCommand = async params => {
         limitTimezone: null,
         messageCount,
         toolUseCount,
+        anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
       };
     }
   }; // End of executeWithRetry function

package/src/claude.runtime-switch.lib.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// Claude runtime switching module
+// Extracted from claude.lib.mjs to maintain file line limits
+// See: docs/case-studies/issue-1141
+
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const { $ } = await use('command-stream');
+const fs = (await use('fs')).promises;
+import { log, cleanErrorMessage } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+
+// Function to handle Claude runtime switching between Node.js and Bun
+export const handleClaudeRuntimeSwitch = async argv => {
+  if (argv['force-claude-bun-run']) {
+    await log('\n🔧 Switching Claude runtime to bun...');
+    try {
+      try {
+        await $`which bun`;
+        await log('   ✅ Bun runtime found');
+      } catch (bunError) {
+        reportError(bunError, {
+          context: 'claude.runtime-switch.lib.mjs - bun availability check',
+          level: 'error',
+        });
+        await log('❌ Bun runtime not found. Please install bun first: https://bun.sh/', { level: 'error' });
+        process.exit(1);
+      }
+
+      // Find Claude executable path
+      const claudePathResult = await $`which claude`;
+      const claudePath = claudePathResult.stdout.toString().trim();
+
+      if (!claudePath) {
+        await log('❌ Claude executable not found', { level: 'error' });
+        process.exit(1);
+      }
+
+      await log(`   Claude path: ${claudePath}`);
+
+      try {
+        await fs.access(claudePath, fs.constants.W_OK);
+      } catch (accessError) {
+        reportError(accessError, {
+          context: 'claude.runtime-switch.lib.mjs - Claude executable write permission check (bun)',
+          level: 'error',
+        });
+        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
+        await log('   Try running with sudo or changing file permissions', { level: 'error' });
+        process.exit(1);
+      }
+      // Read current shebang
+      const firstLine = await $`head -1 "${claudePath}"`;
+      const currentShebang = firstLine.stdout.toString().trim();
+      await log(`   Current shebang: ${currentShebang}`);
+      if (currentShebang.includes('bun')) {
+        await log('   ✅ Claude is already configured to use bun');
+        process.exit(0);
+      }
+
+      // Create backup
+      const backupPath = `${claudePath}.nodejs-backup`;
+      await $`cp "${claudePath}" "${backupPath}"`;
+      await log(`   📦 Backup created: ${backupPath}`);
+
+      // Read file content and replace shebang
+      const content = await fs.readFile(claudePath, 'utf8');
+      const newContent = content.replace(/^#!.*node.*$/m, '#!/usr/bin/env bun');
+
+      if (content === newContent) {
+        await log('⚠️  No Node.js shebang found to replace', { level: 'warning' });
+        await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
+        process.exit(0);
+      }
+
+      await fs.writeFile(claudePath, newContent);
+      await log('   ✅ Claude shebang updated to use bun');
+      await log('   🔄 Claude will now run with bun runtime');
+    } catch (error) {
+      await log(`❌ Failed to switch Claude to bun: ${cleanErrorMessage(error)}`, { level: 'error' });
+      process.exit(1);
+    }
+
+    // Exit after switching runtime
+    process.exit(0);
+  }
+
+  if (argv['force-claude-nodejs-run']) {
+    await log('\n🔧 Restoring Claude runtime to Node.js...');
+    try {
+      try {
+        await $`which node`;
+        await log('   ✅ Node.js runtime found');
+      } catch (nodeError) {
+        reportError(nodeError, {
+          context: 'claude.runtime-switch.lib.mjs - Node.js availability check',
+          level: 'error',
+        });
+        await log('❌ Node.js runtime not found. Please install Node.js first', { level: 'error' });
+        process.exit(1);
+      }
+
+      // Find Claude executable path
+      const claudePathResult = await $`which claude`;
+      const claudePath = claudePathResult.stdout.toString().trim();
+
+      if (!claudePath) {
+        await log('❌ Claude executable not found', { level: 'error' });
+        process.exit(1);
+      }
+
+      await log(`   Claude path: ${claudePath}`);
+
+      try {
+        await fs.access(claudePath, fs.constants.W_OK);
+      } catch (accessError) {
+        reportError(accessError, {
+          context: 'claude.runtime-switch.lib.mjs - Claude executable write permission check (nodejs)',
+          level: 'error',
+        });
+        await log('❌ Cannot write to Claude executable (permission denied)', { level: 'error' });
+        await log('   Try running with sudo or changing file permissions', { level: 'error' });
+        process.exit(1);
+      }
+      // Read current shebang
+      const firstLine = await $`head -1 "${claudePath}"`;
+      const currentShebang = firstLine.stdout.toString().trim();
+      await log(`   Current shebang: ${currentShebang}`);
+      if (currentShebang.includes('node') && !currentShebang.includes('bun')) {
+        await log('   ✅ Claude is already configured to use Node.js');
+        process.exit(0);
+      }
+
+      const backupPath = `${claudePath}.nodejs-backup`;
+      try {
+        await fs.access(backupPath);
+        // Restore from backup
+        await $`cp "${backupPath}" "${claudePath}"`;
+        await log(`   ✅ Restored Claude from backup: ${backupPath}`);
+      } catch (backupError) {
+        reportError(backupError, {
+          context: 'claude_restore_backup',
+          level: 'info',
+        });
+        // No backup available, manually update shebang
+        await log('   📝 No backup found, manually updating shebang...');
+        const content = await fs.readFile(claudePath, 'utf8');
+        const newContent = content.replace(/^#!.*bun.*$/m, '#!/usr/bin/env node');
+
+        if (content === newContent) {
+          await log('⚠️  No bun shebang found to replace', { level: 'warning' });
+          await log(`   Current shebang: ${currentShebang}`, { level: 'warning' });
+          process.exit(0);
+        }
+
+        await fs.writeFile(claudePath, newContent);
+        await log('   ✅ Claude shebang updated to use Node.js');
+      }
+
+      await log('   🔄 Claude will now run with Node.js runtime');
+    } catch (error) {
+      await log(`❌ Failed to restore Claude to Node.js: ${cleanErrorMessage(error)}`, { level: 'error' });
+      process.exit(1);
+    }
+
+    // Exit after restoring runtime
+    process.exit(0);
+  }
+};
+
+export default {
+  handleClaudeRuntimeSwitch,
+};

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

@@ -65,7 +65,9 @@ const formatWaitTime = ms => {
 };
 
 // Auto-continue function that waits until limit resets
-export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs) => {
+// 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) => {
   try {
     const resetTime = global.limitResetTime;
     const waitMs = calculateWaitTime(resetTime);
@@ -115,6 +117,17 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     if (argv.fork) resumeArgs.push('--fork');
     if (shouldAttachLogs) resumeArgs.push('--attach-logs');
 
+    // CRITICAL: Pass --working-directory to ensure Claude Code session resume works correctly
+    // Claude Code stores sessions per working directory, so resume MUST use the same directory
+    // Without this, resume creates a NEW temp directory and session is not found
+    if (tempDir) {
+      resumeArgs.push('--working-directory', tempDir);
+      await log(`📂 Using working directory for session continuity: ${tempDir}`);
+    } else {
+      await log(`⚠️  Warning: No working directory specified - session resume may fail`);
+      await log(`   Claude Code sessions are stored per-directory, consider using --working-directory`);
+    }
+
     await log(`\n🔄 Executing: ${resumeArgs.join(' ')}`);
 
     // Execute the resume command
@@ -136,7 +149,11 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     });
     await log(`\n❌ Auto-continue failed: ${cleanErrorMessage(error)}`, { level: 'error' });
     await log('\n🔄 Manual resume command:');
-    await log(`./solve.mjs "${issueUrl}" --resume ${sessionId}`);
+    if (tempDir) {
+      await log(`./solve.mjs "${issueUrl}" --resume ${sessionId} --working-directory "${tempDir}"`);
+    } else {
+      await log(`./solve.mjs "${issueUrl}" --resume ${sessionId}`);
+    }
     await safeExit(1, 'Auto-continue failed');
   }
 };

package/src/solve.config.lib.mjs

@@ -47,6 +47,11 @@ export const createYargsConfig = yargsInstance => {
         description: 'Resume from a previous session ID (when limit was reached)',
         alias: 'r',
       })
+      .option('working-directory', {
+        type: 'string',
+        description: 'Use specified working directory instead of creating a new temp directory. If directory does not exist, it will be created and the repository will be cloned. Essential for --resume to work correctly with Claude Code sessions.',
+        alias: 'd',
+      })
       .option('only-prepare-command', {
         type: 'boolean',
         description: 'Only prepare and print the claude command without executing it',

package/src/solve.mjs

@@ -513,7 +513,7 @@ if (isPrUrl) {
 // Create or find temporary directory for cloning the repository
 // Pass workspace info for --enable-workspaces mode (works with all tools)
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
-const { tempDir, workspaceTmpDir } = await setupTempDirectory(argv, workspaceInfo);
+const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
 // Populate cleanup context for signal handlers
 cleanupContext.tempDir = tempDir;
 cleanupContext.argv = argv;
@@ -521,6 +521,7 @@ cleanupContext.argv = argv;
 let limitReached = false;
 try {
   // Set up repository and clone using the new module
+  // If --working-directory points to existing repo, needsClone is false and we skip cloning
   const { forkedRepo } = await setupRepositoryAndClone({
     argv,
     owner,
@@ -532,6 +533,7 @@ try {
     log,
     formatAligned,
     $,
+    needsClone,
   });
 
   // Verify default branch and status using the new module

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

@@ -3,14 +3,23 @@
  * Handles repository cloning, forking, and remote setup
  */
 
-export async function setupRepositoryAndClone({ argv, owner, repo, forkOwner, tempDir, isContinueMode, issueUrl, log, $ }) {
+export async function setupRepositoryAndClone({ argv, owner, repo, forkOwner, tempDir, isContinueMode, issueUrl, log, $, needsClone = true }) {
   // Set up repository and handle forking
   const { repoToClone, forkedRepo, upstreamRemote, prForkOwner } = await setupRepository(argv, owner, repo, forkOwner, issueUrl);
 
-  // Clone repository and set up remotes
-  await cloneRepository(repoToClone, tempDir, argv, owner, repo);
-  // Set up upstream remote and sync fork if needed
-  await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+  // Clone repository and set up remotes (skip if needsClone is false - directory already has repo)
+  if (needsClone) {
+    await cloneRepository(repoToClone, tempDir, argv, owner, repo);
+    // Set up upstream remote and sync fork if needed
+    await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+  } else {
+    await log('ℹ️  Skipping clone: Using existing repository in working directory');
+    // Still need to ensure upstream remote is set up if using fork mode
+    if (forkedRepo && upstreamRemote) {
+      await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+    }
+  }
+
   // Set up pr-fork remote if we're continuing someone else's fork PR with --fork flag
   const prForkRemote = await setupPrForkRemote(tempDir, argv, prForkOwner, repo, isContinueMode, owner);
 

package/src/solve.repository.lib.mjs

@@ -220,16 +220,58 @@ export const buildWorkspacePath = (owner, repo, issueNumber, timestamp) => {
 // When --enable-workspaces is used, creates:
 //   {workspace}/repository - for the cloned repo
 //   {workspace}/tmp - for temp files, logs, downloads
+// When --working-directory is used, uses the specified directory (creates if needed)
 export const setupTempDirectory = async (argv, workspaceInfo = null) => {
   let tempDir;
   let workspaceTmpDir = null;
   let isResuming = argv.resume;
+  // needsClone indicates if the repository needs to be cloned into the directory
+  // This is true when: new directory is created, or existing directory is empty
+  let needsClone = true;
 
   // Check if workspace mode should be enabled (works with all tools)
   const useWorkspaces = argv.enableWorkspaces;
 
+  // Priority 1: --working-directory option takes precedence over all other directory selection
+  // This is essential for --resume to work correctly with Claude Code sessions,
+  // because Claude Code stores sessions by working directory path, not session ID alone
+  if (argv.workingDirectory) {
+    tempDir = path.resolve(argv.workingDirectory);
+
+    // Check if directory exists
+    try {
+      const stat = await fs.stat(tempDir);
+      if (stat.isDirectory()) {
+        // Directory exists - check if it contains a git repository
+        try {
+          await fs.access(path.join(tempDir, '.git'));
+          // Git repository exists - no need to clone
+          needsClone = false;
+          await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+          await log(formatAligned('', 'Status:', 'Using existing repository', 2));
+          if (isResuming) {
+            await log(formatAligned('', 'Session:', `Resuming ${argv.resume}`, 2));
+          }
+        } catch {
+          // No .git directory - directory is empty or doesn't have a repo, will clone
+          await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+          await log(formatAligned('', 'Status:', 'Directory exists but no repository - will clone', 2));
+        }
+      }
+    } catch {
+      // Directory doesn't exist - create it
+      await fs.mkdir(tempDir, { recursive: true });
+      await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+      await log(formatAligned('', 'Status:', 'Created new directory - will clone repository', 2));
+    }
+
+    return { tempDir, workspaceTmpDir, isResuming, needsClone };
+  }
+
   if (isResuming) {
-    // When resuming, try to find existing directory or create a new one
+    // When resuming without --working-directory, create a new temp directory
+    // WARNING: This will NOT work correctly with Claude Code because the session
+    // is stored in a path-specific location. Use --working-directory for proper resume.
     const scriptDir = path.dirname(process.argv[1]);
     const sessionLogPattern = path.join(scriptDir, `${argv.resume}.log`);
 
@@ -241,7 +283,9 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
       // For resumed sessions, create new temp directory since old one may be cleaned up
       tempDir = path.join(os.tmpdir(), `gh-issue-solver-resume-${argv.resume}-${Date.now()}`);
       await fs.mkdir(tempDir, { recursive: true });
-      await log(`Creating new temporary directory for resumed session: ${tempDir}`);
+      await log(`⚠️  Creating new temporary directory for resumed session: ${tempDir}`);
+      await log(`   Note: Claude Code sessions are tied to working directory paths.`);
+      await log(`   If session resume fails, use --working-directory to specify the original directory.`);
     } catch (err) {
       reportError(err, {
         context: 'resume_session_lookup',
@@ -280,7 +324,7 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
     await log(`\nCreating temporary directory: ${tempDir}`);
   }
 
-  return { tempDir, workspaceTmpDir, isResuming };
+  return { tempDir, workspaceTmpDir, isResuming, needsClone };
 };
 
 // Try to initialize an empty repository by creating a simple README.md

package/src/solve.results.lib.mjs

@@ -377,7 +377,9 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
 
       if (argv.autoResumeOnLimitReset && global.limitResetTime) {
         await log(`\n🔄 AUTO-RESUME ON LIMIT RESET ENABLED - Will resume at ${global.limitResetTime}`);
-        await autoContinueWhenLimitResets(issueUrl, sessionId, argv, shouldAttachLogs);
+        // Pass tempDir to ensure resumed session uses the same working directory
+        // This is critical for Claude Code session resume to work correctly
+        await autoContinueWhenLimitResets(issueUrl, sessionId, argv, shouldAttachLogs, tempDir);
       } else {
         if (global.limitResetTime) {
           await log(`\n⏰ Limit resets at: ${global.limitResetTime}`);