soothe-cli 0.6.14__tar.gz → 0.6.16__tar.gz

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.14
+Version: 0.6.16
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -397,96 +397,3 @@ def dream() -> None:
     client = _require_daemon_ws()
     client.autopilot_dream()
     typer.echo("Dream signal sent.")
-
-
-def _discover_goals(autopilot_dir: Path) -> list[dict]:
-    """Parse goals from GOAL.md/GOALS.md files for offline CLI display."""
-    import re
-
-    goals: list[dict] = []
-
-    goal_file = autopilot_dir / "GOAL.md"
-    if goal_file.exists():
-        g = _parse_single_goal(goal_file.read_text(), str(goal_file))
-        if g:
-            return [g]
-
-    goals_file = autopilot_dir / "GOALS.md"
-    if goals_file.exists():
-        text = goals_file.read_text()
-        for section in re.split(r"## Goal:", text)[1:]:
-            g = _parse_goals_section(section.strip(), str(goals_file))
-            if g:
-                goals.append(g)
-
-    goals_dir = autopilot_dir / "goals"
-    if goals_dir.exists():
-        for subdir in sorted(goals_dir.iterdir()):
-            gfile = subdir / "GOAL.md"
-            if gfile.exists():
-                g = _parse_single_goal(gfile.read_text(), str(gfile))
-                if g:
-                    goals.append(g)
-
-    return goals
-
-
-def _parse_single_goal(text: str, source: str) -> dict | None:
-    """Parse a single GOAL.md file."""
-    if not text.startswith("---"):
-        return None
-
-    parts = text.split("---", 2)
-    if len(parts) < 3:  # noqa: PLR2004
-        return None
-
-    import yaml
-
-    fm = yaml.safe_load(parts[1]) or {}
-    body = parts[2].strip()
-
-    desc = ""
-    for line in body.splitlines():
-        s = line.strip()
-        if s.startswith("# "):
-            desc = s[2:]
-            break
-
-    return {
-        "id": fm.get("id", source.split("/")[-2]),
-        "description": desc or preview_first(body, 100),
-        "priority": int(fm.get("priority", 50)),
-        "status": fm.get("status", "pending"),
-        "depends_on": fm.get("depends_on", []),
-        "source_file": source,
-    }
-
-
-def _parse_goals_section(text: str, source: str) -> dict | None:
-    """Parse a single goal section from GOALS.md."""
-    lines = text.splitlines()
-    name = lines[0].strip() if lines else ""
-    metadata: dict = {}
-
-    for line in lines[1:]:
-        s = line.strip()
-        if s.startswith("- id:"):
-            metadata["id"] = s.split(":", 1)[1].strip()
-        elif s.startswith("- priority:"):
-            metadata["priority"] = int(s.split(":", 1)[1].strip())
-        elif s.startswith("- depends_on:"):
-            raw = s.split(":", 1)[1].strip()
-            if raw.startswith("[") and raw.endswith("]"):
-                inner = raw[1:-1].strip()
-                metadata["depends_on"] = (
-                    [x.strip() for x in inner.split(",") if x.strip()] if inner else []
-                )
-
-    return {
-        "id": metadata.get("id", name.lower().replace(" ", "-")),
-        "description": name,
-        "priority": metadata.get("priority", 50),
-        "status": "pending",
-        "depends_on": metadata.get("depends_on", []),
-        "source_file": source,
-    }

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/config/cli_config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
 
 from soothe_sdk.client.config import SOOTHE_HOME
 
@@ -44,41 +43,6 @@ class CLIConfig:
     # Paths
     soothe_home: Path = field(default_factory=lambda: Path(SOOTHE_HOME))
 
-    # Daemon config cache (fetched via RPC)
-    _daemon_config_cache: dict[str, Any] = field(default_factory=dict)
-
     def websocket_url(self) -> str:
         """Construct WebSocket URL for daemon connection."""
         return f"ws://{self.daemon_host}:{self.daemon_port}"
-
-    async def fetch_daemon_config(self, section: str = "all") -> dict[str, Any]:
-        """Fetch daemon config section via WebSocket RPC.
-
-        Args:
-            section: Config section name (e.g., "providers", "defaults", "all").
-
-        Returns:
-            Wire-safe config section dict.
-        """
-        from soothe_sdk.client import WebSocketClient, fetch_config_section
-
-        client = WebSocketClient(url=self.websocket_url())
-        await client.connect()
-
-        try:
-            config_section = await fetch_config_section(client, section, timeout=5.0)
-            self._daemon_config_cache[section] = config_section
-            return config_section
-        finally:
-            await client.close()
-
-    def get_cached_config(self, section: str) -> dict[str, Any]:
-        """Get cached daemon config section.
-
-        Args:
-            section: Config section name.
-
-        Returns:
-            Cached config section dict, or empty dict if not cached.
-        """
-        return self._daemon_config_cache.get(section, {})

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/runtime/parse/tool_call_resolution.py

@@ -64,6 +64,45 @@ def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
     return not is_step_level_task_tool_id(tcid)
 
 
+def predict_main_execute_tool_call_id(
+    step_id: str,
+    *,
+    tool_call_id: str = "",
+    tool_name: str = "",
+    chunk_index: Any = None,
+) -> str:
+    """Best-effort unified id for main-graph execute tools during streaming."""
+    from soothe_sdk.ux.task_namespace import (
+        _format_unified_tool_call_id,
+        _provider_tool_fragment,
+        is_unified_tool_call_id,
+        parse_unified_tool_call_id,
+    )
+
+    tcid = str(tool_call_id or "").strip()
+    if tcid and is_unified_tool_call_id(tcid):
+        parsed_sid, type_code, _, _ = parse_unified_tool_call_id(tcid)
+        if parsed_sid and type_code == "s":
+            return tcid
+    sid = str(step_id or "").strip()
+    if not sid:
+        return tcid
+    raw_tid = tcid
+    if not raw_tid:
+        name = str(tool_name or "").strip()
+        if name and chunk_index is not None:
+            try:
+                idx = int(chunk_index)
+            except (TypeError, ValueError):
+                idx = None
+            if idx is not None:
+                raw_tid = f"{name}:{idx}"
+    if not raw_tid:
+        return ""
+    frag = _provider_tool_fragment(raw_tid)
+    return _format_unified_tool_call_id(sid, "s", frag)
+
+
 def is_task_level_subgraph_tool_call_id(tool_call_id: str) -> bool:
     """True for unified subgraph tools (``{step}:t{n}:{tool}:{seq}``), not nested ``task`` rows."""
     from soothe_sdk.ux.task_namespace import (
@@ -87,19 +126,22 @@ def should_ingest_tool_for_step_stats(
 ) -> bool:
     """Whether the TUI should register a tool row for step-card stats.
 
-    Main step-level tools are tracked as soon as ``tool_call_id`` and ``tool_name``
-    are known; display does not wait for streamed args.
+    Main execute-graph tools are tracked as soon as ``tool_call_id`` and ``tool_name``
+    are known; display does not wait for streamed args. Subgraph explore tools often
+    arrive with placeholder kwargs before real args.
     """
+    from soothe_sdk.ux.task_namespace import is_step_level_task_tool_id
+
     name = str(tool_name or "").strip()
     tcid = str(tool_call_id or "").strip()
     if not name or not tcid or name == "task":
         return False
     if args_meaningful:
         return True
-    if is_step_card_scope and is_main_step_level_tool_call_id(tcid):
-        return True
+    if is_step_card_scope:
+        return not is_step_level_task_tool_id(tcid)
     # Subgraph explore tools often arrive with ``{"_subgraph_tool": true}`` before real args.
-    return not is_step_card_scope and is_task_level_subgraph_tool_call_id(tcid)
+    return is_task_level_subgraph_tool_call_id(tcid)
 
 
 def _args_from_toolish_block(block: dict[str, Any]) -> dict[str, Any]:
@@ -498,6 +540,7 @@ __all__ = [
     "is_main_step_level_tool_call_id",
     "is_step_card_tool_scope",
     "is_task_level_subgraph_tool_call_id",
+    "predict_main_execute_tool_call_id",
     "is_toolish_display_block",
     "materialize_ai_blocks_with_resolved_tools",
     "merge_tool_display_args",

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/app/_app.py

@@ -49,10 +49,6 @@ from soothe_cli.tui.widgets.welcome import WelcomeBanner
 logger = logging.getLogger(__name__)
 _monotonic = time.monotonic
 
-InputMode = (
-    "normal"  # Literal type alias — actual value used in _module_init; here for isinstance guards
-)
-
 
 class SootheApp(
     App,

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/app/_execution.py

@@ -664,8 +664,6 @@ class _ExecutionMixin:
             await self._submit_cron_job(args, slash_input=command)
         elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
-        elif cmd == "/autopilot-toggle":
-            await self._toggle_autopilot_mode()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
         elif cmd == "/theme":

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -743,8 +743,3 @@ class _MessagesMixin:
     # =========================================================================
     # Model Switching
     # =========================================================================
-    # SOOTHE: Slash command actions
-
-    def action_detach(self) -> None:
-        """Exit TUI but leave daemon running."""
-        self._detach_or_exit()

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/app/_model.py

@@ -293,48 +293,6 @@ class _ModelMixin:
 
         self.push_screen(screen, handle_result)
 
-    async def _toggle_autopilot_mode(self) -> None:
-        """Toggle autopilot mode (solo ↔ autopilot) via daemon RPC.
-
-        Sends command_request to daemon and updates local dashboard mode.
-        """
-        from soothe_cli.tui.widgets.messages import ErrorMessage, UserMessage
-
-        await self._mount_message(UserMessage("/autopilot-toggle"))
-
-        lid = self._loop_id
-        if not lid:
-            await self._mount_message(ErrorMessage("No active loop for autopilot toggle"))
-            return
-
-        if not self._client:
-            await self._mount_message(ErrorMessage("Not connected to daemon"))
-            return
-
-        try:
-            from soothe_cli.tui.commands.command_router import handle_rpc_command
-            from soothe_cli.tui.commands.slash_commands import COMMANDS
-
-            entry = COMMANDS.get("/autopilot-toggle")
-            if not entry:
-                await self._mount_message(ErrorMessage("Command /autopilot-toggle not found"))
-                return
-
-            await handle_rpc_command(
-                entry,
-                "autopilot-toggle",
-                None,
-                self._console,
-                self._client,
-                loop_id=lid,
-            )
-            new_mode = "solo" if self._loop_autopilot_mode == "autopilot" else "autopilot"
-            self._apply_loop_autopilot_mode(new_mode)
-
-        except Exception as exc:
-            logger.exception("Autopilot toggle failed")
-            await self._mount_message(ErrorMessage(f"Failed to toggle autopilot: {exc}"))
-
     async def _submit_autopilot_job(self, task: str) -> None:
         """Submit an autopilot job via WebSocket (like CLI `soothe autopilot run`).
 

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/command_registry.py

@@ -222,22 +222,6 @@ IMMEDIATE_UI: frozenset[str] = _build_bypass_set(BypassTier.IMMEDIATE_UI)
 SIDE_EFFECT_FREE: frozenset[str] = _build_bypass_set(BypassTier.SIDE_EFFECT_FREE)
 """Commands whose side effect fires immediately; chat output deferred until idle."""
 
-QUEUE_BOUND: frozenset[str] = _build_bypass_set(BypassTier.QUEUED)
-"""Commands that must wait in the queue when the app is busy."""
-
-HIDDEN_DEBUG: frozenset[str] = frozenset({"/debug-error"})
-"""Hidden debug commands not exposed in autocomplete or help."""
-
-ALL_CLASSIFIED: frozenset[str] = (
-    ALWAYS_IMMEDIATE
-    | BYPASS_WHEN_CONNECTING
-    | IMMEDIATE_UI
-    | SIDE_EFFECT_FREE
-    | QUEUE_BOUND
-    | HIDDEN_DEBUG
-)
-"""Union of all tiers plus hidden debug commands — used by drift tests."""
-
 
 # ---------------------------------------------------------------------------
 # Autocomplete tuples

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/preview_limits.py

@@ -17,7 +17,7 @@ STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
 # Latest per-tool invocation lines shown per scope (task branch vs main-agent branch).
 STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 3
 
-# When estimated body lines exceed this count, the card auto-collapses (strict `>`).
+# Optional manual full tool-list folding threshold (not auto-collapse).
 STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3
 
 # --- Skill invocation cards (`SkillMessage` collapsed SKILL.md body) ---

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/sessions.py

@@ -3,71 +3,13 @@
 from __future__ import annotations
 
 import logging
-from contextlib import asynccontextmanager
 from datetime import datetime
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
-from soothe_sdk.client.config import SOOTHE_HOME
 from typing_extensions import TypedDict
 
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator
-
-    import aiosqlite
-
 logger = logging.getLogger(__name__)
 
-_aiosqlite_patched = False
-
-
-def _patch_aiosqlite() -> None:
-    """Patch aiosqlite.Connection with `is_alive()` if missing.
-
-    Required by langgraph-checkpoint>=2.1.0.
-    See: https://github.com/langchain-ai/langgraph/issues/6583
-    """
-    global _aiosqlite_patched  # noqa: PLW0603  # Module-level flag requires global statement
-    if _aiosqlite_patched:
-        return
-
-    import aiosqlite as _aiosqlite
-
-    if not hasattr(_aiosqlite.Connection, "is_alive"):
-
-        def _is_alive(self: _aiosqlite.Connection) -> bool:
-            """Check if the connection is still alive.
-
-            Returns:
-                True if connection is alive, False otherwise.
-            """
-            return bool(self._running and self._connection is not None)
-
-        # Dynamically adding a method to aiosqlite.Connection at runtime.
-        # Type checkers can't understand this monkey-patch, so we suppress the
-        # "attr-defined" error that would otherwise be raised.
-        _aiosqlite.Connection.is_alive = _is_alive  # type: ignore[attr-defined]
-
-    _aiosqlite_patched = True
-
-
-@asynccontextmanager
-async def _connect() -> AsyncIterator[aiosqlite.Connection]:
-    """Import aiosqlite, apply the compatibility patch, and connect.
-
-    Centralizes the deferred import + patch + connect sequence used by every
-    database function in this module.
-
-    Yields:
-        An open aiosqlite connection to the sessions database.
-    """
-    import aiosqlite as _aiosqlite
-
-    _patch_aiosqlite()
-
-    async with _aiosqlite.connect(str(get_db_path()), timeout=30.0) as conn:
-        yield conn
-
 
 class LoopInfo(TypedDict, total=False):
     """Loop metadata returned by `list_loops_via_daemon_rpc`."""
@@ -182,27 +124,6 @@ def format_relative_timestamp(iso_timestamp: str | None) -> str:
     return f"{years}y ago"
 
 
-_db_path: Path | None = None
-
-
-def get_db_path() -> Path:
-    """Get path to global database.
-
-    The result is cached after the first successful call to avoid repeated
-    filesystem operations.
-
-    Returns:
-        Path to the SQLite database file.
-    """
-    global _db_path  # noqa: PLW0603  # Module-level cache requires global statement
-    if _db_path is not None:
-        return _db_path
-    db_dir = Path(SOOTHE_HOME)
-    db_dir.mkdir(parents=True, exist_ok=True)
-    _db_path = db_dir / "sessions.db"
-    return _db_path
-
-
 def generate_loop_id() -> str:
     """Generate a new loop ID as a full UUID7 string.
 
@@ -214,17 +135,6 @@ def generate_loop_id() -> str:
     return str(uuid7())
 
 
-async def _table_exists(conn: aiosqlite.Connection, table: str) -> bool:
-    """Check if a table exists in the database.
-
-    Returns:
-        True if table exists, False otherwise.
-    """
-    query = "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?"
-    async with conn.execute(query, (table,)) as cursor:
-        return await cursor.fetchone() is not None
-
-
 async def list_loops_via_daemon_rpc(
     daemon_session: Any,
     limit: int = 20,
@@ -309,97 +219,6 @@ async def list_loops_via_daemon_rpc(
     return loops
 
 
-async def get_most_recent(agent_name: str | None = None) -> str | None:
-    """Return the most recent loop id from local SQLite, optionally filtered by agent.
-
-    Returns:
-        Loop id (``checkpoints.thread_id``), or `None` when the database is empty.
-    """
-    async with _connect() as conn:
-        if not await _table_exists(conn, "checkpoints"):
-            return None
-
-        if agent_name:
-            query = """
-                SELECT thread_id FROM checkpoints
-                WHERE json_extract(metadata, '$.agent_name') = ?
-                ORDER BY checkpoint_id DESC
-                LIMIT 1
-            """
-            params: tuple = (agent_name,)
-        else:
-            query = "SELECT thread_id FROM checkpoints ORDER BY checkpoint_id DESC LIMIT 1"
-            params = ()
-
-        async with conn.execute(query, params) as cursor:
-            row = await cursor.fetchone()
-            return row[0] if row else None
-
-
-async def get_loop_agent(loop_id: str) -> str | None:
-    """Return ``agent_name`` metadata for a loop id.
-
-    Returns:
-        Agent name from checkpoint row metadata, or `None` if not found.
-    """
-    async with _connect() as conn:
-        if not await _table_exists(conn, "checkpoints"):
-            return None
-
-        query = """
-            SELECT json_extract(metadata, '$.agent_name')
-            FROM checkpoints
-            WHERE thread_id = ?
-            LIMIT 1
-        """
-        async with conn.execute(query, (loop_id,)) as cursor:
-            row = await cursor.fetchone()
-            return row[0] if row else None
-
-
-async def loop_exists(loop_id: str) -> bool:
-    """Return True if any checkpoint row exists for this loop id.
-
-    Returns:
-        True if a checkpoint row exists, False otherwise.
-    """
-    async with _connect() as conn:
-        if not await _table_exists(conn, "checkpoints"):
-            return False
-
-        query = "SELECT 1 FROM checkpoints WHERE thread_id = ? LIMIT 1"
-        async with conn.execute(query, (loop_id,)) as cursor:
-            row = await cursor.fetchone()
-            return row is not None
-
-
-async def find_similar_loops(loop_id: str, limit: int = 3) -> list[str]:
-    """Find loop ids that share the given prefix.
-
-    Args:
-        loop_id: Prefix to match against `checkpoints.thread_id`.
-        limit: Maximum number of matches.
-
-    Returns:
-        Matching loop ids (SQLite ``thread_id`` column values).
-    """
-    async with _connect() as conn:
-        if not await _table_exists(conn, "checkpoints"):
-            return []
-
-        query = """
-            SELECT DISTINCT thread_id
-            FROM checkpoints
-            WHERE thread_id LIKE ?
-            ORDER BY thread_id
-            LIMIT ?
-        """
-        prefix = loop_id + "%"
-        async with conn.execute(query, (prefix, limit)) as cursor:
-            rows = await cursor.fetchall()
-            return [r[0] for r in rows]
-
-
 def get_loop_limit() -> int:
     """Default maximum loops to load for `/resume` when no explicit limit is set.
 

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/textual_adapter.py

@@ -66,6 +66,7 @@ from soothe_cli.runtime.parse.tool_call_resolution import (
     is_step_card_tool_scope,
     materialize_ai_blocks_with_resolved_tools,
     merge_tool_display_args,
+    predict_main_execute_tool_call_id,
     resolve_stream_tool_name,
     should_ingest_tool_for_step_stats,
     tool_args_meaningful,
@@ -983,6 +984,16 @@ async def apply_tool_call_wire_update(
             else:
                 step_w.add_tool_call(tcid, name, update_payload, raw_args=raw_args_stream)
             adapter._tool_to_step[tcid] = step_w
+        elif name != "task":
+            update_payload = dict(display_args or {})
+            if not update_payload and raw_args_stream:
+                update_payload = {"_raw": raw_args_stream}
+            router.buffer_main_tool(
+                tcid,
+                name,
+                update_payload,
+                raw_args=raw_args_stream,
+            )
         return True
 
     _merge_buf, display_key = canonical_subgraph_tool_ids(ns_key, tcid, task_scope=ts)
@@ -2286,6 +2297,23 @@ async def execute_task_textual(
                                     continue
 
                                 lookup_id = str(buffer_id) if buffer_id is not None else ""
+                                if not lookup_id and is_step_scope and buffer_name:
+                                    bound_step_id = ""
+                                    if len(router.active_step_ids) == 1:
+                                        bound_step_id = next(iter(router.active_step_ids))
+                                    elif adapter._step_by_namespace.get(ns_key) is not None:
+                                        bound_step_id = getattr(
+                                            adapter._step_by_namespace[ns_key],
+                                            "_step_id",
+                                            "",
+                                        )
+                                    if bound_step_id:
+                                        lookup_id = predict_main_execute_tool_call_id(
+                                            bound_step_id,
+                                            tool_call_id=lookup_id,
+                                            tool_name=str(buffer_name),
+                                            chunk_index=chunk_index,
+                                        )
                                 raw_args_stream = ""
                                 pend_stream = (
                                     pending_tool_calls_lc.get(lookup_id) if lookup_id else None
@@ -2821,7 +2849,12 @@ async def execute_task_textual(
                                     data.get("assessment_reasoning", "")
                                 ).strip()
                                 plan_reasoning = str(data.get("plan_reasoning", "")).strip()
-                                if not assessment_reasoning and not plan_reasoning:
+                                next_action = str(data.get("next_action", "")).strip()
+                                if (
+                                    not assessment_reasoning
+                                    and not plan_reasoning
+                                    and not next_action
+                                ):
                                     continue
                                 pending_text = pending_text_by_namespace.get(ns_key, "")
                                 if pending_text:
@@ -2837,7 +2870,7 @@ async def execute_task_textual(
                                 pa_raw = data.get("plan_action", "")
                                 plan_action = pa_raw if pa_raw in ("keep", "new") else ""
                                 plan_widget = CognitionReasonMessage(
-                                    next_action="",
+                                    next_action=next_action,
                                     status=str(data.get("status", "")),
                                     iteration=int(data.get("iteration", 0)),
                                     plan_action=str(plan_action),

{soothe_cli-0.6.14 → soothe_cli-0.6.16}/src/soothe_cli/tui/theme.py

@@ -99,9 +99,6 @@ LC_TOOL_HOVER = "#FFCB91"
 LC_COGNITION = "#56B6C2"
 """Agent loop step / cognition progress accent (distinct from tool amber)."""
 
-LC_COGNITION_HOVER = "#7BC9D3"
-"""Cognition progress hover — lighter teal for interactive feedback."""
-
 
 # ---------------------------------------------------------------------------
 # Unified Card Palette — Grayscale system for Goal/Plan/Step/Task cards (IG-468)
@@ -194,9 +191,6 @@ CARD_ERROR_LIGHT = "#BE185D"
 LC_COGNITION = CARD_BORDER_DARK
 """Legacy alias — now uses unified card border color."""
 
-LC_COGNITION_HOVER = CARD_BORDER_HOVER_DARK
-"""Legacy alias — now uses unified card hover color."""
-
 
 # ---------------------------------------------------------------------------
 # Brand palette — light
@@ -255,12 +249,6 @@ LC_LIGHT_TOOL = LC_LIGHT_AMBER
 LC_LIGHT_TOOL_HOVER = "#78350F"
 """Tool call hover (darkened for light bg contrast)."""
 
-LC_LIGHT_COGNITION = CARD_BORDER_LIGHT
-"""Legacy alias — now uses unified card border color."""
-
-LC_LIGHT_COGNITION_HOVER = CARD_BORDER_HOVER_LIGHT
-"""Legacy alias — now uses unified card hover color."""
-
 
 # ---------------------------------------------------------------------------
 # Semantic constants  (ANSI color names for Rich console output)