@link-assistant/hive-mind 1.76.0 → 1.76.2

package/CHANGELOG.md

@@ -1,5 +1,88 @@
 # @link-assistant/hive-mind
 
+## 1.76.2
+
+### Patch Changes
+
+- 5d8d6c1: fix(cost): accumulate Anthropic cost across limit-reset resumes (#1886)
+
+  The session cost summary could report a large negative "Difference" (e.g.
+  `$-11.422796 (-31.66%)`) between the public pricing estimate and the Anthropic
+  figure. Root cause: the public estimate is computed from the session JSONL,
+  which accumulates the **entire** session across every limit-reset resume, while
+  the Anthropic `total_cost_usd` from the stream-json `result` event is scoped to a
+  **single** Claude process (only the resumed run). Comparing a full-session
+  estimate against a single-process figure produced a misleading gap even though
+  both numbers were individually correct.
+
+  The per-token math (`calculateModelCost`) was audited and is correct; this is a
+  scope mismatch, not a pricing error.
+
+  Fix:
+  - New `src/anthropic-cost-accumulator.lib.mjs` keeps a model-agnostic running
+    total of Anthropic's per-process `total_cost_usd` (it sums dollars, never
+    inspecting per-token prices, so it is correct for all models).
+  - `runClaude` seeds from and returns the cumulative total on every terminal path;
+    the cross-process limit-reset resume threads it via a new hidden
+    `--previous-anthropic-cost` option (`autoContinueWhenLimitResets`).
+  - A usage-limit hit ends as `is_error` with no `success` result event, so its
+    cost was previously discarded. The cost from a non-success terminal `result`
+    event is now kept as a fallback and folded into the accumulator, closing the
+    gap in the reported scenario.
+  - `displayCostComparison` / `displaySessionTokenUsage` print a verbose
+    accumulation breakdown ("cumulative across resume iterations: this run … +
+    carried forward … = …") so the figure is never mysterious again.
+
+  A deep case study (timeline, proven root causes, exact reproduced numbers, online
+  prior art incl. `anthropics/claude-code#13088`) is compiled under
+  `docs/case-studies/issue-1886/`.
+
+## 1.76.1
+
+### Patch Changes
+
+- 13e7e6a: Docker isolation: reuse the host image instead of re-downloading a copy inside the (nested) Docker daemon (#1879).
+  - src/isolation-runner.lib.mjs: add `HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG` to pin the
+    isolation image tag, and `HIVE_MIND_DOCKER_ISOLATION_PULL` (always|missing|never) to emit a
+    `docker run --pull` policy. Verbose mode now logs the resolved image and pull policy.
+  - scripts/preload-dind-isolation-image.mjs: seed a DinD container's nested daemon from the
+    host (`docker save | docker exec -i … docker load`) so isolated tasks reuse the host image.
+  - .env.example: document the Docker isolation image/pull controls.
+  - Dockerfile / Dockerfile.dind / coolify/Dockerfile: bump the box base images to
+    `konard/box:2.2.0` / `konard/box-dind:2.2.0` (and the `docs/UBUNTU-SERVER*.md` examples).
+    v2.2.0 ships box's native host-image passthrough (box#94/#95), so the DinD deployment can seed
+    the nested daemon from the host automatically with
+    `-v /var/run/docker.sock:/var/run/host-docker.sock:ro -e DIND_HOST_PASSTHROUGH=public`.
+  - tests/test-issue-1879-docker-image-reuse.mjs: regression coverage.
+  - docs/case-studies/issue-1879: deep case study with logs, timeline, root causes, and runbook;
+    records that box#94 shipped in v2.2.0 and reports two upstream follow-ups — box#96
+    (public-mode passthrough test false positive) and box#97 (per-repository passthrough allowlist).
+
+- 7335a73: Continue fork PRs with "Allow edits by maintainers" instead of halting on a misclassified fork divergence (#1893).
+
+  When the solver continues a cross-repository PR opened from another contributor's fork, it
+  synced the upstream default branch and then tried to push it back to `origin` — the
+  contributor's fork, which the operating maintainer does not own. GitHub rejected the push
+  with `! [remote rejected] main -> main (permission denied)`, and the solver misclassified
+  that permission error as a fork divergence (the heuristic matched the substring `rejected`),
+  halting with `Repository setup halted - fork divergence requires user decision` and advising
+  `--allow-fork-divergence-resolution-using-force-push-with-lease` — a flag that cannot help,
+  since force-push also requires fork write access.
+  - src/solve.branch-divergence.lib.mjs: add two pure helpers —
+    `shouldPushDefaultBranchToFork({currentUser, forkedRepo})` (skip the push when the user does
+    not own the fork; fail-open when owner/user is unknown) and `isPermissionDeniedPushError()`
+    (recognize a permission-denied rejection so it is never treated as divergence).
+  - src/solve.fork-sync.lib.mjs: new module holding `setupUpstreamAndSync` (extracted from
+    solve.repository.lib.mjs to stay under the 1500-line limit, re-exported unchanged). It now
+    resolves the current user, skips the fork's default-branch push when the user is not the fork
+    owner, and on a permission-denied push warns and continues on the PR branch instead of
+    halting. Genuine non-fast-forward divergence still triggers the original guidance. Adds
+    verbose diagnostics explaining each skip/continue decision.
+  - tests/test-issue-1893-fork-pr-permission-denied.mjs: regression coverage (9 cases) using the
+    exact failure output from the run log.
+  - docs/case-studies/issue-1893: deep case study with downloaded logs/data, timeline, root
+    causes, fix, codebase-wide audit, and existing-components review.
+
 ## 1.76.0
 
 ### Minor Changes

package/package.json

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

package/src/anthropic-cost-accumulator.lib.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * Issue #1886: Cumulative Anthropic cost across resume iterations.
+ *
+ * Background
+ * ----------
+ * The "Token Usage Summary" compares two numbers:
+ *   - "Public pricing estimate" — computed locally from the session JSONL by
+ *     `calculateSessionTokens`. The JSONL accumulates the *entire* logical
+ *     session: when a run hits a usage limit and is resumed (either in-process
+ *     via the auto-merge loop, or cross-process via
+ *     `autoContinueWhenLimitResets` spawning a fresh `solve` with `--resume`),
+ *     Claude Code appends to the *same* `<session-id>.jsonl`, so every run's
+ *     tokens are present.
+ *   - "Calculated by Anthropic" — taken from the `result` event's
+ *     `total_cost_usd`. That figure is scoped to a *single* Claude process: it
+ *     only covers the tokens that process produced, NOT the tokens inherited
+ *     from a previous run that was interrupted by a limit reset.
+ *
+ * The result is a scope mismatch, not a pricing bug. In issue #1886 the public
+ * estimate ($36.085016, full session) was compared against Anthropic's
+ * per-process figure ($24.662220, the resumed run only), yielding a misleading
+ * "-31.66%" difference even though both numbers are individually correct.
+ *
+ * The fix
+ * -------
+ * Accumulate Anthropic's reported cost across resume iterations so the figure
+ * shown next to the full-session public estimate covers the same scope. This
+ * module is the single source of truth for that running total:
+ *
+ *   - Each `solve` process seeds the accumulator once from
+ *     `--previous-anthropic-cost` (0 for the first run; the carried-forward
+ *     total for an auto-resumed run).
+ *   - Every finished Claude process adds its own `total_cost_usd` via
+ *     `addAnthropicRunCost`, which also covers the in-process auto-merge loop
+ *     (each iteration is a separate Claude process in the same node process).
+ *   - The display and the cross-process spawn both read the cumulative total,
+ *     so "Calculated by Anthropic" tracks the full session.
+ *
+ * The accumulation is model-agnostic: it sums dollar figures and never inspects
+ * per-token prices, so it is correct for Fable 5, Opus, Sonnet, Haiku, and any
+ * future model. See docs/case-studies/issue-1886/ for the full analysis.
+ */
+
+// Module-level singleton: the cumulative Anthropic cost for the current logical
+// session (this node process plus everything seeded from prior processes).
+let cumulativeAnthropicCostUSD = 0;
+// Seeding must happen exactly once per node process. The auto-merge loop calls
+// runClaude (and therefore the seed helper) repeatedly within a single process;
+// re-seeding from the same CLI flag each time would wipe out accumulation.
+let seeded = false;
+
+/**
+ * Coerce an arbitrary value to a non-negative finite USD amount.
+ * @param {*} value
+ * @returns {number} the sanitized amount, or 0 when not a positive finite number
+ */
+const toCostAmount = value => {
+  const n = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+};
+
+/**
+ * Seed the accumulator from the carried-forward previous-run cost, exactly once
+ * per node process. Subsequent calls are no-ops so the in-process auto-merge
+ * loop does not reset the running total.
+ * @param {number|string|null|undefined} previousAnthropicCostUSD
+ * @returns {number} the cumulative total after seeding
+ */
+export const seedCumulativeAnthropicCost = previousAnthropicCostUSD => {
+  if (seeded) return cumulativeAnthropicCostUSD;
+  cumulativeAnthropicCostUSD = toCostAmount(previousAnthropicCostUSD);
+  seeded = true;
+  return cumulativeAnthropicCostUSD;
+};
+
+/**
+ * Add a single Claude process's reported cost to the running total.
+ * Non-positive / non-finite inputs (e.g. a null cost when a run was interrupted
+ * by a limit before emitting a success result) contribute nothing.
+ * @param {number|string|null|undefined} runCostUSD
+ * @returns {number} the cumulative total after adding
+ */
+export const addAnthropicRunCost = runCostUSD => {
+  cumulativeAnthropicCostUSD += toCostAmount(runCostUSD);
+  return cumulativeAnthropicCostUSD;
+};
+
+/**
+ * @returns {number} the cumulative Anthropic cost for the current logical session
+ */
+export const getCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD;
+
+/**
+ * @returns {boolean} true once a positive cost has been seeded or accumulated
+ */
+export const hasCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD > 0;
+
+/**
+ * Reset the accumulator. Intended for tests — production code seeds once and
+ * accumulates for the lifetime of the process.
+ */
+export const resetCumulativeAnthropicCost = () => {
+  cumulativeAnthropicCostUSD = 0;
+  seeded = false;
+};

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

@@ -138,19 +138,38 @@ export const displayModelUsage = async (usage, log) => {
 /**
  * Display cost comparison between public pricing and Anthropic's official cost
  * Issue #1557: Show simplified format when costs match, remove USD suffix
- * @param {number|null} publicCost - Public pricing estimate
- * @param {number|null} anthropicCost - Anthropic's official cost
+ * Issue #1886: `anthropicCost` is the cumulative Anthropic cost across every
+ *   resume iteration (the session JSONL — and therefore `publicCost` — spans
+ *   the full session, so the Anthropic figure must too). The optional
+ *   `previousAnthropicCost` is the portion carried in from earlier runs; when
+ *   non-zero we show a verbose breakdown so the accumulation is auditable.
+ * @param {number|null} publicCost - Public pricing estimate (full session)
+ * @param {number|null} anthropicCost - Anthropic's cumulative official cost (full session)
  * @param {Function} log - Logging function
+ * @param {Object} [options]
+ * @param {number} [options.previousAnthropicCost=0] - cost carried in from earlier resume iterations
  */
-export const displayCostComparison = async (publicCost, anthropicCost, log) => {
+export const displayCostComparison = async (publicCost, anthropicCost, log, options = {}) => {
+  const previousAnthropicCost = options.previousAnthropicCost || 0;
   const hasPublic = publicCost !== null && publicCost !== undefined;
   const hasAnthropic = anthropicCost !== null && anthropicCost !== undefined;
   const publicDec = hasPublic ? new Decimal(publicCost) : null;
   const anthropicDec = hasAnthropic ? new Decimal(anthropicCost) : null;
+  // Issue #1886: when the Anthropic figure was accumulated across resumes,
+  // expose the breakdown in verbose mode so "this run + carried forward = total"
+  // is auditable from the saved log.
+  const logAccumulationBreakdown = async () => {
+    if (previousAnthropicCost > 0 && anthropicDec) {
+      const thisRun = anthropicDec.minus(new Decimal(previousAnthropicCost));
+      await log(`      ↳ Anthropic cost is cumulative across resume iterations (issue #1886):`, { verbose: true });
+      await log(`         this run: $${thisRun.toFixed(6)} + carried forward: $${new Decimal(previousAnthropicCost).toFixed(6)} = $${anthropicDec.toFixed(6)}`, { verbose: true });
+    }
+  };
   // Issue #1703: also collapse to the short form when the rounded difference is below display precision,
   // so reports like "Difference: $-0.000000 (-0.00%)" no longer waste two extra lines.
   if (publicDec && anthropicDec && anthropicDec.minus(publicDec).abs().toFixed(6) === '0.000000') {
     await log(`\n   💰 Cost: $${anthropicDec.toFixed(6)}`);
+    await logAccumulationBreakdown();
     return;
   }
   await log('\n   💰 Cost estimation:');
@@ -163,6 +182,7 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
   } else {
     await log('      Difference:              unknown');
   }
+  await logAccumulationBreakdown();
 };
 
 /**
@@ -316,11 +336,12 @@ export const displayBudgetStats = async (usage, tokenUsage, log) => {
  * @param {string} params.sessionId - Claude session id (skips when falsy)
  * @param {string} params.tempDir - Working directory containing the session JSONL (skips when falsy)
  * @param {Object|null} params.resultModelUsage - Authoritative per-model usage from the result JSON event
- * @param {number} params.anthropicTotalCostUSD - Anthropic's official total cost (for the comparison line)
+ * @param {number} params.anthropicTotalCostUSD - Anthropic's cumulative official cost across resume iterations (issue #1886)
+ * @param {number} [params.previousAnthropicCostUSD=0] - portion of anthropicTotalCostUSD carried in from earlier resume iterations (issue #1886)
  * @param {Object} params.argv - Parsed CLI args (reads argv.tokensBudgetStats)
  * @param {Function} params.log - Logger
  */
-export const displaySessionTokenUsage = async ({ sessionId, tempDir, resultModelUsage, anthropicTotalCostUSD, argv, log }) => {
+export const displaySessionTokenUsage = async ({ sessionId, tempDir, resultModelUsage, anthropicTotalCostUSD, previousAnthropicCostUSD = 0, argv, log }) => {
   if (!sessionId || !tempDir) return;
   try {
     const tokenUsage = await calculateSessionTokens(sessionId, tempDir, resultModelUsage);
@@ -355,7 +376,9 @@ export const displaySessionTokenUsage = async ({ sessionId, tempDir, resultModel
         await log('\n   📈 Total across all models:');
       }
       // Show cost comparison (for both single and multiple models)
-      await displayCostComparison(tokenUsage.totalCostUSD, anthropicTotalCostUSD, log);
+      // Issue #1886: anthropicTotalCostUSD is cumulative across resume iterations
+      // so it shares the full-session scope of the JSONL-based public estimate.
+      await displayCostComparison(tokenUsage.totalCostUSD, anthropicTotalCostUSD, log, { previousAnthropicCost: previousAnthropicCostUSD });
       // Show total tokens for single model only
       if (modelIds.length === 1) {
         await log(`      Total tokens: ${formatNumber(tokenUsage.totalTokens)}`);

package/src/claude.lib.mjs

@@ -17,6 +17,7 @@ import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import Decimal from 'decimal.js-light';
 import { createEmptySubSessionUsage, accumulateModelUsage, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage, getRawRequestInputTokens, displaySessionTokenUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand, buildClaudeAutonomousResumeCommand } from './claude.command-builder.lib.mjs';
+import { seedCumulativeAnthropicCost, addAnthropicRunCost } from './anthropic-cost-accumulator.lib.mjs'; // Issue #1886
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 import { SESSION_FORCE_KILLED_MARKER, postTrackedComment } from './tool-comments.lib.mjs'; // Issue #1625
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
@@ -662,6 +663,9 @@ export const executeClaudeCommand = async params => {
     let stderrErrors = [];
     let resultSuccessReceived = false;
     let anthropicTotalCostUSD = null;
+    // Issue #1886: a usage-limit hit ends as is_error (no success result). Keep
+    // the latest cost from ANY result event as a fallback for the failure path.
+    let anthropicCostFromAnyResult = null;
     let errorDuringExecution = false;
     let resultSummary = null;
     let resultModelUsage = null;
@@ -942,7 +946,9 @@ export const executeClaudeCommand = async params => {
                   anthropicTotalCostUSD = data.total_cost_usd;
                   await log(`💰 Anthropic official cost captured from success result: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });
                 } else if (data.total_cost_usd !== undefined && data.total_cost_usd !== null) {
-                  await log(`💰 Anthropic cost from ${data.subtype || 'unknown'} result ignored: $${data.total_cost_usd.toFixed(6)}`, { verbose: true });
+                  // Issue #1886: non-success terminal (e.g. usage-limit hit) still reports this process's cost — keep as accumulation fallback.
+                  anthropicCostFromAnyResult = data.total_cost_usd;
+                  await log(`💰 Anthropic cost from ${data.subtype || 'unknown'} result kept as fallback for accumulation: $${data.total_cost_usd.toFixed(6)}`, { verbose: true });
                 }
                 // Issue #1263: Extract result summary (AI's summary of work done) for --attach-solution-summary
                 if (data.subtype === 'success' && data.result && typeof data.result === 'string') {
@@ -1106,6 +1112,10 @@ export const executeClaudeCommand = async params => {
           await log(JSON.stringify(data, null, 2));
           if (data.type === 'result' && data.subtype === 'success' && data.total_cost_usd != null) {
             anthropicTotalCostUSD = data.total_cost_usd;
+          } else if (data.type === 'result' && data.total_cost_usd != null) {
+            // Issue #1886: keep a non-success terminal result's cost as a fallback
+            // for accumulation (see the streaming branch above).
+            anthropicCostFromAnyResult = data.total_cost_usd;
           }
           // Issue #1472: Forward remaining buffer event to interactive handler (was previously missed)
           if (interactiveHandler) {
@@ -1187,6 +1197,9 @@ export const executeClaudeCommand = async params => {
           await log(`\n\n❌ API explicitly marked error as not retryable (x-should-retry: false) and session made no progress (num_turns=${resultNumTurns}) after ${retryCount} attempt(s)`, { level: 'error' });
           await log(`   This error is not recoverable. Failing fast to avoid a stuck retry loop (Issue #1437).`, { level: 'error' });
           await log(`   Check https://status.anthropic.com/ for API status.`, { level: 'error' });
+          // Issue #1886: fold captured cost so a cross-process resume's carried-forward cost is not dropped here.
+          seedCumulativeAnthropicCost(argv.previousAnthropicCost);
+          const cumulativeAnthropicCostUSDOnStuckRetry = addAnthropicRunCost(anthropicTotalCostUSD ?? anthropicCostFromAnyResult);
           return {
             success: false,
             sessionId,
@@ -1196,7 +1209,7 @@ export const executeClaudeCommand = async params => {
             messageCount,
             toolUseCount,
             is503Error,
-            anthropicTotalCostUSD,
+            anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnStuckRetry, // Issue #1104/#1886
             resultSummary,
             // Issue #1845: surface the actual error so callers can show it to users
             errorInfo: { message: lastMessage || 'API explicitly marked error as not retryable', exitCode },
@@ -1233,6 +1246,9 @@ export const executeClaudeCommand = async params => {
           return await executeWithRetry();
         } else {
           await log(`\n\n❌ Transient API error persisted after ${maxRetries} retries\n   Please try again later or check https://status.anthropic.com/`, { level: 'error' });
+          // Issue #1886: fold captured cost so the carried-forward cost survives this retries-exhausted path.
+          seedCumulativeAnthropicCost(argv.previousAnthropicCost);
+          const cumulativeAnthropicCostUSDOnRetriesExhausted = addAnthropicRunCost(anthropicTotalCostUSD ?? anthropicCostFromAnyResult);
           return {
             success: false,
             sessionId,
@@ -1242,7 +1258,7 @@ export const executeClaudeCommand = async params => {
             messageCount,
             toolUseCount,
             is503Error, // preserve for callers that check this
-            anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
+            anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnRetriesExhausted, // Issue #1104/#1886: Include cumulative cost even on failure
             resultSummary, // Issue #1263: Include result summary
             // Issue #1845: surface the actual error so callers can show it to users
             errorInfo: { message: lastMessage || `Transient API error persisted after ${maxRetries} retries`, exitCode },
@@ -1294,6 +1310,12 @@ export const executeClaudeCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
         await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log, argv);
+        // Issue #1886: on failure (usually a usage-limit hit → auto-resume) fold
+        // the captured cost into the cumulative total so autoContinueWhenLimitResets
+        // carries it forward. A limit hit ends as is_error → fall back to the
+        // non-success result cost.
+        seedCumulativeAnthropicCost(argv.previousAnthropicCost);
+        const cumulativeAnthropicCostUSDOnFailure = addAnthropicRunCost(anthropicTotalCostUSD ?? anthropicCostFromAnyResult);
         return {
           success: false,
           sessionId,
@@ -1303,7 +1325,7 @@ export const executeClaudeCommand = async params => {
           messageCount,
           toolUseCount,
           errorDuringExecution,
-          anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
+          anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnFailure, // Issue #1104/#1886: cumulative cost even on failure
           resultSummary, // Issue #1263: Include result summary
           // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content
           // filtering policy") so users see what actually went wrong, not just a generic message.
@@ -1322,7 +1344,13 @@ export const executeClaudeCommand = async params => {
       await log(`📊 Total messages: ${messageCount}, Tool uses: ${toolUseCount}`);
       // Calculate and display total token usage from session JSONL file.
       // Extracted to claude.budget-stats.lib.mjs to keep this file under the line limit (Issue #1834).
-      await displaySessionTokenUsage({ sessionId, tempDir, resultModelUsage, anthropicTotalCostUSD, argv, log });
+      // Issue #1886: the JSONL spans every resume iteration but each result
+      // event's total_cost_usd covers only this process; seed the carried-forward
+      // cost + add this process's so the cumulative total shares the JSONL scope.
+      seedCumulativeAnthropicCost(argv.previousAnthropicCost);
+      const cumulativeAnthropicCostUSD = addAnthropicRunCost(anthropicTotalCostUSD);
+      const previousAnthropicCostUSD = cumulativeAnthropicCostUSD - (anthropicTotalCostUSD || 0);
+      await displaySessionTokenUsage({ sessionId, tempDir, resultModelUsage, anthropicTotalCostUSD: cumulativeAnthropicCostUSD, previousAnthropicCostUSD, argv, log });
       await showResumeCommand(sessionId, tempDir, claudePath, argv.model, log, argv);
       return {
         success: true,
@@ -1332,7 +1360,7 @@ export const executeClaudeCommand = async params => {
         limitTimezone,
         messageCount,
         toolUseCount,
-        anthropicTotalCostUSD, // Pass Anthropic's official total cost
+        anthropicTotalCostUSD: cumulativeAnthropicCostUSD, // Issue #1104/#1886: cumulative Anthropic cost across resume iterations
         errorDuringExecution, // Issue #1088: Track if error_during_execution subtype occurred
         resultSummary, // Issue #1263: Include result summary for --attach-solution-summary
         resultModelUsage, // Issue #1454
@@ -1378,6 +1406,9 @@ export const executeClaudeCommand = async params => {
         }
       }
       await log(`\n\n❌ Error executing Claude command: ${error.message}`, { level: 'error' });
+      // Issue #1886: fold captured cost so the carried-forward cost survives this exception path too.
+      seedCumulativeAnthropicCost(argv.previousAnthropicCost);
+      const cumulativeAnthropicCostUSDOnException = addAnthropicRunCost(anthropicTotalCostUSD ?? anthropicCostFromAnyResult);
       return {
         success: false,
         sessionId,
@@ -1386,7 +1417,7 @@ export const executeClaudeCommand = async params => {
         limitTimezone: null,
         messageCount,
         toolUseCount,
-        anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
+        anthropicTotalCostUSD: cumulativeAnthropicCostUSDOnException, // Issue #1104/#1886: Include cumulative cost even on failure
         resultSummary, // Issue #1263: Include result summary
         // Issue #1845: surface the actual exception message so callers can show it to users
         errorInfo: { message: error.message || error.toString() },

package/src/isolation-runner.lib.mjs

@@ -28,8 +28,13 @@ const { $ } = await use('command-stream');
 const VALID_ISOLATION_BACKENDS = ['screen', 'tmux', 'docker'];
 const RUNNING_SESSION_STATUSES = new Set(['executing', 'running']);
 const TERMINAL_SESSION_STATUSES = new Set(['executed', 'completed', 'failed', 'cancelled', 'canceled', 'error']);
-const DEFAULT_HIVE_MIND_IMAGE = 'konard/hive-mind:latest';
-const DEFAULT_HIVE_MIND_DIND_IMAGE = 'konard/hive-mind-dind:latest';
+const HIVE_MIND_IMAGE_REPO = 'konard/hive-mind';
+const HIVE_MIND_DIND_IMAGE_REPO = 'konard/hive-mind-dind';
+const DEFAULT_HIVE_MIND_IMAGE_TAG = 'latest';
+// Docker's `--pull` accepts these policies. We only emit the flag when an
+// operator explicitly opts in; otherwise Docker's own default ("missing")
+// applies and `docker run` reuses any locally present image. See issue #1879.
+const VALID_DOCKER_PULL_POLICIES = new Set(['always', 'missing', 'never']);
 const DOCKER_ISOLATION_TRACKING_BACKEND = 'screen';
 const DOCKER_CONTAINER_HOME = '/home/box';
 const DOCKER_CONTAINER_PREFIX = 'hive-mind-isolation';
@@ -79,15 +84,52 @@ function maybeAddMount(mounts, source, target, existsSync) {
   mounts.push({ source, target });
 }
 
+/**
+ * Resolve the tag used for the Docker isolation image.
+ *
+ * Defaults to `latest`, but operators can pin it (e.g. to the exact version
+ * already present on the host) via `HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG`.
+ * Pinning matters for Docker-in-Docker deployments: the nested daemon starts
+ * with an empty image store, so an unpinned `:latest` whose registry digest has
+ * drifted from the host copy forces a fresh multi-gigabyte pull on every task.
+ * A pinned tag lets a pre-seeded image be reused instead. See issue #1879.
+ */
+export function resolveDockerIsolationImageTag({ env = process.env } = {}) {
+  const explicit = String(env.HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG || '').trim();
+  return explicit || DEFAULT_HIVE_MIND_IMAGE_TAG;
+}
+
 /**
  * Pick the Docker image used for `--isolation docker`.
  *
  * start-command defaults its Docker backend to a base OS image. Hive Mind needs
  * an image with the same CLI/tooling baseline as the parent process instead.
+ *
+ * `HIVE_MIND_DOCKER_ISOLATION_IMAGE` is a full override (repo:tag). Otherwise
+ * the repo is chosen by image variant and the tag by
+ * `resolveDockerIsolationImageTag()`.
  */
 export function getDockerIsolationImage({ env = process.env } = {}) {
   if (env.HIVE_MIND_DOCKER_ISOLATION_IMAGE) return env.HIVE_MIND_DOCKER_ISOLATION_IMAGE;
-  return String(env.HIVE_MIND_IMAGE_VARIANT || '').toLowerCase() === 'dind' ? DEFAULT_HIVE_MIND_DIND_IMAGE : DEFAULT_HIVE_MIND_IMAGE;
+  const repo = String(env.HIVE_MIND_IMAGE_VARIANT || '').toLowerCase() === 'dind' ? HIVE_MIND_DIND_IMAGE_REPO : HIVE_MIND_IMAGE_REPO;
+  return `${repo}:${resolveDockerIsolationImageTag({ env })}`;
+}
+
+/**
+ * Resolve the Docker `--pull` policy for isolated tasks.
+ *
+ * Returns one of `always` | `missing` | `never`, or `null` when unset (in which
+ * case the `--pull` flag is omitted and Docker's default applies). Operators set
+ * `HIVE_MIND_DOCKER_ISOLATION_PULL=never` to force reuse of an image already
+ * present in the (possibly nested) daemon and fail fast instead of silently
+ * re-downloading it. Invalid values are ignored. See issue #1879.
+ */
+export function getDockerIsolationPullPolicy({ env = process.env } = {}) {
+  const raw = String(env.HIVE_MIND_DOCKER_ISOLATION_PULL || '')
+    .trim()
+    .toLowerCase();
+  if (!raw) return null;
+  return VALID_DOCKER_PULL_POLICIES.has(raw) ? raw : null;
 }
 
 /**
@@ -123,7 +165,16 @@ export function buildDockerIsolationCommand(command, args = [], options = {}) {
   const { sessionId, tool = 'claude', env = process.env, homeDir = os.homedir(), existsSync = fs.existsSync } = options;
   const image = getDockerIsolationImage({ env });
   const innerCommand = buildShellCommand(command, args);
-  const dockerArgs = ['docker', 'run', '--rm', '--name', makeDockerContainerName(sessionId), '--workdir', DOCKER_CONTAINER_HOME, '-e', `HOME=${DOCKER_CONTAINER_HOME}`, '-e', `HIVE_MIND_PARENT_SESSION_ID=${sessionId || ''}`];
+  const dockerArgs = ['docker', 'run', '--rm'];
+
+  // Reuse a locally present image instead of re-downloading it when the
+  // operator opts in. Omitted by default so Docker's "missing" policy applies.
+  const pullPolicy = getDockerIsolationPullPolicy({ env });
+  if (pullPolicy) {
+    dockerArgs.push('--pull', pullPolicy);
+  }
+
+  dockerArgs.push('--name', makeDockerContainerName(sessionId), '--workdir', DOCKER_CONTAINER_HOME, '-e', `HOME=${DOCKER_CONTAINER_HOME}`, '-e', `HIVE_MIND_PARENT_SESSION_ID=${sessionId || ''}`);
 
   if (shouldRunPrivilegedDockerIsolation(image, env)) {
     dockerArgs.push('--privileged');
@@ -359,9 +410,12 @@ export async function executeWithIsolation(command, args, options = {}) {
   if (verbose) {
     console.log(`[VERBOSE] isolation-runner: ${[binPath, ...startCommandArgs].map(shellQuote).join(' ')}`);
     if (backend === 'docker') {
-      const image = getDockerIsolationImage({ env: options.env || process.env });
-      const mounts = getDockerIsolationAuthMounts({ tool: options.tool, env: options.env || process.env, homeDir: options.homeDir || os.homedir(), existsSync: options.existsSync || fs.existsSync });
+      const env = options.env || process.env;
+      const image = getDockerIsolationImage({ env });
+      const pullPolicy = getDockerIsolationPullPolicy({ env });
+      const mounts = getDockerIsolationAuthMounts({ tool: options.tool, env, homeDir: options.homeDir || os.homedir(), existsSync: options.existsSync || fs.existsSync });
       console.log(`[VERBOSE] isolation-runner: Docker isolation image: ${image}`);
+      console.log(`[VERBOSE] isolation-runner: Docker isolation pull policy: ${pullPolicy || '(docker default: missing — reuse local image if present)'}`);
       console.log(`[VERBOSE] isolation-runner: Docker isolation mounts: ${mounts.map(m => m.target).join(', ') || '(none)'}`);
     }
   }

package/src/solve.auto-continue.lib.mjs

@@ -54,6 +54,9 @@ import { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIt
 // Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
 
+// Issue #1886: cumulative Anthropic cost carried across cross-process resumes
+const { getCumulativeAnthropicCost } = await import('./anthropic-cost-accumulator.lib.mjs');
+
 const { calculateWaitTime } = validation;
 
 /**
@@ -168,6 +171,20 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     resumeArgs.push('--auto-resume-iteration', String(nextAutoResumeIteration));
     resumeArgs.push('--auto-resume-max-iterations', String(maxAutoResumeIterations));
 
+    // Issue #1886: carry the cumulative Anthropic cost into the resumed process.
+    // The resumed run reads the same session JSONL (full session, all runs), so
+    // its public-pricing estimate spans every run; without this the resumed
+    // run's "Calculated by Anthropic" figure would cover only its own process
+    // and disagree with the full-session public estimate (the -31.66% gap in
+    // issue #1886). getCumulativeAnthropicCost() already includes this run's
+    // cost folded in at the runClaude return, plus anything carried from prior
+    // iterations via --previous-anthropic-cost.
+    const carriedAnthropicCost = getCumulativeAnthropicCost();
+    if (carriedAnthropicCost > 0) {
+      resumeArgs.push('--previous-anthropic-cost', String(carriedAnthropicCost));
+      await log(`💰 Carrying forward cumulative Anthropic cost: $${carriedAnthropicCost.toFixed(6)} (issue #1886)`, { verbose: true });
+    }
+
     // Pass session type for proper comment differentiation
     // See: https://github.com/link-assistant/hive-mind/issues/1152
     const sessionType = isRestart ? 'auto-restart' : 'auto-resume';

package/src/solve.branch-divergence.lib.mjs

@@ -38,6 +38,61 @@ export function classifyPushRejection(errorOutput = '') {
   return 'unknown';
 }
 
+/**
+ * Detect whether a push failure was caused by missing permissions rather than
+ * by branch divergence. Git surfaces this as `! [remote rejected] ...
+ * (permission denied)` (HTTP 403). This is fundamentally different from a
+ * non-fast-forward / divergence rejection: force-pushing or force-with-lease
+ * will NOT help because the user simply cannot write to the remote.
+ *
+ * Issue #1893: when continuing another contributor's fork PR, the maintainer
+ * does not own the fork, so pushing the fork's default branch is rejected with
+ * "permission denied". The old heuristic matched the substring "rejected" and
+ * misclassified this as fork divergence, halting the run and recommending a
+ * useless `--allow-fork-divergence-resolution-using-force-push-with-lease`.
+ */
+export function isPermissionDeniedPushError(errorOutput = '') {
+  const normalized = String(errorOutput || '').toLowerCase();
+  return normalized.includes('permission denied') || normalized.includes('permission to') || normalized.includes('error: 403') || normalized.includes('the requested url returned error: 403') || (normalized.includes('denied') && normalized.includes('to https://'));
+}
+
+/**
+ * Decide whether the solver should push the freshly-synced default branch to
+ * the fork's `origin` remote.
+ *
+ * We only push the default branch to keep a fork we OWN in sync with upstream.
+ * When continuing someone else's fork PR (the fork belongs to the contributor,
+ * not the current user), the maintainer has push rights only to the PR branch
+ * (via "Allow edits by maintainers"), never to the fork's default branch.
+ * Attempting the push is both impossible (permission denied) and unnecessary,
+ * so we skip it. Issue #1893.
+ *
+ * @param {object} params
+ * @param {string|null} params.currentUser - authenticated GitHub login
+ * @param {string|null} params.forkedRepo - "owner/name" of the fork (origin)
+ * @returns {{ shouldPush: boolean, reason: string, forkOwner: string|null }}
+ */
+export function shouldPushDefaultBranchToFork({ currentUser, forkedRepo } = {}) {
+  const forkOwner = forkedRepo && forkedRepo.includes('/') ? forkedRepo.split('/')[0] : null;
+
+  if (!forkOwner) {
+    // Without a parseable fork owner we cannot prove ownership; fall back to the
+    // historical behaviour of attempting the push so nothing regresses.
+    return { shouldPush: true, reason: 'fork-owner-unknown', forkOwner: null };
+  }
+
+  if (!currentUser) {
+    // Could not resolve the current user; attempt the push and let git report.
+    return { shouldPush: true, reason: 'current-user-unknown', forkOwner };
+  }
+
+  if (currentUser.toLowerCase() === forkOwner.toLowerCase()) {
+    return { shouldPush: true, reason: 'owns-fork', forkOwner };
+  }
+
+  return { shouldPush: false, reason: 'not-fork-owner', forkOwner };
+}
+
 export function shouldTreatPushRejectionAsRemoteSynchronized(divergence = null) {
   if (!divergence?.remoteExists || divergence.ahead !== 0 || divergence.behind !== 0) {
     return false;

package/src/solve.config.lib.mjs

@@ -218,6 +218,19 @@ export const SOLVE_OPTION_DEFINITIONS = {
     default: 0,
     hidden: true,
   },
+  // Issue #1886: carried-forward Anthropic cost from previous resume iterations.
+  // The session JSONL accumulates the full session across limit-reset resumes,
+  // but Anthropic's result-event total_cost_usd is scoped to a single process.
+  // Threading the previous total here lets the resumed run display the
+  // full-session Anthropic cost alongside the full-session public estimate,
+  // instead of a misleading per-run figure. Internal/hidden: set automatically
+  // by autoContinueWhenLimitResets when spawning the resumed solve process.
+  'previous-anthropic-cost': {
+    type: 'number',
+    description: 'Internal: cumulative Anthropic total_cost_usd carried forward from previous resume iterations (issue #1886)',
+    default: 0,
+    hidden: true,
+  },
   'auto-merge': {
     type: 'boolean',
     description: 'Automatically merge the pull request when the working session is finished and all CI/CD statuses pass and PR is mergeable. Implies --auto-restart-until-mergeable.',

package/src/solve.fork-sync.lib.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+// Fork upstream-sync module for the solve command.
+// Extracted from solve.repository.lib.mjs to keep files under 1500 lines (#1893).
+
+// Use use-m to dynamically import modules for cross-runtime compatibility
+// Check if use is already defined globally (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 use = globalThis.use;
+
+// Use command-stream for consistent $ behavior; wrap with rate-limit retry (#1726)
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry((await use('command-stream')).$);
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log, formatAligned } = lib;
+
+// Import exit handler
+import { safeExit } from './exit-handler.lib.mjs';
+
+// Issue #1893: helpers that decide whether the fork's default branch may be
+// pushed and that distinguish a permission-denied rejection from a genuine
+// fork divergence.
+const { isPermissionDeniedPushError, shouldPushDefaultBranchToFork } = await import('./solve.branch-divergence.lib.mjs');
+
+// Set up upstream remote and sync fork
+export const setupUpstreamAndSync = async (tempDir, forkedRepo, upstreamRemote, owner, repo, argv) => {
+  if (!forkedRepo || !upstreamRemote) return;
+
+  await log(`${formatAligned('🔗', 'Setting upstream:', upstreamRemote)}`);
+
+  // Check if upstream remote already exists
+  const checkUpstreamResult = await $({ cwd: tempDir })`git remote get-url upstream 2>/dev/null`;
+  let upstreamExists = checkUpstreamResult.code === 0;
+
+  if (upstreamExists) {
+    await log(`${formatAligned('ℹ️', 'Upstream exists:', 'Using existing upstream remote')}`);
+  } else {
+    // Add upstream remote since it doesn't exist
+    const upstreamResult = await $({ cwd: tempDir })`git remote add upstream https://github.com/${upstreamRemote}.git`;
+
+    if (upstreamResult.code === 0) {
+      await log(`${formatAligned('✅', 'Upstream set:', upstreamRemote)}`);
+      upstreamExists = true;
+    } else {
+      await log(`${formatAligned('⚠️', 'Warning:', 'Failed to add upstream remote')}`);
+      if (upstreamResult.stderr) {
+        await log(`${formatAligned('', 'Error details:', upstreamResult.stderr.toString().trim())}`);
+      }
+    }
+  }
+
+  // Proceed with fork sync if upstream remote is available
+  if (upstreamExists) {
+    // Fetch upstream
+    await log(`${formatAligned('🔄', 'Fetching upstream...', '')}`);
+    const fetchResult = await $({ cwd: tempDir })`git fetch upstream`;
+    if (fetchResult.code === 0) {
+      await log(`${formatAligned('✅', 'Upstream fetched:', 'Successfully')}`);
+
+      // Sync the default branch with upstream to avoid merge conflicts
+      await log(`${formatAligned('🔄', 'Syncing default branch...', '')}`);
+
+      // Get current branch so we can return to it after sync
+      const currentBranchResult = await $({ cwd: tempDir })`git branch --show-current`;
+      if (currentBranchResult.code === 0) {
+        const currentBranch = currentBranchResult.stdout.toString().trim();
+
+        // Get the default branch name from the original repository using GitHub API
+        const repoInfoResult = await $`gh api repos/${owner}/${repo} --jq .default_branch`;
+        if (repoInfoResult.code === 0) {
+          const upstreamDefaultBranch = repoInfoResult.stdout.toString().trim();
+          await log(`${formatAligned('ℹ️', 'Default branch:', upstreamDefaultBranch)}`);
+
+          // Always sync the default branch, regardless of current branch
+          // This ensures fork is up-to-date even if we're working on a different branch
+
+          // Step 1: Switch to default branch if not already on it
+          let syncSuccessful = true;
+          if (currentBranch !== upstreamDefaultBranch) {
+            await log(`${formatAligned('🔄', 'Switching to:', `${upstreamDefaultBranch} branch`)}`);
+            const checkoutResult = await $({ cwd: tempDir })`git checkout ${upstreamDefaultBranch}`;
+            if (checkoutResult.code !== 0) {
+              await log(`${formatAligned('⚠️', 'Warning:', `Failed to checkout ${upstreamDefaultBranch}`)}`);
+              syncSuccessful = false; // Cannot proceed with sync
+            }
+          }
+
+          // Step 2: Sync default branch with upstream (only if checkout was successful)
+          if (syncSuccessful) {
+            const syncResult = await $({ cwd: tempDir })`git reset --hard upstream/${upstreamDefaultBranch}`;
+            if (syncResult.code === 0) {
+              await log(`${formatAligned('✅', 'Default branch synced:', `with upstream/${upstreamDefaultBranch}`)}`);
+
+              // Step 3: Push the updated default branch to fork to keep it in sync.
+              //
+              // Issue #1893: only push the default branch when the current user
+              // OWNS the fork. When continuing another contributor's fork PR the
+              // fork belongs to them, and "Allow edits by maintainers" grants
+              // push access only to the PR branch — never to the fork's default
+              // branch. Attempting the push there is guaranteed to be rejected
+              // with "permission denied" and is unnecessary, so we skip it and
+              // keep working on the PR branch.
+              const currentUserResult = await $`gh api user --jq .login`;
+              const currentUser = currentUserResult.code === 0 ? currentUserResult.stdout.toString().trim() : null;
+              const pushDecision = shouldPushDefaultBranchToFork({ currentUser, forkedRepo });
+
+              if (!pushDecision.shouldPush) {
+                await log(`${formatAligned('ℹ️', 'Skipping fork push:', `${upstreamDefaultBranch} synced locally only`)}`);
+                await log(`${formatAligned('', 'Reason:', `Fork ${forkedRepo} is owned by ${pushDecision.forkOwner}, not ${currentUser || 'the current user'}`)}`, {
+                  verbose: true,
+                });
+                await log(`${formatAligned('', 'Next:', 'Continuing on the PR branch (maintainer edits allowed on the PR head only)')}`, {
+                  verbose: true,
+                });
+                // Fall through to Step 4 (return to original branch) without pushing.
+                if (currentBranch !== upstreamDefaultBranch) {
+                  await log(`${formatAligned('🔄', 'Returning to:', `${currentBranch} branch`)}`);
+                  const returnResult = await $({ cwd: tempDir })`git checkout ${currentBranch}`;
+                  if (returnResult.code === 0) {
+                    await log(`${formatAligned('✅', 'Branch restored:', `Back on ${currentBranch}`)}`);
+                  } else {
+                    await log(`${formatAligned('⚠️', 'Warning:', `Failed to return to ${currentBranch}`)}`);
+                  }
+                }
+                return;
+              }
+
+              await log(`${formatAligned('🔄', 'Pushing to fork:', `${upstreamDefaultBranch} branch`)}`);
+              const pushResult = await $({ cwd: tempDir })`git push origin ${upstreamDefaultBranch} 2>&1`;
+              if (pushResult.code === 0) {
+                await log(`${formatAligned('✅', 'Fork updated:', 'Default branch pushed to fork')}`);
+              } else {
+                // Check if it's a non-fast-forward error (fork has diverged from upstream)
+                const errorMsg = (pushResult.stderr ? pushResult.stderr.toString().trim() : '') || (pushResult.stdout ? pushResult.stdout.toString().trim() : '');
+
+                // Issue #1893: a "permission denied" rejection is NOT a divergence.
+                // It means the current user cannot write to this fork (e.g. it
+                // belongs to another contributor). Force-push / force-with-lease
+                // cannot fix that, so never recommend the divergence flag here.
+                // Syncing the default branch is best-effort, so we warn and
+                // continue working on the PR branch instead of halting.
+                if (isPermissionDeniedPushError(errorMsg)) {
+                  await log('');
+                  await log(`${formatAligned('ℹ️', 'Skipping fork sync:', `No push access to ${forkedRepo}`)}`);
+                  await log(`${formatAligned('', 'Reason:', "Fork's default branch is owned by another user; this is expected when")}`, { verbose: true });
+                  await log(`${formatAligned('', '', "continuing a contributor's fork PR (maintainer edits cover the PR branch only)")}`, { verbose: true });
+                  await log(`${formatAligned('', 'Push output:', errorMsg.split('\n')[0] || errorMsg)}`, { verbose: true });
+                  // Return to the original branch and continue without halting.
+                  if (currentBranch !== upstreamDefaultBranch) {
+                    await log(`${formatAligned('🔄', 'Returning to:', `${currentBranch} branch`)}`);
+                    const returnResult = await $({ cwd: tempDir })`git checkout ${currentBranch}`;
+                    if (returnResult.code === 0) {
+                      await log(`${formatAligned('✅', 'Branch restored:', `Back on ${currentBranch}`)}`);
+                    } else {
+                      await log(`${formatAligned('⚠️', 'Warning:', `Failed to return to ${currentBranch}`)}`);
+                    }
+                  }
+                  return;
+                }
+
+                const isNonFastForward = errorMsg.includes('non-fast-forward') || errorMsg.includes('rejected') || errorMsg.includes('tip of your current branch is behind');
+
+                if (isNonFastForward) {
+                  // Fork has diverged from upstream
+                  await log('');
+                  await log(`${formatAligned('⚠️', 'FORK DIVERGENCE DETECTED', '')}`, { level: 'warn' });
+                  await log('');
+                  await log('  🔍 What happened:');
+                  await log(`     Your fork's ${upstreamDefaultBranch} branch has different commits than upstream`);
+                  await log('     This typically occurs when upstream had a force push (e.g., git reset --hard)');
+                  await log('');
+                  await log('  📦 Current state:');
+                  await log(`     • Fork: ${forkedRepo}`);
+                  await log(`     • Upstream: ${owner}/${repo}`);
+                  await log(`     • Branch: ${upstreamDefaultBranch}`);
+                  await log('');
+
+                  // Check if user has enabled automatic force push
+                  if (argv.allowForkDivergenceResolutionUsingForcePushWithLease) {
+                    await log('  🔄 Auto-resolution ENABLED (--allow-fork-divergence-resolution-using-force-push-with-lease):');
+                    await log('     Attempting to force-push with --force-with-lease...');
+                    await log('');
+
+                    // Use --force-with-lease for safer force push
+                    // This will only force push if the remote hasn't changed since our last fetch
+                    await log(`${formatAligned('🔄', 'Force pushing:', 'Syncing fork with upstream (--force-with-lease)')}`);
+                    const forcePushResult = await $({
+                      cwd: tempDir,
+                    })`git push --force-with-lease origin ${upstreamDefaultBranch} 2>&1`;
+
+                    if (forcePushResult.code === 0) {
+                      await log(`${formatAligned('✅', 'Fork synced:', 'Successfully force-pushed to align with upstream')}`);
+                      await log('');
+                    } else {
+                      // Force push also failed - this is a more serious issue
+                      await log('');
+                      await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to sync fork with upstream')}`, {
+                        level: 'error',
+                      });
+                      await log('');
+                      await log('  🔍 What happened:');
+                      await log(`     Fork branch ${upstreamDefaultBranch} has diverged from upstream`);
+                      await log('     Both normal push and force-with-lease push failed');
+                      await log('');
+                      await log('  📦 Error details:');
+                      const forceErrorMsg = forcePushResult.stderr ? forcePushResult.stderr.toString().trim() : '';
+                      for (const line of forceErrorMsg.split('\n')) {
+                        if (line.trim()) await log(`     ${line}`);
+                      }
+                      await log('');
+                      await log('  💡 Possible causes:');
+                      await log('     • Fork branch is protected (branch protection rules prevent force push)');
+                      await log('     • Someone else pushed to fork after our fetch');
+                      await log('     • Insufficient permissions to force push');
+                      await log('');
+                      await log('  🔧 Manual resolution:');
+                      await log(`     1. Visit your fork: https://github.com/${forkedRepo}`);
+                      await log('     2. Check branch protection settings');
+                      await log('     3. Manually sync fork with upstream:');
+                      await log('        git fetch upstream');
+                      await log(`        git reset --hard upstream/${upstreamDefaultBranch}`);
+                      await log(`        git push --force origin ${upstreamDefaultBranch}`);
+                      await log('');
+                      await safeExit(1, 'Repository setup failed - fork sync failed');
+                    }
+                  } else {
+                    // Flag is not enabled - provide guidance
+                    await log('  💡 Your options:');
+                    await log('');
+                    await log('     Option 1: Delete your fork and recreate it (SIMPLEST)');
+                    await log(`              gh repo delete ${forkedRepo}`);
+                    await log('              Then run the solve command again - the fork will be recreated automatically');
+                    await log('              ⚠️  Only use this if your fork has no unique commits you need to preserve');
+                    await log('');
+                    await log('     Option 2: Enable automatic force-push (DANGEROUS)');
+                    await log('              Add --allow-fork-divergence-resolution-using-force-push-with-lease flag to your command');
+                    await log('              This will automatically sync your fork with upstream using force-with-lease');
+                    await log('              ⚠️  Overwrites fork history - any unique commits will be LOST');
+                    await log('');
+                    await log('     Option 3: Manually resolve the divergence');
+                    await log('              1. Decide if you need any commits unique to your fork');
+                    await log('              2. If yes, cherry-pick them after syncing');
+                    await log('              3. If no, manually force-push:');
+                    await log('                 git fetch upstream');
+                    await log(`                 git reset --hard upstream/${upstreamDefaultBranch}`);
+                    await log(`                 git push --force origin ${upstreamDefaultBranch}`);
+                    await log('');
+                    await log('  🔧 To proceed with auto-resolution, restart with:');
+                    await log(`     solve ${argv.url || argv['issue-url'] || argv._[0] || '<issue-url>'} --allow-fork-divergence-resolution-using-force-push-with-lease`);
+                    await log('');
+                    await safeExit(1, 'Repository setup halted - fork divergence requires user decision');
+                  }
+                } else {
+                  // Some other push error (not divergence-related)
+                  await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to push updated default branch to fork')}`);
+                  await log(`${formatAligned('', 'Push error:', errorMsg)}`);
+                  await log(`${formatAligned('', 'Reason:', 'Fork must be updated or process must stop')}`);
+                  await log(`${formatAligned('', 'Solution draft:', 'Fork sync is required for proper workflow')}`);
+                  await log(`${formatAligned('', 'Next steps:', '1. Check GitHub permissions for the fork')}`);
+                  await log(`${formatAligned('', '', '2. Ensure fork is not protected')}`);
+                  await log(`${formatAligned('', '', '3. Try again after resolving fork issues')}`);
+                  await safeExit(1, 'Repository setup failed');
+                }
+              }
+
+              // Step 4: Return to the original branch if it was different
+              if (currentBranch !== upstreamDefaultBranch) {
+                await log(`${formatAligned('🔄', 'Returning to:', `${currentBranch} branch`)}`);
+                const returnResult = await $({ cwd: tempDir })`git checkout ${currentBranch}`;
+                if (returnResult.code === 0) {
+                  await log(`${formatAligned('✅', 'Branch restored:', `Back on ${currentBranch}`)}`);
+                } else {
+                  await log(`${formatAligned('⚠️', 'Warning:', `Failed to return to ${currentBranch}`)}`);
+                  // This is not fatal, continue with sync on default branch
+                }
+              }
+            } else {
+              await log(`${formatAligned('⚠️', 'Warning:', `Failed to sync ${upstreamDefaultBranch} with upstream`)}`);
+              if (syncResult.stderr) {
+                await log(`${formatAligned('', 'Sync error:', syncResult.stderr.toString().trim())}`);
+              }
+            }
+          }
+        } else {
+          await log(`${formatAligned('⚠️', 'Warning:', 'Failed to get default branch name')}`);
+        }
+      } else {
+        await log(`${formatAligned('⚠️', 'Warning:', 'Failed to get current branch')}`);
+      }
+    } else {
+      await log(`${formatAligned('⚠️', 'Warning:', 'Failed to fetch upstream')}`);
+      if (fetchResult.stderr) {
+        await log(`${formatAligned('', 'Fetch error:', fetchResult.stderr.toString().trim())}`);
+      }
+    }
+  }
+};

package/src/solve.repository.lib.mjs

@@ -1045,220 +1045,10 @@ export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) =
   await safeExit(1, 'Repository setup failed');
 };
 
-// Set up upstream remote and sync fork
-export const setupUpstreamAndSync = async (tempDir, forkedRepo, upstreamRemote, owner, repo, argv) => {
-  if (!forkedRepo || !upstreamRemote) return;
-
-  await log(`${formatAligned('🔗', 'Setting upstream:', upstreamRemote)}`);
-
-  // Check if upstream remote already exists
-  const checkUpstreamResult = await $({ cwd: tempDir })`git remote get-url upstream 2>/dev/null`;
-  let upstreamExists = checkUpstreamResult.code === 0;
-
-  if (upstreamExists) {
-    await log(`${formatAligned('ℹ️', 'Upstream exists:', 'Using existing upstream remote')}`);
-  } else {
-    // Add upstream remote since it doesn't exist
-    const upstreamResult = await $({ cwd: tempDir })`git remote add upstream https://github.com/${upstreamRemote}.git`;
-
-    if (upstreamResult.code === 0) {
-      await log(`${formatAligned('✅', 'Upstream set:', upstreamRemote)}`);
-      upstreamExists = true;
-    } else {
-      await log(`${formatAligned('⚠️', 'Warning:', 'Failed to add upstream remote')}`);
-      if (upstreamResult.stderr) {
-        await log(`${formatAligned('', 'Error details:', upstreamResult.stderr.toString().trim())}`);
-      }
-    }
-  }
-
-  // Proceed with fork sync if upstream remote is available
-  if (upstreamExists) {
-    // Fetch upstream
-    await log(`${formatAligned('🔄', 'Fetching upstream...', '')}`);
-    const fetchResult = await $({ cwd: tempDir })`git fetch upstream`;
-    if (fetchResult.code === 0) {
-      await log(`${formatAligned('✅', 'Upstream fetched:', 'Successfully')}`);
-
-      // Sync the default branch with upstream to avoid merge conflicts
-      await log(`${formatAligned('🔄', 'Syncing default branch...', '')}`);
-
-      // Get current branch so we can return to it after sync
-      const currentBranchResult = await $({ cwd: tempDir })`git branch --show-current`;
-      if (currentBranchResult.code === 0) {
-        const currentBranch = currentBranchResult.stdout.toString().trim();
-
-        // Get the default branch name from the original repository using GitHub API
-        const repoInfoResult = await $`gh api repos/${owner}/${repo} --jq .default_branch`;
-        if (repoInfoResult.code === 0) {
-          const upstreamDefaultBranch = repoInfoResult.stdout.toString().trim();
-          await log(`${formatAligned('ℹ️', 'Default branch:', upstreamDefaultBranch)}`);
-
-          // Always sync the default branch, regardless of current branch
-          // This ensures fork is up-to-date even if we're working on a different branch
-
-          // Step 1: Switch to default branch if not already on it
-          let syncSuccessful = true;
-          if (currentBranch !== upstreamDefaultBranch) {
-            await log(`${formatAligned('🔄', 'Switching to:', `${upstreamDefaultBranch} branch`)}`);
-            const checkoutResult = await $({ cwd: tempDir })`git checkout ${upstreamDefaultBranch}`;
-            if (checkoutResult.code !== 0) {
-              await log(`${formatAligned('⚠️', 'Warning:', `Failed to checkout ${upstreamDefaultBranch}`)}`);
-              syncSuccessful = false; // Cannot proceed with sync
-            }
-          }
-
-          // Step 2: Sync default branch with upstream (only if checkout was successful)
-          if (syncSuccessful) {
-            const syncResult = await $({ cwd: tempDir })`git reset --hard upstream/${upstreamDefaultBranch}`;
-            if (syncResult.code === 0) {
-              await log(`${formatAligned('✅', 'Default branch synced:', `with upstream/${upstreamDefaultBranch}`)}`);
-
-              // Step 3: Push the updated default branch to fork to keep it in sync
-              await log(`${formatAligned('🔄', 'Pushing to fork:', `${upstreamDefaultBranch} branch`)}`);
-              const pushResult = await $({ cwd: tempDir })`git push origin ${upstreamDefaultBranch} 2>&1`;
-              if (pushResult.code === 0) {
-                await log(`${formatAligned('✅', 'Fork updated:', 'Default branch pushed to fork')}`);
-              } else {
-                // Check if it's a non-fast-forward error (fork has diverged from upstream)
-                const errorMsg = (pushResult.stderr ? pushResult.stderr.toString().trim() : '') || (pushResult.stdout ? pushResult.stdout.toString().trim() : '');
-                const isNonFastForward = errorMsg.includes('non-fast-forward') || errorMsg.includes('rejected') || errorMsg.includes('tip of your current branch is behind');
-
-                if (isNonFastForward) {
-                  // Fork has diverged from upstream
-                  await log('');
-                  await log(`${formatAligned('⚠️', 'FORK DIVERGENCE DETECTED', '')}`, { level: 'warn' });
-                  await log('');
-                  await log('  🔍 What happened:');
-                  await log(`     Your fork's ${upstreamDefaultBranch} branch has different commits than upstream`);
-                  await log('     This typically occurs when upstream had a force push (e.g., git reset --hard)');
-                  await log('');
-                  await log('  📦 Current state:');
-                  await log(`     • Fork: ${forkedRepo}`);
-                  await log(`     • Upstream: ${owner}/${repo}`);
-                  await log(`     • Branch: ${upstreamDefaultBranch}`);
-                  await log('');
-
-                  // Check if user has enabled automatic force push
-                  if (argv.allowForkDivergenceResolutionUsingForcePushWithLease) {
-                    await log('  🔄 Auto-resolution ENABLED (--allow-fork-divergence-resolution-using-force-push-with-lease):');
-                    await log('     Attempting to force-push with --force-with-lease...');
-                    await log('');
-
-                    // Use --force-with-lease for safer force push
-                    // This will only force push if the remote hasn't changed since our last fetch
-                    await log(`${formatAligned('🔄', 'Force pushing:', 'Syncing fork with upstream (--force-with-lease)')}`);
-                    const forcePushResult = await $({
-                      cwd: tempDir,
-                    })`git push --force-with-lease origin ${upstreamDefaultBranch} 2>&1`;
-
-                    if (forcePushResult.code === 0) {
-                      await log(`${formatAligned('✅', 'Fork synced:', 'Successfully force-pushed to align with upstream')}`);
-                      await log('');
-                    } else {
-                      // Force push also failed - this is a more serious issue
-                      await log('');
-                      await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to sync fork with upstream')}`, {
-                        level: 'error',
-                      });
-                      await log('');
-                      await log('  🔍 What happened:');
-                      await log(`     Fork branch ${upstreamDefaultBranch} has diverged from upstream`);
-                      await log('     Both normal push and force-with-lease push failed');
-                      await log('');
-                      await log('  📦 Error details:');
-                      const forceErrorMsg = forcePushResult.stderr ? forcePushResult.stderr.toString().trim() : '';
-                      for (const line of forceErrorMsg.split('\n')) {
-                        if (line.trim()) await log(`     ${line}`);
-                      }
-                      await log('');
-                      await log('  💡 Possible causes:');
-                      await log('     • Fork branch is protected (branch protection rules prevent force push)');
-                      await log('     • Someone else pushed to fork after our fetch');
-                      await log('     • Insufficient permissions to force push');
-                      await log('');
-                      await log('  🔧 Manual resolution:');
-                      await log(`     1. Visit your fork: https://github.com/${forkedRepo}`);
-                      await log('     2. Check branch protection settings');
-                      await log('     3. Manually sync fork with upstream:');
-                      await log('        git fetch upstream');
-                      await log(`        git reset --hard upstream/${upstreamDefaultBranch}`);
-                      await log(`        git push --force origin ${upstreamDefaultBranch}`);
-                      await log('');
-                      await safeExit(1, 'Repository setup failed - fork sync failed');
-                    }
-                  } else {
-                    // Flag is not enabled - provide guidance
-                    await log('  💡 Your options:');
-                    await log('');
-                    await log('     Option 1: Delete your fork and recreate it (SIMPLEST)');
-                    await log(`              gh repo delete ${forkedRepo}`);
-                    await log('              Then run the solve command again - the fork will be recreated automatically');
-                    await log('              ⚠️  Only use this if your fork has no unique commits you need to preserve');
-                    await log('');
-                    await log('     Option 2: Enable automatic force-push (DANGEROUS)');
-                    await log('              Add --allow-fork-divergence-resolution-using-force-push-with-lease flag to your command');
-                    await log('              This will automatically sync your fork with upstream using force-with-lease');
-                    await log('              ⚠️  Overwrites fork history - any unique commits will be LOST');
-                    await log('');
-                    await log('     Option 3: Manually resolve the divergence');
-                    await log('              1. Decide if you need any commits unique to your fork');
-                    await log('              2. If yes, cherry-pick them after syncing');
-                    await log('              3. If no, manually force-push:');
-                    await log('                 git fetch upstream');
-                    await log(`                 git reset --hard upstream/${upstreamDefaultBranch}`);
-                    await log(`                 git push --force origin ${upstreamDefaultBranch}`);
-                    await log('');
-                    await log('  🔧 To proceed with auto-resolution, restart with:');
-                    await log(`     solve ${argv.url || argv['issue-url'] || argv._[0] || '<issue-url>'} --allow-fork-divergence-resolution-using-force-push-with-lease`);
-                    await log('');
-                    await safeExit(1, 'Repository setup halted - fork divergence requires user decision');
-                  }
-                } else {
-                  // Some other push error (not divergence-related)
-                  await log(`${formatAligned('❌', 'FATAL ERROR:', 'Failed to push updated default branch to fork')}`);
-                  await log(`${formatAligned('', 'Push error:', errorMsg)}`);
-                  await log(`${formatAligned('', 'Reason:', 'Fork must be updated or process must stop')}`);
-                  await log(`${formatAligned('', 'Solution draft:', 'Fork sync is required for proper workflow')}`);
-                  await log(`${formatAligned('', 'Next steps:', '1. Check GitHub permissions for the fork')}`);
-                  await log(`${formatAligned('', '', '2. Ensure fork is not protected')}`);
-                  await log(`${formatAligned('', '', '3. Try again after resolving fork issues')}`);
-                  await safeExit(1, 'Repository setup failed');
-                }
-              }
-
-              // Step 4: Return to the original branch if it was different
-              if (currentBranch !== upstreamDefaultBranch) {
-                await log(`${formatAligned('🔄', 'Returning to:', `${currentBranch} branch`)}`);
-                const returnResult = await $({ cwd: tempDir })`git checkout ${currentBranch}`;
-                if (returnResult.code === 0) {
-                  await log(`${formatAligned('✅', 'Branch restored:', `Back on ${currentBranch}`)}`);
-                } else {
-                  await log(`${formatAligned('⚠️', 'Warning:', `Failed to return to ${currentBranch}`)}`);
-                  // This is not fatal, continue with sync on default branch
-                }
-              }
-            } else {
-              await log(`${formatAligned('⚠️', 'Warning:', `Failed to sync ${upstreamDefaultBranch} with upstream`)}`);
-              if (syncResult.stderr) {
-                await log(`${formatAligned('', 'Sync error:', syncResult.stderr.toString().trim())}`);
-              }
-            }
-          }
-        } else {
-          await log(`${formatAligned('⚠️', 'Warning:', 'Failed to get default branch name')}`);
-        }
-      } else {
-        await log(`${formatAligned('⚠️', 'Warning:', 'Failed to get current branch')}`);
-      }
-    } else {
-      await log(`${formatAligned('⚠️', 'Warning:', 'Failed to fetch upstream')}`);
-      if (fetchResult.stderr) {
-        await log(`${formatAligned('', 'Fetch error:', fetchResult.stderr.toString().trim())}`);
-      }
-    }
-  }
-};
+// Set up upstream remote and sync fork.
+// Extracted into solve.fork-sync.lib.mjs (#1893) to keep this file under the
+// 1500-line limit; re-exported here so existing importers keep working.
+export { setupUpstreamAndSync } from './solve.fork-sync.lib.mjs';
 
 // Set up pr-fork remote for continuing someone else's fork PR with --fork flag
 export const setupPrForkRemote = async (tempDir, argv, prForkOwner, repo, isContinueMode, owner = null) => {