@link-assistant/hive-mind 2.12.5 → 2.13.1

package/src/github.batch.lib.mjs

@@ -17,19 +17,27 @@ import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from
 export { prClosesIssue };
 
 /**
- * Extract open pull requests that are linked to an issue with closing keywords.
+ * Extract pull requests that are linked to an issue with closing keywords.
  * Draft pull requests are still open in-progress solution drafts, so they must
  * count for /hive --skip-issues-with-prs.
+ *
+ * Issue #2160: reporting needs the opposite default from gating. `--skip-issues-with-prs` only
+ * cares about OPEN pull requests, but the end-of-run summary must also see the ones `--auto-merge`
+ * already merged, otherwise a merged solution draft is reported as "(no PR found)".
+ *
  * @param {Object} issueData - GraphQL issue node with timelineItems
  * @param {number} issueNum - Issue number to check
  * @param {Function} logger - Async logger, defaults to shared log helper
- * @returns {Promise<Array<Object>>} Linked open PRs that close the issue
+ * @param {Object} [options]
+ * @param {Array<string>} [options.includeStates=['OPEN']] - PR states to report
+ * @returns {Promise<Array<Object>>} Linked PRs (in the requested states) that close the issue
  */
-export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log) {
+export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log, { includeStates = ['OPEN'] } = {}) {
   const linkedPRs = [];
+  const wantedStates = new Set(includeStates);
 
   for (const item of issueData.timelineItems?.nodes || []) {
-    if (item?.source && item.source.state === 'OPEN') {
+    if (item?.source && wantedStates.has(item.source.state)) {
       // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
       const prBody = item.source.body || '';
       const prTitle = item.source.title || '';
@@ -58,9 +66,12 @@ export async function extractLinkedPullRequestsForIssue(issueData, issueNum, log
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {Array<number>} issueNumbers - Array of issue numbers to check
+ * @param {Object} [options]
+ * @param {Array<string>} [options.includeStates=['OPEN']] - PR states to report in `linkedPRs`
+ *   (issue #2160). `openPRCount` always counts only OPEN pull requests.
  * @returns {Promise<Object>} Object mapping issue numbers to their linked PRs
  */
-export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers) {
+export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers, { includeStates = ['OPEN'] } = {}) {
   try {
     if (!issueNumbers || issueNumbers.length === 0) {
       return {};
@@ -138,12 +149,14 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
             // Issue #1094: Only count PRs that explicitly fix/close/resolve this issue
             // This prevents false positives from PRs that only mention issues without solving them
             // Issue #1760: Draft PRs are still active solution drafts and must block duplicate work
-            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum);
+            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum, log, { includeStates });
 
             results[issueNum] = {
               title: issueData.title,
               state: issueData.state,
-              openPRCount: linkedPRs.length,
+              // Issue #2160: linkedPRs may now include merged/closed PRs for reporting, so the
+              // gate count has to be derived from the open ones only.
+              openPRCount: linkedPRs.filter(pr => pr.state === 'OPEN').length,
               linkedPRs: linkedPRs,
             };
           } else {
@@ -165,18 +178,25 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
 
         for (const issueNum of batch) {
           try {
-            const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --paginate --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null and .source.issue.state == "open")] | length'`;
+            // Issue #2160: return the PRs themselves, not just a count, so the end-of-run summary
+            // can name a merged solution draft even when GraphQL was unavailable.
+            const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --paginate --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null) | {number: .source.issue.number, title: .source.issue.title, body: .source.issue.body, state: (if .source.issue.pull_request.merged_at then "MERGED" else (.source.issue.state | ascii_upcase) end), isDraft: (.source.issue.draft // false), url: .source.issue.html_url}]'`;
 
             // #1756: route REST fallback through execGhWithRetry for transient 5xx + rate-limit
             const { stdout } = await execGhWithRetry(cmd, {
               execOptions: { encoding: 'utf8', env: process.env },
               label: `gh api timeline (issue #${issueNum})`,
             });
-            const openPrCount = parseInt(stdout.trim()) || 0;
+            const wantedStates = new Set(includeStates);
+            const crossReferenced = JSON.parse(stdout.trim() || '[]');
+            const linkedPRs = crossReferenced
+              .filter(pr => wantedStates.has(pr.state))
+              .filter(pr => prClosesIssue(pr.body || '', issueNum) || prClosesIssue(pr.title || '', issueNum))
+              .map(({ number, title, state, isDraft, url }) => ({ number, title, state, isDraft: Boolean(isDraft), url }));
 
             results[issueNum] = {
-              openPRCount: openPrCount,
-              linkedPRs: [], // REST API doesn't give us PR details easily
+              openPRCount: linkedPRs.filter(pr => pr.state === 'OPEN').length,
+              linkedPRs,
             };
           } catch (restError) {
             results[issueNum] = {

package/src/github.lib.mjs

@@ -579,7 +579,9 @@ ${logContent}
       if (useLargeFileMode) {
         await log(`  📁 Log file too large for inline comment (${Math.round(logStats.size / 1024 / 1024)}MB), using gh-upload-log`);
       } else {
-        await log(`  ⚠️  Log comment too long (${logComment.length} chars), GitHub limit is ${githubLimits.commentMaxSize} chars`);
+        // Issue #2160: this is the expected route for a long log, not a problem — the upload
+        // below handles it. Reporting it as a warning made every normal run look degraded.
+        await log(`  ℹ️  Log comment too long (${logComment.length} chars, GitHub limit is ${githubLimits.commentMaxSize} chars), using gh-upload-log`);
       }
       await log('  📎 Uploading log using gh-upload-log...');
       try {

package/src/hive.mjs

@@ -36,8 +36,11 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
 }
 export { createYargsConfig } from './hive.config.lib.mjs';
 import { attachChildExitHandlers } from './child-exit.lib.mjs';
+import { SUBSCRIPTION_BLOCKED_MARKER } from './subscription-error.lib.mjs'; // Issue #2161
 import { isDirectExecution, withTimeout } from './hive.bootstrap.lib.mjs';
 import { createShutdownManager } from './hive.shutdown.lib.mjs';
+// Issue #2160: keep dequeuing safe when the host disk fills up mid-run.
+import { EXIT_CODE_INSUFFICIENT_DISK_SPACE, ensureDiskSpaceForWorker, extractSolverWorkspacePaths } from './disk-guard.lib.mjs';
 const isRunningDirectly = isDirectExecution(process.argv[1], import.meta.url);
 if (isRunningDirectly) {
   console.log('🐝 Hive Mind - AI-powered issue solver');
@@ -602,6 +605,7 @@ if (isRunningDirectly) {
         this.processing = new Set();
         this.completed = new Set();
         this.failed = new Set();
+        this.deferrals = new Map(); // Issue #2160: issueUrl -> environment deferral count
         this.workers = [];
         this.isRunning = true;
       }
@@ -632,6 +636,18 @@ if (isRunningDirectly) {
         this.processing.delete(issueUrl);
         this.failed.add(issueUrl);
       }
+      // Issue #2160: put an issue back at the head of the queue after an *environment* block (a
+      // full host disk). It is neither completed nor failed — the task was never attempted.
+      // Returns how many times this issue has been deferred so the caller can stop looping.
+      requeue(issueUrl) {
+        this.processing.delete(issueUrl);
+        const deferrals = (this.deferrals.get(issueUrl) || 0) + 1;
+        this.deferrals.set(issueUrl, deferrals);
+        if (!this.completed.has(issueUrl) && !this.queue.includes(issueUrl)) {
+          this.queue.unshift(issueUrl);
+        }
+        return deferrals;
+      }
       // Get queue statistics
       getStats() {
         return {
@@ -653,6 +669,32 @@ if (isRunningDirectly) {
     // controlled SIGTERM to each (they run in their own detached process group, so the
     // terminal's SIGINT never reaches them); a *second* interrupt force-kills the groups.
     const activeSolveChildren = new Set();
+    // Issue #2160: workspaces owned by in-flight workers, learned from the solver's own output.
+    // The disk guard must never reclaim these — they hold work in progress.
+    const workerWorkspaces = new Map(); // workerId -> Set<workspace path>
+    const getProtectedWorkspacePaths = () => new Set(Array.from(workerWorkspaces.values()).flatMap(paths => Array.from(paths)));
+    // How long a worker waits for in-flight work to release disk space before deferring its task,
+    // and how many deferrals of one task are tolerated before hive stops: with nothing else
+    // running, no amount of waiting will free space.
+    const DISK_SPACE_WAIT_MS = 10 * 60 * 1000;
+    const MAX_DISK_SPACE_DEFERRALS = 3;
+    let diskSpaceHalt = null;
+    // Issue #2161: an account/subscription block is hive-wide, not per-issue. The
+    // credentials every worker shares have been refused, so each remaining issue
+    // would spin up a full solve run only to die the same way — burning clones,
+    // containers and PR comments while the queue drains into "failed". The first
+    // worker to see the marker in its child's output records it here and stops the
+    // queue; the rest exit as soon as their current child returns.
+    let subscriptionBlock = null;
+    const noteSubscriptionBlock = (workerId, line) => {
+      if (subscriptionBlock) return;
+      subscriptionBlock = { workerId, line: line.trim() };
+      log(`\n${SUBSCRIPTION_BLOCKED_MARKER} — worker ${workerId} reported that the account can no longer use the tool:`, { level: 'error' }).catch(() => {});
+      log(`   ${subscriptionBlock.line}`, { level: 'error' }).catch(() => {});
+      log('   Stopping the hive: every remaining issue would fail the same way until access is restored.', { level: 'error' }).catch(() => {});
+      log('   In-flight workers finish (and auto-commit their work) before the run ends.', { level: 'error' }).catch(() => {});
+      issueQueue.stop();
+    };
     // Worker function to process issues from queue
     async function worker(workerId) {
       await log(`🔧 Worker ${workerId} started`, { verbose: true });
@@ -673,8 +715,35 @@ if (isRunningDirectly) {
           await log(`   📊 Queue: ${stats.queued} waiting, ${stats.processing} processing, ${stats.completed} completed, ${stats.failed} failed`);
           continue;
         }
+        // Issue #2160: re-check free disk space before every task. hive used to check it once at
+        // startup, so a run whose kept workspaces filled the disk kept spawning solvers that died
+        // in their own pre-flight check — and each of those was counted as a *task* failure
+        // (`❌ 4 task(s) failed (completed: 6)`). Reclaim idle workspaces, wait for in-flight ones,
+        // and defer the task rather than burn it.
+        if (!argv.dryRun) {
+          const requiredDiskSpaceMB = argv.minDiskSpace || 10240;
+          const otherWorkInFlight = issueQueue.getStats().processing > 1;
+          const diskGuard = await ensureDiskSpaceForWorker({
+            requiredMB: requiredDiskSpaceMB,
+            protectedPaths: getProtectedWorkspacePaths(),
+            maxWaitMs: otherWorkInFlight ? DISK_SPACE_WAIT_MS : 0,
+            log,
+          });
+          if (!diskGuard.ok) {
+            const deferrals = issueQueue.requeue(issueUrl);
+            await log(`   ⏸️  Worker ${workerId} deferred ${issueUrl}: ${diskGuard.freeMB}MB free, ${requiredDiskSpaceMB}MB required (deferral ${deferrals}/${MAX_DISK_SPACE_DEFERRALS}, not a task failure)`, { level: 'warning' });
+            if (deferrals >= MAX_DISK_SPACE_DEFERRALS && issueQueue.getStats().processing === 0) {
+              diskSpaceHalt = `Insufficient disk space: ${diskGuard.freeMB}MB free, ${requiredDiskSpaceMB}MB required`;
+              await log('   🛑 Stopping: no in-flight work can release disk space. Free space on this host (or enable --auto-cleanup) and rerun.', { level: 'error' });
+              issueQueue.stop();
+            }
+            continue;
+          }
+        }
         // Track if this issue failed
         let issueFailed = false;
+        // Issue #2160: an environment block (full disk) reported by solve itself — requeue, don't fail.
+        let environmentDeferral = false;
         // Issue #1823: Track a graceful shutdown stop so it is neither failed nor completed.
         let gracefulStop = false;
         // Process the issue multiple times if needed
@@ -752,12 +821,20 @@ if (isRunningDirectly) {
               });
               // Issue #1823: register the in-flight child for optional force-kill on a 2nd signal
               activeSolveChildren.add(child);
+              // Issue #2160: start collecting the workspaces this worker owns so the disk guard
+              // (running in the other workers) never reclaims a directory that is still in use.
+              const ownedWorkspaces = new Set();
+              workerWorkspaces.set(workerId, ownedWorkspaces);
               log(`   🧒 Spawned ${solveCommand} worker-${workerId} (pid ${child.pid}, detached process group)`, { verbose: true }).catch(() => {});
               // Handle stdout data - stream output in real-time
               child.stdout.on('data', data => {
                 const lines = data.toString().split('\n');
                 for (const line of lines) {
                   if (line.trim()) {
+                    for (const workspacePath of extractSolverWorkspacePaths(line)) ownedWorkspaces.add(workspacePath);
+                    // Issue #2161: solve prints SUBSCRIPTION_BLOCKED_MARKER on a terminal
+                    // account block. Seen here, it stops the whole hive (see noteSubscriptionBlock).
+                    if (line.includes(SUBSCRIPTION_BLOCKED_MARKER)) noteSubscriptionBlock(workerId, line);
                     log(`   [${solveCommand} worker-${workerId}] ${line}`).catch(logError => {
                       reportError(logError, {
                         context: 'worker_stdout_log',
@@ -777,6 +854,7 @@ if (isRunningDirectly) {
                 const lines = data.toString().split('\n');
                 for (const line of lines) {
                   if (line.trim()) {
+                    if (line.includes(SUBSCRIPTION_BLOCKED_MARKER)) noteSubscriptionBlock(workerId, line); // Issue #2161
                     log(`   [${solveCommand} worker-${workerId} stderr] ${line}`).catch(logError => {
                       reportError(logError, {
                         context: 'worker_stderr_log',
@@ -798,6 +876,8 @@ if (isRunningDirectly) {
                 onLogError: (logError, operation) => reportError(logError, { context: 'worker_child_exit_log', workerId, operation }),
                 onExit: result => {
                   activeSolveChildren.delete(child); // Issue #1823: no longer in-flight
+                  // Issue #2160: the worker released its workspaces — they become reclaimable.
+                  workerWorkspaces.delete(workerId);
                   exitCode = result.exitCode;
                   resolve();
                 },
@@ -813,6 +893,20 @@ if (isRunningDirectly) {
               await log(`   🛑 Worker ${workerId} stopped gracefully during shutdown on ${issueUrl} (exit ${exitCode}, ${duration}s)`);
               gracefulStop = true;
               break; // stop processing more PRs for this issue
+            } else if (exitCode === EXIT_CODE_INSUFFICIENT_DISK_SPACE) {
+              // Issue #2160: solve refused to start because this host is out of disk space. The
+              // issue was never attempted, so it must not be counted as a task failure.
+              await log(`   ⏸️  Worker ${workerId} could not start ${issueUrl}: the host is out of disk space (exit ${exitCode}, ${duration}s) — requeued, not a task failure`, { level: 'warning' });
+              environmentDeferral = true;
+              break;
+            } else if (subscriptionBlock) {
+              // Issue #2161: the run did not fail because of this issue — the account
+              // lost access mid-flight. Report the real reason and stop; solve has
+              // already auto-committed whatever work existed.
+              await log(`   ${SUBSCRIPTION_BLOCKED_MARKER} Worker ${workerId} stopped on ${issueUrl} after ${duration}s: the tool account can no longer be used (exit ${exitCode}).`, { level: 'error' });
+              await log(`   Restore access, then re-run the hive — this issue stays queued, not failed.`, { level: 'error' });
+              gracefulStop = true;
+              break;
             } else {
               throw new Error(`${solveCommand} exited with code ${exitCode}`);
             }
@@ -838,7 +932,16 @@ if (isRunningDirectly) {
         // Only mark as completed if it didn't fail and wasn't gracefully stopped mid-shutdown.
         // Issue #1823: a graceful stop is neither a success nor a failure — leave it in
         // "processing" so it is not miscounted as completed (which would also trigger cleanup).
-        if (!issueFailed && !gracefulStop) {
+        if (environmentDeferral) {
+          // Issue #2160: back to the queue (neither completed nor failed). Stop the run when
+          // nothing else is in flight, since no other worker can release disk space.
+          const deferrals = issueQueue.requeue(issueUrl);
+          if (deferrals >= MAX_DISK_SPACE_DEFERRALS && issueQueue.getStats().processing === 0) {
+            diskSpaceHalt = 'Insufficient disk space reported by the solver pre-flight check';
+            await log('   🛑 Stopping: no in-flight work can release disk space. Free space on this host (or enable --auto-cleanup) and rerun.', { level: 'error' });
+            issueQueue.stop();
+          }
+        } else if (!issueFailed && !gracefulStop) {
           issueQueue.markCompleted(issueUrl);
         }
         // Show queue stats
@@ -1256,10 +1359,22 @@ if (isRunningDirectly) {
       // Perform cleanup if enabled and there were successful completions
       const finalStats = issueQueue.getStats();
       if (finalStats.completed > 0) {
-        await cleanupTempDirectories();
+        // Issue #2160: argv must be forwarded — cleanupTempDirectories returns immediately
+        // without it, so this branch used to be a silent no-op even with --auto-cleanup.
+        await cleanupTempDirectories(argv);
       }
       await log('\n👋 Hive Mind monitoring stopped');
       await log(`   📁 Full log file: ${absoluteLogPath}`);
+      // Issue #2161: the hive did not simply "finish" — it was cut short because the
+      // account lost access. Say so last (that is what a human scrolls to) and exit
+      // non-zero so supervisors and the Telegram monitor report a failure, not a
+      // clean completion.
+      if (subscriptionBlock) {
+        await log(`\n${SUBSCRIPTION_BLOCKED_MARKER} Hive stopped early: the tool account can no longer be used.`, { level: 'error' });
+        await log(`   Reported by worker ${subscriptionBlock.workerId}: ${subscriptionBlock.line}`, { level: 'error' });
+        await log('   Restore subscription/account access, then start the hive again.', { level: 'error' });
+        await safeExit(1, 'Subscription/account access blocked');
+      }
     }
     // Issue #1823: Graceful-shutdown + force-kill logic lives in hive.shutdown.lib.mjs.
     // gracefulShutdown waits (uncapped) for in-flight solve workers to finish on the first
@@ -1292,16 +1407,20 @@ if (isRunningDirectly) {
         verbose: true,
       });
     } else {
-      const systemCheck = await checkSystem(
-        {
-          minDiskSpaceMB: argv.minDiskSpace || 10240,
-          minMemoryMB: 256,
-          exitOnFailure: true,
-        },
-        { log }
-      );
+      // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
+      // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
+      // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
+      // directly, which skips the log-flushing safeExit path and printed no actionable reason.
+      const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
+      const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
+      if (!startupDiskGuard.ok) {
+        await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
+        await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
+        await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
+      }
+      const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
       if (!systemCheck.success) {
-        await safeExit(1, 'Error occurred');
+        await safeExit(1, 'System resource check failed');
       }
       // Validate the selected AI tool connection before starting monitoring with the same model that will be used
       const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
@@ -1326,6 +1445,12 @@ if (isRunningDirectly) {
     }
     const finalStats = issueQueue.getStats(); // Issue #1718: surface worker failures via exit code
     if (finalStats.failed > 0) await safeExit(1, `${finalStats.failed} task(s) failed (completed: ${finalStats.completed})`);
+    // Issue #2160: report an exhausted host disk as the environment problem it is, with its own
+    // exit code, instead of letting it be counted as "N task(s) failed". Genuine task failures are
+    // reported first above, because they say more about the run than the environment condition.
+    if (diskSpaceHalt) {
+      await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `${diskSpaceHalt} — ${finalStats.completed} task(s) completed, ${finalStats.queued} left queued (no task failures)`);
+    }
   } catch (fatalError) {
     // Handle fatal errors during initialization or execution
     console.error('\n❌ Fatal error occurred during hive initialization or execution');

package/src/lib.mjs

@@ -950,9 +950,16 @@ export const displayFormattedError = async options => {
 };
 
 /**
- * Clean up temporary directories
+ * Clean up temporary directories.
+ *
+ * Issue #2160: this used to run `sudo rm -rf /tmp/* /var/tmp/*`, which also wipes the workspaces,
+ * lock directories and logs of any *concurrent* hive/solve process on the same host. The entries
+ * are now enumerated first and anything a live process is sitting in (or that the caller protects)
+ * is left alone.
+ *
  * @param {Object} argv - Command line arguments
  * @param {boolean} [argv.autoCleanup] - Whether auto-cleanup is enabled
+ * @param {Iterable<string>} [argv.protectedTempPaths] - Paths this run still needs
  * @returns {Promise<void>}
  */
 export const cleanupTempDirectories = async argv => {
@@ -962,13 +969,26 @@ export const cleanupTempDirectories = async argv => {
 
   // Dynamic import for command-stream
   const { $ } = await use('command-stream');
+  const { listCleanableTempEntries } = await import('./disk-guard.lib.mjs');
+  const path = await use('path');
 
   try {
     await log('\n🧹 Auto-cleanup enabled, removing temporary directories...');
-    await log('   ⚠️  Executing: sudo rm -rf /tmp/* /var/tmp/*', { verbose: true });
+    const protectedPaths = new Set(argv.protectedTempPaths || []);
+    const currentLogFile = getLogFile();
+    if (currentLogFile) protectedPaths.add(path.resolve(currentLogFile));
+    const { remove, keep } = await listCleanableTempEntries({ protectedPaths });
+    for (const kept of keep) {
+      await log(`   🔒 Keeping ${kept.path} (${kept.reason === 'process_cwd' ? 'a live process is using it' : 'needed by this run'})`, { verbose: true });
+    }
+    if (remove.length === 0) {
+      await log('   ✅ Nothing to clean: every temporary entry is still in use');
+      return;
+    }
+    await log(`   ⚠️  Executing: sudo rm -rf on ${remove.length} temporary entr${remove.length === 1 ? 'y' : 'ies'} (${keep.length} kept)`, { verbose: true });
 
     // Execute cleanup command using command-stream
-    const cleanupCommand = $`sudo rm -rf /tmp/* /var/tmp/*`;
+    const cleanupCommand = $`sudo rm -rf ${remove}`;
 
     let exitCode = 0;
     for await (const chunk of cleanupCommand.stream()) {

package/src/limits-i18n.lib.mjs

@@ -85,6 +85,14 @@ const ENGLISH_LIMITS = {
   subscription_detail_trial_ends: 'trial ends {{time}}',
   subscription_detail_trial_ends_in: 'trial ends in {{duration}}; {{time}}',
   subscription_status: 'Subscription: {{status}}',
+  subscription_blocked_title: 'Subscription/account access blocked',
+  subscription_blocked_provider: 'Provider said',
+  subscription_blocked_code: 'Error code',
+  subscription_blocked_reason: 'Why the run stopped',
+  subscription_blocked_note: 'This is not a usage limit: waiting, retrying or switching model cannot fix it.',
+  subscription_blocked_steps: 'What to do',
+  subscription_blocked_preserved: 'Uncommitted work was auto-committed before stopping.',
+  subscription_blocked_resume: 'Resume after access is restored',
   telegram_api: 'Telegram Bot API',
   telegram_flood_control: 'flood control',
   telegram_last_rate_limit: 'Last 429: {{method}}',

package/src/list-solution-drafts.lib.mjs

@@ -1,8 +1,15 @@
 /**
  * Solution Drafts Listing Module
  * Displays completed issues with their linked pull requests
+ *
+ * Issue #2160: this listing used to ask only for OPEN pull requests, so every issue whose draft
+ * `--auto-merge` had already merged was reported as "(no PR found)" — a false negative in the
+ * summary a human reads to judge the run. Merged and closed drafts are now listed with their state.
  */
 
+/** Pull request states worth reporting at the end of a run, in the order they are most useful. */
+const REPORTED_PULL_REQUEST_STATES = ['OPEN', 'MERGED', 'CLOSED'];
+
 /**
  * Lists all completed issues with their solution drafts (PRs)
  * @param {Object} issueQueue - The issue queue containing completed issues
@@ -10,10 +17,12 @@
  * @param {Function} batchCheckPullRequestsForIssues - Function to batch check PRs for issues
  */
 export async function listSolutionDrafts(issueQueue, log, batchCheckPullRequestsForIssues) {
-  if (!issueQueue.completed || issueQueue.completed.length === 0) return;
+  // `completed` is a Set in hive.mjs, but callers/tests may pass an array.
+  const completedUrls = issueQueue?.completed ? Array.from(issueQueue.completed) : [];
+  if (completedUrls.length === 0) return;
   await log('\n📋 Issues with solution drafts:');
   const byRepo = {};
-  for (const url of issueQueue.completed) {
+  for (const url of completedUrls) {
     const m = url.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
     if (m) (byRepo[`${m[1]}/${m[2]}`] ||= { owner: m[1], repo: m[2], iss: [] }).iss.push({ n: +m[3], url });
   }
@@ -21,12 +30,16 @@ export async function listSolutionDrafts(issueQueue, log, batchCheckPullRequests
     const prs = await batchCheckPullRequestsForIssues(
       r.owner,
       r.repo,
-      r.iss.map(i => i.n)
+      r.iss.map(i => i.n),
+      { includeStates: REPORTED_PULL_REQUEST_STATES }
     );
     for (const i of r.iss)
       if (prs[i.n]?.linkedPRs?.length) {
         await log(`   - ${i.url}`);
-        for (const p of prs[i.n].linkedPRs) await log(`     → PR #${p.number}: ${p.url}`);
+        for (const p of prs[i.n].linkedPRs) {
+          const state = p.state && p.state !== 'OPEN' ? ` (${p.state.toLowerCase()})` : '';
+          await log(`     → PR #${p.number}${state}: ${p.url}`);
+        }
       } else await log(`   - ${i.url} (no PR found)`);
   }
 }

package/src/locales/en.lino

@@ -322,6 +322,15 @@ en
     session "session"
     start "Start"
     subscription
+      blocked
+        title "Subscription/account access blocked"
+        provider "Provider said"
+        code "Error code"
+        reason "Why the run stopped"
+        note "This is not a usage limit: waiting, retrying or switching model cannot fix it."
+        steps "What to do"
+        preserved "Uncommitted work was auto-committed before stopping."
+        resume "Resume after access is restored"
       detail
         ends
           label "ends {{time}}"
@@ -746,6 +755,7 @@ en
                - When you execute commands and the output becomes large, save the logs to files for easier review.
                - When running commands, avoid setting a timeout yourself. Let them run as long as needed. The default timeout of 2 minutes is usually enough, and once commands finish, review the logs in the file.
                - When running sudo commands, especially package installations like apt-get, yum, or npm install, run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.
+               - When you need to wait for something (CI checks, a background job, a deploy), do not run a long foreground `sleep`: agent harnesses block it ("Blocked: sleep 240 followed by: ..."). Poll instead with a short until-loop (e.g. `until <check>; do sleep 10; done`) or re-check the condition on your next step.
           """
         purpose
           subagent "   - When the task is large and requires processing many files or folders, use `general-purpose` sub-agents to delegate work. Each separate file or folder can be delegated to a sub-agent for more efficient processing."

package/src/locales/hi.lino

@@ -322,6 +322,15 @@ hi
     session "सत्र"
     start "शुरुआत"
     subscription
+      blocked
+        title "सदस्यता/खाता पहुँच अवरुद्ध"
+        provider "प्रदाता ने कहा"
+        code "त्रुटि कोड"
+        reason "रन क्यों रुका"
+        note "यह उपयोग सीमा नहीं है: प्रतीक्षा, पुनः प्रयास या मॉडल बदलना इसे ठीक नहीं करेगा।"
+        steps "क्या करें"
+        preserved "रुकने से पहले बिना कमिट किए बदलाव स्वतः कमिट कर दिए गए।"
+        resume "पहुँच बहाल होने पर फिर से शुरू करें"
       detail
         ends
           label "{{time}} को समाप्त होगी"
@@ -746,6 +755,7 @@ hi
                - जब आप कमांड चलाते हैं और आउटपुट बड़ा हो जाता है, तो आसान समीक्षा के लिए लॉग को फ़ाइलों में सहेजें।
                - जब आप कमांड चलाते हैं, तो स्वयं टाइमआउट सेट न करें। उन्हें जितना आवश्यक हो उतना चलने दें। डिफ़ॉल्ट 2 मिनट का टाइमआउट आमतौर पर पर्याप्त होता है, और कमांड समाप्त होने के बाद फ़ाइल में लॉग की समीक्षा करें।
                - जब आप sudo कमांड चलाते हैं, विशेष रूप से apt-get, yum, या npm install जैसी पैकेज स्थापना, तो टाइमआउट और प्रोसेस को मारने पर अनुमति त्रुटियों से बचने के लिए उन्हें पृष्ठभूमि में चलाएँ। run_in_background पैरामीटर का उपयोग करें या कमांड के अंत में & जोड़ें।
+               - जब आपको किसी चीज़ की प्रतीक्षा करनी हो (CI जाँच, पृष्ठभूमि कार्य, डिप्लॉय), तो लंबा `sleep` अग्रभूमि में न चलाएँ: एजेंट हार्नेस उसे रोक देते हैं ("Blocked: sleep 240 followed by: ...")। इसके बजाय छोटे अंतराल वाले until लूप से पोलिंग करें (उदाहरण: `until <जाँच>; do sleep 10; done`) या अगले चरण में स्थिति फिर से जाँचें।
           """
         purpose
           subagent "   - जब कार्य बड़ा हो और कई फ़ाइलों या फ़ोल्डरों के प्रसंस्करण की आवश्यकता हो, तो कार्य सौंपने के लिए `general-purpose` sub-agents का उपयोग करें। प्रत्येक अलग फ़ाइल या फ़ोल्डर को अधिक कुशल प्रसंस्करण के लिए एक sub-agent को सौंपा जा सकता है।"

package/src/locales/ru.lino

@@ -322,6 +322,15 @@ ru
     session "сеанс"
     start "Начало"
     subscription
+      blocked
+        title "Доступ по подписке/аккаунту заблокирован"
+        provider "Ответ провайдера"
+        code "Код ошибки"
+        reason "Почему запуск остановлен"
+        note "Это не лимит использования: ожидание, повтор или смена модели не помогут."
+        steps "Что делать"
+        preserved "Незакоммиченные изменения были автоматически закоммичены перед остановкой."
+        resume "Продолжить после восстановления доступа"
       detail
         ends
           label "заканчивается {{time}}"
@@ -746,6 +755,7 @@ ru
                - Когда выполняешь команды и вывод становится большим, сохраняй логи в файлы для удобного просмотра.
                - Когда запускаешь команды, не задавай таймаут самостоятельно. Дай им работать столько, сколько нужно. Стандартного таймаута в 2 минуты обычно достаточно, и после завершения команды просмотри логи в файле.
                - Когда запускаешь команды sudo, особенно установку пакетов вроде apt-get, yum или npm install, запускай их в фоне, чтобы избежать таймаутов и ошибок прав доступа при необходимости остановить процесс. Используй параметр run_in_background или добавляй & в конце команды.
+               - Когда нужно чего-то дождаться (проверок CI, фоновой задачи, деплоя), не запускай длинный `sleep` в основном потоке: агентные окружения блокируют его ("Blocked: sleep 240 followed by: ..."). Вместо этого опрашивай состояние коротким циклом until (например, `until <проверка>; do sleep 10; done`) или проверяй условие заново на следующем шаге.
           """
         purpose
           subagent "   - Когда задача большая и требует обработки многих файлов или папок, используй `general-purpose` суб-агентов, чтобы делегировать работу. Каждый отдельный файл или папка может быть делегирован суб-агенту для более эффективной обработки."

package/src/locales/zh.lino

@@ -322,6 +322,15 @@ zh
     session "会话"
     start "开始"
     subscription
+      blocked
+        title "订阅/账号访问被阻止"
+        provider "服务方提示"
+        code "错误代码"
+        reason "运行停止的原因"
+        note "这不是用量限制：等待、重试或切换模型都无法解决。"
+        steps "如何处理"
+        preserved "停止前已自动提交未提交的改动。"
+        resume "恢复访问后继续"
       detail
         ends
           label "结束于 {{time}}"
@@ -746,6 +755,7 @@ zh
                - 当你执行的命令输出变得很大时，将日志保存到文件以便复查。
                - 当你运行命令时，不要自行设置超时。让它们按需运行。默认 2 分钟超时通常足够，命令完成后再查看文件中的日志。
                - 当你运行 sudo 命令（尤其是 apt-get、yum 或 npm install 等包安装）时，请在后台运行以避免超时和需要终止进程时的权限错误。使用 run_in_background 参数或在命令末尾追加 &。
+               - 当你需要等待某件事（CI 检查、后台任务、部署）时，不要在前台运行长时间的 `sleep`：智能体运行环境会拦截它（"Blocked: sleep 240 followed by: ..."）。请改用短间隔的 until 轮询循环（例如 `until <检查>; do sleep 10; done`），或在下一步重新检查条件。
           """
         purpose
           subagent "   - 当任务很大且需要处理许多文件或文件夹时，使用 `general-purpose` 子代理来委派工作。每个单独的文件或文件夹都可以委派给一个子代理以更高效地处理。"

package/src/session-log-rename.lib.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Session log renaming (Issue #2160)
+ *
+ * When an AI tool reports its session id, the run log is renamed to `<sessionId>.log` so that
+ * the log file can be correlated with the tool session. The logic used to live inline in
+ * src/claude.lib.mjs and depended on `getLogFile`/`setLogFile` being forwarded through every
+ * caller. Restart/watch iterations (src/solve.restart-shared.lib.mjs) either omitted those
+ * parameters or passed no-op stubs, which produced this on every restart iteration:
+ *
+ *   ⚠️ Could not rename log file: getLogFile is not a function
+ *
+ * Extracting the logic makes the failure mode explicit (a named reason instead of a TypeError)
+ * and testable.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2160
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Rename the current log file to `<sessionId>.log`.
+ *
+ * Never throws: every failure is returned as `{ ok: false, reason }` so callers can log it.
+ *
+ * @param {Object} params
+ * @param {string} params.sessionId - Session id reported by the AI tool
+ * @param {Function} params.getLogFile - Accessor returning the current log file path
+ * @param {Function} params.setLogFile - Accessor updating the current log file path
+ * @param {Function} [params.log] - Async logger
+ * @param {Object} [params.fileSystem] - Injectable fs.promises replacement (tests)
+ * @returns {Promise<{ok: boolean, reason?: string, error?: Error, sessionLogFile?: string}>}
+ */
+export const renameLogToSessionId = async ({ sessionId, getLogFile, setLogFile, log, fileSystem = fs }) => {
+  if (!sessionId) return { ok: false, reason: 'missing_session_id' };
+  if (typeof getLogFile !== 'function' || typeof setLogFile !== 'function') {
+    // Issue #2160: a caller that forgot to forward the accessors. Report it as a real defect
+    // instead of surfacing "getLogFile is not a function" as a mysterious warning.
+    if (log) await log('⚠️ Could not rename log file: log file accessors were not provided by the caller', { verbose: true });
+    return { ok: false, reason: 'missing_log_file_accessors' };
+  }
+
+  const currentLogFile = getLogFile();
+  if (!currentLogFile) {
+    if (log) await log('⚠️ Could not rename log file: no current log file is configured', { verbose: true });
+    return { ok: false, reason: 'no_current_log_file' };
+  }
+
+  const sessionLogFile = path.join(path.dirname(currentLogFile), `${sessionId}.log`);
+  if (sessionLogFile === currentLogFile) return { ok: true, reason: 'already_named', sessionLogFile };
+
+  try {
+    await fileSystem.rename(currentLogFile, sessionLogFile);
+    setLogFile(sessionLogFile);
+    if (log) await log(`📁 Log renamed to: ${sessionLogFile}`);
+    return { ok: true, sessionLogFile };
+  } catch (error) {
+    if (log) await log(`⚠️ Could not rename log file: ${error.message}`, { verbose: true });
+    return { ok: false, reason: 'rename_failed', error, sessionLogFile };
+  }
+};
+
+export default { renameLogToSessionId };