@link-assistant/hive-mind 1.46.7 → 1.46.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 1.46.9
+
+### Patch Changes
+
+- 8104fad: Fix wrong context window calculation showing impossible percentages like 250% (Issue #1539). When peakContextUsage is unknown (e.g. sub-agent models from result JSON only), skip the context window input tokens display entirely instead of falling back to cumulative totals across all requests, which are not valid per-request context window metrics.
+
+## 1.46.8
+
+### Patch Changes
+
+- Fix wrong context window calculation showing impossible percentages like 250% (Issue #1539). When peakContextUsage is unknown (e.g. sub-agent models from result JSON only), skip the context window input tokens display entirely instead of falling back to cumulative totals across all requests, which are not valid per-request context window metrics.
+- bcf2b9b: Retry on network issues and minimize terminal/log output differences (#1536): add ghRetry/ghCmdRetry utilities with exponential backoff for transient network errors (TCP reset, TLS timeout, connection refused, unexpected EOF). Apply retry to critical gh CLI calls: accept-invite, repository setup, auto-fork permission check, visibility detection, write permission check. Log stderr to log file on command failure for terminal/log parity. Add 'unexpected eof' to transient error detection patterns.
+
 ## 1.46.7
 
 ### Patch Changes

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -158,16 +158,19 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const subSessions = tokenUsage?.subSessions || [];
   const hasMultipleSubSessions = subSessions.length > 1;
 
+  const peakContext = usage.peakContextUsage || 0;
+
   if (hasMultipleSubSessions) {
     for (let i = 0; i < subSessions.length; i++) {
       const sub = subSessions[i];
       const subPeak = sub.peakContextUsage || 0;
-      const subCumulative = (sub.inputTokens || 0) + (sub.cacheCreationTokens || 0) + (sub.cacheReadTokens || 0);
-      const contextValue = subPeak > 0 ? subPeak : subCumulative;
+      // Issue #1539: Only use peak per-request context for context window display.
+      // Cumulative totals across all requests can exceed the context limit and produce
+      // impossible percentages (e.g. 250%). When peak is unknown, skip context display.
       const parts = [];
-      if (contextLimit && contextValue > 0) {
-        const pct = ((contextValue / contextLimit) * 100).toFixed(0);
-        parts.push(`${formatNumber(contextValue)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
+      if (contextLimit && subPeak > 0) {
+        const pct = ((subPeak / contextLimit) * 100).toFixed(0);
+        parts.push(`${formatNumber(subPeak)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
       }
       if (outputLimit) {
         const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
@@ -177,15 +180,12 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
         await log(`        ${i + 1}. Context window: ${parts.join(', ')}`);
       }
     }
-  } else {
-    // Single sub-session: single-line format
-    const peakContext = usage.peakContextUsage || 0;
-    const cumulativeContext = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-    const contextValue = peakContext > 0 ? peakContext : cumulativeContext;
+  } else if (peakContext > 0) {
+    // Single sub-session with known peak: single-line format
     const parts = [];
-    if (contextLimit && contextValue > 0) {
-      const pct = ((contextValue / contextLimit) * 100).toFixed(0);
-      parts.push(`${formatNumber(contextValue)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
+    if (contextLimit) {
+      const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+      parts.push(`${formatNumber(peakContext)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
     }
     if (outputLimit) {
       const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
@@ -195,6 +195,8 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
       await log(`        Context window: ${parts.join(', ')}`);
     }
   }
+  // Issue #1539: When peakContextUsage is unknown, skip context window line entirely.
+  // Cumulative totals are shown on the Total line below — no duplication needed.
 
   // Cumulative totals — single line
   const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
@@ -202,6 +204,11 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
   let totalLine = `${formatNumber(totalInputNonCached)}`;
   if (cachedTokens > 0) totalLine += ` + ${formatNumber(cachedTokens)} cached`;
   totalLine += ` input tokens, ${formatNumber(usage.outputTokens)} output tokens`;
+  // Issue #1539: When peakContextUsage is unknown, embed output percentage in Total line
+  if (peakContext === 0 && outputLimit) {
+    const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+    totalLine += ` (${outPct}% of ${formatNumber(outputLimit)} output limit)`;
+  }
   await log(`        Total: ${totalLine}`);
 };
 
@@ -230,6 +237,15 @@ export const mergeResultModelUsage = (modelUsage, resultModelUsage) => {
       if (resultUsage.costUSD != null) {
         modelUsage[modelId]._resultCostUSD = resultUsage.costUSD;
       }
+      // Issue #1539: Extract model limits from result JSON for sub-agent models
+      // Claude Code's result event includes contextWindow and maxOutputTokens per model,
+      // which we use as fallback when modelInfo API is unavailable.
+      if (resultUsage.contextWindow) {
+        modelUsage[modelId]._resultContextWindow = resultUsage.contextWindow;
+      }
+      if (resultUsage.maxOutputTokens) {
+        modelUsage[modelId]._resultMaxOutputTokens = resultUsage.maxOutputTokens;
+      }
     } else {
       const jsonlUsage = modelUsage[modelId];
       const jsonlTotal = jsonlUsage.inputTokens + jsonlUsage.cacheCreationTokens + jsonlUsage.cacheReadTokens + jsonlUsage.outputTokens;
@@ -244,6 +260,13 @@ export const mergeResultModelUsage = (modelUsage, resultModelUsage) => {
       if (resultUsage.costUSD != null) {
         jsonlUsage._resultCostUSD = resultUsage.costUSD;
       }
+      // Issue #1539: Also extract model limits from result JSON as fallback
+      if (resultUsage.contextWindow) {
+        jsonlUsage._resultContextWindow = resultUsage.contextWindow;
+      }
+      if (resultUsage.maxOutputTokens) {
+        jsonlUsage._resultMaxOutputTokens = resultUsage.maxOutputTokens;
+      }
     }
   }
 };
@@ -274,36 +297,35 @@ const formatSubSessionsList = (subSessions, contextLimit, outputLimit) => {
   let result = '';
   for (let i = 0; i < subSessions.length; i++) {
     const sub = subSessions[i];
+    // Issue #1539: Only use peak per-request context; skip context display when unknown
     const subPeakContext = sub.peakContextUsage || 0;
-    // Cumulative fallback: inputTokens + cacheCreationTokens + cacheReadTokens for this sub-session
-    const subCumulative = (sub.inputTokens || 0) + (sub.cacheCreationTokens || 0) + (sub.cacheReadTokens || 0);
-    result += formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `, subCumulative);
+    result += formatContextOutputLine(subPeakContext, contextLimit, sub.outputTokens, outputLimit, `${i + 1}. `);
   }
   return result;
 };
 
 /**
  * Issue #1526: Build a single-line context window + output tokens string.
+ * Issue #1539: Only show context window when peakContext > 0 (per-request peak known).
+ * When peakContext is 0 (unknown), context part is omitted to avoid misleading percentages.
  * Format: "- Context window: X / Y input tokens (Z%), A / B output tokens (W%)"
- * When only one of context or output limits is available, shows just that part.
- * @param {number} peakContext - Peak context usage (0 if unknown)
+ * @param {number} peakContext - Peak context usage (0 if unknown — context display skipped)
  * @param {number} contextLimit - Context window limit (null if unknown)
  * @param {number} outputTokens - Output tokens used
  * @param {number} outputLimit - Output token limit (null if unknown)
  * @param {string} [prefix='- '] - Line prefix
  * @returns {string} Formatted line or empty string
  */
-const formatContextOutputLine = (peakContext, contextLimit, outputTokens, outputLimit, prefix = '- ', cumulativeContext = 0) => {
+const formatContextOutputLine = (peakContext, contextLimit, outputTokens, outputLimit, prefix = '- ') => {
   const parts = [];
   if (contextLimit) {
-    // Use peakContextUsage when available (per-request peak from JSONL tracking).
-    // Fall back to cumulative total (inputTokens + cacheCreationTokens + cacheReadTokens)
-    // when peak is unknown (e.g., model only from result JSON, not in JSONL).
-    // Issue #1526: Never skip context display — always show what data we have.
-    const contextValue = peakContext > 0 ? peakContext : cumulativeContext;
-    if (contextValue > 0) {
-      const pct = ((contextValue / contextLimit) * 100).toFixed(0);
-      parts.push(`${formatTokensCompact(contextValue)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`);
+    // Issue #1539: Only use peak per-request context for context window display.
+    // When peak is unknown (e.g., model only from result JSON, not in JSONL),
+    // skip context display. Cumulative totals across all requests are not valid
+    // context window metrics and produce impossible percentages (e.g. 250%).
+    if (peakContext > 0) {
+      const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+      parts.push(`${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`);
     }
   }
   if (outputLimit) {
@@ -322,7 +344,8 @@ const formatContextOutputLine = (peakContext, contextLimit, outputTokens, output
  * Sub-sessions are shown as a global section (not duplicated per model) since JSONL
  * sub-session tracking is global across all models.
  * Issue #1526: Shorter output format — context window + output tokens on single line.
- * Fix: exclude cacheReadTokens from context window fallback calculation (cumulative ≠ per-request).
+ * Issue #1539: Only display context window when peak per-request usage is known.
+ * Cumulative totals are never used as context window metrics (they can exceed model limits).
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens or buildAgentBudgetStats
  * @returns {string} Formatted markdown string for PR comment
  */
@@ -358,17 +381,17 @@ export const buildBudgetStatsString = tokenUsage => {
 
       if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
+      const peakContext = usage.peakContextUsage || 0;
+
       if (!isMultiModel && hasMultipleSubSessions) {
         // Single-model + multiple sub-sessions: show numbered sub-sessions under that model
         stats += formatSubSessionsList(subSessions, contextLimit, outputLimit);
-      } else {
+      } else if (peakContext > 0) {
         // Issue #1526: Single line format for context window + output tokens
-        // Use peakContextUsage when available; fall back to cumulative total when peak is unknown
-        // (e.g., for result-JSON-sourced sub-agent models where only cumulative totals are available)
-        const peakContext = usage.peakContextUsage || 0;
-        const cumulativeContext = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-        stats += formatContextOutputLine(peakContext, contextLimit, usage.outputTokens, outputLimit, '- ', cumulativeContext);
+        stats += formatContextOutputLine(peakContext, contextLimit, usage.outputTokens, outputLimit, '- ');
       }
+      // Issue #1539: When peakContextUsage is unknown, skip context window line entirely.
+      // Cumulative totals are shown on the Total line below — no duplication needed.
 
       // Cumulative totals per model: input tokens + cached shown separately
       // Issue #1526: Shorter format — single "Total:" line
@@ -378,6 +401,13 @@ export const buildBudgetStatsString = tokenUsage => {
       if (cachedTokens > 0) totalLine += ` + ${formatTokensCompact(cachedTokens)} cached`;
       totalLine += ` input tokens, ${formatTokensCompact(usage.outputTokens)} output tokens`;
 
+      // Issue #1539: When peakContextUsage is unknown (no per-request data), embed
+      // output token percentage in the Total line so no data is lost.
+      if (peakContext === 0 && outputLimit) {
+        const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+        totalLine += ` (${outPct}% of ${formatTokensCompact(outputLimit)} output limit)`;
+      }
+
       // Issue #1508: Show per-model cost when available
       if (usage.costUSD !== null && usage.costUSD !== undefined) {
         totalLine += `, $${usage.costUSD.toFixed(6)} cost`;

package/src/claude.lib.mjs

@@ -498,13 +498,10 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
   }
   // Initialize per-model usage tracking
   const modelUsage = {};
-  // Issue #1501: Deduplicate JSONL entries by message ID (upstream: anthropics/claude-code#6805)
-  // Claude Code's stream-json mode splits single API responses with multiple content blocks
-  // into separate JSONL entries, each with the same message ID and identical usage stats.
+  // Issue #1501: Deduplicate JSONL entries by message ID (stream-json splits responses)
   const seenMessageIds = new Set();
   let duplicateCount = 0;
   // Issue #1501: Track peak context usage per request (not cumulative)
-  // The context window limit is per-request, so we track the max single-request fill.
   const peakContextByModel = {};
   let globalPeakContext = 0;
   // Issue #1491: Track sub-sessions between compactification events
@@ -610,7 +607,10 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         usage.costUSD = usage._resultCostUSD ?? null;
         usage.costBreakdown = null;
         usage.modelName = modelId;
-        usage.modelInfo = null;
+        // Issue #1539: Use contextWindow/maxOutputTokens from result JSON as fallback model limits
+        const ctx = usage._resultContextWindow,
+          out = usage._resultMaxOutputTokens;
+        usage.modelInfo = ctx || out ? { limit: { context: ctx || null, output: out || null } } : null;
       }
     }
     // Calculate grand totals across all models

package/src/github.lib.mjs

@@ -2,7 +2,7 @@
 // GitHub-related utility functions. Check if use is already defined (when imported from solve.mjs), if not, fetch it (when running standalone)
 if (typeof globalThis.use === 'undefined') globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
 const { $ } = await use('command-stream'); // Use command-stream for consistent $ behavior
-import { log, maskToken, cleanErrorMessage, isENOSPC } from './lib.mjs';
+import { log, maskToken, cleanErrorMessage, isENOSPC, ghCmdRetry } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
@@ -172,8 +172,8 @@ export const checkRepositoryWritePermission = async (owner, repo, options = {})
   }
   try {
     await log('🔍 Checking repository write permissions...');
-    // Use GitHub API to check repository permissions
-    const permResult = await $`gh api repos/${owner}/${repo} --jq .permissions`;
+    // Use GitHub API to check repository permissions (issue #1536: retry on network errors)
+    const permResult = await ghCmdRetry(() => $`gh api repos/${owner}/${repo} --jq .permissions`, { label: `write perms ${owner}/${repo}` });
     if (permResult.code !== 0) {
       // API call failed - might be a private repo or network issue
       const errorOutput = (permResult.stderr ? permResult.stderr.toString() : '') + (permResult.stdout ? permResult.stdout.toString() : '');
@@ -1437,7 +1437,8 @@ export async function handlePRNotFoundError({ prNumber, owner, repo, argv, shoul
  */
 export async function detectRepositoryVisibility(owner, repo) {
   try {
-    const visibilityResult = await $`gh api repos/${owner}/${repo} --jq .visibility`;
+    // Issue #1536: retry on transient network errors
+    const visibilityResult = await ghCmdRetry(() => $`gh api repos/${owner}/${repo} --jq .visibility`, { label: `visibility ${owner}/${repo}` });
     if (visibilityResult.code === 0) {
       const visibility = visibilityResult.stdout.toString().trim();
       const isPublic = visibility === 'public';

package/src/lib.mjs

@@ -291,11 +291,92 @@ export const isTransientNetworkError = error => {
   const output = (error?.stderr?.toString() || error?.stdout?.toString() || '').toLowerCase();
   const combined = msg + ' ' + output;
 
-  const transientPatterns = ['i/o timeout', 'dial tcp', 'connection refused', 'connection reset', 'econnreset', 'etimedout', 'enotfound', 'ehostunreach', 'enetunreach', 'network is unreachable', 'temporary failure', 'http 502', 'http 503', 'http 504', 'bad gateway', 'service unavailable', 'gateway timeout', 'tls handshake timeout', 'ssl_error', 'socket hang up'];
+  // Issue #1536: added 'unexpected eof' — seen in gh CLI when connection drops mid-response
+  const transientPatterns = ['i/o timeout', 'dial tcp', 'connection refused', 'connection reset', 'econnreset', 'etimedout', 'enotfound', 'ehostunreach', 'enetunreach', 'network is unreachable', 'temporary failure', 'http 502', 'http 503', 'http 504', 'bad gateway', 'service unavailable', 'gateway timeout', 'tls handshake timeout', 'ssl_error', 'socket hang up', 'unexpected eof'];
 
   return transientPatterns.some(pattern => combined.includes(pattern));
 };
 
+/**
+ * Retry a GitHub CLI / API operation with exponential backoff on transient network errors.
+ * Unlike the generic `retry()`, this function:
+ * - Only retries on transient network errors (TCP reset, TLS timeout, etc.)
+ * - Immediately rethrows non-transient errors (404, 403, auth failures)
+ * - Logs stderr to the log file when a command fails (fixing terminal/log parity)
+ *
+ * Issue #1536: Most gh commands had no retry logic, causing solve to abort on
+ * intermittent network issues.
+ *
+ * @param {Function} fn - Async function to execute (should call gh CLI or GitHub API)
+ * @param {Object} [options] - Options
+ * @param {number} [options.maxAttempts=3] - Maximum number of attempts
+ * @param {number} [options.delay=1000] - Initial delay between retries in ms
+ * @param {number} [options.backoff=2] - Backoff multiplier
+ * @param {string} [options.label='gh command'] - Label for log messages
+ * @returns {Promise<*>} Result of successful function execution
+ * @throws {Error} Last error if all attempts fail or error is non-transient
+ */
+export const ghRetry = async (fn, options = {}) => {
+  const { maxAttempts = 3, delay = 1000, backoff = 2, label = 'gh command' } = options;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (isTransientNetworkError(error) && attempt < maxAttempts) {
+        const waitTime = delay * Math.pow(backoff, attempt - 1);
+        await log(`⚠️ ${label}: Network error (attempt ${attempt}/${maxAttempts}), retrying in ${waitTime / 1000}s...`, { level: 'warn' });
+        await sleep(waitTime);
+        continue;
+      }
+      throw error;
+    }
+  }
+};
+
+/**
+ * Execute a command-stream `$` call with retry on transient network errors.
+ * This wraps the pattern: call $`gh ...`, check exit code, handle errors.
+ * On failure, stderr is logged to the log file (fixing terminal/log parity from issue #1536).
+ *
+ * @param {Function} cmdFn - Function that returns a command-stream result (e.g., () => $`gh api ...`)
+ * @param {Object} [options] - Options
+ * @param {number} [options.maxAttempts=3] - Maximum number of attempts
+ * @param {number} [options.delay=1000] - Initial delay between retries in ms
+ * @param {number} [options.backoff=2] - Backoff multiplier
+ * @param {string} [options.label='gh command'] - Label for log messages
+ * @returns {Promise<{stdout: string, stderr: string, code: number}>} Command result
+ */
+export const ghCmdRetry = async (cmdFn, options = {}) => {
+  const { maxAttempts = 3, delay = 1000, backoff = 2, label = 'gh command' } = options;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await cmdFn();
+
+    // Log stderr to log file for parity (issue #1536)
+    const stderr = result.stderr?.toString().trim();
+    if (stderr && result.code !== 0) {
+      await log(`   [stderr] ${stderr}`, { level: 'warn' });
+    }
+
+    if (result.code === 0) {
+      return result;
+    }
+
+    // Check if this is a transient network error worth retrying
+    const combinedOutput = (result.stdout?.toString() || '') + ' ' + (result.stderr?.toString() || '');
+    if (isTransientNetworkError({ message: combinedOutput }) && attempt < maxAttempts) {
+      const waitTime = delay * Math.pow(backoff, attempt - 1);
+      await log(`⚠️ ${label}: Network error (attempt ${attempt}/${maxAttempts}), retrying in ${waitTime / 1000}s...`, { level: 'warn' });
+      await sleep(waitTime);
+      continue;
+    }
+
+    // Non-transient error or last attempt — return the result as-is
+    return result;
+  }
+};
+
 /**
  * Format bytes to human readable string
  * @param {number} bytes - Number of bytes

package/src/solve.accept-invite.lib.mjs

@@ -5,9 +5,13 @@
  * this module only accepts the invitation for the specific repository or organization
  * that is being solved. This is safer and more targeted.
  *
+ * Issue #1536: Added retry with exponential backoff for transient network errors
+ * (TLS handshake timeout, unexpected EOF, connection reset, etc.)
+ *
  * @see https://docs.github.com/en/rest/collaborators/invitations
  * @see https://docs.github.com/en/rest/orgs/members
  * @see https://github.com/link-assistant/hive-mind/issues/1373
+ * @see https://github.com/link-assistant/hive-mind/issues/1536
  */
 
 import { promisify } from 'util';
@@ -15,6 +19,10 @@ import { exec as execCallback } from 'child_process';
 
 const exec = promisify(execCallback);
 
+// Import retry utility (issue #1536)
+const lib = await import('./lib.mjs');
+const { ghRetry } = lib;
+
 /**
  * Accepts pending GitHub repository or organization invitation for a specific target.
  *
@@ -35,7 +43,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
 
   // Check for pending repository invitation
   try {
-    const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
+    const { stdout: repoInvJson } = await ghRetry(() => exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"'), { label: 'fetch repo invitations' });
     const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
     verbose && (await log(`   Found ${repoInvitations.length} total pending repo invitation(s)`, { verbose: true }));
 
@@ -43,7 +51,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
 
     if (matchingInv) {
       try {
-        await exec(`gh api -X PATCH /user/repository_invitations/${matchingInv.id}`);
+        await ghRetry(() => exec(`gh api -X PATCH /user/repository_invitations/${matchingInv.id}`), { label: `accept repo invitation for ${fullName}` });
         await log(`✅ --auto-accept-invite: Accepted repository invitation for ${fullName}`);
         result.acceptedRepo = true;
       } catch (e) {
@@ -58,7 +66,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
 
   // Check for pending organization membership
   try {
-    const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+    const { stdout: orgMemJson } = await ghRetry(() => exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"'), { label: 'fetch org memberships' });
     const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
     const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
     verbose && (await log(`   Found ${pendingOrgs.length} total pending org invitation(s)`, { verbose: true }));
@@ -68,7 +76,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
     if (matchingOrg) {
       const orgName = matchingOrg.organization.login;
       try {
-        await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
+        await ghRetry(() => exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`), { label: `accept org invitation for ${orgName}` });
         await log(`✅ --auto-accept-invite: Accepted organization invitation for ${orgName}`);
         result.acceptedOrg = true;
       } catch (e) {

package/src/solve.mjs

@@ -239,9 +239,9 @@ const claudePath = argv.executeToolWithBun ? 'bunx claude' : process.env.CLAUDE_
 if (argv.autoFork && !argv.fork) {
   const { detectRepositoryVisibility } = githubLib;
 
-  // Check if we have write access first
+  // Check if we have write access first (issue #1536: retry on transient network errors)
   await log('🔍 Checking repository access for auto-fork...');
-  const permResult = await $`gh api repos/${owner}/${repo} --jq .permissions`;
+  const permResult = await lib.ghCmdRetry(() => $`gh api repos/${owner}/${repo} --jq .permissions`, { label: 'auto-fork perms' });
 
   if (permResult.code === 0) {
     const permissions = JSON.parse(permResult.stdout.toString().trim());

package/src/solve.repository.lib.mjs

@@ -36,7 +36,7 @@ const { checkRepositoryWritePermission } = githubLib;
 // Get root repository (fork source or self), or null if inaccessible
 export const getRootRepository = async (owner, repo) => {
   try {
-    const result = await $`gh api repos/${owner}/${repo} --jq '{fork: .fork, source: .source.full_name}' 2>&1`;
+    const result = await lib.ghCmdRetry(() => $`gh api repos/${owner}/${repo} --jq '{fork: .fork, source: .source.full_name}' 2>&1`, { label: `get root repo ${owner}/${repo}` });
     if (result.code !== 0) return null;
 
     const repoInfo = JSON.parse(result.stdout.toString().trim());
@@ -50,11 +50,10 @@ export const getRootRepository = async (owner, repo) => {
 // Check if current user has a fork of the given root repository
 export const checkExistingForkOfRoot = async rootRepo => {
   try {
-    const userResult = await $`gh api user --jq .login`;
+    const userResult = await lib.ghCmdRetry(() => $`gh api user --jq .login`, { label: 'get user (fork check)' });
     if (userResult.code !== 0) return null;
     const currentUser = userResult.stdout.toString().trim();
-
-    const forksResult = await $`gh api repos/${rootRepo}/forks --paginate --jq '.[] | select(.owner.login == "${currentUser}") | .full_name'`;
+    const forksResult = await lib.ghCmdRetry(() => $`gh api repos/${rootRepo}/forks --paginate --jq '.[] | select(.owner.login == "${currentUser}") | .full_name'`, { label: `check forks of ${rootRepo}` });
     if (forksResult.code !== 0) return null;
 
     const forks = forksResult.stdout
@@ -363,8 +362,8 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
     await log(`\n${formatAligned('🍴', 'Fork mode:', 'ENABLED')}`);
     await log(`${formatAligned('', 'Checking fork status...', '')}\n`);
 
-    // Get current user
-    const userResult = await $`gh api user --jq .login`;
+    // Get current user (issue #1536: retry on transient network errors)
+    const userResult = await lib.ghCmdRetry(() => $`gh api user --jq .login`, { label: 'get current user' });
     if (userResult.code !== 0) {
       await log(`${formatAligned('❌', 'Error:', 'Failed to get current user')}`);
       await safeExit(1, 'Repository setup failed');