linkgravity 1.0.0

package/src/config.py

@@ -0,0 +1,123 @@
+import os
+from pathlib import Path
+
+from core.atomic_io import atomic_write_json, safe_load_json
+
+WORKSPACE_DIR = Path.home() / ".gemini" / "linkgravity"
+WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
+DATA_DIR = WORKSPACE_DIR / "data"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+LGY_CONFIG_FILE = WORKSPACE_DIR / "lgy.json"
+
+DEFAULT_LGY_CONFIG = {
+    "discord_token": "",
+    "session_scopes": [],
+    "allowed_user_ids": "",
+    "wake_words": "Jarvis",
+    "active_timer": 60,
+    "voice_threshold": 3000,
+    "tts_voice": "ko-KR-SunHiNeural",
+    "tts_enabled": True,
+}
+
+
+class _PrintLogger:
+    """logger.py hasn't been initialized yet at this point in config.py's
+    own load order, so this is a minimal stand-in just for the (rare)
+    lgy.json-corrupted case."""
+
+    def error(self, msg):
+        print(f"[config] {msg}")
+
+
+def load_bot_settings():
+    data = safe_load_json(LGY_CONFIG_FILE, DEFAULT_LGY_CONFIG.copy(), logger=_PrintLogger())
+    for k, v in DEFAULT_LGY_CONFIG.items():
+        data.setdefault(k, v)
+    return data
+
+
+def save_bot_settings(data):
+    atomic_write_json(LGY_CONFIG_FILE, data)
+
+
+bot_settings = load_bot_settings()
+
+from core.logger import init_logger
+from core.session_manager import SessionManager
+
+logger = init_logger(WORKSPACE_DIR)
+
+
+DISCORD_TOKEN = bot_settings.get("discord_token", "")
+
+
+def _parse_session_scopes(raw_scopes) -> dict:
+    """
+    Each entry: {"guild_id": "...", "channel_ids": ["...", ...]}.
+    An empty/missing channel_ids means "the whole server is allowed" -
+    otherwise only the listed channels within that server are allowed.
+    Returns {guild_id: frozenset_of_channel_ids_or_None}.
+    """
+    scopes = {}
+    for entry in raw_scopes or []:
+        try:
+            guild_id = int(entry["guild_id"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        channel_ids = entry.get("channel_ids") or []
+        channel_ids = {int(c) for c in channel_ids if str(c).strip()}
+        scopes[guild_id] = frozenset(channel_ids) if channel_ids else None
+    return scopes
+
+
+SESSION_SCOPES = _parse_session_scopes(bot_settings.get("session_scopes"))
+ALLOWED_IDS = set(int(x) for x in bot_settings.get("allowed_user_ids", "").split(",") if x.strip())
+TTS_VOICE = bot_settings.get("tts_voice", "ko-KR-SunHiNeural")
+
+
+def is_allowed_session_channel(channel) -> bool:
+    """True if a new agy session may be started from this channel (via
+    /new). A channel is allowed if its server is in SESSION_SCOPES AND
+    either that server has no channel restriction (whole-server access)
+    or this specific channel is in its allowed list."""
+    guild = getattr(channel, "guild", None)
+    if not guild or guild.id not in SESSION_SCOPES:
+        return False
+    allowed_channels = SESSION_SCOPES[guild.id]
+    return allowed_channels is None or channel.id in allowed_channels
+
+
+TMP_FILE_DIR = WORKSPACE_DIR / "tmp-files"
+TMP_VOICE_DIR = WORKSPACE_DIR / "tmp-voice"
+# Per-user wake-word recordings + built .rpw reference (see
+# EnrollmentManager in cogs/voice/enrollment.py). No folder/.rpw yet means
+# "not enrolled" - falls back to transcribing everything and matching
+# bot_settings["wake_words"] as text.
+WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
+
+TMP_FILE_DIR.mkdir(parents=True, exist_ok=True)
+TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
+WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
+
+MAX_EMBED_LEN = 1900
+STREAM_RATE_LIMIT_SEC = 0.5
+PERSISTENT_FILE = DATA_DIR / "persistent_tools.json"
+SESSION_FILE = DATA_DIR / "sessions.json"
+
+EMBED_COLOR = 0x5865F2
+
+MODEL_CHOICES = {
+    "flash": "Gemini 3.5 Flash",
+    "flash_lite": "Gemini 3.5 Flash Lite",
+    "pro": "Gemini 3.1 Pro",
+}
+
+AGY_BIN = os.getenv("AGY_BIN_PATH", str(Path.home() / ".local/bin/agy"))
+
+session_manager = SessionManager(DATA_DIR)
+
+
+def allowed(user_id: int) -> bool:
+    return not ALLOWED_IDS or user_id in ALLOWED_IDS

package/src/core/agy_runner.py

@@ -0,0 +1,380 @@
+import asyncio
+import functools
+import os
+import re
+import signal
+
+from config import logger
+
+active_processes = {}
+agy_start_lock = asyncio.Lock()
+# Threads killed intentionally - agy's SIGTERM exit code isn't reliable enough to tell otherwise.
+_intentionally_stopped = set()
+
+# Forced stdout buffer size (see _find_libstdbuf) - big enough for one write, small enough not to delay polling.
+_STDOUT_BUFFER_SIZE = 65536
+
+
+@functools.lru_cache(maxsize=1)
+def _find_libstdbuf() -> str | None:
+    """Find libstdbuf.so, the shared library `stdbuf` LD_PRELOADs. Linux-only
+    (no macOS/Windows equivalent implemented) - returns None there too.
+
+    agy runs commands under a PTY, so glibc line-buffers instead of
+    fully-buffering stdout - agy's completion-detection misreads the gap
+    between line writes as "done," truncating multi-line output to its
+    first line despite exit code 0. LD_PRELOADing this forces full
+    buffering instead. Returns None (no fix applied) if not found.
+    """
+    candidates = [
+        "/usr/lib/x86_64-linux-gnu/coreutils/libstdbuf.so",  # Debian/Ubuntu
+        "/usr/lib/aarch64-linux-gnu/coreutils/libstdbuf.so",
+        "/usr/libexec/coreutils/libstdbuf.so",  # Fedora/RHEL
+        "/usr/lib/coreutils/libstdbuf.so",  # Arch
+        "/usr/lib/libstdbuf.so",
+    ]
+    for path in candidates:
+        if os.path.isfile(path):
+            return path
+
+    # lru_cache: only runs once per process.
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["find", "/usr", "-name", "libstdbuf.so"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        found = [line for line in result.stdout.strip().splitlines() if line]
+        if found:
+            return found[0]
+    except Exception:
+        pass
+
+    logger.warning(
+        "[AGY ENV] libstdbuf.so not found - run_command output for "
+        "multi-line commands may come back truncated. Add its path to "
+        "_find_libstdbuf()'s candidates list if coreutils is installed "
+        "somewhere nonstandard."
+    )
+    return None
+
+
+def stop_active_process(thread_id: str) -> bool:
+    """Kill the agy subprocess for this thread, if any. Also used when a
+    new voice utterance interrupts a still-in-flight turn. Returns
+    whether a process was actually found and signaled.
+    """
+    target_proc = active_processes.get(thread_id)
+    if not target_proc:
+        return False
+    _intentionally_stopped.add(thread_id)
+    if os.name == "nt":
+        try:
+            target_proc.send_signal(signal.CTRL_BREAK_EVENT)
+        except Exception:
+            target_proc.kill()
+    else:
+        try:
+            os.killpg(os.getpgid(target_proc.pid), signal.SIGTERM)
+        except Exception:
+            target_proc.kill()
+    return True
+
+
+async def _get_latest_conversation_id() -> str:
+    try:
+        from pathlib import Path
+
+        history_dir = Path.home() / ".gemini/antigravity-cli/brain"
+        if not history_dir.exists():
+            return ""
+        dirs = [d for d in history_dir.iterdir() if d.is_dir()]
+        if not dirs:
+            return ""
+        latest = max(dirs, key=lambda x: x.stat().st_mtime)
+        return latest.name
+    except Exception:
+        return ""
+
+
+async def run_agy(
+    *args, timeout: int = 300, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
+) -> str:
+    args_list = list(args)
+
+    if cwd:
+        expanded_cwd = os.path.expanduser(cwd)
+        os.makedirs(expanded_cwd, exist_ok=True)
+        cwd_param = expanded_cwd
+        args_list = ["--add-dir", expanded_cwd] + args_list
+    else:
+        cwd_param = None
+
+    try:
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                env = os.environ.copy()
+                env["AGY_DISCORD_BOT"] = "1"
+                env["PYTHONUNBUFFERED"] = "1"
+                if thread_id:
+                    env["DISCORD_THREAD_ID"] = thread_id
+
+                libstdbuf_path = _find_libstdbuf()  # works around agy's output-truncation bug
+                if libstdbuf_path:
+                    existing_preload = env.get("LD_PRELOAD", "")
+                    env["LD_PRELOAD"] = (
+                        f"{libstdbuf_path}:{existing_preload}" if existing_preload else libstdbuf_path
+                    )
+                    env["_STDBUF_O"] = str(_STDOUT_BUFFER_SIZE)
+
+                kwargs = {
+                    "stdout": asyncio.subprocess.PIPE,
+                    "stderr": asyncio.subprocess.PIPE,
+                    "stdin": asyncio.subprocess.DEVNULL,
+                    "cwd": cwd_param,
+                    "env": env,
+                }
+
+                if os.name == "nt":
+                    import subprocess
+
+                    kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+                elif hasattr(os, "setsid"):
+                    kwargs["preexec_fn"] = os.setsid
+
+                from config import AGY_BIN
+
+                cmd = [AGY_BIN] + args_list
+
+                async with agy_start_lock:
+                    proc = await asyncio.create_subprocess_exec(*cmd, **kwargs)
+                    if thread_id:
+                        active_processes[thread_id] = proc
+
+                    if stream_queue and "--conversation" not in args:
+                        await asyncio.sleep(1.0)
+                        latest_conv_id = await _get_latest_conversation_id()
+                        if latest_conv_id:
+                            await stream_queue.put(("__CONV_ID__:" + latest_conv_id, False))
+
+                stdout_chunks = []
+                stderr_chunks = []
+
+                import codecs
+
+                decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+
+                ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+                async def read_stdout():
+                    while True:
+                        chunk = await proc.stdout.read(1024)
+                        if not chunk:
+                            decoded = decoder.decode(b"", final=True)
+                            if decoded:
+                                clean = ansi_escape.sub("", decoded)
+                                stdout_chunks.append(clean)
+                                if stream_queue is not None:
+                                    await stream_queue.put((clean, False))
+                            break
+                        decoded = decoder.decode(chunk, final=False)
+                        if decoded:
+                            clean = ansi_escape.sub("", decoded)
+                            stdout_chunks.append(clean)
+                            if stream_queue is not None:
+                                await stream_queue.put((clean, False))
+                                if (
+                                    "(Calls tool:" in clean
+                                    or "Tool Output:" in clean
+                                    or "Tool Execute:" in clean
+                                    or clean.startswith("● ")
+                                ):
+                                    await stream_queue.put(("__SPLIT__", True))
+
+                async def read_stderr():
+                    while True:
+                        chunk = await proc.stderr.read(1024)
+                        if not chunk:
+                            break
+                        stderr_chunks.append(chunk)
+
+                async def _gather_pipes():
+                    await asyncio.gather(read_stdout(), read_stderr())
+
+                gather_task = asyncio.create_task(_gather_pipes())
+                wait_task = asyncio.create_task(proc.wait())
+
+                # Slices let the timeout pause during a pending Discord approval (up to 3600s).
+                from config import session_manager as _sm
+
+                poll_slice = 5.0
+                remaining_budget = float(timeout)
+                timed_out = False
+                while True:
+                    done, _pending_tasks = await asyncio.wait(
+                        [gather_task, wait_task], return_when=asyncio.FIRST_COMPLETED, timeout=poll_slice
+                    )
+                    if done:
+                        break
+                    if not _sm.pending_approvals:
+                        remaining_budget -= poll_slice
+                        if remaining_budget <= 0:
+                            timed_out = True
+                            break
+
+                if timed_out:
+                    gather_task.cancel()
+                    raise asyncio.TimeoutError()
+
+                if wait_task in done:
+                    try:
+                        await asyncio.wait_for(gather_task, timeout=1.0)
+                    except asyncio.TimeoutError:
+                        gather_task.cancel()
+                elif gather_task in done:
+                    try:
+                        await asyncio.wait_for(wait_task, timeout=2.0)
+                    except asyncio.TimeoutError:
+                        pass
+
+                text = "".join(stdout_chunks).strip()
+                err_text = b"".join(stderr_chunks).decode(errors="replace").strip()
+                if err_text:
+                    logger.warning(f"[AGY STDERR] {err_text}")
+
+                if proc.returncode is not None and proc.returncode != 0:
+                    if thread_id in _intentionally_stopped or proc.returncode in (-15, -9, 15, 9, 143, 137):
+                        error_msg = "🛑 Generation stopped by user request."
+                        if stream_queue is not None:
+                            await stream_queue.put(("\n\n" + error_msg, True))
+                        return error_msg
+
+                    if "authentication failed or timed out" in text or "authentication failed or timed out" in err_text:
+                        if attempt < max_retries - 1:
+                            logger.warning("[AGY RETRY] Authentication timeout. Retrying...")
+                            await asyncio.sleep(2.0)
+                            continue
+
+                    error_msg = f"⚠️ Agent exited abnormally (exit code {proc.returncode})\n"
+                    if err_text:
+                        error_msg += f"```\n{err_text}\n```\n"
+                    if text:
+                        error_msg += f"Output:\n```\n{text}\n```\n"
+                    logger.error(f"[AGY ERROR] {error_msg}")
+                    if stream_queue is not None:
+                        await stream_queue.put(("\n\n" + error_msg, True))
+                    return error_msg
+
+                # DEBUG-only (LOG_LEVEL) raw stdout capture.
+                logger.debug(f"[AGY RAW STDOUT] {text!r}")
+                return text or "(Empty response)"
+
+            except asyncio.CancelledError:
+                try:
+                    if proc:
+                        if os.name == "nt":
+                            proc.send_signal(signal.CTRL_BREAK_EVENT)
+                        else:
+                            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                except Exception:
+                    pass
+                msg = "🛑 AI Task manually stopped by user."
+                if stream_queue is not None:
+                    await stream_queue.put(("\n\n" + msg, True))
+                return msg
+            except asyncio.TimeoutError:
+                try:
+                    if proc:
+                        if os.name == "nt":
+                            proc.send_signal(signal.CTRL_BREAK_EVENT)
+                        else:
+                            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                except Exception:
+                    pass
+                if attempt < max_retries - 1:
+                    logger.warning("[AGY RETRY] Global timeout. Retrying...")
+                    await asyncio.sleep(2.0)
+                    continue
+                msg = "🛑 AI Task timed out."
+                if stream_queue is not None:
+                    await stream_queue.put(("\n\n" + msg, True))
+                return msg
+            except Exception as e:
+                logger.exception(f"[AGY UNEXPECTED ERROR] {e}")
+                if attempt < max_retries - 1:
+                    logger.warning(f"[AGY RETRY] Unexpected error: {e}. Retrying...")
+                    await asyncio.sleep(2.0)
+                    continue
+                msg = f"🛑 AI Task encountered an error: {str(e)}"
+                if stream_queue is not None:
+                    await stream_queue.put(("\n\n" + msg, True))
+                return msg
+    finally:
+        if thread_id and thread_id in active_processes:
+            del active_processes[thread_id]
+        _intentionally_stopped.discard(thread_id)
+
+
+async def agy_new_conversation(
+    content: str, model: str = None, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
+) -> tuple[str, str]:
+    # --print consumes the next token as the prompt, so the flag must come first.
+    args = ["--dangerously-skip-permissions", "--print", content]
+    if model:
+        args.extend(["--model", model])
+    result_text = await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
+    conv_id = await _get_latest_conversation_id()
+    return result_text, conv_id
+
+
+async def agy_send_message(
+    conv_id: str,
+    content: str,
+    model: str = None,
+    stream_queue: asyncio.Queue = None,
+    thread_id: str = None,
+    cwd: str = None,
+) -> str:
+    args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id]
+    if model:
+        args.extend(["--model", model])
+    return await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
+
+
+def get_current_model() -> str:
+    import json
+    from pathlib import Path
+
+    try:
+        settings_path = Path.home() / ".gemini/antigravity-cli/settings.json"
+        if settings_path.exists():
+            data = json.loads(settings_path.read_text())
+            return data.get("model", "Default")
+    except Exception:
+        logger.warning("Failed to read current model from settings.json")
+    return "Default"
+
+
+async def generate_thread_title(user_input: str, response: str) -> str:
+    fallback = user_input.replace("\n", " ").strip()
+    if len(fallback) > 50:
+        fallback = fallback[:47] + "..."
+
+    try:
+        prompt = (
+            "Summarize the topic of this exchange in 5 words or fewer, as a short title. "
+            "Reply with ONLY the title text, no quotes, no punctuation at the end.\n\n"
+            f"Question: {user_input[:500]}\n\nAnswer: {response[:500]}"
+        )
+        title = await run_agy("--print", prompt, timeout=30)
+        title = title.strip().strip('"').strip("'")
+        if not title or len(title) > 80:
+            return fallback
+        return title
+    except Exception as e:
+        logger.warning(f"AI thread-title generation failed, falling back to raw input: {e}")
+        return fallback

package/src/core/atomic_io.py

@@ -0,0 +1,31 @@
+import json
+import os
+from pathlib import Path
+
+
+def atomic_write_json(path: Path, data) -> None:
+    """Writes JSON atomically: writes to a temp file first, then renames it
+    into place. os.replace() is atomic on both POSIX and Windows, so a
+    crash mid-write leaves the ORIGINAL file untouched instead of a
+    half-written, corrupted one."""
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    tmp_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    os.replace(tmp_path, path)
+
+
+def safe_load_json(path: Path, default, logger=None):
+    """Loads JSON, returning `default` (and backing up the file) if it's
+    missing or fails to parse - and actually logging that, instead of
+    silently pretending nothing was ever saved."""
+    if not path.exists():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        if logger:
+            logger.error(f"Failed to parse {path}: {e} - backing up as .corrupted and starting fresh")
+        try:
+            path.replace(path.with_suffix(path.suffix + ".corrupted"))
+        except OSError:
+            pass
+        return default

package/src/core/logger.py

@@ -0,0 +1,28 @@
+import logging
+import os
+from pathlib import Path
+from sys import stdout
+
+from loguru import logger
+
+
+def init_logger(workspace_dir: Path):
+    logging.getLogger("discord").setLevel(logging.WARNING)
+    LOG_DIR = workspace_dir / "logs"
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    logger.remove()
+    log_format = "<green>{time:YYYY-MM-DD HH:mm:ss}</green> <level>{level: <5}</level> <cyan>{name}</cyan>: {message}"
+    file_format = "{time:YYYY-MM-DD HH:mm:ss} {level: <5} {name}: {message}"
+    # Defaults to INFO - set LOG_LEVEL=DEBUG then `lgy restart` for
+    # verbose detail (e.g. agy_runner.py's raw agy stdout capture).
+    level = os.environ.get("LOG_LEVEL", "INFO").upper()
+    logger.add(stdout, level=level, format=log_format, colorize=True)
+    logger.add(
+        LOG_DIR / "bot.log",
+        format=file_format,
+        level=level,
+        rotation="10 MB",
+        retention="7 days",
+        encoding="utf-8",
+    )
+    return logger

package/src/core/session_manager.py

@@ -0,0 +1,126 @@
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from core.atomic_io import atomic_write_json, safe_load_json
+
+
+class SessionManager:
+    """Manages conversation state, async streaming queues, and user approval states."""
+
+    def __init__(self, data_dir: Path):
+        self.session_file = data_dir / "sessions.json"
+        self.persistent_file = data_dir / "persistent_tools.json"
+
+        self.sessions: dict[str, dict] = self._load_sessions()
+        self.active_queues: dict[str, asyncio.Queue] = {}
+        self.active_tts_tasks: dict[str, asyncio.Task] = {}
+        self.pending_approvals: dict[str, asyncio.Future] = {}
+        self.pending_approval_types: dict[str, str] = {}
+        self.pending_approval_messages: dict[str, Any] = {}
+        # conv_id -> current approval_key. Keyed by approval_key (not conv_id)
+        # so a 2nd call can't overwrite the 1st's still-pending Future.
+        self.active_approval_by_conv: dict[str, str] = {}
+
+        self.persistent_allowed: dict = self._load_persistent()
+        self.session_allowed_tools: dict[str, set] = {}
+
+    def _load_sessions(self) -> dict:
+        from config import logger
+
+        return safe_load_json(self.session_file, {}, logger=logger)
+
+    def save_sessions(self):
+        atomic_write_json(self.session_file, self.sessions)
+
+    def get_session(self, thread_id: str) -> dict | None:
+        return self.sessions.get(str(thread_id))
+
+    def set_session(self, thread_id: str, data: dict):
+        self.sessions[str(thread_id)] = data
+        self.save_sessions()
+
+    def update_session(self, thread_id: str, key: str, value: Any):
+        if str(thread_id) in self.sessions:
+            self.sessions[str(thread_id)][key] = value
+            self.save_sessions()
+
+    def remove_session(self, thread_id: str) -> dict | None:
+        sess = self.sessions.pop(str(thread_id), None)
+        self.save_sessions()
+        return sess
+
+    def get_all_sessions(self) -> dict[str, dict]:
+        return self.sessions
+
+    def _load_persistent(self) -> dict:
+        from config import logger
+
+        data = safe_load_json(self.persistent_file, {"tools": [], "commands": []}, logger=logger)
+        if isinstance(data, list):
+            return {"tools": data, "commands": []}
+        return data
+
+    def save_persistent(self):
+        atomic_write_json(self.persistent_file, self.persistent_allowed)
+
+    def register_queue(self, thread_id: str, queue: asyncio.Queue):
+        self.active_queues[str(thread_id)] = queue
+
+    def remove_queue(self, thread_id: str) -> asyncio.Queue | None:
+        return self.active_queues.pop(str(thread_id), None)
+
+    def get_queue(self, thread_id: str) -> asyncio.Queue | None:
+        return self.active_queues.get(str(thread_id))
+
+    def has_active_queues(self) -> bool:
+        return bool(self.active_queues)
+
+    def get_active_queue_keys(self) -> list:
+        return list(self.active_queues.keys())
+
+    def get_tts_task(self, thread_id: str) -> asyncio.Task | None:
+        return self.active_tts_tasks.get(str(thread_id))
+
+    def set_tts_task(self, thread_id: str, task: asyncio.Task):
+        self.active_tts_tasks[str(thread_id)] = task
+
+    def remove_tts_task(self, thread_id: str):
+        self.active_tts_tasks.pop(str(thread_id), None)
+
+    def set_pending_approval(
+        self, approval_key: str, future: asyncio.Future, app_type: str = "tool", conv_id: str | None = None
+    ):
+        self.pending_approvals[approval_key] = future
+        self.pending_approval_types[approval_key] = app_type
+        if conv_id:
+            self.active_approval_by_conv[conv_id] = approval_key
+
+    def get_pending_approval(self, approval_key: str) -> asyncio.Future | None:
+        return self.pending_approvals.get(approval_key)
+
+    def get_pending_approval_by_conv(self, conv_id: str) -> asyncio.Future | None:
+        """Looks up whichever approval is CURRENTLY active for a given
+        conversation - for callers that only have the stable
+        conversation_id, not the specific per-call approval_key (voice/
+        text "yes"/"no" responses, /stop)."""
+        approval_key = self.active_approval_by_conv.get(conv_id)
+        if not approval_key:
+            return None
+        return self.pending_approvals.get(approval_key)
+
+    def get_pending_approval_type_by_conv(self, conv_id: str) -> str:
+        approval_key = self.active_approval_by_conv.get(conv_id)
+        if not approval_key:
+            return "tool"
+        return self.pending_approval_types.get(approval_key, "tool")
+
+    def clear_pending_approval(self, approval_key: str):
+        self.pending_approvals.pop(approval_key, None)
+        self.pending_approval_types.pop(approval_key, None)
+        self.pending_approval_messages.pop(approval_key, None)
+        # Only remove the conv_id pointer if it still points at THIS key -
+        # a newer call may have already overwritten it.
+        for conv, key in list(self.active_approval_by_conv.items()):
+            if key == approval_key:
+                del self.active_approval_by_conv[conv]