cade-cli 0.16.7__tar.gz → 0.16.9__tar.gz

{cade_cli-0.16.7 → cade_cli-0.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.16.7
+Version: 0.16.9
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs
@@ -129,7 +129,7 @@ The script detects your OS/arch, downloads the matching prebuilt binary
 `~/.local/bin`. Pin a version or install location:
 
 ```bash
-CADE_VERSION=0.16.7 CADE_INSTALL_DIR=/usr/local/bin \
+CADE_VERSION=0.16.9 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 
@@ -252,18 +252,16 @@ cade agent list
 cade agent use reviewer
 cade agent info / cade agent edit reviewer
 
+cade agent mem add ~/Notes                    # one step: register + index
 cade agent mem                                # status
-cade agent mem add ~/notes
 cade agent mem search "auth design"
-cade agent mem warm                           # pre-load semantic search
 ```
 
-Memory is per-agent — each agent has its own
-`~/.cade/data/agents/<id>/memory/.librarian/` index, so a `reviewer` agent's
-notes never leak into another. Cade advertises `Memory_*` tools without starting
-the memory server; the first actual memory call starts it and keeps it warm for
-later calls. Use `cade agent mem warm` when you want to pay that semantic-search
-warmup before a conversation.
+Memory is per-agent under
+`~/.cade/data/agents/<id>/memory/<agent>/.librarian/`. Cade keeps the index and
+embedder ready (auto-heal empty indexes, warm after add/update, longer first
+search timeouts). The model uses `Memory_*` for notes recall — not Local_*
+filesystem tools. Details: [`docs/agents.md`](./docs/agents.md#memory).
 
 ---
 

{cade_cli-0.16.7 → cade_cli-0.16.9}/README.md

@@ -38,7 +38,7 @@ The script detects your OS/arch, downloads the matching prebuilt binary
 `~/.local/bin`. Pin a version or install location:
 
 ```bash
-CADE_VERSION=0.16.7 CADE_INSTALL_DIR=/usr/local/bin \
+CADE_VERSION=0.16.9 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 
@@ -161,18 +161,16 @@ cade agent list
 cade agent use reviewer
 cade agent info / cade agent edit reviewer
 
+cade agent mem add ~/Notes                    # one step: register + index
 cade agent mem                                # status
-cade agent mem add ~/notes
 cade agent mem search "auth design"
-cade agent mem warm                           # pre-load semantic search
 ```
 
-Memory is per-agent — each agent has its own
-`~/.cade/data/agents/<id>/memory/.librarian/` index, so a `reviewer` agent's
-notes never leak into another. Cade advertises `Memory_*` tools without starting
-the memory server; the first actual memory call starts it and keeps it warm for
-later calls. Use `cade agent mem warm` when you want to pay that semantic-search
-warmup before a conversation.
+Memory is per-agent under
+`~/.cade/data/agents/<id>/memory/<agent>/.librarian/`. Cade keeps the index and
+embedder ready (auto-heal empty indexes, warm after add/update, longer first
+search timeouts). The model uses `Memory_*` for notes recall — not Local_*
+filesystem tools. Details: [`docs/agents.md`](./docs/agents.md#memory).
 
 ---
 

{cade_cli-0.16.7 → cade_cli-0.16.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.16.7"
+version = "0.16.9"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.16.7 → cade_cli-0.16.9}/src/cadecoder/ai/prompts.py

@@ -174,7 +174,7 @@ Tool names are versioned (e.g. Slack.SendMessage@2.3.0). Pass the full string to
 
 Re-call SelectTools when the domain shifts or the first result missed. Tools registered earlier in the session persist; you don't need to rediscover them.
 
-Routing: external info/actions on third-party services → discovery + Arcade_UseTool | external pages on the open web → Local_WebFetch (read a URL) and Local_WebSearch (find URLs); pair them — search to find, fetch to read | local code → Local_Search, Local_ReadFile, Local_ListFiles, other Local_* tools. Never grep local files for external-service data, and never guess URLs — search or ask first.
+Routing: external info/actions on third-party services → discovery + Arcade_UseTool | external pages on the open web → Local_WebFetch (read a URL) and Local_WebSearch (find URLs); pair them — search to find, fetch to read | agent notes / persistent library → Memory_SearchLibrary (and other Memory_* tools); never use Local_Search / Local_ReadFile as a fallback for vault or notes recall | local code → Local_Search, Local_ReadFile, Local_ListFiles, other Local_* tools. Never grep local files for external-service data, and never guess URLs — search or ask first.
 
 Anti-patterns: Search → Select chained reflexively; one SelectTools per step instead of per workflow; invoking discovered tools by name instead of through Arcade_UseTool; stripping @version; ignoring an auth URL and retrying.
 """

{cade_cli-0.16.7 → cade_cli-0.16.9}/src/cadecoder/cli/commands/mem.py

@@ -1,21 +1,25 @@
-"""``cade mem`` — manage the current agent's memory, backed by agent-library.
+"""``cade agent mem`` — manage the current agent's memory, backed by agent-library.
 
-Drives the librarian Typer app in-process with ``prog_name="cade mem"`` (so the
-help tree reads as ``cade mem`` rather than ``librarian``/``libr``), scoped to
-the current agent's memory directory. The same on-disk catalogue is what the
-agent's ``Memory_*`` MCP tools read and write.
+Preferred path: ``cade agent mem …``. Flat ``cade mem …`` remains a hidden
+alias. Drives the librarian Typer app in-process (help branded as ``cade mem``),
+scoped to the current agent's memory directory — the same catalogue the
+agent's ``Memory_*`` MCP tools use.
 """
 
 from __future__ import annotations
 
-import os
 from pathlib import Path
 from typing import Annotated, Any
 
 import typer
 from rich.console import Console
 
-from cadecoder.core.memory import ensure_memory_dir
+from cadecoder.core.memory import (
+    apply_memory_env,
+    ensure_memory_dir,
+    ensure_memory_ready,
+    warm_memory_embedder,
+)
 from cadecoder.core.runtime import get_runtime
 
 console = Console(stderr=True)
@@ -36,18 +40,7 @@ def _apply_memory_env() -> Path:
     Returns:
         The agent's memory directory (parent of ``.librarian``).
     """
-    runtime = get_runtime()
-    persona_dir = ensure_memory_dir(runtime.persona_name)
-    librarian_dir = persona_dir / ".librarian"
-    os.environ["DATABASE_PATH"] = str(librarian_dir / "index.db")
-    os.environ["DOCUMENTS_PATH"] = str(librarian_dir / "documents")
-    os.environ["SOURCES_CONFIG_PATH"] = str(librarian_dir / "sources.json")
-    os.environ["HOME"] = str(persona_dir)
-    # Rebrand librarian's usage hints (e.g. "Add a source with: libr add ...")
-    # to "cade mem". Must be set before librarian.cli is imported, which only
-    # happens later via _load_librarian_app().
-    os.environ["LIBRARIAN_PROG_NAME"] = "cade mem"
-    return persona_dir
+    return apply_memory_env()
 
 
 def _load_librarian_app() -> Any:
@@ -62,6 +55,13 @@ def _load_librarian_app() -> Any:
     * ``list`` shows the agent's memory **documents** (what users expect from
       "list"), while the source-directory listing moves to ``sources``.
     """
+    # ``mem update`` / ``mem add`` import ``librarian.server`` (tool registration
+    # via arcade-core). Frozen binaries must patch return-value detection before
+    # that import or ``add_tool`` raises ``ValueError: Source code not found``.
+    from cadecoder.core.frozen import patch_frozen_return_detection
+
+    patch_frozen_return_detection()
+
     from librarian.cli import app
 
     _remap_index_to_update(app)
@@ -178,7 +178,7 @@ def _mem_status() -> None:
     """Render the current agent's memory under "Agent Memory" branding.
 
     Shared by ``cade mem`` (CLI) and the in-chat ``/mem`` command so the view
-    is always the same.
+    is always the same. Auto-heals an empty index when sources are registered.
     """
     from datetime import datetime
 
@@ -186,14 +186,18 @@ def _mem_status() -> None:
     from rich.table import Table
 
     runtime = get_runtime()
-    memory_dir = ensure_memory_dir(runtime.persona_name)
+    ready = ensure_memory_ready(runtime.persona_name, heal=True, warm=False)
+    memory_dir = ready.persona_dir
     db_path = memory_dir / ".librarian" / "index.db"
 
     counts = _read_memory_stats(db_path)
-    if db_path.exists():
+    document_count = int(counts.get("document_count", ready.document_count) or 0)
+    if db_path.exists() and document_count > 0:
         last_updated = datetime.fromtimestamp(db_path.stat().st_mtime).strftime("%Y-%m-%d %H:%M:%S")
+    elif ready.sources and document_count == 0:
+        last_updated = "empty — sources registered but nothing indexed yet"
     else:
-        last_updated = "never — run 'cade agent mem update'"
+        last_updated = "never"
 
     agent_id = runtime.agent_id or "-"
 
@@ -206,10 +210,18 @@ def _mem_status() -> None:
     table = Table(show_header=False, box=None, pad_edge=False)
     table.add_column(style="green")
     table.add_column(style="white")
-    table.add_row("Count", str(counts.get("document_count", 0)))
+    table.add_row("Count", str(document_count))
+    table.add_row("Sources", str(len(ready.sources)))
     table.add_row("Last updated", last_updated)
     table.add_row("Location", str(memory_dir))
     out.print(table)
+    if ready.healed:
+        out.print("[dim]Index was empty and has been rebuilt from registered sources.[/dim]")
+    elif not ready.sources:
+        out.print(
+            "[dim]No notes folder yet — add one with "
+            "[bold]cade agent mem add ~/Notes[/bold].[/dim]"
+        )
 
 
 def _mem_list(*, json_output: bool = False, limit: int = 50) -> None:
@@ -265,7 +277,7 @@ def _mem_list(*, json_output: bool = False, limit: int = 50) -> None:
     if not documents:
         out.print(
             "[dim]No documents in this agent's memory yet — "
-            "add docs or run 'cade agent mem update'.[/dim]"
+            "add a notes folder with 'cade agent mem add ~/Notes'.[/dim]"
         )
         return
 
@@ -351,29 +363,32 @@ def _warm_memory() -> int:
 
 
 def mem_command(ctx: typer.Context) -> None:
-    """Run a ``cade mem`` subcommand scoped to the current agent.
+    """Run a ``cade agent mem`` subcommand scoped to the current agent.
 
     Examples:
-        cade mem                   # show the cade mem help
-        cade mem search "topic"    # search the current agent's memory
-        cade mem add ./docs        # add a source to the current agent's memory
+        cade agent mem                   # status (auto-heals empty index)
+        cade agent mem add ~/Notes       # register + index a notes folder
+        cade agent mem search "topic"    # search the current agent's memory
     """
     memory_home = _apply_memory_env()
     forwarded = list(ctx.args)
-    # Bare `cade mem` defaults to the Agent Memory status view (which already
+    # Bare `cade agent mem` defaults to the Agent Memory status view (which already
     # names the current agent) rather than a help+error panel.
     if not forwarded:
         forwarded = ["status"]
     elif forwarded[0] in {"--help", "-h"}:
         agent_name = get_runtime().persona_name
         console.print(
-            f"[dim]cade mem: scoped to agent [bold]{agent_name}[/bold] "
+            f"[dim]cade agent mem: scoped to agent [bold]{agent_name}[/bold] "
             f"(storage={memory_home})[/dim]\n"
         )
     elif forwarded[0] == "warm":
         rc = _warm_memory()
         raise typer.Exit(rc)
     rc = _run_mem(forwarded)
+    # After sources change or a rebuild, warm so the next Memory_* search is not cold.
+    if rc == 0 and forwarded and forwarded[0] in {"update", "add"}:
+        warm_memory_embedder(quiet=True)
     raise typer.Exit(rc)
 
 

cade_cli-0.16.9/src/cadecoder/core/memory.py

@@ -0,0 +1,312 @@
+"""Per-agent memory directory management for the bundled agent-library server.
+
+The current runtime (agent-backed) scopes memory under
+``data/agents/<id>/memory/<persona>/`` where ``<persona>`` is the agent name.
+All librarian storage lives in a ``.librarian/`` subfolder so that pointing
+``HOME`` at the persona directory makes librarian's hardcoded
+``Path.home() / ".librarian"`` resolve to the same files the ``DATABASE_PATH`` /
+``DOCUMENTS_PATH`` / ``SOURCES_CONFIG_PATH`` env vars point at — the ``Memory_*``
+MCP tools and ``cade mem`` then share one on-disk catalogue.
+
+``ensure_memory_ready`` is the invisible contract: sources without an index are
+healed automatically, and the embedder can be prewarmed so the first search
+does not time out.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from cadecoder.core.logging import log
+from cadecoder.core.paths import validate_name
+from cadecoder.core.runtime import get_runtime
+
+
+@dataclass(frozen=True)
+class MemoryReadyState:
+    """Snapshot of an agent's memory after readiness checks."""
+
+    persona_dir: Path
+    librarian_dir: Path
+    sources: list[dict] = field(default_factory=list)
+    document_count: int = 0
+    healed: bool = False
+    missing_sources: list[str] = field(default_factory=list)
+    warmed: bool = False
+
+    @property
+    def has_sources(self) -> bool:
+        """True when at least one source is registered."""
+        return bool(self.sources)
+
+    @property
+    def is_ready(self) -> bool:
+        """True when sources exist and the index has documents."""
+        return self.has_sources and self.document_count > 0
+
+
+def ensure_memory_dir(persona_name: str) -> Path:
+    """Create the memory directory for a persona/agent and return it.
+
+    Two one-time bootstraps keep a fresh persona from being starved of state:
+
+    1. **Flat-layout migration** of any top-level ``index.db`` / ``sources.json``
+       / ``settings.json`` / ``documents/`` into ``.librarian/``.
+    2. **Global librarian bootstrap**: copy ``~/.librarian/sources.json`` and
+       ``settings.json`` (if present) into a brand-new persona so documents
+       indexed outside Cade aren't orphaned. The index itself is never copied —
+       call :func:`ensure_memory_ready` to rebuild it.
+
+    Both skip when the target already exists, so repeated calls never churn data.
+
+    Args:
+        persona_name: The persona/agent name scoping the memory.
+
+    Returns:
+        The persona memory directory (the parent of ``.librarian``).
+    """
+    safe_name = validate_name(persona_name, kind="persona")
+    persona_dir = get_runtime().memory_dir(safe_name)
+    persona_dir.mkdir(parents=True, exist_ok=True)
+
+    librarian_dir = persona_dir / ".librarian"
+    librarian_dir.mkdir(exist_ok=True)
+    (librarian_dir / "documents").mkdir(exist_ok=True)
+
+    # 1) Flat-layout migration.
+    for filename in ("index.db", "sources.json", "settings.json"):
+        old = persona_dir / filename
+        new = librarian_dir / filename
+        if old.is_file() and not new.exists():
+            old.rename(new)
+
+    old_documents = persona_dir / "documents"
+    new_documents = librarian_dir / "documents"
+    if old_documents.is_dir() and old_documents.resolve() != new_documents.resolve():
+        for child in list(old_documents.iterdir()):
+            target = new_documents / child.name
+            if not target.exists():
+                child.rename(target)
+        try:
+            old_documents.rmdir()
+        except OSError:
+            pass
+
+    # 2) Global librarian bootstrap (sources/settings only — never index/docs).
+    global_librarian = Path.home() / ".librarian"
+    if global_librarian.is_dir() and global_librarian.resolve() != librarian_dir.resolve():
+        for filename in ("sources.json", "settings.json"):
+            source_file = global_librarian / filename
+            target_file = librarian_dir / filename
+            if source_file.is_file() and not target_file.exists():
+                shutil.copy2(source_file, target_file)
+
+    return persona_dir
+
+
+def librarian_dir_for(persona_name: str | None = None) -> Path:
+    """Return ``.librarian`` for the persona, creating the layout if needed."""
+    runtime = get_runtime()
+    name = persona_name or runtime.persona_name
+    return ensure_memory_dir(name) / ".librarian"
+
+
+def load_memory_sources(persona_name: str | None = None) -> list[dict]:
+    """Load registered memory sources for a persona.
+
+    Args:
+        persona_name: Persona/agent name; defaults to the active runtime persona.
+
+    Returns:
+        List of source dicts from ``sources.json``, or ``[]`` when missing/invalid.
+    """
+    sources_path = librarian_dir_for(persona_name) / "sources.json"
+    if not sources_path.is_file():
+        return []
+    try:
+        data = json.loads(sources_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    return data if isinstance(data, list) else []
+
+
+def memory_has_sources(persona_name: str | None = None) -> bool:
+    """Return True when the persona has at least one registered source."""
+    return bool(load_memory_sources(persona_name))
+
+
+def read_memory_document_count(persona_name: str | None = None) -> int:
+    """Return indexed document count without mutating process env.
+
+    Args:
+        persona_name: Persona/agent name; defaults to the active runtime persona.
+
+    Returns:
+        Document count, or ``0`` when the index is missing or unreadable.
+    """
+    db_path = librarian_dir_for(persona_name) / "index.db"
+    if not db_path.exists():
+        return 0
+    try:
+        from librarian.storage.database import Database
+
+        stats = Database(db_path=str(db_path)).get_stats()
+        return int(stats.get("document_count", 0) or 0)
+    except Exception:  # noqa: BLE001
+        return 0
+
+
+def missing_memory_sources(persona_name: str | None = None) -> list[str]:
+    """Return source paths that are registered but missing on disk."""
+    missing: list[str] = []
+    for source in load_memory_sources(persona_name):
+        path = source.get("path")
+        if not path:
+            continue
+        if not Path(str(path)).expanduser().exists():
+            name = str(source.get("name") or path)
+            missing.append(name)
+    return missing
+
+
+def apply_memory_env(persona_name: str | None = None) -> Path:
+    """Point librarian storage env vars at the persona's ``.librarian`` dir.
+
+    Args:
+        persona_name: Persona/agent name; defaults to the active runtime persona.
+
+    Returns:
+        The persona memory directory (parent of ``.librarian``).
+    """
+    runtime = get_runtime()
+    name = persona_name or runtime.persona_name
+    persona_dir = ensure_memory_dir(name)
+    librarian_dir = persona_dir / ".librarian"
+    os.environ["DATABASE_PATH"] = str(librarian_dir / "index.db")
+    os.environ["DOCUMENTS_PATH"] = str(librarian_dir / "documents")
+    os.environ["SOURCES_CONFIG_PATH"] = str(librarian_dir / "sources.json")
+    os.environ["HOME"] = str(persona_dir)
+    os.environ["LIBRARIAN_PROG_NAME"] = "cade mem"
+    return persona_dir
+
+
+def rebuild_memory_index(persona_name: str | None = None) -> int:
+    """Non-interactively rebuild the memory index from registered sources.
+
+    Args:
+        persona_name: Persona/agent name; defaults to the active runtime persona.
+
+    Returns:
+        Indexed document count after rebuild (best-effort; ``0`` on failure).
+    """
+    apply_memory_env(persona_name)
+    try:
+        from librarian.cli import index_build
+    except ImportError:
+        log.debug("agent-library not installed; cannot rebuild memory index")
+        return 0
+
+    try:
+        index_build(source=None, confirm=True, verbose=False)
+    except SystemExit as exc:
+        code = exc.code
+        if code not in (None, 0):
+            log.warning(f"memory index rebuild exited with code {code}")
+            return read_memory_document_count(persona_name)
+    except Exception as exc:  # noqa: BLE001
+        log.warning(f"memory index rebuild failed: {exc}")
+        return read_memory_document_count(persona_name)
+
+    return read_memory_document_count(persona_name)
+
+
+def warm_memory_embedder(*, quiet: bool = True) -> bool:
+    """Load the text embedding model so the next search is not cold.
+
+    Args:
+        quiet: When True, only log failures at debug; otherwise raise-free warn.
+
+    Returns:
+        True when the embedder loaded successfully.
+    """
+    try:
+        from librarian.processing.embed import get_embedder
+    except ImportError:
+        if not quiet:
+            log.warning("agent-library not installed; cannot warm memory embedder")
+        return False
+
+    try:
+        embedder = get_embedder()
+        _ = embedder.dimension
+        log.debug(
+            f"memory embedder warm (model={getattr(embedder, 'model_name', '?')}, "
+            f"dimension={embedder.dimension})"
+        )
+        return True
+    except Exception as exc:  # noqa: BLE001
+        if quiet:
+            log.debug(f"memory embedder warm failed: {exc}")
+        else:
+            log.warning(f"memory embedder warm failed: {exc}")
+        return False
+
+
+def ensure_memory_ready(
+    persona_name: str | None = None,
+    *,
+    heal: bool = True,
+    warm: bool = False,
+) -> MemoryReadyState:
+    """Ensure persona memory is usable: layout, non-empty index, optional warm.
+
+    When sources are registered but ``document_count == 0``, rebuilds the index
+    non-interactively so bootstrap-from-global-sources never presents an empty
+    catalogue as ready. Missing source paths are recorded quietly (logged) and
+    skipped by the rebuild.
+
+    Args:
+        persona_name: Persona/agent name; defaults to the active runtime persona.
+        heal: Rebuild when sources exist but the index is empty.
+        warm: Preload the embedding model after heal (or when already ready).
+
+    Returns:
+        :class:`MemoryReadyState` describing the post-check catalogue.
+    """
+    runtime = get_runtime()
+    name = persona_name or runtime.persona_name
+    persona_dir = ensure_memory_dir(name)
+    librarian_dir = persona_dir / ".librarian"
+    sources = load_memory_sources(name)
+    missing = missing_memory_sources(name)
+    if missing:
+        log.debug(f"memory sources missing on disk (skipped): {', '.join(missing)}")
+
+    document_count = read_memory_document_count(name)
+    healed = False
+    if heal and sources and document_count == 0:
+        log.info(
+            f"memory index empty with {len(sources)} source(s) for agent "
+            f"{name!r}; rebuilding automatically"
+        )
+        document_count = rebuild_memory_index(name)
+        healed = True
+
+    warmed = False
+    if warm and (document_count > 0 or healed):
+        apply_memory_env(name)
+        warmed = warm_memory_embedder(quiet=True)
+
+    return MemoryReadyState(
+        persona_dir=persona_dir,
+        librarian_dir=librarian_dir,
+        sources=sources,
+        document_count=document_count,
+        healed=healed,
+        missing_sources=missing,
+        warmed=warmed,
+    )

{cade_cli-0.16.7 → cade_cli-0.16.9}/src/cadecoder/daemon/server.py

@@ -269,9 +269,32 @@ def _resolve_sandbox_root(cfg: Any) -> Any:
     return base.resolve()
 
 
+async def _prewarm_shared_memory(memory_url: str) -> None:
+    """Best-effort warm of the shared memory HTTP service (embedder load)."""
+    try:
+        from cadecoder.tools.manager.composite import build_builtin_http_config
+        from cadecoder.tools.manager.mcp import MCPToolManager
+
+        config = build_builtin_http_config("__builtin_memory__", memory_url)
+        manager = MCPToolManager(config, None)
+        try:
+            await manager.initialize()
+            # Keyword search still loads the hybrid stack / embedder on many builds.
+            await manager.execute(
+                "Memory_SearchLibrary",
+                {"query": "cade memory warm", "mode": "keyword", "limit": 1},
+            )
+            log.debug("shared memory service prewarmed")
+        finally:
+            await manager.close()
+    except Exception as e:  # noqa: BLE001
+        log.debug(f"shared memory prewarm skipped: {e}")
+
+
 async def _start_builtin_services(persona: str) -> None:
     """Promote stdio local-tools to a shared loopback HTTP service when possible."""
     try:
+        from cadecoder.core.memory import ensure_memory_ready, memory_has_sources
         from cadecoder.daemon.services import BuiltinServices
         from cadecoder.tools.manager.composite import (
             BUILTIN_LOCAL_NAME,
@@ -282,19 +305,37 @@ async def _start_builtin_services(persona: str) -> None:
         log.debug(f"builtin services unavailable: {e}")
         return
 
+    # Heal empty index before any worker can search; warm in-process is a
+    # best-effort hint — the shared memory HTTP process warms on first use /
+    # via ensure_memory_service prewarm.
+    try:
+        await asyncio.to_thread(ensure_memory_ready, persona, heal=True, warm=False)
+    except Exception as e:  # noqa: BLE001
+        log.debug(f"memory readiness at daemon boot skipped: {e}")
+
     servers = {s.name: s for s in effective_mcp_servers(persona=persona)}
     local = servers.get(BUILTIN_LOCAL_NAME)
     start_local = local is not None and local.transport == MCPTransportType.STDIO
     if not start_local:
         return
 
-    services = BuiltinServices(persona=persona, start_local=True, start_memory=False)
+    start_memory = False
+    try:
+        start_memory = memory_has_sources(persona)
+    except Exception:  # noqa: BLE001
+        start_memory = False
+
+    services = BuiltinServices(persona=persona, start_local=True, start_memory=start_memory)
     if not await services.start():
         return
     if services.local_url:
         os.environ["CADE_BUILTIN_LOCAL_URL"] = services.local_url
     if services.memory_url:
         os.environ["CADE_BUILTIN_MEMORY_URL"] = services.memory_url
+        asyncio.create_task(
+            _prewarm_shared_memory(services.memory_url),
+            name="cade-daemon-memory-prewarm",
+        )
 
 
 async def _start_cron(supervisor: Supervisor):

{cade_cli-0.16.7 → cade_cli-0.16.9}/src/cadecoder/daemon/services.py

@@ -161,6 +161,20 @@ class BuiltinServices:
         return True
 
     async def _start_memory(self) -> None:
+        # Heal empty index in the parent before the memory subprocess starts so
+        # the first client never sees sources-with-zero-docs as ready.
+        try:
+            from cadecoder.core.memory import ensure_memory_ready
+
+            await asyncio.to_thread(
+                ensure_memory_ready,
+                self.persona,
+                heal=True,
+                warm=False,
+            )
+        except Exception as e:  # noqa: BLE001
+            log.debug(f"memory readiness before shared service skipped: {e}")
+
         config = _build_memory_config(self.persona)
         if config is None:
             return  # agent-library not installed; nothing to share