virtual-context 0.3.4__tar.gz → 0.3.6__tar.gz

virtual_context-0.3.6/.github/workflows/python-publish.yml

@@ -0,0 +1,29 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

{virtual_context-0.3.4 → virtual_context-0.3.6}/.gitignore

@@ -8,6 +8,9 @@ build/
 # Virtual environment
 .venv/
 
+# Infrastructure configs (contains secrets — never commit)
+infrastructure/
+
 # Testing
 .pytest_cache/
 

{virtual_context-0.3.4 → virtual_context-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.3.4
+Version: 0.3.6
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context

{virtual_context-0.3.4 → virtual_context-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.3.4"
+version = "0.3.6"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_assembler.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 
 import pytest
 
-from virtual_context.core.assembler import ContextAssembler
+from virtual_context.core.assembler import ContextAssembler, format_tag_section
 from virtual_context.types import (
     AssemblerConfig,
     Message,
@@ -77,6 +77,36 @@ def test_assemble_xml_tags(assembler, retrieval_result):
     assert "</virtual-context>" in section
 
 
+def test_format_tag_section_renders_code_refs():
+    now = datetime.now(timezone.utc)
+    section = format_tag_section(
+        "backend",
+        [
+            StoredSummary(
+                ref="ref-1",
+                primary_tag="backend",
+                tags=["backend"],
+                summary="Request cache boundary moved ahead of the mutable reminder.",
+                summary_tokens=18,
+                full_tokens=50,
+                metadata=SegmentMetadata(
+                    code_refs=[
+                        {"file": "virtual_context/proxy/formats.py", "line": 1312, "symbol": "inject_context"},
+                        {"file": "virtual_context/core/provider_adapters.py", "symbol": "AnthropicAdapter"},
+                    ],
+                ),
+                created_at=now,
+                start_timestamp=now,
+                end_timestamp=now,
+            ),
+        ],
+    )
+
+    assert "[refs:" in section
+    assert "virtual_context/proxy/formats.py:1312 inject_context" in section
+    assert "virtual_context/core/provider_adapters.py AnthropicAdapter" in section
+
+
 def test_trim_conversation(assembler):
     messages = [
         Message(role="user", content="x" * 400),

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_engine_state.py

@@ -28,6 +28,7 @@ def _make_snapshot(
             tags=[f"tag-{i}", "common"],
             primary_tag=f"tag-{i}",
             timestamp=datetime(2026, 1, 15, 10, i, 0, tzinfo=timezone.utc),
+            code_refs=[{"file": f"src/module_{i}.py", "line": i + 1, "symbol": f"func_{i}"}],
         )
         for i in range(turn_count)
     ]
@@ -75,6 +76,7 @@ class TestEngineStateSQLite:
             assert restored.tags == orig.tags
             assert restored.primary_tag == orig.primary_tag
             assert restored.timestamp == orig.timestamp
+            assert restored.code_refs == orig.code_refs
 
     def test_load_empty_store(self, tmp_path):
         """Loading from an empty store returns None."""
@@ -131,6 +133,7 @@ class TestEngineStateFilesystem:
             assert restored.message_hash == orig.message_hash
             assert restored.tags == orig.tags
             assert restored.primary_tag == orig.primary_tag
+            assert restored.code_refs == orig.code_refs
 
     def test_load_empty_store(self, tmp_path):
         """Loading from an empty store returns None."""

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_fact_redesign.py

@@ -61,17 +61,75 @@ def test_compaction_uses_replace_facts_for_segment():
 
 def test_code_mode_prompt_appended():
     """When code_mode is True, the compactor prompt should include the code mode block."""
-    from virtual_context.core.compactor import CODE_MODE_FACT_PROMPT
-    assert "Do NOT extract intermediary" in CODE_MODE_FACT_PROMPT
-    assert "conclusions, findings, discoveries" in CODE_MODE_FACT_PROMPT
+    from virtual_context.core.compactor import (
+        CODE_FACT_EXTRACTION_PROMPT,
+        CODE_SUMMARY_PROMPT,
+        CODE_TAG_SUMMARY_ROLLUP_PROMPT,
+    )
+    assert "Do NOT extract intermediary" in CODE_FACT_EXTRACTION_PROMPT
+    assert "conclusions, findings, discoveries" in CODE_FACT_EXTRACTION_PROMPT
+    assert "engineering conversation segment" in CODE_SUMMARY_PROMPT
+    assert '"code_refs"' in CODE_SUMMARY_PROMPT
+    assert "rolling up engineering context" in CODE_TAG_SUMMARY_ROLLUP_PROMPT
+
+
+def test_compactor_template_path_appends_code_fact_prompt():
+    from datetime import datetime, timezone
+    from unittest.mock import MagicMock
+
+    from virtual_context.core.compactor import CODE_FACT_EXTRACTION_PROMPT, DomainCompactor
+    from virtual_context.types import Message, TaggedSegment
+
+    captured: dict[str, str] = {}
+
+    llm = MagicMock()
+
+    def _complete(*, system, user, max_tokens):
+        captured["user"] = user
+        return ('{"summary":"ok","entities":[],"key_decisions":[],"action_items":[],"date_references":[],"refined_tags":[],"code_refs":[]}', {})
+
+    llm.complete.side_effect = _complete
+
+    compactor = DomainCompactor(
+        llm_provider=llm,
+        config=CompactorConfig(code_mode=True),
+    )
+
+    seg = TaggedSegment(
+        primary_tag="backend",
+        tags=["backend"],
+        messages=[
+            Message(role="user", content="We changed the request cache boundary in formats.py."),
+            Message(role="assistant", content="It now sits above the mutable VC injection block."),
+        ],
+        token_count=40,
+        start_timestamp=datetime.now(timezone.utc),
+        end_timestamp=datetime.now(timezone.utc),
+        turn_count=1,
+    )
+
+    compactor._compact_one(seg)
+
+    assert CODE_FACT_EXTRACTION_PROMPT.strip() in captured["user"]
 
 
 def test_tag_generator_accepts_code_mode():
-    from virtual_context.core.tag_generator import LLMTagGenerator
+    from virtual_context.core.tag_generator import (
+        CODE_TAG_GENERATOR_PROMPT_COMPACT,
+        CODE_TAG_GENERATOR_PROMPT_DETAILED,
+        CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL,
+        LLMTagGenerator,
+    )
     from virtual_context.types import TagGeneratorConfig
     from unittest.mock import MagicMock
     gen = LLMTagGenerator(llm_provider=MagicMock(), config=TagGeneratorConfig(), code_mode=True)
     assert gen._code_mode is True
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_DETAILED
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_DETAILED
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_COMPACT
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_COMPACT
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL
 
 
 def test_build_tag_generator_passes_code_mode():

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_proxy.py

@@ -965,6 +965,47 @@ class TestRequestCapture:
         m = ProxyMetrics()
         m.update_request_tags(99, response_tags=["x"])  # should not raise
 
+    def test_same_turn_different_turn_ids_do_not_collide(self):
+        m = ProxyMetrics()
+        m.capture_request(
+            7,
+            {"messages": []},
+            "anthropic",
+            conversation_id="conv-1",
+            turn_id="req-a",
+            inbound_tags=["first"],
+        )
+        m.capture_request(
+            7,
+            {"messages": []},
+            "anthropic",
+            conversation_id="conv-1",
+            turn_id="req-b",
+            inbound_tags=["second"],
+        )
+        m.capture_response(
+            7,
+            {"content": "a"},
+            conversation_id="conv-1",
+            turn_id="req-a",
+            upstream_input_tokens=100,
+        )
+        m.capture_response(
+            7,
+            {"content": "b"},
+            conversation_id="conv-1",
+            turn_id="req-b",
+            upstream_input_tokens=200,
+        )
+
+        req_a = m.get_captured_request(7, conversation_id="conv-1", turn_id="req-a")
+        req_b = m.get_captured_request(7, conversation_id="conv-1", turn_id="req-b")
+
+        assert req_a["inbound_tags"] == ["first"]
+        assert req_a["upstream_input_tokens"] == 100
+        assert req_b["inbound_tags"] == ["second"]
+        assert req_b["upstream_input_tokens"] == 200
+
 
 # ---------------------------------------------------------------------------
 # Request event model field

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_proxy_formats.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import copy
 import json
+import math
 from unittest.mock import MagicMock
 
 import pytest
@@ -14,6 +15,7 @@ from virtual_context.proxy.formats import (
     OpenAIFormat,
     OpenAIResponsesFormat,
     GeminiFormat,
+    _estimate_media_tokens,
     detect_format,
     get_format,
 )
@@ -30,6 +32,10 @@ from virtual_context.proxy.server import (
     _strip_vc_prompt,
 )
 
+_ONE_BY_ONE_PNG_B64 = (
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/a4sAAAAASUVORK5CYII="
+)
+
 
 # ---------------------------------------------------------------------------
 # Format detection
@@ -236,6 +242,125 @@ class TestAnthropicFormat:
         assert content[1]["cache_control"] == {"type": "ephemeral"}
         assert content[2]["text"].startswith("<system-reminder>")
 
+    def test_estimate_message_tokens_counts_calibrated_tool_result_image_and_signature(self):
+        msg = {
+            "role": "user",
+            "content": [
+                {
+                    "type": "tool_result",
+                    "tool_use_id": "tool-1",
+                    "content": [
+                        {"type": "text", "text": "Screenshot captured"},
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": "image/png",
+                                "data": _ONE_BY_ONE_PNG_B64,
+                            },
+                        },
+                    ],
+                },
+                {"type": "thinking", "text": "Working", "signature": "sig" * 1000},
+            ],
+        }
+        original = copy.deepcopy(msg)
+        estimate = self.fmt.estimate_message_tokens(msg)
+
+        media_tokens = sum(self.fmt._estimate_media_tokens(m) for m in self.fmt._collect_media_from_value(msg))
+        expected = (
+            self.fmt._TOOL_CALL_ID_TOKENS
+            + math.ceil(self.fmt._count("Screenshot captured") * self.fmt._TOOL_RESULT_TEXT_SCALE)
+            + math.ceil(self.fmt._count("Working") * self.fmt._ASSISTANT_TEXT_SCALE)
+            + math.ceil(self.fmt._count("sig" * 1000) * self.fmt._THINKING_SIGNATURE_SCALE)
+            + media_tokens
+        )
+
+        assert estimate == expected
+        assert msg == original
+
+    def test_estimate_payload_tokens_from_serialized_ignores_nested_tool_result_image(self):
+        body = {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": "tool-1",
+                            "content": [
+                                {"type": "text", "text": "Screenshot captured"},
+                                {
+                                    "type": "image",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": "image/png",
+                                        "data": _ONE_BY_ONE_PNG_B64,
+                                    },
+                                },
+                            ],
+                        }
+                    ],
+                }
+            ],
+            "system": "You are helpful.",
+        }
+        serialized = json.dumps(body, default=str)
+        estimate = self.fmt.estimate_payload_tokens_from_serialized(body, serialized)
+
+        media_tokens = sum(self.fmt._estimate_media_tokens(m) for m in self.fmt._collect_media(body))
+        expected = (
+            math.ceil(self.fmt._count("You are helpful.") * self.fmt._SYSTEM_SCALE)
+            + self.fmt._TOOL_CALL_ID_TOKENS
+            + math.ceil(self.fmt._count("Screenshot captured") * self.fmt._TOOL_RESULT_TEXT_SCALE)
+            + media_tokens
+        )
+        assert estimate == expected
+
+    def test_estimate_message_tokens_counts_tool_use_semantics_not_wrapper_json(self):
+        fmt = AnthropicFormat()
+        fmt.set_token_counter(lambda text: len(text) if text else 0)
+        msg = {
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "tool_use",
+                    "id": "toolu_123",
+                    "name": "probe_tool",
+                    "input": {"path": "/tmp/demo.txt", "limit": 5},
+                }
+            ],
+        }
+        expected = (
+            fmt._TOOL_CALL_ID_TOKENS
+            + math.ceil(len("probe_tool") * fmt._TOOL_NAME_SCALE)
+            + math.ceil(
+                len(json.dumps({"path": "/tmp/demo.txt", "limit": 5}, sort_keys=True))
+                * fmt._TOOL_USE_INPUT_SCALE
+            )
+        )
+        assert fmt.estimate_message_tokens(msg) == expected
+
+    def test_estimate_message_tokens_tool_id_length_does_not_change_estimate(self):
+        fmt = AnthropicFormat()
+        fmt.set_token_counter(lambda text: len(text) if text else 0)
+        short = {
+            "role": "assistant",
+            "content": [{"type": "tool_use", "id": "t1", "name": "probe_tool", "input": {"path": "/tmp/demo.txt"}}],
+        }
+        long = {
+            "role": "assistant",
+            "content": [{"type": "tool_use", "id": "toolu_0123456789abcdef", "name": "probe_tool", "input": {"path": "/tmp/demo.txt"}}],
+        }
+        assert fmt.estimate_message_tokens(short) == fmt.estimate_message_tokens(long)
+
+    def test_estimate_tools_tokens_scales_anthropic_tools(self):
+        fmt = AnthropicFormat()
+        fmt.set_token_counter(lambda text: len(text) if text else 0)
+        body = {"tools": [{"name": "probe_tool", "description": "Expand topic", "input_schema": {"type": "object"}}]}
+        raw = len(json.dumps(body["tools"]))
+        assert fmt.estimate_tools_tokens(body) == math.ceil(raw * fmt._TOOLS_SCALE)
+
     def test_extract_conversation_id(self):
         body = {"messages": [
             {"role": "user", "content": "hi"},
@@ -461,6 +586,34 @@ class TestGeminiFormat:
         body = {"contents": [{"role": "user", "parts": [{"text": "hi"}]}]}
         assert len(self.fmt.get_messages(body)) == 1
 
+    def test_estimate_message_tokens_recurse_nested_inline_data(self):
+        msg = {
+            "role": "user",
+            "parts": [
+                {
+                    "functionResponse": {
+                        "name": "chrome",
+                        "response": {
+                            "content": [
+                                {"text": "screenshot"},
+                                {
+                                    "inline_data": {
+                                        "mime_type": "image/png",
+                                        "data": _ONE_BY_ONE_PNG_B64,
+                                    }
+                                },
+                            ]
+                        },
+                    }
+                }
+            ],
+        }
+        estimate = self.fmt.estimate_message_tokens(msg)
+        blanked = copy.deepcopy(msg)
+        blanked["parts"][0]["functionResponse"]["response"]["content"][1]["inline_data"]["data"] = ""
+        expected = self.fmt._count(json.dumps(blanked, default=str)) + 1
+        assert estimate == expected
+
     def test_inject_context(self):
         body = {"contents": [
             {"role": "user", "parts": [{"text": "hi"}]},

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_request_captures_persistence.py

@@ -175,6 +175,40 @@ class TestRequestCapturesPersistence:
         assert [c["model"] for c in store.load_request_captures(conversation_id="c1")] == ["model-a"]
         assert [c["model"] for c in store.load_request_captures(conversation_id="c2")] == ["model-b"]
 
+    def test_same_turns_are_isolated_by_turn_id(self, tmp_path):
+        store = SQLiteStore(tmp_path / "test.db")
+        for turn_id, model in (("req-a", "model-a"), ("req-b", "model-b")):
+            store.save_request_capture({
+                "turn": 7,
+                "turn_id": turn_id,
+                "ts": "2026-03-20T10:00:00+00:00",
+                "api_format": "anthropic",
+                "model": model,
+                "stream": False,
+                "message_count": 1,
+                "conversation_id": "c1",
+                "inbound_tags": [],
+                "response_tags": [],
+                "passthrough": False,
+                "inbound_tokens": 0,
+                "outbound_tokens": 0,
+                "inbound_bytes": 0,
+                "outbound_bytes": 0,
+                "context_tokens": 0,
+                "overhead_ms": 0,
+                "turns_dropped": 0,
+                "turns_stubbed": 0,
+                "message_preview": "",
+                "upstream_input_tokens": 0,
+                "upstream_output_tokens": 0,
+                "cache_creation_input_tokens": 0,
+                "cache_read_input_tokens": 0,
+            })
+
+        loaded = store.load_request_captures(conversation_id="c1")
+        assert len(loaded) == 2
+        assert sorted(c["turn_id"] for c in loaded) == ["req-a", "req-b"]
+
     def test_prune_turn_messages_keeps_suffix(self, tmp_path):
         store = SQLiteStore(tmp_path / "test.db")
         for turn in range(6):
@@ -288,6 +322,46 @@ class TestProxyMetricsStoreIntegration:
         assert loaded[0]["upstream_input_tokens"] == 100
         assert loaded[0]["upstream_output_tokens"] == 50
 
+    def test_capture_response_uses_turn_id_when_turn_collides(self, tmp_path):
+        from virtual_context.proxy.metrics import ProxyMetrics
+
+        store = self._make_store(tmp_path)
+        m = ProxyMetrics(store=store)
+        m.capture_request(
+            turn=1,
+            body={"model": "test-a", "messages": []},
+            api_format="anthropic",
+            conversation_id="c1",
+            turn_id="req-a",
+        )
+        m.capture_request(
+            turn=1,
+            body={"model": "test-b", "messages": []},
+            api_format="anthropic",
+            conversation_id="c1",
+            turn_id="req-b",
+        )
+        m.capture_response(
+            turn=1,
+            body={"content": "hello-a"},
+            upstream_input_tokens=100,
+            conversation_id="c1",
+            turn_id="req-a",
+        )
+        m.capture_response(
+            turn=1,
+            body={"content": "hello-b"},
+            upstream_input_tokens=200,
+            conversation_id="c1",
+            turn_id="req-b",
+        )
+
+        loaded = sorted(
+            store.load_request_captures(conversation_id="c1"),
+            key=lambda capture: capture["turn_id"],
+        )
+        assert [capture["upstream_input_tokens"] for capture in loaded] == [100, 200]
+
     def test_update_tags_persists(self, tmp_path):
         from virtual_context.proxy.metrics import ProxyMetrics
         store = self._make_store(tmp_path)

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_retriever.py

@@ -498,6 +498,7 @@ class TestSummaryFloor:
             tag="authentication",
             summary="JWT setup with RS256 signing and 1-hour expiry. Refresh token rotation.",
             summary_tokens=25,
+            code_refs=[{"file": "auth/jwt.py", "line": 88, "symbol": "issue_token"}],
             source_turn_numbers=[0, 1],
             created_at=now,
             updated_at=now,
@@ -531,6 +532,12 @@ class TestSummaryFloor:
         assert len(result.summaries) == 2
         assert result.total_tokens > 0
         assert result.retrieval_metadata.get("summary_floor") is True
+        assert any(
+            summary.metadata.code_refs == [
+                {"file": "auth/jwt.py", "line": 88, "symbol": "issue_token"}
+            ]
+            for summary in result.summaries
+        )
         store.close()
 
     def test_floor_inactive_pre_compaction(self, tmp_sqlite_db):

{virtual_context-0.3.4 → virtual_context-0.3.6}/tests/test_tag_generator.py

@@ -3,6 +3,7 @@
 import pytest
 
 from virtual_context.core.tag_generator import (
+    CODE_TAG_GENERATOR_PROMPTS,
     KeywordTagGenerator,
     LLMTagGenerator,
     build_tag_generator,
@@ -122,6 +123,64 @@ class TestLLMTagGenerator:
         assert generator._tag_vocabulary["auth"] == 10
         assert generator._tag_vocabulary["database"] == 5
 
+    def test_code_refs_parsed_and_normalized(self):
+        provider = MockLLMProvider(
+            response=(
+                '{"tags": ["backend"], "primary": "backend", '
+                '"code_refs": ['
+                '{"file": " server.py ", "line": "42", "symbol": "handle_request"}, '
+                '{"path": "server.py", "line": 42, "name": "handle_request"}, '
+                '{"file": "retriever.py", "class": "ContextRetriever"}'
+                ']}'
+            )
+        )
+        config = TagGeneratorConfig(type="llm", max_tags=5, min_tags=1)
+        generator = LLMTagGenerator(llm_provider=provider, config=config, code_mode=True)
+
+        result = generator.generate_tags("Patch the request path")
+
+        assert result.code_refs == [
+            {"file": "server.py", "line": 42, "symbol": "handle_request"},
+            {"file": "retriever.py", "symbol": "ContextRetriever"},
+        ]
+
+    @pytest.mark.parametrize("prompt_mode", ["detailed", "compact", "small_model"])
+    def test_code_mode_uses_dedicated_tagger_prompt_family(self, prompt_mode):
+        from virtual_context.core.compactor import CODE_FACT_EXTRACTION_PROMPT
+
+        provider = MockLLMProvider(
+            response='{"tags": ["backend"], "primary": "backend", "fact_signals": [], "code_refs": []}'
+        )
+        config = TagGeneratorConfig(type="llm", max_tags=5, min_tags=1, prompt_mode=prompt_mode)
+        generator = LLMTagGenerator(llm_provider=provider, config=config, code_mode=True)
+
+        generator.generate_tags("We fixed the cache boundary in server.py.")
+
+        system = provider.calls[0]["system"]
+        assert system == CODE_TAG_GENERATOR_PROMPTS[prompt_mode].format(min_tags=1, max_tags=5)
+        assert "fact_signals" in system
+        assert "code_refs" in system
+        assert CODE_FACT_EXTRACTION_PROMPT.strip() not in system
+
+    def test_fact_signals_parsed_from_code_mode_response(self):
+        provider = MockLLMProvider(
+            response=(
+                '{"tags": ["backend"], "primary": "backend", '
+                '"fact_signals": ['
+                '{"subject": "cache boundary", "verb": "changed", "object": "moved above vc reminder injection", '
+                '"status": "completed", "fact_type": "world", "what": "Cache boundary changed to sit above the VC reminder injection."}'
+                '], "code_refs": []}'
+            )
+        )
+        config = TagGeneratorConfig(type="llm", max_tags=5, min_tags=1)
+        generator = LLMTagGenerator(llm_provider=provider, config=config, code_mode=True)
+
+        result = generator.generate_tags("Patch the cache boundary.")
+
+        assert len(result.fact_signals) == 1
+        assert result.fact_signals[0].subject == "cache boundary"
+        assert result.fact_signals[0].verb == "changed"
+
     def test_select_relevant_store_tags_reuses_cached_embeddings(self):
         provider = MockLLMProvider(response='{"tags": ["database"], "primary": "database"}')
         cache_loads: list[list[str]] = []