deepparallel 0.5.5__tar.gz → 0.5.7__tar.gz

{deepparallel-0.5.5 → deepparallel-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.5
+Version: 0.5.7
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.5"
+__version__ = "0.5.7"

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/branding.py

@@ -373,12 +373,12 @@ def status_text(
     body.append(f"  {DOT} v{version}  {DOT} ", style=DIM)
     body.append("served via Crowe Logic\n", style=f"bold {CROWE_ACCENT}")
     body.append(f"{tool_count} tools", style=WHITE_HEX)
-    body.append(f" {DOT} 5,800+ MCP servers", style=DIM)
-    body.append(f"  {DOT} fusion: {fusion}\n", style=DIM)
+    body.append(f" {DOT} MCP registry (local + 5,800+)", style=DIM)
+    body.append(f"  {DOT} memory {DOT} fusion: {fusion}\n", style=DIM)
     body.append("Backend: ", style=DIM)
     body.append(f"{backend_label}\n\n", style="white")
     body.append("/help", style="bold")
-    body.append("  /tools  /fast //deep //fuse  ", style=DIM)
+    body.append("  /tools  /memory  /cockpit  /fast //deep //fuse  ", style=DIM)
     body.append("/quit", style="bold")
     return _gutter(body)
 

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/cli.py

@@ -45,7 +45,7 @@ from deepparallel.config import (
     missing_required,
     resolve_settings,
 )
-from deepparallel import licensing, supply_chain
+from deepparallel import licensing, memory, supply_chain
 from deepparallel.fusion import (
     EscalationBackend,
     ReasonAnswerBackend,
@@ -177,6 +177,11 @@ def _build_guardian(settings: Settings) -> Backend | None:
     return backend_for_deployment(settings, settings.guardian_deployment)
 
 
+def _system_prompt() -> str:
+    """System prompt with the long-term memory index injected (recall tier 1)."""
+    return load_system_prompt() + memory.index_block()
+
+
 def _make_renderer(*, force_plain: bool, assume_yes: bool = False) -> Renderer:
     plain = force_plain or _bool_env("DEEPPARALLEL_PLAIN", False) or not sys.stdout.isatty()
     if plain:
@@ -233,7 +238,7 @@ def _stream_once(backend: Backend, settings: Settings, messages: list[dict]) ->
 
 def _stream_repl(backend: Backend, settings: Settings) -> None:
     """Plain-chat interactive loop (no tools)."""
-    system = load_system_prompt()
+    system = _system_prompt()
     history: list[tuple[str, str]] = []
     while True:
         try:
@@ -289,7 +294,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     (/fast //fuse //escalate //deep) swaps the active fusion mode live."""
     registry = get_registry()
     guardian = _build_guardian(settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages: list[dict] = [{"role": "system", "content": system}]
     mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
     deep_next = False
@@ -315,7 +320,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
             break
         if user_msg == "/help":
             branding.info(
-                "/quit · /reset · /info · /tools · /auto · /cockpit · /fast //fuse //escalate //deep · prompt"
+                "/quit · /reset · /info · /tools · /auto · /memory · /cockpit · /fast //fuse //escalate //deep · prompt"
             )
             continue
         if user_msg in {"/auto", "/yes"}:
@@ -354,6 +359,15 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 cockpit.status("done", "cockpit complete")
                 branding.info("cockpit OFF.")
             continue
+        if user_msg == "/memory":
+            mems = memory.list_memories()
+            if mems:
+                branding.info(f"{len(mems)} memories saved. Most recent:")
+                for m in mems[-8:]:
+                    console.print(f"  [dim]-[/] {m['name']}: {m['description'][:64]}")
+            else:
+                branding.info("no memories yet; the agent saves them with the remember tool.")
+            continue
 
         messages.append({"role": "user", "content": user_msg})
         if deep_next:
@@ -482,7 +496,7 @@ def run(
     if fuse is not None:
         settings = replace(settings, fusion_mode=fuse)
     backend = _require_ready(settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     if deep:
         _run_deep(settings, messages)
@@ -530,7 +544,7 @@ def cockpit(ctx: click.Context, assume_yes: bool, prompt: tuple[str, ...]) -> No
     cp.status("start", "cockpit online")
     cp.ensure_panel()
     backend = _wrap_fusion(backend, settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     renderer = _make_renderer(force_plain=False, assume_yes=settings.auto_approve)
     try:

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/config.py

@@ -104,7 +104,54 @@ def _int_env(name: str, default: int) -> int:
         return default
 
 
+_TOML_TO_ENV = {
+    "backend.backend": "DEEPPARALLEL_BACKEND",
+    "backend.deployment": "DEEPPARALLEL_DEPLOYMENT",
+    "backend.temperature": "DEEPPARALLEL_TEMPERATURE",
+    "backend.max_tokens": "DEEPPARALLEL_MAX_TOKENS",
+    "backend.parallel_models": "DEEPPARALLEL_PARALLEL_MODELS",
+    "fusion.mode": "DEEPPARALLEL_FUSION",
+    "tools.auto_approve": "DEEPPARALLEL_AUTO_APPROVE",
+    "memory.enabled": "DEEPPARALLEL_MEMORY",
+    "memory.dir": "DEEPPARALLEL_MEMORY_DIR",
+    "mcp.config": "DEEPPARALLEL_MCP_CONFIG",
+}
+
+
+def _apply_config_file() -> None:
+    """Layer ~/.config/deepparallel/config.toml under the environment.
+
+    Sets each known DEEPPARALLEL_* env var only when unset, so precedence is
+    explicit env var > config.toml > built-in default. Missing or malformed
+    config is ignored. Path override: DEEPPARALLEL_CONFIG.
+    """
+    import tomllib
+
+    path = os.environ.get("DEEPPARALLEL_CONFIG") or os.path.expanduser(
+        "~/.config/deepparallel/config.toml"
+    )
+    try:
+        with open(path, "rb") as fh:
+            data = tomllib.load(fh)
+    except (OSError, ValueError):
+        return
+    for dotted, env_name in _TOML_TO_ENV.items():
+        if os.environ.get(env_name) is not None:
+            continue
+        section, key = dotted.split(".", 1)
+        val = (data.get(section) or {}).get(key)
+        if val is None:
+            continue
+        if isinstance(val, bool):
+            os.environ[env_name] = "true" if val else "false"
+        elif isinstance(val, list):
+            os.environ[env_name] = ",".join(str(x) for x in val)
+        else:
+            os.environ[env_name] = str(val)
+
+
 def resolve_settings() -> Settings:
+    _apply_config_file()
     backend = os.environ.get("DEEPPARALLEL_BACKEND", "azure").strip().lower()
     if backend not in {"azure", "foundry", "crowe", "openai", "ollama"}:
         backend = "azure"

deepparallel-0.5.7/deepparallel/memory.py

@@ -0,0 +1,186 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Persistent, continuously-growing memory for DeepParallel.
+
+This is what makes CroweLM a learning model in practice: durable facts persist
+across sessions and feed back into context. Two recall tiers:
+
+- index: MEMORY.md is injected into the system prompt every session, so the
+  model remembers the user and their projects without being re-told.
+- retrieval: recall(query) ranks individual memories by relevance (TF-IDF
+  cosine over tokens, stdlib only) for an on-demand, semantic-style pull.
+
+Memories are markdown files with frontmatter under the memory directory
+(default ~/.config/deepparallel/memory; override DEEPPARALLEL_MEMORY_DIR).
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import time
+from pathlib import Path
+
+INDEX_FILE = "MEMORY.md"
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+_TOK_RE = re.compile(r"[a-z0-9]+")
+_FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.S)
+
+
+def memory_dir() -> Path:
+    raw = os.environ.get("DEEPPARALLEL_MEMORY_DIR") or os.path.expanduser(
+        "~/.config/deepparallel/memory"
+    )
+    return Path(raw)
+
+
+def enabled() -> bool:
+    return os.environ.get("DEEPPARALLEL_MEMORY", "on").strip().lower() not in {
+        "0", "off", "false", "no",
+    }
+
+
+def _slugify(name: str) -> str:
+    return _SLUG_RE.sub("-", name.strip().lower()).strip("-") or "memory"
+
+
+def _unique_slug(d: Path, slug: str) -> str:
+    cand, i = slug, 2
+    while (d / f"{cand}.md").exists():
+        cand, i = f"{slug}-{i}", i + 1
+    return cand
+
+
+def load_index() -> str:
+    try:
+        return (memory_dir() / INDEX_FILE).read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def index_block() -> str:
+    """The memory index formatted for system-prompt injection (empty if none)."""
+    idx = load_index()
+    if not idx or not enabled():
+        return ""
+    return (
+        "\n\nLong-term memory (recalled from past sessions; background context, "
+        "verify file/line specifics before relying on them):\n" + idx
+    )
+
+
+def save_memory(content: str, name: str = "", description: str = "", mtype: str = "note") -> str:
+    """Write one durable fact as a markdown file and add an index line."""
+    d = memory_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    first_line = content.strip().split("\n", 1)[0]
+    title = (name or first_line)[:60].strip() or "memory"
+    slug = _unique_slug(d, _slugify(title))
+    desc = (description or first_line).replace("\n", " ").strip()[:120]
+    body = (
+        f"---\nname: {title}\ndescription: {desc}\ntype: {mtype}\n"
+        f"created: {int(time.time())}\n---\n\n{content.strip()}\n"
+    )
+    (d / f"{slug}.md").write_text(body, encoding="utf-8")
+    _append_index(d, slug, title, desc)
+    return slug
+
+
+def _append_index(d: Path, slug: str, title: str, desc: str) -> None:
+    idx = d / INDEX_FILE
+    existing = idx.read_text(encoding="utf-8") if idx.exists() else "# DeepParallel Memory\n\n"
+    if f"]({slug}.md)" in existing:
+        return
+    if not existing.endswith("\n"):
+        existing += "\n"
+    idx.write_text(existing + f"- [{title}]({slug}.md) - {desc}\n", encoding="utf-8")
+
+
+def _parse(text: str, fallback: str) -> tuple[str, str, str]:
+    m = _FM_RE.match(text)
+    if not m:
+        return fallback, "", text.strip()
+    meta = {}
+    for line in m.group(1).splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            meta[k.strip()] = v.strip()
+    return meta.get("name", fallback), meta.get("description", ""), m.group(2).strip()
+
+
+def list_memories() -> list[dict]:
+    d = memory_dir()
+    out = []
+    if not d.exists():
+        return out
+    for p in sorted(d.glob("*.md")):
+        if p.name == INDEX_FILE:
+            continue
+        name, desc, body = _parse(p.read_text(encoding="utf-8", errors="replace"), p.stem)
+        out.append({"name": name, "description": desc, "content": body, "path": str(p)})
+    return out
+
+
+def _tokenize(text: str) -> list[str]:
+    return _TOK_RE.findall(text.lower())
+
+
+def recall(query: str, limit: int = 5) -> list[dict]:
+    """Relevance-ranked memories via TF-IDF cosine over tokens (stdlib only)."""
+    mems = list_memories()
+    if not mems or not query.strip():
+        return []
+    docs = [_tokenize(f"{m['name']} {m['description']} {m['content']}") for m in mems]
+    df: dict[str, int] = {}
+    for toks in docs:
+        for t in set(toks):
+            df[t] = df.get(t, 0) + 1
+    n = len(docs)
+
+    def vec(toks: list[str]) -> dict[str, float]:
+        if not toks:
+            return {}
+        tf: dict[str, int] = {}
+        for t in toks:
+            tf[t] = tf.get(t, 0) + 1
+        return {t: (c / len(toks)) * math.log((n + 1) / (df.get(t, 0) + 1) + 1) for t, c in tf.items()}
+
+    qv = vec(_tokenize(query))
+    qa = math.sqrt(sum(v * v for v in qv.values()))
+    scored = []
+    for m, toks in zip(mems, docs):
+        dv = vec(toks)
+        da = math.sqrt(sum(v * v for v in dv.values()))
+        num = sum(qv.get(t, 0.0) * dv.get(t, 0.0) for t in qv)
+        score = num / (da * qa) if da and qa else 0.0
+        if score > 0:
+            scored.append(
+                {"name": m["name"], "description": m["description"], "content": m["content"],
+                 "score": round(score, 4)}
+            )
+    scored.sort(key=lambda x: x["score"], reverse=True)
+    return scored[:limit]
+
+
+def _rebuild_index(d: Path) -> None:
+    lines = ["# DeepParallel Memory", ""]
+    for m in list_memories():
+        lines.append(f"- [{m['name']}]({Path(m['path']).stem}.md) - {m['description']}")
+    (d / INDEX_FILE).write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def forget(name: str) -> bool:
+    d = memory_dir()
+    target = d / f"{_slugify(name)}.md"
+    if not target.exists():
+        for p in d.glob("*.md"):
+            if p.stem == name and p.name != INDEX_FILE:
+                target = p
+                break
+    if target.exists() and target.name != INDEX_FILE:
+        target.unlink()
+        _rebuild_index(d)
+        return True
+    return False

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/tools/__init__.py

@@ -19,7 +19,9 @@ from deepparallel.tools import (  # noqa: E402,F401
     codeast,
     edit,
     files,
+    git_ops,
     mcp,
+    memory,
     sandbox,
     search,
     shell,

deepparallel-0.5.7/deepparallel/tools/git_ops.py

@@ -0,0 +1,185 @@
+"""Git operations tools: status, diff, log, branch, add, commit, clone."""
+
+from __future__ import annotations
+
+import json
+import shlex
+import subprocess
+from pathlib import Path
+
+from deepparallel.tools import tool
+
+
+def _repo(repo_path: str) -> Path:
+    return Path(repo_path).expanduser().resolve()
+
+
+def _is_repo(repo: Path) -> bool:
+    try:
+        r = subprocess.run(
+            ["git", "-C", str(repo), "rev-parse", "--git-dir"],
+            capture_output=True, text=True, timeout=10,
+        )
+        return r.returncode == 0
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _run_git(repo: Path, args: list[str], timeout_seconds: int = 30) -> dict:
+    """Run a git command in repo and return a result dict.
+
+    Surfaces failures as {"error": ...} instead of raising.
+    """
+    try:
+        r = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            cwd=str(repo),
+        )
+    except FileNotFoundError:
+        return {"error": "git executable not found on PATH"}
+    except subprocess.TimeoutExpired:
+        return {"error": f"git command timed out after {timeout_seconds}s"}
+    except Exception as e:  # noqa: BLE001 - surface failure to the model
+        return {"error": f"{type(e).__name__}: {e}"}
+    stdout = r.stdout or ""
+    if len(stdout) > 50000:
+        stdout = stdout[:50000] + "\n... (output truncated at 50KB)"
+    return {
+        "output": stdout.strip(),
+        "stderr": (r.stderr or "").strip()[:10000],
+        "return_code": r.returncode,
+    }
+
+
+@tool(dangerous=False)
+def git_status(repo_path: str) -> str:
+    """Show the working tree status of a git repository.
+
+    :param repo_path: Path to the git repository.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    return json.dumps(_run_git(repo, ["status", "--porcelain=v2", "--branch"]))
+
+
+@tool(dangerous=False)
+def git_diff(repo_path: str, staged: bool = False) -> str:
+    """Show changes in the working directory or staging area.
+
+    :param repo_path: Path to the git repository.
+    :param staged: If true, show staged changes; default shows unstaged changes.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    args = ["diff"]
+    if staged:
+        args.append("--cached")
+    return json.dumps(_run_git(repo, args))
+
+
+@tool(dangerous=False)
+def git_log(repo_path: str, count: int = 10) -> str:
+    """Show recent commit history as one line per commit.
+
+    :param repo_path: Path to the git repository.
+    :param count: Number of commits to show (capped at 50).
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    count = max(1, min(int(count), 50))
+    return json.dumps(_run_git(repo, ["log", f"-{count}", "--oneline", "--decorate"]))
+
+
+@tool(dangerous=False)
+def git_branch(repo_path: str) -> str:
+    """List branches and report the current branch.
+
+    :param repo_path: Path to the git repository.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    listing = _run_git(repo, ["branch", "--list"])
+    if "error" in listing:
+        return json.dumps(listing)
+    current = _run_git(repo, ["rev-parse", "--abbrev-ref", "HEAD"])
+    branches = []
+    for line in listing["output"].splitlines():
+        name = line.replace("*", "", 1).strip()
+        if name:
+            branches.append(name)
+    return json.dumps(
+        {
+            "branches": branches,
+            "current": current.get("output", ""),
+            "return_code": listing["return_code"],
+        }
+    )
+
+
+@tool(dangerous=True)
+def git_add(repo_path: str, paths: str = ".") -> str:
+    """Stage files for the next commit.
+
+    :param repo_path: Path to the git repository.
+    :param paths: Space-separated pathspecs to stage (default "." for all).
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    pathspecs = shlex.split(paths) if paths.strip() else ["."]
+    return json.dumps(_run_git(repo, ["add", "--", *pathspecs]))
+
+
+@tool(dangerous=True)
+def git_commit(repo_path: str, message: str, add_all: bool = False) -> str:
+    """Create a commit, optionally staging all tracked changes first.
+
+    :param repo_path: Path to the git repository.
+    :param message: The commit message.
+    :param add_all: If true, stage all tracked changes before committing.
+    """
+    repo = _repo(repo_path)
+    if not _is_repo(repo):
+        return json.dumps({"error": f"Not a git repository: {repo_path}"})
+    args = ["commit", "-m", message]
+    if add_all:
+        args.append("--all")
+    return json.dumps(_run_git(repo, args))
+
+
+@tool(dangerous=True)
+def git_clone(url: str, target_path: str) -> str:
+    """Clone a git repository into a local path.
+
+    :param url: The repository URL to clone.
+    :param target_path: Local path to clone into.
+    """
+    target = Path(target_path).expanduser().resolve()
+    try:
+        r = subprocess.run(
+            ["git", "clone", url, str(target)],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+    except FileNotFoundError:
+        return json.dumps({"error": "git executable not found on PATH"})
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": "git clone timed out after 300s"})
+    except Exception as e:  # noqa: BLE001 - surface failure to the model
+        return json.dumps({"error": f"{type(e).__name__}: {e}"})
+    return json.dumps(
+        {
+            "output": (r.stdout or "").strip(),
+            "stderr": (r.stderr or "").strip()[:10000],
+            "return_code": r.returncode,
+            "target_path": str(target),
+        }
+    )

{deepparallel-0.5.5 → deepparallel-0.5.7}/deepparallel/tools/mcp.py

@@ -35,8 +35,9 @@ _pool_lock = threading.Lock()
 class _ServerConnection:
     """One MCP server subprocess plus its JSON-RPC stdio channel."""
 
-    def __init__(self, command: list[str], env: dict | None = None) -> None:
+    def __init__(self, command: list[str], env: dict | None = None, cwd: str | None = None) -> None:
         self.command = command
+        self._cwd = cwd
         self.server_info: dict = {}
         self.tools: list[dict] = []
         self.last_used = time.time()
@@ -56,6 +57,7 @@ class _ServerConnection:
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             env=self._env,
+            cwd=self._cwd,
         )
         init = self._request(
             "initialize",
@@ -124,6 +126,62 @@ class _ServerConnection:
         return json.loads(line.decode())
 
 
+_CONFIG_ENV = "DEEPPARALLEL_MCP_CONFIG"
+_DEFAULT_CONFIG = os.path.expanduser("~/.config/deepparallel/mcp.json")
+_registry_cache: dict | None = None
+
+
+def _load_registry() -> dict:
+    """Custom/local MCP servers from the user config (Claude `mcpServers` format).
+
+    Path: $DEEPPARALLEL_MCP_CONFIG or ~/.config/deepparallel/mcp.json. Each entry
+    has command/args/cwd/env (env values expand $VARS from the process env, so
+    the model's servers inherit the configured key vault). Cached per process.
+    """
+    global _registry_cache
+    if _registry_cache is not None:
+        return _registry_cache
+    path = os.environ.get(_CONFIG_ENV) or _DEFAULT_CONFIG
+    servers: dict = {}
+    try:
+        with open(path) as fh:
+            data = json.load(fh)
+        for name, spec in (data.get("mcpServers") or {}).items():
+            cmd = [str(spec["command"]), *[str(a) for a in spec.get("args", [])]]
+            env = {k: os.path.expandvars(str(v)) for k, v in (spec.get("env") or {}).items()}
+            cwd = spec.get("cwd")
+            servers[name] = {
+                "command": [os.path.expandvars(c) for c in cmd],
+                "cwd": os.path.expandvars(cwd) if cwd else None,
+                "env": env,
+                "description": str(spec.get("description", "")),
+            }
+    except (OSError, ValueError, KeyError, TypeError):
+        pass
+    _registry_cache = servers
+    return servers
+
+
+def _custom_matches(query: str, servers: dict) -> list[dict]:
+    """Local servers whose name/description matches the query, as search rows."""
+    q = query.lower()
+    tokens = [t for t in re.findall(r"[a-z0-9]+", q) if len(t) > 2]
+    out = []
+    for name, spec in servers.items():
+        hay = (name + " " + spec.get("description", "")).lower()
+        if not query.strip() or q in hay or any(t in hay for t in tokens):
+            out.append(
+                {
+                    "name": name,
+                    "description": spec.get("description", ""),
+                    "version": "local",
+                    "local": True,
+                    "packages": [{"type": "command", "package": name, "transport": "stdio"}],
+                }
+            )
+    return out
+
+
 def _build_command(package: str, package_type: str) -> list[str]:
     if package_type == "npm":
         return ["npx", "-y", package]
@@ -146,7 +204,11 @@ def _get_or_start(package: str, package_type: str) -> _ServerConnection:
             oldest = min(_pool, key=lambda k: _pool[k].last_used)
             _pool[oldest].stop()
             del _pool[oldest]
-        conn = _ServerConnection(_build_command(package, package_type))
+        custom = _load_registry().get(package)
+        if custom is not None:
+            conn = _ServerConnection(custom["command"], env=custom["env"], cwd=custom["cwd"])
+        else:
+            conn = _ServerConnection(_build_command(package, package_type))
         conn.start()
         _pool[package] = conn
         return conn
@@ -224,6 +286,11 @@ def mcp_search(query: str, limit: int = 10) -> str:
     except Exception as e:  # noqa: BLE001 - surface registry failure to the model
         return json.dumps({"error": f"registry search failed: {type(e).__name__}: {e}"})
     results = [_format_server(entry) for entry in servers]
+    # Local/custom servers (crios-nova, lab MCPs) come first: they are the
+    # user's own, and the public registry never lists them.
+    custom = _custom_matches(query, _load_registry())
+    seen = {c["name"] for c in custom}
+    results = custom + [r for r in results if r["name"] not in seen]
     return json.dumps({"query": query, "count": len(results), "servers": results})