codent 0.3.1__tar.gz → 0.3.3__tar.gz

{codent-0.3.1 → codent-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codent
-Version: 0.3.1
+Version: 0.3.3
 Requires-Python: >=3.10
 Requires-Dist: rich>=13.0
 Requires-Dist: openai>=1.0

{codent-0.3.1 → codent-0.3.3}/codent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codent
-Version: 0.3.1
+Version: 0.3.3
 Requires-Python: >=3.10
 Requires-Dist: rich>=13.0
 Requires-Dist: openai>=1.0

{codent-0.3.1 → codent-0.3.3}/codent.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ core/golden_test_runner.py
 core/guardian.py
 core/hive_recall.py
 core/identity.py
+core/init_cmd.py
 core/intent_detection.py
 core/intent_gate.py
 core/learning_loop.py
@@ -123,4 +124,8 @@ tests/test_provider_router.py
 tests/test_recipes.py
 tests/test_teacher.py
 tests/test_verification.py
-tests/test_web_fetch.py
+tests/test_web_fetch.py
+vendor/__init__.py
+vendor/bin/__init__.py
+vendor/bin/ollama
+vendor/wheels/__init__.py

{codent-0.3.1 → codent-0.3.3}/codent.egg-info/top_level.txt

@@ -2,3 +2,4 @@ cont
 cont_ui
 cont_watcher
 core
+vendor

{codent-0.3.1 → codent-0.3.3}/cont.py

@@ -416,8 +416,12 @@ from core.provider_router import (
 )
 
 # Discover working base URL at startup (LM Studio → Ollama fallback)
-# Discover working base URL at startup (LM Studio → Ollama fallback)
+# Skip the hard-exit when running offline-only flags (--init, --local-list, --help)
+_OFFLINE_FLAGS = {"--init", "--local-list", "--help", "-h", "--version"}
+_OFFLINE_MODE = any(a in _OFFLINE_FLAGS for a in sys.argv[1:])
 _PROVIDER_NAME = "lmstudio"
+BASE_URL = "http://127.0.0.1:1234/v1"
+_TRIED_URLS = []
 try:
     BASE_URL, _TRIED_URLS = discover_openai_base_url()
 except EndpointNotFoundError:
@@ -428,6 +432,9 @@ except EndpointNotFoundError:
         _TRIED_URLS = [OLLAMA_BASE]
         _PROVIDER_NAME = "ollama"
         console.print("[yellow]LM Studio unavailable, using Ollama fallback.[/yellow]")
+    elif _OFFLINE_MODE:
+        # --init / --local-list: provider gerek yok, sessizce devam et
+        _PROVIDER_NAME = "offline"
     else:
         console.print("[bold red]Error: No LLM provider available.[/bold red]")
         console.print("\n[yellow]Hint:[/yellow] Start LM Studio (port 1234) or Ollama (port 11434).")
@@ -1879,6 +1886,12 @@ def main():
         list_presets()
         sys.exit(0)
 
+    # Handle --init (install bundled wheels for offline llama-cpp-python)
+    if getattr(args, 'init', None) is not None:
+        from core.init_cmd import run_init
+        run_init(args.init or None)
+        sys.exit(0)
+
     # Handle all exit flags (--set-home, --show-home, --self-report, --memory-*, etc.)
     handle_exit_flags(args)
 

{codent-0.3.1 → codent-0.3.3}/core/cli.py

@@ -268,6 +268,8 @@ Model selection:
     # Local LLM — fallback GGUF presets (LM Studio kapalıysa)
     parser.add_argument("--local-list", action="store_true",
                         help="List available local GGUF model presets")
+    parser.add_argument("--init", nargs="?", const="", metavar="GGUF_PATH",
+                        help="Bundled wheel'lardan llama-cpp-python yükle (opsiyonel: GGUF path)")
 
     # Genesis — owner recognition
     parser.add_argument("--set-keyphrase", action="store_true",

{codent-0.3.1 → codent-0.3.3}/core/guardian.py

@@ -1140,6 +1140,33 @@ def check_network_safety() -> tuple[bool, list[str]]:
 
 # ── Kontrol 27: Halüsinasyon guard ──
 
+def check_system_search_meta_filter() -> tuple[bool, list[str]]:
+    """system_search META dizinleri (logs/, pheromone/, inbox/, __pycache__/)
+    filtrelemeli — bunlar DATA değil, arama gürültüsü.
+    """
+    violations = []
+    tools_path = Path(__file__).parent / "tools.py"
+    if not tools_path.exists():
+        return True, []
+    src = tools_path.read_text(encoding="utf-8", errors="ignore")
+    # system_search içinde meta filtre var mı?
+    try:
+        idx = src.index("def system_search")
+    except ValueError:
+        return True, []
+    end = src.find("\ndef ", idx + 1)
+    body = src[idx:end if end != -1 else len(src)]
+    required = ["/logs/", "/.cont/hive/pheromone/",
+                "/.cont/hive/inbox/", "/__pycache__/"]
+    missing = [tok for tok in required if tok not in body]
+    if missing:
+        violations.append(
+            f"system_search META filtresi eksik: {missing}. "
+            "core/tools.py system_search içinde bu dizinler hariç tutulmalı."
+        )
+    return not violations, violations
+
+
 def check_hallucination_guard() -> tuple[bool, list[str]]:
     """Tablo/kolon iddiası yapan görevlerde SQL çalıştırılmış mı?
 
@@ -1365,6 +1392,7 @@ def run_guardian(full: bool = False) -> GuardianReport:
         ("cc_audit", check_cc_audit),
         ("network_safety", check_network_safety),
         ("hallucination_guard", check_hallucination_guard),
+        ("system_search_meta_filter", check_system_search_meta_filter),
     ]
 
     checks = operational_checks + (code_checks if full else [])

codent-0.3.3/core/init_cmd.py

@@ -0,0 +1,181 @@
+"""cont --init — bundled binaries + wheels for offline setup.
+
+Adımlar:
+  1. Ollama yüklü mü? Yoksa vendor/bin/ollama → ~/.local/bin/ kopyala
+  2. ollama serve & başlat (zaten çalışmıyorsa)
+  3. GGUF verildiyse `ollama create` ile model kaydet
+  4. /api/tags ile test et
+
+llama-cpp-python wheel kurulumu opsiyonel kalıyor (Ollama önceliklidir).
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+OLLAMA_PORT = 11434
+OLLAMA_URL = f"http://127.0.0.1:{OLLAMA_PORT}"
+
+
+def _vendor_dir(sub: str) -> Path:
+    """Locate vendor/<sub> in source tree OR installed package."""
+    here = Path(__file__).resolve().parent
+    candidate = here.parent / "vendor" / sub
+    if candidate.exists():
+        return candidate
+    try:
+        import vendor  # type: ignore
+        candidate = Path(vendor.__file__).parent / sub
+        if candidate.exists():
+            return candidate
+    except ImportError:
+        pass
+    return candidate
+
+
+def _which(name: str) -> str | None:
+    return shutil.which(name)
+
+
+def _ollama_serve_running() -> bool:
+    try:
+        with urllib.request.urlopen(f"{OLLAMA_URL}/api/tags", timeout=2) as r:
+            return r.status == 200
+    except Exception:
+        return False
+
+
+def _install_ollama() -> str:
+    """Copy bundled ollama to ~/.local/bin/. Returns installed path."""
+    src = _vendor_dir("bin") / "ollama"
+    if not src.exists():
+        print(f"[HATA] vendor/bin/ollama bulunamadı: {src}")
+        sys.exit(1)
+
+    dest_dir = Path.home() / ".local" / "bin"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / "ollama"
+    shutil.copy2(src, dest)
+    dest.chmod(0o755)
+    print(f"[OK] ollama → {dest}")
+
+    # PATH uyarısı
+    if str(dest_dir) not in os.environ.get("PATH", "").split(":"):
+        print(f"[UYARI] {dest_dir} PATH'te değil. ~/.bashrc'ye ekle:")
+        print(f'        export PATH="{dest_dir}:$PATH"')
+    return str(dest)
+
+
+def _start_ollama_serve(ollama_bin: str) -> bool:
+    """Start `ollama serve` in background. Returns True if up within 10s."""
+    if _ollama_serve_running():
+        print("[OK] ollama serve zaten çalışıyor")
+        return True
+
+    print("[*] ollama serve başlatılıyor...")
+    log_path = Path.home() / ".cache" / "cont" / "ollama_serve.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    log_fp = open(log_path, "ab")
+    subprocess.Popen(
+        [ollama_bin, "serve"],
+        stdout=log_fp, stderr=log_fp,
+        start_new_session=True,
+    )
+
+    for _ in range(20):
+        time.sleep(0.5)
+        if _ollama_serve_running():
+            print(f"[OK] ollama serve hazır (log: {log_path})")
+            return True
+
+    print(f"[HATA] ollama serve 10s içinde yanıt vermedi (log: {log_path})")
+    return False
+
+
+def _create_model_from_gguf(ollama_bin: str, gguf_path: Path,
+                            model_name: str = "cont-local") -> bool:
+    """Generate Modelfile + run `ollama create`."""
+    print(f"[*] {model_name} modeli {gguf_path.name} GGUF'undan oluşturuluyor...")
+    modelfile = Path.home() / ".cache" / "cont" / "Modelfile.cont"
+    modelfile.parent.mkdir(parents=True, exist_ok=True)
+    modelfile.write_text(f"FROM {gguf_path}\n", encoding="utf-8")
+
+    try:
+        subprocess.run(
+            [ollama_bin, "create", model_name, "-f", str(modelfile)],
+            check=True,
+        )
+        print(f"[OK] model kaydedildi: {model_name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"[HATA] ollama create başarısız: {e}")
+        return False
+
+
+def _smoke_test(model_name: str) -> bool:
+    """Hızlı /api/generate çağrısı — model yanıt veriyor mu?"""
+    print(f"[*] {model_name} smoke test...")
+    import json
+    body = json.dumps({
+        "model": model_name,
+        "prompt": "2+2=?",
+        "stream": False,
+    }).encode()
+    req = urllib.request.Request(
+        f"{OLLAMA_URL}/api/generate",
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=120) as r:
+            resp = json.loads(r.read())
+            ans = (resp.get("response") or "").strip()[:80]
+            print(f"[OK] yanıt: {ans!r}")
+            return True
+    except Exception as e:
+        print(f"[HATA] smoke test başarısız: {e}")
+        return False
+
+
+def run_init(gguf_path: str | None = None) -> None:
+    print("Cont init başlıyor...\n")
+
+    # 1. Ollama var mı?
+    ollama_bin = _which("ollama")
+    if ollama_bin:
+        print(f"[OK] ollama zaten yüklü: {ollama_bin}")
+    else:
+        ollama_bin = _install_ollama()
+
+    # 2. Servis ayağa kalksın
+    if not _start_ollama_serve(ollama_bin):
+        sys.exit(1)
+
+    # 3. GGUF verildiyse model oluştur
+    if gguf_path:
+        gp = Path(gguf_path).expanduser()
+        if not gp.exists():
+            print(f"[HATA] GGUF bulunamadı: {gp}")
+            sys.exit(1)
+
+        model_name = "cont-local"
+        if not _create_model_from_gguf(ollama_bin, gp, model_name):
+            sys.exit(1)
+
+        # 4. Test
+        if not _smoke_test(model_name):
+            sys.exit(1)
+
+        print(f"\n[BAŞARILI] Cont kullanıma hazır.")
+        print(f"           Modeli kullanmak için: cont --model ollama:{model_name}")
+    else:
+        print("\n[INFO] GGUF verilmedi — model oluşturulmadı.")
+        print("       Daha sonra: cont --init <model.gguf>")
+
+    print("\nInit tamamlandı.")

{codent-0.3.1 → codent-0.3.3}/core/runtime.py

@@ -1168,6 +1168,8 @@ def run_task(task: str, logger=None, event_callback=None) -> tuple:
                 tool_choice="none" if budget_exhausted else "auto",
                 base_url=getattr(_ctx, "base_url", ""),
                 iteration=iteration,
+                budget_used=budget.phase_calls,
+                budget_total=budget.BUDGET_PER_PHASE,
             )
 
         _spin_stop = threading.Event()

{codent-0.3.1 → codent-0.3.3}/core/self_improve.py

@@ -457,9 +457,20 @@ class SelfImproveLoop:
         self._thread.start()
 
     def _print_background_status(self, message):
-        """Print status without breaking input prompt."""
-        sys.stdout.write(f"\r\033[K  {message}\n")
-        sys.stdout.flush()
+        """Write status to daemon log — NEVER to terminal (would break input).
+
+        Use `cont --triage` or `cont --status` to view recent activity.
+        """
+        try:
+            from datetime import datetime
+            from pathlib import Path
+            log_dir = Path.home() / ".config" / "cont" / "daemon"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_file = log_dir / "self_improve.log"
+            with open(log_file, "a", encoding="utf-8") as f:
+                f.write(f"[{datetime.now().isoformat(timespec='seconds')}] {message}\n")
+        except Exception:
+            pass
 
     def _should_stop(self) -> bool:
         """Check if we should stop (user active or stop requested)."""

{codent-0.3.1 → codent-0.3.3}/core/tool_helpers.py

@@ -132,6 +132,23 @@ def extract_fenced_tool_requests(text: str) -> list:
                     except json.JSONDecodeError:
                         idx = brace + 1
 
+    # b3) Parenthesized form: (tool_name\n {...})  — Qwen3 emit fallback
+    # Example: "(web_search\n {\"query\": \"...\"})"
+    if "(" in text:
+        for m in re.finditer(r'\(\s*([a-z_][a-z0-9_]*)\s+', text):
+            name = m.group(1)
+            # Try raw_decode JSON starting after the tool name
+            tail = text[m.end():]
+            brace = tail.find("{")
+            if brace == -1 or brace > 5:
+                continue
+            try:
+                obj, _ = json.JSONDecoder().raw_decode(tail[brace:])
+                if isinstance(obj, dict):
+                    tool_calls.append({"name": name, "args": obj})
+            except json.JSONDecodeError:
+                pass
+
     # c) Bare JSON tool call (Ollama Qwen3 fallback)
     # Pattern: yanıt bir tool call JSON ile başlıyor veya tek satır
     if not tool_calls and text.strip().startswith(("{", "[")):

{codent-0.3.1 → codent-0.3.3}/core/tools.py

@@ -779,6 +779,14 @@ def system_search(query: str, type: str = None, extension: str = None,
                 extension=extension, project=project
             )
 
+        # META veri filtresi: log/pheromone/inbox/__pycache__ dosyaları DATA değil
+        _META_DIR_TOKENS = ("/logs/", "/.cont/hive/pheromone/",
+                            "/.cont/hive/inbox/", "/__pycache__/")
+        results = [
+            r for r in results
+            if not any(tok in r.get("path", "") for tok in _META_DIR_TOKENS)
+        ]
+
         if not results:
             return json.dumps({
                 "status": "not_found",

{codent-0.3.1 → codent-0.3.3}/core/trace.py

@@ -226,6 +226,40 @@ _ROLE_COLORS = {
 }
 _ROLE_TAGS = {"system": "S", "user": "U", "assistant": "A", "tool": "T"}
 
+# FULL-mode role styling: tag → (rich color, label)
+_FULL_ROLE_STYLE = {
+    "system":    ("dim",          "S"),
+    "user":      ("bold white",   "U"),
+    "assistant": ("green",        "A"),
+    "tool":      ("cyan",         "T"),
+}
+
+
+def _box_lines(title: str, body_lines: list, color: str = "yellow", width: int = 70) -> list:
+    """Build a Rich-markup box: ┌─ title ──┐ / │ ... │ / └────────┘"""
+    inner_w = width - 2
+    title_str = f" {title} "
+    top = f"[{color}]┌─{title_str}{'─' * max(0, inner_w - len(title_str) - 1)}┐[/{color}]"
+    out = [top]
+    for ln in body_lines:
+        # Strip rich tags for length calc
+        plain = re.sub(r"\[/?[^\]]+\]", "", ln)
+        pad = max(0, inner_w - len(plain) - 1)
+        out.append(f"[{color}]│[/{color}] {ln}{' ' * pad}[{color}]│[/{color}]")
+    out.append(f"[{color}]└{'─' * inner_w}┘[/{color}]")
+    return out
+
+
+def _budget_bar(used: int, total: int, width: int = 16) -> str:
+    """ASCII progress bar: ████░░░░░░░░ 3/12"""
+    if total <= 0:
+        return ""
+    filled = int(round(width * used / total))
+    filled = max(0, min(width, filled))
+    bar = "█" * filled + "░" * (width - filled)
+    color = "green" if used < total * 0.7 else ("yellow" if used < total else "red")
+    return f"[{color}]{bar}[/{color}] [dim]{used}/{total}[/dim]"
+
 
 # ── Public hooks ─────────────────────────────────────────────────
 
@@ -237,6 +271,8 @@ def trace_llm_request(
     tool_choice: Optional[str],
     base_url: str = "",
     iteration: int = 0,
+    budget_used: int = 0,
+    budget_total: int = 0,
 ):
     """Hook: BEFORE LLM API call. Caller must guard with is_off()."""
     if _level == TraceLevel.OFF:
@@ -254,42 +290,30 @@ def trace_llm_request(
     tc = tool_choice or "auto"
 
     if _level == TraceLevel.STORY:
-        # ── STORY: grouped turn header + input section ──
-        _rich("")
-        _rich(f"[bold white on #333333] 🎬 TURN #{_turn_counter} [/bold white on #333333]"
-              f"  [dim]{provider}[/dim] [bold]{model}[/bold]"
-              f"  [dim]tools={tools_str}  ~{est_tok} tok[/dim]")
-
-        # Section A: INPUT (to LLM) — last K messages
-        _rich("[bold #6699cc]  🧠 INPUT (to LLM)[/bold #6699cc]")
-        tail = messages[-_last_k:]
-        for m in tail:
-            role = m.get("role", "?")
-            tag = _ROLE_TAGS.get(role, "?")
-            color = _ROLE_COLORS.get(role, "dim")
-            raw_content = m.get("content", "") or ""
-
-            # Special: tool results show tool name
-            if role == "tool":
-                tool_id = m.get("tool_call_id", "")
-                short = _sanitize(_preview(raw_content, 120))
-                _rich(f"    [{color}]\\[T][/{color}] [dim]{short}[/dim]")
-            else:
-                short = _sanitize(_preview(raw_content, 140))
-                _rich(f"    [{color}]\\[{tag}][/{color}] {short}")
-
-    elif _level == TraceLevel.COMPACT or _level == TraceLevel.FULL:
-        # ── COMPACT/FULL: technical one-liner ──
+        # STORY: minimal turn header only — intent+result come from
+        # trace_story_intent and trace_tool_result.
+        _rich(f"\n[bold white on #333333] 🎬 TURN #{_turn_counter} [/bold white on #333333] "
+              f"[dim]{provider} {model} ~{est_tok}tok[/dim]")
+
+    elif _level == TraceLevel.COMPACT:
         _emit(
             f"LLM→ provider={provider} model={model} msgs={msg_count} "
             f"roles={roles} tools={tools_str} tool_choice={tc} est_tok_in={est_tok}"
         )
-        if _level >= TraceLevel.FULL:
-            _emit(f"  base_url={_sanitize(base_url)}")
-            for m in messages[-_last_k:]:
-                r = _ROLE_TAGS.get(m.get("role", "?"), "?")
-                content = _sanitize(_preview(m.get("content", "") or "", 200))
-                _emit(f"  [{r}] {content}")
+
+    elif _level == TraceLevel.FULL:
+        # FULL: rich formatted LLM INPUT block + budget bar
+        _rich("")
+        _rich(f"[bold white on #2255aa] 🎬 TURN #{_turn_counter} [/bold white on #2255aa] "
+              f"[dim]{provider} • {model} • ~{est_tok}tok • tools={tools_str}/{tc}[/dim]")
+        if budget_total > 0:
+            _rich(f"  [bold]📊 BÜTÇE:[/bold] {_budget_bar(budget_used, budget_total)} call")
+        _rich("[bold #6699cc]🧠 LLM INPUT[/bold #6699cc]")
+        for m in messages[-_last_k:]:
+            role = m.get("role", "?")
+            color, tag = _FULL_ROLE_STYLE.get(role, ("dim", "?"))
+            content = _sanitize(_preview(m.get("content", "") or "", 220))
+            _rich(f"  [{color}]\\[{tag}][/{color}] {content}")
 
     _emit_jsonl({
         "event": "llm_request",
@@ -318,30 +342,27 @@ def trace_llm_response(
     out_chars = len(content or "")
 
     if _level == TraceLevel.STORY:
-        # ── STORY: OUTPUT section ──
-        _rich(f"[bold #66cc99]  🎭 OUTPUT (from LLM)[/bold #66cc99]"
-              f"  [dim]{latency_ms}ms  {out_chars} chars[/dim]")
-
-        if tool_calls_count:
-            names = ", ".join(tool_names[:4]) if tool_names else f"{tool_calls_count} tool(s)"
-            _rich(f"    [yellow]→ Tool calls: {names}[/yellow]")
+        # STORY: minimal — trace_story_intent handles intent+chain
+        if not tool_calls_count and content and content.strip():
+            short = _sanitize(_preview(content, 200))
+            _rich(f"  [green]💬[/green] [dim]{short}[/dim] [dim]({latency_ms}ms)[/dim]")
 
-        if content and content.strip():
-            lines = content.strip().split("\n")
-            for ln in lines[:_max_lines]:
-                short = _sanitize(ln[:200])
-                _rich(f"    [dim]{short}[/dim]")
-
-    elif _level == TraceLevel.COMPACT or _level == TraceLevel.FULL:
-        # ── COMPACT/FULL: technical one-liner ──
+    elif _level == TraceLevel.COMPACT:
         line = f"LLM← stop={finish_reason} out_chars={out_chars} latency={latency_ms}ms"
         if tool_calls_count:
             line += f" tool_calls={tool_calls_count}"
         _emit(line)
 
-        if _level >= TraceLevel.FULL and content:
-            for ln in (content or "").split("\n")[:_max_lines]:
-                _emit(f"  | {_sanitize(ln[:200])}")
+    elif _level == TraceLevel.FULL:
+        # FULL: rich model thought block
+        _rich(f"[bold #66cc99]💭 MODEL DÜŞÜNCE[/bold #66cc99] "
+              f"[dim]{latency_ms}ms • {out_chars} chars • stop={finish_reason}[/dim]")
+        if content and content.strip():
+            for ln in content.strip().split("\n")[:_max_lines]:
+                _rich(f"  [dim italic]\"{_sanitize(ln[:200])}\"[/dim italic]")
+        if tool_calls_count:
+            names = ", ".join(tool_names[:4]) if tool_names else f"{tool_calls_count} tool(s)"
+            _rich(f"  [yellow]→ next: {names}[/yellow]")
 
     _emit_jsonl({
         "event": "llm_response",
@@ -365,11 +386,23 @@ def trace_tool_call(
     h = _args_hash(args)
 
     if _level == TraceLevel.STORY:
-        # ── STORY: narrative tool beat ──
         human = _sanitize(_human_args(tool_name, args))
         _rich(f"  [bold yellow]⚙️  {tool_name}[/bold yellow] [dim]{human}[/dim]")
+
+    elif _level == TraceLevel.FULL:
+        # FULL: 🔧 boxed tool call
+        _rich("[bold yellow]🔧 TOOL CALL[/bold yellow]")
+        body = []
+        for k, v in list(args.items())[:6]:
+            val = _sanitize(_preview(str(v), 60))
+            body.append(f"[dim]{k}:[/dim] {val}")
+        if not body:
+            body = ["[dim](no args)[/dim]"]
+        for ln in _box_lines(tool_name, body, color="yellow", width=72):
+            _rich(ln)
+
     else:
-        # ── COMPACT/FULL: technical ──
+        # COMPACT
         prev = _sanitize(_preview(json.dumps(args, ensure_ascii=False), 160))
         _emit(f"TOOL→ {tool_name} args_hash={h} args_preview=\"{prev}\"")
 
@@ -398,15 +431,25 @@ def trace_tool_result(
     preview = _sanitize(_preview(result_preview, 120))
 
     if _level == TraceLevel.STORY:
-        # ── STORY: narrative result ──
         if error:
             err_short = _sanitize(_preview(str(error), 80))
             _rich(f"    [bold red]❌ ERROR[/bold red] [dim]{err_short}  ({latency_ms}ms)[/dim]")
         else:
             _rich(f"    [green]✅ ok[/green] [dim]{result_chars} chars  {latency_ms}ms[/dim]"
                   f"  [dim italic]{preview[:80]}[/dim italic]")
+
+    elif _level == TraceLevel.FULL:
+        if error:
+            err_short = _sanitize(_preview(str(error), 100))
+            _rich(f"  [bold red]→ ❌ {err_short}[/bold red] [dim]({latency_ms}ms)[/dim]")
+        else:
+            _rich(f"  [bold green]→ ✅ {result_chars} chars[/bold green] [dim]({latency_ms}ms)[/dim]")
+            if result_preview:
+                for ln in result_preview.split("\n")[:_max_lines]:
+                    _rich(f"    [cyan]{_sanitize(ln[:200])}[/cyan]")
+
     else:
-        # ── COMPACT/FULL: technical ──
+        # COMPACT
         status = "err" if error else "ok"
         line = f"TOOL← {status} {tool_name} chars={result_chars} latency={latency_ms}ms"
         if error:
@@ -415,10 +458,6 @@ def trace_tool_result(
             line += f" preview=\"{preview}\""
         _emit(line)
 
-        if _level >= TraceLevel.FULL and result_preview:
-            for ln in result_preview.split("\n")[:_max_lines]:
-                _emit(f"  | {_sanitize(ln[:200])}")
-
     _emit_jsonl({
         "event": "tool_result",
         "tool_name": tool_name,
@@ -538,6 +577,18 @@ def trace_memory_recall(
                 content = _sanitize(_preview(snip.get("content", ""), 120))
                 color = "green" if level == "HIGH" else "dim"
                 _rich(f"    [{color}]\\[{level}][/{color}] {content}")
+    elif _level == TraceLevel.FULL:
+        snips = list(top_snippets or [])
+        _rich(f"[bold #cc99ff]🧠 MEMORY[/bold #cc99ff] [dim]({source}, {result_count} hits)[/dim]")
+        for i, snip in enumerate(snips[:4]):
+            is_last = (i == min(3, len(snips) - 1))
+            branch = "└─" if is_last else "├─"
+            level = snip.get("level", "?")
+            content = _sanitize(_preview(snip.get("content", ""), 120))
+            color = "yellow" if level == "HIGH" else "dim"
+            _rich(f"  [{color}]{branch} [{level}][/{color}] {content}")
+        if not snips:
+            _rich(f"  [dim]└─ (no snippets)[/dim]")
     else:
         _emit(f"MEMORY {source}: {entity_count} entities → {result_count} results")
         for snip in (top_snippets or [])[:2]:

{codent-0.3.1 → codent-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codent"
-version = "0.3.1"
+version = "0.3.3"
 requires-python = ">=3.10"
 dependencies = [
     "rich>=13.0",
@@ -26,7 +26,14 @@ cont = "cont:main"
 
 [tool.setuptools]
 py-modules = ["cont", "cont_watcher"]
-packages = ["core", "cont_ui"]
+packages = ["core", "cont_ui", "vendor", "vendor.wheels", "vendor.bin"]
+
+[tool.setuptools.package-dir]
+vendor = "vendor"
+"vendor.wheels" = "vendor/wheels"
+"vendor.bin" = "vendor/bin"
 
 [tool.setuptools.package-data]
 "*" = ["*.toml", "*.html", "*.yaml"]
+"vendor.wheels" = ["*.whl"]
+"vendor.bin" = ["ollama"]