@link-assistant/hive-mind 2.7.2 → 2.7.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.7.3
+
+### Patch Changes
+
+- e6c67c0: Reset Anthropic cost accounting between fresh auto-restart working sessions while preserving cumulative totals for true session resumes.
+
 ## 2.7.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "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

@@ -29,12 +29,11 @@
  * 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).
+ *   - Each `executeClaude` call starts a scope. Fresh sessions reset it; true
+ *     resumes retain it or seed it from `--previous-anthropic-cost` when the
+ *     resume crosses a process boundary.
+ *   - Every finished Claude process in that logical session adds its own
+ *     `total_cost_usd` via `addAnthropicRunCost`.
  *   - The display and the cross-process spawn both read the cumulative total,
  *     so "Calculated by Anthropic" tracks the full session.
  *
@@ -43,12 +42,12 @@
  * 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).
+// Module-level singleton: the cumulative Anthropic cost for the active logical
+// session (including anything seeded by a true resume from a prior process).
 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.
+// Seeding must happen exactly once per active scope. Resume retries may call the
+// seed helper repeatedly; re-seeding from the same CLI flag would wipe out the
+// costs already accumulated in this process.
 let seeded = false;
 
 /**
@@ -61,10 +60,34 @@ const toCostAmount = value => {
   return Number.isFinite(n) && n > 0 ? n : 0;
 };
 
+/**
+ * Start accounting for one logical Claude session.
+ *
+ * A fresh execution owns a new transcript and therefore a new cost scope. A
+ * true `--resume` execution continues the active scope (or restores it from
+ * `--previous-anthropic-cost` when the resume happens in a child process).
+ * Calling this at the public `executeClaude` boundary keeps retries inside one
+ * scope while preventing watch-mode and mergeability auto-restarts from
+ * inheriting the preceding working session's cost.
+ *
+ * @param {Object} [options]
+ * @param {boolean|string} [options.resume=false] - whether this execution resumes an existing Claude session
+ * @param {number|string|null} [options.previousAnthropicCost=0] - cumulative cost restored by a resumed child process
+ * @returns {number} the cumulative cost at the start of this execution
+ */
+export const beginAnthropicCostScope = ({ resume = false, previousAnthropicCost = 0 } = {}) => {
+  if (!resume) {
+    cumulativeAnthropicCostUSD = 0;
+    seeded = true;
+    return cumulativeAnthropicCostUSD;
+  }
+  return seedCumulativeAnthropicCost(previousAnthropicCost);
+};
+
 /**
  * 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.
+ * per active scope. Subsequent calls are no-ops so resume retries do not reset
+ * the running total.
  * @param {number|string|null|undefined} previousAnthropicCostUSD
  * @returns {number} the cumulative total after seeding
  */
@@ -98,8 +121,8 @@ export const getCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD;
 export const hasCumulativeAnthropicCost = () => cumulativeAnthropicCostUSD > 0;
 
 /**
- * Reset the accumulator. Intended for tests — production code seeds once and
- * accumulates for the lifetime of the process.
+ * Reset the accumulator. Intended for tests; production code starts scopes via
+ * `beginAnthropicCostScope`.
  */
 export const resetCumulativeAnthropicCost = () => {
   cumulativeAnthropicCostUSD = 0;

package/src/claude.lib.mjs

@@ -17,7 +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 { beginAnthropicCostScope, seedCumulativeAnthropicCost, addAnthropicRunCost } from './anthropic-cost-accumulator.lib.mjs'; // Issues #1886, #2056
 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
@@ -236,6 +236,8 @@ export const resolveThinkingSettings = async (argv, log) => {
 export const checkPlaywrightMcpAvailability = ensureClaudePlaywrightMcpServer;
 export const executeClaude = async params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, setLogFile, getLogFile, formatAligned, getResourceSnapshot, claudePath, $ } = params;
+  // Issue #2056: reset fresh sessions while retaining issue #1886's true-resume accumulation.
+  beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
   if (argv.promptSubagentsViaAgentCommander) {
     try {
       await $`which start-agent`;
@@ -304,11 +306,9 @@ export const executeClaude = async params => {
   }
   const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
   const escapedSystemPrompt = systemPrompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
-
   // Issue #1877: deploy the experimental HANDOFF.md Agent Skill so Claude loads
   // it natively from .claude/skills/handoff/SKILL.md (no-op unless --use-handoff).
   await deployHandoffSkill({ tempDir, argv, log, $ });
-
   return await withAgentsMdAsClaudeMd({ tempDir, branchName, argv, prompt, fs, path, $, log, formatAligned }, () =>
     executeClaudeCommand({
       tempDir,
@@ -1176,6 +1176,7 @@ export const executeClaudeCommand = async params => {
       // logs the failure and returns false; we fall through to the normal commandFailed return below
       // (the 400 is not a transient pattern, so it is not retried).
       if (commandFailed && retryableLastError.requiresFreshSession && (await tryThinkingBlockRecovery({ classified: retryableLastError, source: 'result', sessionId }))) {
+        beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
         return await executeWithRetry();
       }
       // Issues #1331, #1353, #1472/#1475: Unified transient error retry (exponential backoff, session preservation)
@@ -1376,6 +1377,7 @@ export const executeClaudeCommand = async params => {
       // Issue #1834: Corrupted extended-thinking blocks surfaced as a thrown exception. Same recovery
       // as the streamed-result path: resume the session first, then fall back to a fresh restart.
       if (retryableException.requiresFreshSession && (await tryThinkingBlockRecovery({ classified: retryableException, source: 'exception', sessionId }))) {
+        beginAnthropicCostScope({ resume: argv.resume, previousAnthropicCost: argv.previousAnthropicCost });
         retryCount++;
         return await executeWithRetry();
       }

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

@@ -181,7 +181,11 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     // cost folded in at the runClaude return, plus anything carried from prior
     // iterations via --previous-anthropic-cost.
     const carriedAnthropicCost = getCumulativeAnthropicCost();
-    if (carriedAnthropicCost > 0) {
+    // Issue #2056: only a real resume reads the same transcript and belongs to
+    // the same cost scope. A configured auto-restart deliberately starts a
+    // fresh Claude session, so carrying the old cost would recreate the exact
+    // cross-session overcount reported in the issue.
+    if (!isRestart && carriedAnthropicCost > 0) {
       resumeArgs.push('--previous-anthropic-cost', String(carriedAnthropicCost));
       await log(`💰 Carrying forward cumulative Anthropic cost: $${carriedAnthropicCost.toFixed(6)} (issue #1886)`, { verbose: true });
     }