crow-cli 0.1.28__tar.gz → 0.1.30__tar.gz

{crow_cli-0.1.28 → crow_cli-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crow-cli
-Version: 0.1.28
+Version: 0.1.30
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/crow-cli/crow-cli
 Project-URL: Repository, https://github.com/crow-cli/crow-cli
@@ -9,6 +9,7 @@ Project-URL: Documentation, https://github.com/crow-cli/crow-cli#readme
 Requires-Python: >=3.14
 Requires-Dist: agent-client-protocol>=0.9.0
 Requires-Dist: coolname>=2.2.0
+Requires-Dist: crow-memory>=0.1.30
 Requires-Dist: directory-tree>=1.0.0
 Requires-Dist: fastmcp>=2.14.5
 Requires-Dist: httpx>=0.28.1

{crow_cli-0.1.28 → crow_cli-0.1.30}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "crow-cli"
-version = "0.1.28"
+version = "0.1.30"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"
 dependencies = [
     "agent-client-protocol>=0.9.0",
     "coolname>=2.2.0",
+    "crow-memory>=0.1.30",
     "directory-tree>=1.0.0",
     "fastmcp>=2.14.5",
     "httpx>=0.28.1",
@@ -19,6 +20,16 @@ dependencies = [
     "typer>=0.24.1",
 ]
 
+[tool.uv.sources]
+crow-memory = { path = "../crow-memory", editable = true }
+torch = [{ index = "pytorch-cpu" }]
+torchvision = [{ index = "pytorch-cpu" }]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
 
 [project.urls]
 Homepage = "https://github.com/crow-cli/crow-cli"

{crow_cli-0.1.28 → crow_cli-0.1.30}/src/crow_cli/agent/configure.py

@@ -91,7 +91,7 @@ class LLMConfig:
 class Config:
     config_dir: Path
     llm: LLMConfig = field(default_factory=LLMConfig)
-    memory_url: str = ""
+    memory_path: str = ""
     mcp_servers: dict[str, Any] = field(default_factory=dict)
     max_retries_per_step: int = 3
     MAX_COMPACT_TOKENS: int = 190000
@@ -134,7 +134,7 @@ class Config:
             _logger.info("No config.yaml found, returning bare Config")
             return cls(
                 config_dir=target_dir,
-                memory_url="http://localhost:8901",
+                memory_path=str(Path.home() / ".crow" / "memory.lance"),
             )
 
         with open(config_file) as f:
@@ -162,7 +162,7 @@ class Config:
             )
 
         # Parse overrides
-        memory_url = parsed.get("memory_url") or "http://localhost:8901"
+        memory_path = os.path.expanduser(parsed.get("memory_path") or "~/.crow/memory.lance")
         overrides = {}
         for key, typ in (
             ("max_retries_per_step", int),
@@ -184,7 +184,7 @@ class Config:
         return cls(
             config_dir=target_dir,
             llm=llm,
-            memory_url=memory_url,
+            memory_path=memory_path,
             mcp_servers=mcp_servers,
             system_prompt_path=system_prompt_path,
             **overrides,

{crow_cli-0.1.28 → crow_cli-0.1.30}/src/crow_cli/agent/default/defaults.py

@@ -160,32 +160,6 @@ COMPOSE_YAML = """services:
     volumes:
       - ./searxng/:/etc/searxng
 
-  crow-memory:
-    image: ghcr.io/crow-cli/crow-memory:latest
-    # For local development, replace image with build:
-    #   build:
-    #     context: /path/to/crow-cli/crow-memory
-    #     dockerfile: Dockerfile
-    restart: always
-    ports:
-      - "8901:8901"
-    environment:
-      - CROW_MEMORY_PATH=/data/memory.lance
-      - CROW_MEMORY_HOST=0.0.0.0
-      - CROW_MEMORY_PORT=8901
-      - CUDA_VISIBLE_DEVICES=
-    volumes:
-      - ./memory.lance:/data/memory.lance
-    # GPU acceleration — uncomment when you want hardware-accelerated embeddings.
-    # CPU mode is ~100ms text / ~2-3s image, which is fine for background agents.
-    # deploy:
-    #   resources:
-    #     reservations:
-    #       devices:
-    #         - driver: nvidia
-    #           count: 1
-    #           capabilities: [gpu]
-
   litellm:
     image: ghcr.io/berriai/litellm:main-v1.82.6-nightly
     restart: always
@@ -214,8 +188,8 @@ mcpServers:
     args:
       - crow-mcp
 
-# DEFAULT crow-memory service URL
-memory_url: http://localhost:8901
+# Memory store path (LanceDB, in-process)
+memory_path: ~/.crow/memory.lance
 
 # EXAMPLE PROVIDER
 # providers:

{crow_cli-0.1.28 → crow_cli-0.1.30}/src/crow_cli/agent/main.py

@@ -36,13 +36,6 @@ Now you're guaranteed to have an API key and a base url to access an LLM, run th
 uvx crow-cli init
 ```
 
-# Start the memory service
-crow-cli persists every session to a local [crow-memory](https://github.com/crow-cli/crow-cli/tree/main/crow-memory) service (LanceDB + ColBERT embeddings) running in Docker. The init wizard writes a `compose.yaml` for you:
-```bash
-cd ~/.crow && docker compose up -d
-```
-This starts crow-memory (port 8901) and optionally SearXNG for web search. Without it, sessions won't persist and the memory tools (`list_sessions`, `query_memory`, `query_session`) won't work.
-
 Then restart your agent.
 """
 
@@ -172,7 +165,7 @@ class AcpAgent(Agent):
             hooks if hooks is not None else [uv_project_hook]
         )
         self._logger = setup_logger(self._config.config_dir / "logs" / "crow-cli.log")
-        self._memory_url = self._config.memory_url
+        self._memory_path = self._config.memory_path
         self._exit_stack = AsyncExitStack()
         self._agent_id: str | None = None
         self._session_id: str | None = None  # stripped version for ACP upstream
@@ -422,14 +415,14 @@ class AcpAgent(Agent):
 
         try:
             # Find the highest-indexed agent for this session
-            max_idx = AgentSession.get_max_agent_idx(session_id, memory_url=self._memory_url)
+            max_idx = AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
             agent_id = f"{session_id}-{max_idx}"
             self._logger.info(
                 "LOAD_SESSION: Step 1: Loading agent %s from DB", agent_id
             )
             session = AgentSession.load(
                 agent_id,
-                memory_url=self._memory_url,
+                memory_path=self._memory_path,
             )
             self._logger.info("LOAD_SESSION: Step 1 complete: Agent loaded from DB")
 
@@ -513,7 +506,7 @@ class AcpAgent(Agent):
         if self._session_id == session_id and self._agent_id:
             agent_id = self._agent_id
         else:
-            max_idx = AgentSession.get_max_agent_idx(session_id, memory_url=self._memory_url)
+            max_idx = AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
             agent_id = f"{session_id}-{max_idx}"
 
         # Initialize if not set
@@ -565,7 +558,7 @@ class AcpAgent(Agent):
         if self._session_id == session_id and self._agent_id:
             agent_id = self._agent_id
         else:
-            max_idx = AgentSession.get_max_agent_idx(session_id, memory_url=self._memory_url)
+            max_idx = AgentSession.get_max_agent_idx(session_id, memory_path=self._memory_path)
             agent_id = f"{session_id}-{max_idx}"
 
         async def _execute_turn() -> PromptResponse:
@@ -786,7 +779,7 @@ class AcpAgent(Agent):
         self._logger.info("Listing sessions for working directory: %s", cwd)
         if cwd is None:
             return ListSessionsResponse(sessions=[], next_cursor=None)
-        sessions_info = get_session_by_cwd(cwd, self._memory_url)
+        sessions_info = get_session_by_cwd(cwd, self._memory_path)
         sessions = [SessionInfo(**session) for session in sessions_info]
         return ListSessionsResponse(sessions=sessions, next_cursor=None)
 

crow_cli-0.1.30/src/crow_cli/agent/memory.py

@@ -0,0 +1,164 @@
+"""In-process memory layer for crow-cli.
+
+Wraps crow-memory's MemoryStore (LanceDB + ColBERT/ColQwen2) directly — no
+HTTP, no service, no retry logic. The embedders are loaded once per process
+via a singleton; the model weights are mmap'd and shared with crow-mcp by the
+kernel's page cache.
+"""
+
+import logging
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+DEFAULT_MEMORY_PATH = str(Path.home() / ".crow" / "memory.lance")
+
+
+class MemoryServiceError(Exception):
+    """Raised when a memory operation fails (e.g. agent not found)."""
+
+    def __init__(self, status: int, detail: str):
+        self.status = status
+        self.detail = detail
+        super().__init__(f"memory error {status}: {detail}")
+
+
+class MemoryClient:
+    """In-process adapter over MemoryStore.
+
+    Same interface as the old HTTP client so session.py / main.py don't change
+    shape — but backed by a direct LanceDB connection. The `base_url` param is
+    now a filesystem path (kept as positional for compat during transition).
+    """
+
+    def __init__(self, path: str = DEFAULT_MEMORY_PATH, **_kwargs):
+        from crow_memory import get_store
+        self._store = get_store(path)
+
+    def close(self):
+        pass  # nothing to close; store is process-global
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        pass
+
+    # ---- agents ----
+
+    def create_agent(
+        self,
+        *,
+        agent_id: str,
+        session_id: str,
+        agent_idx: int = 1,
+        cwd: str = "/tmp",
+        prompt_id: str | None = None,
+        prompt_args: dict | None = None,
+        system_prompt: str = "",
+        tool_definitions: list[dict] | None = None,
+        request_params: dict | None = None,
+        model_identifier: str = "",
+        initial_messages: list[dict] | None = None,
+    ) -> dict:
+        agent = self._store.add_agent({
+            "agent_id": agent_id,
+            "session_id": session_id,
+            "agent_idx": agent_idx,
+            "cwd": cwd,
+            "prompt_id": prompt_id,
+            "prompt_args": prompt_args or {},
+            "system_prompt": system_prompt,
+            "tool_definitions": tool_definitions or [],
+            "request_params": request_params or {},
+            "model_identifier": model_identifier,
+        })
+        for m in (initial_messages or []):
+            if m.get("role") != "system":
+                self._store.add_message(agent_id, m)
+        return agent
+
+    def load(self, agent_id: str, hydrate: bool = False) -> tuple[dict, list[dict]]:
+        agent = self._store.get_agent(agent_id)
+        if agent is None:
+            raise MemoryServiceError(404, f"agent '{agent_id}' not found")
+        messages = self._store.load_messages(agent_id, hydrate_images=hydrate)
+        return agent, messages
+
+    def list_agents(self, session_id: str | None = None) -> list[dict]:
+        return self._store.list_agents(session_id=session_id)
+
+    # ---- messages ----
+
+    def add_message(self, agent_id: str, message: dict, usage: dict | None = None) -> dict:
+        return self._store.add_message(agent_id, message, usage)
+
+    def save_messages(self, agent_id: str, messages: list[dict]) -> dict:
+        ids = [self._store.add_message(agent_id, m)["id"] for m in messages]
+        return {"agent_id": agent_id, "ids": ids, "count": len(ids)}
+
+    def query_messages(
+        self,
+        *,
+        session_id: str | None = None,
+        agent_id: str | None = None,
+        agent_idx: int | None = None,
+        roles: list[str] | None = None,
+        after: str | None = None,
+        before: str | None = None,
+        order: str = "asc",
+        limit: int = 1_000_000,
+        offset: int = 0,
+    ) -> list[dict]:
+        return self._store.query_messages(
+            session_id=session_id, agent_id=agent_id, agent_idx=agent_idx,
+            roles=roles, after=after, before=before, order=order,
+            limit=limit, offset=offset,
+        )
+
+    # ---- sessions ----
+
+    def get_max_agent_idx(self, session_id: str) -> int:
+        return self._store.get_max_agent_idx(session_id)
+
+    def list_sessions(self, limit: int = 50, offset: int = 0) -> list[dict]:
+        return self._store.list_sessions(limit=limit, offset=offset)
+
+    # ---- prompts ----
+
+    def lookup_or_create_prompt(self, template: str, name: str = "crow-default") -> str:
+        result = self._store.lookup_or_create_prompt(template, name)
+        return result["id"]
+
+    def get_prompt(self, prompt_id: str) -> dict:
+        p = self._store.get_prompt(prompt_id)
+        if p is None:
+            raise MemoryServiceError(404, f"prompt '{prompt_id}' not found")
+        return p
+
+    # ---- images ----
+
+    def get_image(self, image_id: str) -> tuple[bytes, str]:
+        img = self._store.get_image(image_id)
+        if img is None:
+            raise MemoryServiceError(404, f"image '{image_id}' not found")
+        return img["data"], img["mime"]
+
+    # ---- search ----
+
+    def search(
+        self,
+        query: str | None = None,
+        modality: str = "text",
+        filters: dict | None = None,
+        limit: int = 10,
+        query_image: bytes | None = None,
+    ) -> dict:
+        out = {"messages": [], "images": []}
+        if modality in ("text", "both") and query:
+            out["messages"] = self._store.search_messages(query, filters, limit)
+        if modality in ("image", "both"):
+            out["images"] = self._store.search_images(
+                query=query, query_image=query_image, limit=limit
+            )
+        return out

{crow_cli-0.1.28 → crow_cli-0.1.30}/src/crow_cli/agent/session.py

@@ -16,19 +16,19 @@ from typing import Any
 import yaml
 from coolname import generate_slug
 
-from crow_cli.agent.memory import DEFAULT_MEMORY_URL, MemoryClient, MemoryServiceError
+from crow_cli.agent.memory import DEFAULT_MEMORY_PATH, MemoryClient, MemoryServiceError
 from crow_cli.agent.prompt import render_template
 from crow_cli.agent.context import get_directory_tree
 
 from crow_cli.agent.configure import Config
 
-def get_session_by_cwd(cwd, memory_url=DEFAULT_MEMORY_URL):
+def get_session_by_cwd(cwd, memory_path=DEFAULT_MEMORY_PATH):
     """
-    Lookup agents by working directory via the crow-memory service.
+    Lookup agents by working directory via the in-process memory store.
 
     Returns list of session info dicts with session_id, title, updated_at.
     """
-    client = MemoryClient(memory_url)
+    client = MemoryClient(memory_path)
     try:
         result = []
         for agent in client.list_agents():
@@ -80,12 +80,12 @@ def get_coolname() -> str:
 def lookup_or_create_prompt(
     template: str,
     name: str,
-    memory_url: str = DEFAULT_MEMORY_URL,
+    memory_path: str = DEFAULT_MEMORY_PATH,
 ) -> str:
     """
     Lookup existing prompt by template content, or create new one if not found.
     """
-    client = MemoryClient(memory_url)
+    client = MemoryClient(memory_path)
     try:
         return client.lookup_or_create_prompt(template, name)
     finally:
@@ -94,7 +94,7 @@ def lookup_or_create_prompt(
 
 class AgentSession:
     """
-    Manages conversation state and persistence via the crow-memory service.
+    Manages conversation state and persistence via the in-process memory store (LanceDB).
 
     agent_id = "{session_id}-{agent_idx}" is the key.
     session_id is derived for ACP upstream routing only.
@@ -105,13 +105,13 @@ class AgentSession:
         agent_id: str,
         session_id: str,
         agent_idx: int = 0,
-        memory_url: str = DEFAULT_MEMORY_URL,
+        memory_path: str = DEFAULT_MEMORY_PATH,
         cwd: str = "/tmp",
     ):
         self.agent_id = agent_id
         self.session_id = session_id
         self.agent_idx = agent_idx
-        self.memory_url = memory_url
+        self.memory_path = memory_path
         self.cwd = cwd
         self.messages: list[dict] = []
         self._client = None
@@ -119,9 +119,9 @@ class AgentSession:
 
     @property
     def client(self) -> MemoryClient:
-        """Lazy-load the HTTP client to the crow-memory service."""
+        """Lazy-load the in-process memory client."""
         if self._client is None:
-            self._client = MemoryClient(self.memory_url)
+            self._client = MemoryClient(self.memory_path)
         return self._client
 
     def add_message(self, msg: dict, usage: dict | None = None):
@@ -190,14 +190,14 @@ class AgentSession:
         tool_definitions: list[dict],
         request_params: dict[str, Any],
         model_identifier: str,
-        memory_url: str = DEFAULT_MEMORY_URL,
+        memory_path: str = DEFAULT_MEMORY_PATH,
         cwd: str = "/tmp",
         agent_idx: int = 1,
         session_id: str | None = None,
         initial_messages: list[dict[str, Any]] | None = None,
     ) -> "AgentSession":
         """Factory method to create a new agent session."""
-        client = MemoryClient(memory_url)
+        client = MemoryClient(memory_path)
 
         # Load and render prompt
         try:
@@ -228,7 +228,7 @@ class AgentSession:
         client.close()
 
         # Build session instance
-        session = cls(agent_id, session_id, agent_idx, memory_url, cwd=cwd)
+        session = cls(agent_id, session_id, agent_idx, memory_path, cwd=cwd)
         session.model_identifier = model_identifier
         session.tools = tool_definitions
         session.request_params = request_params
@@ -251,10 +251,10 @@ class AgentSession:
     def get_max_agent_idx(
         cls,
         session_id: str,
-        memory_url: str = DEFAULT_MEMORY_URL,
+        memory_path: str = DEFAULT_MEMORY_PATH,
     ) -> int:
         """Return the highest agent_idx for a given session_id."""
-        client = MemoryClient(memory_url)
+        client = MemoryClient(memory_path)
         try:
             return client.get_max_agent_idx(session_id)
         finally:
@@ -265,10 +265,10 @@ class AgentSession:
         cls,
         limit: int = 50,
         offset: int = 0,
-        memory_url: str = DEFAULT_MEMORY_URL,
+        memory_path: str = DEFAULT_MEMORY_PATH,
     ) -> list[dict]:
         """List sessions ordered by most-recent message activity (desc)."""
-        client = MemoryClient(memory_url)
+        client = MemoryClient(memory_path)
         try:
             return client.list_sessions(limit=limit, offset=offset)
         finally:
@@ -278,10 +278,10 @@ class AgentSession:
     def load(
         cls,
         agent_id: str,
-        memory_url: str = DEFAULT_MEMORY_URL,
+        memory_path: str = DEFAULT_MEMORY_PATH,
     ) -> "AgentSession":
         """Factory method to load existing agent session from the service."""
-        client = MemoryClient(memory_url)
+        client = MemoryClient(memory_path)
         try:
             agent, messages = client.load(agent_id, hydrate=True)
         except MemoryServiceError as e:
@@ -295,7 +295,7 @@ class AgentSession:
             agent_id=agent["agent_id"],
             session_id=agent["session_id"],
             agent_idx=agent["agent_idx"],
-            memory_url=memory_url,
+            memory_path=memory_path,
             cwd=agent["cwd"],
         )
         session.model_identifier = agent["model_identifier"]
@@ -446,7 +446,7 @@ def make_agent_session(
     else:
         template = config.system_prompt
     prompt_id = lookup_or_create_prompt(
-        template, name="crow-default", memory_url=config.memory_url
+        template, name="crow-default", memory_path=config.memory_path
     )
     skills = get_skills(config.config_dir / "skills")
 
@@ -471,7 +471,7 @@ def make_agent_session(
         tool_definitions=tools,
         request_params={"temperature": 0.2},
         model_identifier=model_id,
-        memory_url=config.memory_url,
+        memory_path=config.memory_path,
         cwd=cwd,
         agent_idx=agent_idx,
         session_id=session_id,

{crow_cli-0.1.28 → crow_cli-0.1.30}/src/crow_cli/cli/init_cmd.py

@@ -285,8 +285,8 @@ def run_init(config_dir: Path, yes: bool = False):
     # =========================================================================
     console.print("\n[bold cyan]═══ Step 3: Review ═══[/bold cyan]\n")
 
-    memory_url = "http://localhost:8901"
-    console.print(f"[dim]Using crow-memory service at {memory_url}[/dim]")
+    memory_path = str(Path.home() / ".crow" / "memory.lance")
+    console.print(f"[dim]Memory store: {memory_path}[/dim]")
 
     if providers:
         p_table = Table(title="Providers", show_header=True)
@@ -309,11 +309,11 @@ def run_init(config_dir: Path, yes: bool = False):
     s_table.add_column("Service", style="cyan")
     s_table.add_column("Status", style="green")
     s_table.add_row("SearXNG", "✓ Docker" if setup_searxng else "✗ Skip")
-    s_table.add_row("Memory", "crow-memory service")
+    s_table.add_row("Memory", "in-process LanceDB")
     console.print(s_table)
 
     console.print(f"\n[dim]Config directory: {config_dir}[/dim]")
-    console.print(f"[dim]Memory service: {memory_url}[/dim]")
+    console.print(f"[dim]Memory store: {memory_path}[/dim]")
 
     if not yes and not Confirm.ask("\nLooks good?", default=True):
         console.print("[red]Aborted. No files were written.[/red]")
@@ -345,7 +345,7 @@ def run_init(config_dir: Path, yes: bool = False):
                 "args": ["crow-mcp"],
             }
         },
-        "memory_url": memory_url,
+        "memory_path": memory_path,
         "providers": providers,
         "models": models,
         "MAX_COMPACT_TOKENS": 190000,
@@ -384,19 +384,15 @@ def run_init(config_dir: Path, yes: bool = False):
     available_services = compose_template.get("services", {})
     active_services: dict[str, Any] = {}
 
-    # crow-memory is always included — it's the persistence layer
-    if "crow-memory" in available_services:
-        active_services["crow-memory"] = available_services["crow-memory"]
-
     if setup_searxng and "searxng" in available_services:
         active_services["searxng"] = available_services["searxng"]
 
+    compose_file = config_dir / "compose.yaml"
     if active_services:
         compose_data: dict[str, Any] = {
             "services": active_services,
             "volumes": compose_template.get("volumes", {}),
         }
-        compose_file = config_dir / "compose.yaml"
         with open(compose_file, "w") as f:
             yaml.dump(compose_data, f, default_flow_style=False, sort_keys=False)
         console.print(f"[green]✓[/green] Written {compose_file}")
@@ -407,20 +403,17 @@ def run_init(config_dir: Path, yes: bool = False):
     # =========================================================================
     # STEP 5: Start services (just instructions)
     # =========================================================================
-    console.print("\n[bold cyan]═══ Step 5: Start Services ═══[/bold cyan]\n")
-
-    services_list = ["crow-memory"]
-    if setup_searxng:
-        services_list.append("SearXNG")
-
-    console.print(
-        Panel(
-            f"[bold white]cd {config_dir} && docker compose up -d[/bold white]\n\n"
-            f"[dim]Starts: {', '.join(services_list)}[/dim]",
-            title="[yellow]Start " + " + ".join(services_list) + "[/yellow]",
-            border_style="yellow",
+    if active_services:
+        console.print("\n[bold cyan]═══ Step 5: Start Services ═══[/bold cyan]\n")
+        services_list = list(active_services.keys())
+        console.print(
+            Panel(
+                f"[bold white]cd {config_dir} && docker compose up -d[/bold white]\n\n"
+                f"[dim]Starts: {', '.join(services_list)}[/dim]",
+                title="[yellow]Start " + " + ".join(services_list) + "[/yellow]",
+                border_style="yellow",
+            )
         )
-    )
 
     # =========================================================================
     # Done
@@ -429,22 +422,19 @@ def run_init(config_dir: Path, yes: bool = False):
     system_prompt_dir = config_dir / "prompts"
 
     console.print()
-    console.print(
-        Panel.fit(
-            "[bold green]✓ Configuration complete![/bold green]\n\n"
-            f"Config:   [cyan]{config_file}[/cyan]\n"
-            f"Memory:   [cyan]{config_dir / 'memory.lance'}[/cyan]\n"
-            f"Logs:     [cyan]{config_logs}[/cyan]\n"
-            f"Prompt:   [cyan]{system_prompt_dir}/system_prompt.jinja2[/cyan]\n"
-            f"Secrets:  [cyan]{env_file}[/cyan]\n"
-            f"Compose:  [cyan]{compose_file}[/cyan]\n\n"
-            "[dim]Start services with:[/dim]\n"
-            f"    [bold red]cd {config_dir} && docker compose up -d[/bold red]\n"
-            f"[dim]Then to test:\n"
-            f'    [bold white]crow-cli run "hey"[/bold white]',
-            border_style="green",
-        )
-    )
+    done_lines = [
+        "[bold green]✓ Configuration complete![/bold green]\n",
+        f"Config:   [cyan]{config_file}[/cyan]",
+        f"Memory:   [cyan]{config_dir / 'memory.lance'}[/cyan] [dim](in-process, no service)[/dim]",
+        f"Logs:     [cyan]{config_logs}[/cyan]",
+        f"Prompt:   [cyan]{system_prompt_dir}/system_prompt.jinja2[/cyan]",
+        f"Secrets:  [cyan]{env_file}[/cyan]",
+    ]
+    if active_services:
+        done_lines.append(f"Compose:  [cyan]{compose_file}[/cyan]")
+        done_lines.append(f"\n[dim]Start services:[/dim] [bold red]cd {config_dir} && docker compose up -d[/bold red]")
+    done_lines.append(f'\n[dim]Test:[/dim] [bold white]crow-cli run "hey"[/bold white]')
+    console.print(Panel.fit("\n".join(done_lines), border_style="green"))
 
 
 # For typer integration