@link-assistant/hive-mind 2.15.1 → 2.15.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @link-assistant/hive-mind
 
+## 2.15.2
+
+### Patch Changes
+
+- c1f6a41: Authenticate git downloads so a run no longer dies with `Reason: Repository setup failed` (issue #2192).
+
+  A run ended after three clone attempts, each answered by GitHub with `fatal: remote error: GitHub is temporarily limiting some unauthenticated downloads to protect the stability of the platform. Please retry later or authenticate.` — while every `gh api` call in the same process succeeded. Three defects lined up, and each is fixed:
+
+  - **Public clones were sent anonymously even though a token was available.** `gh auth setup-git` installs a credential helper, but git only consults a helper after the server answers `401`, and github.com answers `200` for a public repository. Measured with `GIT_TRACE_CURL=1`, a public `git clone`/`gh repo clone` sent **0** `Authorization` headers. The new `src/git-auth-transport.lib.mjs` sends the token preemptively via `http.https://github.com/.extraheader`, injected through `GIT_CONFIG_COUNT`/`GIT_CONFIG_KEY_n`/`GIT_CONFIG_VALUE_n` environment variables (**3** headers now sent) — so the token never reaches `.git/config` or a command line, and every git child process (`clone`, `fetch`, `pull`, `push`, `gh repo clone`) inherits it. `HIVE_MIND_DISABLE_GIT_AUTH_TRANSPORT=1` opts out.
+  - **The refusal was reported as `Unknown error`.** `classifyCloneError` now returns `ANONYMOUS_RATE_LIMIT`, and `src/transient-errors.lib.mjs` gains the shared `github-anonymous-rate-limit` category, so the log names the real cause and the "How to fix" section stops suggesting `gh auth login` to an already-logged-in run.
+  - **Retries only slept.** The clone loop and `gitCmdRetry` now upgrade the transport before the next attempt, falling back to `gh-setup-git-identity --repair` (non-interactive) when no token is reachable; only a genuinely absent token still fails.
+
+  Authentication now happens _before_ the first clone in `setupRepositoryAndClone`, `review`, and `create-test-repo`. Full analysis, the run log excerpts and a reproduction script are in `docs/case-studies/issue-2192/`.
+
 ## 2.15.1
 
 ### Patch Changes

package/package.json

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

package/src/git-auth-transport.lib.mjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+/**
+ * Authenticated git HTTPS transport for github.com (issue #2192).
+ *
+ * A `solve` run died with `Reason: Repository setup failed` after three clone
+ * attempts, each rejected by GitHub with:
+ *
+ *   fatal: remote error: GitHub is temporarily limiting some unauthenticated
+ *   downloads to protect the stability of the platform. Please retry later or
+ *   authenticate.
+ *
+ * The container *was* authenticated: every `gh` API call in the same run
+ * succeeded, and `gh auth setup-git` had installed
+ * `credential.https://github.com.helper = !gh auth git-credential`.
+ *
+ * A credential helper does not help here. git only asks the helper for
+ * credentials **after** the server answers `401`, and github.com answers `200`
+ * for a public repository — so a public clone is performed anonymously even
+ * when a token is sitting right there. Verified with `GIT_TRACE_CURL=1`:
+ * `git clone` and `gh repo clone` of a public repository send zero
+ * `Authorization` headers with the helper configured (see
+ * `experiments/issue-2192-anonymous-clone-auth.mjs`). Anonymous traffic is what
+ * GitHub throttles, so the run hit the limit and no amount of retrying or
+ * credential-helper repair could have fixed it.
+ *
+ * The remedy is the one GitHub's own `actions/checkout` uses: send the token
+ * preemptively via `http.<host>.extraheader`. Two properties matter here:
+ *
+ *   1. The header is injected through `GIT_CONFIG_COUNT` / `GIT_CONFIG_KEY_n` /
+ *      `GIT_CONFIG_VALUE_n` environment variables (git >= 2.31) rather than
+ *      written into `.git/config` or passed as `-c` arguments. The token never
+ *      lands in a file the AI session can read back, never appears in a
+ *      process command line visible to `ps`, and is inherited by every git
+ *      child process — `gh repo clone`, `git fetch`, `git pull`, `git push` —
+ *      without touching those ~36 call sites.
+ *   2. Existing `GIT_CONFIG_*` entries are preserved: the new keys are appended
+ *      after whatever the operator (or an outer container) already configured.
+ *
+ * The token value is protected in logs by the existing sanitizer: base64 forms
+ * of known local tokens are masked by `findEncodedKnownTokenRuns`
+ * (issue #2156), and the header is never logged by this module in any case.
+ *
+ * @see docs/case-studies/issue-2192/README.md
+ * @module git-auth-transport
+ */
+
+import { ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS, isAnonymousDownloadLimit } from './transient-errors.lib.mjs';
+
+/** Hosts whose HTTPS git traffic is authenticated by default. */
+export const DEFAULT_AUTHENTICATED_HOSTS = Object.freeze(['github.com']);
+
+/** Env var used as the idempotency marker / diagnostic breadcrumb. */
+export const GIT_AUTH_TRANSPORT_MARKER = 'HIVE_MIND_GIT_AUTH_TRANSPORT';
+
+/** Env var an operator can set to opt out of forced authentication. */
+export const GIT_AUTH_TRANSPORT_DISABLE = 'HIVE_MIND_DISABLE_GIT_AUTH_TRANSPORT';
+
+// GitHub's wording when it refuses an *anonymous* git download lives in the
+// shared transient vocabulary (`transient-errors.lib.mjs`) so classification
+// and repair can never drift apart; re-exported for callers that only import
+// this module.
+export { ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS, isAnonymousDownloadLimit };
+
+/**
+ * Build the `Authorization` header value git should send to github.com.
+ *
+ * GitHub accepts the token as the *password* of HTTP Basic auth with any
+ * username; `x-access-token` is the username `actions/checkout` uses.
+ *
+ * @param {string} token
+ * @returns {string} e.g. `Authorization: Basic eC1hY2Nlc3M...`
+ */
+export const buildAuthorizationHeader = token => `Authorization: Basic ${Buffer.from(`x-access-token:${token}`, 'utf8').toString('base64')}`;
+
+/**
+ * Read the number of `GIT_CONFIG_*` pairs already present in `env`.
+ *
+ * Anything unparseable is treated as zero rather than throwing: a malformed
+ * outer environment must not stop the solver from cloning.
+ *
+ * @param {Record<string, string|undefined>} env
+ * @returns {number}
+ */
+export const readGitConfigCount = env => {
+  const parsed = Number.parseInt(String(env?.GIT_CONFIG_COUNT ?? ''), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
+};
+
+/**
+ * True when `env` already carries an `extraheader` entry for every host.
+ *
+ * Recognises entries installed by this module *and* by an outer environment
+ * (a CI runner, a parent container), so authentication configured upstream is
+ * never duplicated.
+ *
+ * @param {Record<string, string|undefined>} env
+ * @param {string[]} [hosts]
+ * @returns {boolean}
+ */
+export const hasGitAuthConfig = (env, hosts = DEFAULT_AUTHENTICATED_HOSTS) => {
+  const count = readGitConfigCount(env);
+  const configuredKeys = new Set();
+  for (let index = 0; index < count; index++) {
+    const key = env?.[`GIT_CONFIG_KEY_${index}`];
+    const value = env?.[`GIT_CONFIG_VALUE_${index}`];
+    if (typeof key === 'string' && typeof value === 'string' && value.trim()) configuredKeys.add(key.toLowerCase());
+  }
+  return hosts.every(host => configuredKeys.has(gitAuthConfigKey(host).toLowerCase()));
+};
+
+/**
+ * git config key that carries the preemptive `Authorization` header for `host`.
+ *
+ * The trailing slash matters: git matches `http.<url>.*` by URL prefix, so
+ * `https://github.com/` covers every repository on the host and nothing else.
+ *
+ * @param {string} host
+ * @returns {string}
+ */
+export const gitAuthConfigKey = host => `http.https://${host}/.extraheader`;
+
+/**
+ * Compute the `GIT_CONFIG_*` variables that add preemptive authentication for
+ * `hosts`, preserving any entries already present in `env`.
+ *
+ * Pure: returns a patch, mutates nothing.
+ *
+ * @param {object} params
+ * @param {string} params.token - GitHub token
+ * @param {string[]} [params.hosts]
+ * @param {Record<string, string|undefined>} [params.env] - environment to extend
+ * @returns {Record<string, string>} variables to merge into the environment
+ */
+export const buildGitAuthConfigEnv = ({ token, hosts = DEFAULT_AUTHENTICATED_HOSTS, env = {} }) => {
+  if (!token) throw new TypeError('buildGitAuthConfigEnv requires a GitHub token');
+  const header = buildAuthorizationHeader(token);
+  const patch = {};
+  let index = readGitConfigCount(env);
+  for (const host of hosts) {
+    patch[`GIT_CONFIG_KEY_${index}`] = gitAuthConfigKey(host);
+    patch[`GIT_CONFIG_VALUE_${index}`] = header;
+    index++;
+  }
+  patch.GIT_CONFIG_COUNT = String(index);
+  patch[GIT_AUTH_TRANSPORT_MARKER] = hosts.join(',');
+  return patch;
+};
+
+/**
+ * True when the operator disabled forced authentication.
+ *
+ * @param {Record<string, string|undefined>} env
+ * @returns {boolean}
+ */
+export const isGitAuthTransportDisabled = (env = process.env) => {
+  const raw = String(env?.[GIT_AUTH_TRANSPORT_DISABLE] ?? '')
+    .trim()
+    .toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes';
+};
+
+/**
+ * Resolve a GitHub token without ever printing it.
+ *
+ * Order: explicit env vars first (an operator override beats stored state),
+ * then `gh auth token`. Returns `{ token, source }` or `{ token: null }`.
+ *
+ * @param {object} params
+ * @param {Function} params.$ - command-stream `$` tag
+ * @param {Record<string, string|undefined>} [params.env]
+ * @returns {Promise<{token: string|null, source: string|null, error: string|null}>}
+ */
+/**
+ * Return the caller's `$` or load command-stream's on demand.
+ *
+ * @param {Function|undefined} provided
+ * @returns {Promise<Function>} command-stream `$` tag
+ */
+export const resolveDollar = async provided => {
+  if (typeof provided === 'function') return provided;
+  // Call sites deep in the retry helpers do not carry a `$` of their own; fall
+  // back to the same command-stream instance the rest of the codebase loads.
+  const { ensureUseM } = await import('./use-m-bootstrap.lib.mjs');
+  const use = globalThis.use || (await ensureUseM());
+  return (await use('command-stream')).$;
+};
+
+export const resolveGitHubToken = async ({ $, env = process.env }) => {
+  for (const name of ['GH_TOKEN', 'GITHUB_TOKEN']) {
+    const value = env?.[name];
+    if (typeof value === 'string' && value.trim()) return { token: value.trim(), source: name, error: null };
+  }
+  try {
+    // `quietProbe` keeps the token out of the mirrored output that becomes the
+    // attached log (issue #2130); the value is only ever used in memory.
+    const { quietProbe } = await import('./quiet-probe.lib.mjs');
+    const result = await quietProbe(await resolveDollar($))`gh auth token`;
+    const token = (result?.stdout?.toString() || '').trim();
+    if (result?.code === 0 && token) return { token, source: 'gh auth token', error: null };
+    return { token: null, source: null, error: (result?.stderr?.toString() || '').trim() || `gh auth token exited ${result?.code}` };
+  } catch (error) {
+    return { token: null, source: null, error: error?.message || String(error) };
+  }
+};
+
+/**
+ * Ensure git sends credentials to github.com preemptively.
+ *
+ * Idempotent, never throws, and safe to call from any entry point: the worst
+ * case (no token, gh not installed, operator opt-out) leaves the environment
+ * exactly as it was and reports why.
+ *
+ * @param {object} params
+ * @param {Function} [params.$] - command-stream `$` tag (loaded on demand when omitted)
+ * @param {Function} [params.log] - logger; called with human-readable lines
+ * @param {Record<string, string|undefined>} [params.env] - environment to mutate (default `process.env`)
+ * @param {string[]} [params.hosts]
+ * @param {string} [params.reason] - short phrase explaining why it was invoked
+ * @param {boolean} [params.repair] - when true, try `gh-setup-git-identity --repair` if no token is found
+ * @returns {Promise<{status: 'applied'|'already-configured'|'disabled'|'no-token', hosts: string[], source?: string|null, error?: string|null}>}
+ */
+export const ensureAuthenticatedGitTransport = async ({ $, log = async () => {}, env = process.env, hosts = DEFAULT_AUTHENTICATED_HOSTS, reason = '', repair = false } = {}) => {
+  if (isGitAuthTransportDisabled(env)) {
+    await log(`ℹ️  Authenticated git transport disabled via ${GIT_AUTH_TRANSPORT_DISABLE}; git will download from github.com anonymously`, { verbose: true });
+    return { status: 'disabled', hosts };
+  }
+
+  if (hasGitAuthConfig(env, hosts)) {
+    // Issue #2192 asks for enough diagnostics to reconstruct the transport state
+    // from a log. Verbose-only: on the happy path this fires before every clone.
+    await log(`🔐 Authenticated git transport already configured for ${hosts.join(', ')}${reason ? ` - ${reason}` : ''}`, { verbose: true });
+    return { status: 'already-configured', hosts };
+  }
+
+  let { token, source, error } = await resolveGitHubToken({ $, env });
+
+  if (!token && repair) {
+    // Issue #2192 asks for auto-recovery of the git/gh state when it is
+    // repairable without interactive credentials. `gh-setup-git-identity`
+    // derives the identity and the credential helper from the authenticated
+    // gh account; it cannot invent a token, so this only helps when gh state
+    // is broken rather than logged out.
+    const { repairGitIdentity } = await import('./git.lib.mjs');
+    const repaired = await repairGitIdentity();
+    await log(repaired.success ? '🔧 Repaired git/gh configuration with gh-setup-git-identity --repair' : `ℹ️  gh-setup-git-identity repair unavailable: ${repaired.error}`, { verbose: !repaired.success });
+    if (repaired.success) ({ token, source, error } = await resolveGitHubToken({ $, env }));
+  }
+
+  if (!token) {
+    await log(`⚠️  No GitHub token available for git transport${error ? ` (${error.split('\n')[0]})` : ''} - downloads from ${hosts.join(', ')} stay anonymous and can be throttled`, { level: 'warning' });
+    return { status: 'no-token', hosts, error };
+  }
+
+  Object.assign(env, buildGitAuthConfigEnv({ token, hosts, env }));
+  await log(`🔐 Authenticated git transport enabled for ${hosts.join(', ')} (token source: ${source})${reason ? ` - ${reason}` : ''}`, { verbose: true });
+  return { status: 'applied', hosts, source };
+};
+
+/**
+ * Point git at `gh` for credentials when nothing is configured yet.
+ *
+ * This is the *401* half of authentication (private repositories, pushes); the
+ * `extraheader` above is the *200* half (public downloads). Both are needed:
+ * neither can replace the other.
+ *
+ * @param {object} params
+ * @param {Function} params.$ - command-stream `$` tag
+ * @param {Function} [params.log]
+ * @param {string} [params.host]
+ * @returns {Promise<{status: 'present'|'configured'|'failed', error?: string}>}
+ */
+export const ensureGlobalCredentialHelper = async ({ $, log = async () => {}, host = 'github.com' }) => {
+  const { quietProbe } = await import('./quiet-probe.lib.mjs');
+  const dollar = await resolveDollar($);
+  const existing = await quietProbe(dollar)`git config --get-all ${`credential.https://${host}.helper`}`;
+  const configured = (existing?.stdout?.toString() || '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean);
+  if (configured.length > 0) return { status: 'present' };
+
+  const setup = await quietProbe(dollar)`gh auth setup-git 2>&1`;
+  if (setup?.code === 0) {
+    await log(`🔑 Configured the gh credential helper for ${host}`, { verbose: true });
+    return { status: 'configured' };
+  }
+  const reason = (setup?.stdout?.toString() || setup?.stderr?.toString() || '').trim().split('\n')[0];
+  await log(`ℹ️  Could not configure a global git credential helper for ${host}${reason ? `: ${reason}` : ''}`, { verbose: true });
+  return { status: 'failed', error: reason };
+};
+
+export default {
+  ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS,
+  DEFAULT_AUTHENTICATED_HOSTS,
+  GIT_AUTH_TRANSPORT_DISABLE,
+  GIT_AUTH_TRANSPORT_MARKER,
+  buildAuthorizationHeader,
+  buildGitAuthConfigEnv,
+  ensureAuthenticatedGitTransport,
+  ensureGlobalCredentialHelper,
+  gitAuthConfigKey,
+  hasGitAuthConfig,
+  resolveDollar,
+  isAnonymousDownloadLimit,
+  isGitAuthTransportDisabled,
+  readGitConfigCount,
+  resolveGitHubToken,
+};

package/src/lib.mjs

@@ -710,6 +710,13 @@ export const gitCmdRetry = async (cmdFn, options = {}) => {
     const description = describeTransientError({ message: combinedOutput });
 
     if (description.transient && attempt < maxAttempts) {
+      // Issue #2192: GitHub rejected the request because it arrived
+      // *unauthenticated*. Waiting does not change that, so authenticate the
+      // transport (repairing the gh state if needed) before the next attempt.
+      if (description.category === 'github-anonymous-rate-limit') {
+        const { ensureAuthenticatedGitTransport } = await import('./git-auth-transport.lib.mjs');
+        await ensureAuthenticatedGitTransport({ log: logFn, repair: true, reason: `${label} rejected as unauthenticated` });
+      }
       const waitTime = delay * Math.pow(backoff, attempt - 1);
       await logFn(`⚠️ ${label}: transient git error (attempt ${attempt}/${maxAttempts}), retrying in ${Math.round(waitTime / 1000)}s... [${formatTransientDiagnostics(description)}]`, { level: 'warn' });
       await sleep(waitTime);

package/src/review.mjs

@@ -50,6 +50,7 @@ const fs = (await use('fs')).promises;
 import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 import { QUIET_PROBE } from './quiet-probe.lib.mjs';
 import { reportError } from './sentry.lib.mjs';
+import { ensureAuthenticatedGitTransport } from './git-auth-transport.lib.mjs'; // issue #2192
 import * as memoryCheck from './memory-check.mjs';
 
 // Import Claude execution functions
@@ -244,6 +245,11 @@ try {
   await log(`📝 Files changed: ${prDetails.files.length}`);
 
   // Clone the repository using gh tool with authentication
+  // Issue #2192: authenticate the git transport first. `gh repo clone` of a
+  // public repository sends no Authorization header (the credential helper is
+  // only consulted after a 401, and github.com answers 200), so without this the
+  // clone is anonymous and can be refused by GitHub's unauthenticated-download limiter.
+  await ensureAuthenticatedGitTransport({ $, log, reason: 'review clone' });
   await log(`\nCloning repository ${owner}/${repo} using gh tool...\n`);
   const cloneResult = await $`gh repo clone ${owner}/${repo} ${tempDir}`;
 

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

@@ -7,8 +7,18 @@
 // issue comment so it's excluded from --auto-attach-solution-summary's check.
 import { REPOSITORY_INITIALIZATION_REQUIRED_MARKER, postTrackedComment } from './tool-comments.lib.mjs';
 import { QUIET_PROBE } from './quiet-probe.lib.mjs'; // issue #2130: keep read-only probe payloads out of the attached log
+// Issue #2192: a credential helper is never consulted for a *public* clone
+// (github.com answers 200, so git never asks), which is why an authenticated
+// container still got throttled as anonymous. The token has to be sent
+// preemptively, before the first git network call.
+import { ensureAuthenticatedGitTransport } from './git-auth-transport.lib.mjs';
 
 export async function setupRepositoryAndClone({ argv, owner, repo, forkOwner, forkRepoName, tempDir, isContinueMode, issueUrl, log, $, needsClone = true }) {
+  // Issue #2192: authenticate git *before* the first clone/fetch. Doing this
+  // afterwards (as setupGitCredentialHelper does) is too late — the clone is the
+  // call GitHub rejected with "temporarily limiting some unauthenticated downloads".
+  await ensureAuthenticatedGitTransport({ $, log, reason: 'repository setup' });
+
   // Set up repository and handle forking
   const { repoToClone, forkedRepo, upstreamRemote, prForkOwner } = await setupRepository(argv, owner, repo, forkOwner, issueUrl, forkRepoName);
 

package/src/solve.repository.lib.mjs

@@ -31,6 +31,9 @@ import { ensureAiToolScratchIgnored } from './ai-tool-scratch.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 GitHub utilities for permission checks
 const githubLib = await import('./github.lib.mjs');
@@ -949,6 +952,14 @@ export const classifyCloneError = errorOutput => {
     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' };
@@ -1075,6 +1086,9 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
         await log('     • Network connectivity issues');
         if (errorClassification.type === 'TRANSIENT') await log('     • GitHub server issues (temporary)');
         if (errorClassification.type === 'RATE_LIMIT') await log('     • API rate limiting exceeded');
+        // Issue #2192: the request never carried an Authorization header, so
+        // GitHub counted it against the anonymous budget regardless of `gh auth status`.
+        if (errorClassification.type === 'ANONYMOUS_RATE_LIMIT') await log('     • The clone was sent anonymously — GitHub throttles unauthenticated downloads');
         // Issue #1957: the transfer started but was interrupted (e.g. the connection
         // dropped while reading the pack). The retries above were already exhausted.
         if (errorClassification.type === 'NETWORK') await log('     • Connection dropped mid-transfer (the clone was interrupted before completing)');
@@ -1087,6 +1101,11 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
         if (argv.fork) await log(`     4. Check fork: gh repo view ${repoToClone}`);
         if (errorClassification.type === 'TRANSIENT') await log('     5. Wait and retry / check: https://www.githubstatus.com');
         if (errorClassification.type === 'RATE_LIMIT') await log('     5. Wait for rate limit to reset or use --token with different token');
+        if (errorClassification.type === 'ANONYMOUS_RATE_LIMIT') {
+          await log('     5. Make sure a token is available to git: gh auth token (or set GH_TOKEN)');
+          await log('     6. Repair the git/gh state non-interactively: gh-setup-git-identity --repair');
+          await log(`     7. Hive Mind normally authenticates git itself; if that was turned off, unset ${GIT_AUTH_TRANSPORT_DISABLE}`);
+        }
         if (errorClassification.type === 'NETWORK') {
           await log('     5. Check your network connection / VPN / proxy, then re-run the command');
           await log('     6. On slow or unstable links, a shallower history transfers faster and is less');
@@ -1100,6 +1119,13 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
     // Retryable error and we have attempts left
     const delay = baseDelay * Math.pow(2, attempt - 1); // Exponential backoff
     await log(`${formatAligned('⚠️', 'Clone failed:', errorClassification.description)}`);
+    // Issue #2192: auto-recovery. GitHub rejected the download as anonymous, so a
+    // plain retry would be rejected the same way. Authenticate the transport (and,
+    // if no token is reachable, let `gh-setup-git-identity --repair` restore the
+    // gh state non-interactively) before spending the next attempt.
+    if (errorClassification.type === 'ANONYMOUS_RATE_LIMIT') {
+      await ensureAuthenticatedGitTransport({ $, log, repair: true, reason: 'GitHub rejected the clone as unauthenticated' });
+    }
     await log(`${formatAligned('⏳', 'Retrying:', `Waiting ${delay / 1000}s before attempt ${attempt + 1}/${maxRetries}...`)}`);
     if (errorClassification.type === 'RATE_LIMIT') {
       await log('     💡 Tip: Rate limiting detected - using longer delay');

package/src/transient-errors.lib.mjs

@@ -75,11 +75,25 @@ export const GITHUB_SERVER_TRANSIENT_PATTERNS = Object.freeze([
  */
 export const GIT_TRANSIENT_PATTERNS = Object.freeze(['unexpected disconnect', 'sideband', 'early eof', 'the remote end hung up', 'remote end hung up unexpectedly', 'rpc failed', 'fetch-pack', 'index-pack failed', 'transfer closed', 'unable to access', 'could not read from remote repository', 'failed to connect to github.com', 'operation timed out after', 'gnutls_handshake() failed', 'the requested url returned error: 5']);
 
+/**
+ * GitHub throttling *anonymous* git downloads (issue #2192):
+ *
+ *   fatal: remote error: GitHub is temporarily limiting some unauthenticated
+ *   downloads to protect the stability of the platform. Please retry later or
+ *   authenticate.
+ *
+ * Retryable — GitHub itself says "retry later" — but the *real* fix is to
+ * authenticate, which `src/git-auth-transport.lib.mjs` does before retrying.
+ * Kept as its own category so a run that hits this is never diagnosed as a
+ * generic network fault (the failing run reported "Unknown error" three times).
+ */
+export const ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS = Object.freeze(['temporarily limiting some unauthenticated downloads', 'limiting some unauthenticated downloads', 'please retry later or authenticate', 'retry later or authenticate']);
+
 /**
  * Union used by the general-purpose `isTransientNetworkError` helpers. Kept as
  * a single flat list so a caller cannot accidentally miss a category.
  */
-export const ALL_TRANSIENT_PATTERNS = Object.freeze([...NETWORK_TRANSIENT_PATTERNS, ...GITHUB_SERVER_TRANSIENT_PATTERNS, ...GIT_TRANSIENT_PATTERNS]);
+export const ALL_TRANSIENT_PATTERNS = Object.freeze([...NETWORK_TRANSIENT_PATTERNS, ...GITHUB_SERVER_TRANSIENT_PATTERNS, ...GIT_TRANSIENT_PATTERNS, ...ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS]);
 
 /**
  * Pull every plausible string out of an error-ish value so pattern matches
@@ -126,6 +140,15 @@ const matchPattern = (error, patterns) => {
  */
 export const isTransientNetworkError = error => matchPattern(error, ALL_TRANSIENT_PATTERNS) !== null;
 
+/**
+ * True when `error` is GitHub refusing an *unauthenticated* git download.
+ * The remedy is to authenticate the transport, not merely to wait.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export const isAnonymousDownloadLimit = error => matchPattern(error, ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS) !== null;
+
 /**
  * True when `error` is a GitHub server-side fault (5xx or GraphQL internal).
  * Narrower than `isTransientNetworkError` — used for logging/classification.
@@ -174,7 +197,7 @@ export const parseGitHubRequestId = error => {
  * Full classification of a failure, for retry decisions *and* for diagnostics.
  *
  * @param {unknown} error
- * @returns {{transient: boolean, category: 'network'|'github-server'|'git-transport'|null, matchedPattern: string|null, requestId: string|null, text: string}}
+ * @returns {{transient: boolean, category: 'network'|'github-server'|'git-transport'|'github-anonymous-rate-limit'|null, matchedPattern: string|null, requestId: string|null, text: string}}
  */
 export const describeTransientError = error => {
   const text = collectErrorText(error);
@@ -184,10 +207,16 @@ export const describeTransientError = error => {
   const networkPattern = find(NETWORK_TRANSIENT_PATTERNS);
   const serverPattern = find(GITHUB_SERVER_TRANSIENT_PATTERNS);
   const gitPattern = find(GIT_TRANSIENT_PATTERNS);
+  const anonymousPattern = find(ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS);
 
   let category = null;
   let matchedPattern = null;
-  if (networkPattern) {
+  if (anonymousPattern) {
+    // Checked first: this failure has a specific remedy (authenticate) and its
+    // text also mentions timeouts/retries that the other lists could match.
+    category = 'github-anonymous-rate-limit';
+    matchedPattern = anonymousPattern;
+  } else if (networkPattern) {
     category = 'network';
     matchedPattern = networkPattern;
   } else if (serverPattern) {
@@ -224,11 +253,13 @@ export const formatTransientDiagnostics = description => {
 };
 
 export default {
+  ANONYMOUS_DOWNLOAD_LIMIT_PATTERNS,
   NETWORK_TRANSIENT_PATTERNS,
   GITHUB_SERVER_TRANSIENT_PATTERNS,
   GIT_TRANSIENT_PATTERNS,
   ALL_TRANSIENT_PATTERNS,
   collectErrorText,
+  isAnonymousDownloadLimit,
   isTransientNetworkError,
   isGitHubServerError,
   matchTransientPattern,