simplicio-cli 0.4.2__tar.gz → 0.5.0__tar.gz

{simplicio_cli-0.4.2/simplicio_cli.egg-info → simplicio_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.4.2
+Version: 0.5.0
 Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -31,13 +31,17 @@ Requires-Dist: sentence-transformers>=2.2
 Requires-Dist: numpy>=1.23
 Requires-Dist: anthropic>=0.30
 Requires-Dist: openai>=1.30
-Requires-Dist: simplicio-mapper>=0.6.0
-Requires-Dist: simplicio-prompt>=1.9.0
+Requires-Dist: simplicio-mapper>=0.6.1
+Requires-Dist: simplicio-prompt>=1.12.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: orjson>=3.10
 Requires-Dist: diskcache>=5.6
+Requires-Dist: libcst>=1.8
 Provides-Extra: bench
 Requires-Dist: fpdf2>=2.7; extra == "bench"
+Provides-Extra: local
+Requires-Dist: llama-cpp-python>=0.3.2; extra == "local"
+Requires-Dist: huggingface-hub>=0.23; extra == "local"
 Dynamic: license-file
 
 # simplicio-cli
@@ -351,7 +355,9 @@ The install ships **three Simplicio packages** that play distinct roles:
   (`bench/run_fanout.py`) measures both real PHPUnit pass-rate and a
   structural regex check on every subagent and surfaces the gap; full
   ongoing numbers in [`bench/results_fanout.md`](bench/results_fanout.md) ·
-  [`bench/results_fanout.pdf`](bench/results_fanout.pdf).
+  [`bench/results_fanout.pdf`](bench/results_fanout.pdf). Set
+  `BENCH_SINDICO_SRC` / `BENCH_SINDICO_WORK` when the local
+  `sistema-sindico` checkout and work copy are not under `/tmp`.
 
 Each is independently published on PyPI; ship them as a set so the CLI's
 mapper-rich precedent ranking, contract-shaped prompts, and (when called
@@ -540,6 +546,7 @@ user prompt. UserPromptSubmit is the right pre-hook for routing decisions.
 | DeepSeek | `deepseek-chat` | `https://api.deepseek.com` |
 | OpenAI | `gpt-4.1` | `https://api.openai.com/v1` |
 | Local (Ollama) | `llama3` | `http://localhost:11434/v1` |
+| Local (in-process) | `local-llama/default` | *(leave unset)* |
 | Anthropic native | `claude-opus-4-7` | *(leave unset)* |
 
 If `SIMPLICIO_BASE_URL` is unset and the key is `ANTHROPIC_API_KEY`, it uses the
@@ -550,6 +557,40 @@ your `base_url` — so **any** OpenAI-like provider works without code changes.
 simplicio smoke      # prints provider config + one test call
 ```
 
+### Path 4 — offline-first local model (zero key, zero HTTP)
+
+simplicio ships an **in-process** backend powered by
+[`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python). When **no
+provider is configured** (`SIMPLICIO_MODEL` *and* `SIMPLICIO_BASE_URL` both
+unset), it runs **Qwen2.5-Coder-1.5B-Instruct (Q5_K_M GGUF)** directly — small,
+code-specialized, fast on CPU, no API key, no Ollama, no HTTP overhead. The
+6-layer contract is what makes a 1.5B usable: it lifts the same model from ~34%
+to ~88% pass-rate on the local benchmark.
+
+```bash
+pip install 'simplicio-cli[local]'          # pulls llama-cpp-python + huggingface-hub
+
+simplicio task "add input validation to createUser" \
+  --target src/users.ts --local              # forces the local model
+
+# the GGUF is fetched once from the Hugging Face Hub, then cached + reused
+```
+
+Explicit routes (override the default model/weights):
+
+```bash
+SIMPLICIO_MODEL=local-llama/default                                  # bundled default
+SIMPLICIO_MODEL=local-llama/bartowski/Qwen2.5-Coder-7B-Instruct-GGUF::Qwen2.5-Coder-7B-Instruct-Q4_K_M.gguf
+SIMPLICIO_MODEL=local-llama//models/my-model.gguf                    # direct local path
+SIMPLICIO_LOCAL_MODEL_PATH=/models/my-model.gguf                     # always wins
+```
+
+Tuning knobs (all optional): `SIMPLICIO_LOCAL_CTX` (context window, default
+`8192`), `SIMPLICIO_LOCAL_THREADS`, `SIMPLICIO_LOCAL_GPU_LAYERS` (offload to GPU,
+default `0`), `SIMPLICIO_LOCAL_MAX_TOKENS` (generation cap),
+`SIMPLICIO_LOCAL_TEMP` (default `0.1`), `SIMPLICIO_LOCAL_MODEL_REPO` /
+`SIMPLICIO_LOCAL_MODEL_FILE`.
+
 ### The pipeline (both paths)
 
 Whichever entry point you use, each task runs through the same engine:

{simplicio_cli-0.4.2 → simplicio_cli-0.5.0}/README.md

@@ -309,7 +309,9 @@ The install ships **three Simplicio packages** that play distinct roles:
   (`bench/run_fanout.py`) measures both real PHPUnit pass-rate and a
   structural regex check on every subagent and surfaces the gap; full
   ongoing numbers in [`bench/results_fanout.md`](bench/results_fanout.md) ·
-  [`bench/results_fanout.pdf`](bench/results_fanout.pdf).
+  [`bench/results_fanout.pdf`](bench/results_fanout.pdf). Set
+  `BENCH_SINDICO_SRC` / `BENCH_SINDICO_WORK` when the local
+  `sistema-sindico` checkout and work copy are not under `/tmp`.
 
 Each is independently published on PyPI; ship them as a set so the CLI's
 mapper-rich precedent ranking, contract-shaped prompts, and (when called
@@ -498,6 +500,7 @@ user prompt. UserPromptSubmit is the right pre-hook for routing decisions.
 | DeepSeek | `deepseek-chat` | `https://api.deepseek.com` |
 | OpenAI | `gpt-4.1` | `https://api.openai.com/v1` |
 | Local (Ollama) | `llama3` | `http://localhost:11434/v1` |
+| Local (in-process) | `local-llama/default` | *(leave unset)* |
 | Anthropic native | `claude-opus-4-7` | *(leave unset)* |
 
 If `SIMPLICIO_BASE_URL` is unset and the key is `ANTHROPIC_API_KEY`, it uses the
@@ -508,6 +511,40 @@ your `base_url` — so **any** OpenAI-like provider works without code changes.
 simplicio smoke      # prints provider config + one test call
 ```
 
+### Path 4 — offline-first local model (zero key, zero HTTP)
+
+simplicio ships an **in-process** backend powered by
+[`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python). When **no
+provider is configured** (`SIMPLICIO_MODEL` *and* `SIMPLICIO_BASE_URL` both
+unset), it runs **Qwen2.5-Coder-1.5B-Instruct (Q5_K_M GGUF)** directly — small,
+code-specialized, fast on CPU, no API key, no Ollama, no HTTP overhead. The
+6-layer contract is what makes a 1.5B usable: it lifts the same model from ~34%
+to ~88% pass-rate on the local benchmark.
+
+```bash
+pip install 'simplicio-cli[local]'          # pulls llama-cpp-python + huggingface-hub
+
+simplicio task "add input validation to createUser" \
+  --target src/users.ts --local              # forces the local model
+
+# the GGUF is fetched once from the Hugging Face Hub, then cached + reused
+```
+
+Explicit routes (override the default model/weights):
+
+```bash
+SIMPLICIO_MODEL=local-llama/default                                  # bundled default
+SIMPLICIO_MODEL=local-llama/bartowski/Qwen2.5-Coder-7B-Instruct-GGUF::Qwen2.5-Coder-7B-Instruct-Q4_K_M.gguf
+SIMPLICIO_MODEL=local-llama//models/my-model.gguf                    # direct local path
+SIMPLICIO_LOCAL_MODEL_PATH=/models/my-model.gguf                     # always wins
+```
+
+Tuning knobs (all optional): `SIMPLICIO_LOCAL_CTX` (context window, default
+`8192`), `SIMPLICIO_LOCAL_THREADS`, `SIMPLICIO_LOCAL_GPU_LAYERS` (offload to GPU,
+default `0`), `SIMPLICIO_LOCAL_MAX_TOKENS` (generation cap),
+`SIMPLICIO_LOCAL_TEMP` (default `0.1`), `SIMPLICIO_LOCAL_MODEL_REPO` /
+`SIMPLICIO_LOCAL_MODEL_FILE`.
+
 ### The pipeline (both paths)
 
 Whichever entry point you use, each task runs through the same engine:

{simplicio_cli-0.4.2 → simplicio_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.4.2"
+version = "0.5.0"
 description = "Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens."
 readme = "README.md"
 license = { text = "MIT" }
@@ -45,15 +45,19 @@ dependencies = [
   "numpy>=1.23",
   "anthropic>=0.30",
   "openai>=1.30",
-  "simplicio-mapper>=0.6.0",
-  "simplicio-prompt>=1.9.0",
+  "simplicio-mapper>=0.6.1",
+  "simplicio-prompt>=1.12.0",
   "httpx>=0.27",
   "orjson>=3.10",
   "diskcache>=5.6",
+  "libcst>=1.8",
 ]
 
 [project.optional-dependencies]
 bench = ["fpdf2>=2.7"]
+# Offline-first in-process inference (Path 4). Pulls the llama.cpp Python
+# bindings plus huggingface-hub to fetch the default Qwen2.5-Coder-1.5B GGUF.
+local = ["llama-cpp-python>=0.3.2", "huggingface-hub>=0.23"]
 
 [project.urls]
 Homepage = "https://github.com/wesleysimplicio/simplicio-cli"
@@ -73,7 +77,16 @@ where = ["."]
 include = ["simplicio*"]
 
 [tool.setuptools.package-data]
-simplicio = ["templates/*.md", "templates/*.sh"]
+simplicio = [
+  "templates/*.md",
+  "templates/*.sh",
+  "templates/recipes/**/*.json",
+  "templates/recipes/**/*.yaml",
+  "templates/recipes/**/*.yml",
+  "templates/stacks/**/*",
+  "templates/stacks/*/tree/.gitignore",
+  "templates/stacks/*/tree/.eslintrc.json",
+]
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

simplicio_cli-0.5.0/simplicio/__init__.py

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

simplicio_cli-0.5.0/simplicio/_cache.py

@@ -0,0 +1,253 @@
+"""Content-addressed completion cache for provider outputs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _cache_root() -> Path:
+    override = os.environ.get("SIMPLICIO_CACHE_DIR")
+    if override:
+        return Path(override)
+    return Path.home() / ".simplicio" / "cache"
+
+
+def make_key(provider_id: str, model: str, prompt: str, **kwargs: Any) -> str:
+    payload = {
+        "v": 1,
+        "provider_id": provider_id,
+        "model": model,
+        "prompt": prompt,
+        "kwargs": kwargs,
+    }
+    raw = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+@dataclass
+class CacheEntry:
+    completion: str
+    provider_id: str = ""
+    model: str = ""
+    created_at: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "completion": self.completion,
+            "provider_id": self.provider_id,
+            "model": self.model,
+            "created_at": self.created_at,
+            "metadata": dict(self.metadata),
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "CacheEntry":
+        return cls(
+            completion=str(payload.get("completion", "")),
+            provider_id=str(payload.get("provider_id", "")),
+            model=str(payload.get("model", "")),
+            created_at=float(payload.get("created_at") or time.time()),
+            metadata=dict(payload.get("metadata") or {}),
+        )
+
+
+class CompletionCache:
+    def __init__(
+        self,
+        root: Optional[Path] = None,
+        *,
+        ttl_days: Optional[float] = None,
+        max_mb: Optional[float] = None,
+    ) -> None:
+        self.root = Path(root) if root is not None else _cache_root()
+        self.ttl_days = (
+            ttl_days
+            if ttl_days is not None
+            else _env_float("SIMPLICIO_CACHE_TTL_DAYS", 30)
+        )
+        self.max_mb = (
+            max_mb if max_mb is not None else _env_float("SIMPLICIO_CACHE_MAX_MB", 500)
+        )
+        self.hits = 0
+        self.misses = 0
+        self.puts = 0
+
+    @property
+    def enabled(self) -> bool:
+        return _env_flag("SIMPLICIO_CACHE", True)
+
+    @property
+    def bust(self) -> bool:
+        return _env_flag("SIMPLICIO_BUST_CACHE", False)
+
+    def path_for(self, key: str) -> Path:
+        return self.root / key[:2] / f"{key}.json"
+
+    def get(self, key: str) -> Optional[CacheEntry]:
+        if not self.enabled or self.bust:
+            self.misses += 1
+            return None
+        path = self.path_for(key)
+        try:
+            if not path.exists():
+                self.misses += 1
+                return None
+            if self._is_expired(path):
+                self._safe_unlink(path)
+                self.misses += 1
+                return None
+        except OSError:
+            self.misses += 1
+            return None
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                entry = CacheEntry.from_dict(json.load(handle))
+                self.hits += 1
+                return entry
+        except (OSError, ValueError, TypeError):
+            self._safe_unlink(path)
+            self.misses += 1
+            return None
+
+    def put(self, key: str, entry: CacheEntry) -> None:
+        if not self.enabled:
+            return
+        path = self.path_for(key)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            fd, tmp_name = tempfile.mkstemp(
+                prefix=f".{path.stem}.",
+                suffix=".tmp",
+                dir=str(path.parent),
+            )
+        except OSError:
+            return
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump(entry.to_dict(), handle, sort_keys=True)
+            try:
+                os.replace(tmp_name, path)
+            except OSError:
+                return
+        finally:
+            if os.path.exists(tmp_name):
+                self._safe_unlink(Path(tmp_name))
+        self.puts += 1
+        self._evict_if_needed()
+
+    def clear(self) -> int:
+        n = self.stats()["entries"]
+        if self.root.exists():
+            shutil.rmtree(self.root)
+        return int(n)
+
+    def stats(self) -> Dict[str, Any]:
+        files = list(self._files())
+        total_bytes = sum(path.stat().st_size for path in files if path.exists())
+        now = time.time()
+        oldest = None
+        if files:
+            oldest = max(0.0, now - min(path.stat().st_mtime for path in files))
+        return {
+            "enabled": self.enabled,
+            "bust": self.bust,
+            "root": str(self.root),
+            "entries": len(files),
+            "hits": self.hits,
+            "misses": self.misses,
+            "puts": self.puts,
+            "hit_rate": round(self.hits / (self.hits + self.misses), 4)
+            if self.hits + self.misses
+            else 0.0,
+            "bytes": total_bytes,
+            "mb": round(total_bytes / (1024 * 1024), 3),
+            "oldest_age_s": round(oldest, 3) if oldest is not None else None,
+            "ttl_days": self.ttl_days,
+            "max_mb": self.max_mb,
+        }
+
+    def _files(self) -> list[Path]:
+        try:
+            if not self.root.exists():
+                return []
+            return [path for path in self.root.rglob("*.json") if path.is_file()]
+        except OSError:
+            return []
+
+    def _is_expired(self, path: Path) -> bool:
+        if self.ttl_days <= 0:
+            return False
+        max_age = self.ttl_days * 86400
+        return (time.time() - path.stat().st_mtime) > max_age
+
+    def _evict_if_needed(self) -> None:
+        max_bytes = int(max(0.0, self.max_mb) * 1024 * 1024)
+        if max_bytes <= 0:
+            return
+        files = self._files()
+        total = sum(path.stat().st_size for path in files if path.exists())
+        if total <= max_bytes:
+            return
+        for path in sorted(files, key=lambda p: p.stat().st_mtime):
+            size = path.stat().st_size
+            self._safe_unlink(path)
+            total -= size
+            if total <= max_bytes:
+                break
+
+    @staticmethod
+    def _safe_unlink(path: Path) -> None:
+        try:
+            path.unlink()
+        except OSError:
+            return
+
+
+_cache: Optional[CompletionCache] = None
+
+
+def cache() -> CompletionCache:
+    global _cache
+    if _cache is None:
+        _cache = CompletionCache()
+    return _cache
+
+
+def reset_for_tests() -> None:
+    global _cache
+    _cache = None
+
+
+__all__ = [
+    "CacheEntry",
+    "CompletionCache",
+    "cache",
+    "make_key",
+    "reset_for_tests",
+]

simplicio_cli-0.5.0/simplicio/cli.py

@@ -0,0 +1,235 @@
+"""CLI entrypoint for simplicio."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def maybe_autoinstall(cmd: str | None) -> bool:
+    """Install skill + hook on first run when Claude Code is detected."""
+    if os.environ.get("SIMPLICIO_SKIP_AUTO_INIT"):
+        return False
+    if cmd in ("init", "detect"):
+        return False
+    home = Path(os.environ["HOME"]) if os.environ.get("HOME") else Path.home()
+    claude_home = home / ".claude"
+    if not claude_home.is_dir():
+        return False
+    hook_path = claude_home / "hooks" / "simplicio-userpromptsubmit.sh"
+    if hook_path.exists():
+        return False
+    try:
+        from .init import install
+
+        report = install(claude_home=claude_home, dry_run=False)
+    except Exception as e:
+        print(f"simplicio: auto-activation skipped ({e})", file=sys.stderr)
+        return False
+    if (
+        report.skill_installed
+        or report.hook_script_installed
+        or report.settings_updated
+    ):
+        print(
+            "simplicio: auto-activation installed in Claude Code "
+            "(skill + UserPromptSubmit hook). "
+            "Disable next time with SIMPLICIO_SKIP_AUTO_INIT=1.",
+            file=sys.stderr,
+        )
+        return True
+    return False
+
+
+def _dispatch_nested(argv: list[str]) -> int | None:
+    if argv and argv[0] == "scratch":
+        maybe_autoinstall("scratch")
+        from .scratch.cli import main as scratch_main
+
+        return scratch_main(argv[1:])
+    if argv and argv[0] == "skill":
+        maybe_autoinstall("skill")
+        args = argv[1:]
+        if not args or args[0] != "new":
+            print(
+                'usage: simplicio skill new "<description>" [--planner ...] [--dry-run]',
+                file=sys.stderr,
+            )
+            return 2
+        from .scratch.skill_opt import main as skill_main
+
+        return skill_main(args[1:])
+    return None
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    nested = _dispatch_nested(argv)
+    if nested is not None:
+        return nested
+
+    ap = argparse.ArgumentParser(prog="simplicio")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    pi = sub.add_parser("index", help="index/cache the repo (once, or after changes)")
+    pi.add_argument("--root", default=".")
+    pi.add_argument("--stack", default="angular")
+
+    pt = sub.add_parser("task", help="run a task")
+    pt.add_argument("goal")
+    pt.add_argument("--root", default=".")
+    pt.add_argument("--stack", default="angular")
+    pt.add_argument("--target", required=True)
+    pt.add_argument("--criteria", default="- true state\n- false state")
+    pt.add_argument("--constraints", default="- build passes")
+    pt.add_argument(
+        "--dry-run-task",
+        action="store_true",
+        help="generate the would-be task output without applying/testing",
+    )
+    pt.add_argument(
+        "--json", action="store_true", help="emit stable structured task output"
+    )
+    pt.add_argument(
+        "--bound-paths",
+        action="append",
+        default=[],
+        help="glob limiting which paths the task may change; repeatable",
+    )
+    pt.add_argument(
+        "--local",
+        action="store_true",
+        help="force the in-process local model (Qwen2.5-Coder-1.5B GGUF, "
+        "no API key); overrides SIMPLICIO_MODEL/SIMPLICIO_BASE_URL",
+    )
+
+    pb = sub.add_parser("bench", help="compare with vs without (real numbers)")
+    pb.add_argument("--root", default=".")
+    pb.add_argument("--stack", default="angular")
+    pb.add_argument("--cases", default="bench/cases.json")
+
+    pc = sub.add_parser("cache", help="inspect or clear completion cache")
+    pc_sub = pc.add_subparsers(dest="cache_cmd", required=True)
+    pc_stats = pc_sub.add_parser("stats", help="print completion cache statistics")
+    pc_stats.add_argument("--json", action="store_true")
+    pc_clear = pc_sub.add_parser("clear", help="clear completion cache")
+    pc_clear.add_argument("--force", action="store_true", help="required to clear")
+
+    sub.add_parser(
+        "smoke", help="one proof call: connect+generate (needs SIMPLICIO_MODEL+KEY)"
+    )
+
+    p_init = sub.add_parser(
+        "init", help="install skill + UserPromptSubmit hook into ~/.claude/"
+    )
+    p_init.add_argument("--claude-home", help="override ~/.claude (for tests)")
+    p_init.add_argument("--dry-run", action="store_true")
+
+    p_det = sub.add_parser("detect", help="heuristic: is a prompt a code-edit task")
+    p_det.add_argument("--prompt", help="prompt text (default: read from stdin)")
+    p_det.add_argument("--quiet", action="store_true")
+    p_det.add_argument("--json", action="store_true")
+
+    a = ap.parse_args(argv)
+    maybe_autoinstall(a.cmd)
+    if a.cmd == "index":
+        from .precedent import index_repo
+
+        index_repo(a.root, a.stack)
+    elif a.cmd == "smoke":
+        from .providers import generate, info
+
+        print("provider:", info())
+        out = generate("Reply exactly: OK simplicio connected.")
+        print("model reply:", out.strip()[:200])
+    elif a.cmd == "bench":
+        from .bench import run_bench
+
+        run_bench(a.root, a.stack, a.cases)
+    elif a.cmd == "cache":
+        from ._cache import cache
+
+        c = cache()
+        if a.cache_cmd == "stats":
+            stats = c.stats()
+            if a.json:
+                print(json.dumps(stats, sort_keys=True))
+            else:
+                print(f"root: {stats['root']}")
+                print(f"enabled: {stats['enabled']}  bust: {stats['bust']}")
+                print(f"entries: {stats['entries']}  size: {stats['mb']} MB")
+                print(f"ttl_days: {stats['ttl_days']}  max_mb: {stats['max_mb']}")
+            return 0
+        if a.cache_cmd == "clear":
+            if not a.force:
+                print("simplicio cache clear requires --force", file=sys.stderr)
+                return 2
+            removed = c.clear()
+            print(f"cleared {removed} cached completion(s)")
+            return 0
+    elif a.cmd == "init":
+        from .init import main as init_main
+
+        init_argv = []
+        if a.claude_home:
+            init_argv += ["--claude-home", a.claude_home]
+        if a.dry_run:
+            init_argv += ["--dry-run"]
+        return init_main(init_argv)
+    elif a.cmd == "detect":
+        from .detect import main as detect_main
+
+        detect_argv = []
+        if a.prompt is not None:
+            detect_argv += ["--prompt", a.prompt]
+        if a.quiet:
+            detect_argv += ["--quiet"]
+        if a.json:
+            detect_argv += ["--json"]
+        return detect_main(detect_argv)
+    else:
+        from .pipeline import run, run_task
+
+        if getattr(a, "local", False):
+            # Force Path 4: pin the local model and drop any HTTP endpoint so the
+            # in-process llama backend wins regardless of the ambient config.
+            os.environ["SIMPLICIO_MODEL"] = "local-llama/default"
+            os.environ.pop("SIMPLICIO_BASE_URL", None)
+
+        if a.json or a.dry_run_task:
+            result = run_task(
+                a.root,
+                a.stack,
+                a.goal,
+                a.target,
+                a.criteria,
+                a.constraints,
+                dry_run_task=a.dry_run_task,
+                bound_paths=a.bound_paths,
+                quiet=a.json,
+            )
+            if a.json:
+                print(json.dumps(result, sort_keys=True))
+            else:
+                status = "DRY-RUN" if a.dry_run_task else "DONE"
+                print(f"{status}: {result['diff_summary']}")
+                for warning in result["warnings"]:
+                    print(f"warning: {warning}", file=sys.stderr)
+            return 0 if (a.dry_run_task or result["applied"]) else 1
+        run(
+            a.root,
+            a.stack,
+            a.goal,
+            a.target,
+            a.criteria,
+            a.constraints,
+            bound_paths=a.bound_paths,
+        )
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())