claude-team-mcp 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

claude_team_mcp/tools/__init__.py

@@ -16,6 +16,7 @@ from . import examine_worker
 from . import list_workers
 from . import list_worktrees
 from . import message_workers
+from . import poll_worker_changes
 from . import read_worker_logs
 from . import spawn_workers
 from . import wait_idle_workers
@@ -27,7 +28,7 @@ def register_all_tools(mcp: FastMCP, ensure_connection) -> None:
 
     Args:
         mcp: The FastMCP server instance
-        ensure_connection: Function to ensure iTerm2 connection is alive
+        ensure_connection: Function to ensure terminal backend is alive
     """
     # Tools that don't need ensure_connection
     annotate_worker.register_tools(mcp)
@@ -38,10 +39,11 @@ def register_all_tools(mcp: FastMCP, ensure_connection) -> None:
     list_workers.register_tools(mcp)
     list_worktrees.register_tools(mcp)
     message_workers.register_tools(mcp)
+    poll_worker_changes.register_tools(mcp)
     read_worker_logs.register_tools(mcp)
     wait_idle_workers.register_tools(mcp)
 
-    # Tools that need ensure_connection for iTerm2 operations
+    # Tools that need ensure_connection for terminal backend operations
     adopt_worker.register_tools(mcp, ensure_connection)
     discover_workers.register_tools(mcp, ensure_connection)
     spawn_workers.register_tools(mcp, ensure_connection)

claude_team_mcp/tools/adopt_worker.py

@@ -1,7 +1,7 @@
 """
 Adopt worker tool.
 
-Provides adopt_worker for importing existing iTerm2 Claude Code sessions.
+Provides adopt_worker for importing existing terminal Claude Code and Codex sessions.
 """
 
 import logging
@@ -15,7 +15,12 @@ if TYPE_CHECKING:
     from ..server import AppContext
 
 from ..registry import SessionStatus
-from ..session_state import find_jsonl_by_iterm_id
+from ..session_state import (
+    find_codex_session_by_iterm_id,
+    find_codex_session_by_tmux_id,
+    find_jsonl_by_iterm_id,
+    find_jsonl_by_tmux_id,
+)
 from ..utils import error_response, HINTS
 
 logger = logging.getLogger("claude-team-mcp")
@@ -27,19 +32,21 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
     @mcp.tool()
     async def adopt_worker(
         ctx: Context[ServerSession, "AppContext"],
-        iterm_session_id: str,
+        iterm_session_id: str | None = None,
+        tmux_pane_id: str | None = None,
         session_name: str | None = None,
         max_age: int = 3600,
     ) -> dict:
         """
-        Adopt an existing iTerm2 Claude Code session into the MCP registry.
+        Adopt an existing terminal Claude Code or Codex session into the MCP registry.
 
-        Takes an iTerm2 session ID (from discover_workers) and registers it
+        Takes a terminal session ID (from discover_workers) and registers it
         for management. Only works for sessions originally spawned by claude-team
         (which have markers in their JSONL for reliable correlation).
 
         Args:
             iterm_session_id: The iTerm2 session ID (from discover_workers)
+            tmux_pane_id: The tmux pane ID (from discover_workers)
             session_name: Optional friendly name for the worker
             max_age: Only check JSONL files modified within this many seconds (default 3600)
 
@@ -49,51 +56,99 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 
-        # Ensure we have a fresh connection (websocket can go stale)
-        _, app = await ensure_connection(app_ctx)
+        # Ensure we have a fresh backend connection/state
+        backend = await ensure_connection(app_ctx)
+        backend_id = backend.backend_id
+
+        target_id = iterm_session_id if backend_id == "iterm" else tmux_pane_id
+        if backend_id == "tmux" and not target_id:
+            target_id = iterm_session_id
+        if backend_id == "iterm" and not target_id:
+            target_id = tmux_pane_id
+
+        if not target_id:
+            return error_response(
+                "terminal session id is required",
+                hint="Pass iterm_session_id or tmux_pane_id from discover_workers",
+            )
 
         # Check if already managed
         for managed in registry.list_all():
-            if managed.iterm_session.session_id == iterm_session_id:
+            if (
+                managed.terminal_session.backend_id == backend_id
+                and managed.terminal_session.native_id == target_id
+            ):
                 return error_response(
                     f"Session already managed as '{managed.session_id}'",
                     hint="Use message_workers to communicate with the existing session",
                     existing_session=managed.to_dict(),
                 )
 
-        # Find the iTerm2 session by ID
+        # Find the terminal session by ID
         target_session = None
-        for window in app.terminal_windows:
-            for tab in window.tabs:
-                for iterm_session in tab.sessions:
-                    if iterm_session.session_id == iterm_session_id:
-                        target_session = iterm_session
-                        break
-                if target_session:
-                    break
-            if target_session:
+        try:
+            terminal_sessions = await backend.list_sessions()
+        except Exception as e:
+            logger.warning(f"Error listing sessions for backend {backend_id}: {e}")
+            terminal_sessions = []
+
+        for session in terminal_sessions:
+            if session.native_id == target_id:
+                target_session = session
                 break
 
         if not target_session:
             return error_response(
-                f"iTerm2 session not found: {iterm_session_id}",
-                hint="Run discover_workers to scan for active Claude sessions in iTerm2",
+                f"Terminal session not found: {target_id}",
+                hint="Run discover_workers to scan for active Claude or Codex sessions",
             )
 
-        # Use marker-based discovery to recover original session identity
-        # This only works for sessions we originally spawned (which have our markers)
-        match = find_jsonl_by_iterm_id(iterm_session_id, max_age_seconds=max_age)
-        if not match:
+        # Use marker-based discovery to recover original session identity.
+        # This only works for sessions we originally spawned (which have our markers).
+        agent_type = "claude"
+        match = None
+        if backend_id == "iterm":
+            match = find_jsonl_by_iterm_id(target_id, max_age_seconds=max_age)
+            if not match:
+                codex_match = find_codex_session_by_iterm_id(
+                    target_id,
+                    max_age_seconds=max_age,
+                )
+                if not codex_match:
+                    return error_response(
+                        "Session not found or not spawned by claude-team",
+                        hint="adopt_worker only works for sessions originally spawned by claude-team. "
+                        "External sessions cannot be reliably correlated to their JSONL files.",
+                        iterm_session_id=target_id,
+                    )
+                match = codex_match
+                agent_type = "codex"
+        elif backend_id == "tmux":
+            match = find_jsonl_by_tmux_id(target_id, max_age_seconds=max_age)
+            if not match:
+                codex_match = find_codex_session_by_tmux_id(
+                    target_id,
+                    max_age_seconds=max_age,
+                )
+                if not codex_match:
+                    return error_response(
+                        "Session not found or not spawned by claude-team",
+                        hint="adopt_worker only works for sessions originally spawned by claude-team. "
+                        "External sessions cannot be reliably correlated to their JSONL files.",
+                        tmux_pane_id=target_id,
+                    )
+                match = codex_match
+                agent_type = "codex"
+        else:
             return error_response(
-                "Session not found or not spawned by claude-team",
-                hint="adopt_worker only works for sessions originally spawned by claude-team. "
-                "External sessions cannot be reliably correlated to their JSONL files.",
-                iterm_session_id=iterm_session_id,
+                "adopt_worker is only supported with iTerm2 or tmux backend",
+                hint=HINTS["terminal_backend_required"],
             )
 
         logger.info(
-            f"Recovered session via iTerm marker: "
-            f"project={match.project_path}, internal_id={match.internal_session_id}"
+            "Recovered session via terminal marker: "
+            f"project={match.project_path}, internal_id={match.internal_session_id}, "
+            f"agent_type={agent_type}"
         )
 
         # Validate project path still exists
@@ -105,12 +160,14 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
 
         # Register with recovered identity (no new marker needed)
         managed = registry.add(
-            iterm_session=target_session,
+            terminal_session=target_session,
             project_path=match.project_path,
             name=session_name,
             session_id=match.internal_session_id,  # Recover original ID
         )
-        managed.claude_session_id = match.jsonl_path.stem
+        managed.agent_type = agent_type
+        if agent_type == "claude":
+            managed.claude_session_id = match.jsonl_path.stem
 
         # Mark ready immediately (no discovery needed, we already have it)
         registry.update_status(managed.session_id, SessionStatus.READY)

claude_team_mcp/tools/close_workers.py

@@ -14,7 +14,7 @@ from mcp.server.session import ServerSession
 if TYPE_CHECKING:
     from ..server import AppContext
 
-from ..iterm_utils import send_prompt, send_key, close_pane
+from ..iterm_utils import CODEX_PRE_ENTER_DELAY
 from ..registry import SessionRegistry, SessionStatus
 from ..worktree import WorktreeError, remove_worktree
 from ..utils import error_response, HINTS
@@ -22,7 +22,28 @@ from ..utils import error_response, HINTS
 logger = logging.getLogger("claude-team-mcp")
 
 
+def _compute_prompt_delay(text: str, agent_type: str) -> float:
+    """Compute a safe delay before sending Enter for a prompt."""
+    line_count = text.count("\n")
+    char_count = len(text)
+    if line_count > 0:
+        paste_delay = min(2.0, 0.1 + (line_count * 0.01) + (char_count / 1000 * 0.05))
+    else:
+        paste_delay = 0.05
+    if agent_type == "codex":
+        return max(CODEX_PRE_ENTER_DELAY, paste_delay)
+    return paste_delay
+
+
+async def _send_prompt(backend, session, text: str, agent_type: str) -> None:
+    """Send a prompt and press Enter using the active terminal backend."""
+    await backend.send_text(session, text)
+    await asyncio.sleep(_compute_prompt_delay(text, agent_type))
+    await backend.send_key(session, "enter")
+
+
 async def _close_single_worker(
+    backend,
     session,
     session_id: str,
     registry: "SessionRegistry",
@@ -38,6 +59,7 @@ async def _close_single_worker(
         session: The ManagedSession object
         session_id: ID of the session to close
         registry: The session registry
+        backend: Terminal backend used for terminal operations
         force: If True, force close even if session is busy
 
     Returns:
@@ -54,14 +76,20 @@ async def _close_single_worker(
 
     try:
         # Send Ctrl+C to interrupt any running operation
-        await send_key(session.iterm_session, "ctrl-c")
+        await backend.send_key(session.terminal_session, "ctrl-c")
         # TODO(rabsef-bicrym): Programmatically time these actions
         await asyncio.sleep(1.0)
 
-        # Send /exit to quit Claude
-        await send_prompt(session.iterm_session, "/exit", submit=True)
-        # TODO(rabsef-bicrym): Programmatically time these actions
-        await asyncio.sleep(1.0)
+        if session.agent_type == "codex":
+            # Codex exits via Ctrl+C (may require a second press).
+            await backend.send_key(session.terminal_session, "ctrl-c")
+            # TODO(rabsef-bicrym): Programmatically time these actions
+            await asyncio.sleep(1.0)
+        else:
+            # Claude exits via /exit.
+            await _send_prompt(backend, session.terminal_session, "/exit", session.agent_type)
+            # TODO(rabsef-bicrym): Programmatically time these actions
+            await asyncio.sleep(1.0)
 
         # Clean up worktree if exists (keeps branch alive for cherry-picking)
         worktree_cleaned = False
@@ -76,8 +104,8 @@ async def _close_single_worker(
                 # Log but don't fail the close
                 logger.warning(f"Failed to clean up worktree for {session_id}: {e}")
 
-        # Close the iTerm2 pane/window
-        await close_pane(session.iterm_session, force=force)
+        # Close the terminal pane/window
+        await backend.close_session(session.terminal_session, force=force)
 
         # Remove from registry
         registry.remove(session_id)
@@ -111,7 +139,7 @@ def register_tools(mcp: FastMCP) -> None:
         Close one or more managed Claude Code sessions.
 
         Gracefully terminates the Claude sessions in parallel and closes
-        their iTerm2 panes. All session_ids must exist in the registry.
+        their terminal panes/windows. All session_ids must exist in the registry.
 
         ⚠️ **NOTE: WORKTREE CLEANUP**
         Workers with worktrees commit to ephemeral branches. When closed:
@@ -137,6 +165,7 @@ def register_tools(mcp: FastMCP) -> None:
         """
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
+        backend = app_ctx.terminal_backend
 
         if not session_ids:
             return error_response(
@@ -166,7 +195,7 @@ def register_tools(mcp: FastMCP) -> None:
 
         # Close all sessions in parallel
         async def close_one(sid: str, session) -> tuple[str, dict]:
-            result = await _close_single_worker(session, sid, registry, force)
+            result = await _close_single_worker(backend, session, sid, registry, force)
             return (sid, result)
 
         tasks = [close_one(sid, session) for sid, session in sessions_to_close]

claude_team_mcp/tools/discover_workers.py

@@ -1,7 +1,7 @@
 """
 Discover workers tool.
 
-Provides discover_workers for finding existing Claude Code sessions in iTerm2.
+Provides discover_workers for finding existing Claude Code and Codex sessions.
 """
 
 import logging
@@ -14,10 +14,15 @@ if TYPE_CHECKING:
     from ..server import AppContext
 
 from ..session_state import (
+    find_codex_session_by_iterm_id,
+    find_codex_session_by_tmux_id,
     find_jsonl_by_iterm_id,
+    find_jsonl_by_tmux_id,
     get_project_dir,
+    parse_codex_session,
     parse_session,
 )
+from ..utils import error_response, HINTS
 
 logger = logging.getLogger("claude-team-mcp")
 
@@ -31,12 +36,14 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         max_age: int = 3600,
     ) -> dict:
         """
-        Discover existing Claude Code sessions running in iTerm2.
+        Discover existing Claude Code and Codex sessions running in the active terminal backend.
 
-        For each iTerm2 pane, searches JSONL files in ~/.claude/projects/ for a
-        matching iTerm session ID marker. Sessions spawned by claude-team write
-        their iTerm session ID into the JSONL (e.g., <!claude-team-iterm:UUID!>),
-        enabling reliable detection and recovery after MCP server restarts.
+        For each terminal session, searches JSONL files in ~/.claude/projects/ and
+        ~/.codex/sessions/ for matching terminal session markers. Sessions spawned
+        by claude-team write their terminal IDs into the JSONL
+        (e.g., <!claude-team-iterm:UUID!> or <!claude-team-tmux:%1!>), enabling
+        reliable detection and recovery after MCP server restarts.
+        For tmux, only panes in claude-team-managed sessions are scanned.
 
         Only JSONL files modified within max_age seconds are checked. If a session
         was started more than max_age seconds ago and hasn't had recent activity,
@@ -49,44 +56,57 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         Returns:
             Dict with:
                 - sessions: List of discovered sessions, each containing:
-                    - iterm_session_id: iTerm2's internal session ID
+                    - backend_id: Terminal backend identifier
+                    - iterm_session_id: iTerm2's internal session ID (iTerm backend)
+                    - tmux_pane_id: tmux pane id (tmux backend)
                     - project_path: Detected project path
-                    - claude_session_id: The JSONL session UUID
+                    - claude_session_id: The JSONL session UUID (Claude only)
+                    - codex_session_id: The JSONL session UUID (Codex only)
                     - internal_session_id: Our short session ID (e.g., "b48e2d5b")
                     - last_assistant_preview: Preview of last assistant message
                     - already_managed: True if already in our registry
-                - count: Total number of Claude sessions found
+                    - agent_type: "claude" or "codex"
+                - count: Total number of sessions found
                 - unmanaged_count: Number not yet in registry (available to adopt)
         """
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 
-        # Ensure we have a fresh connection (websocket can go stale)
-        _, app = await ensure_connection(app_ctx)
+        # Ensure we have a fresh backend connection/state
+        backend = await ensure_connection(app_ctx)
+        backend_id = backend.backend_id
+
+        if backend_id not in ("iterm", "tmux"):
+            return error_response(
+                "discover_workers is only supported with iTerm2 or tmux backend",
+                hint=HINTS["terminal_backend_required"],
+            )
 
         discovered = []
 
-        # Get all managed iTerm session IDs so we can flag already-managed ones
-        managed_iterm_ids = {
-            s.iterm_session.session_id for s in registry.list_all()
+        managed_ids = {
+            s.terminal_session.native_id
+            for s in registry.list_all()
+            if s.terminal_session.backend_id == backend_id
         }
 
-        # Scan all iTerm2 panes and check if their session ID appears in any JSONL
-        for window in app.terminal_windows:
-            for tab in window.tabs:
-                for iterm_session in tab.sessions:
-                    try:
-                        # Look for this iTerm session ID in recent JSONL files
-                        # Claude-team spawned sessions write their iTerm ID as a marker
-                        match = find_jsonl_by_iterm_id(
-                            iterm_session.session_id,
-                            max_age_seconds=max_age
-                        )
+        try:
+            terminal_sessions = await backend.list_sessions()
+        except Exception as e:
+            logger.warning(f"Error listing sessions for backend {backend_id}: {e}")
+            terminal_sessions = []
 
-                        if not match:
-                            # Not a Claude session we know about
-                            continue
+        for terminal_session in terminal_sessions:
+            native_id = terminal_session.native_id
+            try:
+                if backend_id == "iterm":
+                    # Look for this iTerm session ID in recent JSONL files
+                    match = find_jsonl_by_iterm_id(
+                        native_id,
+                        max_age_seconds=max_age,
+                    )
 
+                    if match:
                         project_path = match.project_path
                         claude_session_id = match.jsonl_path.stem
                         internal_session_id = match.internal_session_id
@@ -94,7 +114,10 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                         # Get last assistant message preview from JSONL
                         last_assistant_preview = None
                         try:
-                            jsonl_path = get_project_dir(project_path) / f"{claude_session_id}.jsonl"
+                            jsonl_path = (
+                                get_project_dir(project_path)
+                                / f"{claude_session_id}.jsonl"
+                            )
                             if jsonl_path.exists():
                                 state = parse_session(jsonl_path)
                                 if state.last_assistant_message:
@@ -108,18 +131,139 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                             logger.debug(f"Could not get conversation preview: {e}")
 
                         discovered.append({
-                            "iterm_session_id": iterm_session.session_id,
+                            "backend_id": backend_id,
+                            "iterm_session_id": native_id,
                             "project_path": project_path,
                             "claude_session_id": claude_session_id,
                             "internal_session_id": internal_session_id,
                             "last_assistant_preview": last_assistant_preview,
-                            "already_managed": iterm_session.session_id in managed_iterm_ids,
+                            "already_managed": native_id in managed_ids,
+                            "agent_type": "claude",
                         })
+                        continue
+
+                    # Fall back to Codex marker scan if no Claude match
+                    codex_match = find_codex_session_by_iterm_id(
+                        native_id,
+                        max_age_seconds=max_age,
+                    )
+
+                    if not codex_match:
+                        continue
 
+                    project_path = codex_match.project_path
+                    internal_session_id = codex_match.internal_session_id
+
+                    # Get last assistant message preview from Codex JSONL
+                    last_assistant_preview = None
+                    try:
+                        jsonl_path = codex_match.jsonl_path
+                        if jsonl_path.exists():
+                            state = parse_codex_session(jsonl_path)
+                            if state.last_assistant_message:
+                                content = state.last_assistant_message.content
+                                last_assistant_preview = (
+                                    content[:200] + "..."
+                                    if len(content) > 200
+                                    else content
+                                )
                     except Exception as e:
-                        logger.warning(f"Error scanning session {iterm_session.session_id}: {e}")
+                        logger.debug(f"Could not get conversation preview: {e}")
+
+                    discovered.append({
+                        "backend_id": backend_id,
+                        "iterm_session_id": native_id,
+                        "project_path": project_path,
+                        "codex_session_id": codex_match.jsonl_path.stem,
+                        "internal_session_id": internal_session_id,
+                        "last_assistant_preview": last_assistant_preview,
+                        "already_managed": native_id in managed_ids,
+                        "agent_type": "codex",
+                    })
+                    continue
+
+                # Tmux backend
+                match = find_jsonl_by_tmux_id(
+                    native_id,
+                    max_age_seconds=max_age,
+                )
+
+                if not match:
+                    # Fall back to Codex marker scan if no Claude match
+                    codex_match = find_codex_session_by_tmux_id(
+                        native_id,
+                        max_age_seconds=max_age,
+                    )
+
+                    if not codex_match:
                         continue
 
+                    project_path = codex_match.project_path
+                    internal_session_id = codex_match.internal_session_id
+
+                    # Get last assistant message preview from Codex JSONL
+                    last_assistant_preview = None
+                    try:
+                        jsonl_path = codex_match.jsonl_path
+                        if jsonl_path.exists():
+                            state = parse_codex_session(jsonl_path)
+                            if state.last_assistant_message:
+                                content = state.last_assistant_message.content
+                                last_assistant_preview = (
+                                    content[:200] + "..."
+                                    if len(content) > 200
+                                    else content
+                                )
+                    except Exception as e:
+                        logger.debug(f"Could not get conversation preview: {e}")
+
+                    discovered.append({
+                        "backend_id": backend_id,
+                        "tmux_pane_id": native_id,
+                        "project_path": project_path,
+                        "codex_session_id": codex_match.jsonl_path.stem,
+                        "internal_session_id": internal_session_id,
+                        "last_assistant_preview": last_assistant_preview,
+                        "already_managed": native_id in managed_ids,
+                        "agent_type": "codex",
+                    })
+                    continue
+
+                project_path = match.project_path
+                claude_session_id = match.jsonl_path.stem
+                internal_session_id = match.internal_session_id
+
+                # Get last assistant message preview from JSONL
+                last_assistant_preview = None
+                try:
+                    jsonl_path = get_project_dir(project_path) / f"{claude_session_id}.jsonl"
+                    if jsonl_path.exists():
+                        state = parse_session(jsonl_path)
+                        if state.last_assistant_message:
+                            content = state.last_assistant_message.content
+                            last_assistant_preview = (
+                                content[:200] + "..."
+                                if len(content) > 200
+                                else content
+                            )
+                except Exception as e:
+                    logger.debug(f"Could not get conversation preview: {e}")
+
+                discovered.append({
+                    "backend_id": backend_id,
+                    "tmux_pane_id": native_id,
+                    "project_path": project_path,
+                    "claude_session_id": claude_session_id,
+                    "internal_session_id": internal_session_id,
+                    "last_assistant_preview": last_assistant_preview,
+                    "already_managed": native_id in managed_ids,
+                    "agent_type": "claude",
+                })
+
+            except Exception as e:
+                logger.warning(f"Error scanning session {native_id}: {e}")
+                continue
+
         unmanaged = [s for s in discovered if not s["already_managed"]]
 
         return {

claude_team_mcp/tools/list_workers.py

@@ -4,6 +4,7 @@ List workers tool.
 Provides list_workers for viewing all managed Claude Code sessions.
 """
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from mcp.server.fastmcp import Context, FastMCP
@@ -23,6 +24,7 @@ def register_tools(mcp: FastMCP) -> None:
     async def list_workers(
         ctx: Context[ServerSession, "AppContext"],
         status_filter: str | None = None,
+        project_filter: str | None = None,
     ) -> dict:
         """
         List all managed Claude Code sessions.
@@ -32,6 +34,7 @@ def register_tools(mcp: FastMCP) -> None:
 
         Args:
             status_filter: Optional filter by status - "ready", "busy", "spawning", "closed"
+            project_filter: Optional filter by project path (full path, basename, or partial match)
 
         Returns:
             Dict with:
@@ -55,6 +58,32 @@ def register_tools(mcp: FastMCP) -> None:
         else:
             sessions = registry.list_all()
 
+        # Filter by project path or main repo path
+        if project_filter:
+            normalized_filter = project_filter.strip()
+            if normalized_filter:
+                filtered_sessions = []
+                for session in sessions:
+                    candidates = [session.project_path]
+                    if session.main_repo_path is not None:
+                        candidates.append(str(session.main_repo_path))
+                    matches = False
+                    for candidate in candidates:
+                        if not candidate:
+                            continue
+                        if candidate == normalized_filter:
+                            matches = True
+                            break
+                        if Path(candidate).name == normalized_filter:
+                            matches = True
+                            break
+                        if normalized_filter in candidate:
+                            matches = True
+                            break
+                    if matches:
+                        filtered_sessions.append(session)
+                sessions = filtered_sessions
+
         # Sort by created_at
         sessions = sorted(sessions, key=lambda s: s.created_at)