smartmemory-mcp 0.2.4__tar.gz

smartmemory_mcp-0.2.4/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: smartmemory-mcp
+Version: 0.2.4
+Summary: Unified SmartMemory MCP server — tiered tools, local + remote backends
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: httpx>=0.27
+Provides-Extra: keyring
+Requires-Dist: keyring>=24.0; extra == "keyring"

smartmemory_mcp-0.2.4/README.md

@@ -0,0 +1,34 @@
+# smart-memory-mcp
+
+Unified SmartMemory MCP (Model Context Protocol) server — tiered tools, local + remote backends.
+
+## Overview
+
+MCP server exposing SmartMemory operations to MCP-compatible clients (Claude Desktop, Cursor, etc.). Implements the full memory toolset (add, search, recall, decisions, plans, anchors, code-index) and routes to either a local SmartMemory instance or a remote `smart-memory-service` API endpoint.
+
+## Status
+
+**Version:** 0.2.1
+
+## Quick start
+
+```bash
+pip install -e .
+
+# Run the server
+smartmemory-mcp        # or python -m smartmemory_mcp
+```
+
+Tests:
+
+```bash
+pytest tests/ -v
+```
+
+## Documentation
+
+Full SmartMemory documentation: https://docs.smartmemory.ai
+
+## Part of SmartMemory
+
+This is one component of the SmartMemory ecosystem. See the [main repo](https://github.com/smart-memory/smart-memory) for the broader project.

smartmemory_mcp-0.2.4/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smartmemory-mcp"
+version = "0.2.4"
+description = "Unified SmartMemory MCP server — tiered tools, local + remote backends"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = [
+    "fastmcp>=2.0",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+keyring = ["keyring>=24.0"]
+
+[project.scripts]
+smartmemory-mcp = "smartmemory_mcp.server:main"

smartmemory_mcp-0.2.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smartmemory_mcp-0.2.4/smartmemory_mcp/backends/dispatch.py

@@ -0,0 +1,86 @@
+"""Backend dispatch — resolve local or remote backend based on config.
+
+Local-first: if smartmemory package is installed and mode != "remote", use LocalBackend.
+Remote: if mode == "remote" or only env vars available, use RemoteBackend.
+Result cached in module-level _backend after first resolution.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from smartmemory_mcp.backends.interface import MemoryBackend
+
+log = logging.getLogger(__name__)
+
+_backend: "MemoryBackend | None" = None
+
+
+def resolve_backend() -> "MemoryBackend":
+    """Return the active backend, creating it on first call.
+
+    Resolution order:
+    1. Try importing smartmemory_app.config.load_config — if available, read mode.
+       - mode == "remote" -> RemoteBackend with config values
+       - mode == "local" or mode is set -> LocalBackend
+    2. If smartmemory not installed, check SMARTMEMORY_API_KEY env var -> RemoteBackend.
+    3. No backend resolvable -> raise RuntimeError.
+    """
+    global _backend
+    if _backend is not None:
+        return _backend
+
+    # Path 1: smartmemory package installed — use its config system
+    try:
+        from smartmemory_app.config import load_config
+
+        cfg = load_config()
+        if cfg.mode == "remote":
+            log.info("Backend dispatch: remote mode (from config)")
+            from smartmemory_mcp.backends.remote import RemoteBackend
+            from smartmemory_mcp.tier import get_api_key
+
+            _backend = RemoteBackend(
+                api_url=cfg.api_url,
+                api_key=get_api_key(),  # Reads env var → keyring → file
+                team_id=cfg.team_id,
+            )
+            return _backend
+
+        # Local mode (mode == "local" or mode is set to anything else, or None with package available)
+        log.info("Backend dispatch: local mode (smartmemory installed)")
+        from smartmemory_mcp.backends.local import LocalBackend
+
+        _backend = LocalBackend()
+        return _backend
+
+    except ImportError:
+        pass  # smartmemory package not installed — fall through to env var path
+
+    # Path 2: No smartmemory package — check for stored/env API key
+    from smartmemory_mcp.tier import get_api_key
+
+    api_key = get_api_key()
+    if api_key:
+        log.info("Backend dispatch: remote mode (from stored API key)")
+        from smartmemory_mcp.backends.remote import RemoteBackend
+
+        _backend = RemoteBackend(api_key=api_key)
+        return _backend
+
+    # Path 3: No backend resolvable
+    raise RuntimeError(
+        "No SmartMemory backend available.\n"
+        "Either:\n"
+        "  1. Install the full package: pip install smartmemory\n"
+        "  2. Set SMARTMEMORY_API_KEY env var for remote mode\n"
+        "  3. Run: smartmemory setup"
+    )
+
+
+def reset_backend() -> None:
+    """Clear the cached backend. Used by tests to force re-resolution."""
+    global _backend
+    _backend = None

smartmemory_mcp-0.2.4/smartmemory_mcp/backends/interface.py

@@ -0,0 +1,170 @@
+"""MemoryBackend protocol — structural interface for local and remote backends."""
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+from .models import MemoryResult
+
+
+@runtime_checkable
+class MemoryBackend(Protocol):
+    """Duck-typed interface that all backend implementations must satisfy.
+
+    Tools call these methods without knowing whether the backend is local (in-process
+    SmartMemory) or remote (REST API via httpx). Methods use **kwargs liberally so
+    backends can accept extra parameters without protocol changes.
+    """
+
+    # --- Core CRUD ---------------------------------------------------------------
+
+    def add(self, content: str, memory_type: str = "semantic", **kwargs: Any) -> dict[str, Any]:
+        """Store a memory item."""
+        ...
+
+    def get(self, item_id: str, **kwargs: Any) -> MemoryResult | None:
+        """Get a single memory by ID."""
+        ...
+
+    def update(self, item_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Update a memory item."""
+        ...
+
+    def delete(self, item_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Delete a memory item."""
+        ...
+
+    # --- Search & Recall ---------------------------------------------------------
+
+    def search(self, query: str, top_k: int = 5, **kwargs: Any) -> list[MemoryResult]:
+        """Semantic similarity search."""
+        ...
+
+    def search_by_metadata(self, metadata_key: str, metadata_value: str, top_k: int = 10, **kwargs: Any) -> list[MemoryResult]:
+        """Search by metadata key-value match."""
+        ...
+
+    def recall(self, cwd: str | None = None, top_k: int = 10, **kwargs: Any) -> str:
+        """Recall recent and relevant memories, formatted as markdown."""
+        ...
+
+    # --- Pipeline ----------------------------------------------------------------
+
+    def ingest(self, content: str, memory_type: str = "semantic", **kwargs: Any) -> dict[str, Any] | str:
+        """Ingest content through the full extraction pipeline."""
+        ...
+
+    def ingest_structured(self, data: dict[str, Any], schema: str | None = None, **kwargs: Any) -> str:
+        """Ingest structured data with an optional schema."""
+        ...
+
+    def ingest_conversation_sync(
+        self,
+        turns: list,
+        session_boundaries: list | None = None,
+        conversation_id: str | None = None,
+        session_dates: list | None = None,
+        turns_per_chunk: int = 15,
+        max_chunk_chars: int = 12000,
+        max_concurrent: int = 4,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Ingest a conversation as session chunks (RLM-1g)."""
+        ...
+
+    # --- Collection operations ---------------------------------------------------
+
+    def list_memories(self, **kwargs: Any) -> list[MemoryResult]:
+        """List all memory items."""
+        ...
+
+    def clear_user_memories(self, **kwargs: Any) -> dict[str, Any]:
+        """Delete all memories for the current user."""
+        ...
+
+    def get_all_items_debug(self, **kwargs: Any) -> list[dict[str, Any]]:
+        """Return all items including internal nodes (debug only)."""
+        ...
+
+    def stats(self, **kwargs: Any) -> dict[str, Any]:
+        """Return memory statistics (total, by type, health score)."""
+        ...
+
+    # --- Evolution & clustering --------------------------------------------------
+
+    def run_evolution_cycle(self, **kwargs: Any) -> dict[str, Any]:
+        """Run a full evolution cycle across all evolvers."""
+        ...
+
+    # CORE-MEMORY-DYNAMICS-1 M1b: commit_working_to_episodic / commit_working_to_procedural
+    # removed from the protocol. The core façades are gone — the ConsolidationRouter
+    # now routes pending items at ingest. Backends that previously implemented these
+    # methods should drop them; callers should use add()/ingest() with
+    # memory_type="pending".
+
+    def run_evolver(self, evolver_name: str, **kwargs: Any) -> dict[str, Any]:
+        """Run a specific evolver by name."""
+        ...
+
+    def run_clustering(self, **kwargs: Any) -> dict[str, Any]:
+        """Run clustering analysis on stored memories."""
+        ...
+
+    # --- Insight & reflection ----------------------------------------------------
+
+    def reflect(self, **kwargs: Any) -> dict[str, Any]:
+        """Generate reflections from stored memories."""
+        ...
+
+    def summary(self, **kwargs: Any) -> dict[str, Any]:
+        """Generate a summary of stored memories."""
+        ...
+
+    def orphaned_notes(self, **kwargs: Any) -> list[MemoryResult]:
+        """Find notes without links to other memories."""
+        ...
+
+    def find_old_notes(self, **kwargs: Any) -> list[MemoryResult]:
+        """Find notes that haven't been accessed recently."""
+        ...
+
+    # --- Personalization ---------------------------------------------------------
+
+    def personalize(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Personalize a response using stored memory context."""
+        ...
+
+    def update_from_feedback(self, item_id: str, feedback: str, **kwargs: Any) -> dict[str, Any]:
+        """Update a memory item based on user feedback."""
+        ...
+
+    # --- Grounding & linking -----------------------------------------------------
+
+    def ground(self, item_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Ground a memory item with external references."""
+        ...
+
+    def link(self, source_id: str, target_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Create a link between two memory items."""
+        ...
+
+    def add_edge(self, source_id: str, target_id: str, relation: str, **kwargs: Any) -> dict[str, Any]:
+        """Add a typed edge between two items in the knowledge graph."""
+        ...
+
+    def get_links(self, item_id: str, **kwargs: Any) -> list[MemoryResult]:
+        """Get all links for a memory item."""
+        ...
+
+    def get_neighbors(self, item_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Get neighboring nodes in the knowledge graph."""
+        ...
+
+    def find_shortest_path(self, source_id: str, target_id: str, **kwargs: Any) -> dict[str, Any]:
+        """Find the shortest path between two nodes in the graph."""
+        ...
+
+    # --- Retrieval feedback (SELF-IMPROVE-6) -------------------------------------
+
+    def submit_feedback(self, search_session_id: str, result_used: list[str], **kwargs: Any) -> dict[str, Any]:
+        """Submit result-selection feedback for a completed search session."""
+        ...

smartmemory_mcp-0.2.4/smartmemory_mcp/backends/local.py

@@ -0,0 +1,327 @@
+"""Local backend — delegates to smartmemory_app.storage (optional dependency)."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .models import MemoryResult, normalize_item, normalize_items
+
+log = logging.getLogger(__name__)
+
+
+class LocalBackend:
+    """Wraps smartmemory package for local-mode operations."""
+
+    def __init__(self) -> None:
+        try:
+            from smartmemory_app.storage import get_memory
+            self._get_memory = get_memory
+            self._mem = get_memory()
+        except ImportError:
+            raise RuntimeError(
+                "Local backend requires the smartmemory package.\n"
+                "Install with: pip install smartmemory"
+            )
+
+    # -- Core CRUD --
+
+    def add(self, content: str, memory_type: str = "semantic", metadata: dict | None = None, **kwargs: Any) -> str:
+        """Store a memory item."""
+        from smartmemory.models.memory_item import MemoryItem
+        # DIST-LITE-QUIET-1: attribute the write so it lands as tier-2 user content, not
+        # origin='unknown' (tier 4, hidden from recall+search). An explicit origin in
+        # metadata (e.g. an importer) wins; default to this producer.
+        meta = dict(metadata or {})
+        origin = meta.pop("origin", None) or kwargs.pop("origin", None) or "mcp:memory_add"
+        item = MemoryItem(content=content, memory_type=memory_type, metadata=meta, origin=origin)
+        return self._mem.add(item)
+
+    def get(self, item_id: str, **kwargs: Any) -> MemoryResult | None:
+        """Retrieve a memory by ID."""
+        result = self._mem.get(item_id)
+        if result is None:
+            return None
+        return normalize_item(result)
+
+    def update(
+        self,
+        item_id: str,
+        content: str | None = None,
+        metadata: dict | None = None,
+        properties: dict | None = None,
+        write_mode: str | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Update an existing memory via the canonical update_properties path.
+
+        See CORE-CRUD-UPDATE-1 contract: `properties` takes precedence over the
+        content/metadata conveniences; `write_mode` is "merge" (default) or
+        "replace".
+        """
+        item = self._mem.get(item_id)
+        if item is None:
+            return f"Not found: {item_id}"
+
+        if properties is not None:
+            props = dict(properties)
+        else:
+            props = {}
+            if content is not None:
+                props["content"] = content
+            if metadata is not None:
+                existing_meta = {}
+                if hasattr(item, "metadata") and isinstance(item.metadata, dict):
+                    existing_meta = item.metadata
+                elif isinstance(item, dict):
+                    existing_meta = item.get("metadata") or {}
+                props["metadata"] = {**existing_meta, **metadata}
+
+        if not props:
+            return "At least one of 'content', 'metadata', or 'properties' must be provided"
+
+        self._mem.update_properties(item_id, props, write_mode=write_mode)
+        return f"Updated: {item_id}"
+
+    def delete(self, item_id: str, **kwargs: Any) -> bool:
+        """Delete a memory by ID."""
+        return self._mem.delete(item_id)
+
+    # -- Search --
+
+    def search(self, query: str, top_k: int = 5, **kwargs: Any) -> list[MemoryResult]:
+        """Semantic search."""
+        from smartmemory_app.storage import search
+        results = normalize_items(search(query, top_k, **kwargs))
+        # SELF-IMPROVE-6: track shown IDs for local-mode feedback
+        self._last_search_session_id = f"local:{id(results)}:{top_k}"
+        self._last_shown_ids = [r.get("item_id", "") for r in results if r.get("item_id")]
+        return results
+
+    def search_by_metadata(self, metadata_key: str, metadata_value: str, top_k: int = 10, **kwargs: Any) -> list[MemoryResult]:
+        """Search by metadata field."""
+        return normalize_items(self._mem.search_by_metadata(metadata_key, metadata_value, top_k=top_k))
+
+    def blame_code(self, **kwargs: Any) -> dict[str, Any]:
+        """Code-provenance blame passthrough (CORE-CODE-PROVENANCE-1 Phase 2b).
+
+        Delegates to the in-process lite SmartMemory, which reads the same local
+        store the capture hook wrote to. Returns the forge-shaped BlameResult dict;
+        raises ValueError on a git error (the tool maps it to a graceful string).
+        """
+        return self._mem.blame_code(**kwargs)
+
+    def read_transcript_centered(self, **kwargs: Any) -> dict[str, Any]:
+        """Centered transcript-reader passthrough (CORE-CODE-PROVENANCE-1 Phase 2c).
+
+        The read half of the blame->read chain. Delegates to the in-process lite
+        SmartMemory, which reads the raw transcript JSONL on the local filesystem.
+        Local-only — the hosted REST surface is parked.
+        """
+        return self._mem.read_transcript_centered(**kwargs)
+
+    # -- Ingest & Recall --
+
+    def ingest(self, content: str, memory_type: str = "episodic", **kwargs: Any) -> str:
+        """Full pipeline ingestion."""
+        from smartmemory_app.storage import ingest
+        # storage.ingest() uses 'properties' not 'metadata'
+        if "metadata" in kwargs:
+            kwargs["properties"] = kwargs.pop("metadata")
+        # DIST-LITE-QUIET-1: attribute the write (the /remember skill + MCP memory_ingest
+        # surface) so it lands as tier-2 user content, not origin='unknown'. A caller-
+        # supplied origin is preserved.
+        kwargs.setdefault("origin", "mcp:memory_ingest")
+        return ingest(content, memory_type, **kwargs)
+
+    def recall(self, cwd: str | None = None, top_k: int = 10, **kwargs: Any) -> str:
+        """Context-aware recall."""
+        from smartmemory_app.storage import recall
+        return recall(cwd, top_k)
+
+    def ingest_structured(self, data: dict, schema: str | None = None, schema_name: str | None = None, **kwargs: Any) -> str:
+        """Structured data ingestion."""
+        name = schema or schema_name
+        return self._mem.ingest_structured(data, schema=name)
+
+    def ingest_conversation_sync(
+        self,
+        turns: list,
+        session_boundaries: list | None = None,
+        conversation_id: str | None = None,
+        session_dates: list | None = None,
+        turns_per_chunk: int = 15,
+        max_chunk_chars: int = 12000,
+        max_concurrent: int = 4,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Conversation bulk ingestion via local SmartMemory (RLM-1g)."""
+        from dataclasses import asdict
+
+        response = self._mem.ingest_conversation_sync(
+            turns,
+            session_boundaries=session_boundaries,
+            conversation_id=conversation_id,
+            session_dates=session_dates,
+            turns_per_chunk=turns_per_chunk,
+            max_chunk_chars=max_chunk_chars,
+            max_concurrent=max_concurrent,
+        )
+        return asdict(response) if hasattr(response, "__dataclass_fields__") else response
+
+    def read_around(
+        self,
+        item_id: str,
+        char_budget: int = 20000,
+        before_ratio: float = 0.3,
+        after_ratio: float = 0.7,
+        cursor: dict | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Auto-centered conversation read via local SmartMemory (CORE-RECALL-CENTERED-1 P2).
+
+        Returns a char-budgeted asymmetric window of the conversation chunks
+        surrounding ``item_id``. Hard-truncates (raise_on_overflow=False) rather
+        than raising, so the MCP tool always returns a window.
+        """
+        return self._mem.read_around(
+            item_id,
+            char_budget=char_budget,
+            before_ratio=before_ratio,
+            after_ratio=after_ratio,
+            cursor=cursor,
+            raise_on_overflow=False,
+        )
+
+    # -- Listing & Stats --
+
+    def list_memories(self, limit: int = 100, offset: int = 0, **kwargs: Any) -> list[MemoryResult]:
+        """List memories with pagination."""
+        return normalize_items(self._mem.list_memories(limit=limit, offset=offset))
+
+    def clear_user_memories(self, confirm: bool = False, **kwargs: Any) -> str:
+        """Clear all user memories."""
+        if not confirm:
+            return "Pass confirm=True to clear all memories."
+        self._mem.clear_user_memories()
+        return "All memories cleared."
+
+    def get_all_items_debug(self, **kwargs: Any) -> dict:
+        """Get debug stats."""
+        return self._mem.get_all_items_debug()
+
+    def stats(self, **kwargs: Any) -> dict:
+        """Memory statistics."""
+        return self.get_all_items_debug(**kwargs)
+
+    # -- Evolution --
+
+    def run_evolution_cycle(self, **kwargs: Any) -> dict:
+        """Trigger evolution cycle."""
+        return self._mem.run_evolution_cycle(**kwargs)
+
+    # CORE-MEMORY-DYNAMICS-1 M1b: commit_working_to_* removed — core façades
+    # are gone, ConsolidationRouter routes at ingest. Use add()/ingest() with
+    # memory_type="pending" instead.
+
+    def run_evolver(self, evolver_class: Any, **kwargs: Any) -> dict:
+        """Run a specific evolver."""
+        return self._mem.run_evolver(evolver_class, **kwargs)
+
+    def run_clustering(self, **kwargs: Any) -> dict:
+        """Run clustering."""
+        return self._mem.run_clustering(**kwargs)
+
+    # -- Insight --
+
+    def reflect(self, **kwargs: Any) -> str:
+        """Reflective analysis."""
+        return self._mem.reflect(**kwargs)
+
+    def summary(self, **kwargs: Any) -> dict:
+        """Memory summary."""
+        return self._mem.summary(**kwargs)
+
+    def orphaned_notes(self, **kwargs: Any) -> list[MemoryResult]:
+        """Find orphaned notes."""
+        return normalize_items(self._mem.orphaned_notes(**kwargs))
+
+    def find_old_notes(self, days: int = 90, **kwargs: Any) -> list[MemoryResult]:
+        """Find notes older than the given number of days."""
+        return normalize_items(self._mem.find_old_notes(days, **kwargs))
+
+    def personalize(self, user_id: str = "mcp-user", traits: dict | None = None, preferences: dict | None = None, **kwargs: Any) -> str:
+        """Personalize memory system."""
+        return self._mem.personalize(user_id=user_id, traits=traits or {}, preferences=preferences or {}, **kwargs)
+
+    def update_from_feedback(self, feedback: dict | None = None, memory_type: str = "semantic", **kwargs: Any) -> str:
+        """Update from user feedback."""
+        return self._mem.update_from_feedback(feedback=feedback or {}, memory_type=memory_type, **kwargs)
+
+    def ground(self, item_id: str, **kwargs: Any) -> dict:
+        """Ground a memory item."""
+        return self._mem.ground(item_id=item_id, **kwargs)
+
+    # -- Graph --
+
+    def link(self, source_id: str, target_id: str, link_type: str = "RELATES_TO", **kwargs: Any) -> str:
+        """Link two memories."""
+        return self._mem.link(source_id, target_id, link_type=link_type)
+
+    def add_edge(self, source_id: str, target_id: str, relation_type: str, **kwargs: Any) -> str:
+        """Add a graph edge."""
+        return self._mem.add_edge(source_id, target_id, relation_type=relation_type, **kwargs)
+
+    def get_links(self, item_id: str, **kwargs: Any) -> list[MemoryResult]:
+        """Get links for an item."""
+        return normalize_items(self._mem.get_links(item_id))
+
+    def get_neighbors(self, item_id: str, **kwargs: Any) -> dict:
+        """Get graph neighbors."""
+        return self._mem.get_neighbors(item_id)
+
+    def find_shortest_path(self, start_id: str, end_id: str, **kwargs: Any) -> list:
+        """Find shortest path between two items."""
+        return self._mem.find_shortest_path(start_id, end_id, **kwargs)
+
+    # -- Auth (no-ops for local) --
+
+    def login(self, api_key: str, **kwargs: Any) -> str:
+        """No-op in local mode."""
+        return "Local mode — no authentication required."
+
+    def whoami(self, **kwargs: Any) -> str:
+        """Local mode session info."""
+        return "Local mode — single user."
+
+    def switch_team(self, team_id: str, **kwargs: Any) -> str:
+        """No-op in local mode."""
+        return "Local mode — teams not applicable."
+
+    # -- Retrieval feedback (SELF-IMPROVE-6) --
+
+    def submit_feedback(self, search_session_id: str, result_used: list[str], **kwargs: Any) -> dict:
+        """Emit result-selection feedback via core retrieval_tracking (local mode).
+
+        Uses the shown_ids captured from the most recent search() call to provide
+        accurate selection rate data (not just result_used == result_shown).
+        """
+        try:
+            from smartmemory.observability.retrieval_tracking import emit_result_feedback
+
+            # Use shown_ids from the search that produced these results
+            shown_ids = getattr(self, "_last_shown_ids", None) or []
+            if not shown_ids:
+                log.warning("submit_feedback: no prior search() call — shown_ids unknown, skipping")
+                return {"status": "skipped", "reason": "no prior search context"}
+
+            emit_result_feedback(
+                query_hash="",
+                result_used=result_used,
+                result_shown=shown_ids,
+                workspace_id="default",
+                search_session_id=search_session_id,
+            )
+            return {"status": "ok", "search_session_id": search_session_id, "result_used_count": len(result_used)}
+        except Exception as exc:
+            return {"error": str(exc)}