@link-assistant/hive-mind 2.16.0 → 2.18.0

package/src/session-kill-resume.in-place.lib.mjs

@@ -0,0 +1,136 @@
+/**
+ * Re-enter the *same* container when recovering a killed session (issue #2189).
+ *
+ * The incident behind #2189 ended with a session that was killed 10 minutes
+ * after the AI tool had already finished its work. Recovery, when it finally
+ * happened, threw that container away: a fresh isolated run re-cloned the
+ * repository, re-installed everything and re-did work that was sitting on disk.
+ * The issue asks for the opposite — "ideally re-entering the same `$` session
+ * id / container".
+ *
+ * `start-command@0.33.0` (upstream link-foundation/start#162, filed from this
+ * very issue) makes that possible: `$ --resume <id> -- <command>` commits the
+ * stopped container's filesystem and runs the recovery command in a container
+ * derived from that snapshot, keeping the original execution UUID and log.
+ *
+ * Not every session may take that path, and the two exceptions are deliberate:
+ *
+ * - **Formal AI tasks** (issue #2146) reach their sidecar over an *internal*
+ *   Docker network that Hive Mind attaches with `docker network connect` after
+ *   the container is created. `$` knows nothing about that network, so a
+ *   resumed container would come up without it and the task would silently talk
+ *   to nothing. #2146 requires Formal AI to fail closed, so these fall back to
+ *   the normal launch path, which re-acquires the sidecar lease properly.
+ * - **`--use-router` tasks** are attached to the router network the same way,
+ *   with a freshly minted token, and have the same problem.
+ *
+ * Everything else — the overwhelming majority, and every session in the
+ * original incident — resumes in place.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2189
+ * @see https://github.com/link-foundation/start/issues/162
+ * @see https://github.com/link-assistant/hive-mind/issues/2146
+ */
+
+import { isFormalAiTask } from './formal-ai-sidecar.lib.mjs';
+import { hasUseRouterFlag } from './router-isolation.lib.mjs';
+import { RESUME_MODES } from './isolation-runner.resume.lib.mjs';
+
+/** Why a killed session cannot be re-entered in place. Reported, never thrown. */
+export const IN_PLACE_SKIP_REASONS = Object.freeze({
+  NOT_DOCKER: 'not-docker',
+  NO_IDENTIFIER: 'no-identifier',
+  FORMAL_AI_TASK: 'formal-ai-task',
+  ROUTER_TASK: 'router-task',
+  NO_RESUME_SUPPORT: 'no-resume-support',
+  CONTAINER_GONE: 'container-gone',
+  UNSUPPORTED: 'resume-unsupported',
+  REFUSED: 'resume-refused',
+  ERROR: 'resume-error',
+});
+
+/**
+ * Decide — purely, from persisted facts — whether a killed session is a
+ * candidate for a same-container resume.
+ *
+ * Kept separate from the Docker probe below so the policy is testable without a
+ * daemon, and so a caller can report precisely *why* a session was relaunched
+ * from scratch instead of resumed.
+ *
+ * @param {Object} options
+ * @param {string} options.sessionName - The killed session's name (= container name)
+ * @param {Object} options.sessionInfo - Persisted session info
+ * @returns {{eligible: boolean, reason: string, identifier: string|null, containerName: string|null}}
+ */
+export function planSameContainerResume({ sessionName = null, sessionInfo = {} } = {}) {
+  const containerName = sessionInfo?.sessionId || sessionName || null;
+  const identifier = sessionInfo?.executionUuid || containerName || null;
+  const base = { eligible: false, identifier, containerName };
+
+  if (sessionInfo?.isolationBackend !== 'docker') {
+    // screen/tmux sessions have no filesystem to preserve: their work happens
+    // on the host, which a fresh run already sees.
+    return { ...base, reason: IN_PLACE_SKIP_REASONS.NOT_DOCKER };
+  }
+  if (!identifier) return { ...base, reason: IN_PLACE_SKIP_REASONS.NO_IDENTIFIER };
+
+  const args = Array.isArray(sessionInfo?.args) ? sessionInfo.args : [];
+  if (isFormalAiTask({ args, model: sessionInfo?.model || null })) {
+    return { ...base, reason: IN_PLACE_SKIP_REASONS.FORMAL_AI_TASK };
+  }
+  if (hasUseRouterFlag(args)) return { ...base, reason: IN_PLACE_SKIP_REASONS.ROUTER_TASK };
+
+  return { ...base, eligible: true, reason: 'ready' };
+}
+
+/**
+ * Attempt the same-container resume. Never throws, and never leaves work
+ * running that it does not report: the caller may only fall back to a fresh
+ * launch when `resumed` is false.
+ *
+ * @param {Object} options
+ * @param {string} options.sessionName - The killed session's name
+ * @param {Object} options.sessionInfo - Persisted session info
+ * @param {Object} options.plan - Result of planKillRecovery() (needs `command.display`)
+ * @param {Object} options.runner - Isolation runner module
+ * @param {boolean} [options.verbose]
+ * @returns {Promise<{resumed: boolean, reason: string, sessionId: string|null, executionUuid: string|null, mode: string|null, snapshotImage: string|null}>}
+ */
+export async function resumeKilledSessionInPlace({ sessionName, sessionInfo, plan, runner, verbose = false } = {}) {
+  const decision = planSameContainerResume({ sessionName, sessionInfo });
+  const miss = reason => ({ resumed: false, reason, sessionId: null, executionUuid: decision.identifier, mode: null, snapshotImage: null });
+  if (!decision.eligible) return miss(decision.reason);
+  if (typeof runner?.resumeIsolatedSession !== 'function' || typeof runner?.checkDockerContainerExists !== 'function') {
+    return miss(IN_PLACE_SKIP_REASONS.NO_RESUME_SUPPORT);
+  }
+
+  // A container that no longer exists has nothing left to re-enter; `$` would
+  // fall back to a full relaunch, which is what the caller does anyway — but
+  // through the path that also re-acquires leases.
+  const exists = await runner.checkDockerContainerExists(decision.containerName, verbose);
+  if (!exists) return miss(IN_PLACE_SKIP_REASONS.CONTAINER_GONE);
+
+  const result = await runner.resumeIsolatedSession(decision.identifier, { command: plan?.command?.display || null, verbose });
+  if (!result?.success) {
+    const reason = result?.unsupported ? IN_PLACE_SKIP_REASONS.UNSUPPORTED : IN_PLACE_SKIP_REASONS.REFUSED;
+    if (verbose) console.log(`[VERBOSE] In-place resume of ${sessionName} was not possible (${reason}): ${result?.error || 'no reason given'}`);
+    return miss(reason);
+  }
+
+  // `docker-snapshot` names the new container `<session>-resume-<attempt>`; the
+  // old name stays addressable through upstream's `sessionNameHistory`, but the
+  // *new* one is what `$ --status` reports on now, so that is what the monitor
+  // has to track. A resume that somehow reports the old name (a `docker-start`
+  // race, say) is tracked under the execution UUID instead, which upstream
+  // resolves just as well and cannot collide with the dying session's entry.
+  const returnedName = result.sessionName && result.sessionName !== sessionName ? result.sessionName : null;
+  const sessionId = returnedName || decision.identifier;
+  return {
+    resumed: true,
+    reason: result.mode === RESUME_MODES.DOCKER_SNAPSHOT ? 'resumed-in-place' : `resumed-${result.mode || 'unknown'}`,
+    sessionId,
+    executionUuid: result.uuid || decision.identifier,
+    mode: result.mode || null,
+    snapshotImage: result.snapshotImage || null,
+  };
+}

package/src/session-kill-resume.lib.mjs

@@ -24,6 +24,7 @@ import { readLastSessionIdFromLog, planKilledSessionResume } from './session-res
 import { resolveOnSessionKillPolicy, resolveSessionKillResumeAttempts, shouldResumeKilledSession, ON_SESSION_KILL_RESUME } from './session-kill-policy.lib.mjs';
 import { argvFromSessionArgs } from './session-monitor.kill-sections.lib.mjs';
 import { formatKillResumeSection } from './session-kill-diagnostics.lib.mjs';
+import { resumeKilledSessionInPlace } from './session-kill-resume.in-place.lib.mjs';
 
 /** Field recording how many automatic recovery sessions this session produced. */
 export const KILL_RESUME_ATTEMPTS_FIELD = 'killRecoveryAttempts';
@@ -65,9 +66,18 @@ export function planKillRecovery({ sessionInfo = {}, logPath = null, killed = fa
 /**
  * Start the recovery working session decided by {@link planKillRecovery}.
  *
- * The new session is launched through the same isolation runner the original
- * used and is tracked like any other session, so it reports its own completion
- * (and, if it is killed too, its own diagnosis) through the normal path.
+ * Two ways in, in order of preference:
+ *
+ *   1. **Same container** (issue #2189) — `$ --resume` re-enters the killed
+ *      session's own filesystem, so the clone, the caches and the half-finished
+ *      branch survive. See `./session-kill-resume.in-place.lib.mjs` for the
+ *      cases that are deliberately excluded.
+ *   2. **A fresh isolated run** — the original behaviour, used whenever (1) is
+ *      not available or refuses. Correct, just more expensive.
+ *
+ * Either way the new session is tracked like any other, so it reports its own
+ * completion (and, if it is killed too, its own diagnosis) through the normal
+ * path.
  *
  * @param {Object} options
  * @param {string} options.sessionName - The killed session's name
@@ -77,10 +87,10 @@ export function planKillRecovery({ sessionInfo = {}, logPath = null, killed = fa
  * @param {Function} options.trackSession - Tracker for the new session
  * @param {Function} [options.persistSnapshot] - Persist the attempt counter
  * @param {boolean} [options.verbose]
- * @returns {Promise<{resumed: boolean, reason: string, sessionId: string|null, display: string|null}>}
+ * @returns {Promise<{resumed: boolean, reason: string, sessionId: string|null, display: string|null, inPlace: boolean}>}
  */
 export async function startKillRecoverySession({ sessionName, sessionInfo, plan, runner, trackSession, persistSnapshot = null, verbose = false } = {}) {
-  const fail = reason => ({ resumed: false, reason, sessionId: null, display: plan?.command?.display || null });
+  const fail = reason => ({ resumed: false, reason, sessionId: null, display: plan?.command?.display || null, inPlace: false });
   if (!plan?.shouldResume || !plan.command) return fail(plan?.reason || 'no-plan');
   if (!runner || typeof runner.executeWithIsolation !== 'function' || typeof runner.generateSessionId !== 'function') return fail('no-isolation-runner');
   if (typeof trackSession !== 'function') return fail('no-tracker');
@@ -88,10 +98,20 @@ export async function startKillRecoverySession({ sessionName, sessionInfo, plan,
   if (!backend) return fail('no-isolation-backend');
 
   try {
-    const newSessionId = runner.generateSessionId();
-    const tool = sessionInfo?.tool || 'claude';
-    const result = await runner.executeWithIsolation(sessionInfo?.command || 'solve', plan.command.args, { backend, sessionId: newSessionId, tool, verbose });
-    if (!result?.success) return fail('start-failed');
+    // Preferred path: re-enter the container the work already happened in.
+    const inPlace = await resumeKilledSessionInPlace({ sessionName, sessionInfo, plan, runner, verbose });
+    let newSessionId = inPlace.sessionId;
+    let executionUuid = inPlace.executionUuid;
+    let containerFilesystemStartBytes = null;
+
+    if (!inPlace.resumed) {
+      newSessionId = runner.generateSessionId();
+      const tool = sessionInfo?.tool || 'claude';
+      const result = await runner.executeWithIsolation(sessionInfo?.command || 'solve', plan.command.args, { backend, sessionId: newSessionId, tool, verbose });
+      if (!result?.success) return fail('start-failed');
+      executionUuid = result.executionUuid || null;
+      containerFilesystemStartBytes = Number.isFinite(result.containerFilesystemStartBytes) ? result.containerFilesystemStartBytes : null;
+    }
 
     trackSession(
       newSessionId,
@@ -105,9 +125,15 @@ export async function startKillRecoverySession({ sessionName, sessionInfo, plan,
         [KILL_RESUME_ATTEMPTS_FIELD]: plan.attempt,
         killRecoveryResumed: true,
         killRecoveryOfSession: sessionName,
+        // A resumed execution keeps its UUID; a fresh launch gets a new one, and
+        // inheriting the dead session's would make `$ --status` answer about the
+        // wrong execution until the monitor happened to correct it.
+        executionUuid,
+        killRecoveryInPlace: inPlace.resumed,
+        killRecoveryResumeMode: inPlace.mode || null,
         oomEventObservedAt: undefined,
         dockerBackendGoneFirstSeenAt: undefined,
-        containerFilesystemStartBytes: Number.isFinite(result.containerFilesystemStartBytes) ? result.containerFilesystemStartBytes : null,
+        containerFilesystemStartBytes,
       },
       verbose
     );
@@ -122,9 +148,10 @@ export async function startKillRecoverySession({ sessionName, sessionInfo, plan,
     }
 
     if (verbose) {
-      console.log(`[VERBOSE] Session ${sessionName} was killed; started recovery session ${newSessionId} (attempt ${plan.attempt}/${plan.maxAttempts}): ${plan.command.display}`);
+      const how = inPlace.resumed ? `resumed in place (${inPlace.mode || 'unknown mode'})` : `started fresh (in-place resume skipped: ${inPlace.reason})`;
+      console.log(`[VERBOSE] Session ${sessionName} was killed; recovery session ${newSessionId} ${how} (attempt ${plan.attempt}/${plan.maxAttempts}): ${plan.command.display}`);
     }
-    return { resumed: true, reason: 'started', sessionId: newSessionId, display: plan.command.display };
+    return { resumed: true, reason: inPlace.resumed ? inPlace.reason : 'started', sessionId: newSessionId, display: plan.command.display, inPlace: inPlace.resumed };
   } catch (error) {
     if (verbose) {
       console.log(`[VERBOSE] Could not start recovery session for ${sessionName}: ${error?.message || error}`);
@@ -138,7 +165,7 @@ export async function startKillRecoverySession({ sessionName, sessionInfo, plan,
  * Never throws — a failed recovery must still leave a correct kill report.
  *
  * @param {Object} options - See planKillRecovery() and startKillRecoverySession()
- * @returns {Promise<{resumed: boolean, reason: string, policy: string, sessionId: string|null, display: string|null, attempt: number, maxAttempts: number}>}
+ * @returns {Promise<{resumed: boolean, reason: string, policy: string, sessionId: string|null, display: string|null, attempt: number, maxAttempts: number, inPlace: boolean}>}
  */
 export async function recoverKilledSession({ sessionName, sessionInfo, logPath = null, killed = false, env = process.env, runner = null, trackSession = null, persistSnapshot = null, verbose = false, readLastSessionId = readLastSessionIdFromLog } = {}) {
   let plan;
@@ -146,15 +173,15 @@ export async function recoverKilledSession({ sessionName, sessionInfo, logPath =
     plan = planKillRecovery({ sessionInfo, logPath, killed, env, verbose, readLastSessionId });
   } catch (error) {
     if (verbose) console.log(`[VERBOSE] Could not plan kill recovery for ${sessionName}: ${error?.message || error}`);
-    return { resumed: false, reason: 'plan-error', policy: ON_SESSION_KILL_RESUME, sessionId: null, display: null, attempt: 0, maxAttempts: 0 };
+    return { resumed: false, reason: 'plan-error', policy: ON_SESSION_KILL_RESUME, sessionId: null, display: null, attempt: 0, maxAttempts: 0, inPlace: false };
   }
 
   if (!plan.shouldResume) {
-    return { resumed: false, reason: plan.reason, policy: plan.policy, sessionId: null, display: plan.command?.display || null, attempt: plan.attempt, maxAttempts: plan.maxAttempts };
+    return { resumed: false, reason: plan.reason, policy: plan.policy, sessionId: null, display: plan.command?.display || null, attempt: plan.attempt, maxAttempts: plan.maxAttempts, inPlace: false };
   }
 
   const started = await startKillRecoverySession({ sessionName, sessionInfo, plan, runner, trackSession, persistSnapshot, verbose });
-  return { resumed: started.resumed, reason: started.reason, policy: plan.policy, sessionId: started.sessionId, display: started.display, attempt: plan.attempt, maxAttempts: plan.maxAttempts };
+  return { resumed: started.resumed, reason: started.reason, policy: plan.policy, sessionId: started.sessionId, display: started.display, attempt: plan.attempt, maxAttempts: plan.maxAttempts, inPlace: started.inPlace === true };
 }
 
 /**

package/src/session-monitor.kill-sections.lib.mjs

@@ -95,6 +95,14 @@ export async function buildKillCompletionSections({ sessionName, sessionInfo, st
       exitCode,
       stopRequestedByUser: sessionInfo?.stopRequestedByUser === true,
       locale,
+      // start-command 0.33.0 scans the log tail for fatal markers when the
+      // command exits and reports what it found (link-foundation/start#164,
+      // #165 — both filed from this issue). Pass it through: `$` saw the exit
+      // live, so it can carry evidence our bounded re-read of a huge log may
+      // have missed. Absent on an older `$`, which is why the local scan stays.
+      reportedMemoryExhausted: statusResult?.memoryExhausted ?? null,
+      reportedMemoryExhaustedReason: statusResult?.memoryExhaustedReason ?? null,
+      reportedExitReason: statusResult?.exitReason ?? null,
     });
 
     const argv = argvFromSessionArgs(sessionInfo?.args);

package/src/session-store.lib.mjs

@@ -52,7 +52,7 @@ import path from 'node:path';
 //   - `stopRequestedByUser`/`stopRequestedBy` must survive a restart too: with
 //     `--on-session-kill=resume` now the default, forgetting that an operator
 //     asked for the stop would relaunch the very work they cancelled.
-const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'commandAlias', 'isolationBackend', 'sessionId', 'executionUuid', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args', 'completionNotifiedAt', 'completionExitCode', 'completionStatus', 'lastToolSessionId', 'killRecoveryAttempts', 'killRecoverySessionId', 'killRecoveryOfSession', 'killRecoveryResumed', 'stopRequestedByUser', 'stopRequestedBy', 'onSessionKill', 'resolvedPullRequestUrl'];
+const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'commandAlias', 'isolationBackend', 'sessionId', 'executionUuid', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args', 'completionNotifiedAt', 'completionExitCode', 'completionStatus', 'lastToolSessionId', 'killRecoveryAttempts', 'killRecoverySessionId', 'killRecoveryOfSession', 'killRecoveryResumed', 'killRecoveryInPlace', 'killRecoveryResumeMode', 'stopRequestedByUser', 'stopRequestedBy', 'onSessionKill', 'resolvedPullRequestUrl'];
 
 /**
  * Resolve the directory durable bot state is written to. Honors

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

@@ -0,0 +1,86 @@
+/**
+ * Clone failure classification and partial-clone cleanup for the solve command.
+ *
+ * Extracted from solve.repository.lib.mjs, which had grown past the 1350-line
+ * warning threshold that scripts/check-file-line-limits.sh enforces (issue
+ * #1593, surfaced again by issue #2198). These two helpers are pure decision
+ * logic with no dependency on the repository-setup flow around them, so they
+ * are the natural seam.
+ *
+ * Both names stay re-exported from solve.repository.lib.mjs so existing
+ * importers - and tests/anonymous-clone-auth-2192.test.mjs,
+ * tests/test-issue-1957-incomplete-clone.mjs - are unaffected.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { isENOSPC } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+// Issue #2192: GitHub throttles *anonymous* git downloads; the wording overlaps
+// the permission, not-found and rate-limit cases, so it is checked before them.
+import { isAnonymousDownloadLimit } from './git-auth-transport.lib.mjs';
+
+// Classify git clone errors to determine if they are retryable
+export const classifyCloneError = errorOutput => {
+  const output = errorOutput.toLowerCase();
+  // Issue #1211: ENOSPC (disk full) errors - NOT retryable, requires user action
+  if (isENOSPC(errorOutput) || output.includes('no space left on device') || (output.includes('unable to write file') && output.includes('error')) || output.includes('errno -28')) {
+    return { type: 'ENOSPC', retryable: false, description: 'No space left on device' };
+  }
+
+  // Transient server errors (5xx) - typically retryable
+  if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
+    return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
+  }
+  // Network-related errors - typically retryable
+  // Issue #1957: git fetch-pack/sideband disconnects (e.g.
+  // "fetch-pack: unexpected disconnect while reading sideband packet",
+  // "early EOF", "the remote end hung up unexpectedly", "RPC failed",
+  // "index-pack failed") leave an incomplete or missing clone but are transient.
+  if (output.includes('connection refused') || output.includes('connection timed out') || output.includes('connection reset') || output.includes('unable to connect') || output.includes('network is unreachable') || output.includes('ssl error') || output.includes('unexpected disconnect') || output.includes('sideband') || output.includes('early eof') || output.includes('remote end hung up') || output.includes('rpc failed') || output.includes('fetch-pack') || output.includes('index-pack failed') || output.includes('transfer closed')) {
+    return { type: 'NETWORK', retryable: true, description: 'Network connectivity issue (interrupted transfer)' };
+  }
+
+  // Issue #2192: GitHub refusing an *unauthenticated* download. Retryable, but
+  // waiting is not the remedy — the clone has to be authenticated. Checked
+  // before PERMISSION/NOT_FOUND/RATE_LIMIT because GitHub's wording ("limiting",
+  // "retry later or authenticate") overlaps all three.
+  if (isAnonymousDownloadLimit(errorOutput)) {
+    return { type: 'ANONYMOUS_RATE_LIMIT', retryable: true, description: 'GitHub is limiting unauthenticated downloads (this clone was not authenticated)' };
+  }
+
+  // Authentication/permission errors - not retryable
+  if (output.includes('error: 401') || output.includes('error: 403') || output.includes('authentication failed') || output.includes('permission denied')) {
+    return { type: 'PERMISSION', retryable: false, description: 'Authentication or permission error' };
+  }
+  // Repository not found - not retryable
+  if (output.includes('error: 404') || output.includes('not found') || output.includes('repository not found')) {
+    return { type: 'NOT_FOUND', retryable: false, description: 'Repository not found' };
+  }
+
+  // Rate limiting - retryable with backoff
+  if (output.includes('rate limit') || output.includes('too many requests') || output.includes('api rate limit exceeded')) {
+    return { type: 'RATE_LIMIT', retryable: true, description: 'Rate limit exceeded' };
+  }
+  // Default to retryable for unknown errors
+  return { type: 'UNKNOWN', retryable: true, description: 'Unknown error' };
+};
+
+// Issue #1957: remove leftovers from an interrupted clone so a retry can start clean.
+// We empty the directory in place (rather than removing it) because the path was
+// created up-front by setupTempDirectory and may be the configured working directory.
+export const cleanPartialClone = async tempDir => {
+  try {
+    const entries = await fs.readdir(tempDir);
+    for (const entry of entries) {
+      await fs.rm(path.join(tempDir, entry), { recursive: true, force: true });
+    }
+  } catch (error) {
+    // Directory may not exist yet, or be unreadable — non-fatal; the retry/clone
+    // will surface any real problem with a clearer message.
+    if (error?.code !== 'ENOENT') {
+      reportError(error, { context: 'clean_partial_clone', tempDir, operation: 'empty_directory' });
+    }
+  }
+};

package/src/solve.repository.lib.mjs

@@ -28,12 +28,13 @@ const { log, formatAligned } = lib;
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
 import { ensureAiToolScratchIgnored } from './ai-tool-scratch.lib.mjs';
+import { reclaimAgentSnapshotStores } from './agent-snapshot-store.lib.mjs';
 import { parseForkFullNameFromGhOutput } from './github-repository-names.lib.mjs';
 import { checkReplacementRepositoryBranchSafety } from './solve.repository-safety.lib.mjs';
 import { buildForkReplacementBlockedReason, buildForkReplacementSafetyCheckDescription } from './solve.repository-recovery-message.lib.mjs';
 // Issue #2192: GitHub throttles *anonymous* git downloads; a token must be sent
 // preemptively (a credential helper is never consulted for a public repository).
-import { GIT_AUTH_TRANSPORT_DISABLE, ensureAuthenticatedGitTransport, isAnonymousDownloadLimit } from './git-auth-transport.lib.mjs';
+import { GIT_AUTH_TRANSPORT_DISABLE, ensureAuthenticatedGitTransport } from './git-auth-transport.lib.mjs';
 
 // Import GitHub utilities for permission checks
 const githubLib = await import('./github.lib.mjs');
@@ -931,69 +932,12 @@ Thank you!`;
 
   return { repoToClone, forkedRepo, upstreamRemote, prForkOwner: forkOwner };
 };
-// Classify git clone errors to determine if they are retryable
-export const classifyCloneError = errorOutput => {
-  const output = errorOutput.toLowerCase();
-  // Issue #1211: ENOSPC (disk full) errors - NOT retryable, requires user action
-  if (lib.isENOSPC(errorOutput) || output.includes('no space left on device') || (output.includes('unable to write file') && output.includes('error')) || output.includes('errno -28')) {
-    return { type: 'ENOSPC', retryable: false, description: 'No space left on device' };
-  }
-
-  // Transient server errors (5xx) - typically retryable
-  if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
-    return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
-  }
-  // Network-related errors - typically retryable
-  // Issue #1957: git fetch-pack/sideband disconnects (e.g.
-  // "fetch-pack: unexpected disconnect while reading sideband packet",
-  // "early EOF", "the remote end hung up unexpectedly", "RPC failed",
-  // "index-pack failed") leave an incomplete or missing clone but are transient.
-  if (output.includes('connection refused') || output.includes('connection timed out') || output.includes('connection reset') || output.includes('unable to connect') || output.includes('network is unreachable') || output.includes('ssl error') || output.includes('unexpected disconnect') || output.includes('sideband') || output.includes('early eof') || output.includes('remote end hung up') || output.includes('rpc failed') || output.includes('fetch-pack') || output.includes('index-pack failed') || output.includes('transfer closed')) {
-    return { type: 'NETWORK', retryable: true, description: 'Network connectivity issue (interrupted transfer)' };
-  }
-
-  // Issue #2192: GitHub refusing an *unauthenticated* download. Retryable, but
-  // waiting is not the remedy — the clone has to be authenticated. Checked
-  // before PERMISSION/NOT_FOUND/RATE_LIMIT because GitHub's wording ("limiting",
-  // "retry later or authenticate") overlaps all three.
-  if (isAnonymousDownloadLimit(errorOutput)) {
-    return { type: 'ANONYMOUS_RATE_LIMIT', retryable: true, description: 'GitHub is limiting unauthenticated downloads (this clone was not authenticated)' };
-  }
-
-  // Authentication/permission errors - not retryable
-  if (output.includes('error: 401') || output.includes('error: 403') || output.includes('authentication failed') || output.includes('permission denied')) {
-    return { type: 'PERMISSION', retryable: false, description: 'Authentication or permission error' };
-  }
-  // Repository not found - not retryable
-  if (output.includes('error: 404') || output.includes('not found') || output.includes('repository not found')) {
-    return { type: 'NOT_FOUND', retryable: false, description: 'Repository not found' };
-  }
+// Issue #2198: clone-failure classification and partial-clone cleanup live in
+// their own module to keep this file under the line-limit warning threshold.
+// Re-exported so importers keep working.
+import { classifyCloneError, cleanPartialClone } from './solve.clone-errors.lib.mjs';
 
-  // Rate limiting - retryable with backoff
-  if (output.includes('rate limit') || output.includes('too many requests') || output.includes('api rate limit exceeded')) {
-    return { type: 'RATE_LIMIT', retryable: true, description: 'Rate limit exceeded' };
-  }
-  // Default to retryable for unknown errors
-  return { type: 'UNKNOWN', retryable: true, description: 'Unknown error' };
-};
-
-// Issue #1957: remove leftovers from an interrupted clone so a retry can start clean.
-// We empty the directory in place (rather than removing it) because the path was
-// created up-front by setupTempDirectory and may be the configured working directory.
-export const cleanPartialClone = async tempDir => {
-  try {
-    const entries = await fs.readdir(tempDir);
-    for (const entry of entries) {
-      await fs.rm(path.join(tempDir, entry), { recursive: true, force: true });
-    }
-  } catch (error) {
-    // Directory may not exist yet, or be unreadable — non-fatal; the retry/clone
-    // will surface any real problem with a clearer message.
-    if (error?.code !== 'ENOENT') {
-      reportError(error, { context: 'clean_partial_clone', tempDir, operation: 'empty_directory' });
-    }
-  }
-};
+export { classifyCloneError, cleanPartialClone };
 // Clone repository and set up remotes with retry mechanism
 export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) => {
   const maxRetries = 3;
@@ -1340,6 +1284,30 @@ export const checkoutPrBranch = async (tempDir, branchName, prForkRemote, prFork
 
   return checkoutResult;
 };
+/**
+ * Reclaim orphaned `@link-assistant/agent` snapshot stores (issue #2186).
+ *
+ * Deliberately *not* gated on `--auto-cleanup`: the stores this removes belong to
+ * worktrees that no longer exist, so there is nothing left to restore them into
+ * and keeping them has no debugging value. On a public repository auto-cleanup
+ * defaults to off, and that must not also mean "leak ~5 GB/h of home-directory
+ * state that no Hive Mind disk check can even see".
+ *
+ * Never fatal: this runs while solve is finalizing, after the work is done.
+ */
+export const cleanupAgentSnapshotStores = async () => {
+  try {
+    const { removed } = await reclaimAgentSnapshotStores({ log: async (message, options) => log(message, options) });
+    if (removed.length > 0) await log(`🧹 Reclaimed ${removed.length} orphaned agent snapshot store(s)`);
+  } catch (cleanupError) {
+    reportError(cleanupError, {
+      context: 'cleanup_agent_snapshot_stores',
+      operation: 'reclaim_agent_snapshots',
+    });
+    await log(`⚠️  Could not reclaim orphaned agent snapshot stores: ${cleanupError.message}`, { level: 'warning' });
+  }
+};
+
 // Cleanup temporary directory
 export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
   // Determine if we should skip cleanup
@@ -1370,4 +1338,9 @@ export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
     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}`);
   }
+
+  // Issue #2186: whatever was decided about the workspace above, agent state
+  // whose worktree is already gone is reclaimed. The store belonging to
+  // `tempDir` is untouched while `tempDir` still exists.
+  await cleanupAgentSnapshotStores();
 };

package/src/solve.resource-diagnostics.lib.mjs

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import v8 from 'node:v8';
 
+import { measureAgentSnapshotUsage } from './agent-snapshot-store.lib.mjs';
+
 export const RESOURCE_MARKER_PREFIX = '📈 [RESOURCES]';
 
 export const RESOURCE_PHASE_SOLVE_START = 'solve_start';
@@ -327,6 +329,7 @@ export function buildResourceMarker(snapshot) {
   const cpu = s.cpu || {};
   const memory = s.memory || {};
   const disk = s.disk || {};
+  const agentState = s.agentState || null;
   return [
     RESOURCE_MARKER_PREFIX,
     `phase=${encodeValue(s.phase || 'snapshot')}`,
@@ -353,6 +356,11 @@ export function buildResourceMarker(snapshot) {
     `mem=${encodeValue(`${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total`)}`,
     `heap=${encodeValue(formatHeapUsage(memory))}`,
     `disk=${encodeValue(`${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total`)}`,
+    // Issue #2186: only emitted when the agent state was actually measured, so
+    // markers written before this existed keep parsing byte-for-byte the same.
+    agentState ? `agentStatePath=${encodeValue(agentState.path)}` : null,
+    agentState ? numberField('agentStoreCount', finiteNumber(agentState.count)) : null,
+    agentState ? numberField('agentStoreBytes', finiteNumber(agentState.bytes)) : null,
   ]
     .filter(Boolean)
     .join(' ');
@@ -404,6 +412,15 @@ function parseMarkerLine(line) {
       usedPercent: parseNumber(fields.diskUsedPercent),
       error: fields.error ? decodeURIComponent(fields.error) : null,
     },
+    // Issue #2186: absent in markers produced before agent state was measured,
+    // and absent on hosts where the agent data home does not exist.
+    agentState: fields.agentStatePath
+      ? {
+          path: decodeURIComponent(fields.agentStatePath),
+          count: parseNumber(fields.agentStoreCount),
+          bytes: parseNumber(fields.agentStoreBytes),
+        }
+      : null,
   };
 }
 
@@ -440,13 +457,18 @@ export function formatResourceSnapshotForLog(snapshot, label = null) {
   const memory = s.memory || {};
   const disk = s.disk || {};
   const lines = [`📈 Resource usage (${phaseLabel}):`, `   CPU load: ${formatNumber(cpu.load1)} ${formatNumber(cpu.load5)} ${formatNumber(cpu.load15)}${Number.isFinite(cpu.cpuCount) ? ` (${cpu.cpuCount} CPUs)` : ''}`, `   Memory: ${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total (${formatBytes(memory.usedBytes)} used)`, `   Process RSS: ${formatBytes(memory.processRssBytes)}, V8 heap: ${formatHeapUsage(memory)}`, `   Disk (${disk.path || '/'}): ${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total${Number.isFinite(disk.usedPercent) ? ` (${disk.usedPercent.toFixed(1)}% used)` : ''}`];
+  // Issue #2186: `/` alone hid ~5 GB/h of agent snapshot growth under
+  // `~/.local/share`, so name the directory that is actually filling up.
+  if (s.agentState && Number(s.agentState.count) > 0) {
+    lines.push(`   Agent snapshot stores (${s.agentState.path}): ${s.agentState.count} store(s), ${formatBytes(s.agentState.bytes)}${s.agentState.truncated ? '+ (measurement truncated)' : ''}`);
+  }
   if (isHeapUnderPressure(memory)) lines.push(`   ⚠️  V8 heap is at ${memory.processHeapUsedPercent.toFixed(1)}% of its limit — a further allocation can abort the process with "JavaScript heap out of memory"`);
   if (disk.error) lines.push(`   Disk probe error: ${disk.error}`);
   lines.push(buildResourceMarker(snapshot));
   return lines.join('\n');
 }
 
-export async function recordResourceSnapshot({ phase, log, diskPath = '/', label = null, capture = captureResourceSnapshot, logExecutionContext = false, detectContext = detectExecutionContext } = {}) {
+export async function recordResourceSnapshot({ phase, log, diskPath = '/', label = null, capture = captureResourceSnapshot, logExecutionContext = false, detectContext = detectExecutionContext, measureAgentState = measureAgentSnapshotUsage } = {}) {
   if (typeof log !== 'function') return null;
   try {
     // Issue #2001: optionally report the execution context (host vs container)
@@ -459,6 +481,17 @@ export async function recordResourceSnapshot({ phase, log, diskPath = '/', label
       }
     }
     const snapshot = capture({ phase, diskPath });
+    // Issue #2186: agent state lives outside `diskPath` and needs the file
+    // system, so it is measured separately and stays best-effort — a missing or
+    // unreadable agent data home must never cost us the rest of the snapshot.
+    if (typeof measureAgentState === 'function') {
+      try {
+        const agentState = await measureAgentState();
+        if (agentState && Number(agentState.count) > 0) snapshot.agentState = agentState;
+      } catch {
+        /* agent state is a diagnostic extra, not a precondition */
+      }
+    }
     await log(formatResourceSnapshotForLog(snapshot, label));
     return snapshot;
   } catch (error) {

package/src/solve.validation.lib.mjs

@@ -35,6 +35,9 @@ const {
 } = githubLib;
 
 // Import git-related functions for identity validation and repair
+// Issue #2194: recovery diagnostics for URLs that had to be repaired before parsing.
+const { formatUrlRepairs, hasNotableRepair, revealHiddenCharacters } = await import('./github-url-recovery.lib.mjs');
+
 const gitLib = await import('./git.lib.mjs');
 const { checkGitIdentity, repairGitIdentity } = gitLib;
 
@@ -83,6 +86,16 @@ export const validateGitHubUrl = issueUrl => {
     return { isValid: false, isIssueUrl: null, isPrUrl: null };
   }
 
+  // Issue #2194: the URL needed repair before it could be understood. Say so up
+  // front, so a wrong guess is visible before a whole session runs against the
+  // wrong entity.
+  if (hasNotableRepair(parsedUrl.repairs)) {
+    console.error('ℹ️  Repaired the GitHub URL before solving:');
+    console.error(`     You typed: ${revealHiddenCharacters(issueUrl)}`);
+    console.error(`     Using:     ${parsedUrl.canonical || parsedUrl.normalized}`);
+    console.error(`     Repaired:  ${formatUrlRepairs(parsedUrl.repairs, { notableOnly: true })}`);
+  }
+
   // Check if it's an issue or pull request
   const isIssueUrl = parsedUrl.type === 'issue';
   const isPrUrl = parsedUrl.type === 'pull';
@@ -102,9 +115,12 @@ export const validateGitHubUrl = issueUrl => {
     isIssueUrl,
     isPrUrl,
     normalizedUrl: parsedUrl.normalized,
+    canonicalUrl: parsedUrl.canonical || parsedUrl.normalized,
     owner: parsedUrl.owner,
     repo: parsedUrl.repo,
     number: parsedUrl.number,
+    repairs: parsedUrl.repairs || [],
+    recovered: Boolean(parsedUrl.recovered),
   };
 };