virtual-context 0.2.2__tar.gz → 0.2.4__tar.gz

{virtual_context-0.2.2 → virtual_context-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.2.2
+Version: 0.2.4
 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.2.2 → virtual_context-0.2.4}/pyproject.toml

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

{virtual_context-0.2.2 → virtual_context-0.2.4}/tests/test_conversation_lifecycle.py

@@ -29,3 +29,25 @@ def test_conversation_store_view_blocks_stale_writes_after_delete(tmp_path):
     view1 = ConversationStoreView(store, conversation_id, generation1)
     view1.save_turn_message(conversation_id, 0, "fresh-u", "fresh-a")
     assert store.get_turn_messages(conversation_id, [0])[0][:2] == ("fresh-u", "fresh-a")
+
+
+def test_conversation_store_view_blocks_chain_and_tool_link_writes_after_delete(tmp_path):
+    store = SQLiteStore(tmp_path / "vc.db")
+    conversation_id = "conv-delete"
+
+    generation0 = store.activate_conversation(conversation_id)
+    view0 = ConversationStoreView(store, conversation_id, generation0)
+    store.begin_conversation_deletion(conversation_id)
+
+    with pytest.raises(StaleConversationWriteError):
+        view0.store_chain_snapshot("chain-1", conversation_id, 0, "{}", 0)
+
+    with pytest.raises(StaleConversationWriteError):
+        view0.link_turn_tool_output(conversation_id, 0, "tool-turn-1")
+
+    with pytest.raises(StaleConversationWriteError):
+        view0.link_segment_tool_output(conversation_id, "seg-1", "tool-seg-1")
+
+    assert store.get_chain_snapshot(conversation_id, "chain-1") is None
+    assert store.get_tool_outputs_for_turn(conversation_id, 0) == []
+    assert store.get_tool_outputs_for_segment(conversation_id, "seg-1") == []

virtual_context-0.2.4/tests/test_registry_lifecycle.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from virtual_context.proxy.metrics import ProxyMetrics
+from virtual_context.proxy.registry import SessionRegistry
+
+
+def _dummy_state(conversation_id: str):
+    return SimpleNamespace(
+        engine=SimpleNamespace(
+            config=SimpleNamespace(conversation_id=conversation_id),
+        ),
+        shutdown=lambda *args, **kwargs: None,
+    )
+
+
+def test_remove_conversation_clears_all_routing_maps():
+    registry = SessionRegistry(
+        config_path=None,
+        upstream="",
+        metrics=ProxyMetrics(),
+    )
+    keep_state = _dummy_state("conv-keep")
+    delete_state = _dummy_state("conv-delete")
+
+    registry._conversations["conv-keep"] = keep_state
+    registry._conversations["conv-delete"] = delete_state
+    registry._sys_hashes = {"sys-keep": "conv-keep", "sys-delete": "conv-delete"}
+    registry._chat_ids = {"chat-keep": "conv-keep", "chat-delete": "conv-delete"}
+    registry._last_msg_hashes = {"msg-keep": "conv-keep", "msg-delete": "conv-delete"}
+
+    removed = registry.remove_conversation("conv-delete")
+
+    assert removed is delete_state
+    assert registry.get_state("conv-delete") is None
+    assert registry.get_state("conv-keep") is keep_state
+    assert "conv-delete" not in registry._conversations
+    assert "conv-delete" not in registry._sys_hashes.values()
+    assert "conv-delete" not in registry._chat_ids.values()
+    assert "conv-delete" not in registry._last_msg_hashes.values()

{virtual_context-0.2.2 → virtual_context-0.2.4}/tests/test_store_sqlite.py

@@ -177,6 +177,20 @@ class TestSQLiteStore:
         aliases = store.get_tag_aliases()
         assert aliases["db"] == "database"
 
+    def test_delete_conversation_removes_only_conversation_scoped_aliases(self, store):
+        store.set_tag_alias("global-db", "database")
+        store.set_tag_alias("db", "database", conversation_id="session-1")
+        store.set_tag_alias("sql", "database", conversation_id="session-2")
+
+        store.delete_conversation("session-1")
+
+        aliases_session_1 = store.get_tag_aliases("session-1")
+        aliases_session_2 = store.get_tag_aliases("session-2")
+        assert aliases_session_1["global-db"] == "database"
+        assert "db" not in aliases_session_1
+        assert aliases_session_2["global-db"] == "database"
+        assert aliases_session_2["sql"] == "database"
+
     def test_metadata_preserved(self, store):
         seg = _make_segment()
         seg.metadata = SegmentMetadata(

{virtual_context-0.2.2 → virtual_context-0.2.4}/tests/test_upstream_trim.py

@@ -61,14 +61,16 @@ class TestTrimToUpstreamLimit:
         assert "tools" in trimmed
         assert len(trimmed["tools"]) == 1
 
-    def test_accounts_for_max_tokens(self):
+    def test_max_tokens_not_subtracted_from_budget(self):
+        """max_tokens is NOT subtracted — upstream_limit is the input budget."""
         body = _make_body(50, system="Sys.")
         body["max_tokens"] = 50_000
         fmt = self._fmt()
         total_before = fmt.estimate_payload_tokens(body)
         trimmed, removed = trim_to_upstream_limit(body, 60_000, fmt)
-        if total_before > 10_000:
-            assert removed > 0
+        # With 60k budget and no max_tokens subtraction, small body fits
+        if total_before <= 60_000:
+            assert removed == 0
 
     def test_anthropic_format(self):
         body = {
@@ -116,7 +118,7 @@ class TestTrimToUpstreamLimit:
         fmt = copy.copy(OpenAIResponsesFormat())
         fmt.set_token_counter(lambda text: len(text) // 4)
 
-        trimmed, removed = trim_to_upstream_limit(body, 2500, fmt)
+        trimmed, removed = trim_to_upstream_limit(body, 1500, fmt)
 
         assert removed > 0
         rendered = str(trimmed["input"])

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/__init__.py

@@ -14,7 +14,7 @@ from .types import (
     VirtualContextConfig,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.2.4"
 
 __all__ = [
     "VirtualContextEngine",

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/compaction_pipeline.py

@@ -124,7 +124,10 @@ class CompactionPipeline:
         # Messages to compact: everything between watermark and protected zone.
         # Compact all available messages (not just the minimum) so compaction
         # fires infrequently — one big batch instead of many small ones.
-        offset = self._engine_state.history_offset(len(conversation_history))
+        _total_turns = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        offset = self._engine_state.history_offset(
+            len(conversation_history), total_turns_indexed=_total_turns,
+        )
         compact_messages = conversation_history[offset:-protected_count]
 
         if not compact_messages:
@@ -137,9 +140,9 @@ class CompactionPipeline:
             return None
 
         logger.info(
-            "Compacting %d messages (offset=%d, watermark=%d, history=%d, protected=%d turns)",
+            "Compacting %d messages (offset=%d, watermark=%d, history=%d, protected=%d turns, indexed=%s)",
             len(compact_messages), offset, self._engine_state.compacted_through,
-            len(conversation_history), protected_turns,
+            len(conversation_history), protected_turns, _total_turns,
         )
         report = self._run_compaction(conversation_history, compact_messages, progress_callback=progress_callback)
 
@@ -172,7 +175,10 @@ class CompactionPipeline:
             logger.info("Not enough messages outside protected zone to compact")
             return None
 
-        offset = self._engine_state.history_offset(len(conversation_history))
+        _total_turns = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        offset = self._engine_state.history_offset(
+            len(conversation_history), total_turns_indexed=_total_turns,
+        )
         compact_messages = conversation_history[offset:-protected_count]
 
         if not compact_messages:
@@ -524,6 +530,20 @@ class CompactionPipeline:
         max_seg_tokens = self._config.compactor.max_segment_tokens
         merge_threshold = self._config.compactor.merge_overlap_threshold
 
+        # ------------------------------------------------------------------
+        # Store-based skip: collect turn numbers already covered by stored
+        # tag summaries so we can skip segments that would re-compact the
+        # same turns (happens when compacted_through > history_len and
+        # history_offset() returns 0).
+        # ------------------------------------------------------------------
+        try:
+            _already_compacted_turns = self._store.get_compacted_turn_numbers(
+                self._config.conversation_id,
+            )
+        except Exception:
+            _already_compacted_turns = set()
+        _skipped_segments = 0
+
         # ==================================================================
         # Pass 1: Sequential pre-pass — stubs + merge check (no LLM calls)
         # ==================================================================
@@ -537,6 +557,19 @@ class CompactionPipeline:
         embed_fn = self._semantic.get_embed_fn() if self._semantic else None
 
         for seg in segments:
+            # --- Store-based skip: already-compacted turn range ---
+            if _already_compacted_turns:
+                seg_range = segment_turn_ranges.get(seg.id)
+                if seg_range:
+                    seg_turns = set(range(seg_range[0], seg_range[1]))
+                    if seg_turns and seg_turns <= _already_compacted_turns:
+                        _skipped_segments += 1
+                        logger.info(
+                            "SEGMENT SKIP (already compacted) ref=%s turns=%d-%d primary=%s",
+                            seg.id[:8], seg_range[0], seg_range[1] - 1, seg.primary_tag,
+                        )
+                        continue
+
             # --- Stub passthrough (no LLM) ---
             text = " ".join(m.content for m in seg.messages)
             if _is_stub_content_fn(text):
@@ -665,9 +698,11 @@ class CompactionPipeline:
                 )
             return all_results
 
-        logger.info("Pass 1 complete: %d stubs stored, %d segments ready for compaction (%d merges)",
+        if _skipped_segments:
+            logger.info("Store-based skip: %d segments skipped (turns already compacted)", _skipped_segments)
+        logger.info("Pass 1 complete: %d stubs stored, %d segments ready for compaction (%d merges, %d skipped)",
                     len(all_results), len(compactable),
-                    sum(1 for s in compactable if s.merge_ref))
+                    sum(1 for s in compactable if s.merge_ref), _skipped_segments)
 
         # ==================================================================
         # Pass 2: Batch LLM compaction + store

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/composite_store.py

@@ -89,11 +89,20 @@ class CompositeStore:
     def get_conversation_stats(self) -> list[ConversationStats]:
         return self._segments.get_conversation_stats()
 
-    def get_tag_aliases(self) -> dict[str, str]:
-        return self._segments.get_tag_aliases()
+    def get_tag_aliases(self, conversation_id: str | None = None) -> dict[str, str]:
+        return self._segments.get_tag_aliases(conversation_id=conversation_id)
 
-    def set_tag_alias(self, alias: str, canonical: str) -> None:
-        return self._segments.set_tag_alias(alias, canonical)
+    def set_tag_alias(
+        self,
+        alias: str,
+        canonical: str,
+        conversation_id: str = "",
+    ) -> None:
+        return self._segments.set_tag_alias(
+            alias,
+            canonical,
+            conversation_id=conversation_id,
+        )
 
     def delete_segment(self, ref: str) -> bool:
         return self._segments.delete_segment(ref)
@@ -152,6 +161,12 @@ class CompositeStore:
             )
         return deleted
 
+    def delete_tag_aliases_for_conversation(self, conversation_id: str) -> int:
+        delete_aliases = getattr(self._segments, "delete_tag_aliases_for_conversation", None)
+        if callable(delete_aliases):
+            return int(delete_aliases(conversation_id) or 0)
+        return 0
+
     def save_turn_message(
         self, conversation_id: str, turn_number: int,
         user_content: str, assistant_content: str,

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/conversation_store.py

@@ -14,6 +14,9 @@ class ConversationStoreView:
 
     _GUARDED_METHODS = {
         "delete_segment",
+        "delete_fact_links",
+        "link_segment_tool_output",
+        "link_turn_tool_output",
         "save_engine_state",
         "save_request_capture",
         "save_tag_summary",
@@ -25,6 +28,7 @@ class ConversationStoreView:
         "store_chunk_embeddings",
         "store_fact_links",
         "store_facts",
+        "store_chain_snapshot",
         "store_segment",
         "store_tag_summary_embedding",
         "store_tool_output",

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/hint_builder.py

@@ -59,7 +59,9 @@ def build_autonomous_hint(
         "To find detailed information you have the following tools:\n"
         "- vc_restore_tool(ref): ALL compacted tool turns can be restored to "
         "full fidelity — thinking, tool calls, and raw output. Use the ref "
-        "from the compacted stub. This is the fastest way to get exact data.\n"
+        "from the compacted stub. This is the fastest way to get exact data "
+        "like file paths, directory listings, code blocks, command output, "
+        "and search results. Summaries never contain these — restore first.\n"
         "- vc_find_quote(query): search raw text across ALL topics.\n"
         "- vc_query_facts(subject?, verb?, status?, object_contains?): "
         "structured fact lookup.\n"
@@ -73,7 +75,9 @@ def build_autonomous_hint(
         "For counting/listing questions: scan [all topics] for every topic "
         "that could relate — items are often spread across unrelated topics.\n"
         "If a search already returned the answer, stop and respond.\n"
-        "Never answer without searching first.\n"
+        "Virtual context tools allow you to search and restore full "
+        "conversational depth and previously compacted tool calls. "
+        "Use liberally to answer the user's question.\n"
         "FACT vs SUMMARY: The <facts> block contains structured events with "
         "statuses (completed, planned, active). Summaries describe topics "
         "DISCUSSED — they include plans, itineraries, and ideas that may "

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/protocols.py

@@ -35,8 +35,13 @@ class SegmentStore(Protocol):
     def search(self, query: str, tags: list[str] | None = None, limit: int = 5, conversation_id: str | None = None) -> list[StoredSummary]: ...
     def get_all_tags(self, conversation_id: str | None = None) -> list[TagStats]: ...
     def get_conversation_stats(self) -> list[ConversationStats]: ...
-    def get_tag_aliases(self) -> dict[str, str]: ...
-    def set_tag_alias(self, alias: str, canonical: str) -> None: ...
+    def get_tag_aliases(self, conversation_id: str | None = None) -> dict[str, str]: ...
+    def set_tag_alias(
+        self,
+        alias: str,
+        canonical: str,
+        conversation_id: str = "",
+    ) -> None: ...
     def delete_segment(self, ref: str) -> bool: ...
     def cleanup(self, max_age: timedelta | None = None, max_total_tokens: int | None = None) -> int: ...
     def save_tag_summary(self, tag_summary: TagSummary, conversation_id: str = "") -> None: ...
@@ -53,6 +58,7 @@ class SegmentStore(Protocol):
     def search_tag_summaries_fts(self, query: str, limit: int = 20, conversation_id: str | None = None) -> list[tuple[str, float]]: ...
     def store_tag_summary_embedding(self, tag: str, conversation_id: str, embedding: list[float]) -> None: ...
     def load_tag_summary_embeddings(self, conversation_id: str | None = None) -> dict[str, list[float]]: ...
+    def delete_tag_aliases_for_conversation(self, conversation_id: str) -> int: ...
 
 
 @runtime_checkable

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/retrieval_assembler.py

@@ -115,7 +115,10 @@ class RetrievalAssembler:
             active_tags = self._get_active_tags(conversation_history)
 
         # Compute current utilization (only count un-compacted history)
-        _offset = self._engine_state.history_offset(len(conversation_history))
+        _total_turns = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        _offset = self._engine_state.history_offset(
+            len(conversation_history), total_turns_indexed=_total_turns,
+        )
         snapshot = self._monitor.build_snapshot(
             conversation_history[_offset:]
         )
@@ -267,7 +270,8 @@ class RetrievalAssembler:
         ws_param, full_segments_param = self._load_working_set_segments()
 
         _hist = history or []
-        uncompacted = _hist[self._engine_state.history_offset(len(_hist)):]
+        _tti = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        uncompacted = _hist[self._engine_state.history_offset(len(_hist), total_turns_indexed=_tti):]
         assembled = self._assembler.assemble(
             core_context=core_context,
             retrieval_result=rr,
@@ -351,7 +355,8 @@ class RetrievalAssembler:
             return list(conversation_history)
 
         # Skip compacted messages -- their content is in stored summaries
-        offset = self._engine_state.history_offset(total)
+        _tti2 = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        offset = self._engine_state.history_offset(total, total_turns_indexed=_tti2)
         older = conversation_history[offset:-protected_count]
         recent = conversation_history[-protected_count:]
 

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/retriever.py

@@ -429,7 +429,10 @@ def _alias_ride_along(
     in X's alias group and retrieve segments that match those aliases but
     weren't already selected. These ride free — no max_results cap.
     """
-    aliases = store.get_tag_aliases()
+    try:
+        aliases = store.get_tag_aliases(conversation_id=conversation_id)
+    except TypeError:
+        aliases = store.get_tag_aliases()
     if not aliases:
         return []
 

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/store.py

@@ -59,10 +59,15 @@ class ContextStore(ABC):
         """Return aggregate statistics grouped by conversation_id, newest first."""
 
     @abstractmethod
-    def get_tag_aliases(self) -> dict[str, str]: ...
+    def get_tag_aliases(self, conversation_id: str | None = None) -> dict[str, str]: ...
 
     @abstractmethod
-    def set_tag_alias(self, alias: str, canonical: str) -> None: ...
+    def set_tag_alias(
+        self,
+        alias: str,
+        canonical: str,
+        conversation_id: str = "",
+    ) -> None: ...
 
     @abstractmethod
     def delete_segment(self, ref: str) -> bool: ...
@@ -132,6 +137,23 @@ class ContextStore(ABC):
         existing conversations when conversation markers are unavailable.
         """
 
+    # ------------------------------------------------------------------
+    # Compaction dedup: turn numbers already covered by stored segments
+    # ------------------------------------------------------------------
+
+    def get_compacted_turn_numbers(self, conversation_id: str) -> set[int]:
+        """Return the set of turn numbers already covered by stored tag summaries.
+
+        Used by the compaction pipeline to skip segments whose turns have
+        already been compacted, preventing redundant LLM calls when the
+        compaction watermark drifts ahead of the in-memory history window.
+        """
+        tag_summaries = self.get_all_tag_summaries(conversation_id=conversation_id)
+        covered: set[int] = set()
+        for ts in tag_summaries:
+            covered.update(ts.source_turn_numbers)
+        return covered
+
     # ------------------------------------------------------------------
     # Turn messages (lightweight per-turn text for post-restart recall)
     # ------------------------------------------------------------------
@@ -352,6 +374,13 @@ class ContextStore(ABC):
     def delete_conversation(self, conversation_id: str) -> int:
         return 0
 
+    def delete_tag_aliases_for_conversation(self, conversation_id: str) -> int:
+        """Delete aliases owned by ``conversation_id``.
+
+        Backends may keep legacy/global aliases under the empty conversation id.
+        """
+        return 0
+
     def store_tool_output(
         self,
         ref: str,

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/tag_canonicalizer.py

@@ -15,14 +15,37 @@ class TagCanonicalizer:
     Normalization (lowercase, hyphenate) is always applied even without aliases.
     """
 
-    def __init__(self, store=None) -> None:
+    def __init__(self, store=None, conversation_id: str = "") -> None:
         self._alias_cache: dict[str, str] = {}
         self._store = store
         self._known_tags: set[str] = set()
+        self._conversation_id = conversation_id
+
+    def _load_store_aliases(self) -> dict[str, str]:
+        if not self._store:
+            return {}
+        getter = getattr(self._store, "get_tag_aliases", None)
+        if not callable(getter):
+            return {}
+        try:
+            return getter(conversation_id=self._conversation_id)
+        except TypeError:
+            return getter()
+
+    def _store_alias(self, alias: str, canonical: str) -> None:
+        if not self._store:
+            return
+        setter = getattr(self._store, "set_tag_alias", None)
+        if not callable(setter):
+            return
+        try:
+            setter(alias, canonical, conversation_id=self._conversation_id)
+        except TypeError:
+            setter(alias, canonical)
 
     def load(self) -> None:
         if self._store:
-            self._alias_cache = self._store.get_tag_aliases()
+            self._alias_cache = self._load_store_aliases()
             # Seed known tags from canonical values
             self._known_tags.update(self._alias_cache.values())
 
@@ -65,8 +88,7 @@ class TagCanonicalizer:
     def register_alias(self, alias: str, canonical: str) -> None:
         normalized = alias.lower().strip().replace(" ", "-").replace("_", "-")
         self._alias_cache[normalized] = canonical
-        if self._store:
-            self._store.set_tag_alias(normalized, canonical)
+        self._store_alias(normalized, canonical)
 
     def get_aliases(self) -> dict[str, str]:
         return dict(self._alias_cache)

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/tag_consolidator.py

@@ -87,6 +87,32 @@ class ConsolidationResult:
 
 # ── core logic ──────────────────────────────────────────────────────────
 
+def _store_conversation_id(store: ContextStore) -> str:
+    conversation_id = getattr(store, "conversation_id", "")
+    return conversation_id if isinstance(conversation_id, str) else ""
+
+
+def _get_store_aliases(store: ContextStore) -> dict[str, str]:
+    getter = getattr(store, "get_tag_aliases", None)
+    if not callable(getter):
+        return {}
+    conversation_id = _store_conversation_id(store)
+    try:
+        return getter(conversation_id=conversation_id or None)
+    except TypeError:
+        return getter()
+
+
+def _set_store_alias(store: ContextStore, alias: str, canonical: str) -> None:
+    setter = getattr(store, "set_tag_alias", None)
+    if not callable(setter):
+        return
+    conversation_id = _store_conversation_id(store)
+    try:
+        setter(alias, canonical, conversation_id=conversation_id)
+    except TypeError:
+        setter(alias, canonical)
+
 def consolidate_tags(
     store: ContextStore,
     llm: LLMProvider,
@@ -171,11 +197,11 @@ def consolidate_tags(
         return result
 
     # Write aliases
-    existing_aliases = store.get_tag_aliases()
+    existing_aliases = _get_store_aliases(store)
     for group in all_groups:
         for alias in group.aliases:
             if alias not in existing_aliases:
-                store.set_tag_alias(alias, group.canonical)
+                _set_store_alias(store, alias, group.canonical)
                 result.aliases_written += 1
 
     logger.info("Wrote %d new aliases.", result.aliases_written)

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/core/tagging_pipeline.py

@@ -327,7 +327,10 @@ class TaggingPipeline:
             self._check_and_split_broad_tags(conversation_history)
 
         # Build snapshot (only count un-compacted messages)
-        _offset = self._engine_state.history_offset(len(conversation_history))
+        _total_turns = len(self._turn_tag_index.entries) if self._turn_tag_index else None
+        _offset = self._engine_state.history_offset(
+            len(conversation_history), total_turns_indexed=_total_turns,
+        )
         snapshot = self._monitor.build_snapshot(
             conversation_history[_offset:],
             payload_tokens=payload_tokens,

{virtual_context-0.2.2 → virtual_context-0.2.4}/virtual_context/engine.py

@@ -315,7 +315,10 @@ class VirtualContextEngine:
         self._temporal.reference_date = value
 
     def _init_canonicalizer(self) -> None:
-        self._canonicalizer = TagCanonicalizer(store=self._store)
+        self._canonicalizer = TagCanonicalizer(
+            store=self._store,
+            conversation_id=self.config.conversation_id,
+        )
         self._canonicalizer.load()
 
     def _init_tag_generator(self) -> None: