@link-assistant/hive-mind 2.12.5 → 2.13.1

package/src/session-monitor.lib.mjs

@@ -389,6 +389,35 @@ export async function buildDiskDiagnosticsExtraSection(logPath, { verbose = fals
     return '';
   }
 }
+/**
+ * Issue #2161: Replay the `🚫 SUBSCRIPTION/ACCESS BLOCKED` report from the
+ * captured solve log into the Telegram completion message, so the operator is
+ * told that the account itself lost access (and not that "claude failed") on the
+ * surface they actually watch. Returns '' when the session hit no such block.
+ */
+export async function buildSubscriptionBlockedExtraSection(logPath, { verbose = false, readFile = fs.readFile, locale = null } = {}) {
+  if (!logPath) return '';
+  try {
+    let logText = '';
+    try {
+      logText = await readFile(logPath, 'utf8');
+    } catch (readError) {
+      if (verbose) {
+        console.log(`[VERBOSE] Could not read session log ${logPath} for subscription block: ${readError?.message || readError}`);
+      }
+      return '';
+    }
+    const telegramLib = await import('./subscription-block-telegram.lib.mjs');
+    const parsed = telegramLib.parseSubscriptionBlockFromLog(logText);
+    if (!parsed) return '';
+    return telegramLib.formatSubscriptionBlockedSection(parsed, { locale });
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] Could not build subscription block section for ${logPath}: ${error?.message || error}`);
+    }
+    return '';
+  }
+}
 async function getDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, { verbose = false, sizeProvider = null } = {}) {
   if (sessionInfo?.isolationBackend !== 'docker') return null;
   const containerName = sessionInfo.sessionId || sessionName;
@@ -826,6 +855,21 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           }
         }
         const dockerTaskContainerExtraSections = dockerTaskContainerAction?.extraSection ? [dockerTaskContainerAction.extraSection] : [];
+        // Issue #2161: a blocked subscription/account explains every other
+        // symptom of the run, so it goes first in the completion message.
+        const subscriptionBlockedExtraSections = [];
+        try {
+          const blockedSection = await buildSubscriptionBlockedExtraSection(statusResult?.logPath || sessionInfo?.logPath || null, {
+            verbose,
+            readFile: options.readFile,
+            locale: sessionInfo?.locale || null,
+          });
+          if (blockedSection) subscriptionBlockedExtraSections.push(blockedSection);
+        } catch (blockedError) {
+          if (verbose) {
+            console.log(`[VERBOSE] Could not build subscription block section for ${sessionName}: ${blockedError?.message || blockedError}`);
+          }
+        }
         // Issue #2134: say exactly WHY a session was killed, and warn when a
         // session merely survived a kill event instead of reporting a plain
         // success. The pull request gets the very same report below.
@@ -869,7 +913,7 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           infoBlock: sessionInfo?.infoBlock || '',
           pullRequestUrl,
           pullRequestState,
-          extraSections: [...limitsExtraSections, ...killReport.sections, ...resumeExtraSections, ...diskExtraSections, ...dockerTaskContainerExtraSections],
+          extraSections: [...subscriptionBlockedExtraSections, ...limitsExtraSections, ...killReport.sections, ...resumeExtraSections, ...diskExtraSections, ...dockerTaskContainerExtraSections],
         });
         if (killReport.killed || killReport.recovered) {
           const notice = await announceKillOnPullRequest({

package/src/solve.mjs

@@ -19,7 +19,9 @@ const fs = (await use('fs')).promises;
 const crypto = (await use('crypto')).default;
 const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
-const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, formatToolExecutionFailure, getVersionInfo, logSolveStartup, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
+const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, formatToolExecutionFailure, extractToolErrorCore, getVersionInfo, logSolveStartup, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
+// Issue #2161: terminal subscription/account-access blocks.
+const { detectSubscriptionError, formatSubscriptionErrorReport, formatSubscriptionErrorSummary, SUBSCRIPTION_BLOCKED_MARKER } = await import('./subscription-error.lib.mjs');
 const githubLib = await import('./github.lib.mjs');
 const { sanitizeLogContent, attachLogToGitHub, getToolDisplayName } = githubLib;
 const validation = await import('./solve.validation.lib.mjs');
@@ -221,6 +223,15 @@ const skipToolConnectionCheck = prepareOnly || argv.skipToolConnectionCheck || a
 const { cascadePlaywrightMcpDisable, ensureSolvePlaywrightMcpReady } = await import('./playwright-mcp.lib.mjs');
 await cascadePlaywrightMcpDisable(argv, log);
 if (!(await performSystemChecks(argv.minDiskSpace || 10240, skipToolConnectionCheck, argv.model, argv))) {
+  // Issue #2160: an exhausted host disk is an environment condition, not a defect in the issue.
+  // Exit with EX_TEMPFAIL (75) so an orchestrator can requeue the task, and skip the pre-exit
+  // notifier: posting "🚨 Solution Draft Failed — Reason: System checks failed" on the target
+  // repository's issue told its maintainers nothing they could act on.
+  if (argv.systemCheckFailure?.check === 'disk-space') {
+    const { EXIT_CODE_INSUFFICIENT_DISK_SPACE } = await import('./disk-guard.lib.mjs');
+    const { availableMB, requiredMB } = argv.systemCheckFailure;
+    await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space on this host (${availableMB}MB available, ${requiredMB}MB required) — the issue itself was not attempted`, { skipPreExit: true });
+  }
   await safeExit(1, 'System checks failed');
 }
 // Playwright MCP preflight is local/free and stays independent from paid tool connection checks.
@@ -269,6 +280,9 @@ const { isPublic: isRepoPublic } = await detectRepositoryVisibility(owner, repo)
 if (argv.autoCleanup === undefined) {
   // For public repos: keep temp directories (default false) For private repos: clean up temp directories (default true)
   argv.autoCleanup = !isRepoPublic;
+  // Issue #2160: remember that this was a default, not a flag, so the "keeping directory"
+  // message at the end of the session can say why the workspace is being kept.
+  argv.autoCleanupSource = 'repository-visibility-default';
   if (argv.verbose) {
     await log(`   Auto-cleanup default: ${argv.autoCleanup} (repository is ${isRepoPublic ? 'public' : 'private'})`, {
       verbose: true,
@@ -1000,6 +1014,15 @@ try {
     const toolForFailure = argv.tool || 'claude';
     // Issue #1845: surface the core error instead of just "<TOOL> execution failed" (terminal + comment).
     const toolFailureMessage = formatToolExecutionFailure({ tool: toolForFailure, toolResult });
+    // Issue #2161: an account/subscription block ("Your organization has disabled
+    // Claude subscription access for Claude Code", a revoked OAuth token, an
+    // expired plan) is terminal — the run must stop, say precisely what happened
+    // and preserve the work, instead of ending on a bare "<TOOL> execution failed
+    // with <provider sentence>". Adapters that parse structured provider codes
+    // (claude.lib.mjs) hand the classification over directly; for every other tool
+    // the rendered message is re-classified here, so the whole failure surface is
+    // covered by one chokepoint.
+    const subscriptionInfo = toolResult?.subscriptionError || detectSubscriptionError({ message: extractToolErrorCore({ toolResult }) || toolFailureMessage, tool: toolForFailure });
     if (sessionId) {
       await log('');
       await log('💡 To continue this session:');
@@ -1014,15 +1037,32 @@ try {
       await log('');
     }
     // Preserve work before remote diagnostics; issue #2101 ended during log upload.
+    let preservedWork = null;
     try {
       const { criticalErrorRecovery } = await import('./config.lib.mjs');
       if (criticalErrorRecovery.autoCommitUncommittedChanges) {
         const { commitUncommittedChangesOnCriticalError } = await import('./critical-error-commit.lib.mjs');
-        await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: toolFailureMessage });
+        // Issue #2161: when the subscription is gone it is unknown whether/when it
+        // will be restored, so the emergency commit is the only thing standing
+        // between the operator and hours of lost work — name it as such.
+        preservedWork = await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: subscriptionInfo ? formatSubscriptionErrorSummary(subscriptionInfo, { tool: toolForFailure }) : toolFailureMessage });
       }
     } catch (preserveError) {
       await log(`  ⚠️  Could not auto-commit before failure exit: ${preserveError.message}`, { verbose: true });
     }
+    // Issue #2161: printed after the emergency commit so the block can state
+    // whether the work was preserved. This is the message the operator reads.
+    if (subscriptionInfo) {
+      const reportLines = formatSubscriptionErrorReport(subscriptionInfo, {
+        tool: toolForFailure,
+        sessionId,
+        tempDir,
+        branchName,
+        committed: preservedWork ? preservedWork.committed : null,
+        resumeCommand: sessionId && argv.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: toolForFailure, model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null,
+      });
+      for (const line of reportLines) await log(line, { level: 'error' });
+    }
     // Attach failure logs before exiting (Issues #1212, #1462: fall back to issue if no PR)
     const hasPR = global.createdPR && global.createdPR.number;
     const hasIssue = global.issueNumber;
@@ -1052,7 +1092,9 @@ try {
           // Include sessionId so the PR comment can present it
           sessionId,
           // If not a usage limit case, fall back to generic failure format
-          errorMessage: limitReached ? undefined : toolFailureMessage,
+          // Issue #2161: the PR/issue comment gets the diagnosis + the remediation
+          // steps too — whoever finds the run in the morning reads that, not the log.
+          errorMessage: limitReached ? undefined : subscriptionInfo ? [formatSubscriptionErrorSummary(subscriptionInfo, { tool: toolForFailure }), '', ...(subscriptionInfo.guidance || []).map(step => `- ${step}`)].join('\n') : toolFailureMessage,
           argv,
           requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
@@ -1070,7 +1112,9 @@ try {
         await log(`  ⚠️  Error uploading failure logs: ${uploadError.message}`);
       }
     }
-    await safeExit(1, toolFailureMessage);
+    // Issue #2161: the exit message is what /hive and the session monitor see, so
+    // it carries the marker rather than the generic tool-failure sentence.
+    await safeExit(1, subscriptionInfo ? `${SUBSCRIPTION_BLOCKED_MARKER} — ${formatSubscriptionErrorSummary(subscriptionInfo, { tool: toolForFailure })}` : toolFailureMessage);
   }
   // Clean up .playwright-mcp/ to prevent browser artifacts from triggering auto-restart (Issue #1124)
   if (argv.playwrightMcpAutoCleanup !== false) {

package/src/solve.repository.lib.mjs

@@ -1338,6 +1338,10 @@ export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
   } else if (limitReached) {
     await log(`\n📁 Keeping directory for future resume: ${tempDir}`);
   } else if (!argv.autoCleanup) {
-    await log(`\n📁 Keeping directory (--no-auto-cleanup): ${tempDir}`);
+    // Issue #2160: `--no-auto-cleanup` is only one of the two ways to get here. On a public
+    // repository auto-cleanup defaults to off, and reporting a flag that was never passed made
+    // the run log misleading — the disk kept filling with no hint of why.
+    const reason = argv.autoCleanupSource === 'repository-visibility-default' ? 'auto-cleanup is off by default for public repositories' : '--no-auto-cleanup';
+    await log(`\n📁 Keeping directory (${reason}): ${tempDir}`);
   }
 };

package/src/solve.restart-shared.lib.mjs

@@ -30,7 +30,10 @@ const fs = (await use('fs')).promises;
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, formatAligned, extractToolErrorCore } = lib;
+// Issue #2160: the real log-file accessors must be forwarded to every tool executor. Passing
+// no-op stubs (or omitting them entirely) broke session-log renaming in restart/watch iterations
+// ("⚠️ Could not rename log file: getLogFile is not a function").
+const { log, formatAligned, extractToolErrorCore, getLogFile, setLogFile } = lib;
 const { ensurePullRequestBaseBranch } = await import('./solve.pr-base-guard.lib.mjs');
 const { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } = await import('./ai-tool-scratch.lib.mjs');
 const { RESOURCE_PHASE_RESTART_AFTER, RESOURCE_PHASE_RESTART_BEFORE, recordResourceSnapshot } = await import('./solve.resource-diagnostics.lib.mjs');
@@ -240,8 +243,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       $,
     });
   } else if (argv.tool === 'opencode') {
@@ -280,6 +283,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       opencodePath,
       $,
     });
@@ -318,8 +323,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       codexPath,
@@ -362,6 +367,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       agentPath,
       $,
     });
@@ -400,8 +407,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       geminiPath,
@@ -442,8 +449,8 @@ export const executeToolIteration = async params => {
       repo,
       argv,
       log,
-      setLogFile: () => {},
-      getLogFile: () => '',
+      setLogFile,
+      getLogFile,
       formatAligned,
       getResourceSnapshot,
       qwenPath,
@@ -488,6 +495,8 @@ export const executeToolIteration = async params => {
       log,
       formatAligned,
       getResourceSnapshot,
+      setLogFile,
+      getLogFile,
       claudePath,
       $,
     });

package/src/solve.results.lib.mjs

@@ -485,12 +485,15 @@ export const cleanupClaudeFile = async (tempDir, branchName, claudeCommitHash =
     const verifyResult = await $({ cwd: tempDir })`git ls-files ${fileName} 2>&1`;
     const fileStillExists = verifyResult.code === 0 && verifyResult.stdout && verifyResult.stdout.trim();
     if (fileStillExists) {
-      await log(`   ⚠️  WARNING: ${fileName} still exists after cleanup — attempting direct removal...`);
-      // Check if the file existed before the initial commit (parent)
+      // Issue #2160: the pre-existence check must come FIRST. A file that legitimately predates
+      // the session is not a cleanup failure, and warning about it produced a false positive
+      // ("⚠️ WARNING: .gitkeep still exists after cleanup" immediately followed by
+      // "ℹ️ .gitkeep existed before this session — keeping pre-existing file").
       const parentCommit = `${claudeCommitHash}~1`;
       const parentFileExists = await $({ cwd: tempDir })`git cat-file -e ${parentCommit}:${fileName} 2>&1`;
       if (parentFileExists.code !== 0) {
-        // File didn't exist before the session — force remove it
+        // File didn't exist before the session — this is a real leftover, force remove it
+        await log(`   ⚠️  WARNING: ${fileName} still exists after cleanup — attempting direct removal...`);
         await $({ cwd: tempDir })`git rm -f ${fileName} 2>&1`;
         const fallbackCommit = await $({ cwd: tempDir })`git commit -m "Remove leftover ${fileName} (post-cleanup fallback, Issue #1436)" 2>&1`;
         if (fallbackCommit.code === 0) {

package/src/solve.validation.lib.mjs

@@ -53,12 +53,6 @@ const { parseResetTime: parseResetTimeToDate } = usageLimitLib;
 
 const { validateClaudeConnection } = claudeLib;
 
-// Wrapper function for disk space check using imported module
-const checkDiskSpace = async (minSpaceMB = 10240) => {
-  const result = await memoryCheck.checkDiskSpace(minSpaceMB, { log });
-  return result.success;
-};
-
 // Wrapper function for memory check using imported module
 const checkMemory = async (minMemoryMB = 256) => {
   const result = await memoryCheck.checkMemory(minMemoryMB, { log });
@@ -217,9 +211,13 @@ export const validateContinueOnlyOnFeedback = async (argv, isPrUrl, isIssueUrl)
 // Note: skipToolConnection only skips the connection check, not model validation
 // Model validation should be done separately before calling this function
 export const performSystemChecks = async (minDiskSpace = 10240, skipToolConnection = false, model = 'sonnet', argv = {}) => {
-  // Check disk space before proceeding
-  const hasEnoughSpace = await checkDiskSpace(minDiskSpace);
-  if (!hasEnoughSpace) {
+  // Check disk space before proceeding.
+  // Issue #2160: record *which* check failed on argv. A full disk says nothing about the issue
+  // being solved, so the caller exits with a retry-later code and skips the "Solution Draft
+  // Failed" comment instead of blaming the task (hive counted 4 such exits as task failures).
+  const diskSpace = await memoryCheck.checkDiskSpace(minDiskSpace, { log });
+  if (!diskSpace.success) {
+    argv.systemCheckFailure = { check: 'disk-space', availableMB: diskSpace.availableMB, requiredMB: minDiskSpace };
     return false;
   }
 

package/src/subscription-block-telegram.lib.mjs

@@ -0,0 +1,115 @@
+// Issue #2161: Telegram surface for subscription/account-access blocks.
+//
+// `/solve` prints a SUBSCRIPTION_BLOCKED_MARKER report into the session log when
+// the account can no longer use the agent tool (expired/cancelled Claude MAX
+// subscription, org policy, revoked ChatGPT/Codex entitlement, ...). The session
+// monitor captures that log, so the same block can be replayed into the Telegram
+// completion message without any extra plumbing between processes.
+
+import { SUBSCRIPTION_BLOCKED_MARKER } from './subscription-error.lib.mjs';
+import { lt } from './limits-i18n.lib.mjs';
+
+const MAX_MESSAGE_LENGTH = 400;
+const MAX_GUIDANCE_STEPS = 4;
+
+const truncate = (value, limit = MAX_MESSAGE_LENGTH) => {
+  const text = String(value || '').trim();
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit - 1)}…`;
+};
+
+const stripPrefix = (line, prefix) => line.slice(line.indexOf(prefix) + prefix.length).trim();
+
+/**
+ * Parse the last SUBSCRIPTION_BLOCKED_MARKER report out of a captured session log.
+ *
+ * The report is emitted by formatSubscriptionErrorReport(); every line after the
+ * marker line is indented, so the block ends at the first non-indented line.
+ *
+ * @param {string} logText
+ * @returns {null|{tool: string|null, label: string|null, message: string|null, code: string|null, reason: string|null, guidance: string[], committed: boolean|null, resumeCommand: string|null}}
+ */
+export function parseSubscriptionBlockFromLog(logText) {
+  if (!logText || typeof logText !== 'string') return null;
+  if (!logText.includes(SUBSCRIPTION_BLOCKED_MARKER)) return null;
+
+  const lines = logText.split('\n');
+  // Walk backwards: the richest report (from /solve) is the last one printed.
+  let markerIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].includes(SUBSCRIPTION_BLOCKED_MARKER)) {
+      markerIndex = i;
+      break;
+    }
+  }
+  if (markerIndex === -1) return null;
+
+  const headline = stripPrefix(lines[markerIndex], SUBSCRIPTION_BLOCKED_MARKER).replace(/^—\s*/, '');
+  const separator = headline.indexOf(':');
+  const parsed = {
+    tool: separator > 0 ? headline.slice(0, separator).trim() : null,
+    label: separator > 0 ? headline.slice(separator + 1).trim() : headline || null,
+    message: null,
+    code: null,
+    reason: null,
+    guidance: [],
+    committed: null,
+    resumeCommand: null,
+  };
+
+  for (let i = markerIndex + 1; i < lines.length; i += 1) {
+    const raw = lines[i];
+    if (!raw.trim()) continue;
+    if (!/^\s{3}/.test(raw)) break; // end of the indented report block
+    const line = raw.trim();
+    if (line.startsWith('Provider said:')) parsed.message = stripPrefix(line, 'Provider said:');
+    else if (line.startsWith('Error code:')) parsed.code = stripPrefix(line, 'Error code:');
+    else if (line.startsWith('HTTP status:')) parsed.code = `HTTP ${stripPrefix(line, 'HTTP status:')}`;
+    else if (line.startsWith('Why this stops the run:')) parsed.reason = stripPrefix(line, 'Why this stops the run:');
+    else if (line.startsWith('•')) parsed.guidance.push(line.slice(1).trim());
+    else if (line.startsWith('💾')) parsed.committed = true;
+    else if (line.startsWith('⚠️')) parsed.committed = false;
+    else if (line.startsWith('▶️')) parsed.resumeCommand = stripPrefix(line, ':');
+  }
+
+  return parsed;
+}
+
+/**
+ * Render the parsed block as a Telegram extraSection (title + fenced body), the
+ * same shape formatDiskDiagnosticsBlock() uses.
+ *
+ * @returns {string} empty string when there is nothing to show
+ */
+export function formatSubscriptionBlockedSection(parsed, { locale = null } = {}) {
+  if (!parsed) return '';
+  const options = locale ? { locale } : {};
+  const body = [];
+
+  const label = parsed.label || lt('subscription_blocked_title', {}, options);
+  body.push(parsed.tool ? `${parsed.tool}: ${label}` : label);
+  if (parsed.message) body.push(`${lt('subscription_blocked_provider', {}, options)}: ${truncate(parsed.message)}`);
+  if (parsed.code) body.push(`${lt('subscription_blocked_code', {}, options)}: ${parsed.code}`);
+  if (parsed.reason) body.push(`${lt('subscription_blocked_reason', {}, options)}: ${parsed.reason}`);
+  body.push(lt('subscription_blocked_note', {}, options));
+  if (parsed.guidance.length) {
+    body.push('');
+    body.push(`${lt('subscription_blocked_steps', {}, options)}:`);
+    for (const step of parsed.guidance.slice(0, MAX_GUIDANCE_STEPS)) body.push(`  • ${step}`);
+  }
+  if (parsed.committed === true) {
+    body.push('');
+    body.push(lt('subscription_blocked_preserved', {}, options));
+  }
+  if (parsed.resumeCommand) {
+    body.push('');
+    body.push(`${lt('subscription_blocked_resume', {}, options)}: ${parsed.resumeCommand}`);
+  }
+
+  return `🚫 ${lt('subscription_blocked_title', {}, options)}\n\`\`\`\n${body.join('\n')}\n\`\`\``;
+}
+
+export default {
+  parseSubscriptionBlockFromLog,
+  formatSubscriptionBlockedSection,
+};