multacd 1.0.0__py3-none-any.whl

core/llm_client.py

@@ -0,0 +1,347 @@
+"""LLM client — wrapper LiteLLM: streaming + tool call + retry.
+
+Dipakai oleh agent loop (Step 7) lewat async generator:
+
+    client = setup_client(config)
+    async for event in client.stream_completion(messages, tools):
+        if isinstance(event, StreamText):
+            ... tampilkan event.content ke TUI ...
+        elif isinstance(event, StreamDone):
+            ... event.text = teks penuh, event.tool_calls = [ToolCallRequest] ...
+
+Test cepat tanpa API key (logika akumulasi + error mapping):
+    python -m core.llm_client
+Test live (butuh ~/.multacd/config.yaml yang valid):
+    python -m core.llm_client --live "hello"
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from typing import Any
+
+import litellm
+from litellm import (
+    APIConnectionError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+)
+
+from core.config import Config, load_config
+
+MAX_CONNECTION_RETRIES = 3
+MAX_RATE_LIMIT_RETRIES = 3
+RETRY_BASE_DELAY = 2.0  # detik, exponential backoff
+REQUEST_TIMEOUT = 120.0
+
+
+class LLMError(Exception):
+    """Error LLM dengan pesan yang friendly — tampilkan langsung ke user."""
+
+
+@dataclass
+class ToolCallRequest:
+    """Satu tool call yang diminta LLM (sudah dirakit dari fragment streaming)."""
+
+    id: str
+    name: str
+    arguments: dict[str, Any]
+
+
+@dataclass
+class StreamText:
+    """Potongan teks baru dari LLM (tampilkan real-time ke TUI)."""
+
+    content: str
+
+
+@dataclass
+class StreamDone:
+    """Stream selesai: teks penuh + daftar tool call (bisa kosong)."""
+
+    text: str
+    tool_calls: list[ToolCallRequest] = field(default_factory=list)
+
+
+StreamEvent = StreamText | StreamDone
+
+
+def setup_client(config: Config) -> LLMClient:
+    """Init client dari config (LiteLLM stateless — ini bungkus kwargs + retry)."""
+    return LLMClient(config)
+
+
+class LLMClient:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def _base_kwargs(self) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {
+            "model": self.config.model,
+            "api_key": self.config.api_key,
+            "max_tokens": self.config.max_tokens,
+            "temperature": self.config.temperature,
+            "timeout": REQUEST_TIMEOUT,
+        }
+        if self.config.api_base:
+            kwargs["api_base"] = self.config.api_base
+        return kwargs
+
+    async def stream_completion(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> AsyncIterator[StreamEvent]:
+        """Kirim messages ke LLM, yield StreamText lalu diakhiri satu StreamDone.
+
+        Retry hanya dilakukan jika stream BELUM menghasilkan teks apapun
+        (aman — tidak ada duplikasi output). Gagal di tengah stream
+        langsung raise LLMError.
+        """
+        kwargs = self._base_kwargs()
+        if tools:
+            kwargs["tools"] = tools
+
+        conn_attempts = 0
+        rate_attempts = 0
+        while True:
+            accumulator = _StreamAccumulator()
+            yielded_any_text = False
+            try:
+                stream = await litellm.acompletion(stream=True, messages=messages, **kwargs)
+                async for chunk in stream:
+                    for event in accumulator.feed(chunk):
+                        if isinstance(event, StreamText) and event.content:
+                            yielded_any_text = True
+                        yield event
+                yield accumulator.done()
+                return
+            except RateLimitError as e:
+                rate_attempts += 1
+                if rate_attempts > MAX_RATE_LIMIT_RETRIES or yielded_any_text:
+                    raise LLMError(
+                        "⏳ Rate limit dari provider (429) — "
+                        f"sudah retry {MAX_RATE_LIMIT_RETRIES}x, masih dibatasi. "
+                        "Tunggu sebentar lalu coba lagi."
+                    ) from e
+                await asyncio.sleep(RETRY_BASE_DELAY * (2 ** (rate_attempts - 1)))
+            except APIConnectionError as e:
+                conn_attempts += 1
+                if conn_attempts > MAX_CONNECTION_RETRIES or yielded_any_text:
+                    raise LLMError(
+                        "🌐 Gagal konek ke LLM provider "
+                        f"({MAX_CONNECTION_RETRIES}x percobaan). "
+                        "Cek koneksi internet / api_base di config."
+                    ) from e
+                await asyncio.sleep(RETRY_BASE_DELAY * conn_attempts)
+            except AuthenticationError as e:
+                raise LLMError(
+                    "🔑 API key ditolak provider. Cek `api_key` di ~/.multacd/config.yaml "
+                    "(BYOK — pastikan key cocok dengan `model` yang dipilih)."
+                ) from e
+            except NotFoundError as e:
+                raise LLMError(
+                    f"🔍 Model `{self.config.model}` tidak ditemukan oleh provider. "
+                    "Cek penulisan `model` di config (format LiteLLM, mis. "
+                    "`anthropic/claude-sonnet-4-6`, `openai/gpt-4o`)."
+                ) from e
+            except LLMError:
+                raise
+            except Exception as e:
+                raise LLMError(f"❌ LLM error tak terduga ({type(e).__name__}): {e}") from e
+
+    async def complete(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> StreamDone:
+        """Non-streaming: kumpulkan stream jadi satu hasil (buat test/debug)."""
+        full: StreamDone | None = None
+        async for event in self.stream_completion(messages, tools):
+            if isinstance(event, StreamDone):
+                full = event
+        assert full is not None
+        return full
+
+
+def _get(obj: Any, key: str, default: Any = None) -> Any:
+    """Ambil atribut ATAU key dict — chunk LiteLLM bisa berbentuk keduanya."""
+    if obj is None:
+        return default
+    if isinstance(obj, dict):
+        return obj.get(key, default)
+    return getattr(obj, key, default)
+
+
+class _StreamAccumulator:
+    """Rakit fragment streaming LiteLLM jadi teks + tool call utuh."""
+
+    def __init__(self) -> None:
+        self._text_parts: list[str] = []
+        self._calls: dict[int, dict[str, Any]] = {}
+
+    def feed(self, chunk: Any) -> list[StreamText]:
+        events: list[StreamText] = []
+        choices = _get(chunk, "choices", []) or []
+        if not choices:
+            return events
+        delta = _get(choices[0], "delta", {}) or {}
+
+        content = _get(delta, "content")
+        if content:
+            self._text_parts.append(content)
+            events.append(StreamText(content))
+
+        for tc in _get(delta, "tool_calls", None) or []:
+            index = _get(tc, "index", 0) or 0
+            slot = self._calls.setdefault(index, {"id": "", "name": "", "args": ""})
+            tc_id = _get(tc, "id")
+            if tc_id:
+                slot["id"] = tc_id
+            func = _get(tc, "function", {}) or {}
+            name = _get(func, "name")
+            if name:
+                slot["name"] = name
+            args = _get(func, "arguments")
+            if args:
+                slot["args"] += args
+        return events
+
+    def done(self) -> StreamDone:
+        calls: list[ToolCallRequest] = []
+        for index in sorted(self._calls):
+            slot = self._calls[index]
+            name = slot["name"]
+            if not name:
+                continue  # fragment tanpa nama — abaikan
+            raw_args = slot["args"] or "{}"
+            try:
+                arguments = json.loads(raw_args)
+            except json.JSONDecodeError as e:
+                raise LLMError(
+                    f"❌ LLM mengirim tool_call `{name}` dengan argumen bukan JSON valid: {e}"
+                ) from e
+            if not isinstance(arguments, dict):
+                raise LLMError(
+                    f"❌ Argumen tool_call `{name}` harus object JSON, dapat: {type(arguments).__name__}"
+                )
+            calls.append(ToolCallRequest(id=slot["id"] or f"call_{index}", name=name, arguments=arguments))
+        return StreamDone(text="".join(self._text_parts), tool_calls=calls)
+
+
+# ── Self-test (tanpa API key) ──────────────────────────────────────────────
+
+def _fake_chunk(text: str = "", tool_deltas: list[dict] | None = None) -> dict:
+    return {
+        "choices": [
+            {"delta": {"content": text, "tool_calls": tool_deltas or []}},
+        ]
+    }
+
+
+async def _self_test() -> None:
+    # 1. Teks murni
+    acc = _StreamAccumulator()
+    events: list[StreamEvent] = []
+    for ch in [_fake_chunk("Halo, "), _fake_chunk("dunia!")]:
+        events += acc.feed(ch)
+    done = acc.done()
+    assert [e.content for e in events] == ["Halo, ", "dunia!"], events
+    assert done.text == "Halo, dunia!" and done.tool_calls == []
+
+    # 2. Tool call terpecah jadi fragment (kasus nyata streaming)
+    acc = _StreamAccumulator()
+    acc.feed(_fake_chunk("bentar, ", [{"index": 0, "id": "call_1",
+            "function": {"name": "read_file", "arguments": '{"path": "ma'}}]))
+    acc.feed(_fake_chunk("", [{"index": 0, "function": {"arguments": 'in.py"}'}}]))
+    acc.feed(_fake_chunk("", [{"index": 1, "id": "call_2",
+            "function": {"name": "bash", "arguments": '{"command": "ls"}'}}]))
+    done = acc.done()
+    assert done.text == "bentar, ", done.text
+    assert len(done.tool_calls) == 2, done.tool_calls
+    assert done.tool_calls[0].name == "read_file"
+    assert done.tool_calls[0].arguments == {"path": "main.py"}, done.tool_calls[0].arguments
+    assert done.tool_calls[1].name == "bash"
+
+    # 3. Argumen bukan JSON → LLMError (bukan crash)
+    acc = _StreamAccumulator()
+    acc.feed(_fake_chunk("", [{"index": 0, "function": {"name": "x", "arguments": "{oops"}}]))
+    try:
+        acc.done()
+    except LLMError:
+        pass
+    else:
+        raise AssertionError("argumen invalid harus raise LLMError")
+
+    # 4. Error mapping: auth, not-found, retry koneksi 3x
+    from unittest.mock import patch
+
+    cfg = Config(model="openai/gpt-4o", api_key="sk-bad")
+    client = LLMClient(cfg)
+
+    async def _drain(c: LLMClient) -> StreamDone:
+        async for ev in c.stream_completion([{"role": "user", "content": "hi"}]):
+            if isinstance(ev, StreamDone):
+                return ev
+        raise AssertionError("unreachable")
+
+    with patch("core.llm_client.litellm.acompletion", side_effect=AuthenticationError("bad", "x", "x")):
+        try:
+            await _drain(client)
+        except LLMError as e:
+            assert "API key" in str(e), e
+        else:
+            raise AssertionError("auth error harus jadi LLMError")
+
+    with patch("core.llm_client.litellm.acompletion", side_effect=NotFoundError("nf", "x", "x")):
+        try:
+            await _drain(client)
+        except LLMError as e:
+            assert "tidak ditemukan" in str(e), e
+        else:
+            raise AssertionError("not-found harus jadi LLMError")
+
+    calls = {"n": 0}
+
+    async def _flaky(*a: Any, **k: Any) -> Any:
+        calls["n"] += 1
+        raise APIConnectionError("down", "x", "x")
+
+    with (patch("core.llm_client.litellm.acompletion", side_effect=_flaky),
+          patch("core.llm_client.asyncio.sleep", return_value=None)):
+        try:
+            await _drain(client)
+        except LLMError as e:
+            assert "Gagal konek" in str(e), e
+        else:
+            raise AssertionError("conn error harus jadi LLMError")
+    assert calls["n"] == MAX_CONNECTION_RETRIES + 1, calls
+
+    print("✅ llm_client self-test OK (akumulasi + error mapping + retry)")
+
+
+async def _live_test(prompt: str) -> None:
+    cfg = load_config()
+    client = setup_client(cfg)
+    print(f"model: {cfg.model} — streaming...\n---")
+    async for event in client.stream_completion([{"role": "user", "content": prompt}]):
+        if isinstance(event, StreamText):
+            print(event.content, end="", flush=True)
+        elif isinstance(event, StreamDone):
+            print(f"\n---\n✅ done. tool_calls={len(event.tool_calls)}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--live", metavar="PROMPT", default=None,
+                        help="test live ke provider (butuh config valid)")
+    args = parser.parse_args()
+    if args.live:
+        asyncio.run(_live_test(args.live))
+    else:
+        asyncio.run(_self_test())

core/mode_manager.py

@@ -0,0 +1,342 @@
+"""Mode manager — mode agent + parse slash command.
+
+Mode aktif:
+    code      → Coding Agent (penuh di Phase 2)
+    research  → Research Agent (penuh di Phase 3)
+    personal  → Personal Agent (penuh di Phase 4)
+
+Command yang dikenal (lihat HELP_TEXT):
+    /code /research /personal /clear /scan /model [nama] /help /soul
+
+Command di-intercept sebelum LLM (lihat core/agent_loop.py):
+tidak masuk history, tidak panggil LLM.
+
+Test cepat:
+    python -m core.mode_manager
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.config import Config
+
+MODE_CODE = "code"
+MODE_RESEARCH = "research"
+MODE_PERSONAL = "personal"
+
+HELP_TEXT = (
+    "📖 Command multacd:\n"
+    "  /code          → mode Coding Agent (default)\n"
+    "  /research      → mode Research Agent (riset internet + sumber)\n"
+    "  /personal      → Personal Agent (bot, jadwal, briefing, daemon)\n"
+    "  /clear         → bersihkan history, mulai sesi baru\n"
+    "  /scan          → scan ulang codebase project\n"
+    "  /model [nama]  → lihat / ganti model (cth: /model openai/gpt-4o)\n"
+    "  /soul          → tampilkan kepribadian agent yang aktif\n"
+    "  /help          → tampilkan pesan ini"
+)
+
+# Single source buat slash palette (nama + deskripsi singkat).
+PALETTE_COMMANDS: tuple[tuple[str, str], ...] = (
+    ("/code", "Switch to Coding Agent mode"),
+    ("/research", "Switch to Research Agent mode"),
+    ("/personal", "Switch to Personal Agent mode"),
+    ("/clear", "Clear conversation history"),
+    ("/scan", "Re-scan codebase"),
+    ("/model", "Switch LLM model"),
+    ("/soul", "Show active soul.md"),
+    ("/help", "Show all commands"),
+)
+
+# Command yang butuh argumen lanjutan → Enter = autocomplete, bukan submit.
+COMMANDS_WITH_ARGS = frozenset({"/model"})
+
+MODE_PROMPTS = {
+    MODE_CODE: (
+        "Kamu sedang dalam Coding Agent mode. "
+        "Kamu punya akses ke: filesystem, shell, git, "
+        "run_python, lint_python, run_tests. "
+        "Fokus membantu user dengan kode dan development workflow. "
+        "Smart commit flow: user minta commit → jalankan git_status + git_diff dulu, "
+        "tulis pesan conventional commits (feat/fix/refactor/docs/chore), "
+        "lalu git_add + git_commit (dialog konfirmasi = persetujuan user). "
+        "Jangan push ke branch main/master/production/prod/release/stable "
+        "tanpa izin eksplisit — kalau tool menolak, tawarkan ke user: "
+        "tetap push, buat branch baru, atau batal. "
+        "Kalau merge conflict: analisis ours-vs-theirs, suggest resolusi, "
+        "apply via edit_file + git_add hanya setelah user setuju. "
+        "Kalau run_python/lint_python/run_tests gagal atau error: baca output-nya, "
+        "jelaskan penyebab ke user, suggest fix — jangan auto-fix tanpa izin."
+    ),
+    MODE_RESEARCH: (
+        "Kamu sedang dalam Research Agent mode. "
+        "Kamu punya akses ke: web_search, web_scrape, quick_research, "
+        "deep_research, export_research. "
+        "Panduan: untuk pertanyaan butuh jawaban cepat dengan sumber → "
+        "quick_research; untuk topik kompleks butuh laporan mendalam → "
+        "deep_research. Selalu kutip sumber dalam jawaban. "
+        "Kalau scraping gagal, gunakan snippet dan beritahu user. "
+        "Tawarkan export ke .md setelah research selesai. "
+        "Deteksi dan flag informasi yang kontradiktif antar sumber."
+    ),
+    MODE_PERSONAL: (
+        "Kamu sedang dalam Personal Agent mode. "
+        "Kamu punya akses ke: send_telegram, schedule_job, cancel_job, "
+        "get_jobs, daemon_status, user_manager, generate_briefing, "
+        "web_search, quick_research, read tools, git_status, remember, "
+        "recall. "
+        "Tugasmu: kelola bot Telegram (tambah/hapus user), kelola scheduled "
+        "jobs, cek status daemon, buat & kirim briefing, kirim pesan manual. "
+        "Aturan: aksi berdampak (tambah/hapus user, schedule/cancel, kirim "
+        "pesan/file, generate briefing) selalu konfirmasi dulu — tool sudah "
+        "ASK, hormati jawaban user. "
+        "'Kirim briefing sekarang' = konfirmasi, lalu generate_briefing "
+        "(send_to_admin=True kalau user mau dikirim ke Telegram). "
+        "Jangan panggil tool yang tidak ada di daftar."
+    ),
+}
+
+# Tool aktif di mode /personal: personal tools + baca + riset ringan.
+# Tulis/shell/eksekusi TIDAK ada — mode ini dashboard manajemen, aman.
+PERSONAL_MODE_TOOLS = [
+    "send_telegram",
+    "schedule_job",
+    "cancel_job",
+    "get_jobs",
+    "daemon_status",
+    "user_manager",
+    "generate_briefing",
+    "web_search",
+    "quick_research",
+    "read_file",
+    "read_many_files",
+    "glob",
+    "grep",
+    "list_dir",
+    "scan_codebase",
+    "git_status",
+    "remember",
+    "recall",
+]
+
+# Tool aktif di mode /research: research tools + read tools Phase 1
+# (web_fetch, read_file, dll tetap aktif — lihat PLAN-phase3 §10).
+RESEARCH_MODE_TOOLS = [
+    "web_search",
+    "web_scrape",
+    "quick_research",
+    "deep_research",
+    "export_research",
+    "read_file",
+    "read_many_files",
+    "glob",
+    "grep",
+    "list_dir",
+    "scan_codebase",
+    "web_fetch",
+]
+
+
+@dataclass
+class CommandResult:
+    """Hasil parse slash command.
+
+    is_command False → bukan command, teruskan ke LLM seperti biasa.
+    action: "clear" | "scan" | "mode" | None — aksi UI yang harus
+    dilakukan caller (agent_loop handle clear; TUI sync mode/model).
+    """
+
+    is_command: bool
+    message: str = ""
+    action: str | None = None
+
+
+class ModeManager:
+    """Pegang mode aktif + parse /command. Default: /code.
+
+    `rescan_fn`: callback () -> str pesan display; dipasang app TUI
+    agar /scan refresh project context + composer (lihat tui/app.py).
+    Tanpa itu, /scan cuma return sinyal tanpa eksekusi.
+    """
+
+    def __init__(self, config: Config | None = None, soul: str = "",
+                 rescan_fn: Callable[[], str] | None = None) -> None:
+        self._mode = MODE_CODE
+        self._config = config
+        self._soul = soul
+        self._rescan_fn = rescan_fn
+        self._git_enabled = True
+
+    def set_git_enabled(self, enabled: bool) -> None:
+        """Matikan kalau folder bukan git repo → tool git disembunyikan."""
+        self._git_enabled = enabled
+
+    def get_mode(self) -> str:
+        return self._mode
+
+    def set_soul(self, soul: str) -> None:
+        self._soul = soul
+
+    def set_mode(self, mode: str) -> str:
+        if mode not in (MODE_CODE, MODE_RESEARCH, MODE_PERSONAL):
+            return f"❓ Mode tidak dikenal: {mode}. Pilihan: /code /research /personal"
+        self._mode = mode
+        return f"✅ Mode: {mode}"
+
+    def get_mode_prompt(self) -> str:
+        return MODE_PROMPTS[self._mode]
+
+    def get_active_tools(self) -> list[str] | None:
+        """None = semua tool aktif. Bukan git repo → list tanpa tool git.
+
+        Mode /research → list eksplisit (research + read tools).
+        """
+        if self._mode == MODE_RESEARCH:
+            return list(RESEARCH_MODE_TOOLS)
+        if self._mode == MODE_PERSONAL:
+            return list(PERSONAL_MODE_TOOLS)
+        if self._git_enabled:
+            return None
+        from core.permissions import GIT_TOOLS, KNOWN_TOOLS
+        return sorted(KNOWN_TOOLS - GIT_TOOLS)
+
+    @staticmethod
+    def is_command(text: str) -> bool:
+        return text.strip().startswith("/")
+
+    def handle_command(self, user_input: str) -> CommandResult:
+        text = user_input.strip()
+        if not text.startswith("/"):
+            return CommandResult(is_command=False)
+        parts = text.split(None, 1)
+        cmd = parts[0].lower()
+        arg = parts[1].strip() if len(parts) > 1 else ""
+
+        if cmd == "/code":
+            return CommandResult(True, self.set_mode(MODE_CODE), "mode")
+        if cmd == "/research":
+            msg = self.set_mode(MODE_RESEARCH)
+            return CommandResult(
+                True,
+                f"{msg} — tanya apa saja, jawaban berkutipan sumber. "
+                "Ctrl+R panel sumber.",
+                "mode")
+        if cmd == "/personal":
+            msg = self.set_mode(MODE_PERSONAL)
+            try:
+                from tools.personal.daemon_status import daemon_status
+                snapshot = daemon_status()["result"]
+            except Exception as e:
+                snapshot = f"(status daemon gagal dibaca: {e})"
+            return CommandResult(
+                True,
+                f"{msg} 🏠 — kelola bot, jadwal, briefing, daemon.\n"
+                f"{snapshot}",
+                "mode")
+        if cmd == "/clear":
+            return CommandResult(True, "🧹 History dibersihkan — mulai sesi baru.", "clear")
+        if cmd == "/scan":
+            if self._rescan_fn is None:
+                return CommandResult(True, "🔍 Scan ulang belum wiring (jalan di TUI).", "scan")
+            try:
+                return CommandResult(True, self._rescan_fn(), "scan")
+            except Exception as e:
+                return CommandResult(True, f"❌ Scan gagal ({type(e).__name__}): {e}", None)
+        if cmd == "/model":
+            if not arg:
+                current = self._config.model if self._config else "?"
+                return CommandResult(True, f"🤖 Model aktif: {current}", None)
+            if self._config is None:
+                return CommandResult(True, "❌ Config tidak tersedia — model tidak bisa diganti.", None)
+            if not arg.strip():
+                return CommandResult(True, "❌ Nama model tidak boleh kosong.", None)
+            self._config.model = arg.strip()
+            return CommandResult(True, f"✅ Model diganti ke: {self._config.model}", "model")
+        if cmd == "/help":
+            return CommandResult(True, HELP_TEXT, None)
+        if cmd == "/soul":
+            return CommandResult(True, self._soul or "(soul kosong)", None)
+        return CommandResult(True, f"❓ Command tidak dikenal: {parts[0]}. Ketik /help.", None)
+
+
+if __name__ == "__main__":
+    from core.config import Config as _Config
+
+    cfg = _Config(model="m", api_key="k")
+    mm = ModeManager(config=cfg, soul="soul-test")
+
+    # 1. Default mode code + prompt-nya
+    assert mm.get_mode() == "code"
+    assert "Coding Agent" in mm.get_mode_prompt()
+    assert "conventional" in mm.get_mode_prompt()  # smart commit flow
+    assert mm.get_active_tools() is None  # semua tool aktif
+    mm.set_git_enabled(False)
+    active = mm.get_active_tools()
+    assert active is not None and not any(t.startswith("git_") for t in active), active
+    assert "read_file" in active and "bash" in active
+    mm.set_git_enabled(True)
+    assert mm.get_active_tools() is None
+
+    # 2. Bukan command → teruskan ke LLM
+    r = mm.handle_command("halo, apa kabar?")
+    assert r.is_command is False, r
+
+    # 3. /code (case-insensitive) + /help + /soul
+    assert mm.handle_command("/CODE").message == "✅ Mode: code"
+    assert "/scan" in mm.handle_command("/help").message
+    assert mm.handle_command("/soul").message == "soul-test"
+
+    # 4. /research aktif (Phase 3); /personal aktif (Phase 4)
+    r = mm.handle_command("/research")
+    assert mm.get_mode() == "research" and r.action == "mode", (r, mm.get_mode())
+    assert "quick_research" in mm.get_mode_prompt()
+    active = mm.get_active_tools()
+    assert active is not None and "quick_research" in active, active
+    assert "deep_research" in active and "web_search" in active
+    assert "read_file" in active and "web_fetch" in active
+    assert "git_commit" not in active and "bash" not in active
+    mm.handle_command("/code")
+    assert mm.get_mode() == "code" and mm.get_active_tools() is None
+    r = mm.handle_command("/personal")
+    assert mm.get_mode() == "personal" and r.action == "mode", (r, mm.get_mode())
+    assert "Daemon:" in r.message, r.message  # snapshot status ikut
+    assert "Personal Agent" in mm.get_mode_prompt()
+    active = mm.get_active_tools()
+    assert active is not None and "daemon_status" in active, active
+    assert "user_manager" in active and "generate_briefing" in active
+    assert "get_jobs" in active and "send_telegram" in active
+    assert "bash" not in active and "write_file" not in active  # aman
+    assert "delete_file" not in active and "run_python" not in active
+    mm.handle_command("/code")
+    assert mm.get_mode() == "code"
+
+    # 5. /clear dan /scan kasih action signal
+    assert mm.handle_command("/clear").action == "clear"
+    assert mm.handle_command("/scan").action == "scan"
+
+    # 6. /model lihat + ganti
+    assert "m" in mm.handle_command("/model").message
+    r = mm.handle_command("/model openai/gpt-4o")
+    assert cfg.model == "openai/gpt-4o" and r.action == "model", (r, cfg.model)
+
+    # 7. Unknown command + "/" kosong tidak crash
+    assert "tidak dikenal" in mm.handle_command("/ngawur").message
+    assert "tidak dikenal" in mm.handle_command("/").message
+
+    # 8. Tanpa config: /model X ditolak dengan sopan
+    mm2 = ModeManager()
+    assert "tidak tersedia" in mm2.handle_command("/model x").message
+
+    # 9. /scan tanpa callback → sinyal; dengan callback → pesan display
+    assert mm2.handle_command("/scan").action == "scan"
+    mm3 = ModeManager(rescan_fn=lambda: "🔍 demo · Python — context diperbarui.")
+    r = mm3.handle_command("/scan")
+    assert r.action == "scan" and "demo" in r.message, r
+    mm4 = ModeManager(rescan_fn=lambda: (_ for _ in ()).throw(RuntimeError("disk")))
+    assert "gagal" in mm4.handle_command("/scan").message.lower()
+
+    print("✅ mode_manager self-test OK (9 skenario + research aktif)")