fix: prompts call MCP tools directly, sync handles semantic errors, status uses local routing

- Prompts (search, continue_conversation) now call MCP tools directly
  instead of going through API endpoints, matching the recent_activity
  pattern and fixing #526 where prompts returned empty results
- sync_file catches SemanticDependenciesMissingError separately so
  entities are still returned successfully when vector embedding fails,
  with a clear warning instead of silent failure (#578)
- `bm status` and `bm doctor` default to local routing since they scan
  the local filesystem — cloud routing returned Docker-internal paths

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/cli/commands/doctor.py

@@ -139,6 +139,9 @@ def doctor(
     """Run local consistency checks to verify file/database sync."""
     try:
         validate_routing_flags(local, cloud)
+        # Doctor runs local filesystem checks — always default to local routing
+        if not local and not cloud:
+            local = True
         with force_routing(local=local, cloud=cloud):
             run_with_cleanup(run_doctor())
     except (ToolError, ValueError) as e:

src/basic_memory/cli/commands/status.py

@@ -179,6 +179,13 @@ def status(
 
     try:
         validate_routing_flags(local, cloud)
+        # Trigger: no explicit routing flag provided
+        # Why: status scans the local filesystem — cloud routing would use the
+        #      Docker-internal path stored in the cloud database, which doesn't
+        #      exist locally.
+        # Outcome: default to local routing unless --cloud was explicitly requested.
+        if not local and not cloud:
+            local = True
         with force_routing(local=local, cloud=cloud):
             run_with_cleanup(run_status(project, verbose))  # pragma: no cover
     except ValueError as e:

src/basic_memory/mcp/prompts/continue_conversation.py

@@ -4,17 +4,16 @@
 providing context from previous interactions to maintain continuity.
 """
 
+from textwrap import dedent
 from typing import Annotated, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from basic_memory.config import ConfigManager
-from basic_memory.mcp.async_client import get_client
-from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.utils import call_post
-from basic_memory.schemas.prompt import ContinueConversationRequest
+from basic_memory.mcp.tools.recent_activity import recent_activity
+from basic_memory.mcp.tools.search import search_notes
+from basic_memory.schemas.search import SearchResponse
 
 
 @mcp.prompt(
@@ -42,22 +41,94 @@ async def continue_conversation(
     """
     logger.info(f"Continuing session, topic: {topic}, timeframe: {timeframe}")
 
-    async with get_client() as client:
-        config = ConfigManager().config
-        active_project = await get_active_project(client, project=config.default_project)
-
-        # Create request model
-        request = ContinueConversationRequest(  # pyright: ignore [reportCallIssue]
-            topic=topic, timeframe=timeframe
-        )
-
-        # Call the prompt API endpoint
-        response = await call_post(
-            client,
-            f"/v2/projects/{active_project.external_id}/prompt/continue-conversation",
-            json=request.model_dump(exclude_none=True),
-        )
-
-        # Extract the rendered prompt from the response
-        result = response.json()
-        return result["prompt"]
+    if topic:
+        # Search for the topic using the search tool directly
+        result = await search_notes(query=topic, after_date=timeframe)
+
+        if isinstance(result, SearchResponse):
+            context_text = _format_continuation_results(result, topic)
+            result_count = len(result.results)
+        elif isinstance(result, dict):
+            results = result.get("results", [])
+            context_text = str(result)
+            result_count = len(results)
+        else:
+            # Error string
+            context_text = str(result)
+            result_count = 0
+    else:
+        # No topic — show recent activity
+        effective_timeframe = timeframe or "7d"
+        activity_text = await recent_activity(timeframe=effective_timeframe)
+        context_text = str(activity_text)
+        result_count = -1  # Signals we used recent_activity
+
+    target = f"'{topic}'" if topic else "recent activity"
+
+    prompt = dedent(f"""
+        # Continuing conversation on: {target}
+
+        This is a memory retrieval session.
+
+        Please use the available basic-memory tools to gather relevant context before responding.
+        Start by executing one of the suggested commands below to retrieve content.
+
+        {context_text}
+
+        ---
+
+        ## Next Steps
+    """)
+
+    if topic and result_count > 0:
+        prompt += dedent(f"""
+            Found {result_count} results related to '{topic}'.
+
+            1. **Read full content** - Use `read_note("permalink")` to dive into specific notes
+            2. **Build context** - Use `build_context("memory://path")` to see relationships
+            3. **Search deeper** - Use `search_notes("{topic}")` with different filters
+
+            > **Knowledge Capture:** As you continue this conversation, actively look for
+            > opportunities to record new information, decisions, or insights using `write_note()`.
+        """)
+    elif topic:
+        prompt += dedent(f"""
+            No previous context found for '{topic}'.
+
+            This is an opportunity to start documenting this topic:
+
+            1. **Create a new note** - Use `write_note(title="{topic}", content="...")` to start
+            2. **Search with variations** - Try `search_notes("{topic}")` with different terms
+            3. **Check recent activity** - Use `recent_activity(timeframe="7d")` to see what's new
+        """)
+    else:
+        prompt += dedent("""
+            1. **Explore specific items** - Use `read_note("permalink")` to dive deeper
+            2. **Search for topics** - Use `search_notes("topic")` to find specific content
+            3. **Build context** - Use `build_context("memory://path")` to see relationships
+        """)
+
+    return prompt
+
+
+def _format_continuation_results(result: SearchResponse, topic: str) -> str:
+    """Format search results for conversation continuation context."""
+    if not result.results:
+        return f"No previous context found for '{topic}'."
+
+    lines = [f"## Previous Context for '{topic}'\n"]
+
+    for item in result.results:
+        title = item.title or "Untitled"
+        permalink = item.permalink or ""
+
+        lines.append(f"### {title}")
+        if permalink:
+            lines.append(f"permalink: {permalink}")
+            lines.append(f"Read with: `read_note(\"{permalink}\")`")
+        if item.content:
+            content = item.content[:300] + "..." if len(item.content) > 300 else item.content
+            lines.append(f"\n{content}")
+        lines.append("")
+
+    return "\n".join(lines)

src/basic_memory/mcp/prompts/search.py

@@ -3,17 +3,15 @@
 These prompts help users search and explore their knowledge base.
 """
 
+from textwrap import dedent
 from typing import Annotated, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from basic_memory.config import ConfigManager
-from basic_memory.mcp.async_client import get_client
-from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.utils import call_post
-from basic_memory.schemas.prompt import SearchPromptRequest
+from basic_memory.mcp.tools.search import search_notes
+from basic_memory.schemas.search import SearchResponse
 
 
 @mcp.prompt(
@@ -41,20 +39,65 @@ async def search_prompt(
     """
     logger.info(f"Searching knowledge base, query: {query}, timeframe: {timeframe}")
 
-    async with get_client() as client:
-        config = ConfigManager().config
-        active_project = await get_active_project(client, project=config.default_project)
+    # Call the search tool directly — it returns SearchResponse, dict, or error string
+    result = await search_notes(query=query, after_date=timeframe)
 
-        # Create request model
-        request = SearchPromptRequest(query=query, timeframe=timeframe)
+    # Format the tool output into a prompt with guidance
+    if isinstance(result, SearchResponse):
+        result_count = len(result.results)
+        result_text = _format_search_results(result, query)
+    elif isinstance(result, dict):
+        # json output format
+        results = result.get("results", [])
+        result_count = len(results)
+        result_text = str(result)
+    else:
+        # Error string from search tool
+        result_count = 0
+        result_text = str(result)
 
-        # Call the prompt API endpoint
-        response = await call_post(
-            client,
-            f"/v2/projects/{active_project.external_id}/prompt/search",
-            json=request.model_dump(exclude_none=True),
-        )
+    return dedent(f"""
+        # Search Results: "{query}"
 
-        # Extract the rendered prompt from the response
-        result = response.json()
-        return result["prompt"]
+        This is a memory retrieval session showing search results.
+
+        {result_text}
+
+        ---
+
+        ## Next Steps
+
+        Based on these {result_count} results, you can:
+
+        1. **Read a specific note** - Use `read_note("permalink")` to see full content
+        2. **Build context** - Use `build_context("memory://path")` to see relationships
+        3. **Refine search** - Use `search_notes("refined query")` to narrow results
+        4. **Check recent activity** - Use `recent_activity(timeframe="7d")` for recent changes
+    """)
+
+
+def _format_search_results(result: SearchResponse, query: str) -> str:
+    """Format SearchResponse into readable markdown."""
+    if not result.results:
+        return f"No results found for '{query}'."
+
+    lines = [f"Found {len(result.results)} results:\n"]
+
+    for item in result.results:
+        title = item.title or "Untitled"
+        permalink = item.permalink or ""
+        score = f" (score: {item.score:.2f})" if item.score else ""
+
+        lines.append(f"- **{title}**{score}")
+        if permalink:
+            lines.append(f"  permalink: {permalink}")
+        if item.content:
+            # Truncate content snippet
+            content = item.content[:200] + "..." if len(item.content) > 200 else item.content
+            lines.append(f"  {content}")
+        lines.append("")
+
+    if result.has_more:
+        lines.append("*More results available. Use page=2 to see next page.*")
+
+    return "\n".join(lines)

src/basic_memory/sync/sync_service.py

@@ -29,6 +29,7 @@
 )
 from basic_memory.repository.search_repository import create_search_repository
 from basic_memory.services import EntityService, FileService
+from basic_memory.repository.semantic_errors import SemanticDependenciesMissingError
 from basic_memory.services.exceptions import SyncFatalError
 from basic_memory.services.link_resolver import LinkResolver
 from basic_memory.services.search_service import SearchService
@@ -600,7 +601,18 @@ async def sync_file(
                 entity, checksum = await self.sync_regular_file(path, new)
 
             if entity is not None:
-                await self.search_service.index_entity(entity)
+                try:
+                    await self.search_service.index_entity(entity)
+                except SemanticDependenciesMissingError:
+                    # Trigger: sqlite-vec or embedding provider unavailable
+                    # Why: FTS indexing succeeded but vector embeddings cannot be generated.
+                    #      Don't fail the entire sync — the entity is usable for text search.
+                    # Outcome: entity returned successfully, warning logged for visibility.
+                    logger.warning(
+                        f"Semantic search dependencies missing — vector embeddings skipped "
+                        f"for path={path}. Run 'bm reindex --embeddings' after resolving "
+                        f"the dependency issue."
+                    )
 
                 # Clear failure tracking on successful sync
                 self._clear_failure(path)