@link-assistant/hive-mind 1.32.2 → 1.33.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.33.0
+
+### Minor Changes
+
+- f7a2fdd: Add --auto-init-repository option to automatically initialize empty repositories by creating a simple README.md file, enabling branch creation and pull request workflows on repositories with no commits
+
+## 1.32.3
+
+### Patch Changes
+
+- 04cf237: fix: properly drain active handles at exit to prevent indefinite process hang (Issue #1431)
+
+  Root causes identified and fixed: process.stdin (ReadStream) was never unreferenced; undici's global connection pool (Socket×2) was never closed; surviving command-stream child processes (ChildProcess) were never unreferenced; process.stdout/stderr (WriteStream×2) were not unreferenced on non-TTY descriptors.
+
+  Added drainHandles() in exit-handler.lib.mjs that unrefs/closes all four handle types before process.exit(). Added logActiveHandles() export with per-handle detail (fd, path, pid, remoteAddress) that always logs to the log file. Added no-leaked-streams ESLint rule to catch bare createReadStream/createWriteStream calls whose return value is discarded — the stream companion to the existing no-leaked-timers rule.
+
 ## 1.32.2
 
 ### Patch Changes

package/README.md

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

package/package.json

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

package/src/exit-handler.lib.mjs

@@ -66,12 +66,127 @@ const showExitMessage = async (reason = 'Process exiting', code = 0) => {
   await logFunction(`📁 Full log file: ${currentLogPath}`);
 };
 
+/**
+ * Drain and unref active Node.js handles so the event loop can exit naturally.
+ *
+ * Issue #1431: After all work completes, several handle types keep the event loop
+ * alive and prevent the process from exiting on its own:
+ *
+ *   - ReadStream  — process.stdin is never unreferenced. Node keeps it open so the
+ *                   process can receive user input, but a CLI tool is done with input
+ *                   at this point.  Calling .unref() signals that this handle should
+ *                   not prevent exit.
+ *
+ *   - Socket (×2) — Node 18+ built-in fetch() uses undici internally. Each HTTP
+ *                   request leaves a keep-alive socket in undici's global connection
+ *                   pool. Calling getGlobalDispatcher().close() drains and destroys
+ *                   all pooled connections.
+ *
+ *   - ChildProcess — command-stream spawns child processes. The handle stays alive
+ *                    until the OS reclaims the process entry. Calling .unref() on
+ *                    each surviving child lets Node exit without waiting for them.
+ *
+ *   - WriteStream (×2) — process.stdout and process.stderr are always-open writable
+ *                        streams. On non-TTY file descriptors (e.g. pipes, redirects)
+ *                        they can keep the event loop alive. Calling .unref() is safe
+ *                        because we have already finished all output at this point.
+ *
+ * All of these are "unref" fixes — the handles are not forcibly destroyed, just
+ * marked as non-blocking so the event loop considers the process idle once all real
+ * async work is done. This is the idiomatic Node.js pattern for CLI tools.
+ */
+const drainHandles = async () => {
+  // 1. Unref process.stdin so a dangling ReadStream cannot block exit.
+  try {
+    if (process.stdin && !process.stdin.destroyed) {
+      process.stdin.unref();
+    }
+  } catch {
+    // Ignore — stdin may already be closed
+  }
+
+  // 2. Close undici's global dispatcher to drain keep-alive HTTP sockets (Socket handles).
+  //    Node 18+ built-in fetch uses undici; each fetch() call may leave a socket in the
+  //    pool. getGlobalDispatcher().close() is the documented way to drain them.
+  try {
+    const { getGlobalDispatcher } = await import('undici');
+    const dispatcher = getGlobalDispatcher();
+    if (dispatcher && typeof dispatcher.close === 'function') {
+      await Promise.race([
+        dispatcher.close(),
+        new Promise(resolve => setTimeout(resolve, 1000)), // hard 1s deadline
+      ]);
+    }
+  } catch {
+    // undici may not be available in all Node versions — safe to ignore
+  }
+
+  // 3. Unref surviving child processes from command-stream.
+  //    These are typically already-exited but their OS handle entry lingers.
+  try {
+    for (const handle of process._getActiveHandles()) {
+      if (handle?.constructor?.name === 'ChildProcess' && typeof handle.unref === 'function') {
+        handle.unref();
+      }
+    }
+  } catch {
+    // _getActiveHandles is a private V8 API — safe to ignore
+  }
+
+  // 4. Unref stdout/stderr on non-TTY descriptors.
+  //    On a TTY these are already non-blocking; on pipes/redirects they keep the loop alive.
+  try {
+    if (process.stdout && !process.stdout.isTTY && typeof process.stdout.unref === 'function') {
+      process.stdout.unref();
+    }
+    if (process.stderr && !process.stderr.isTTY && typeof process.stderr.unref === 'function') {
+      process.stderr.unref();
+    }
+  } catch {
+    // Ignore
+  }
+};
+
+/**
+ * Log active handles and requests for diagnostics.
+ * Always logs if there are unexpected handles (not just in verbose mode),
+ * treating lingering handles as a warning-level signal.
+ *
+ * @param {Function|null} log - Optional logging function; falls back to console.warn
+ */
+export const logActiveHandles = async (log = null) => {
+  try {
+    const handles = process._getActiveHandles();
+    const requests = process._getActiveRequests();
+    if (handles.length === 0 && requests.length === 0) return;
+
+    const emit = log || (msg => console.warn(msg));
+    await emit(`\n🔍 Active Node.js handles at exit (${handles.length} handles, ${requests.length} requests):`);
+    for (const h of handles) {
+      const name = h.constructor?.name || typeof h;
+      // Extra detail for streams: show fd and path/remoteAddress if available
+      const detail = [h.fd != null ? `fd=${h.fd}` : null, h.path ? `path=${h.path}` : null, h.remoteAddress ? `remote=${h.remoteAddress}:${h.remotePort}` : null, h.pid != null ? `pid=${h.pid}` : null, h.spawnfile ? `file=${h.spawnfile}` : null].filter(Boolean).join(', ');
+      await emit(`   Handle: ${name}${detail ? ` (${detail})` : ''}`);
+    }
+    for (const r of requests) {
+      await emit(`   Request: ${r.constructor?.name || typeof r}`);
+    }
+  } catch {
+    // _getActiveHandles is a private V8 API — safe to ignore if unavailable
+  }
+};
+
 /**
  * Safe exit function that ensures log path is shown
  */
 export const safeExit = async (code = 0, reason = 'Process completed') => {
   await showExitMessage(reason, code);
 
+  // Issue #1431: Drain/unref active handles so the event loop exits naturally.
+  // This resolves the root causes of dangling ReadStream (stdin), Socket (undici),
+  // ChildProcess (command-stream), and WriteStream (stdout/stderr) handles.
+  await drainHandles();
+
   // Close Sentry to flush any pending events and allow the process to exit cleanly.
   // Use Promise.race with a hard timeout to guarantee sentry.close() never hangs
   // indefinitely — the 2000ms hint passed to sentry.close() is forwarded to internal

package/src/option-suggestions.lib.mjs

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

package/src/solve.branch-errors.lib.mjs

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

package/src/solve.config.lib.mjs

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

package/src/solve.mjs

@@ -76,7 +76,7 @@ const { startWatchMode } = watchLib;
 const { startAutoRestartUntilMergeable } = await import('./solve.auto-merge.lib.mjs');
 const { runAutoEnsureRequirements } = await import('./solve.auto-ensure.lib.mjs');
 const exitHandler = await import('./exit-handler.lib.mjs');
-const { initializeExitHandler, installGlobalExitHandlers, safeExit } = exitHandler;
+const { initializeExitHandler, installGlobalExitHandlers, safeExit, logActiveHandles } = exitHandler;
 const { createInterruptWrapper } = await import('./solve.interrupt.lib.mjs');
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
 
@@ -534,11 +534,16 @@ try {
   });
 
   // Verify default branch and status using the new module
+  // Pass argv, owner, repo, issueUrl for empty repository auto-initialization (--auto-init-repository)
   const defaultBranch = await verifyDefaultBranchAndStatus({
     tempDir,
     log,
     formatAligned,
     $,
+    argv,
+    owner,
+    repo,
+    issueUrl,
   });
   // Create or checkout branch using the new module
   const branchName = await createOrCheckoutBranch({
@@ -1450,14 +1455,14 @@ try {
   // closeSentry() uses a hard Promise.race deadline so it cannot block indefinitely.
   await closeSentry();
 
-  // Issue #1335: Log active handles at exit to diagnose future process hang.
-  if (argv.verbose) {
-    const handles = process._getActiveHandles();
-    const requests = process._getActiveRequests();
-    if (handles.length > 0 || requests.length > 0) {
-      await log(`\n🔍 Active Node.js handles at exit (${handles.length} handles, ${requests.length} requests):`, { verbose: true });
-      for (const h of handles) await log(`   Handle: ${h.constructor?.name || typeof h}`, { verbose: true });
-      for (const r of requests) await log(`   Request: ${r.constructor?.name || typeof r}`, { verbose: true });
-    }
-  }
+  // Issue #1431: Log active handles before draining.
+  // Always logged to file and console so future hangs are immediately visible in logs.
+  // drainHandles() inside safeExit() will unref/close these before process.exit().
+  await logActiveHandles(msg => log(msg));
+
+  // Issue #1431: safeExit() calls drainHandles() to unref/close known handle types
+  // (process.stdin ReadStream, undici Socket pool, command-stream ChildProcess,
+  // process.stdout/stderr WriteStreams) so the event loop exits naturally, then
+  // calls process.exit(0) as a deterministic safety net.
+  await safeExit(0, 'Process completed');
 }

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

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

package/src/solve.repository.lib.mjs

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