Files
headroom/tests/test_ccr_context_tracker.py
9b9a883e96 fix(ccr): only proactively expand compressions present in the requesting conversation (#3924)
## Description

**What users see:** with Claude Code agent teams behind the proxy in
`token` mode, a teammate can receive a large block of another agent's
tool output glued onto the message it got from the lead. The teammate
never ran that tool, so it treats the block as junk ("got system context
garbage message, ignoring it" in #1174). The lead is not affected.

**Why it happens:** CCR proactive expansion keeps one tracker per proxy
process of every lossy compression it made. When a new user message
shares a few keywords with one of them, it appends that compression's
full original text to the message. Since the 2026-05-26 cross-project
leak, the tracker filters by workspace (the cwd). But a lead and its
teammates run in the same cwd, so they share every tracked entry. A
teammate's `<teammate-message>` that mentions the same files as the
lead's earlier `Bash`/`Read` output pulls that output in. In the repro
below a 127-character teammate message reached the model as 27,722
characters.

**Fix:** only expand compressions that the requesting conversation
actually holds, meaning their CCR marker is in this request. The handler
already scans the request for markers and drops hashes this proxy never
stored (`injector.verify_ownership()`, used for `headroom_retrieve`
injection). It now hands that list to
`ContextTracker.analyze_query(present_hashes=...)`, which skips
everything else before ranking. A conversation that still sees a
compressed marker gets its expansion exactly as before. A compression it
never received was never "context it lost", so it is no longer a
candidate.

This uses content (markers in the request) rather than a session id.
Parallel agents with the same model and system prompt can share a
fallback session id (#2193), so the session id cannot tell them apart.

Refs #1174. Related: #2706 (stale, changes requested) asks for
per-session ownership plus a claim/release and replay guard, for the
duplicate-expansion cost problem in #2186. This PR is smaller and
independent of it. It also keeps a new session from receiving expansions
of an earlier session's compressions in the same cwd, because those
markers are not in the new session's history.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `headroom/ccr/context_tracker.py`: `analyze_query` takes an optional
keyword `present_hashes`. When given, contexts whose hash is not in it
are skipped before scoring, so a foreign match cannot take one of the
`max_proactive_expansions` slots. `None` (the default) keeps today's
workspace-only behaviour for other callers.
- `headroom/proxy/handlers/anthropic.py`: keeps the ownership-verified
marker list from the CCR scan (`ccr_present_hashes`, initialised next to
`ccr_workspace_key` so it is always bound) and passes it to
`analyze_query`.
- `tests/test_ccr_expansion_conversation_scope.py` (new): drives the
real `/v1/messages` handler in token mode. A lead compression is tracked
for a cwd, then (1) a teammate request from the same cwd without the
marker must be forwarded unchanged, and (2) a request that holds the
marker must still get the expansion, including a line that only exists
in the original.
- `tests/test_ccr_context_tracker.py`: `TestConversationScoping` covers
absent hash skipped, present hash expanded, a stronger foreign match not
taking the only slot, and `None` keeping the old behaviour.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [x] Manual testing performed

### Test Output

```text
# New tests on unmodified main
FAILED tests/test_ccr_expansion_conversation_scope.py::test_teammate_does_not_receive_lead_tool_output
PASSED tests/test_ccr_expansion_conversation_scope.py::test_conversation_holding_the_marker_still_expands
FAILED TestConversationScoping (3 tests: analyze_query has no present_hashes yet)
PASSED TestConversationScoping::test_none_keeps_workspace_only_behaviour
4 failed, 2 passed

# With the fix
6 passed in 4.45s

# Related suites, serial
$ pytest tests/test_ccr_context_tracker.py tests/test_ccr_expansion_conversation_scope.py \
    tests/test_anthropic_ccr_workspace_unbound.py tests/test_proxy_anthropic_cache_stability.py \
    tests/test_proxy_handler_helpers.py tests/test_proxy_system_prompt_immutable.py \
    tests/test_cache_breakpoint_diagnostics.py tests/test_testing_harness.py \
    tests/test_cli_proxy_env.py tests/test_proxy_ccr.py -q
278 passed, 8 skipped, 2 warnings in 42.08s

$ uvx ruff@0.16.8 check . && uvx ruff@0.16.8 format --check .
All checks passed!
1706 files already formatted

$ uvx mypy@1.20.2 headroom --ignore-missing-imports --no-site-packages
headroom\fileperms.py:71: error: Module has no attribute "fchmod"  [attr-defined]
Found 1 error in 1 file (checked 554 source files)
# Windows-only: os.fchmod does not exist on Windows. The file is not touched
# by this PR; CI runs mypy on Linux.
```

The same suites run in parallel (`-n 6`) once reported
`test_ccr_tool_stays_in_forwarded_tools_across_frozen_transition` as
failed. It passes on its own both with and without this change, and
passes in the serial run above, so it looks order-dependent and
unrelated.

## Real Behavior Proof

- Environment: Windows 11, Python 3.12, this branch vs `upstream/main`
at d5318ac2. Real proxy app (`create_app`) with `mode="token"`,
`savings_profile="coding"`, the real compression pipeline and a warm
Kompress ONNX model; only the upstream HTTP call is stubbed. Both
requests send the same `x-headroom-cwd`, as `headroom wrap claude` does
for a lead and its teammates.
- Exact command / steps: (1) "Lead" request: a `Bash` tool result of
about 27 KB of prose about the auth middleware, which the proxy
compresses with Kompress and tracks. (2) "Teammate" request: a different
system prompt and a single user message, `<teammate-message
teammate_id="team-lead">Review the auth middleware session token
handling and report back.</teammate-message>`. Inspect what the proxy
forwards for the teammate.
- Observed result: on `main` the teammate's message is forwarded as
27,722 characters instead of 127. After the teammate's text comes
`<headroom_proactive_expansion>[Proactive Context Expansion - relevant
to your query | workspace: …] --- Expanded from earlier (0 items
compressed in turn 1, high relevance to current query) ---` and then the
lead's full original tool output. On this branch the same teammate
message is forwarded unchanged (127 → 127). The lead's own compression
and tracking are unchanged (`tracked contexts: 1` in both runs).
- Not tested: a live Claude Code agent-team run against the real
Anthropic API. The OpenAI handler, which has no proactive expansion
path. Cache mode, where the append is already skipped, so this change
has no effect there.

## Runtime Rollout Safety

- Rollout-managed feature(s): None. CCR proactive expansion is not gated
in `headroom/rollout.py`.
- Minimum rollout channel: Not applicable.
- Stable/default behavior changed: Yes, in token mode only: proactive
expansion now fires only for compressions whose marker is in the
request. Cache mode (the default) already skips the append and is
unaffected.
- Kill switch / disable path: Unchanged. `--no-ccr-proactive-expansion`
or `HEADROOM_NO_CCR_PROACTIVE_EXPANSION=1` turns the feature off.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert this PR. All state is in-process; no persisted
format changes.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Additional Notes

- No documentation change: proactive expansion's user-facing description
("expand what was compressed earlier when it becomes relevant") is
unchanged; this narrows it to the conversation's own content, which is
what the docs already imply.
- Trade-off: if the client itself drops the message that held a marker
(for example Claude Code's `/compact`), that compression is no longer
proactively expanded in that conversation. That is the behaviour #2186
asked for.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/3924"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: JD Davis <mxjerrett@gmail.com>
2026-10-04 13:58:00 -07:00

1049 lines
36 KiB
Python

"""Tests for CCR context tracker.
These tests verify that:
1. Compression events are tracked correctly
2. Query analysis finds relevant compressed contexts
3. Proactive expansion works as expected
4. LRU eviction and TTL work correctly
5. Expansion recommendations are appropriate
"""
import json
import time
import pytest
from headroom.cache.compression_store import (
get_compression_store,
reset_compression_store,
)
from headroom.ccr.context_tracker import (
CompressedContext,
ContextTracker,
ContextTrackerConfig,
ExpansionRecommendation,
get_context_tracker,
looks_like_claude_code_compact_summary,
reset_context_tracker,
)
class TestContextTrackerBasics:
"""Test basic context tracking functionality."""
@pytest.fixture(autouse=True)
def reset_trackers(self):
"""Reset trackers before each test."""
reset_context_tracker()
reset_compression_store()
yield
reset_context_tracker()
reset_compression_store()
def test_track_compression(self):
"""Track a compression event."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="abc123",
turn_number=1,
tool_name="Bash",
original_count=100,
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()
stats = tracker.get_stats()
assert stats["tracked_contexts"] == 1
def test_claude_code_compact_summary_not_tracked(self):
"""Claude Code `/compact` summaries are not proactively re-expanded."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="compact_summary",
turn_number=1,
tool_name="Claude Code",
original_count=1,
compressed_count=1,
query_context="Claude Code /compact summary",
sample_content=(
"This session is being continued from a previous conversation "
"that ran out of context. The conversation is summarized below: "
"We changed the auth middleware and still need to run tests."
),
workspace_key="ws-test",
)
assert tracker.get_tracked_hashes() == []
def test_claude_code_compact_summary_detector_is_narrow(self):
"""The compact-summary detector does not reject ordinary summaries."""
assert looks_like_claude_code_compact_summary(
"This session is being continued from a previous conversation. "
"The conversation is summarized below."
)
assert not looks_like_claude_code_compact_summary(
"search results summary for auth middleware files"
)
def test_track_multiple_compressions(self):
"""Track multiple compression events."""
tracker = ContextTracker()
for i in range(5):
tracker.track_compression(
hash_key=f"hash_{i}",
turn_number=i,
tool_name="Bash",
original_count=100,
compressed_count=10,
workspace_key="ws-test",
)
hashes = tracker.get_tracked_hashes()
assert len(hashes) == 5
assert all(f"hash_{i}" in hashes for i in range(5))
def test_tracking_disabled(self):
"""Tracking disabled doesn't store contexts."""
config = ContextTrackerConfig(enabled=False)
tracker = ContextTracker(config)
tracker.track_compression(
hash_key="abc123",
turn_number=1,
tool_name="Bash",
original_count=100,
compressed_count=10,
workspace_key="ws-test",
)
assert len(tracker.get_tracked_hashes()) == 0
def test_update_existing_hash(self):
"""Updating existing hash updates the context data."""
tracker = ContextTracker()
tracker.track_compression(
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,
workspace_key="ws-test",
)
tracker.track_compression(
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
hashes = tracker.get_tracked_hashes()
assert len(hashes) == 2
assert "first" in hashes
assert "second" in hashes
# The updated context should have the new values
stats = tracker.get_stats()
first_ctx = next(c for c in stats["contexts"] if c["hash"] == "first")
assert first_ctx["items"] == "6/60" # Updated values
assert first_ctx["turn"] == 3
class TestLRUEviction:
"""Test LRU eviction at capacity."""
def test_eviction_at_capacity(self):
"""Oldest entries evicted when at capacity."""
config = ContextTrackerConfig(max_tracked_contexts=3)
tracker = ContextTracker(config)
for i in range(5):
tracker.track_compression(
hash_key=f"hash_{i}",
turn_number=i,
tool_name=None,
original_count=100,
compressed_count=10,
workspace_key="ws-test",
)
time.sleep(0.01) # Ensure different timestamps
hashes = tracker.get_tracked_hashes()
assert len(hashes) == 3
# Should have the last 3
assert "hash_2" in hashes
assert "hash_3" in hashes
assert "hash_4" in hashes
# First 2 should be evicted
assert "hash_0" not in hashes
assert "hash_1" not in hashes
class TestQueryAnalysis:
"""Test query analysis for relevance detection."""
@pytest.fixture(autouse=True)
def reset_trackers(self):
"""Reset trackers before each test."""
reset_context_tracker()
reset_compression_store()
yield
reset_context_tracker()
reset_compression_store()
def test_analyze_query_finds_relevant_context(self):
"""Query analysis finds relevant compressed context."""
# Use lower relevance threshold to make test more reliable
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,
query_context="find authentication files",
# Use more explicit content with keywords that will match
sample_content="authentication middleware handler login security",
workspace_key="ws-test",
)
recommendations = tracker.analyze_query(
query="show authentication middleware", current_turn=2, workspace_key="ws-test"
)
assert len(recommendations) >= 1
assert recommendations[0].hash_key == "auth_hash"
def test_analyze_query_no_match(self):
"""Query analysis returns empty for unrelated query."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="db_hash",
turn_number=1,
tool_name="Bash",
original_count=100,
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, workspace_key="ws-test"
)
# Should not match unrelated query
assert len(recommendations) == 0
def test_analyze_query_keyword_overlap(self):
"""Query matches based on keyword overlap."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="python_files",
turn_number=1,
tool_name="Glob",
original_count=200,
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 keywords
recommendations = tracker.analyze_query(
query="Show me the main python file", current_turn=2, workspace_key="ws-test"
)
assert len(recommendations) >= 1
def test_analyze_query_proactive_disabled(self):
"""No recommendations when proactive expansion disabled."""
config = ContextTrackerConfig(proactive_expansion=False)
tracker = ContextTracker(config)
tracker.track_compression(
hash_key="abc123",
turn_number=1,
tool_name="Bash",
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, workspace_key="ws-test"
)
assert len(recommendations) == 0
def test_analyze_query_respects_age(self):
"""Old contexts get lower relevance scores."""
config = ContextTrackerConfig(max_context_age_seconds=2.0)
tracker = ContextTracker(config)
tracker.track_compression(
hash_key="old_context",
turn_number=1,
tool_name="Bash",
original_count=100,
compressed_count=10,
sample_content='["auth.py"]',
workspace_key="ws-test",
)
# Wait for context to age
time.sleep(2.1)
recommendations = tracker.analyze_query(
query="Show me the authentication code", current_turn=5, workspace_key="ws-test"
)
# Should not recommend aged-out context
assert len(recommendations) == 0
def test_analyze_query_max_recommendations(self):
"""Respects max proactive expansions limit."""
config = ContextTrackerConfig(max_proactive_expansions=2)
tracker = ContextTracker(config)
# Track many relevant contexts
for i in range(5):
tracker.track_compression(
hash_key=f"hash_{i}",
turn_number=i,
tool_name="Bash",
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, workspace_key="ws-test"
)
assert len(recommendations) <= 2
class TestRelevanceCalculation:
"""Test relevance score calculation."""
def test_extract_keywords(self):
"""Keywords are extracted correctly."""
tracker = ContextTracker()
keywords = tracker._extract_keywords("Find authentication middleware files")
assert "authentication" in keywords
assert "middleware" in keywords
assert "files" in keywords
# Stop words should be filtered
assert "the" not in keywords
def test_exact_substring_match_bonus(self):
"""Exact substring matches get bonus score."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="exact_match",
turn_number=1,
tool_name=None,
original_count=100,
compressed_count=10,
sample_content="authentication_middleware.py, auth_handler.py",
workspace_key="ws-test",
)
# Query with exact substring match
recommendations = tracker.analyze_query(
query="authentication middleware", current_turn=2, workspace_key="ws-test"
)
assert len(recommendations) >= 1
# Should have high relevance
assert recommendations[0].relevance_score > 0.3
class TestExpansionExecution:
"""Test execution of expansion recommendations."""
@pytest.fixture(autouse=True)
def reset_stores(self):
"""Reset stores before each test."""
reset_context_tracker()
reset_compression_store()
yield
reset_context_tracker()
reset_compression_store()
def test_execute_full_expansion(self):
"""Execute full expansion retrieval."""
store = get_compression_store()
original = json.dumps([{"id": i} for i in range(100)])
hash_key = store.store(
original=original,
compressed="[]",
original_item_count=100,
)
tracker = ContextTracker()
recommendations = [
ExpansionRecommendation(
hash_key=hash_key,
reason="relevant to query",
relevance_score=0.8,
)
]
results = tracker.execute_expansions(recommendations)
assert len(results) == 1
assert results[0]["type"] == "full"
assert results[0]["item_count"] == 100
def test_execute_nonexistent_hash(self):
"""Handle expansion of nonexistent hash gracefully."""
tracker = ContextTracker()
recommendations = [
ExpansionRecommendation(
hash_key="nonexistent123",
reason="test",
relevance_score=0.5,
)
]
results = tracker.execute_expansions(recommendations)
# Should handle gracefully, no results
assert len(results) == 0
class TestExpansionFormatting:
"""Test formatting of expansions for context."""
def test_format_full_expansion(self):
"""Format full expansion for LLM context."""
tracker = ContextTracker()
expansions = [
{
"hash": "abc123",
"type": "full",
"content": '[{"id": 1}, {"id": 2}]',
"item_count": 2,
"reason": "relevant to query",
}
]
formatted = tracker.format_expansions_for_context(expansions)
assert "[Proactive Context Expansion" in formatted
assert "Expanded from earlier" in formatted
assert '[{"id": 1}, {"id": 2}]' in formatted
assert formatted.startswith("<headroom_proactive_expansion>\n")
assert formatted.endswith("\n</headroom_proactive_expansion>")
def test_format_empty_expansions(self):
"""Empty expansions return empty string."""
tracker = ContextTracker()
formatted = tracker.format_expansions_for_context([])
assert formatted == ""
def test_format_expansion_xml_wrapper(self):
"""Expansion output is wrapped in machine-readable XML provenance tag."""
tracker = ContextTracker()
expansions = [
{
"hash": "h1",
"type": "full",
"content": "expanded content",
"item_count": 1,
"reason": "high relevance",
}
]
result = tracker.format_expansions_for_context(expansions)
assert result.startswith("<headroom_proactive_expansion>\n")
assert result.endswith("\n</headroom_proactive_expansion>")
assert "[Proactive Context Expansion" in result
assert result.count("[End Proactive Expansion]") == 1
def test_proactive_expansion_identifiable_after_injection(self):
"""Injected expansion carries XML provenance tag after full injection chain."""
from headroom.ccr.context_tracker import ContextTracker
from headroom.proxy.handlers.anthropic import AnthropicHandlerMixin
tracker = ContextTracker()
expansions = [
{
"hash": "h1",
"type": "full",
"content": "expanded context",
"item_count": 1,
"reason": "high relevance",
}
]
expansion_text = tracker.format_expansions_for_context(expansions)
# Simulate a user turn that contains peer_turn markup
messages = [
{
"role": "user",
"content": [
{"type": "text", "text": "<peer_turn from='AgentX'>some content</peer_turn>"}
],
}
]
result = AnthropicHandlerMixin._append_context_to_latest_non_frozen_user_turn(
messages, expansion_text, frozen_message_count=0
)
injected = result[0]["content"][0]["text"]
# Headroom-injected content is identifiable by XML tag, distinct from peer content
assert "<headroom_proactive_expansion>" in injected
assert "</headroom_proactive_expansion>" in injected
assert "<peer_turn from='AgentX'>" in injected # peer content unchanged
def test_format_expansion_xml_close_tag_in_payload_escaped(self):
"""Payload containing the XML close tag is escaped to keep wrapper boundaries intact."""
tracker = ContextTracker()
expansions = [
{
"hash": "h1",
"type": "full",
"content": "return '</headroom_proactive_expansion>'",
"item_count": 1,
"reason": "high relevance",
}
]
result = tracker.format_expansions_for_context(expansions)
assert result.startswith("<headroom_proactive_expansion>\n")
assert result.endswith("\n</headroom_proactive_expansion>")
assert result.count("<headroom_proactive_expansion>") == 1
assert result.count("</headroom_proactive_expansion>") == 1
class TestGlobalTracker:
"""Test global tracker singleton."""
@pytest.fixture(autouse=True)
def reset_tracker(self):
"""Reset global tracker."""
reset_context_tracker()
yield
reset_context_tracker()
def test_singleton_pattern(self):
"""Global tracker uses singleton pattern."""
tracker1 = get_context_tracker()
tracker2 = get_context_tracker()
assert tracker1 is tracker2
def test_reset_clears_tracker(self):
"""Reset clears the global tracker."""
tracker = get_context_tracker()
tracker.track_compression(
hash_key="test",
turn_number=1,
tool_name=None,
original_count=10,
compressed_count=1,
workspace_key="ws-test",
)
assert len(tracker.get_tracked_hashes()) == 1
reset_context_tracker()
new_tracker = get_context_tracker()
assert len(new_tracker.get_tracked_hashes()) == 0
class TestContextTrackerConfig:
"""Test context tracker configuration."""
def test_default_config(self):
"""Default config values."""
config = ContextTrackerConfig()
assert config.enabled is True
assert config.max_tracked_contexts == 100
assert config.relevance_threshold == 0.3
assert config.max_context_age_seconds == 300.0
assert config.proactive_expansion is True
assert config.max_proactive_expansions == 2
def test_custom_config(self):
"""Custom config values."""
config = ContextTrackerConfig(
enabled=False,
max_tracked_contexts=50,
relevance_threshold=0.5,
max_proactive_expansions=5,
)
assert config.enabled is False
assert config.max_tracked_contexts == 50
assert config.relevance_threshold == 0.5
assert config.max_proactive_expansions == 5
class TestCompressedContextDataClass:
"""Test CompressedContext dataclass."""
def test_create_context(self):
"""Create compressed context."""
context = CompressedContext(
hash_key="abc123",
turn_number=5,
timestamp=1234567890.0,
tool_name="Bash",
original_item_count=100,
compressed_item_count=10,
query_context="find files",
sample_content='["file1.py", "file2.py"]',
workspace_key="ws-test",
)
assert context.hash_key == "abc123"
assert context.turn_number == 5
assert context.tool_name == "Bash"
assert context.original_item_count == 100
assert context.compressed_item_count == 10
class TestExpansionRecommendationDataClass:
"""Test ExpansionRecommendation dataclass."""
def test_expansion_recommendation(self):
"""Create an expansion recommendation (retrieval is always full)."""
rec = ExpansionRecommendation(
hash_key="abc123",
reason="high relevance",
relevance_score=0.9,
)
assert rec.hash_key == "abc123"
assert rec.relevance_score == 0.9
# Partial/search expansion fields no longer exist.
assert not hasattr(rec, "expand_full")
assert not hasattr(rec, "search_query")
class TestContextTrackerStats:
"""Test tracker statistics."""
def test_stats_structure(self):
"""Stats have expected structure."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="test",
turn_number=1,
tool_name="Bash",
original_count=100,
compressed_count=10,
workspace_key="ws-test",
)
stats = tracker.get_stats()
assert "tracked_contexts" in stats
assert "current_turn" in stats
assert "config" in stats
assert "contexts" in stats
assert stats["tracked_contexts"] == 1
assert len(stats["contexts"]) == 1
def test_stats_context_details(self):
"""Stats include context details."""
tracker = ContextTracker()
tracker.track_compression(
hash_key="abc123",
turn_number=3,
tool_name="Glob",
original_count=50,
compressed_count=5,
workspace_key="ws-test",
)
stats = tracker.get_stats()
context_stat = stats["contexts"][0]
assert context_stat["hash"] == "abc123"
assert context_stat["turn"] == 3
assert context_stat["tool"] == "Glob"
assert context_stat["items"] == "5/50"
class TestTrackerClear:
"""Test tracker clear functionality."""
def test_clear_removes_all(self):
"""Clear removes all tracked contexts."""
tracker = ContextTracker()
for i in range(5):
tracker.track_compression(
hash_key=f"hash_{i}",
turn_number=i,
tool_name=None,
original_count=10,
compressed_count=1,
workspace_key="ws-test",
)
assert len(tracker.get_tracked_hashes()) == 5
tracker.clear()
assert len(tracker.get_tracked_hashes()) == 0
stats = 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()) == 5
# ============================================================================
# Conversation scoping (#1174).
#
# One workspace (cwd) can carry several live conversations at once: a Claude
# Code lead and its agent-team teammates all run in the same directory. The
# workspace gate alone let the lead's compressed tool output keyword-match a
# teammate's incoming message and get appended to it. `present_hashes` limits
# expansion to compressions whose markers the requesting conversation holds.
# ============================================================================
class TestConversationScoping:
"""Same-workspace conversations must not receive each other's content."""
_QUERY = "please review the auth middleware session code"
@pytest.fixture(autouse=True)
def reset_trackers(self):
reset_context_tracker()
reset_compression_store()
yield
reset_context_tracker()
reset_compression_store()
@staticmethod
def _track(tracker: ContextTracker, hash_key: str, sample: str) -> None:
tracker.track_compression(
hash_key=hash_key,
turn_number=1,
tool_name="Bash",
original_count=100,
compressed_count=10,
workspace_key="ws-team",
query_context="list the auth code",
sample_content=sample,
)
def test_hash_absent_from_request_is_not_expanded(self):
tracker = ContextTracker(ContextTrackerConfig(relevance_threshold=0.1))
self._track(tracker, "lead_hash", "auth middleware login session token")
recommendations = tracker.analyze_query(
query=self._QUERY, current_turn=2, workspace_key="ws-team", present_hashes=[]
)
assert recommendations == []
def test_hash_present_in_request_still_expands(self):
tracker = ContextTracker(ContextTrackerConfig(relevance_threshold=0.1))
self._track(tracker, "own_hash", "auth middleware login session token")
recommendations = tracker.analyze_query(
query=self._QUERY,
current_turn=2,
workspace_key="ws-team",
present_hashes=["own_hash"],
)
assert [r.hash_key for r in recommendations] == ["own_hash"]
def test_foreign_hash_does_not_take_an_expansion_slot(self):
config = ContextTrackerConfig(relevance_threshold=0.1, max_proactive_expansions=1)
tracker = ContextTracker(config)
# The foreign context is the stronger match; with a single slot it
# would win if it were scored at all.
self._track(tracker, "lead_hash", "auth middleware login session token review code")
self._track(tracker, "own_hash", "auth notes")
recommendations = tracker.analyze_query(
query=self._QUERY,
current_turn=2,
workspace_key="ws-team",
present_hashes=["own_hash"],
)
assert [r.hash_key for r in recommendations] == ["own_hash"]
def test_none_keeps_workspace_only_behaviour(self):
tracker = ContextTracker(ContextTrackerConfig(relevance_threshold=0.1))
self._track(tracker, "any_hash", "auth middleware login session token")
recommendations = tracker.analyze_query(
query=self._QUERY, current_turn=2, workspace_key="ws-team"
)
assert [r.hash_key for r in recommendations] == ["any_hash"]