sonnet-term 0.1.0__py3-none-any.whl

agent_core.py

@@ -0,0 +1,1195 @@
+#!/usr/bin/env python3
+"""agent_core.py — Sonnet engine: spawn hermes subprocess + inject KINJI prompts.
+Windows-friendly: pake subprocess, gak butuh tmux (kayak userbot Linux)."""
+import json
+import os
+import queue
+import shlex
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+BASE = Path(__file__).resolve().parent
+
+
+def _assets():
+    """Resolusi lokasi prompts_enc + skills (paket terpasang / checkout)."""
+    try:
+        import sonnet_data
+        return sonnet_data.find()
+    except Exception:
+        return BASE / "prompts_enc", BASE / ".hermes" / "skills"
+
+
+PROMPTS, SKILLS_SRC = _assets()
+
+
+def _hermes_home(workdir: Path) -> Path:
+    """HERMES_HOME untuk instance ini.
+
+    `SONNET_HERMES_HOME` (dipakai CLI + pip install) menang. Kalau ga
+    di-set, baru fallback ke `<workdir>/.hermes` — itu benar untuk
+    checkout git, tapi salah untuk pip install karena workdir =
+    site-packages (read-only, dan state harus di user dir)."""
+    env = os.environ.get("SONNET_HERMES_HOME")
+    if env:
+        return Path(env).expanduser()
+    return workdir / ".hermes"
+
+
+def find_hermes_binary() -> str:
+    """FIX (31 Agu, direfactor 03 Sep jadi module-level biar bisa dipake
+    dari gui_server.py juga — mis. buat endpoint OAuth start): JANGAN
+    pake hermes system dari PATH user — itu versi berbeda & config-nya
+    gak nyambung ke workdir Sonnet (gejala: "no API keys or providers
+    found → run setup?"). Pilih hermes BUNDLED di runtime/ dulu, baru PATH."""
+    candidates = []
+    # runtime/ di samping backend/ (dist layout: runtime/python.exe,
+    # runtime/Scripts/hermes.exe kalo embeddable + pip install)
+    for base in (Path(__file__).resolve().parent.parent / "runtime",
+                 BASE.parent / "runtime"):
+        if base.exists():
+            for name in ("hermes.exe", "hermes"):
+                p = base / name
+                if p.exists():
+                    candidates.append(str(p))
+            # embeddable python: runtime/python.exe -m hermes_agent? gak
+            # — hermes punya entrypoint hermes.exe setelah pip install
+    import shutil
+    for name in ("hermes", "hermes.exe"):
+        hit = shutil.which(name)
+        if hit:
+            candidates.append(hit)
+    # preferensi: bundled dulu, path terakhir. Fallback "hermes" (bare,
+    # biar Popen coba lookup PATH sendiri) — SAMA kayak behavior lama,
+    # jangan diubah ke "" biar caller lama (spawn agent chat) gak berubah.
+    return candidates[0] if candidates else "hermes"
+
+# FIX (02 Sep #13): provider slug → hermes-CLI key env var mapping.
+# Kalo provider lo gak ada di sini, fallback ke `<PROVIDER>_API_KEY`
+# (auto-derive dari slug). Tambah di sini kalo hermes butuh nama env
+# var yg beda dari default.
+_PROVIDER_KEY_ENV = {
+    "deepseek": "DEEPSEEK_API_KEY",
+    "gmi": "GMI_API_KEY",
+    "openrouter": "OPENROUTER_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "openai": "OPENAI_API_KEY",
+    "nous": "NOUS_API_KEY",
+}
+
+# default: deepseek (satu-satunya provider di project ini)
+DEEPSEEK_MODEL = "deepseek-v4-pro"
+DEEPSEEK_BASE = os.environ.get("SONNET_BASE_URL", "https://api.deepseek.com/v1")
+# GMI Cloud (model abbrev "MiniMax" / provider gmi*) — endpoint
+# yang bener: api.gmi-serving.com (bukan gmi-cloud.com — domain lama
+# udah gak aktif & return 401 "Invalid token, failed to decode" buat
+# key JWT yang sebenernya valid). FIX (02 Sep #11).
+GMI_BASE = "https://api.gmi-serving.com/v1"  # FIX (02 Sep #11): domain lama gmi-cloud.com udah 401, dipindah ke serving
+
+# ── key derivation (obfuscated: split + reversed + xor) ──────────────────
+# gak ada string key utuh di binary — di-assemble runtime dari potongan.
+# FORMAT HARUS SAMA dengan scripts/encrypt_prompts.py:
+#   seed = reversed(parts) + "::" + parts
+_SEED_A = ["s0nn3t", "k1nj1"]
+_SEED_B = ["d4shb04rd", "x9f2"]
+_XOR = 0x5A
+
+
+def _derive_key() -> bytes:
+    import hashlib
+    parts = _SEED_A + _SEED_B          # x9f2, d4shb04rd, k1nj1, s0nn3t
+    seed = "".join(reversed(parts)) + "::" + "".join(parts)
+    return hashlib.sha256(seed.encode()).digest()
+
+
+def load_prompt(name: str) -> str:
+    """Decrypt .bin prompt ke memory. Prompt gak pernah ke-tulis ke disk."""
+    try:
+        from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+    except ImportError:
+        return ""
+    p = PROMPTS / (name + ".bin")
+    if not p.exists():
+        return ""
+    raw = p.read_bytes()
+    nonce, ct = raw[:12], raw[12:]
+    try:
+        data = AESGCM(_derive_key()).decrypt(nonce, ct, b"sonnet-prompts-v1")
+        return data.decode("utf-8")
+    except Exception:
+        return ""
+
+
+class HermesSession:
+    """Bungkus 1 sesi hermes agent: spawn subprocess, kirim prompt, stream reply.
+
+    Flow (ikutin userbot):
+      1. spawn hermes --cli dengan env (model, key, base_url)
+      2. pre-warm: tunggu prompt '> ' muncul
+      3. kirim pesan → baca stdout chunk-by-chunk → yield ke UI
+    """
+
+    def __init__(self, api_key: str, model: str = DEEPSEEK_MODEL,
+                 persona: str = "kinji", workdir: Path | None = None,
+                 extra_system: str = "", max_tokens: int = 16384,
+                 thinking: str = "medium", tavily_key: str = "",
+                 profile: str | None = None,
+                 provider: str = "deepseek",
+                 base_url: str = "https://api.deepseek.com/v1",
+                 api_mode: str = "chat_completions",
+                 hermes_auth_dir: Path | None = None,
+                 computer_use_enabled: bool = False):
+        self.api_key = api_key
+        self.model = model
+        self.persona = persona
+        self.workdir = workdir or Path.cwd()
+        self.extra_system = extra_system
+        self.max_tokens = max_tokens
+        self.thinking = thinking
+        self.tavily_key = tavily_key
+        self.profile = profile   # Bot Mode: -p <nama> → profile hermes terisolasi
+        self.provider = provider
+        self.base_url = base_url
+        self.api_mode = api_mode
+        self.computer_use_enabled = computer_use_enabled
+        # FIX (04 Sep): sumber central token OAuth provider "hermes"
+        # (ditulis sekali oleh wizard login ke USERDATA/.hermes/auth.json).
+        # Dipakai _ensure_hermes_auth() buat sync ke HERMES_HOME AKTIF
+        # (yang sekarang selalu ikut workdir project user) — bukan buat
+        # maksa workdir pindah ke USERDATA kayak dulu (itu yang bikin
+        # "agent gak fokus di folder yang dipilih user").
+        self.hermes_auth_dir = hermes_auth_dir
+        self.proc: subprocess.Popen | None = None
+        self._out_queue: queue.Queue = queue.Queue()
+        self._thread: threading.Thread | None = None
+
+    # FIX (11 Sep #X): mapping "hermes" (slug UI) → "nous" (nama provider
+    # hermes CLI) tadinya cuma ada INLINE, diduplikat di 3 tempat beda
+    # (_ensure_hermes_config, _run_oneshot, spawn_gateway) — gampang jadi
+    # gak sinkron kalau salah satu diubah tapi yang lain kelupaan. Helper
+    # ini dipake buat caller BARU (per-request model/provider override di
+    # HermesGatewayClient.chat_stream, lihat gui_server.py._run_gateway_turn)
+    # biar nilai yang dikirim SELALU sama persis kayak yang ditulis
+    # _ensure_hermes_config() ke config.yaml — gak nambah tempat ke-4 yang
+    # bisa nyimpang.
+    def resolved_provider(self) -> str:
+        prov = (self.provider or "").lower().strip()
+        return "nous" if prov == "hermes" else prov
+
+    # ── prompt building (ngikutin userbot: system_prompt + bridge_prompt) ──
+    def build_system(self) -> str:
+        sp = load_prompt("system_prompt")      # KINJI persona 45KB
+        bp = load_prompt("bridge_prompt")      # BRIDGE_PROMPT 23KB
+        parts = [sp, bp]
+        if self.extra_system:
+            parts.append(self.extra_system)
+        # personality breach kalau dipilih
+        if self.persona == "breach":
+            try:
+                ps = json.loads(load_prompt("personalities"))
+                if "breach" in ps:
+                    parts.append(ps["breach"].get("system_prompt", ""))
+            except Exception:
+                pass
+        return "\n\n".join(p for p in parts if p)
+
+    def _ensure_soul(self):
+        """Tulis persona ke HERMES_HOME/SOUL.md — hermes auto-inject
+        SOUL.md dari HERMES_HOME tiap start (identity slot #1, "always
+        included when present"). ini yang bikin prompt KINJI (45KB
+        persona + 23KB bridge) beneran ke-load."""
+        try:
+            sp = load_prompt("system_prompt")
+            bp = load_prompt("bridge_prompt")
+            if not (sp or bp):
+                print("SOUL: prompts kosong — skip", flush=True)
+                return
+            soul = ("# sonnet identity\n\n" + sp + "\n\n" + bp
+                    if sp else bp)
+            hdir = _hermes_home(self.workdir)   # HERMES_HOME
+            hdir.mkdir(parents=True, exist_ok=True)
+            p = hdir / "SOUL.md"
+            p.write_text(soul, encoding="utf-8")
+            print(f"SOUL.md ditulis: {p} ({len(soul)} chars)", flush=True)
+        except Exception as e:
+            print("SOUL write error: %r" % (e,), flush=True)
+
+    def _tools_flag(self) -> str:
+        """Build -t flag value based on config. computer_use cuma included
+        kalau di-enable di Settings UI."""
+        base = "skills,memory,web,todo,session_search,terminal,file,browser,cronjob,delegation,vision,image_gen,tts,code_execution,kanban,clarify"
+        if getattr(self, "computer_use_enabled", False):
+            base += ",computer_use"
+        return base
+
+    def _ensure_skills(self):
+        """FIX (01 Sep): extract skill pack ke HERMES_HOME/skills/ pas
+        first-run (kalo kosong). Skill pack (999 skill) di-bundle di
+        backend/skills_pack.zip — user Windows gak punya akses ke repo
+        kita, jadi harus ke-seed dari installer."""
+        import zipfile
+        try:
+            hdir = _hermes_home(self.workdir)
+            skills_dir = hdir / "skills"
+            # Sudah ke-seed penuh? Cek JUMLAH, bukan "ada": seed
+            # sebelumnya bisa ketinggal terputus (crash / disk penuh /
+            # versi lama) dan `any()`bakal lolos dengan 58 dari 973.
+            # 973 = jumlah project skill di pack ini; pakai ambang
+            # konservatif supaya partial seed di Heal ulang.
+            EXPECTED = 900
+            have = (len(list(skills_dir.rglob("SKILL.md")))
+                    if skills_dir.is_dir() else 0)
+            if have >= EXPECTED:
+                return
+            pack = BASE / "skills_pack.zip"   # di backend/ (frozen: exe dir)
+            if not pack.exists():
+                # distribution pip/git: skill pack ada sebagai direktori
+                # (sonnet_data/skills) atau .hermes/skills, bukan zip.
+                if SKILLS_SRC.is_dir() and any(
+                        SKILLS_SRC.rglob("SKILL.md")):
+                    if have:
+                        # heal: buang sisa partial biar file basi
+                        # (skill yg dihapus di versi baru) gak nempel
+                        import shutil as _sh
+                        _sh.rmtree(skills_dir, ignore_errors=True)
+                    skills_dir.mkdir(parents=True, exist_ok=True)
+                    n = 0
+                    for src in SKILLS_SRC.rglob("SKILL.md"):
+                        rel = src.relative_to(SKILLS_SRC)
+                        dst = skills_dir / rel
+                        dst.parent.mkdir(parents=True, exist_ok=True)
+                        dst.write_bytes(src.read_bytes())
+                        n += 1
+                    print(f"SKILLS: {n} skill di-seed dari "
+                          f"{SKILLS_SRC}", flush=True)
+                    return
+                print("SKILLS: gak ada skills_pack.zip atau "
+                      "sonnet_data/skills — skip", flush=True)
+                return
+            skills_dir.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(pack) as z:
+                # zip berisi prefix "skills/..." → strip biar extract
+                # langsung ke skills_dir (bukan skills/skills)
+                # FIX (11 Sep): zip sekarang tanpa prefix skills/ — cek dulu
+                has_prefix = any(n.startswith("skills/") for n in z.namelist())
+                for member in z.namelist():
+                    if has_prefix and member.startswith("skills/"):
+                        member = member[len("skills/"):]
+                    if not member:
+                        continue
+                    target = skills_dir / member
+                    if member.endswith("/"):
+                        target.mkdir(parents=True, exist_ok=True)
+                        continue
+                    try:
+                        target.parent.mkdir(parents=True, exist_ok=True)
+                        # Baca dari zip — pake nama asli (dengan prefix kalo ada)
+                        orig = "skills/" + member if has_prefix else member
+                        target.write_bytes(z.read(orig))
+                    except Exception:
+                        pass
+            n = len(list(skills_dir.rglob("SKILL.md")))
+            print(f"SKILLS: extracted {n} skills ke {skills_dir}", flush=True)
+            # FIX (10 Sep): setelah extract, tulis apikey.json untuk tavily-search
+            # biar skill bisa langsung dipake tanpa user input ulang di workdir baru.
+            # JANGAN overwrite kalau udah ada (user mungkin udah punya key sendiri).
+            if self.tavily_key:
+                tavily_skill_dir = skills_dir / "web" / "tavily-search"
+                apikey_path = tavily_skill_dir / "apikey.json"
+                if tavily_skill_dir.exists() and not apikey_path.exists():
+                    try:
+                        import json as _json
+                        apikey_path.write_text(
+                            _json.dumps({"tavily_api_key": self.tavily_key}, indent=2),
+                            encoding="utf-8")
+                        print(f"SKILLS: apikey.json ditulis ke {apikey_path}", flush=True)
+                    except Exception:
+                        pass
+        except Exception as e:
+            print("SKILLS extract error: %r" % (e,), flush=True)
+
+    def _ensure_hermes_auth(self):
+        """provider 'hermes' (CLI: 'nous') pakai OAuth — token cuma pernah
+        ditulis SEKALI ke lokasi central (USERDATA/.hermes/auth.json) pas
+        login lewat wizard (lihat handle_hermes_oauth_start di gui_server).
+        HERMES_HOME sekarang SELALU ikut self.workdir (folder project user
+        yang dipilih lewat tombol folder) — bukan dipaksa balik ke USERDATA
+        kayak versi lama. Supaya hermes CLI tetep nemu token-nya di
+        HERMES_HOME aktif itu, copy token dari sumber central ke situ tiap
+        spawn/kirim pesan (bukan mindahin workdir-nya)."""
+        # Provider slug di CLI = "nous"; GUI desktop pernah pakai
+        # "hermes". Terima keduanya — kalau cuma cek "hermes", token
+        # OAuth Portal nggak pernah di-sync ke HERMES_HOME aktif dan
+        # chat oneshot mati diam dengan "credentials or agent init
+        # failed".
+        if (self.provider or "").lower() not in ("hermes", "nous") \
+                or not self.hermes_auth_dir:
+            return
+        try:
+            src = Path(self.hermes_auth_dir) / "auth.json"
+            if not src.exists():
+                return  # belum pernah login — biarin hermes CLI yang teriak
+            dst_dir = _hermes_home(self.workdir)
+            dst_dir.mkdir(parents=True, exist_ok=True)
+            dst = dst_dir / "auth.json"
+            if not dst.exists() or src.stat().st_mtime > dst.stat().st_mtime:
+                import shutil
+                shutil.copy2(src, dst)
+                print(f"hermes auth synced ke {dst}", flush=True)
+        except Exception as e:
+            print("hermes auth sync error: %r" % (e,), flush=True)
+
+    def spawn(self):
+        # ── Windows: one-shot mode — hermes chat -q gak butuh TTY
+        #    (winpty/pipe terbukti gagal). spawn() cuma prepare; tiap
+        #    chat = 1 subprocess hermes chat -q ... -Q (quiet). ──
+        if os.name == "nt":
+            self._oneshot = True
+            # jangan reset session_id kalau udah ada (konteks chat lanjut)
+            if not hasattr(self, "session_id"):
+                self.session_id = None
+            self._ensure_soul()
+            self._ensure_skills()  # FIX (01 Sep): seed skill pack first-run
+            # FIX (31 Agu): _ensure_hermes_config WAJIB dipanggil di Windows
+            # juga — dulu cuma di jalur Linux, makanya config.yaml gak pernah
+            # ke-tulis api_key → hermes bilang "no API keys or providers
+            # found → run setup?" → chat gak dibalas.
+            self._ensure_hermes_config()
+            self._ensure_hermes_auth()  # FIX (04 Sep): sync token OAuth ke HERMES_HOME aktif
+            return
+        self._oneshot = False
+        self._ensure_soul()
+        self._ensure_skills()  # FIX (01 Sep): seed skill pack first-run
+        env = os.environ.copy()
+        # FIX (11 Sep): tambahin folder cua + runtime/Scripts ke PATH biar
+        # hermes CLI bisa nemu cua-computer-server.exe
+        base = Path(__file__).resolve().parent.parent
+        cua_dir = str(base / "cua")
+        runtime_dir = str(base / "runtime")
+        runtime_scripts = str(base / "runtime" / "Scripts")
+        # FIX: tambahin juga path cua-driver yang di-install hermes
+        cua_driver_path = str(Path.home() / "AppData" / "Local" / "Programs" / "Cua" / "cua-driver" / "bin")
+        env["PATH"] = cua_dir + os.pathsep + runtime_dir + os.pathsep + runtime_scripts + os.pathsep + cua_driver_path + os.pathsep + env.get("PATH", "")
+        # bikin .hermes/config.yaml otomatis dari template (isi api_key)
+        self._ensure_hermes_config()
+        self._ensure_hermes_auth()  # FIX (04 Sep): sync token OAuth ke HERMES_HOME aktif
+        env.update({
+            # HOME ga di-override: Hermes hormat HERMES_HOME, dan
+            # memaksa HOME ke workdir bikin auth global user
+            # (~/.hermes/auth.json untuk Portal OAuth) gak ketemu —
+            # gejalanya oneshot diam tanpa error. Dulu HOME di-paksa
+            # karena .hermes masih di workdir/.hermes; sekarang
+            # HERMES_HOME yg dipisah dari workdir.
+            "HERMES_HOME": str(_hermes_home(self.workdir)),
+            "TERMINAL_CWD": str(self.workdir),
+            "UB_MODEL": self.model,
+            "UB_API_KEY": self.api_key,
+            # FIX (02 Sep #12): dulu base_url ditebak dari substring nama
+            # model ("MiniMax" di nama → GMI, selain itu → DeepSeek) —
+            # gak nyambung sama registry per-provider (self.base_url/
+            # self.provider, hasil resolve dari model yang lagi aktif di
+            # /api/models). Sekarang pake self.base_url langsung, dan
+            # DEEPSEEK_API_KEY cuma di-set kalau provider aktifnya emang
+            # deepseek — biar gak nabrak provider lain kayak GMI (lihat
+            # komentar sama di _run_oneshot, jalur Windows).
+            "UB_BASE_URL": getattr(self, "base_url", None) or DEEPSEEK_BASE,
+            "PYTHONDONTWRITEBYTECODE": "1",
+            # UTF-8 mode: python pake utf-8 buat semua io, gak peduli
+            # locale Windows (cp1252) → write_text gak bakal UnicodeEncodeError
+            "PYTHONUTF8": "1",
+            # defer agent startup (kayak userbot): hermes CLI cepet muncul,
+            # agent baru ke-init pas pesan pertama → first-turn gak 2-3 menit
+            "HERMES_DEFER_AGENT_STARTUP": "1",
+        })
+        # FIX (02 Sep #13): sama kayak _run_oneshot — provider → env var
+        # mapping generik, bukan hardcoded deepseek doang.
+        _prov_lx = (getattr(self, "provider", "") or "").lower().strip()
+        # FIX (03 Sep): provider "hermes" (UI slug) → "nous" (hermes CLI
+        # provider name). hermes CLI gak recognize "hermes" sebagai provider.
+        if _prov_lx == "hermes":
+            _prov_lx = "nous"
+        if not _prov_lx:
+            env["DEEPSEEK_API_KEY"] = self.api_key
+        else:
+            _key_env = _PROVIDER_KEY_ENV.get(_prov_lx, f"{_prov_lx.upper()}_API_KEY")
+            env[_key_env] = self.api_key
+        if self.tavily_key:
+            # web search (tavily) — hermes baca TAVILY_API_KEY buat web_search
+            env["TAVILY_API_KEY"] = self.tavily_key
+        if self.thinking:
+            env["UB_REASONING_EFFORT"] = self.thinking
+            env["REASONING_EFFORT"] = self.thinking
+        # hermes CLI: cek ketersediaan
+        hermes = self._find_hermes()
+        cmd = [hermes, "--cli", "--no-restore-cwd", "--yolo",
+               "-t", self._tools_flag()]
+        # ── Bot Mode: insert -p <profile> (baca profile terisolasi di
+        #    HERMES_HOME/profiles/<nama>/), kalo profile-nya ada.
+        if self.profile:
+            prof_dir = _hermes_home(self.workdir) / "profiles" / self.profile
+            if prof_dir.exists():
+                cmd[1:1] = ["-p", self.profile]
+        # ── WAJIB PTY: hermes --cli gak jalan lewat pipe biasa.
+        # Linux: pakai tmux (kayak userbot produksi — TERBUKTI JALAN).
+        # Windows: ConPTY via winpty kalau ada, atau pipe biasa.
+        if os.name == "posix" and self._have_tmux():
+            self._spawn_tmux(cmd, env)
+        elif os.name == "posix":
+            self._spawn_pty(cmd, env)
+        else:
+            self._spawn_pipe(cmd, env)
+
+    def _have_tmux(self) -> bool:
+        import shutil
+        return shutil.which("tmux") is not None
+
+    def _spawn_tmux(self, cmd, env):
+        """Spawn hermes di tmux session (persistent, PTY beneran).
+        Output di-pipe ke file log via `tmux pipe-pane` — stream asli
+        (delta), bukan snapshot capture-pane (yang bikin duplikat)."""
+        import uuid
+        self._tmux_name = "sonnet_" + uuid.uuid4().hex[:8]
+        self._logfile = f"/tmp/{self._tmux_name}.log"
+        cwd = str(self.workdir)
+        # env inline: HOME, HERMES_HOME, UB_*, DEEPSEEK_API_KEY
+        envline = " ".join(f"{k}={shlex.quote(v)}" for k, v in env.items()
+                           if k.startswith(("HOME", "HERMES", "UB_", "DEEPSEEK",
+                                           "PYTHON", "TAVILY", "TERMINAL")))
+        inner = f"cd {shlex.quote(cwd)} && env {envline} " + " ".join(shlex.quote(c) for c in cmd)
+        subprocess.run(["tmux", "new-session", "-d", "-s", self._tmux_name,
+                        "-x", "200", "-y", "50", inner], check=False)
+        # pipe output pane ke file (stream asli, ANSI + semua)
+        subprocess.run(["tmux", "pipe-pane", "-t", self._tmux_name,
+                        "-o", f"cat >> {self._logfile}"], check=False)
+        self._out_queue = queue.Queue()
+        self._thread = threading.Thread(target=self._tmux_reader, daemon=True)
+        self._thread.start()
+        self.proc = None  # dikelola tmux
+
+    def _tmux_reader(self):
+        """Baca stream pane dari logfile (offset-based, delta asli)."""
+        offset = 0
+        while True:
+            try:
+                try:
+                    sz = os.path.getsize(self._logfile)
+                except OSError:
+                    time.sleep(0.4)
+                    continue
+                if sz > offset:
+                    with open(self._logfile, "r", encoding="utf-8",
+                              errors="replace") as f:
+                        f.seek(offset)
+                        self._out_queue.put(f.read())
+                        offset = f.tell()
+                time.sleep(0.3)
+            except Exception:
+                time.sleep(1)
+
+    def _spawn_pty(self, cmd, env):
+        import pty
+        import fcntl
+        import termios
+        import struct
+        master, slave = pty.openpty()
+        fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 50, 200, 0, 0))
+        self.proc = subprocess.Popen(
+            cmd,
+            stdin=slave, stdout=slave, stderr=slave,
+            text=True, encoding="utf-8", errors="replace",
+            env=env, cwd=str(self.workdir), close_fds=True,
+        )
+        os.close(slave)
+        self._pty_master = master
+        self._thread = threading.Thread(target=self._reader_pty, daemon=True)
+        self._thread.start()
+
+    def _spawn_pipe(self, cmd, env):
+        # ── Windows: hermes --cli WAJIB TTY — pipe biasa bikin hermes
+        #    nolak interaktif ("No interactive TTY detected") → chat gak
+        #    dijawab. pake winpty/ConPTY (bundled di runtime/) dulu.
+        print("spawn windows: cmd=" + " ".join(cmd), flush=True)
+        try:
+            from winpty import PtyProcess
+            self._winpty = PtyProcess.spawn(
+                cmd, cwd=str(self.workdir), env=env, dimensions=(50, 200))
+            self._thread = threading.Thread(target=self._reader_winpty,
+                                             daemon=True)
+            self._thread.start()
+            print("spawn OK via winpty", flush=True)
+            return
+        except Exception as e:
+            print("winpty gagal: %r — fallback pipe" % (e,), flush=True)
+            self._winpty = None
+        self.proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=env,
+            cwd=str(self.workdir),
+            bufsize=1,
+        )
+        self._thread = threading.Thread(target=self._reader, daemon=True)
+        self._thread.start()
+
+    def _reader_winpty(self):
+        while True:
+            try:
+                data = self._winpty.read(4096)
+                if not data:
+                    print("winpty reader EOF — process mati/keluar", flush=True)
+                    break
+                self._out_queue.put(data)
+            except Exception as e:
+                print("winpty reader error: %r" % (e,), flush=True)
+                break
+
+    def _find_hermes(self) -> str:
+        return find_hermes_binary()
+
+    def _ensure_hermes_config(self):
+        """Bikin .hermes/config.yaml dari template, isi api_key dari self.api_key.
+        Kalau template gak ada (bundle rusak) → fallback config minimal,
+        biar hermes gak nolak start ("no API keys or providers found").
+        File yang ADA TAPI KOSONG (hermes nge-init config kosong pas
+        pertama start) juga di-repair → tulis ulang template."""
+        hdir = _hermes_home(self.workdir)
+        hdir.mkdir(parents=True, exist_ok=True)
+        cfg_path = hdir / "config.yaml"
+        txt = ""
+        if cfg_path.exists():
+            try:
+                txt = cfg_path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                txt = ""
+        if not txt.strip() or "model:" not in txt:
+            tpl = BASE / "hermes_config_template.yaml"
+            if tpl.exists():
+                # WAJIB encoding utf-8 — template ada karakter non-ASCII
+                # (em-dash —) yang gagal di-encode pake cp1252 Windows
+                cfg_path.write_text(tpl.read_text(encoding="utf-8"),
+                                    encoding="utf-8")
+            else:
+                cfg_path.write_text(
+                    "model:\n"
+                    "  default: deepseek-v4-pro\n"
+                    "  provider: deepseek\n"
+                    "  base_url: https://api.deepseek.com/v1\n"
+                    "  api_key: \"\"\n"
+                    "  max_tokens: 16384\n"
+                    "  api_mode: chat_completions\n"
+                    "agent:\n"
+                    "  max_turns: 150\n"
+                    "  verify_on_stop: true\n"
+                    "  reasoning_effort: medium\n"
+                    "terminal:\n"
+                    "  backend: local\n"
+                    "  timeout: 60\n"
+                    "  home_mode: false\n"
+                    "web:\n"
+                    "  backend: curl\n"
+                    "display:\n"
+                    "  show_reasoning: true\n"
+                    "  streaming: true\n"
+                    "  compact: true\n", encoding="utf-8")
+            print(f"config.yaml di-repair: {cfg_path} "
+                  f"({cfg_path.stat().st_size} bytes)", flush=True)
+        # isi api_key + model/provider/base_url (selalu update ke session
+        # ini — biar gak ke-pake key/model lama dari config sebelumnya)
+        #
+        # FIX (11 Sep #18): BUG BESAR — implementasi lama mutasi config.yaml
+        # pake serangkaian re.sub() di TEKS MENTAH, bukan parse YAML beneran.
+        # Dua masalah independen, dan KOMBINASI keduanya yang bikin "chat
+        # jawab kosong, ctx_used=0":
+        #   1) Regex-nya UNANCHORED & tanpa count=1 — re.sub(r"default:\s*\S+",
+        #      ...) misalnya nyari literal "default:" DI MANA AJA di file
+        #      (bukan cuma di bawah `model:`), dan kalau kebetulan match >1
+        #      kali, SEMUA ketiban value yang sama. Gak ada satupun langkah
+        #      yang validasi hasilnya masih YAML valid.
+        #   2) Begitu hasilnya kebetulan syntactically invalid (kombinasi
+        #      value tertentu — nggak harus dari 1 baris yang "kelihatan
+        #      salah" sendirian), file KETULIS ke disk apa adanya. hermes
+        #      gateway gagal parse config.yaml pas start ("mapping values
+        #      are not allowed here") → fallback ke default bawaan hermes-
+        #      agent (provider `nous` lewat auto-detect chain internalnya,
+        #      TANPA model) — SEMUA override di bawah ini (termasuk
+        #      provider/model yang mau kita pasang) diabaikan total oleh
+        #      hermes. Provider nous kepanggil tanpa model → API balikin
+        #      400 "Model parameter is required" → non-retryable → turn
+        #      kelar TANPA assistant.delta apapun. Endpoint
+        #      /api/sessions/{id}/chat/stream cuma janji event
+        #      assistant.delta/tool.started/tool.completed/run.completed
+        #      (gak ada event error terpisah di dokumentasi resminya), jadi
+        #      run.completed yang kosong itu ke-terima apa adanya sebagai
+        #      "turn sukses tanpa isi" — persis gejala di backend.log.
+        #
+        # FIX: parse config.yaml jadi dict BENERAN (yaml.safe_load), mutasi
+        # AS DATA (bukan string), yaml.safe_dump ulang. Dump dari dict
+        # SELALU syntactically valid apapun isi value-nya — termasuk yang
+        # ada titik dua di tengah kayak "meituan/longcat-2.0:free" (valid
+        # sebenernya secara YAML, tapi sekarang gak lagi tergantung regex
+        # nebak-nebak buat mastiin). Kalau file yang ADA di disk gagal
+        # diparse (mis. korup dari sebelum fix ini di-deploy), jangan coba
+        # tambal teks yang udah rusak — mulai dari template bersih dulu,
+        # baru tumpuk override di atasnya. Ditutup dengan re-parse hasil
+        # dump SEBELUM ditulis ke disk: kalau tetep gagal (harusnya gak
+        # pernah kejadian), batalin write daripada nimpa config yang masih
+        # hidup dengan sesuatu yang mungkin lebih rusak.
+        #
+        # DEPENDENCY BARU: butuh `pyyaml` (import yaml) di environment yang
+        # menjalankan gui_server.py/agent_core.py — sebelumnya file ini gak
+        # pernah beneran parse YAML, cuma regex di string. Kalau belum ada:
+        # pip install pyyaml (atau pip install pyyaml --break-system-packages
+        # tergantung environment-nya).
+        import yaml
+        try:
+            try:
+                cfg = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
+                if not isinstance(cfg, dict):
+                    raise ValueError("root config.yaml bukan mapping")
+            except Exception as e:
+                print(f"config.yaml gak valid ({e!r}) — rebuild dari "
+                      f"template sebelum apply override user", flush=True)
+                tpl = BASE / "hermes_config_template.yaml"
+                base_txt = tpl.read_text(encoding="utf-8") if tpl.exists() else (
+                    "model:\n  default: deepseek-v4-pro\n  provider: deepseek\n"
+                    "  base_url: https://api.deepseek.com/v1\n  api_key: \"\"\n"
+                    "  max_tokens: 16384\n  api_mode: chat_completions\n"
+                    "agent:\n  max_turns: 150\n  verify_on_stop: true\n"
+                    "  reasoning_effort: medium\n")
+                cfg = yaml.safe_load(base_txt) or {}
+            cfg.setdefault("model", {})
+            cfg.setdefault("agent", {})
+            cfg.setdefault("display", {})
+
+            # FIX (02 Sep #5): show_reasoning di-force TRUE — dulu false,
+            # yang bikin hermes verbose (-v) nge-print reasoning MENTAH
+            # "[thinking] ..." polos ke stdout → bocor ke chat.
+            if cfg["display"].get("show_reasoning") is False:
+                cfg["display"]["show_reasoning"] = True
+                print("config: show_reasoning di-force true", flush=True)
+
+            # FIX (05 Sep #17): reasoning_effort ikut dropdown "thinking" —
+            # jalur gateway (yang beneran aktif buat chat GUI) cuma baca
+            # dari config.yaml ini, env var UB_REASONING_EFFORT gak dipake
+            # spawn_gateway().
+            think_val = getattr(self, "thinking", None)
+            if think_val:
+                cfg["agent"]["reasoning_effort"] = think_val
+                print(f"config: reasoning_effort → {think_val}", flush=True)
+
+            # FIX (11 Sep): toggle computer_use — gateway resolve toolset
+            # dari config.yaml agent.disabled_toolsets (default-ALLOW semua
+            # KECUALI yang di-deny di situ), bukan dari -t/--toolsets CLI
+            # (itu cuma berlaku buat -z/--oneshot dan --tui, gak ke `gateway`).
+            if not getattr(self, "computer_use_enabled", False):
+                cfg["agent"]["disabled_toolsets"] = ["computer_use"]
+                print("config: disabled_toolsets → [computer_use]", flush=True)
+            else:
+                cfg["agent"].pop("disabled_toolsets", None)
+
+            # model aktif (default) — dari self.model (BRIDGE.cfg), bukan
+            # force ke deepseek-v4-pro: user bisa pilih model GMI dll.
+            model_val = getattr(self, "model", None) or "deepseek-v4-pro"
+            cfg["model"]["default"] = model_val
+            print(f"config: default → {model_val}", flush=True)
+
+            # provider + base_url + api_mode (biar endpoint custom kaya
+            # GMI/OpenRouter ke-detect; fallback deepseek)
+            prov = getattr(self, "provider", "") or ""
+            base = getattr(self, "base_url", "") or ""
+            amode = getattr(self, "api_mode", "") or ""
+            # FIX (03 Sep): provider "hermes" (UI slug) → "nous" (hermes CLI
+            # provider name) — sama persis kayak resolved_provider() di atas.
+            if prov == "hermes":
+                prov = "nous"
+                base = base or "https://inference-api.nousresearch.com/v1"
+            if prov:
+                cfg["model"]["provider"] = prov
+            if base:
+                cfg["model"]["base_url"] = base
+            if amode:
+                cfg["model"]["api_mode"] = amode
+            cfg["model"]["api_key"] = self.api_key
+
+            # ── FIX (01 Sep): anti-bug hermes v0.21 — versi-agnostic, aman
+            # di semua versi (field yang gak dikenal di versi lama cuma
+            # di-ignore). 1) paste collapse v0.21 motong prompt panjang →
+            # model echo → reply ilang; 2) context_file_max_chars 20K →
+            # SOUL.md 53K kepotong tengah → persona plenger.
+            cfg.setdefault("paste_collapse_threshold", 0)
+            cfg.setdefault("paste_collapse_char_threshold", 0)
+            cfg.setdefault("context_file_max_chars", 200000)
+
+            new_txt = ("# Auto-generated oleh Sonnet Desktop — override user "
+                       "ditulis ulang tiap respawn, JANGAN edit manual.\n"
+                       "# Sumber template: hermes_config_template.yaml\n\n"
+                       + yaml.safe_dump(cfg, sort_keys=False,
+                                        default_flow_style=False,
+                                        allow_unicode=True))
+            # Self-check: dump dari dict SELALU syntactically valid, jadi
+            # ini jaring pengaman terakhir, bukan langkah yang "emang
+            # diharapkan gagal" — tapi kalau somehow tetep gagal, JANGAN
+            # nimpa config.yaml yang masih hidup dengan sesuatu yang
+            # mungkin lebih rusak.
+            yaml.safe_load(new_txt)
+            cfg_path.write_text(new_txt, encoding="utf-8")
+        except Exception as e:
+            print(f"BATAL update config.yaml — {e!r} (config.yaml LAMA "
+                  f"dibiarin apa adanya, dicoba lagi turn berikutnya)",
+                  flush=True)
+
+    # ── FIX (05 Sep): key internal Sonnet↔hermes gateway. TIDAK PERNAH
+    # diisi/dilihat user — di-generate sekali per-workdir pas pertama kali
+    # dibutuhkan, disimpen di 2 tempat: config.yaml (biar hermes gateway
+    # baca dari situ) + file lokal .hermes/.sonnet_gateway_key (biar
+    # gui_server.py bisa baca tanpa parse ulang YAML tiap request).
+    # Loopback-only (127.0.0.1) — key ini cuma jaga proses lain di mesin
+    # yang sama gak nebeng akses ke toolset hermes (terminal dll), BUKAN
+    # secret yang perlu di-treat kayak API key provider LLM.
+    def _ensure_api_server_key(self) -> str:
+        hdir = _hermes_home(self.workdir)
+        hdir.mkdir(parents=True, exist_ok=True)
+        key_path = hdir / ".sonnet_gateway_key"
+        if key_path.exists():
+            key = key_path.read_text(encoding="utf-8").strip()
+            if key:
+                self._sync_gateway_key_to_config(key)
+                return key
+        import secrets
+        key = secrets.token_urlsafe(32)
+        key_path.write_text(key, encoding="utf-8")
+        self._sync_gateway_key_to_config(key)
+        return key
+
+    def _sync_gateway_key_to_config(self, key: str):
+        """Tulis key ke gateway.api_server.key di config.yaml (dipanggil
+        _ensure_hermes_config duluan biar section-nya udah ada dari
+        template — lihat hermes_config_template.yaml)."""
+        import re
+        cfg_path = _hermes_home(self.workdir) / "config.yaml"
+        try:
+            txt = cfg_path.read_text(encoding="utf-8")
+        except Exception:
+            return
+        if re.search(r"(?m)^(\s*)key:\s*\"[^\"]*\"\s*$", txt):
+            # replace key: "..." PALING BAWAH aja yg ada indentasi (di
+            # dalem gateway.api_server:) — cukup 1 baris cocok pola ini
+            # di file kita karena api_key model beda key ("api_key:").
+            txt = re.sub(r'(?m)^(\s*)key:\s*"[^"]*"\s*$',
+                         lambda m: f'{m.group(1)}key: "{key}"', txt, count=1)
+        else:
+            txt += (f'\ngateway:\n  api_server:\n    enabled: true\n'
+                    f'    host: 127.0.0.1\n    port: 8642\n    key: "{key}"\n')
+        try:
+            cfg_path.write_text(txt, encoding="utf-8")
+        except Exception:
+            pass
+
+    def spawn_gateway(self, port: int = 8642):
+        """Ganti _run_oneshot: nyalain `hermes gateway` SEKALI (persistent,
+        bukan spawn ulang tiap pesan). gui_server.py ngobrol ke proses ini
+        lewat HTTP+SSE (lihat hermes_gateway_client.py), bukan baca stdout-nya
+        langsung — jadi stdout proc ini gak perlu di-parse sama sekali."""
+        if self.proc is not None and self.proc.poll() is None:
+            return  # udah jalan
+        self._ensure_hermes_config()
+        self._ensure_hermes_auth()
+        self._ensure_soul()
+        self._ensure_skills()
+        key = self._ensure_api_server_key()
+        env = os.environ.copy()
+        # FIX (11 Sep): tambahin folder cua + runtime/Scripts ke PATH biar
+        # hermes CLI bisa nemu cua-computer-server.exe
+        base = Path(__file__).resolve().parent.parent
+        cua_dir = str(base / "cua")
+        runtime_dir = str(base / "runtime")
+        runtime_scripts = str(base / "runtime" / "Scripts")
+        # FIX: tambahin juga path cua-driver yang di-install hermes
+        cua_driver_path = str(Path.home() / "AppData" / "Local" / "Programs" / "Cua" / "cua-driver" / "bin")
+        env["PATH"] = cua_dir + os.pathsep + runtime_dir + os.pathsep + runtime_scripts + os.pathsep + cua_driver_path + os.pathsep + env.get("PATH", "")
+        env.update({
+            # HOME ga di-override: Hermes hormat HERMES_HOME, dan
+            # memaksa HOME ke workdir bikin auth global user
+            # (~/.hermes/auth.json untuk Portal OAuth) gak ketemu —
+            # gejalanya oneshot diam tanpa error. Dulu HOME di-paksa
+            # karena .hermes masih di workdir/.hermes; sekarang
+            # HERMES_HOME yg dipisah dari workdir.
+            "HERMES_HOME": str(_hermes_home(self.workdir)),
+            "PYTHONUTF8": "1",
+            "API_SERVER_ENABLED": "true",
+            "API_SERVER_PORT": str(port),
+            "API_SERVER_HOST": "127.0.0.1",
+            "API_SERVER_KEY": key,
+        })
+        _prov = (getattr(self, "provider", "") or "").lower().strip() or "deepseek"
+        if _prov == "hermes":
+            _prov = "nous"
+        _key_env = _PROVIDER_KEY_ENV.get(_prov, f"{_prov.upper()}_API_KEY")
+        env[_key_env] = self.api_key
+        hermes = self._find_hermes()
+        cmd = [hermes, "gateway"]
+        if self.profile:
+            cmd[1:1] = ["-p", self.profile]
+        gw_log_path = _hermes_home(self.workdir) / "gateway.log"
+        gw_log_path.parent.mkdir(parents=True, exist_ok=True)
+        # FIX: dulu stdout/stderr proc ini di-DEVNULL total — kalau `hermes
+        # gateway` gagal start (config salah, port kepake, dependency
+        # ilang, dst) gak ada JEJAK APAPUN buat diagnosis, proc mati diem2
+        # & _ensure_gateway_ready() di gui_server.py cuma timeout generik
+        # ("hermes gateway gak ready dalam Ns"). Sekarang redirect ke
+        # gateway.log (append, biar histori beberapa kali respawn/crash
+        # kebaca, bukan ketimpa). File handle di PARENT aman ditutup abis
+        # Popen — child udah punya duplikat fd/handle sendiri (Windows
+        # maupun POSIX), sama pola kayak _logfile tmux di atas cuma lewat
+        # Popen langsung, bukan `tmux pipe-pane`.
+        gw_log = open(gw_log_path, "a", encoding="utf-8")
+        gw_log.write(f"\n=== spawn {time.strftime('%Y-%m-%d %H:%M:%S')} — {cmd!r} ===\n")
+        gw_log.flush()
+        self.proc = subprocess.Popen(
+            cmd, stdin=subprocess.DEVNULL,
+            stdout=gw_log, stderr=subprocess.STDOUT,
+            env=env, cwd=str(self.workdir))
+        gw_log.close()
+        self.gateway_key = key
+        self.gateway_port = port
+        self.gateway_log_path = gw_log_path
+
+    def _run_oneshot(self, text: str):
+        """Windows: spawn `hermes chat -q <text> -Q` (non-interactive,
+        gak butuh TTY). Output stream → queue. session_id di-parse dari
+        output → dipake --resume buat konteks lanjut."""
+        import shlex
+        # FIX (31 Agu): generate/repair config.yaml SEBELUM spawn — kalau
+        # config kosong, hermes masuk gate "not configured" → nanya interaktif
+        # "Run setup now? [Y/n]" → stdin DEVNULL → HANG PERMANEN.
+        self._ensure_hermes_config()
+        self._ensure_hermes_auth()  # FIX (04 Sep): sync token OAuth ke HERMES_HOME aktif
+        env = os.environ.copy()
+        # FIX (11 Sep): tambahin folder cua + runtime/Scripts ke PATH biar
+        # hermes CLI bisa nemu cua-computer-server.exe
+        base = Path(__file__).resolve().parent.parent
+        cua_dir = str(base / "cua")
+        runtime_dir = str(base / "runtime")
+        runtime_scripts = str(base / "runtime" / "Scripts")
+        # FIX: tambahin juga path cua-driver yang di-install hermes
+        cua_driver_path = str(Path.home() / "AppData" / "Local" / "Programs" / "Cua" / "cua-driver" / "bin")
+        env["PATH"] = cua_dir + os.pathsep + runtime_dir + os.pathsep + runtime_scripts + os.pathsep + cua_driver_path + os.pathsep + env.get("PATH", "")
+        env.update({
+            # HOME ga di-override: Hermes hormat HERMES_HOME, dan
+            # memaksa HOME ke workdir bikin auth global user
+            # (~/.hermes/auth.json untuk Portal OAuth) gak ketemu —
+            # gejalanya oneshot diam tanpa error. Dulu HOME di-paksa
+            # karena .hermes masih di workdir/.hermes; sekarang
+            # HERMES_HOME yg dipisah dari workdir.
+            "HERMES_HOME": str(_hermes_home(self.workdir)),
+            "TERMINAL_CWD": str(self.workdir),
+            "UB_MODEL": self.model,
+            "UB_API_KEY": self.api_key,
+            "PYTHONUTF8": "1",
+            "HERMES_DEFER_AGENT_STARTUP": "1",
+            # FIX (01 Sep): biar kerjaan panjang (CTF, exploit, riset) gak
+            # ke-potong di 12 iterasi — config max_turns 150 + env backup.
+            "HERMES_MAX_ITERATIONS": "150",
+        })
+        # FIX (02 Sep #12): UB_BASE_URL gak pernah di-set di jalur Windows
+        # ini sama sekali (padahal Linux path di spawn() udah nyetel) —
+        # config.yaml SUDAH bener nulis base_url per-provider (lihat
+        # _ensure_hermes_config), tapi kalau hermes CLI prioritasin env
+        # var di atas config file (umum di banyak CLI tool), base_url yang
+        # bener gak pernah nyampe ke proc-nya. Sekarang disamain: env ikut
+        # self.base_url (hasil resolve dari registry model aktif), bukan
+        # ke-tebak dari nama model kayak sebelumnya.
+        if getattr(self, "base_url", None):
+            env["UB_BASE_URL"] = self.base_url
+        # FIX (02 Sep #12 → #13): provider → env var mapping GENERIC, bukan
+        # hardcoded `DEEPSEEK_API_KEY` doang. Hermes CLI provider resolver
+        # cek env var per-prefix (OPENROUTER_API_KEY, GMI_API_KEY, dll —
+        # lihat cli-config.yaml.example) — kalau gak ada, dia bail
+        # ("Provider resolver returned an empty API key"). Sebelumnya
+        # cuma `DEEPSEEK_API_KEY` di-inject, jadi provider lain (GMI,
+        # OpenRouter, custom) gagal despite key udah di-set di UI
+        # (config.yaml bener, tapi env var ke provider-specific prefix
+        # gak pernah di-pass). Sekarang: provider_slug → key_env_var
+        # pake mapping, fallback ke `<PROVIDER>_API_KEY`. Result: user
+        # add provider bebas di settings UI → env var yg cocok ke-inject
+        # otomatis pas spawn, gak perlu patch ulang tiap provider baru.
+        _prov = (getattr(self, "provider", "") or "").lower().strip()
+        # FIX (03 Sep): provider "hermes" (UI slug) → "nous" (hermes CLI
+        # provider name). hermes CLI gak recognize "hermes" sebagai provider.
+        if _prov == "hermes":
+            _prov = "nous"
+        if not _prov:
+            # provider default/kosong → set DEEPSEEK_API_KEY (default lama)
+            env["DEEPSEEK_API_KEY"] = self.api_key
+        else:
+            _key_env = _PROVIDER_KEY_ENV.get(_prov, f"{_prov.upper()}_API_KEY")
+            env[_key_env] = self.api_key
+        if getattr(self, "thinking", None):
+            env["UB_REASONING_EFFORT"] = self.thinking
+            env["REASONING_EFFORT"] = self.thinking
+        if self.tavily_key:
+            env["TAVILY_API_KEY"] = self.tavily_key
+        hermes = self._find_hermes()
+        # FIX (02 Sep): JANGAN pake -Q (quiet) — hermes force
+        # tool_progress_mode="off" di quiet mode → tool preview ("┊ ✍️
+        # write ...", "┊ 📖 read ...") di-suppress TOTAL → pane Activity
+        # gak pernah ke-trigger (user kira agent gak pake tools). Tanpa -Q
+        # tool progress ke-render; noise tambahan (Query:, footer Session:)
+        # di-handle stream_filter + parser session_id (dua format).
+        cmd = [hermes, "chat", "-q", text, "--yolo", "--no-restore-cwd",
+               # FIX (02 Sep #4): -v (verbose) → hermes emit info context:
+               #   stdout: "📊 Context limit: N tokens (compress at P% = M)"
+               #   stderr: "Token usage: prompt=N, completion=M"
+               # (tanpa -v dua-duanya di-suppress di oneshot mode). Baris
+               # logging "HH:MM:SS - module - LEVEL" ikut ke-emit → di-drop
+               # stream_filter. Dipake gui_server buat ctx bar + deteksi
+               # auto-compact aktif.
+               "-v",
+               "-t", self._tools_flag()]
+        if self.profile:
+            prof_dir = _hermes_home(self.workdir) / "profiles" / self.profile
+            if prof_dir.exists():
+                cmd[1:1] = ["-p", self.profile]
+        if getattr(self, "session_id", None):
+            cmd += ["--resume", self.session_id]
+        print("oneshot: " + " ".join(cmd[:6]) + "...", flush=True)
+        # FIX (04 Sep #2): tutup PAKSA proc + reader thread LAMA (kalau
+        # masih ada/nyangkut — mis. warmup probe yang timeout 90s tanpa
+        # sempet early-exit, atau chat sebelumnya yang di-stop tapi
+        # procnya belum bener2 kelar exit) SEBELUM self.proc di-assign
+        # ke proc BARU di bawah. Kenapa ini WAJIB: _reader() baca
+        # `self.proc.stdout` ULANG tiap iterasi loop (bukan snapshot
+        # sekali di awal) — kalau thread reader lama masih hidup pas
+        # self.proc ketiban proc baru, thread lama itu bakal nyasar ikut
+        # baca stdout proc BARU di iterasi berikutnya. Dua thread rebutan
+        # baca 1 pipe yang sama = baris ke-korup/ke-drop/ke-duplikat, dan
+        # readline() concurrent kayak gini kadang raise exception yang
+        # bikin salah satu thread MATI DIAM-DIAM (gak ada try/except di
+        # _reader) → poll_output() selamanya kosong → chat kayak gak
+        # keproses sampe STUCK 5 menit baru ketauan. Ini persis gejala:
+        # "abis idle lama/baru buka app, chat pertama gak ke-proses,
+        # harus stop+kirim ulang baru jalan" — warmup probe yang lambat
+        # nyerempet chat pertama beneran, exact race di atas.
+        _old_proc, _old_thread = self.proc, self._thread
+        if _old_proc is not None:
+            try:
+                if _old_proc.poll() is None:
+                    _old_proc.terminate()
+            except Exception:
+                pass
+        if _old_thread is not None and _old_thread.is_alive():
+            _old_thread.join(timeout=2.0)
+            if _old_thread.is_alive():
+                # 2s gak cukup (proc bandel nolak terminate) — paksa kill
+                try:
+                    if _old_proc is not None and _old_proc.poll() is None:
+                        _old_proc.kill()
+                except Exception:
+                    pass
+                _old_thread.join(timeout=2.0)
+                if _old_thread.is_alive():
+                    print("WARNING: reader thread lama gak mau berhenti "
+                          "dalam 4s — lanjut spawn proc baru, tapi race "
+                          "masih mungkin kejadian sekali ini", flush=True)
+        self.proc = subprocess.Popen(
+            cmd, stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            text=True, encoding="utf-8", errors="replace",
+            env=env, cwd=str(self.workdir), bufsize=1)
+        self._thread = threading.Thread(target=self._reader, daemon=True)
+        self._thread.start()
+
+    def _reader(self):
+        assert self.proc and self.proc.stdout
+        while True:
+            line = self.proc.stdout.readline()
+            if not line:
+                break
+            self._out_queue.put(line)
+
+    def _reader_pty(self):
+        """Baca dari pty master → queue (chunk-based, pty gak ada readline)."""
+        import os as _os
+        while True:
+            try:
+                data = _os.read(self._pty_master, 4096)
+                if not data:
+                    break
+                self._out_queue.put(data.decode("utf-8", errors="replace"))
+            except Exception:
+                break
+
+    def is_alive(self) -> bool:
+        """Cek hermes process masih hidup (winpty/tmux/pipe/oneshot).
+        FIX (31 Agu) oneshot: proc udah exit TAPI session_id masih ada =
+        konteks bisa di-resume via --resume — jangan dianggap mati, kalau
+        mati ensure_session bakal respawn & session_id hilang → konteks
+        antar-chat ilang (agent lupa chat sebelumnya)."""
+        try:
+            if getattr(self, "_oneshot", False):
+                if self.proc and self.proc.poll() is None:
+                    return True
+                # proc exit — masih "hidup" kalo punya session_id buat resume
+                return bool(getattr(self, "session_id", None))
+            if hasattr(self, "_tmux_name"):
+                r = subprocess.run(["tmux", "has-session", "-t",
+                                    self._tmux_name], capture_output=True)
+                return r.returncode == 0
+            if getattr(self, "_winpty", None):
+                return bool(self._winpty.isalive())
+            if self.proc:
+                return self.proc.poll() is None
+        except Exception:
+            pass
+        return False
+
+    def send(self, text: str):
+        if getattr(self, "_oneshot", False):
+            self._run_oneshot(text)
+            return
+        if hasattr(self, "_tmux_name"):
+            # ── submit robust: tmux send-keys flaky (Enter ke-drop pas
+            #    render). teks dikirim literal, terus Enter diulang tiap
+            #    1.5s SAMPE teks ilang dari prompt (capture-pane) — baru
+            #    dianggap ke-submit. gak peduli timing render. ──
+            import re as _re
+            subprocess.run(["tmux", "send-keys", "-t", self._tmux_name,
+                            "-l", text], check=False)
+            for _ in range(10):
+                time.sleep(1.5)
+                try:
+                    r = subprocess.run(
+                        ["tmux", "capture-pane", "-p", "-t", self._tmux_name],
+                        capture_output=True, text=True, timeout=5)
+                    pane = _re.sub(r"\x1b\[[0-9;? ]*[A-Za-z]", "", r.stdout or "")
+                except Exception:
+                    pane = ""
+                # teks masih di prompt "❯ <teks>" → belum submit → Enter lagi
+                if f"❯ {text}" in pane or f"> {text}" in pane:
+                    subprocess.run(["tmux", "send-keys", "-t",
+                                    self._tmux_name, "Enter"], check=False)
+                    continue
+                # teks udah ilang dari prompt = ke-submit (atau prompt
+                # ke-render ulang) — pastikan prompt kosong sebelum exit
+                if "❯" in pane:
+                    return
+            # timeout 15s: kirim Enter sekali terakhir buat jaga-jaga
+            subprocess.run(["tmux", "send-keys", "-t", self._tmux_name,
+                            "Enter"], check=False)
+        elif os.name == "posix" and hasattr(self, "_pty_master"):
+            os.write(self._pty_master, (text + "\r").encode("utf-8"))
+        elif getattr(self, "_winpty", None):
+            # ── winpty ConPTY flaky kayak tmux: Enter bisa ke-drop pas
+            #    render. pisahin teks & Enter + retry kalau gak ada
+            #    output sama sekali (gak ke-submit). ──
+            self._winpty.write(text)
+            time.sleep(0.3)
+            self._winpty.write("\r")
+            for _ in range(3):
+                time.sleep(1.5)
+                if not self._out_queue.empty():
+                    return  # ada output = ke-submit
+                self._winpty.write("\r")
+        else:
+            assert self.proc and self.proc.stdin
+            self.proc.stdin.write(text + "\n")
+            self.proc.stdin.flush()
+
+    def stop(self):
+        """Stop generation yang lagi jalan (interrupt hermes).
+        Dipanggil dari websocket {type: 'stop'} (tombol '■ hentikan')."""
+        try:
+            if hasattr(self, "_tmux_name"):
+                subprocess.run(["tmux", "send-keys", "-t", self._tmux_name,
+                                "C-c"], check=False)
+            elif os.name == "posix" and hasattr(self, "_pty_master"):
+                os.write(self._pty_master, b"\x03")
+            elif getattr(self, "_winpty", None):
+                self._winpty.write("\x03")
+            elif self.proc and self.proc.poll() is None:
+                self.proc.terminate()
+        except Exception:
+            pass
+
+    def wait_ready(self, timeout: float = 60) -> bool:
+        """Tunggu hermes siap (prompt '>' muncul di output) — kayak userbot probe.
+        Return True kalau udah siap, False kalau timeout."""
+        t0 = time.time()
+        buf = ""
+        while time.time() - t0 < timeout:
+            for line in self.poll_output(0.3):
+                buf += line
+            if "❯" in buf or "> " in buf:
+                return True
+            time.sleep(0.2)
+        return False
+
+    def poll_output(self, timeout: float = 0.1):
+        """Ambil semua output yang udah masuk (non-blocking)."""
+        lines = []
+        try:
+            while True:
+                lines.append(self._out_queue.get(timeout=timeout))
+        except queue.Empty:
+            pass
+        return lines
+
+    def close(self):
+        if getattr(self, "_oneshot", False):
+            if self.proc:
+                try:
+                    self.proc.kill()
+                except Exception:
+                    pass
+            self.proc = None
+            return
+        if hasattr(self, "_tmux_name"):
+            subprocess.run(["tmux", "kill-session", "-t", self._tmux_name],
+                           capture_output=True, check=False)
+            try:
+                os.unlink(self._logfile)  # bersihin logfile stream
+            except Exception:
+                pass
+        if os.name == "posix" and hasattr(self, "_pty_master"):
+            try:
+                os.close(self._pty_master)
+            except Exception:
+                pass
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception:
+                pass
+            self.proc = None
+        if getattr(self, "_winpty", None):
+            try:
+                self._winpty.terminate()
+            except Exception:
+                pass
+            self._winpty = None
+
+
+if __name__ == "__main__":
+    # smoke test: spawn hermes, kirim halo, baca output 15 detik
+    key = os.environ.get("DEEPSEEK_API_KEY", "")
+    if not key:
+        print("set DEEPSEEK_API_KEY dulu")
+        raise SystemExit(1)
+    s = HermesSession(key)
+    s.spawn()
+    import time
+    time.sleep(8)  # pre-warm
+    s.send("halo, balas singkat")
+    t0 = time.time()
+    while time.time() - t0 < 15:
+        for line in s.poll_output():
+            print(line, end="")
+        time.sleep(0.3)
+    s.close()