@@ -360,14 +360,23 @@ def _record_cost(self, prompt: str, response: str) -> int:
         self._thread_local.delta = delta
         return delta
 
+    def _reset_call_delta(self) -> None:
+        """Zero the call-local delta for a NO-CALL path.
+
+        Called at the start of every tool-aware path (and used by cache hits) so
+        a reused worker never reports a previous call's token count — every
+        no-call / early-return path leaves the delta at 0.
+        """
+        self._thread_local.delta = 0
+
     def _cached_call(self, key: str, prompt: str, *, max_tokens: int = 1024) -> str:
         kind = key.split(":", 1)[0]
         ev = getattr(self, "evidence", None)
         with self._lock:
             cached = self._cache.get(key)
         if cached is not None:
             # cover: later cache hit must not report the previous call's delta.
-            self._thread_local.delta = 0
+            self._reset_call_delta()
             # cache hits log key-only (the full text is on the original miss event)
             if ev is not None:
                 ev.log("replay", "model_call", kind=kind, cache_hit=True, key=key,
@@ -865,6 +874,7 @@ def _call(self, prompt: str, *, max_tokens: int = 1024) -> str:
         return out
 
     def attempt_with_tools(self, task, skill, memory, tools):
+        self._reset_call_delta()
         # Expose a REAL, callable `search` tool (a shell shim that logs each
         # call) so the gbrain quick-answerer judge (tool_called=search) is
         # validated honestly: we detect the call from the shim's log, not from
@@ -1356,6 +1366,7 @@ def attempt_with_tools(
         tools: List[str],
     ) -> Tuple[str, List[str]]:
         self.last_call_error = ""
+        self._reset_call_delta()
         if not self.tool_replay:
             self.last_call_error = (
                 "OpenCode CLI tool replay is not supported without explicit "
@@ -1616,6 +1627,7 @@ def _call(self, prompt: str, *, max_tokens: int = 1024, retries: int = 3) -> str
         return out
 
     def attempt_with_tools(self, task, skill, memory, tools):
+        self._reset_call_delta()
         # Codex exec runs in a sandbox with shell access; expose the same real
         # `search` shim and let it run (workspace-write so the shim can log).
         import tempfile, shutil, stat
@@ -1880,6 +1892,7 @@ def _parse_jsonl_response(raw: str) -> str:
         return "\n".join(parts).strip()
 
     def attempt_with_tools(self, task, skill, memory, tools):
+        self._reset_call_delta()
         # Expose REAL, callable tool shims in the working directory so the
         # gbrain quick-answerer judge (tool_called=search) is validated
         # honestly: we detect each call from the shim's log, not from a
 
@@ -223,6 +223,44 @@ def fake_run(*args, **kwargs):
     assert db.token_delta() > 0, "dual-backend tool replay did not set target delta"
 
 
+def test_record_cost_concurrent_no_lost_updates():
+    """Barrier-forced concurrent _record_cost calls must not lose updates."""
+    n = 30
+    barrier = threading.Barrier(n)
+
+    class _BarrierEcho(_EchoBackend):
+        def _cost_worker(self):
+            barrier.wait(timeout=15)
+            self._record_cost("hello", "world")
+
+    b = _BarrierEcho()
+    threads = [threading.Thread(target=b._cost_worker) for _ in range(n)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    per = len("hello") // 4 + len("world") // 4
+    assert b._tokens == per * n, f"concurrent _record_cost lost updates: {b._tokens} != {per * n}"
+
+
+def test_disabled_tool_replay_resets_call_delta():
+    """A prior call's delta must not leak through a disabled-tool-replay path."""
+    from types import SimpleNamespace
+
+    from skillopt_sleep.backend import OpenCodeCliBackend
+
+    b = OpenCodeCliBackend(model="", opencode_path="opencode", tool_replay=False)
+    # A prior call on this thread set a nonzero call-local delta.
+    b._record_cost("hello", "world")
+    assert b.token_delta() > 0  # stale from the prior call
+    # Disabled-tool-replay attempt_with_tools returns early; the delta must be
+    # reset to 0 so a reused worker does not report the previous call's cost.
+    task = SimpleNamespace(intent="intent", context_excerpt="ctx")
+    out, called = b.attempt_with_tools(task, skill="s", memory="m", tools=["search"])
+    assert out == "" and called == []
+    assert b.token_delta() == 0, "disabled-tool-replay leaked the prior call's delta"
+
+
 def test_cmd_harvest_redact_deep_is_key_aware():
     """_redact_deep must key-aware redact — `{"api_key": "x"}` used to leak."""
     from skillopt_sleep.__main__ import _redact_deep