mycode-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/.pre-commit-config.yaml

@@ -27,4 +27,4 @@ repos:
       - id: biome-check
         additional_dependencies: ["@biomejs/biome@2.4.7"]
         args: ["--config-path=biome.json"]
-        files: ^frontend/
+        files: ^web/

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/AGENTS.md

@@ -27,8 +27,7 @@ Core runtime (`mycode/core/`):
 - `session.py` — append-only JSONL session storage, compact/rewind events, interrupted tool repair
 - `config.py` — layered config loading and provider resolution
 - `models.py` — bundled model metadata lookup (`context_window`, `supports_reasoning`, `supports_image_input`)
-- `system_prompt.py` — runtime system prompt assembly, AGENTS.md discovery, skills discovery
-- `system_prompt.md` — system prompt template
+- `system_prompt.py` — runtime system prompt assembly, inlined base prompt, AGENTS.md discovery, skills discovery
 - `providers/base.py` — ProviderAdapter abstract interface
 - `providers/__init__.py` — adapter registry and provider lookup helpers
 - `providers/anthropic_like.py` — adapters: `anthropic`, `moonshotai`, `minimax`

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Minimal coding agent with web UI
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/cli/render.py

@@ -106,6 +106,19 @@ _TOOL_PREVIEW_KEY: dict[str, str] = {
 }
 
 
+def _tool_preview(name: str, args: dict[str, Any]) -> str:
+    """Extract a one-line preview string for a tool call."""
+
+    if not args:
+        return ""
+    key = _TOOL_PREVIEW_KEY.get(name.lower())
+    raw = args.get(key) if key else next(iter(args.values()), "")
+    preview = str(raw or "")
+    if len(preview) > 60:
+        preview = preview[:60] + "…"
+    return preview
+
+
 def format_local_timestamp(value: str, display_format: str) -> str:
     """Format an ISO timestamp with a simple local fallback."""
 
@@ -199,14 +212,7 @@ class TerminalView:
                     self.console.print(_LeftMarkdown(str(content), code_theme=CODE_THEME))
                 else:
                     name, args = content
-                    preview = ""
-                    if isinstance(args, dict) and args:
-                        key = _TOOL_PREVIEW_KEY.get(name.lower())
-                        raw = args.get(key) if key else next(iter(args.values()), "")
-                        preview = str(raw or "")
-                        if len(preview) > 60:
-                            preview = preview[:60] + "…"
-
+                    preview = _tool_preview(name, args if isinstance(args, dict) else {})
                     line = Text()
                     line.append(f"{TOOL_MARKER} ", style=SUCCESS)
                     line.append(name.capitalize(), style=TOOL_NAME)
@@ -356,6 +362,7 @@ class ReplyRenderer:
         self._tool_name: str = ""
         self._tool_args: dict[str, Any] = {}
         self._tool_buffered = False
+        self._tool_live: Live | None = None
         self._usage: dict[str, Any] | None = None
 
     async def render(
@@ -446,13 +453,21 @@ class ReplyRenderer:
         self._tool_name = name
         self._tool_args = args
 
-        # Bash streams output — print header immediately.
-        # Other tools are fast — defer to tool_done for single-line display.
         if name.lower() == "bash":
+            # Bash streams output — print header immediately.
             self._print_tool_header(name, args)
             self._tool_buffered = False
         else:
+            # Other tools are fast — show spinner until tool_done.
             self._tool_buffered = True
+            if self._live_mode:
+                self._tool_live = Live(
+                    self._build_tool_spinner(name, args),
+                    console=self._console,
+                    refresh_per_second=12,
+                    transient=True,
+                )
+                self._tool_live.start()
 
     def tool_output(self, line: str) -> None:
         """Render one streamed output line from a running tool."""
@@ -476,14 +491,14 @@ class ReplyRenderer:
         duration = f"{elapsed:.1f}s" if elapsed >= 0.5 else ""
 
         if self._tool_buffered:
-            # Non-streaming tools (read, write, edit): single-line output
+            self._stop_tool_live()
             self._tool_buffered = False
             if is_error:
                 self._print_tool_header(self._tool_name, self._tool_args)
                 first_line = shown_text.split("\n", 1)[0][:100]
                 self._console.print(Text(f"    {first_line}", style=ERROR))
             else:
-                suffix = self._format_edit_suffix(self._tool_name, self._tool_args)
+                suffix = self._format_tool_suffix(self._tool_name, self._tool_args, duration)
                 self._print_tool_header(self._tool_name, self._tool_args, suffix=suffix)
         else:
             # Bash: streaming tool
@@ -511,13 +526,7 @@ class ReplyRenderer:
     ) -> None:
         """Print the ``⏺ Name  preview  [suffix]`` tool header line."""
 
-        preview = ""
-        if args:
-            key = _TOOL_PREVIEW_KEY.get(name.lower())
-            raw = args.get(key) if key else next(iter(args.values()), "")
-            preview = str(raw or "")
-            if len(preview) > 60:
-                preview = preview[:60] + "…"
+        preview = _tool_preview(name, args)
 
         text = Text()
         text.append(f"{TOOL_MARKER} ", style=SUCCESS)
@@ -529,34 +538,66 @@ class ReplyRenderer:
             text.append_text(suffix)
         self._console.print(text)
 
+    def _build_tool_spinner(self, name: str, args: dict[str, Any]) -> Spinner:
+        """Build a transient spinner shown while a buffered tool runs."""
+
+        preview = _tool_preview(name, args)
+        label = Text()
+        label.append(f" {name.capitalize()}", style=TOOL_NAME)
+        if preview:
+            label.append(f"  {preview}", style=MUTED)
+        return Spinner("dots", text=label, style="dim")
+
+    def _stop_tool_live(self) -> None:
+        if self._tool_live is not None:
+            self._tool_live.stop()
+            self._tool_live = None
+
     @staticmethod
-    def _format_edit_suffix(name: str, args: dict[str, Any]) -> Text | None:
-        """Return the real added/removed line counts for one edit call."""
-
-        if name.lower() != "edit":
-            return None
-
-        old_text = args.get("oldText")
-        new_text = args.get("newText")
-        if not isinstance(old_text, str) or not isinstance(new_text, str):
-            return None
-
-        added = 0
-        removed = 0
-        for tag, old_start, old_end, new_start, new_end in SequenceMatcher(
-            None,
-            old_text.splitlines(),
-            new_text.splitlines(),
-        ).get_opcodes():
-            if tag in {"replace", "delete"}:
-                removed += old_end - old_start
-            if tag in {"replace", "insert"}:
-                added += new_end - new_start
-
-        suffix = Text()
-        suffix.append(f"+{added}", style="green")
-        suffix.append(f" −{removed}", style="red")
-        return suffix
+    def _format_tool_suffix(name: str, args: dict[str, Any], duration: str) -> Text | None:
+        """Build the inline suffix shown after the tool preview on success."""
+
+        parts = Text()
+        lower = name.lower()
+
+        if lower == "edit":
+            old_text = args.get("oldText")
+            new_text = args.get("newText")
+            if isinstance(old_text, str) and isinstance(new_text, str):
+                added = 0
+                removed = 0
+                for tag, old_start, old_end, new_start, new_end in SequenceMatcher(
+                    None,
+                    old_text.splitlines(),
+                    new_text.splitlines(),
+                ).get_opcodes():
+                    if tag in {"replace", "delete"}:
+                        removed += old_end - old_start
+                    if tag in {"replace", "insert"}:
+                        added += new_end - new_start
+                parts.append(f"+{added}", style="green")
+                parts.append(f" −{removed}", style="red")
+        elif lower == "read":
+            offset = args.get("offset")
+            limit = args.get("limit")
+            if isinstance(offset, int) and isinstance(limit, int):
+                parts.append(f":{offset}-{offset + limit}", style=MUTED)
+            elif isinstance(offset, int):
+                parts.append(f":{offset}", style=MUTED)
+            elif isinstance(limit, int):
+                parts.append(f":1-{limit}", style=MUTED)
+        elif lower == "write":
+            content = args.get("content")
+            if isinstance(content, str):
+                lines = content.count("\n") + 1
+                parts.append(f"({lines} lines)", style=MUTED)
+
+        if duration:
+            if parts.plain:
+                parts.append(" · ", style=MUTED)
+            parts.append(duration, style=MUTED)
+
+        return parts if parts.plain else None
 
     def compact(self, message: str) -> None:
         """Render a context compaction notification."""
@@ -663,6 +704,7 @@ class ReplyRenderer:
         if self._live is not None:
             self._live.stop()
             self._live = None
+        self._stop_tool_live()
         self._reasoning.clear()
         self._text.clear()
         self._printed_static_reasoning = False

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/agent.py

@@ -241,7 +241,7 @@ class Agent:
                 if self._cancel_event.is_set():
                     raise asyncio.CancelledError
 
-                self._provider_event_task = asyncio.ensure_future(anext(provider_stream))
+                self._provider_event_task = asyncio.create_task(anext(provider_stream))
                 try:
                     yield await self._provider_event_task
                 except StopAsyncIteration:
@@ -384,24 +384,20 @@ class Agent:
                     if event.type != "tool_done":
                         continue
 
-                    result_data = event.data
-                    result_tool_id = str(result_data.get("tool_use_id") or "")
-                    result_model_text = str(result_data.get("model_text") or "")
-                    result_display_text = str(result_data.get("display_text") or "")
-                    result_is_error = bool(result_data.get("is_error"))
-                    result_content = result_data.get("content")
+                    d = event.data
+                    model_text = str(d.get("model_text") or "")
+                    content = d.get("content")
                     tool_results.append(
                         tool_result_block(
-                            tool_use_id=result_tool_id,
-                            model_text=result_model_text,
-                            display_text=result_display_text,
-                            is_error=result_is_error,
-                            content=result_content if isinstance(result_content, list) else None,
+                            tool_use_id=str(d.get("tool_use_id") or ""),
+                            model_text=model_text,
+                            display_text=str(d.get("display_text") or ""),
+                            is_error=bool(d.get("is_error")),
+                            content=content if isinstance(content, list) else None,
                         )
                     )
 
-                    tool_was_cancelled = result_model_text == "error: cancelled"
-                    if tool_was_cancelled and self._cancel_event.is_set():
+                    if model_text == "error: cancelled" and self._cancel_event.is_set():
                         tool_result_message = build_message("user", tool_results)
                         self.messages.append(tool_result_message)
                         if on_persist:

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/config.py

@@ -13,7 +13,7 @@ import json
 import logging
 import os
 import re
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
@@ -27,6 +27,7 @@ from mycode.core.providers import (
     provider_default_models,
     provider_env_api_key_names,
 )
+from mycode.core.utils import as_bool, as_int
 
 _DEFAULT_MYCODE_HOME = "~/.mycode"
 _API_KEY_ENV_REF_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
@@ -133,19 +134,11 @@ def _normalize_models(value: Any) -> dict[str, ModelConfig]:
             models[model_id] = raw
             continue
         raw_config = raw if isinstance(raw, dict) else {}
-        context_window = raw_config.get("context_window")
-        max_output_tokens = raw_config.get("max_output_tokens")
-        supports_reasoning = raw_config.get("supports_reasoning")
-        supports_image_input = raw_config.get("supports_image_input")
         models[model_id] = ModelConfig(
-            context_window=(
-                context_window if isinstance(context_window, int) and not isinstance(context_window, bool) else None
-            ),
-            max_output_tokens=max_output_tokens
-            if isinstance(max_output_tokens, int) and not isinstance(max_output_tokens, bool)
-            else None,
-            supports_reasoning=supports_reasoning if isinstance(supports_reasoning, bool) else None,
-            supports_image_input=supports_image_input if isinstance(supports_image_input, bool) else None,
+            context_window=as_int(raw_config.get("context_window")),
+            max_output_tokens=as_int(raw_config.get("max_output_tokens")),
+            supports_reasoning=as_bool(raw_config.get("supports_reasoning")),
+            supports_image_input=as_bool(raw_config.get("supports_image_input")),
         )
     return models
 
@@ -348,7 +341,7 @@ def resolve_provider(
             api_base=api_base,
         )
 
-    for available_name, _provider in _available_provider_references(settings):
+    for available_name, _ in _available_provider_references(settings):
         return _resolve_provider_runtime(
             settings,
             selected_name=available_name,
@@ -373,7 +366,7 @@ def resolve_provider_choices(settings: Settings) -> list[ResolvedProvider]:
     """Return currently selectable providers in stable selection order."""
 
     choices: list[ResolvedProvider] = []
-    for selected_name, _provider in _available_provider_references(settings):
+    for selected_name, _ in _available_provider_references(settings):
         try:
             choices.append(_resolve_provider_runtime(settings, selected_name=selected_name))
         except ValueError:
@@ -455,9 +448,7 @@ def _resolve_provider_runtime(
     resolved_api_base = api_base or (provider_config.base_url if provider_config else None)
     model_metadata = lookup_model_metadata(
         provider_type=provider_type,
-        provider_name=selected_name,
         model=resolved_model,
-        api_base=resolved_api_base,
     )
     if provider_config:
         model_config = provider_config.models.get(resolved_model)
@@ -472,29 +463,21 @@ def _resolve_provider_runtime(
                     supports_image_input=model_config.supports_image_input,
                 )
             else:
-                model_metadata = ModelMetadata(
-                    provider=model_metadata.provider,
-                    model=model_metadata.model,
-                    context_window=(
-                        model_config.context_window
-                        if model_config.context_window is not None
-                        else model_metadata.context_window
-                    ),
-                    max_output_tokens=(
-                        model_config.max_output_tokens
-                        if model_config.max_output_tokens is not None
-                        else model_metadata.max_output_tokens
-                    ),
-                    supports_reasoning=(
-                        model_config.supports_reasoning
-                        if model_config.supports_reasoning is not None
-                        else model_metadata.supports_reasoning
-                    ),
-                    supports_image_input=(
-                        model_config.supports_image_input
-                        if model_config.supports_image_input is not None
-                        else model_metadata.supports_image_input
-                    ),
+                # Per-field: use the config override when set, keep catalog value otherwise.
+                model_metadata = replace(
+                    model_metadata,
+                    context_window=model_config.context_window
+                    if model_config.context_window is not None
+                    else model_metadata.context_window,
+                    max_output_tokens=model_config.max_output_tokens
+                    if model_config.max_output_tokens is not None
+                    else model_metadata.max_output_tokens,
+                    supports_reasoning=model_config.supports_reasoning
+                    if model_config.supports_reasoning is not None
+                    else model_metadata.supports_reasoning,
+                    supports_image_input=model_config.supports_image_input
+                    if model_config.supports_image_input is not None
+                    else model_metadata.supports_image_input,
                 )
 
     configured_effort = settings.default_reasoning_effort

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/models.py

@@ -2,15 +2,15 @@
 
 from __future__ import annotations
 
+import functools
 import json
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-_MODELS_CATALOG_PATH = Path(__file__).with_name("models_catalog.json")
+from mycode.core.utils import as_bool, as_int
 
-_models_catalog_cache: dict[str, Any] | None = None
-_models_catalog_loaded = False
+_MODELS_CATALOG_PATH = Path(__file__).with_name("models_catalog.json")
 
 
 @dataclass(frozen=True)
@@ -25,30 +25,21 @@ class ModelMetadata:
     supports_image_input: bool | None
 
 
+@functools.cache
 def load_models_catalog() -> dict[str, Any] | None:
     """Load the bundled model catalog from disk once per process."""
 
-    global _models_catalog_cache, _models_catalog_loaded
-
-    if _models_catalog_loaded:
-        return _models_catalog_cache
-
     try:
         data = json.loads(_MODELS_CATALOG_PATH.read_text(encoding="utf-8"))
     except Exception:
         data = None
-
-    _models_catalog_cache = data if isinstance(data, dict) else None
-    _models_catalog_loaded = True
-    return _models_catalog_cache
+    return data if isinstance(data, dict) else None
 
 
 def lookup_model_metadata(
     *,
     provider_type: str | None,
     model: str | None,
-    provider_name: str | None = None,  # reserved for future per-alias lookup
-    api_base: str | None = None,  # reserved for future custom-endpoint lookup
 ) -> ModelMetadata | None:
     """Resolve metadata for one internal provider type and model."""
 
@@ -96,19 +87,15 @@ def _lookup_entry(
     return ModelMetadata(
         provider=provider_type,
         model=model_id,
-        context_window=_as_int(raw_model.get("context_window")),
-        max_output_tokens=_as_int(raw_model.get("max_output_tokens")),
-        supports_reasoning=raw_model.get("supports_reasoning")
-        if isinstance(raw_model.get("supports_reasoning"), bool)
-        else None,
-        supports_image_input=raw_model.get("supports_image_input")
-        if isinstance(raw_model.get("supports_image_input"), bool)
-        else None,
+        context_window=as_int(raw_model.get("context_window")),
+        max_output_tokens=as_int(raw_model.get("max_output_tokens")),
+        supports_reasoning=as_bool(raw_model.get("supports_reasoning")),
+        supports_image_input=as_bool(raw_model.get("supports_image_input")),
     )
 
 
 def _default_provider(model_id: str) -> str | None:
-    """Return the canonical internal provider type for a normalized model id."""
+    """Return the canonical internal provider type for a well-known model id."""
 
     normalized = model_id.lower()
     if normalized.startswith("claude-"):
@@ -134,11 +121,3 @@ def _strip_prefix(model_id: str) -> str:
     if "/" not in model_id:
         return model_id
     return model_id.split("/", 1)[1].strip()
-
-
-def _as_int(value: Any) -> int | None:
-    """Return an int value while rejecting bools and non-ints."""
-
-    if isinstance(value, bool) or not isinstance(value, int):
-        return None
-    return value

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/providers/openai_chat.py

@@ -19,7 +19,7 @@ from mycode.core.providers.base import (
     get_native_meta,
     load_image_block_payload,
 )
-from mycode.core.tools import parse_tool_arguments
+from mycode.core.utils import parse_tool_arguments
 
 
 @dataclass

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/providers/openai_responses.py

@@ -19,7 +19,7 @@ from mycode.core.providers.base import (
     load_image_block_payload,
     tool_result_content_blocks,
 )
-from mycode.core.tools import parse_tool_arguments
+from mycode.core.utils import parse_tool_arguments
 
 
 class OpenAIResponsesAdapter(ProviderAdapter):

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/session.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import shutil
 from dataclasses import asdict, dataclass, field
 from datetime import UTC, datetime
 from pathlib import Path
@@ -315,42 +316,6 @@ class SessionStore:
         sessions = await self.list_sessions(cwd=cwd)
         return sessions[0] if sessions else None
 
-    async def load_session(self, session_id: str) -> dict | None:
-        def load() -> dict | None:
-            meta = self._read_meta(session_id)
-            if meta is None:
-                return None
-
-            # Read the raw append-only log first. Replay happens after that.
-            raw_messages: list[dict] = []
-            messages_path = self.messages_path(session_id)
-            try:
-                with messages_path.open("r", encoding="utf-8") as handle:
-                    for line in handle:
-                        line = line.strip()
-                        if not line:
-                            continue
-                        try:
-                            msg = json.loads(line)
-                            if isinstance(msg, dict):
-                                raw_messages.append(msg)
-                        except Exception:
-                            continue
-            except FileNotFoundError:
-                pass
-
-            # Replay order defines the visible conversation state.
-            # 1) compact rewrites older history into one summary view
-            # 2) rewind truncates that visible list by message index
-            # 3) interrupted tool repair patches the final visible state
-            visible_messages = apply_compact(raw_messages)
-            visible_messages = apply_rewind(visible_messages)
-            self._repair_interrupted_tool_loop(session_id, meta, visible_messages)
-
-            return {"session": meta, "messages": visible_messages}
-
-        return await asyncio.to_thread(load)
-
     def _repair_interrupted_tool_loop(self, session_id: str, meta: dict, messages: list[dict]) -> None:
         """Append a synthetic tool result when the latest tool loop was interrupted.
 
@@ -388,7 +353,7 @@ class SessionStore:
         if pending_tool_call_index is None:
             return
 
-        # Then collect tool results that were actually recorded after it.
+        # Collect tool results that were recorded after the assistant message.
         completed_tool_use_ids: set[str] = set()
         for message in messages[pending_tool_call_index + 1 :]:
             if message.get("role") != "user":
@@ -432,24 +397,47 @@ class SessionStore:
         self._write_meta(session_id, meta)
         messages.append(repair_message)
 
+    async def load_session(self, session_id: str) -> dict | None:
+        def load() -> dict | None:
+            meta = self._read_meta(session_id)
+            if meta is None:
+                return None
+
+            # Read the raw append-only log first. Replay happens after that.
+            raw_messages: list[dict] = []
+            messages_path = self.messages_path(session_id)
+            try:
+                with messages_path.open("r", encoding="utf-8") as handle:
+                    for line in handle:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            msg = json.loads(line)
+                            if isinstance(msg, dict):
+                                raw_messages.append(msg)
+                        except Exception:
+                            continue
+            except FileNotFoundError:
+                pass
+
+            # Replay order defines the visible conversation state.
+            # 1) compact rewrites older history into one summary view
+            # 2) rewind truncates that visible list by message index
+            # 3) interrupted tool repair patches the final visible state
+            visible_messages = apply_compact(raw_messages)
+            visible_messages = apply_rewind(visible_messages)
+            self._repair_interrupted_tool_loop(session_id, meta, visible_messages)
+
+            return {"session": meta, "messages": visible_messages}
+
+        return await asyncio.to_thread(load)
+
     async def delete_session(self, session_id: str) -> None:
         def delete() -> None:
             sdir = self.session_dir(session_id)
-            if not sdir.exists():
-                return
-            # small recursive delete (no shutil.rmtree to keep deps minimal)
-            for p in sorted(sdir.rglob("*"), reverse=True):
-                try:
-                    if p.is_file() or p.is_symlink():
-                        p.unlink(missing_ok=True)
-                    elif p.is_dir():
-                        p.rmdir()
-                except Exception:
-                    pass
-            try:
-                sdir.rmdir()
-            except Exception:
-                pass
+            if sdir.exists():
+                shutil.rmtree(sdir, ignore_errors=True)
 
         await asyncio.to_thread(delete)
 

{mycode_cli-0.1.1 → mycode_cli-0.1.2}/mycode/core/system_prompt.py

@@ -2,7 +2,7 @@
 
 This module owns the full runtime system prompt:
 
-- base prompt text from ``system_prompt.md``
+- base prompt text (inlined below as _BASE_PROMPT)
 - workspace instructions from AGENTS.md
 - available skills from SKILL.md files
 """
@@ -27,6 +27,19 @@ _SKIP_DIRS = frozenset({"node_modules", "__pycache__", ".git"})
 _NAME_RE = re.compile(r"^[a-zA-Z0-9_-]+$")
 _NAME_MAX_LEN = 64
 
+_BASE_PROMPT = """\
+You are mycode, an expert coding assistant.
+
+You have four tools: read, write, edit, bash.
+
+- Use bash for file operations and exploration like `ls`, `find`, `rg`, etc.
+- Always set offset/limit when reading large files.
+- Always read files before editing them.
+- Use write only for new files or complete rewrites
+- Your response should be concise and relevant.
+- When available skills match the current task, prefer them over manual alternatives. To use a skill: read its `SKILL.md`, then follow the instructions inside.\
+"""
+
 
 # ---------------------------------------------------------------------
 # Full system prompt assembly
@@ -39,12 +52,7 @@ def build_system_prompt(cwd: str, settings: Settings | None = None) -> str:
     resolved_cwd = str(Path(cwd).resolve(strict=False))
     resolved_settings = settings or get_settings(resolved_cwd)
 
-    try:
-        base_prompt = (Path(__file__).resolve().parent / "system_prompt.md").read_text(encoding="utf-8").strip()
-    except Exception:
-        base_prompt = "You are mycode, an expert coding assistant."
-
-    parts = [base_prompt]
+    parts = [_BASE_PROMPT]
 
     instructions_prompt = load_instructions_prompt(resolved_cwd, resolved_settings)
     if instructions_prompt: