@link-assistant/hive-mind 1.30.5 → 1.31.1

package/src/github-merge.lib.mjs

@@ -19,15 +19,10 @@ const exec = promisify(execCallback);
 // Import GitHub URL parser
 import { parseGitHubUrl } from './github.lib.mjs';
 
-// Import linking utilities
-import { extractLinkedIssueNumber } from './github-linking.lib.mjs';
-
-// Default label configuration
-export const READY_LABEL = {
-  name: 'ready',
-  description: 'Is ready to be merged',
-  color: '0E8A16', // Green color
-};
+// Issue #1413: Import ready tag sync, timeline, and label constant from separate module
+// to keep this file under the 1500 line limit
+import { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL } from './github-merge-ready-sync.lib.mjs';
+export { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL };
 
 /**
  * Check if 'ready' label exists in repository
@@ -254,172 +249,6 @@ export async function fetchReadyIssuesWithPRs(owner, repo, verbose = false) {
   }
 }
 
-/**
- * Add a label to a GitHub issue or pull request
- * @param {'issue'|'pr'} type - Whether to add to issue or PR
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {number} number - Issue or PR number
- * @param {string} labelName - Label name to add
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{success: boolean, error: string|null}>}
- */
-async function addLabel(type, owner, repo, number, labelName, verbose = false) {
-  const cmd = type === 'issue' ? 'issue' : 'pr';
-  try {
-    await exec(`gh ${cmd} edit ${number} --repo ${owner}/${repo} --add-label "${labelName}"`);
-    if (verbose) console.log(`[VERBOSE] /merge: Added '${labelName}' label to ${type} #${number}`);
-    return { success: true, error: null };
-  } catch (error) {
-    if (verbose) console.log(`[VERBOSE] /merge: Failed to add label to ${type} #${number}: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-
-/**
- * Sync 'ready' tags between linked pull requests and issues
- *
- * Issue #1367: Before building the merge queue, ensure that:
- * 1. If a PR has 'ready' label and is clearly linked to an issue (via standard GitHub
- *    keywords in the PR body/title), the issue also gets 'ready' label.
- * 2. If an issue has 'ready' label and has a clearly linked open PR, the PR also gets
- *    'ready' label.
- *
- * This ensures the final list of ready PRs reflects all ready work, regardless of
- * where the 'ready' label was originally applied.
- *
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{synced: number, errors: number, details: Array<Object>}>}
- */
-export async function syncReadyTags(owner, repo, verbose = false) {
-  const synced = [];
-  const errors = [];
-
-  if (verbose) {
-    console.log(`[VERBOSE] /merge: Syncing 'ready' tags for ${owner}/${repo}...`);
-  }
-
-  try {
-    // Fetch open PRs with 'ready' label (including body for link detection)
-    const { stdout: prsJson } = await exec(`gh pr list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title,body,labels --limit 100`);
-    const readyPRs = JSON.parse(prsJson.trim() || '[]');
-
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${readyPRs.length} open PRs with 'ready' label for tag sync`);
-    }
-
-    // Fetch open issues with 'ready' label
-    const { stdout: issuesJson } = await exec(`gh issue list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title --limit 100`);
-    const readyIssues = JSON.parse(issuesJson.trim() || '[]');
-
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${readyIssues.length} open issues with 'ready' label for tag sync`);
-    }
-
-    // Build a set of issue numbers that already have 'ready'
-    const readyIssueNumbers = new Set(readyIssues.map(i => String(i.number)));
-
-    // Step 1: For each PR with 'ready', find linked issue and sync label to it
-    for (const pr of readyPRs) {
-      try {
-        const prBody = pr.body || '';
-        const linkedIssueNumber = extractLinkedIssueNumber(prBody);
-
-        if (!linkedIssueNumber) {
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: PR #${pr.number} has no linked issue (no closing keyword in body)`);
-          }
-          continue;
-        }
-
-        if (readyIssueNumbers.has(String(linkedIssueNumber))) {
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: Issue #${linkedIssueNumber} already has 'ready' label (linked from PR #${pr.number})`);
-          }
-          continue;
-        }
-
-        // Issue doesn't have 'ready' label yet - add it
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: PR #${pr.number} has 'ready', adding to linked issue #${linkedIssueNumber}`);
-        }
-
-        const result = await addLabel('issue', owner, repo, linkedIssueNumber, READY_LABEL.name, verbose);
-        if (result.success) {
-          synced.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber) });
-          // Mark this issue as now having 'ready' so we don't process it again
-          readyIssueNumbers.add(String(linkedIssueNumber));
-        } else {
-          errors.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber), error: result.error });
-        }
-      } catch (err) {
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: Error syncing label from PR #${pr.number}: ${err.message}`);
-        }
-        errors.push({ type: 'pr-to-issue', prNumber: pr.number, error: err.message });
-      }
-    }
-
-    // Build a set of PR numbers that already have 'ready'
-    const readyPRNumbers = new Set(readyPRs.map(p => String(p.number)));
-
-    // Step 2: For each issue with 'ready', find linked PRs and sync label to them
-    for (const issue of readyIssues) {
-      try {
-        // Search for open PRs linked to this issue via closing keywords
-        const { stdout: linkedPRsJson } = await exec(`gh pr list --repo ${owner}/${repo} --search "in:body closes #${issue.number} OR fixes #${issue.number} OR resolves #${issue.number}" --state open --json number,title,labels --limit 10`);
-        const linkedPRs = JSON.parse(linkedPRsJson.trim() || '[]');
-
-        for (const linkedPR of linkedPRs) {
-          if (readyPRNumbers.has(String(linkedPR.number))) {
-            if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${linkedPR.number} already has 'ready' label (linked from issue #${issue.number})`);
-            }
-            continue;
-          }
-
-          // PR doesn't have 'ready' label yet - add it
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: Issue #${issue.number} has 'ready', adding to linked PR #${linkedPR.number}`);
-          }
-
-          const result = await addLabel('pr', owner, repo, linkedPR.number, READY_LABEL.name, verbose);
-          if (result.success) {
-            synced.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number });
-            // Mark this PR as now having 'ready'
-            readyPRNumbers.add(String(linkedPR.number));
-          } else {
-            errors.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number, error: result.error });
-          }
-        }
-      } catch (err) {
-        if (verbose) {
-          console.log(`[VERBOSE] /merge: Error syncing label from issue #${issue.number}: ${err.message}`);
-        }
-        errors.push({ type: 'issue-to-pr', issueNumber: issue.number, error: err.message });
-      }
-    }
-  } catch (error) {
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Error during tag sync: ${error.message}`);
-    }
-    errors.push({ type: 'fetch', error: error.message });
-  }
-
-  if (verbose) {
-    console.log(`[VERBOSE] /merge: Tag sync complete. Synced: ${synced.length}, Errors: ${errors.length}`);
-  }
-
-  return {
-    synced: synced.length,
-    errors: errors.length,
-    details: synced,
-    errorDetails: errors,
-  };
-}
-
 /**
  * Get combined list of ready PRs (from both direct PR labels and issue labels)
  * @param {string} owner - Repository owner
@@ -751,11 +580,15 @@ export async function waitForCI(owner, repo, prNumber, options = {}, verbose = f
     onStatusUpdate = null,
     // Issue #1269: Add timeout for callback to prevent infinite blocking
     callbackTimeout = 60 * 1000, // 1 minute max for callback
+    isCancelled = null, // Issue #1407: Support early exit when cancellation is requested
   } = options;
 
   const startTime = Date.now();
 
   while (Date.now() - startTime < timeout) {
+    // Issue #1407: Check for cancellation before each poll to allow early exit
+    if (isCancelled?.()) return { success: false, status: 'cancelled', error: 'Operation was cancelled' };
+
     let ciStatus;
     try {
       ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
@@ -1455,8 +1288,7 @@ export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   }
 }
 
-// Issue #1341: Import and re-export post-merge CI functions from separate module
-// to keep this file under the 1500 line limit
+// Issue #1341: Re-export post-merge CI functions from separate module
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
 export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
 
@@ -1469,32 +1301,30 @@ export default {
   fetchReadyPullRequests,
   fetchReadyIssuesWithPRs,
   getAllReadyPRs,
-  // Issue #1367: Sync 'ready' tags between linked PRs and issues
-  syncReadyTags,
+  syncReadyTags, // Issue #1367: Sync 'ready' tags between linked PRs and issues
   checkPRCIStatus,
   checkPRMergeable,
   checkMergePermissions,
   mergePullRequest,
   waitForCI,
   parseRepositoryUrl,
-  // Issue #1307: New exports for target branch CI waiting
-  getActiveBranchRuns,
+  getActiveBranchRuns, // Issue #1307: New exports for target branch CI waiting
   waitForBranchCI,
   getDefaultBranch,
-  // Issue #1314: Billing limit detection
+  // Issue #1314: Billing limit detection and enhanced CI status and re-run capabilities
   getCheckRunAnnotations,
   getRepoVisibility,
   checkForBillingLimitError,
   BILLING_LIMIT_ERROR_PATTERN,
-  // Issue #1314: Enhanced CI status and re-run capabilities
   getDetailedCIStatus,
   rerunWorkflowRun,
   rerunFailedJobs,
   getWorkflowRunsForSha,
-  // Issue #1341: Post-merge CI waiting and branch health checking
+  // Issue #1341: Post-merge CI waiting; Issue #1363: Detect active workflows
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
-  // Issue #1363: Detect active workflows to distinguish "no CI" from race condition
   getActiveRepoWorkflows,
+  // Issue #1413: Use issue timeline to find genuinely linked PRs (avoids false positives from text search)
+  getLinkedPRsFromTimeline,
 };

package/src/opencode.lib.mjs

@@ -465,6 +465,8 @@ export const executeOpenCodeCommand = async params => {
           for (const line of messageLines) {
             await log(line, { level: 'warning' });
           }
+        } else if (exitCode === 130) {
+          await log('\n\n⚠️ OpenCode command interrupted (CTRL+C)');
         } else {
           await log(`\n\n❌ OpenCode command failed with exit code ${exitCode}`, { level: 'error' });
         }

package/src/opencode.prompts.lib.mjs

@@ -213,7 +213,12 @@ Workflow and collaboration.
 Self review.
    - When you check your solution draft, run all tests locally.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/option-suggestions.lib.mjs

@@ -215,6 +215,9 @@ const KNOWN_OPTION_NAMES = [
   'prompt-examples-folder',
   'session-type',
   'working-directory',
+  'prompt-ensure-all-requirements-are-met',
+  'finalize',
+  'finalize-model',
 ];
 
 /**

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

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * Finalize module for solve.mjs
+ * After the main solve completes, restarts the AI tool N times with a
+ * requirements-check prompt to verify all requirements are met.
+ *
+ * Extracted from solve.mjs to keep files under 1500 lines.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1383
+ */
+
+// Check if use is already defined globally (when imported from solve.mjs)
+// 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 use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $ } = await use('command-stream');
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log } = lib;
+
+// Import shared restart utilities
+const restartShared = await import('./solve.restart-shared.lib.mjs');
+const { executeToolIteration } = restartShared;
+
+/**
+ * Runs finalize requirements-check iterations after the main solve.
+ *
+ * @param {object} params
+ * @param {string} params.issueUrl
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string|number} params.issueNumber
+ * @param {string|number} params.prNumber
+ * @param {string} params.branchName
+ * @param {string} params.tempDir
+ * @param {object} params.argv - CLI arguments
+ * @param {function} params.cleanupClaudeFile - cleanup function
+ * @returns {Promise<{sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo}|null>}
+ */
+export const runAutoEnsureRequirements = async ({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, argv, cleanupClaudeFile }) => {
+  const finalizeCount = argv.finalize;
+  if (!finalizeCount || finalizeCount <= 0 || !prNumber) {
+    return null;
+  }
+
+  await log('');
+  await log(`🔍 FINALIZE: Starting ${finalizeCount} requirements-check restart(s)`);
+  await log('   Will restart the AI tool to verify all requirements are met');
+  await log('');
+
+  // Get PR merge state status for the iterations
+  let currentMergeStateStatus = null;
+  try {
+    const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
+    if (prStateResult.code === 0) {
+      currentMergeStateStatus = prStateResult.stdout.toString().trim();
+    }
+  } catch {
+    // Ignore errors getting merge state
+  }
+
+  let sessionId;
+  let anthropicTotalCostUSD;
+  let publicPricingEstimate;
+  let pricingInfo;
+
+  // Use --finalize-model if provided, otherwise fall back to --model
+  const finalizeModel = argv.finalizeModel || argv.model;
+
+  for (let ensureIteration = 1; ensureIteration <= finalizeCount; ensureIteration++) {
+    await log(`🔄 FINALIZE iteration ${ensureIteration}/${finalizeCount}: Restarting to verify requirements...`);
+
+    const ensureFeedbackLines = ['', '='.repeat(60), '🔍 FINALIZE REQUIREMENTS CHECK:', '='.repeat(60), '', 'We need to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.', ''];
+
+    const ensureResult = await executeToolIteration({
+      issueUrl,
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+      branchName,
+      tempDir,
+      mergeStateStatus: currentMergeStateStatus,
+      feedbackLines: ensureFeedbackLines,
+      argv: {
+        ...argv,
+        // Override model with finalize-model for this iteration
+        model: finalizeModel,
+        // Enable prompt-ensure only during finalize cycle (not the first regular run)
+        promptEnsureAllRequirementsAreMet: true,
+        // Prevent recursive finalize
+        finalize: 0,
+      },
+    });
+
+    // Update session data from finalize restart
+    if (ensureResult) {
+      if (ensureResult.sessionId) sessionId = ensureResult.sessionId;
+      if (ensureResult.anthropicTotalCostUSD) anthropicTotalCostUSD = ensureResult.anthropicTotalCostUSD;
+      if (ensureResult.publicPricingEstimate) publicPricingEstimate = ensureResult.publicPricingEstimate;
+      if (ensureResult.pricingInfo) pricingInfo = ensureResult.pricingInfo;
+    }
+
+    await log(`✅ FINALIZE iteration ${ensureIteration}/${finalizeCount} complete`);
+    await log('');
+  }
+
+  // Clean up CLAUDE.md/.gitkeep after ensure restarts
+  await cleanupClaudeFile(tempDir, branchName, null, argv);
+
+  return { sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo };
+};
+
+export default { runAutoEnsureRequirements };

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

@@ -368,6 +368,12 @@ export const watchUntilMergeable = async params => {
   let iteration = 0;
   let lastCheckTime = new Date();
 
+  // Issue #1335: Cache whether the repo has CI workflows to avoid repeated API calls.
+  // When 'no_checks' is seen, we check if the repo actually has workflows configured.
+  // - If no workflows exist → 'no_checks' is permanent; treat PR as CI-passing and exit.
+  // - If workflows exist → 'no_checks' is a transient race condition; keep waiting.
+  let repoHasWorkflows = null; // null = not yet checked; true/false = cached result
+
   while (true) {
     iteration++;
     const currentTime = new Date();
@@ -812,12 +818,62 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
         const pendingBlocker = blockers.find(b => b.type === 'ci_pending');
         const cancelledOnly = blockers.every(b => b.type === 'ci_cancelled' || b.type === 'ci_pending');
 
-        if (cancelledOnly && cancelledBlocker) {
-          await log(formatAligned('🔄', 'Waiting for re-triggered CI:', cancelledBlocker.details.join(', '), 2));
-        } else if (pendingBlocker) {
-          await log(formatAligned('⏳', 'Waiting for CI:', pendingBlocker.details.length > 0 ? pendingBlocker.details.join(', ') : pendingBlocker.message, 2));
+        // Issue #1335: Detect permanent 'no_checks' state (repo has no CI workflows).
+        // The 'ci_pending' blocker with message 'have not started yet' means GitHub returned
+        // zero check-runs and zero commit statuses for this PR's HEAD SHA. This is ambiguous:
+        //   (a) Transient race condition — CI workflows exist but haven't queued yet after push.
+        //   (b) Permanent state — the repository has no CI/CD workflows configured at all.
+        // We resolve the ambiguity by checking if the repo actually has workflow files via the
+        // GitHub API. If it has none, the 'no_checks' state is permanent and the PR should be
+        // treated as CI-passing (no CI = nothing to wait for).
+        const isNoCIChecks = pendingBlocker && pendingBlocker.message.includes('have not started yet');
+        if (isNoCIChecks) {
+          // Lazy-check whether the repo has workflows (cache result to avoid repeated API calls)
+          if (repoHasWorkflows === null) {
+            const workflowCheck = await getActiveRepoWorkflows(owner, repo, argv.verbose);
+            repoHasWorkflows = workflowCheck.hasWorkflows;
+            if (argv.verbose) {
+              await log(formatAligned('', 'Repo workflow check:', repoHasWorkflows ? `${workflowCheck.count} workflow(s) found — CI check is a transient race condition` : 'No workflows configured — no CI expected', 2));
+            }
+          }
+
+          if (!repoHasWorkflows) {
+            // Root cause confirmed: repo has no CI. The 'no_checks' state is permanent.
+            // Treat the PR as CI-passing and exit the monitoring loop immediately.
+            await log('');
+            await log(formatAligned('ℹ️', 'NO CI WORKFLOWS CONFIGURED', 'Repository has no GitHub Actions workflows'));
+            await log(formatAligned('', 'Conclusion:', 'No CI expected — treating PR as CI-passing', 2));
+            await log(formatAligned('', 'Action:', 'Exiting monitoring loop', 2));
+            await log('');
+
+            // Post a comment explaining the situation
+            try {
+              const commentBody = `## ℹ️ No CI Workflows Detected
+
+No CI/CD checks are configured for this pull request. The repository has no GitHub Actions workflow files in \`.github/workflows/\`.
+
+The auto-restart-until-mergeable monitor is stopping since there is no CI to wait for. The PR may be ready to merge if there are no other issues.
+
+---
+*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
+              await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+            } catch {
+              // Don't fail if comment posting fails
+            }
+
+            return { success: true, reason: 'no_ci_checks', latestSessionId, latestAnthropicCost };
+          } else {
+            // Repo has workflows but CI hasn't started yet — transient race condition, keep waiting
+            await log(formatAligned('⏳', 'Waiting for CI:', 'No checks yet (CI workflows exist, waiting for them to start)', 2));
+          }
         } else {
-          await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
+          if (cancelledOnly && cancelledBlocker) {
+            await log(formatAligned('🔄', 'Waiting for re-triggered CI:', cancelledBlocker.details.join(', '), 2));
+          } else if (pendingBlocker) {
+            await log(formatAligned('⏳', 'Waiting for CI:', pendingBlocker.details.length > 0 ? pendingBlocker.details.join(', ') : pendingBlocker.message, 2));
+          } else {
+            await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
+          }
         }
       } else {
         await log(formatAligned('', 'No action needed', 'Continuing to monitor...', 2));

package/src/solve.config.lib.mjs

@@ -374,6 +374,21 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Automatically accept the pending GitHub repository or organization invitation for the specific repository/organization being solved, before checking write access. Unlike /accept_invites which accepts all pending invitations, this only accepts the invite for the target repo/org.',
     default: false,
   },
+  'prompt-ensure-all-requirements-are-met': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Add a prompt hint to the system prompt to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements. Enabled automatically by --finalize during finalize cycle iterations only.',
+    default: false,
+  },
+  finalize: {
+    type: 'number',
+    description: '[EXPERIMENTAL] After the main solve completes, automatically restart the AI tool N times (default: 1) with a requirements-check prompt to verify all requirements are met. Use --finalize-model to override the model for finalize iterations.',
+    default: 0,
+  },
+  'finalize-model': {
+    type: 'string',
+    description: '[EXPERIMENTAL] Model to use for --finalize iterations. Defaults to the same model as --model.',
+    default: undefined,
+  },
 };
 
 // Function to create yargs configuration - avoids duplication
@@ -535,6 +550,17 @@ export const parseArguments = async (yargs, hideBin) => {
     }
   }
 
+  // --finalize normalization
+  // Issue #1383: When finalize is enabled (as boolean or number), normalize to iteration count
+  // NOTE: promptEnsureAllRequirementsAreMet is NOT set here — it is only enabled during
+  // the finalize cycle iterations themselves (not the first regular worker model run)
+  if (argv && argv.finalize) {
+    // Normalize: if passed as boolean true (flag without value), treat as 1 iteration
+    if (argv.finalize === true) {
+      argv.finalize = 1;
+    }
+  }
+
   if (argv.tool === 'opencode' && !modelExplicitlyProvided) {
     // User did not explicitly provide --model, so use the correct default for opencode
     argv.model = 'grok-code-fast-1';

package/src/solve.error-handlers.lib.mjs

@@ -152,6 +152,45 @@ export const createUnhandledRejectionHandler = options => {
   };
 };
 
+/**
+ * Handles the case where no PR is available when one is required
+ */
+export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned }) => {
+  await log('');
+  await log(formatAligned('❌', 'FATAL ERROR:', 'No pull request available'), { level: 'error' });
+  await log('');
+  await log('  🔍 What happened:');
+  if (isContinueMode) {
+    await log('     Continue mode is active but no PR number is available.');
+    await log('     This usually means PR creation failed or was skipped incorrectly.');
+  } else {
+    await log('     Auto-PR creation is enabled but no PR was created.');
+    await log('     PR creation may have failed without throwing an error.');
+  }
+  await log('');
+  await log('  💡 Why this is critical:');
+  await log('     The solve command requires a PR for:');
+  await log('     • Tracking work progress');
+  await log('     • Receiving and processing feedback');
+  await log('     • Managing code changes');
+  await log('     • Auto-merging when complete');
+  await log('');
+  await log('  🔧 How to fix:');
+  await log('');
+  await log('  Option 1: Create PR manually and use --continue');
+  await log(`     cd ${tempDir}`);
+  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+  await log('     # Then use the PR URL with solve.mjs');
+  await log('');
+  await log('  Option 2: Start fresh without continue mode');
+  await log(`     ./solve.mjs "${issueUrl}" --auto-pull-request-creation`);
+  await log('');
+  await log('  Option 3: Disable auto-PR creation (Claude will create it)');
+  await log(`     ./solve.mjs "${issueUrl}" --no-auto-pull-request-creation`);
+  await log('');
+  await safeExit(1, 'No PR available');
+};
+
 /**
  * Handles execution errors in the main catch block
  */

package/src/solve.interrupt.lib.mjs

@@ -0,0 +1,70 @@
+/**
+ * Interrupt wrapper factory for CTRL+C handling in solve sessions.
+ *
+ * On SIGINT, auto-commits uncommitted changes and uploads session logs if --attach-logs is enabled.
+ */
+
+/**
+ * Creates an interrupt wrapper function that auto-commits and uploads logs on CTRL+C.
+ * @param {object} deps - Dependencies
+ * @param {object} deps.cleanupContext - Mutable context object with tempDir, argv, branchName, prNumber, owner, repo
+ * @param {Function} deps.checkForUncommittedChanges - Tool-specific function to check and commit changes
+ * @param {boolean} deps.shouldAttachLogs - Whether --attach-logs is enabled
+ * @param {Function} deps.attachLogToGitHub - Function to upload log to GitHub PR
+ * @param {Function} deps.getLogFile - Function that returns the current log file path
+ * @param {Function} deps.sanitizeLogContent - Function to sanitize log content before upload
+ * @param {object} deps.$ - Shell command runner
+ * @param {Function} deps.log - Logging function
+ * @returns {Function} Async interrupt wrapper
+ */
+export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChanges, shouldAttachLogs, attachLogToGitHub, getLogFile, sanitizeLogContent, $, log }) => {
+  return async () => {
+    const ctx = cleanupContext;
+    if (!ctx.tempDir || !ctx.argv) return;
+
+    await log('\n⚠️  Session interrupted by user (CTRL+C)');
+
+    // Always auto-commit uncommitted changes on CTRL+C to preserve work
+    if (ctx.branchName) {
+      try {
+        await checkForUncommittedChanges(
+          ctx.tempDir,
+          ctx.owner,
+          ctx.repo,
+          ctx.branchName,
+          $,
+          log,
+          true, // always autoCommit on CTRL+C to preserve work
+          false // no autoRestart
+        );
+      } catch (commitError) {
+        await log(`⚠️  Could not auto-commit changes on interrupt: ${commitError.message}`, {
+          level: 'warning',
+        });
+      }
+    }
+
+    // Upload logs if --attach-logs is enabled and we have a PR
+    if (shouldAttachLogs && ctx.prNumber && ctx.owner && ctx.repo) {
+      await log('📎 Uploading interrupted session logs to Pull Request...');
+      try {
+        await attachLogToGitHub({
+          logFile: getLogFile(),
+          targetType: 'pr',
+          targetNumber: ctx.prNumber,
+          owner: ctx.owner,
+          repo: ctx.repo,
+          $,
+          log,
+          sanitizeLogContent,
+          verbose: ctx.argv.verbose || false,
+          errorMessage: 'Session interrupted by user (CTRL+C)',
+        });
+      } catch (uploadError) {
+        await log(`⚠️  Could not upload logs on interrupt: ${uploadError.message}`, {
+          level: 'warning',
+        });
+      }
+    }
+  };
+};