cade-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{cade_cli-0.8.0 → cade_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: Cade - The CLI Agent from Arcade.dev
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://docs.arcade.dev
@@ -57,6 +57,7 @@ Requires-Dist: pydantic[email]<3.0.0,>=2.0.0
 Requires-Dist: pyperclip<2.0.0,>=1.8.0
 Requires-Dist: pyyaml<7.0.0,>=6.0
 Requires-Dist: rich<14.0.0,>=13.0.0
+Requires-Dist: sounddevice>=0.5.5
 Requires-Dist: tiktoken<1.0.0,>=0.11.0
 Requires-Dist: toml<1.0.0,>=0.10.0
 Requires-Dist: typer>0.10.0

{cade_cli-0.8.0 → cade_cli-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.8.0"
+version = "0.9.0"
 description = "Cade - The CLI Agent from Arcade.dev"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -41,6 +41,7 @@ dependencies = [
     "httpx>=0.27.0,<1.0.0",
     "filelock>=3.0.0,<4.0.0",
     "agent-library>=0.11.0,<1.0.0",
+    "sounddevice>=0.5.5",
 ]
 
 [project.urls]
@@ -103,6 +104,10 @@ target-version = "py311"
 select = ["E", "F", "W", "I", "UP"]
 ignore = ["E501"]
 
+[tool.ruff.lint.per-file-ignores]
+# Imports must come after os.environ and warnings setup at module top
+"src/cadecoder/cli/app.py" = ["E402"]
+
 [tool.ruff.format]
 quote-style = "double"
 

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cade_mcp_local/__init__.py

@@ -69,4 +69,4 @@ __all__ = [
     "FileOperationError",
 ]
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cade_mcp_local/server.py

@@ -18,6 +18,7 @@ from cade_mcp_local.tools import (
     edit_tool,
     git_tool,
     list_files_tool,
+    pin_context_tool,
     read_file_tool,
     retrieve_tool_result_tool,
     search_recent_context_tool,
@@ -67,6 +68,9 @@ def create_app() -> MCPApp:
     # Context tools
     app.add_tool(search_recent_context_tool)
 
+    # Pinned context
+    app.add_tool(pin_context_tool)
+
     # Tool result retrieval (consolidated: full, search, summarize, lines, json, list)
     app.add_tool(retrieve_tool_result_tool)
 

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cade_mcp_local/tools/__init__.py

@@ -20,6 +20,7 @@ from cade_mcp_local.tools.git import (
 )
 from cade_mcp_local.tools.search import search_tool
 from cade_mcp_local.tools.shell import bash_tool
+from cade_mcp_local.tools.snippets import pin_context_tool
 from cade_mcp_local.tools.tool_results import retrieve_tool_result_tool
 from cade_mcp_local.tools.tool_schemas import tool_schema_tool
 
@@ -40,6 +41,8 @@ __all__ = [
     "bash_tool",
     # Context
     "search_recent_context_tool",
+    # Pinned context
+    "pin_context_tool",
     # Tool Results
     "retrieve_tool_result_tool",
     # Tool Schemas

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cade_mcp_local/tools/filesystem.py

@@ -173,6 +173,8 @@ def read_file_tool(
     ] = 0,
 ) -> Annotated[dict[str, Any], "File content, line numbers, and message."]:
     """Read content of a specified file, optionally a specific line range."""
+    if not file_path_arg:
+        raise InvalidInputError("file_path_arg", "file path is required")
     file_path = resolve_path(file_path_arg, confine_to_root=True)
 
     if not file_path.is_file():
@@ -257,6 +259,8 @@ def write_file_tool(
     ] = "overwrite",
 ) -> Annotated[dict[str, Any], "Result of the write operation."]:
     """Write content to a file."""
+    if not file_path_arg:
+        raise InvalidInputError("file_path_arg", "file path is required")
     resolved = resolve_path(file_path_arg)
 
     try:
@@ -301,6 +305,8 @@ def edit_tool(
     ],
 ) -> Annotated[dict[str, Any], "Edit result with diff."]:
     """Find old_string in the file and replace it with new_string."""
+    if not file_path_arg:
+        raise InvalidInputError("file_path_arg", "file path is required")
     resolved = resolve_path(file_path_arg)
 
     if not resolved.is_file():
@@ -375,6 +381,8 @@ def insert_text_tool(
     ] = "before",
 ) -> Annotated[dict[str, Any], "Insert result with diff."]:
     """Insert text at a specific line in a file."""
+    if not file_path_arg:
+        raise InvalidInputError("file_path_arg", "file path is required")
     resolved = resolve_path(file_path_arg)
 
     if not resolved.is_file():

cade_cli-0.9.0/src/cade_mcp_local/tools/snippets.py

@@ -0,0 +1,109 @@
+"""MCP tool for pinning named context to a session."""
+
+import logging
+import re
+from typing import Annotated, Any
+
+from arcade_tdk import ToolContext, tool
+
+from cade_mcp_local.errors import InvalidInputError, PathNotFoundError
+from cade_mcp_local.utils import resolve_path
+
+log = logging.getLogger(__name__)
+
+MAX_PIN_BYTES = 100_000  # 100KB cap
+PREVIEW_CHARS = 2000
+
+
+@tool(
+    name="PinContext",
+    desc=(
+        "Pin named reference material to the current session. The user can later "
+        "ask about it and you can retrieve the full content via RetrieveToolResult. "
+        "Use when the user provides specs, docs, notes, or other material they want "
+        "you to remember. Provide either content (inline text) or file_path (read from file)."
+    ),
+)
+def pin_context_tool(
+    context: ToolContext,
+    name: Annotated[
+        str,
+        "Short identifier for this context (e.g., 'api-spec', 'design-notes'). "
+        "Letters, numbers, hyphens, underscores only.",
+    ],
+    thread_id: Annotated[str, "The current thread/session ID."],
+    content: Annotated[
+        str,
+        "The text content to pin. Provide this OR file_path, not both.",
+    ] = "",
+    file_path: Annotated[
+        str,
+        "Path to a file to read and pin. Relative to project root.",
+    ] = "",
+) -> Annotated[dict[str, Any], "Pin result with preview."]:
+    """Pin named reference material to the session."""
+    if not name or not re.match(r"^[a-zA-Z0-9_-]+$", name):
+        raise InvalidInputError("name", "must be alphanumeric with hyphens/underscores only")
+
+    if not thread_id:
+        raise InvalidInputError("thread_id", "thread ID is required")
+
+    source = "inline"
+    source_path = ""
+
+    if file_path and content:
+        raise InvalidInputError("content/file_path", "provide one or the other, not both")
+
+    if file_path:
+        resolved = resolve_path(file_path, confine_to_root=True)
+        if not resolved.is_file():
+            raise PathNotFoundError(file_path)
+        source = "file"
+        source_path = file_path
+        content = resolved.read_text(encoding="utf-8", errors="replace")
+
+    if not content or not content.strip():
+        raise InvalidInputError("content", "cannot be empty")
+
+    if len(content) > MAX_PIN_BYTES:
+        raise InvalidInputError("content", f"exceeds {MAX_PIN_BYTES // 1024}KB limit")
+
+    from cadecoder.execution.tool_result_store import ToolResultStore
+
+    store = ToolResultStore()
+
+    # Check for duplicate name
+    existing = store.get_user_context_by_name(thread_id, name)
+    if existing:
+        raise InvalidInputError(
+            "name",
+            f"'{name}' already pinned (id={existing.record_id}). Use /unpin to remove first.",
+        )
+
+    record = store.store_user_context(
+        thread_id=thread_id,
+        name=name,
+        content=content,
+        source=source,
+        source_path=source_path,
+    )
+
+    # Build preview
+    preview = content[:PREVIEW_CHARS]
+    if len(content) > PREVIEW_CHARS:
+        preview += f"\n... ({len(content) - PREVIEW_CHARS} more chars)"
+
+    return {
+        "status": "pinned",
+        "name": name,
+        "record_id": record.record_id,
+        "chars": len(content),
+        "source": source,
+        "source_path": source_path or None,
+        "preview": preview,
+        "message": (
+            f"Pinned as '{name}' ({len(content):,} chars). "
+            f'Use Local_RetrieveToolResult(record_id="{record.record_id}") '
+            f"for full content."
+        ),
+    }

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cade_mcp_local/tools/tool_results.py

@@ -41,6 +41,10 @@ def retrieve_tool_result_tool(
         "The record ID from the [EXTERNALIZED_RESULT] reference. "
         "Required for all modes except 'list'.",
     ] = "",
+    name: Annotated[
+        str,
+        "Name of a pinned context snippet (shorthand for looking up UserContext by name).",
+    ] = "",
     mode: Annotated[
         RetrieveMode,
         "Retrieval strategy: 'full' (raw, paginated), 'search' (regex/substring match), "
@@ -111,6 +115,7 @@ def retrieve_tool_result_tool(
             {
                 "record_id": r.record_id,
                 "tool_name": r.tool_name,
+                "name": r.name,
                 "summary": r.summary,
                 "content_chars": r.content_chars,
                 "content_token_estimate": r.content_token_estimate,
@@ -131,6 +136,14 @@ def retrieve_tool_result_tool(
             ),
         }
 
+    # -- name-based lookup for pinned context --
+    if name and not record_id:
+        named_record = store.get_user_context_by_name(thread_id, name)
+        if named_record:
+            record_id = named_record.record_id
+        else:
+            return {"error": f"No pinned context named '{name}' found."}
+
     # -- all other modes require record_id --
     if not record_id:
         return {

cade_cli-0.9.0/src/cadecoder/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.0"

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/ai/prompts.py

@@ -199,6 +199,7 @@ def build_system_prompt(
     persona_name: str | None = None,
     tools_list: str = "(Tools available - use tools to see list)",
     include_discovery: bool = False,
+    thread_id: str | None = None,
 ) -> str:
     """Build the final system prompt, optionally with a persona.
 
@@ -206,6 +207,7 @@ def build_system_prompt(
         persona_name: Name of persona to use (None = default Cade behavior)
         tools_list: Formatted list of available tools
         include_discovery: Whether to include the Arcade discovery section
+        thread_id: Current thread ID for loading pinned context index
 
     Returns:
         Complete system prompt string
@@ -226,40 +228,54 @@ def build_system_prompt(
         .replace("{_TOOL_DISCOVERY}", discovery_section)
     )
 
-    # If no persona, return the base prompt
-    if not persona_name:
-        return base_prompt
+    # Apply persona if specified
+    if persona_name:
+        try:
+            from cadecoder.storage.personas import get_persona_store
 
-    # Load persona from storage
-    try:
-        from cadecoder.storage.personas import get_persona_store
-
-        store = get_persona_store()
-        persona = store.find_persona(persona_name)
+            persona_store = get_persona_store()
+            persona = persona_store.find_persona(persona_name)
 
-        if not persona:
-            log.warning(f"Persona '{persona_name}' not found, using default prompt")
-            return base_prompt
+            if not persona:
+                log.warning(f"Persona '{persona_name}' not found, using default prompt")
+            else:
+                log.info(f"Using persona '{persona.name}' (replace_base={persona.replace_base})")
 
-        log.info(f"Using persona '{persona.name}' (replace_base={persona.replace_base})")
-
-        if persona.replace_base:
-            # Full replacement mode - persona prompt replaces the base entirely
-            # But we still provide environment context and tools for functionality
-            return f"""{persona.system_prompt}
+                if persona.replace_base:
+                    base_prompt = f"""{persona.system_prompt}
 
 {env_context}
 {discovery_section}
 Tools:
 {tools_list}"""
-        else:
-            # Prepend mode - persona instructions come first, then base prompt
-            return f"""{persona.system_prompt}
+                else:
+                    base_prompt = f"""{persona.system_prompt}
 
 ---
 
 {base_prompt}"""
 
-    except Exception as e:
-        log.error(f"Error loading persona '{persona_name}': {e}")
-        return base_prompt
+        except Exception as e:
+            log.error(f"Error loading persona '{persona_name}': {e}")
+
+    # Append pinned context index if any exists for this thread
+    if thread_id:
+        try:
+            from cadecoder.execution.tool_result_store import ToolResultStore
+
+            store = ToolResultStore()
+            snippets = store.list_user_context(thread_id)
+            if snippets:
+                lines = [
+                    "\n=== PINNED CONTEXT ===",
+                    "The user has pinned reference material for this session.",
+                    'Use Local_RetrieveToolResult(record_id="<id>") to read full content.',
+                    "Use Local_PinContext to save new material when the user asks.\n",
+                ]
+                for s in snippets:
+                    lines.append(f"- {s.name} [id={s.record_id}] ({s.content_chars:,} chars)")
+                base_prompt += "\n".join(lines)
+        except Exception as e:
+            log.warning(f"Failed to load pinned context index: {e}")
+
+    return base_prompt

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/cli/app.py

@@ -1,11 +1,26 @@
 """Main CLI application setup and entry point for CadeCoder."""
 
 import os
+import warnings
 
 # Set environment variable to disable tokenizers parallelism warning
 # This must be set before any imports that use tokenizers
 os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
 
+# Suppress pkg_resources deprecation warning from webrtcvad and other packages
+# that haven't migrated to importlib.resources yet.
+# This MUST be set before any imports that might trigger the warning.
+warnings.filterwarnings(
+    "ignore",
+    message=".*pkg_resources is deprecated.*",
+    category=DeprecationWarning,
+)
+warnings.filterwarnings(
+    "ignore",
+    message=".*Deprecated call to.*",
+    category=DeprecationWarning,
+)
+
 from typing import Annotated
 
 import typer
@@ -85,6 +100,14 @@ def main_callback(
             is_eager=True,
         ),
     ] = False,
+    voice: Annotated[
+        bool,
+        typer.Option(
+            "--voice",
+            "-V",
+            help="Enable voice mode (speak to chat, hear responses).",
+        ),
+    ] = False,
     persona: Annotated[
         str | None,
         typer.Option(
@@ -120,6 +143,7 @@ def main_callback(
         ctx: Typer context object
         verbose: Enable verbose logging if True
         resume_flag: Resume most recent thread if True
+        voice: Enable voice mode for the session
         persona: Persona name to use for the session
         message: Single message mode - process one message and exit
         version: Show version and exit if True
@@ -160,14 +184,12 @@ def main_callback(
 
     # Handle eager resume flag before default chat
     if resume_flag and ctx.invoked_subcommand is None:
-        # Invoke resume command directly with persona
-        chat.resume(persona=persona)
+        chat.resume(persona=persona, voice=voice)
         raise typer.Exit()
 
     # If no command was invoked (just "cade"), launch chat
     if ctx.invoked_subcommand is None:
-        # Import and run chat command directly with persona
-        chat.chat(persona=persona)
+        chat.chat(persona=persona, voice=voice)
 
 
 if __name__ == "__main__":

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/core/constants.py

@@ -80,8 +80,8 @@ UI_STYLE: Final[str] = os.environ.get("CADE_UI_STYLE", "minimal")  # Options: "m
 
 DEFAULT_STT_MODEL: Final[str] = "mlx-community/whisper-small-mlx"
 DEFAULT_TTS_MODEL: Final[str] = "mlx-community/Kokoro-82M-bf16"
-DEFAULT_TTS_VOICE: Final[str] = "af_heart"
-DEFAULT_TTS_SPEED: Final[float] = 1.0
+DEFAULT_TTS_VOICE: Final[str] = "af_bella"
+DEFAULT_TTS_SPEED: Final[float] = 1.3
 DEFAULT_VAD_AGGRESSIVENESS: Final[int] = 1  # 0-3, lower = more sensitive to speech
 DEFAULT_SILENCE_FRAMES: Final[int] = 50  # 50 * 30ms = 1.5s of non-speech before stop
 

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/execution/orchestrator.py

@@ -62,6 +62,18 @@ def create_orchestrator(
     Returns:
         Configured Orchestrator instance
     """
+    # Compute threads_dir and publish it as an env var BEFORE creating the
+    # composite tool manager or orchestrator — the MCP subprocess config
+    # captures env vars at construction time.
+    import os
+
+    persona_name = persona or "default"
+    persona_dir = Path(get_config().app_dir) / "memory" / persona_name
+    persona_dir.mkdir(parents=True, exist_ok=True)
+    threads_dir = persona_dir / "threads"
+    threads_dir.mkdir(exist_ok=True)
+    os.environ["CADE_TOOL_RESULT_DIR"] = str(threads_dir)
+
     if tool_manager is None:
         tool_manager = CompositeToolManager(local_only=local_only, persona=persona)
 
@@ -164,11 +176,10 @@ class Orchestrator:
         self._tools_cache: list[dict[str, Any]] | None = None
         self._tools_description_cache: str | None = None
 
-        # All per-thread storage lives under ~/.cadecoder/memory/{persona}/threads/
+        # Per-persona storage paths (tool results use CADE_TOOL_RESULT_DIR env var
+        # set by create_orchestrator; threads_dir still needed for ToolSchemaCache)
         persona_dir = Path(get_config().app_dir) / "memory" / self._persona
-        persona_dir.mkdir(parents=True, exist_ok=True)
         threads_dir = persona_dir / "threads"
-        threads_dir.mkdir(exist_ok=True)
 
         # Context window management — backups scoped to persona
         backup_dir = persona_dir / "context_backups"
@@ -176,8 +187,8 @@ class Orchestrator:
             model=self.default_model, backup_dir=backup_dir
         )
 
-        # Tool result store for externalizing large results
-        self.tool_result_store = ToolResultStore(storage_dir=threads_dir)
+        # Tool result store — uses CADE_TOOL_RESULT_DIR env var (set by create_orchestrator)
+        self.tool_result_store = ToolResultStore()
         self.context_manager.tool_result_store = self.tool_result_store
 
         # Per-thread cache for Arcade tool schemas
@@ -717,14 +728,16 @@ class Orchestrator:
                 and self.tool_manager.has_external_tools()
             )
 
-            # Get persona from context metadata
+            # Get persona and thread_id from context metadata
             persona_name = context.metadata.get("persona") if context.metadata else None
+            thread_id = context.metadata.get("thread_id") if context.metadata else None
 
             # Build system prompt using the persona-aware function
             system_content = build_system_prompt(
                 persona_name=persona_name,
                 tools_list=tools_list,
                 include_discovery=has_external,
+                thread_id=thread_id,
             )
 
             messages.append(

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/execution/tool_result_store.py

@@ -41,6 +41,7 @@ NEVER_EXTERNALIZE_TOOLS: frozenset[str] = frozenset(
         "Local_RetrieveToolResult",
         "Local_SearchRecentContext",
         "Local_ToolSchema",
+        "Local_PinContext",
     }
 )
 
@@ -73,6 +74,7 @@ class ToolResultRecord:
     summary: str
     status: str  # "success" | "error"
     turn_sequence: int  # index within the turn
+    name: str = ""  # human-readable label for UserContext records
 
     def to_json_line(self) -> str:
         """Serialize to a single JSON line (no embedded newlines)."""
@@ -82,6 +84,7 @@ class ToolResultRecord:
     def from_json_line(cls, line: str) -> ToolResultRecord:
         """Deserialize from a JSON line."""
         data = json.loads(line)
+        data.setdefault("name", "")  # backward compat
         return cls(**data)
 
 
@@ -136,6 +139,8 @@ class RetrieveMode(str, Enum):
 
 def _generate_summary(content: str, tool_name: str, status: str, max_len: int = 120) -> str:
     """Generate a brief plain-text summary for the LLM."""
+    if not content:
+        return f"(empty result from {tool_name})"
     if status == "error":
         # Extract HTTP status if present
         for code in ("404", "401", "403", "500", "502", "503"):
@@ -854,7 +859,13 @@ class ToolResultStore:
 
     def __init__(self, storage_dir: Path | None = None) -> None:
         if storage_dir is None:
-            storage_dir = Path.home() / ".cadecoder" / "tool_results"
+            import os
+
+            env_dir = os.environ.get("CADE_TOOL_RESULT_DIR")
+            if env_dir:
+                storage_dir = Path(env_dir)
+            else:
+                storage_dir = Path.home() / ".cadecoder" / "tool_results"
         self.storage_dir = storage_dir
 
         # In-memory session index: record_id -> ToolResultRecord
@@ -976,7 +987,7 @@ class ToolResultStore:
 
             result = tool_results[i]
             tc = tool_calls[i] if i < len(tool_calls) else {}
-            content = result.get("content", "")
+            content = result.get("content") or ""
             tool_name = tool_names[i]
             status = result.get("status", "success")
             tool_call_id = tc.get("id", "")
@@ -1073,6 +1084,82 @@ class ToolResultStore:
         results.sort(key=lambda r: r.record_id, reverse=True)
         return results[:limit]
 
+    # ------------------------------------------------------------------
+    # User context (pinned snippets)
+    # ------------------------------------------------------------------
+
+    def store_user_context(
+        self,
+        thread_id: str,
+        name: str,
+        content: str,
+        source: str = "inline",
+        source_path: str = "",
+    ) -> ToolResultRecord:
+        """Store user-pinned context as a record with tool_name='UserContext'."""
+        source_info = f": {source_path}" if source_path else ""
+        record = ToolResultRecord(
+            record_id=str(ulid()).lower(),
+            tool_call_id="",
+            tool_name="UserContext",
+            thread_id=thread_id,
+            timestamp=datetime.now(UTC).isoformat(),
+            content=content,
+            content_chars=len(content),
+            content_token_estimate=int(len(content) / 4),
+            summary=f"{name} ({source}{source_info}, {len(content)} chars)",
+            status="success",
+            turn_sequence=0,
+            name=name,
+        )
+        self.store_result(record)
+        return record
+
+    def list_user_context(self, thread_id: str) -> list[ToolResultRecord]:
+        """List pinned context for a thread (records where tool_name='UserContext')."""
+        all_records = self.list_by_thread(thread_id, limit=100)
+        return [r for r in all_records if r.tool_name == "UserContext"]
+
+    def get_user_context_by_name(self, thread_id: str, name: str) -> ToolResultRecord | None:
+        """Find a pinned context record by name."""
+        for r in self.list_user_context(thread_id):
+            if r.name == name:
+                return r
+        return None
+
+    def remove_user_context(self, thread_id: str, name: str) -> bool:
+        """Remove a pinned context record by name."""
+        record = self.get_user_context_by_name(thread_id, name)
+        if not record:
+            return False
+        self._index.pop(record.record_id, None)
+        if record.tool_call_id:
+            self._call_id_index.pop(record.tool_call_id, None)
+        self._rewrite_jsonl_without(thread_id, record.record_id)
+        return True
+
+    def _rewrite_jsonl_without(self, thread_id: str, exclude_record_id: str) -> None:
+        """Rewrite JSONL file excluding a specific record. Protected by filelock."""
+        if not self._disk_ok:
+            return
+        jsonl_path = self._thread_jsonl(thread_id)
+        if not jsonl_path.exists():
+            return
+        try:
+            from filelock import FileLock
+
+            lock = FileLock(str(self._thread_lock(thread_id)), timeout=10)
+            with lock:
+                kept = []
+                for record in self._iter_disk_records(thread_id):
+                    if record.record_id != exclude_record_id:
+                        kept.append(record.to_json_line())
+                with open(jsonl_path, "w", encoding="utf-8") as f:
+                    for line in kept:
+                        f.write(line + "\n")
+        except Exception as e:
+            log.warning(f"JSONL rewrite failed for thread {thread_id}: {e}")
+
     # ------------------------------------------------------------------
     # Cleanup
     # ------------------------------------------------------------------

{cade_cli-0.8.0 → cade_cli-0.9.0}/src/cadecoder/tools/manager/composite.py

@@ -59,6 +59,7 @@ class CompositeToolManager(ToolManager):
     def _create_local_tools_config(self) -> MCPServerConfig:
         """Create MCP config for built-in local tools via stdio."""
         import importlib.util
+        import os
 
         # Get the path without importing the module (which would trigger tool registration)
         spec = importlib.util.find_spec("cade_mcp_local.tools")
@@ -66,6 +67,16 @@ class CompositeToolManager(ToolManager):
             raise ImportError("Could not find cade_mcp_local.tools module")
         local_tools_dir = Path(spec.origin).parent
 
+        env: dict[str, str] = {
+            "LOGURU_LEVEL": "WARNING",
+            "CADE_PROJECT_ROOT": str(Path.cwd().resolve()),
+        }
+        # Forward tool result storage dir so MCP tools use the same
+        # persona-scoped location as the orchestrator.
+        tool_result_dir = os.environ.get("CADE_TOOL_RESULT_DIR")
+        if tool_result_dir:
+            env["CADE_TOOL_RESULT_DIR"] = tool_result_dir
+
         return MCPServerConfig(
             name="__builtin_local__",
             url="uv",
@@ -86,10 +97,7 @@ class CompositeToolManager(ToolManager):
             ],
             enabled=True,
             auth_type=MCPAuthType.NONE,
-            env={
-                "LOGURU_LEVEL": "WARNING",
-                "CADE_PROJECT_ROOT": str(Path.cwd().resolve()),
-            },
+            env=env,
             suppress_stderr=True,  # Avoid DEBUG "Added tool" spam in terminal
         )