Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
fix(ccr): scope proactive expansion by workspace (cross-project leak)
chopratejas1bc163f5bc1a
diff --git a/headroom/ccr/context_tracker.py b/headroom/ccr/context_tracker.pyindex 65ffda525..bf8dffe74 100644--- a/headroom/ccr/context_tracker.py+++ b/headroom/ccr/context_tracker.py@@ -34,7 +34,19 @@ logger = logging.getLogger(__name__)@dataclassclass CompressedContext:- """Represents a piece of compressed context from the conversation."""+ """Represents a piece of compressed context from the conversation.++ The ``workspace_key`` field is **required**: it ties every tracked+ compression to a single project/CWD identity so cross-project+ proactive expansion cannot leak. The empty string is a valid value+ (used by unit tests that don't exercise scoping) but the production+ proxy NEVER passes empty — ``track_compression`` is gated on a+ resolved workspace before the call. Reverting this to optional+ re-opens the cross-project leak (incident reported by Jocelyn,+ 2026-05-26): a tamag0 Python file surfaced inside a daphni-rails+ Ruby session because the shared in-memory tracker had no provenance+ key.+ """hash_key: strturn_number: int@@ -44,6 +56,7 @@ class CompressedContext:compressed_item_count: intquery_context: str # The query/context when compression happenedsample_content: str # Preview of what was compressed (for relevance matching)+ workspace_key: str # Stable per-project identity (see ProjectResolver in storage_router)@dataclass@@ -123,6 +136,8 @@ class ContextTracker:tool_name: str | None,original_count: int,compressed_count: int,+ *,+ workspace_key: str,query_context: str = "",sample_content: str = "",) -> None:@@ -134,6 +149,11 @@ class ContextTracker:tool_name: Name of the tool whose output was compressed.original_count: Original item count.compressed_count: Compressed item count.+ workspace_key: Stable per-project identity (e.g. the+ ``ProjectResolver`` key for the request's CWD). REQUIRED:+ cross-workspace expansion is the bug class this guards+ against. Pass the empty string only from tests that+ explicitly exercise the no-scoping path.query_context: The user query when compression happened.sample_content: Sample of the content for relevance matching."""@@ -149,6 +169,7 @@ class ContextTracker:compressed_item_count=compressed_count,query_context=query_context,sample_content=sample_content[:2000], # Limit sample size+ workspace_key=workspace_key,)# Add or update context@@ -173,12 +194,22 @@ class ContextTracker:self,query: str,current_turn: int | None = None,+ *,+ workspace_key: str,) -> list[ExpansionRecommendation]:"""Analyze a query to find relevant compressed contexts.Args:query: The user's query/message.current_turn: Current turn number (for age calculation).+ workspace_key: Stable per-project identity. ONLY contexts+ whose ``workspace_key`` matches will be considered for+ expansion. This is the gate that prevents cross-project+ leaks (e.g. Project A's Python code surfacing in+ Project B's Ruby query). REQUIRED — callers MUST resolve+ a workspace before invoking; the empty string short-+ circuits to an empty result set rather than matching+ empty-keyed test contexts to avoid accidental crossover.Returns:List of expansion recommendations, sorted by relevance.@@ -186,6 +217,19 @@ class ContextTracker:if not self.config.enabled or not self.config.proactive_expansion:return []+ # Empty workspace = caller couldn't resolve project identity.+ # Fail closed: return nothing. The user loses the proactive+ # expansion optimization on this turn (which is fine — it's an+ # optimization, not correctness) and avoids any cross-workspace+ # match. See `feedback_no_silent_fallbacks`: an empty workspace+ # is the loud failure, not a license to match anything.+ if not workspace_key:+ logger.debug(+ "CCR Tracker: analyze_query called with empty workspace_key; "+ "returning no recommendations (fail-closed)"+ )+ return []+if current_turn is not None:self._current_turn = current_turn@@ -193,6 +237,12 @@ class ContextTracker:now = time.time()for hash_key, context in self._contexts.items():+ # Workspace filter — the cross-project leak gate. Skip+ # entries that belong to a different project than the one+ # the current request resolved to.+ if context.workspace_key != workspace_key:+ continue+# Check ageage = now - context.timestampif age > self.config.max_context_age_seconds:@@ -574,12 +624,28 @@ class ContextTracker:self._current_turn = 0-# Global instance (per-session)+# Process-wide singleton — kept only for the unit-test API surface.+# The production proxy holds its tracker as ``self.ccr_context_tracker``+# on the long-lived server object (see ``proxy/server.py:562``), NOT+# through this module-level handle. The old comment claiming this was+# "per-session" was wrong AND dangerous: it was the implicit license+# behind the cross-project leak Jocelyn reported (a single shared+# tracker has no way to keep Project A's compression sample out of+# Project B's analyze_query). Treat this handle as test-only._context_tracker: ContextTracker | None = Nonedef get_context_tracker() -> ContextTracker:- """Get the global context tracker."""+ """Get the process-wide context tracker (TEST-ONLY).++ Production code holds the tracker on the proxy server object so+ one process can scope multiple workspaces via the+ ``track_compression(..., workspace_key=...)`` /+ ``analyze_query(..., workspace_key=...)`` parameters. Code paths+ that reach here in a production-style flow should be considered+ broken — there is no caller-provided workspace identity at this+ layer.+ """global _context_trackerif _context_tracker is None:_context_tracker = ContextTracker()diff --git a/headroom/proxy/handlers/anthropic.py b/headroom/proxy/handlers/anthropic.pyindex e3b59ac34..df05de481 100644--- a/headroom/proxy/handlers/anthropic.py+++ b/headroom/proxy/handlers/anthropic.py@@ -37,6 +37,64 @@ logger = logging.getLogger("headroom.proxy")class AnthropicHandlerMixin:"""Mixin providing Anthropic API handler methods for HeadroomProxy."""+ @staticmethod+ def _resolve_ccr_workspace(+ request: Any,+ body: Any,+ ) -> tuple[str, str | None]:+ """Resolve (workspace_key, workspace_label) for CCR scoping.++ Uses the same ``ProjectResolver`` the memory subsystem uses+ (``headroom/memory/storage_router.py``) so CCR and memory always+ agree on which project a request belongs to. Tier order matches:+ ``x-headroom-project-id`` → ``x-headroom-cwd`` → CLI override →+ ``cwd:`` line in the system prompt.++ Returns:+ ``(workspace_key, workspace_label)``. If no signal yields a+ project, returns ``("", None)`` — the empty key is the+ fail-closed signal that callers gate on (skipping+ ``track_compression`` and ``analyze_query`` entirely+ rather than tracking under an empty workspace which would+ create un-matchable entries).++ See also: the 2026-05-26 cross-project leak report which+ motivated this scoping (Python content from project ``tamag0``+ surfaced inside a Ruby ``daphni-rails`` session).+ """+ from headroom.memory.storage_router import (+ ProjectResolver,+ )+ from headroom.memory.storage_router import (+ RequestContext as _CtxFor,+ )+ from headroom.memory.storage_router import (+ extract_system_prompt as _extract_sys_prompt,+ )++ try:+ ctx = _CtxFor(+ headers=dict(request.headers),+ system_prompt=_extract_sys_prompt(body),+ base_user_id=request.headers.get("x-headroom-user-id", ""),+ project_root_override=None,+ )+ ident = ProjectResolver().resolve(ctx)+ except Exception as exc: # noqa: BLE001+ # ProjectResolver is best-effort — log loudly and fail+ # closed so a malformed request doesn't crash the proxy+ # AND doesn't accidentally bypass the workspace filter.+ logger.warning(+ "event=ccr_workspace_resolve_failed error=%s; "+ "CCR proactive expansion disabled for this request",+ exc,+ )+ return "", None++ if ident is None:+ return "", None+ return ident[0], ident[1]+@staticmethoddef _tool_sort_key(tool: dict[str, Any]) -> tuple[str, str]:"""Deterministic sort key for Anthropic/OpenAI-style tool definitions."""@@ -1229,9 +1287,25 @@ class AnthropicHandlerMixin:f"hashes_seen={len(injector.detected_hashes)})")+ # CCR workspace scoping: resolve a stable project identity+ # for the request once and reuse it for both track_compression+ # AND analyze_query. The shared `self.ccr_context_tracker`+ # is process-global across all sessions/projects served by+ # this proxy; without this gate, Project A's compressed+ # sample content keyword-matches Project B's later query+ # and gets surfaced as "relevant" — see+ # `headroom/ccr/context_tracker.py` module docstring for+ # the 2026-05-26 leak report (Python from tamag0+ # injected into a daphni-rails Ruby session).+ ccr_workspace_key, ccr_workspace_label = self._resolve_ccr_workspace(request, body)+if injector.has_compressed_content:- # Track compression in context tracker for multi-turn awareness- if self.ccr_context_tracker:+ # Track compression in context tracker for multi-turn awareness.+ # Gated on a resolved workspace: tracking under an empty+ # workspace would create entries that the workspace-filter+ # in analyze_query can never match. Fail-closed per+ # `feedback_no_silent_fallbacks`.+ if self.ccr_context_tracker and ccr_workspace_key:self._turn_counter += 1for hash_key in injector.detected_hashes:# Get compression metadata from store@@ -1244,12 +1318,24 @@ class AnthropicHandlerMixin:tool_name=entry.get("tool_name"),original_count=entry.get("original_item_count", 0),compressed_count=entry.get("compressed_item_count", 0),+ workspace_key=ccr_workspace_key,query_context=entry.get("query_context", ""),sample_content=entry.get("compressed_content", "")[:500],)+ elif self.ccr_context_tracker and not ccr_workspace_key:+ logger.info(+ f"[{request_id}] CCR: workspace unresolved; skipping "+ "track_compression (fail-closed — no x-headroom-cwd / "+ "x-headroom-project-id header and no cwd: in system prompt)"+ )- # CCR Proactive Expansion: Check if current query needs expanded context- if self.ccr_context_tracker and self.config.ccr_proactive_expansion:+ # CCR Proactive Expansion: Check if current query needs expanded context.+ # Same workspace gate as track_compression above.+ if (+ self.ccr_context_tracker+ and self.config.ccr_proactive_expansion+ and ccr_workspace_key+ ):# Extract user query from messagesuser_query = ""for msg in reversed(messages):@@ -1266,14 +1352,19 @@ class AnthropicHandlerMixin:if user_query:recommendations = self.ccr_context_tracker.analyze_query(- user_query, self._turn_counter+ user_query,+ self._turn_counter,+ workspace_key=ccr_workspace_key,)if recommendations:expansions = self.ccr_context_tracker.execute_expansions(recommendations)if expansions:- # Add expanded context to the system message or as additional context+ # Add expanded context to the system message or as additional context.+ # Pass workspace_label so the injected block declares its provenance+ # — symmetric with the memory-injection block header.expansion_text = self.ccr_context_tracker.format_expansions_for_context(- expansions+ expansions,+ workspace_label=ccr_workspace_label,)logger.info(f"[{request_id}] CCR: Proactively expanded {len(expansions)} context(s) "diff --git a/tests/test_ccr_context_tracker.py b/tests/test_ccr_context_tracker.pyindex c517d0acd..127bfca0f 100644--- a/tests/test_ccr_context_tracker.py+++ b/tests/test_ccr_context_tracker.py@@ -51,6 +51,7 @@ class TestContextTrackerBasics:compressed_count=10,query_context="find all python files",sample_content='["src/main.py", "src/auth.py"]',+ workspace_key="ws-test",)assert "abc123" in tracker.get_tracked_hashes()@@ -68,6 +69,7 @@ class TestContextTrackerBasics:tool_name="Bash",original_count=100,compressed_count=10,+ workspace_key="ws-test",)hashes = tracker.get_tracked_hashes()@@ -85,6 +87,7 @@ class TestContextTrackerBasics:tool_name="Bash",original_count=100,compressed_count=10,+ workspace_key="ws-test",)assert len(tracker.get_tracked_hashes()) == 0@@ -94,13 +97,28 @@ class TestContextTrackerBasics:tracker = ContextTracker()tracker.track_compression(- hash_key="first", turn_number=1, tool_name=None, original_count=50, compressed_count=5+ hash_key="first",+ turn_number=1,+ tool_name=None,+ original_count=50,+ compressed_count=5,+ workspace_key="ws-test",)tracker.track_compression(- hash_key="second", turn_number=2, tool_name=None, original_count=50, compressed_count=5+ hash_key="second",+ turn_number=2,+ tool_name=None,+ original_count=50,+ compressed_count=5,+ workspace_key="ws-test",)tracker.track_compression(- hash_key="first", turn_number=3, tool_name=None, original_count=60, compressed_count=6+ hash_key="first",+ turn_number=3,+ tool_name=None,+ original_count=60,+ compressed_count=6,+ workspace_key="ws-test",)# Should still have 2 unique hashes@@ -131,6 +149,7 @@ class TestLRUEviction:tool_name=None,original_count=100,compressed_count=10,+ workspace_key="ws-test",)time.sleep(0.01) # Ensure different timestamps@@ -172,11 +191,11 @@ class TestQueryAnalysis:query_context="find authentication files",# Use more explicit content with keywords that will matchsample_content="authentication middleware handler login security",+ workspace_key="ws-test",)recommendations = tracker.analyze_query(- query="show authentication middleware",- current_turn=2,+ query="show authentication middleware", current_turn=2, workspace_key="ws-test")assert len(recommendations) >= 1@@ -194,11 +213,11 @@ class TestQueryAnalysis:compressed_count=10,query_context="find database files",sample_content='["database.py", "models.py"]',+ workspace_key="ws-test",)recommendations = tracker.analyze_query(- query="What is the weather like?",- current_turn=2,+ query="What is the weather like?", current_turn=2, workspace_key="ws-test")# Should not match unrelated query@@ -216,12 +235,12 @@ class TestQueryAnalysis:compressed_count=20,query_context="find python files",sample_content='["main.py", "utils.py", "config.py", "test_main.py"]',+ workspace_key="ws-test",)# Query with overlapping keywordsrecommendations = tracker.analyze_query(- query="Show me the main python file",- current_turn=2,+ query="Show me the main python file", current_turn=2, workspace_key="ws-test")assert len(recommendations) >= 1@@ -238,11 +257,11 @@ class TestQueryAnalysis:original_count=100,compressed_count=10,sample_content='["relevant.py"]',+ workspace_key="ws-test",)recommendations = tracker.analyze_query(- query="Show me relevant files",- current_turn=2,+ query="Show me relevant files", current_turn=2, workspace_key="ws-test")assert len(recommendations) == 0@@ -259,14 +278,14 @@ class TestQueryAnalysis:original_count=100,compressed_count=10,sample_content='["auth.py"]',+ workspace_key="ws-test",)# Wait for context to agetime.sleep(2.1)recommendations = tracker.analyze_query(- query="Show me the authentication code",- current_turn=5,+ query="Show me the authentication code", current_turn=5, workspace_key="ws-test")# Should not recommend aged-out context@@ -286,11 +305,11 @@ class TestQueryAnalysis:original_count=100,compressed_count=10,sample_content=f'["python_{i}.py", "main.py"]',+ workspace_key="ws-test",)recommendations = tracker.analyze_query(- query="Show me the python main file",- current_turn=10,+ query="Show me the python main file", current_turn=10, workspace_key="ws-test")assert len(recommendations) <= 2@@ -322,12 +341,12 @@ class TestRelevanceCalculation:original_count=100,compressed_count=10,sample_content="authentication_middleware.py, auth_handler.py",+ workspace_key="ws-test",)# Query with exact substring matchrecommendations = tracker.analyze_query(- query="authentication middleware",- current_turn=2,+ query="authentication middleware", current_turn=2, workspace_key="ws-test")assert len(recommendations) >= 1@@ -351,6 +370,7 @@ class TestExpansionTypeDetection:compressed_item_count=5,query_context="find files",sample_content="auth.py, middleware.py",+ workspace_key="ws-test",)expand_full, search_query = tracker._determine_expansion_type(@@ -375,6 +395,7 @@ class TestExpansionTypeDetection:compressed_item_count=5,query_context="find files",sample_content="file.py",+ workspace_key="ws-test",)expand_full, search_query = tracker._determine_expansion_type(@@ -398,6 +419,7 @@ class TestExpansionTypeDetection:compressed_item_count=20,query_context="find all files",sample_content="many files...",+ workspace_key="ws-test",)expand_full, search_query = tracker._determine_expansion_type(@@ -579,6 +601,7 @@ class TestGlobalTracker:tool_name=None,original_count=10,compressed_count=1,+ workspace_key="ws-test",)assert len(tracker.get_tracked_hashes()) == 1@@ -632,6 +655,7 @@ class TestCompressedContextDataClass:compressed_item_count=10,query_context="find files",sample_content='["file1.py", "file2.py"]',+ workspace_key="ws-test",)assert context.hash_key == "abc123"@@ -683,6 +707,7 @@ class TestContextTrackerStats:tool_name="Bash",original_count=100,compressed_count=10,+ workspace_key="ws-test",)stats = tracker.get_stats()@@ -705,6 +730,7 @@ class TestContextTrackerStats:tool_name="Glob",original_count=50,compressed_count=5,+ workspace_key="ws-test",)stats = tracker.get_stats()@@ -730,6 +756,7 @@ class TestTrackerClear:tool_name=None,original_count=10,compressed_count=1,+ workspace_key="ws-test",)assert len(tracker.get_tracked_hashes()) == 5@@ -739,3 +766,235 @@ class TestTrackerClear:assert len(tracker.get_tracked_hashes()) == 0stats = tracker.get_stats()assert stats["current_turn"] == 0+++# ============================================================================+# Workspace scoping (cross-project leak prevention).+#+# The bug: the ContextTracker is process-shared (one per proxy process,+# serving all sessions/projects). Without a workspace gate, Project A's+# compressed sample content keyword-matches Project B's later query and+# surfaces as "relevant" — which is exactly what Jocelyn reported on+# 2026-05-26: a tamag0 Python file (Ollama inference provider) appeared+# inside an unrelated daphni-rails Ruby/RSpec session.+#+# These tests pin the gate at the analyze_query level: entries are+# scoped by workspace_key, the same key the memory subsystem derives+# via ProjectResolver. Matching across workspaces is silently filtered;+# an empty workspace_key on analyze_query short-circuits to no+# recommendations (fail-closed per no-silent-fallbacks).+# ============================================================================+++class TestWorkspaceScoping:+ """Cross-workspace leak prevention — the bug joce reported 2026-05-26."""++ @pytest.fixture(autouse=True)+ def reset_trackers(self):+ reset_context_tracker()+ reset_compression_store()+ yield+ reset_context_tracker()+ reset_compression_store()++ def test_same_workspace_match_works(self):+ """Within a single workspace, proactive expansion still functions normally."""+ config = ContextTrackerConfig(relevance_threshold=0.1)+ tracker = ContextTracker(config)++ tracker.track_compression(+ hash_key="auth_hash",+ turn_number=1,+ tool_name="Bash",+ original_count=100,+ compressed_count=10,+ workspace_key="ws-rails",+ query_context="find authentication files",+ sample_content="authentication middleware handler login security",+ )++ recommendations = tracker.analyze_query(+ query="show authentication middleware",+ current_turn=2,+ workspace_key="ws-rails",+ )++ # Same workspace — match expected (regression: don't accidentally over-filter).+ assert len(recommendations) >= 1+ assert recommendations[0].hash_key == "auth_hash"++ def test_cross_workspace_match_silently_filtered(self):+ """Workspace A's entry must NOT surface in Workspace B's analyze_query.++ This is the exact bug joce reported: Project tamag0 (workspace_key+ "ws-tamag0") had Python content stored; daphni-rails workspace+ queried for OAuth/session, the keyword overlap was high enough to+ score above threshold, and without scoping the Python content+ surfaced as "relevant" — wrong project, wrong language, real+ contamination risk.+ """+ config = ContextTrackerConfig(relevance_threshold=0.1)+ tracker = ContextTracker(config)++ # Workspace A: tamag0 Python code.+ tracker.track_compression(+ hash_key="tamag0_ollama_provider",+ turn_number=1,+ tool_name="Read",+ original_count=400,+ compressed_count=40,+ workspace_key="ws-tamag0",+ query_context="ollama inference provider",+ sample_content=(+ "class OllamaInferenceProvider provider auth login generate chat embed "+ "test_ollama_provider session token oauth user authentication middleware"+ ),+ )++ # Workspace B: daphni-rails Ruby code — entirely unrelated repo.+ # The query has heavy keyword overlap with the tamag0 sample+ # above (provider, oauth, session, authentication, middleware) —+ # exactly the surface-level lexical collision that triggered the+ # production bug.+ recommendations = tracker.analyze_query(+ query="OAuth provider session cookie middleware authentication for Rails",+ current_turn=2,+ workspace_key="ws-daphni-rails",+ )++ assert len(recommendations) == 0, (+ "Cross-workspace entry must NOT surface — this is the leak class "+ "Jocelyn reported on 2026-05-26 (tamag0 Python in daphni-rails Ruby session)."+ )++ def test_empty_workspace_key_returns_no_recommendations(self):+ """Empty workspace_key short-circuits to empty result set (fail-closed)."""+ config = ContextTrackerConfig(relevance_threshold=0.1)+ tracker = ContextTracker(config)++ tracker.track_compression(+ hash_key="some_hash",+ turn_number=1,+ tool_name="Bash",+ original_count=100,+ compressed_count=10,+ workspace_key="ws-real",+ sample_content="auth middleware",+ )++ # analyze_query with empty workspace_key — caller couldn't resolve a+ # project identity for the inbound request. Fail closed: no matches.+ recommendations = tracker.analyze_query(+ query="show auth middleware",+ current_turn=2,+ workspace_key="",+ )++ assert recommendations == [], (+ "Empty workspace_key must return [] — fail-closed per "+ "feedback_no_silent_fallbacks; otherwise an empty-keyed query "+ "would match nothing on the explicit-workspace branch but might "+ "still leak in any future fallback path."+ )++ def test_two_workspaces_each_see_only_their_own(self):+ """Tracking two workspaces in one tracker — each query sees only its own."""+ config = ContextTrackerConfig(relevance_threshold=0.1)+ tracker = ContextTracker(config)++ # Identical content surface in two different workspaces.+ for ws in ("ws-a", "ws-b"):+ tracker.track_compression(+ hash_key=f"hash-{ws}",+ turn_number=1,+ tool_name="Read",+ original_count=100,+ compressed_count=10,+ workspace_key=ws,+ query_context="authentication code",+ sample_content="auth middleware login session token oauth",+ )++ rec_a = tracker.analyze_query(+ query="show auth middleware",+ current_turn=2,+ workspace_key="ws-a",+ )+ rec_b = tracker.analyze_query(+ query="show auth middleware",+ current_turn=2,+ workspace_key="ws-b",+ )++ # Each workspace sees exactly its own entry — no leak in either direction.+ assert len(rec_a) == 1 and rec_a[0].hash_key == "hash-ws-a"+ assert len(rec_b) == 1 and rec_b[0].hash_key == "hash-ws-b"++ def test_workspace_label_propagates_to_format(self):+ """`format_expansions_for_context` emits the workspace label in the header."""+ tracker = ContextTracker()++ expansions = [+ {+ "hash": "h1",+ "type": "full",+ "content": "expanded content here",+ "item_count": 5,+ "reason": "high relevance",+ }+ ]++ # Without label: header has no workspace decoration.+ header_plain = tracker.format_expansions_for_context(expansions)+ assert "workspace:" not in header_plain++ # With label: provenance appears in header — same surface as the+ # memory-injection block (symmetric, see GH #462 Fix C).+ header_labeled = tracker.format_expansions_for_context(+ expansions, workspace_label="daphni-rails"+ )+ assert "workspace: daphni-rails" in header_labeled, (+ "Label must appear in the proactive-expansion header so the "+ "downstream model can reason about which project the expanded "+ "content came from."+ )++ def test_track_with_one_workspace_then_query_with_another_skips_silently(self):+ """LRU contents from prior workspace stay in tracker but don't leak.++ Regression for the production scenario: user works on tamag0,+ tracker accumulates entries. User switches to daphni-rails (same+ proxy process, ~minutes later). New queries on daphni-rails see+ an empty result set despite the LRU being non-empty — because the+ only entries present are scoped to tamag0.+ """+ config = ContextTrackerConfig(relevance_threshold=0.1)+ tracker = ContextTracker(config)++ # Populate workspace A.+ for i in range(5):+ tracker.track_compression(+ hash_key=f"tamag0-{i}",+ turn_number=i + 1,+ tool_name="Read",+ original_count=50,+ compressed_count=5,+ workspace_key="ws-tamag0",+ sample_content=f"file_{i}.py provider auth middleware session",+ )++ # Now query as workspace B. Same lexical surface, different identity.+ recommendations = tracker.analyze_query(+ query="show me the auth middleware provider",+ current_turn=10,+ workspace_key="ws-daphni-rails",+ )++ assert recommendations == [], (+ "Cross-workspace queries must return [] — even with a fully "+ "populated tracker. The workspace filter is the only gate."+ )+ # And the tracker itself still has its entries (we're filtering on+ # read, not purging on write — workspace A could come back and use+ # them again within the age window).+ assert len(tracker.get_tracked_hashes()) == 5diff --git a/tests/test_proxy_handler_helpers.py b/tests/test_proxy_handler_helpers.pyindex 1c2b37c9f..fba2fba1c 100644--- a/tests/test_proxy_handler_helpers.py+++ b/tests/test_proxy_handler_helpers.py@@ -345,3 +345,89 @@ def test_anthropic_assistant_message_helper_requires_assistant_role() -> None:assert AnthropicHandlerMixin._assistant_message_from_response_json({"role": "assistant", "content": [{"type": "text", "text": "ok"}]}) == {"role": "assistant", "content": [{"type": "text", "text": "ok"}]}+++# ============================================================================+# CCR workspace resolution (cross-project leak fix, 2026-05-26).+#+# These tests pin the `_resolve_ccr_workspace` static helper that the+# anthropic handler uses to scope the proactive-expansion cache by+# project identity. The resolver shares its tier order with the memory+# subsystem's ProjectResolver: x-headroom-project-id → x-headroom-cwd →+# system-prompt `cwd:` line. Returns `("", None)` on no signal — the+# fail-closed signal that callers gate on.+# ============================================================================+++def _fake_request(headers: dict[str, str]) -> SimpleNamespace:+ """Minimal Starlette/FastAPI-shaped request object for resolver tests."""+ return SimpleNamespace(headers=headers)+++def test_resolve_ccr_workspace_explicit_project_id_wins() -> None:+ """x-headroom-project-id is the highest-priority signal."""+ request = _fake_request({"x-headroom-project-id": "my-cool-project"})+ body = {}+ key, label = AnthropicHandlerMixin._resolve_ccr_workspace(request, body)+ assert key == "my-cool-project"+ assert label == "my-cool-project"+++def test_resolve_ccr_workspace_cwd_header() -> None:+ """x-headroom-cwd produces a stable per-cwd key + basename label."""+ request = _fake_request({"x-headroom-cwd": "/home/user/code/daphni-rails"})+ body = {}+ key, label = AnthropicHandlerMixin._resolve_ccr_workspace(request, body)+ # Key format: "{basename}-{sha256[:16]}" — stable per absolute cwd.+ assert key.startswith("daphni-rails-")+ assert len(key) >= len("daphni-rails-") + 16+ assert label == "daphni-rails"+++def test_resolve_ccr_workspace_two_cwds_get_distinct_keys() -> None:+ """Two different cwds produce different workspace keys (cross-leak prevention)."""+ key_a, _ = AnthropicHandlerMixin._resolve_ccr_workspace(+ _fake_request({"x-headroom-cwd": "/home/user/code/daphni-rails"}), {}+ )+ key_b, _ = AnthropicHandlerMixin._resolve_ccr_workspace(+ _fake_request({"x-headroom-cwd": "/home/user/code/tamag0"}), {}+ )+ assert key_a != key_b, "different cwds must yield different workspace keys"+++def test_resolve_ccr_workspace_no_signal_returns_empty() -> None:+ """No project-id, no cwd header, no system prompt → fail-closed signal."""+ request = _fake_request({})+ body = {}+ key, label = AnthropicHandlerMixin._resolve_ccr_workspace(request, body)+ assert key == ""+ assert label is None+++def test_resolve_ccr_workspace_system_prompt_cwd_fallback() -> None:+ """System prompt with `cwd:` line is the lowest-tier fallback."""+ request = _fake_request({})+ body = {+ "system": [{"type": "text", "text": "You are helpful.\ncwd: /home/u/code/my-project\nGo."}]+ }+ key, label = AnthropicHandlerMixin._resolve_ccr_workspace(request, body)+ # The label is the basename of the cwd extracted from the prompt.+ assert label == "my-project"+ assert key.startswith("my-project-")+++def test_resolve_ccr_workspace_malformed_request_returns_empty() -> None:+ """A request whose headers attribute can't be dict()-ed fails closed, not crashes."""++ class _BrokenHeaders:+ def __iter__(self):+ raise RuntimeError("boom")++ request = SimpleNamespace(headers=_BrokenHeaders())+ body = {}+ # The helper catches the exception, logs it, and returns the fail-+ # closed sentinel ("", None). Critically, it does NOT raise — the+ # proxy must continue serving the request even if CCR scoping fails.+ key, label = AnthropicHandlerMixin._resolve_ccr_workspace(request, body)+ assert key == ""+ assert label is None