@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/_legacy_pane_discovery.py

@@ -1,186 +0,0 @@
-"""Legacy reverse-scan tmux helpers retained for compatibility with
-existing receiver-discovery / takeover / claim-leader fallback paths.
-
-0.2.6 main slice (Family A) introduced
-``team_agent.leader_binding.bind_owner_from_caller_pane`` as the positive
-source for owner identity. These helpers remain available for older
-code paths and tests; they live in a non-linted module so that the
-positive-source CI lint (C24) can succeed on the files where the
-contract bans reverse enumeration patterns.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Any
-
-from team_agent.runtime import TMUX_PANE_FORMAT, run_cmd
-
-
-def _tmux_current_client_pane_info() -> dict[str, str] | None:
-    proc = run_cmd(["tmux", "display-message", "-p", "-F", TMUX_PANE_FORMAT], timeout=5)
-    if proc.returncode != 0:
-        return None
-    return _parse_tmux_pane_info(proc.stdout.strip())
-
-
-def _tmux_list_panes() -> list[dict[str, str]]:
-    proc = run_cmd(["tmux", "list-panes", "-a", "-F", TMUX_PANE_FORMAT], timeout=5)
-    if proc.returncode != 0:
-        return []
-    return [pane for line in proc.stdout.splitlines() if (pane := _parse_tmux_pane_info(line))]
-
-
-def _tmux_pane_info(target: str | None) -> dict[str, str] | None:
-    if not target:
-        return None
-    proc = run_cmd(["tmux", "display-message", "-p", "-t", target, "-F", TMUX_PANE_FORMAT], timeout=5)
-    if proc.returncode != 0:
-        return None
-    return _parse_tmux_pane_info(proc.stdout.strip())
-
-
-def _parse_tmux_pane_info(line: str) -> dict[str, str] | None:
-    parts = line.split("\t")
-    if len(parts) not in {8, 10, 11}:
-        return None
-    keys = [
-        "pane_id",
-        "session_name",
-        "window_index",
-        "window_name",
-        "pane_index",
-        "pane_tty",
-        "pane_current_command",
-        "pane_active",
-    ]
-    if len(parts) >= 10:
-        keys.extend(["pane_current_path", "session_attached"])
-    if len(parts) == 11:
-        keys.append("pane_in_mode")
-    return dict(zip(keys, parts))
-
-
-def _infer_active_tmux_pane(provider: str) -> dict[str, str] | None:
-    from team_agent.messaging.leader_panes import _leader_command_looks_usable
-    panes = _tmux_list_panes()
-    active = [pane for pane in panes if pane.get("pane_active") == "1"]
-    preferred = [pane for pane in active if _leader_command_looks_usable(pane.get("pane_current_command", ""), provider)]
-    if len(preferred) == 1:
-        return preferred[0]
-    if len(active) == 1:
-        return active[0]
-    if preferred:
-        return preferred[0]
-    return active[0] if active else None
-
-
-def _infer_workspace_tmux_pane(provider: str, workspace: Path) -> dict[str, Any]:
-    from team_agent.messaging.leader_panes import (
-        _leader_command_looks_usable,
-        _leader_command_provider,
-    )
-    panes = _tmux_list_panes()
-    workspace_panes = [pane for pane in panes if _pane_path_matches_workspace(pane, workspace)]
-    candidates = [
-        pane
-        for pane in workspace_panes
-        if _leader_command_looks_usable(pane.get("pane_current_command", ""), provider)
-        or _leader_command_provider(pane.get("pane_current_command", "")) is not None
-    ]
-    if not candidates:
-        return {"status": "missing", "workspace_panes": workspace_panes}
-    ranked = sorted(candidates, key=lambda item: _leader_pane_rank(item, provider), reverse=True)
-    best_rank = _leader_pane_rank(ranked[0], provider)
-    best = [pane for pane in ranked if _leader_pane_rank(pane, provider) == best_rank]
-    if len(best) == 1:
-        return {"status": "ok", "pane": best[0], "candidates": candidates}
-    return {"status": "ambiguous", "candidates": best}
-
-
-def _pane_is_usable_leader(pane: dict[str, str], provider: str, workspace: Path | None) -> bool:
-    _ = provider
-    if workspace is not None and not _pane_path_matches_workspace(pane, workspace):
-        return False
-    return True
-
-
-def _pane_path_matches_workspace(pane: dict[str, str], workspace: Path) -> bool:
-    current_path = pane.get("pane_current_path")
-    if not current_path:
-        return False
-    return os.path.realpath(current_path) == os.path.realpath(str(workspace.resolve()))
-
-
-def _leader_pane_rank(pane: dict[str, str], provider: str) -> tuple[int, int, int]:
-    from team_agent.messaging.leader_panes import _leader_command_is_exact
-    return (
-        _tmux_truthy(pane.get("session_attached", "")),
-        1 if pane.get("pane_active") == "1" else 0,
-        1 if _leader_command_is_exact(pane.get("pane_current_command", ""), provider) else 0,
-    )
-
-
-def _tmux_truthy(value: str) -> int:
-    try:
-        return 1 if int(value) > 0 else 0
-    except (TypeError, ValueError):
-        return 1 if value and value != "0" else 0
-
-
-def _format_leader_pane_candidates(candidates: list[dict[str, str]]) -> str:
-    compact = []
-    for pane in candidates[:5]:
-        compact.append(
-            "{pane_id} session={session_name} pane={window_index}.{pane_index} "
-            "cmd={pane_current_command} cwd={pane_current_path} active={pane_active}".format(**pane)
-        )
-    suffix = "" if len(candidates) <= 5 else f" ... +{len(candidates) - 5} more"
-    return "candidates: " + "; ".join(compact) + suffix
-
-
-def _resolve_leader_pane(
-    pane: str | None,
-    provider: str,
-    workspace: Path | None = None,
-    require_current: bool = False,
-) -> tuple[dict[str, str], str]:
-    from team_agent.errors import RuntimeError as _RuntimeError
-    if pane:
-        pane_info = _tmux_pane_info(pane)
-        if not pane_info:
-            raise _RuntimeError(f"tmux pane not found: {pane}")
-        return pane_info, "explicit_pane"
-    pane_info = _tmux_current_client_pane_info()
-    if pane_info and _pane_is_usable_leader(pane_info, provider, workspace):
-        return pane_info, "current_client"
-    if workspace is not None:
-        workspace_match = _infer_workspace_tmux_pane(provider, workspace)
-        if workspace_match["status"] == "ok":
-            return workspace_match["pane"], "workspace_pane_scan"
-        if workspace_match["status"] == "ambiguous":
-            raise _RuntimeError(
-                "multiple tmux leader panes match this workspace; pass --pane explicitly. "
-                + _format_leader_pane_candidates(workspace_match["candidates"])
-            )
-    if require_current:
-        details = ""
-        if pane_info:
-            details = (
-                f" Current tmux client points at pane {pane_info.get('pane_id')} "
-                f"command={pane_info.get('pane_current_command')!r} "
-                f"cwd={pane_info.get('pane_current_path')!r}, not a usable pane for this workspace."
-            )
-        raise _RuntimeError(
-            "Team Agent could not locate a tmux-managed leader pane for this workspace. "
-            "Run quick-start from the visible tmux-managed leader pane, "
-            "or use `team-agent codex`/`team-agent claude` as a convenience fallback."
-            + details
-        )
-    if pane_info and workspace is None:
-        return pane_info, "current_client"
-    pane_info = _infer_active_tmux_pane(provider)
-    if pane_info:
-        return pane_info, "active_pane_scan"
-    raise _RuntimeError("could not infer a tmux leader pane; pass --pane <pane_id>")

package/src/team_agent/abnormal_track.py

@@ -1,253 +0,0 @@
-"""Provider-neutral abnormal-state track (Gap 32 §4).
-
-Reads structured fault records + process identity; never reads a screen and
-never names a provider. Catch-bias for structured error/failed-class records
-(C9), dedup by (signature, turn) (C8), and coordinator-independent whole-team
-disappearance with clean-shutdown vs unexpected distinction (C10).
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def process_abnormal_records(
-    records: list[dict[str, Any]],
-    *,
-    registry: Any,
-    notification_state: dict[str, Any] | None,
-    event_sink: Any = None,
-) -> dict[str, Any]:
-    """Classify raw provider session records that may carry faults.
-
-    ``registry`` carries the provider whose records these are (``{"provider":
-    name}``) or a full registry mapping. Records are turned into structured
-    fault facts by the provider reader (so this module names no provider), then
-    catch-biased + deduped by (signature, turn).
-    """
-    from team_agent.provider_state import read_fault_facts
-    from team_agent.provider_state.registry import get_provider_registry
-
-    state = dict(notification_state or {})
-    seen = set(state.get("seen") or [])
-    notifications: list[dict[str, Any]] = []
-    discovery_log: list[dict[str, Any]] = []
-    diagnostics: list[dict[str, Any]] = []
-
-    provider = _provider_of(registry)
-    white, black = _lists_for(provider, registry, get_provider_registry)
-
-    faults = read_fault_facts(provider, records or []) if provider else []
-    if not faults and records:
-        # Records that produced no structured fault fact are not default-notify
-        # candidates (C9): arbitrary unrecognized lines become diagnostics only.
-        diagnostics.append({"kind": "no_structured_fault", "count": len(records)})
-
-    for fact in faults:
-        signature = str(fact.get("signature") or fact.get("reason") or "fault")
-        turn_id = fact.get("turn_id")
-        text = " ".join(str(x) for x in (signature, fact.get("reason"), _raw_message(fact)) if x).lower()
-        decision = _classify(text, signature, white, black)
-        discovery_log.append({
-            "signature": signature,
-            "turn_id": turn_id,
-            "decision": decision,
-            "kind": fact.get("kind"),
-            "provider": provider,
-        })
-        if decision == "skip":
-            continue
-        # C8: dedup by (signature, turn_id) — a retry loop in the SAME turn folds
-        # to one notify. But a MISSING turn_id must not collapse distinct errors
-        # into one global bucket: discriminate by a per-record content fingerprint
-        # so genuinely different faults each notify (identical duplicates still fold).
-        bucket = turn_id if turn_id is not None else f"norow:{_record_fingerprint(fact)}"
-        dedupe_key = (signature, bucket)
-        key = f"{signature}\x00{bucket}"
-        if key in seen:
-            continue
-        seen.add(key)
-        notifications.append({
-            "signature": signature,
-            "turn_id": turn_id,
-            "dedupe_key": dedupe_key,
-            "state": "blocked_on_human" if fact.get("kind") == "approval" else "abnormal",
-            "decision": decision,
-            "provider": provider,
-            "raw": fact.get("raw", fact),
-            "raw_record": fact.get("raw", fact),
-        })
-        _emit(event_sink, "abnormal.notify", signature=signature, turn_id=turn_id, decision=decision)
-
-    state["seen"] = sorted(seen)
-    return {
-        "notifications": notifications,
-        "discovery_log": discovery_log,
-        "diagnostics": diagnostics,
-        "notification_state": state,
-    }
-
-
-def detect_whole_team_gone(
-    snapshot: dict[str, Any],
-    *,
-    marker_store: Any,
-    event_sink: Any = None,
-) -> dict[str, Any]:
-    """Coordinator-independent whole-team-gone detection (C10/C13).
-
-    Does not require the coordinator to be alive. The whole team is gone when the
-    coordinator, the leader, every provider process, and every session are all
-    absent. Clean shutdown / restart-in-progress (flagged in the snapshot) are
-    silent; an unexpected disappearance records a durable marker and defers user
-    escalation to the next leader command.
-    """
-    coordinator = snapshot.get("coordinator") or {}
-    leader = snapshot.get("leader") or {}
-    provider_processes = snapshot.get("provider_processes")
-    if provider_processes is None:
-        provider_processes = snapshot.get("nodes") or snapshot.get("agents") or []
-    tmux_sessions = snapshot.get("tmux_sessions") or []
-
-    coord_alive = _alive(coordinator)
-    leader_alive = _alive(leader)
-    any_worker_alive = any(_alive(p) for p in provider_processes)
-    sessions_present = bool(tmux_sessions)
-
-    whole_gone = not (coord_alive or leader_alive or any_worker_alive or sessions_present)
-
-    if not whole_gone:
-        return {
-            "state": "alive",
-            "whole_team_gone": False,
-            "classification": "alive",
-            "notify": False,
-            "escalate_user_on_next_leader_command": False,
-            "marker_written": False,
-        }
-
-    if snapshot.get("clean_shutdown"):
-        return _silent_gone("clean_shutdown")
-    if snapshot.get("restart_in_progress"):
-        return _silent_gone("restart_in_progress")
-
-    # Unexpected disappearance (闪退): durable marker + deferred escalation.
-    marker_written = _marker_set(marker_store, "whole_team_gone", {
-        "classification": "unexpected_exit",
-        "provider_processes": len(provider_processes),
-    })
-    _emit(event_sink, "abnormal.whole_team_gone", classification="unexpected_exit")
-    return {
-        "state": "whole_team_gone",
-        "whole_team_gone": True,
-        "classification": "unexpected_exit",
-        "notify": True,
-        "escalate_user_on_next_leader_command": True,
-        "marker_written": bool(marker_written),
-    }
-
-
-def _silent_gone(classification: str) -> dict[str, Any]:
-    return {
-        "state": classification,
-        "whole_team_gone": True,
-        "classification": classification,
-        "notify": False,
-        "escalate_user_on_next_leader_command": False,
-        "marker_written": False,
-    }
-
-
-def _alive(entry: Any) -> bool:
-    from team_agent.provider_state.common import process_is_live
-
-    if isinstance(entry, dict):
-        if "alive" in entry:
-            return entry.get("alive") is True
-        if "process" in entry:
-            ok, _r, _d = process_is_live(entry.get("process"))
-            return ok
-        ok, _r, _d = process_is_live(entry)
-        return ok
-    return bool(entry)
-
-
-def _provider_of(registry: Any) -> str | None:
-    if isinstance(registry, dict):
-        if isinstance(registry.get("provider"), str):
-            return registry.get("provider")
-        if isinstance(registry.get("kind"), str):
-            return registry.get("kind")
-    return None
-
-
-def _lists_for(provider: str | None, registry: Any, get_provider_registry: Any) -> tuple[list[str], list[str]]:
-    entry: Any = None
-    if isinstance(registry, dict) and ("error_whitelist" in registry or "error_blacklist" in registry):
-        entry = registry
-    elif provider is not None:
-        entry = get_provider_registry(provider)
-    if not isinstance(entry, dict):
-        return [], []
-    lists = entry.get("error_lists") if isinstance(entry.get("error_lists"), dict) else {}
-    white = [str(x).lower() for x in (lists.get("whitelist") or entry.get("error_whitelist") or [])]
-    black = [str(x).lower() for x in (lists.get("blacklist") or entry.get("error_blacklist") or [])]
-    return white, black
-
-
-def _classify(text: str, signature: str, white: list[str], black: list[str]) -> str:
-    sig = signature.lower()
-    if any(w and (w in text or w in sig) for w in white):
-        return "skip"  # whitelist > blacklist > default
-    if any(b and (b in text or b in sig) for b in black):
-        return "notify_blacklist"
-    return "notify_default"  # C9 catch-bias for structured faults
-
-
-def _record_fingerprint(fact: dict[str, Any]) -> str:
-    import hashlib
-    import json
-
-    raw = fact.get("raw", fact)
-    try:
-        blob = json.dumps(raw, sort_keys=True, default=str)
-    except (TypeError, ValueError):
-        blob = repr(raw)
-    return hashlib.sha256(blob.encode("utf-8", errors="ignore")).hexdigest()[:16]
-
-
-def _raw_message(fact: dict[str, Any]) -> str:
-    raw = fact.get("raw")
-    if isinstance(raw, dict):
-        return str(raw.get("message") or "")
-    return ""
-
-
-def _marker_set(marker_store: Any, name: str, value: Any) -> bool:
-    if marker_store is None:
-        return False
-    if isinstance(marker_store, dict):
-        marker_store[name] = value
-        return True
-    setter = getattr(marker_store, "set", None) or getattr(marker_store, "write", None)
-    if callable(setter):
-        try:
-            setter(name, value)
-            return True
-        except Exception:
-            return False
-    return False
-
-
-def _emit(event_sink: Any, name: str, **fields: Any) -> None:
-    if event_sink is None:
-        return
-    try:
-        event_sink(name, fields)
-    except TypeError:
-        try:
-            event_sink({"event": name, **fields})
-        except Exception:
-            pass
-    except Exception:
-        pass

package/src/team_agent/approvals/__init__.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-from team_agent.approvals.constants import (
-    INTERNAL_MCP_APPROVAL_CHOICE,
-    INTERNAL_MCP_AUTO_APPROVE_TOOLS,
-    STARTUP_PROMPT_RUNTIME_CHECK_LIMIT,
-)
-from team_agent.approvals.parsing import (
-    APPROVAL_CHOICE_RE,
-    active_approval_choice_index,
-    active_approval_control_index,
-    approval_choice_keys,
-    approval_prompt_fingerprint,
-    capture_has_approval_prompt,
-    capture_has_team_orchestrator_mcp_prompt,
-    choose_internal_mcp_approval_choice,
-    extract_approval_choices,
-    extract_approval_prompt,
-    extract_command_approval_subject,
-    is_approval_control_line,
-    line_is_approval_choice,
-)
-from team_agent.approvals.runtime_prompts import (
-    handle_internal_mcp_approval_prompt,
-    handle_provider_runtime_prompts,
-    handle_provider_startup_prompts,
-    submit_internal_mcp_approval,
-)
-from team_agent.approvals.status import (
-    age_text,
-    agent_health_status,
-    current_task_for_agent,
-    detect_provider_status,
-    refresh_agent_runtime_statuses,
-    sync_agent_health,
-)
-
-__all__ = [
-    "APPROVAL_CHOICE_RE",
-    "INTERNAL_MCP_APPROVAL_CHOICE",
-    "INTERNAL_MCP_AUTO_APPROVE_TOOLS",
-    "STARTUP_PROMPT_RUNTIME_CHECK_LIMIT",
-    "active_approval_choice_index",
-    "active_approval_control_index",
-    "age_text",
-    "agent_health_status",
-    "approval_choice_keys",
-    "approval_prompt_fingerprint",
-    "capture_has_approval_prompt",
-    "capture_has_team_orchestrator_mcp_prompt",
-    "choose_internal_mcp_approval_choice",
-    "current_task_for_agent",
-    "detect_provider_status",
-    "extract_approval_choices",
-    "extract_approval_prompt",
-    "extract_command_approval_subject",
-    "handle_internal_mcp_approval_prompt",
-    "handle_provider_runtime_prompts",
-    "handle_provider_startup_prompts",
-    "is_approval_control_line",
-    "line_is_approval_choice",
-    "refresh_agent_runtime_statuses",
-    "submit_internal_mcp_approval",
-    "sync_agent_health",
-]

package/src/team_agent/approvals/constants.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-
-STARTUP_PROMPT_RUNTIME_CHECK_LIMIT = 3
-INTERNAL_MCP_AUTO_APPROVE_TOOLS = {"send_message", "report_result", "get_team_status", "request_human"}
-INTERNAL_MCP_APPROVAL_CHOICE = "Allow for this session"

package/src/team_agent/approvals/parsing.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import re
-from typing import Any
-
-from team_agent.approvals.constants import INTERNAL_MCP_APPROVAL_CHOICE
-
-
-APPROVAL_CHOICE_RE = re.compile(r"(?:[›❯>]\s*)?(\d+)\.\s+(.+?)(?:\s{2,}.+)?$")
-
-
-def capture_has_approval_prompt(text: str) -> bool:
-    return extract_approval_prompt("_", text) is not None
-
-
-def extract_approval_prompt(agent_id: str, text: str) -> dict[str, Any] | None:
-    lines = text.splitlines()
-    control_index = active_approval_control_index(lines)
-    if control_index is None:
-        return None
-    for index in range(control_index, -1, -1):
-        line = lines[index]
-        if "Allow the team_orchestrator MCP server to run tool" not in line:
-            continue
-        tool_match = re.search(r'run tool "([^"]+)"', line)
-        return {
-            "agent_id": agent_id,
-            "state": "waiting_approval",
-            "kind": "mcp_tool",
-            "tool": tool_match.group(1) if tool_match else None,
-            "prompt": line.strip(),
-            "choices": extract_approval_choices(lines[index : control_index + 1]),
-        }
-    for index in range(control_index, -1, -1):
-        line = lines[index]
-        if line_is_approval_choice(line):
-            continue
-        tool_match = re.search(r"\bteam_orchestrator\s*[-.]\s*([A-Za-z_][A-Za-z0-9_]*)\b", line)
-        if not tool_match:
-            continue
-        return {
-            "agent_id": agent_id,
-            "state": "waiting_approval",
-            "kind": "mcp_tool",
-            "tool": tool_match.group(1),
-            "prompt": f"team_orchestrator - {tool_match.group(1)}",
-            "choices": extract_approval_choices(lines[index : control_index + 1]),
-        }
-    for index in range(control_index, -1, -1):
-        line = lines[index]
-        if "Would you like to run the following command" not in line:
-            continue
-        return {
-            "agent_id": agent_id,
-            "state": "waiting_approval",
-            "kind": "command",
-            "command": extract_command_approval_subject(lines[: control_index + 1], index),
-            "prompt": line.strip(),
-            "choices": extract_approval_choices(lines[index : control_index + 1]),
-        }
-    return {
-        "agent_id": agent_id,
-        "state": "waiting_approval",
-        "kind": "unknown",
-        "prompt": "approval prompt detected",
-        "choices": extract_approval_choices(lines[: control_index + 1]),
-    }
-
-
-def active_approval_control_index(lines: list[str]) -> int | None:
-    control_indices = [
-        index
-        for index, line in enumerate(lines)
-        if is_approval_control_line(line)
-    ]
-    if not control_indices:
-        return None
-    control_index = control_indices[-1]
-    if any(line.strip() for line in lines[control_index + 1 :]):
-        return None
-    return control_index
-
-
-def is_approval_control_line(line: str) -> bool:
-    normalized = line.lower()
-    return "enter to submit | esc to cancel" in normalized or ("esc to cancel" in normalized and "tab to amend" in normalized)
-
-
-def extract_approval_choices(lines: list[str]) -> list[str]:
-    choices: list[str] = []
-    for line in lines:
-        stripped = line.strip()
-        match = APPROVAL_CHOICE_RE.match(stripped)
-        if not match:
-            continue
-        label = match.group(2).strip()
-        if label and label not in choices:
-            choices.append(label)
-    return choices
-
-
-def line_is_approval_choice(line: str) -> bool:
-    return APPROVAL_CHOICE_RE.match(line.strip()) is not None
-
-
-def extract_command_approval_subject(lines: list[str], prompt_index: int) -> str | None:
-    for line in reversed(lines[:prompt_index]):
-        stripped = line.strip()
-        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
-            return stripped[:200]
-    for line in lines[prompt_index + 1 : prompt_index + 8]:
-        stripped = line.strip()
-        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
-            return stripped[:200]
-    return None
-
-
-def active_approval_choice_index(text: str) -> int | None:
-    for line in text.splitlines():
-        stripped = line.strip()
-        if not (stripped.startswith("›") or stripped.startswith("❯") or stripped.startswith(">")):
-            continue
-        match = re.match(r"[›❯>]\s*(\d+)\.", stripped)
-        if match:
-            return int(match.group(1)) - 1
-    return None
-
-
-def capture_has_team_orchestrator_mcp_prompt(text: str) -> bool:
-    return (
-        "Allow the team_orchestrator MCP server to run tool" in text
-        or re.search(r"\bteam_orchestrator\s*[-.]\s*[A-Za-z_][A-Za-z0-9_]*\b", text) is not None
-    )
-
-
-def approval_prompt_fingerprint(prompt: dict[str, Any]) -> str:
-    data = {
-        "kind": prompt.get("kind"),
-        "tool": prompt.get("tool"),
-        "prompt": prompt.get("prompt"),
-        "choices": prompt.get("choices") or [],
-    }
-    return hashlib.sha256(json.dumps(data, sort_keys=True, ensure_ascii=False).encode("utf-8")).hexdigest()[:16]
-
-
-def choose_internal_mcp_approval_choice(prompt: dict[str, Any]) -> str:
-    choices = prompt.get("choices") or []
-    if INTERNAL_MCP_APPROVAL_CHOICE in choices:
-        return INTERNAL_MCP_APPROVAL_CHOICE
-    for choice in choices:
-        if str(choice).startswith("Yes, and don't ask again"):
-            return str(choice)
-    if "Allow" in choices:
-        return "Allow"
-    if "Yes" in choices:
-        return "Yes"
-    return INTERNAL_MCP_APPROVAL_CHOICE
-
-
-def approval_choice_keys(prompt: dict[str, Any], capture_text: str, choice: str) -> list[str]:
-    choices = prompt.get("choices") or []
-    try:
-        target_index = choices.index(choice)
-    except ValueError:
-        return ["Down", "Enter"]
-    active_index = active_approval_choice_index(capture_text)
-    if active_index is None:
-        return [str(target_index + 1), "Enter"]
-    delta = target_index - active_index
-    if delta > 0:
-        return ["Down"] * delta + ["Enter"]
-    if delta < 0:
-        return ["Up"] * abs(delta) + ["Enter"]
-    return ["Enter"]