claude-team-mcp 0.9.0__tar.gz → 0.9.2__tar.gz

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/.pebbles/events.jsonl

@@ -228,3 +228,11 @@
 {"type":"create","timestamp":"2026-02-02T23:29:52.330658Z","issue_id":"cic-ebd","payload":{"description":"tmux_session_name_for_project() hashes the full project_path. Worktree paths produce unique hashes, creating one tmux session per worker instead of one per project. Fix: resolve worktree paths to main repo before hashing.","priority":"1","title":"tmux: worktree paths create separate sessions instead of sharing per-project session","type":"bug"}}
 {"type":"status_update","timestamp":"2026-02-02T23:30:32.877924Z","issue_id":"cic-ebd","payload":{"status":"in_progress"}}
 {"type":"close","timestamp":"2026-02-02T23:33:33.785116Z","issue_id":"cic-ebd","payload":{}}
+{"type":"create","timestamp":"2026-02-04T22:18:18.544978Z","issue_id":"cic-c29","payload":{"description":"","priority":"2","title":"message_workers: wait_mode validation rejects None from MCP clients","type":"task"}}
+{"type":"comment","timestamp":"2026-02-04T22:18:27.550553Z","issue_id":"cic-c29","payload":{"body":"When message_workers is called via MCP clients (e.g. mcporter) that send explicit null for omitted optional params, pydantic rejects it:\n\nError: Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]\n\nThe type annotation is wait_mode: str = 'none' but needs to accept None.\n\nFix: Change to wait_mode: str | None = 'none' and add wait_mode = wait_mode or 'none' guard at the top of the function. Same for timeout: float = 600.0.\n\nFile: src/claude_team_mcp/tools/message_workers.py\nFunction: message_workers (line ~127)"}}
+{"type":"update","timestamp":"2026-02-04T22:18:30.31878Z","issue_id":"cic-c29","payload":{"type":"bug"}}
+{"type":"close","timestamp":"2026-02-05T00:07:32.417031Z","issue_id":"cic-c29","payload":{}}
+{"type":"create","timestamp":"2026-02-05T23:19:38.480182Z","issue_id":"cic-e24","payload":{"description":"When read_worker_logs is called for Codex workers whose marker-based JSONL discovery fails, the fallback in get_jsonl_path() grabs the most recently modified Codex JSONL globally — often the COORDINATOR's own session. All workers return identical log content (the coordinator's conversation). Root cause: max_age_seconds=600 in find_codex_session_by_internal_id is too short, and the blind find_codex_session_file fallback returns wrong data. Fix: cache JSONL path on spawn, increase/remove max_age, remove blind fallback.","priority":"1","title":"read_worker_logs returns wrong session data for Codex workers","type":"bug"}}
+{"type":"update","timestamp":"2026-02-05T23:23:47.02398Z","issue_id":"cic-e24","payload":{"description":"## Bug\n\nWhen read_worker_logs is called for Codex workers whose marker-based JSONL discovery fails, the fallback in get_jsonl_path() grabs the most recently modified Codex JSONL globally — often the COORDINATOR's own session. All workers return identical, wrong log content.\n\n## Observed Behavior\n\n- Three Codex workers (Rick, Morty, Pelé) on martian-todos project\n- All three show claude_session_id: null (marker discovery failed)  \n- read_worker_logs returns identical content for all three — the coordinator's own conversation\n- examine_worker shows coordinator's last_user_prompt for all workers\n- Workers had actually completed their tasks (visible in tmux panes)\n\n## Root Cause\n\nIn registry.py ManagedSession.get_jsonl_path() for Codex:\n\n1. find_codex_session_by_internal_id uses max_age_seconds=600 (10 min) — too short for workers running longer\n2. Blind fallback find_codex_session_file grabs most recent Codex JSONL globally — returns wrong session\n3. Unlike Claude workers, Codex workers SKIP marker discovery at spawn time (spawn_workers.py line ~696 has an `if agent_type == claude` guard), so claude_session_id is never set\n\n## Fix Plan\n\n### 1. Remove blind fallback (critical, immediate)\nIn get_jsonl_path(), remove `find_codex_session_file()` fallback. Return None if marker-based discovery fails. Bad data is worse than no data.\n\n### 2. Cache JSONL path at spawn time (parity with Claude workers)\n- Add `codex_jsonl_path: Optional[Path] = None` field on ManagedSession\n- After sending marker to Codex workers in spawn_workers.py, poll for marker (adapt await_marker_in_jsonl or use find_codex_session_by_internal_id with generous timeout)\n- Store: `managed.codex_jsonl_path = match.jsonl_path`\n- In get_jsonl_path(), check self.codex_jsonl_path first; skip re-discovery if set\n\n### 3. Increase max_age_seconds for re-discovery\n- Change max_age_seconds from 600 to 86400 (24h) in find_codex_session_by_internal_id calls\n- Workers can run for hours; 10 min window is far too short\n\n### 4. Persist path in event log for recovery\n- Include codex_jsonl_path in worker_started events so RecoveredSession objects also have it\n- RecoveredSession.get_jsonl_path() should use persisted path\n\n### 5. Tests\n- Test that get_jsonl_path returns None (not wrong file) when discovery fails\n- Test that spawn caches the path for Codex workers\n- Test that recovered workers use persisted path"}}
+{"type":"status_update","timestamp":"2026-02-05T23:24:08.656684Z","issue_id":"cic-e24","payload":{"status":"in_progress"}}
+{"type":"close","timestamp":"2026-02-05T23:28:34.736194Z","issue_id":"cic-e24","payload":{}}

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.2] - 2026-02-05
+
+### Fixed
+- **Codex worker log discovery**: `read_worker_logs` no longer returns wrong session data (e.g. coordinator's own logs) for Codex workers. Removed blind `find_codex_session_file()` fallback that grabbed the most recent Codex JSONL globally regardless of session ownership.
+- **Codex JSONL path caching**: Codex workers now cache their JSONL path at spawn time (parity with Claude workers), via new `await_codex_marker_in_jsonl()` polling.
+- **Discovery window**: Increased `max_age_seconds` from 600 (10 min) to 86400 (24h) for Codex session file scanning — workers can run for hours.
+- **RecoveredSession crashes**: Fixed `discover_workers`, `adopt_worker`, and `spawn_workers` crashing with `'RecoveredSession' object has no attribute 'terminal_session'` when recovered sessions exist in the registry.
+
+## [0.9.1] - 2026-02-04
+
+### Fixed
+- **MCP tool optional param validation**: All 9 MCP tools now accept `null` for optional parameters with defaults. MCP clients (e.g. mcporter) that send explicit `null` for omitted params no longer trigger pydantic validation errors.
+
 ## [0.9.0] - 2026-02-03
 
 ### Added

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-team-mcp
-Version: 0.9.0
+Version: 0.9.2
 Summary: MCP server for managing multiple Claude Code sessions via iTerm2
 Project-URL: Homepage, https://github.com/Martian-Engineering/claude-team
 Project-URL: Repository, https://github.com/Martian-Engineering/claude-team

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-team-mcp"
-version = "0.9.0"
+version = "0.9.2"
 description = "MCP server for managing multiple Claude Code sessions via iTerm2"
 readme = "README.md"
 requires-python = ">=3.11"

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/registry.py

@@ -139,6 +139,7 @@ class RecoveredSession:
     coordinator_annotation: Optional[str] = None
     worktree_path: Optional[str] = None
     main_repo_path: Optional[str] = None
+    codex_jsonl_path: Optional[str] = None
 
     @staticmethod
     def map_event_state_to_status(event_state: EventState) -> SessionStatus:
@@ -178,6 +179,7 @@ class RecoveredSession:
             "worktree_path": self.worktree_path,
             "main_repo_path": self.main_repo_path,
             "agent_type": self.agent_type,
+            "codex_jsonl_path": self.codex_jsonl_path,
             # Recovery-specific fields
             "source": "event_log",
             "event_state": self.event_state,
@@ -227,6 +229,9 @@ class ManagedSession:
     # Agent type: "claude" (default) or "codex"
     agent_type: AgentType = "claude"
 
+    # Cached Codex JSONL path (discovered at spawn time via marker polling)
+    codex_jsonl_path: Optional[Path] = None
+
     def __post_init__(self):
         """Auto-populate terminal_id from terminal_session if not set."""
         if self.terminal_id is None:
@@ -255,6 +260,7 @@ class ManagedSession:
             "worktree_path": str(self.worktree_path) if self.worktree_path else None,
             "main_repo_path": str(self.main_repo_path) if self.main_repo_path else None,
             "agent_type": self.agent_type,
+            "codex_jsonl_path": str(self.codex_jsonl_path) if self.codex_jsonl_path else None,
             # Source field for distinguishing live vs recovered sessions
             "source": "registry",
         }
@@ -292,22 +298,29 @@ class ManagedSession:
         Get the path to this session's JSONL file.
 
         For Claude workers: uses marker-based discovery in ~/.claude/projects/.
-        For Codex workers: uses marker-based discovery in ~/.codex/sessions/.
+        For Codex workers: uses cached path or marker-based discovery in
+        ~/.codex/sessions/. Returns None (not a wrong file) when discovery fails.
 
         Returns:
             Path object, or None if session cannot be discovered
         """
         if self.agent_type == "codex":
-            from .idle_detection import find_codex_session_file
+            # Use cached path if available (set at spawn time)
+            if self.codex_jsonl_path and self.codex_jsonl_path.exists():
+                return self.codex_jsonl_path
 
-            # Prefer marker-based match, fall back to most recent for legacy sessions.
+            # Try marker-based discovery with generous timeout (workers can run for hours)
             match = find_codex_session_by_internal_id(
                 self.session_id,
-                max_age_seconds=600,
+                max_age_seconds=86400,
             )
             if match:
+                # Cache for future calls
+                self.codex_jsonl_path = match.jsonl_path
                 return match.jsonl_path
-            return find_codex_session_file(max_age_seconds=600)
+
+            # No blind fallback - returning None is better than returning wrong data
+            return None
         else:
             # For Claude, use marker-based discovery
             # Auto-discover if not already known
@@ -353,16 +366,10 @@ class ManagedSession:
             True if idle, False if working or session file not available
         """
         if self.agent_type == "codex":
-            from .idle_detection import find_codex_session_file, is_codex_idle
+            from .idle_detection import is_codex_idle
 
-            # Prefer marker-based match, fall back to most recent for legacy sessions.
-            match = find_codex_session_by_internal_id(
-                self.session_id,
-                max_age_seconds=600,
-            )
-            session_file = match.jsonl_path if match else None
-            if not session_file:
-                session_file = find_codex_session_file(max_age_seconds=600)
+            # Use the same path resolution as get_jsonl_path() (cached or marker-based)
+            session_file = self.get_jsonl_path()
             if not session_file:
                 return False
             return is_codex_idle(session_file)
@@ -795,6 +802,7 @@ class SessionRegistry:
             coordinator_annotation=data.get("coordinator_annotation"),
             worktree_path=data.get("worktree_path"),
             main_repo_path=data.get("main_repo_path"),
+            codex_jsonl_path=data.get("codex_jsonl_path"),
         )
 
     def count(self) -> int:

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/session_state.py

@@ -838,6 +838,42 @@ async def await_marker_in_jsonl(
     return None
 
 
+async def await_codex_marker_in_jsonl(
+    session_id: str,
+    timeout: float = 30.0,
+    poll_interval: float = 0.5,
+) -> Optional[CodexSessionMatch]:
+    """
+    Poll for a Codex session marker to appear in the JSONL.
+
+    Codex workers write markers into ~/.codex/sessions/ files. This function
+    polls until the marker for the given session_id is found.
+
+    Args:
+        session_id: The internal session ID to search for in markers
+        timeout: Maximum seconds to wait (default 30)
+        poll_interval: Seconds between polls (default 0.5, slower than Claude
+            because Codex takes longer to start)
+
+    Returns:
+        CodexSessionMatch if found, None on timeout
+    """
+    import asyncio
+
+    start = time.time()
+
+    while time.time() - start < timeout:
+        match = find_codex_session_by_internal_id(
+            session_id,
+            max_age_seconds=300,
+        )
+        if match:
+            return match
+        await asyncio.sleep(poll_interval)
+
+    return None
+
+
 # =============================================================================
 # Session Discovery
 # =============================================================================

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/adopt_worker.py

@@ -35,7 +35,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         iterm_session_id: str | None = None,
         tmux_pane_id: str | None = None,
         session_name: str | None = None,
-        max_age: int = 3600,
+        max_age: int | None = 3600,
     ) -> dict:
         """
         Adopt an existing terminal Claude Code or Codex session into the MCP registry.
@@ -53,6 +53,9 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         Returns:
             Dict with adopted worker info, or error if session not found
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        max_age = max_age if max_age is not None else 3600
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 
@@ -75,7 +78,8 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         # Check if already managed
         for managed in registry.list_all():
             if (
-                managed.terminal_session.backend_id == backend_id
+                hasattr(managed, 'terminal_session')
+                and managed.terminal_session.backend_id == backend_id
                 and managed.terminal_session.native_id == target_id
             ):
                 return error_response(

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/close_workers.py

@@ -133,7 +133,7 @@ def register_tools(mcp: FastMCP) -> None:
     async def close_workers(
         ctx: Context[ServerSession, "AppContext"],
         session_ids: list[str],
-        force: bool = False,
+        force: bool | None = False,
     ) -> dict:
         """
         Close one or more managed Claude Code sessions.
@@ -163,6 +163,9 @@ def register_tools(mcp: FastMCP) -> None:
                 - success_count: Number of sessions closed successfully
                 - failure_count: Number of sessions that failed to close
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        force = force if force is not None else False
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
         backend = app_ctx.terminal_backend

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/discover_workers.py

@@ -33,7 +33,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
     @mcp.tool()
     async def discover_workers(
         ctx: Context[ServerSession, "AppContext"],
-        max_age: int = 3600,
+        max_age: int | None = 3600,
     ) -> dict:
         """
         Discover existing Claude Code and Codex sessions running in the active terminal backend.
@@ -69,6 +69,9 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 - count: Total number of sessions found
                 - unmanaged_count: Number not yet in registry (available to adopt)
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        max_age = max_age if max_age is not None else 3600
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 
@@ -87,7 +90,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         managed_ids = {
             s.terminal_session.native_id
             for s in registry.list_all()
-            if s.terminal_session.backend_id == backend_id
+            if hasattr(s, 'terminal_session') and s.terminal_session.backend_id == backend_id
         }
 
         try:

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/list_worktrees.py

@@ -31,7 +31,7 @@ def register_tools(mcp: FastMCP) -> None:
     async def list_worktrees(
         ctx: Context[ServerSession, "AppContext"],
         repo_path: str,
-        remove_orphans: bool = False,
+        remove_orphans: bool | None = False,
     ) -> dict:
         """
         List worktrees in a repository's .worktrees/ directory.
@@ -58,6 +58,9 @@ def register_tools(mcp: FastMCP) -> None:
                 - orphan_count: Number of orphaned worktrees
                 - removed_count: Number of orphans removed (when remove_orphans=True)
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        remove_orphans = remove_orphans if remove_orphans is not None else False
+
         resolved_path = Path(repo_path).resolve()
         if not resolved_path.exists():
             return error_response(

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/message_workers.py

@@ -131,8 +131,8 @@ def register_tools(mcp: FastMCP) -> None:
         ctx: Context[ServerSession, "AppContext"],
         session_ids: list[str],
         message: str,
-        wait_mode: str = "none",
-        timeout: float = 600.0,
+        wait_mode: str | None = "none",
+        timeout: float | None = 600.0,
     ) -> dict:
         """
         Send a message to one or more Claude Code worker sessions.
@@ -163,6 +163,10 @@ def register_tools(mcp: FastMCP) -> None:
                 - all_idle: Whether all sessions are idle (only if wait_mode != "none")
                 - timed_out: Whether the wait timed out (only if wait_mode != "none")
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        wait_mode = wait_mode or "none"
+        timeout = timeout if timeout is not None else 600.0
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
         backend = app_ctx.terminal_backend

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/poll_worker_changes.py

@@ -122,7 +122,7 @@ def register_tools(mcp: FastMCP) -> None:
         ctx: Context[ServerSession, "AppContext"],
         since: str | None = None,
         stale_threshold_minutes: int | None = None,
-        include_snapshots: bool = False,
+        include_snapshots: bool | None = False,
     ) -> dict:
         """
         Poll worker event changes since a timestamp.
@@ -144,6 +144,9 @@ def register_tools(mcp: FastMCP) -> None:
                 - idle_count: Count of idle workers
                 - poll_ts: Timestamp when poll was generated
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        include_snapshots = include_snapshots if include_snapshots is not None else False
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/read_worker_logs.py

@@ -22,8 +22,8 @@ def register_tools(mcp: FastMCP) -> None:
     async def read_worker_logs(
         ctx: Context[ServerSession, "AppContext"],
         session_id: str,
-        pages: int = 1,
-        offset: int = 0,
+        pages: int | None = 1,
+        offset: int | None = 0,
     ) -> dict:
         """
         Get conversation history from a Claude Code session with reverse pagination.
@@ -51,6 +51,10 @@ def register_tools(mcp: FastMCP) -> None:
                 - page_info: Pagination metadata (total_messages, total_pages, etc.)
                 - session_id: The session ID
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        pages = pages if pages is not None else 1
+        offset = offset if offset is not None else 0
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/spawn_workers.py

@@ -187,7 +187,11 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
             # Then immediately:
             message_workers(session_ids=["Groucho"], message="Your task is...")
         """
-        from ..session_state import await_marker_in_jsonl, generate_marker_message
+        from ..session_state import (
+            await_codex_marker_in_jsonl,
+            await_marker_in_jsonl,
+            generate_marker_message,
+        )
 
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
@@ -452,7 +456,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                     managed_session_ids = {
                         s.terminal_session.native_id
                         for s in registry.list_all()
-                        if s.terminal_session.backend_id == backend.backend_id
+                        if hasattr(s, 'terminal_session') and s.terminal_session.backend_id == backend.backend_id
                     }
 
                     # Find a window with enough space for ALL workers
@@ -693,7 +697,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                     submit=True,
                 )
 
-            # Wait for markers to appear in JSONL (Claude only)
+            # Wait for markers to appear in JSONL (Claude and Codex)
             for i, managed in enumerate(managed_sessions):
                 if managed.agent_type == "claude":
                     claude_session_id = await await_marker_in_jsonl(
@@ -709,6 +713,24 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                             f"Marker polling timed out for {managed.session_id}, "
                             "JSONL correlation unavailable"
                         )
+                elif managed.agent_type == "codex":
+                    # Poll for Codex marker and cache the JSONL path
+                    codex_match = await await_codex_marker_in_jsonl(
+                        managed.session_id,
+                        timeout=30.0,
+                        poll_interval=0.5,
+                    )
+                    if codex_match:
+                        managed.codex_jsonl_path = codex_match.jsonl_path
+                        logger.info(
+                            f"Codex JSONL path cached for {managed.session_id}: "
+                            f"{codex_match.jsonl_path}"
+                        )
+                    else:
+                        logger.warning(
+                            f"Codex marker polling timed out for {managed.session_id}, "
+                            "JSONL correlation unavailable"
+                        )
 
             # Send worker prompts - always use generate_worker_prompt with bead/custom_prompt
             workers_awaiting_task: list[str] = []  # Workers with no bead and no prompt

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/wait_idle_workers.py

@@ -28,9 +28,9 @@ def register_tools(mcp: FastMCP) -> None:
     async def wait_idle_workers(
         ctx: Context[ServerSession, "AppContext"],
         session_ids: list[str],
-        mode: str = "all",
-        timeout: float = 600.0,
-        poll_interval: float = 2.0,
+        mode: str | None = "all",
+        timeout: float | None = 600.0,
+        poll_interval: float | None = 2.0,
     ) -> dict:
         """
         Wait for worker sessions to become idle.
@@ -56,6 +56,11 @@ def register_tools(mcp: FastMCP) -> None:
                 - waited_seconds: How long we waited
                 - timed_out: Whether we hit the timeout
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        mode = mode or "all"
+        timeout = timeout if timeout is not None else 600.0
+        poll_interval = poll_interval if poll_interval is not None else 2.0
+
         app_ctx = ctx.request_context.lifespan_context
         registry = app_ctx.registry
 

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/src/claude_team_mcp/tools/worker_events.py

@@ -193,10 +193,10 @@ def register_tools(mcp: FastMCP) -> None:
     async def worker_events(
         ctx: Context[ServerSession, "AppContext"],
         since: str | None = None,
-        limit: int = 1000,
-        include_snapshot: bool = False,
-        include_summary: bool = False,
-        stale_threshold_minutes: int = 10,
+        limit: int | None = 1000,
+        include_snapshot: bool | None = False,
+        include_summary: bool | None = False,
+        stale_threshold_minutes: int | None = 10,
         project_filter: str | None = None,
     ) -> dict:
         """
@@ -230,6 +230,12 @@ def register_tools(mcp: FastMCP) -> None:
                     - last_event_ts: newest event timestamp
                 - snapshot: (if include_snapshot) Latest snapshot {ts, data}
         """
+        # Handle None values from MCP clients that send explicit null for omitted params
+        limit = limit if limit is not None else 1000
+        include_snapshot = include_snapshot if include_snapshot is not None else False
+        include_summary = include_summary if include_summary is not None else False
+        stale_threshold_minutes = stale_threshold_minutes if stale_threshold_minutes is not None else 10
+
         # Parse the since timestamp if provided.
         parsed_since = None
         if since is not None and since.strip():

claude_team_mcp-0.9.2/tests/test_codex_jsonl_path.py

@@ -0,0 +1,285 @@
+"""Tests for Codex worker JSONL path resolution (cic-e24).
+
+Validates that:
+1. get_jsonl_path() returns None (not wrong file) when Codex marker discovery fails
+2. get_jsonl_path() uses cached codex_jsonl_path when available
+3. is_idle() uses get_jsonl_path() without blind fallback
+4. codex_jsonl_path is persisted in to_dict() for event log recovery
+5. RecoveredSession includes codex_jsonl_path from event data
+"""
+
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from claude_team_mcp.registry import (
+    ManagedSession,
+    RecoveredSession,
+    SessionStatus,
+    TerminalId,
+)
+
+
+class TestCodexGetJsonlPathNoBlindFallback:
+    """get_jsonl_path() must not return wrong session data for Codex workers."""
+
+    def _make_codex_session(self, session_id="test-abc1", codex_jsonl_path=None):
+        """Create a ManagedSession configured as a Codex worker."""
+        mock_terminal = MagicMock()
+        session = ManagedSession(
+            session_id=session_id,
+            terminal_session=mock_terminal,
+            project_path="/test/project",
+            agent_type="codex",
+        )
+        if codex_jsonl_path:
+            session.codex_jsonl_path = codex_jsonl_path
+        return session
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_returns_none_when_discovery_fails(self, mock_find):
+        """get_jsonl_path returns None when marker discovery fails, not a random file."""
+        mock_find.return_value = None
+        session = self._make_codex_session()
+
+        result = session.get_jsonl_path()
+
+        assert result is None
+        # Verify it used generous max_age
+        mock_find.assert_called_once_with("test-abc1", max_age_seconds=86400)
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_uses_cached_path_when_available(self, mock_find):
+        """get_jsonl_path returns cached codex_jsonl_path without re-discovery."""
+        cached_path = Path("/tmp/test-codex-session.jsonl")
+        cached_path.touch()
+
+        try:
+            session = self._make_codex_session(codex_jsonl_path=cached_path)
+
+            result = session.get_jsonl_path()
+
+            assert result == cached_path
+            # Should NOT call find_codex_session_by_internal_id when cache is valid
+            mock_find.assert_not_called()
+        finally:
+            cached_path.unlink(missing_ok=True)
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_falls_through_when_cached_path_missing(self, mock_find):
+        """get_jsonl_path tries re-discovery when cached file no longer exists."""
+        mock_find.return_value = None
+        nonexistent_path = Path("/tmp/nonexistent-codex-session.jsonl")
+        session = self._make_codex_session(codex_jsonl_path=nonexistent_path)
+
+        result = session.get_jsonl_path()
+
+        assert result is None
+        # Should try marker-based discovery when cached path doesn't exist
+        mock_find.assert_called_once()
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_caches_path_on_successful_discovery(self, mock_find):
+        """get_jsonl_path caches the path when marker discovery succeeds."""
+        mock_match = MagicMock()
+        mock_match.jsonl_path = Path("/tmp/discovered-codex.jsonl")
+        mock_find.return_value = mock_match
+
+        session = self._make_codex_session()
+
+        result = session.get_jsonl_path()
+
+        assert result == Path("/tmp/discovered-codex.jsonl")
+        assert session.codex_jsonl_path == Path("/tmp/discovered-codex.jsonl")
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_uses_86400_max_age_for_rediscovery(self, mock_find):
+        """get_jsonl_path uses 24h max_age (not 600s) for marker discovery."""
+        mock_find.return_value = None
+        session = self._make_codex_session()
+
+        session.get_jsonl_path()
+
+        mock_find.assert_called_once_with("test-abc1", max_age_seconds=86400)
+
+
+class TestCodexIsIdleNoBlindFallback:
+    """is_idle() for Codex workers must not use blind fallback."""
+
+    def _make_codex_session(self, session_id="test-abc1"):
+        """Create a ManagedSession configured as a Codex worker."""
+        mock_terminal = MagicMock()
+        return ManagedSession(
+            session_id=session_id,
+            terminal_session=mock_terminal,
+            project_path="/test/project",
+            agent_type="codex",
+        )
+
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_returns_false_when_no_session_file(self, mock_find):
+        """is_idle returns False (not True from wrong file) when discovery fails."""
+        mock_find.return_value = None
+        session = self._make_codex_session()
+
+        result = session.is_idle()
+
+        assert result is False
+
+    @patch("claude_team_mcp.idle_detection.is_codex_idle")
+    @patch("claude_team_mcp.registry.find_codex_session_by_internal_id")
+    def test_uses_correct_session_file(self, mock_find, mock_is_idle):
+        """is_idle uses the cached/discovered path, not a random recent file."""
+        mock_find.return_value = None
+        session = self._make_codex_session()
+
+        # Create a temp file for the cached path
+        cached_path = Path("/tmp/test-correct-session.jsonl")
+        cached_path.touch()
+
+        try:
+            session.codex_jsonl_path = cached_path
+            mock_is_idle.return_value = True
+
+            result = session.is_idle()
+
+            assert result is True
+            mock_is_idle.assert_called_once_with(cached_path)
+            # Should NOT have called find_codex_session_by_internal_id
+            mock_find.assert_not_called()
+        finally:
+            cached_path.unlink(missing_ok=True)
+
+
+class TestCodexJsonlPathInToDict:
+    """codex_jsonl_path must be serialized for event log persistence."""
+
+    def test_to_dict_includes_codex_jsonl_path_when_set(self):
+        """ManagedSession.to_dict() includes codex_jsonl_path as string."""
+        mock_terminal = MagicMock()
+        session = ManagedSession(
+            session_id="test-123",
+            terminal_session=mock_terminal,
+            project_path="/test/path",
+            agent_type="codex",
+        )
+        session.codex_jsonl_path = Path("/tmp/codex-session.jsonl")
+
+        d = session.to_dict()
+
+        assert d["codex_jsonl_path"] == "/tmp/codex-session.jsonl"
+
+    def test_to_dict_includes_none_codex_jsonl_path(self):
+        """ManagedSession.to_dict() includes None when codex_jsonl_path not set."""
+        mock_terminal = MagicMock()
+        session = ManagedSession(
+            session_id="test-123",
+            terminal_session=mock_terminal,
+            project_path="/test/path",
+            agent_type="claude",
+        )
+
+        d = session.to_dict()
+
+        assert d["codex_jsonl_path"] is None
+
+
+class TestRecoveredSessionCodexJsonlPath:
+    """RecoveredSession must persist codex_jsonl_path from event data."""
+
+    def test_recovered_session_includes_codex_jsonl_path(self):
+        """RecoveredSession stores codex_jsonl_path from snapshot data."""
+        now = datetime.now()
+        session = RecoveredSession(
+            session_id="abc12345",
+            name="Rick",
+            project_path="/test/project",
+            terminal_id=TerminalId("tmux", "%1"),
+            agent_type="codex",
+            status=SessionStatus.READY,
+            last_activity=now,
+            created_at=now,
+            event_state="idle",
+            recovered_at=now,
+            last_event_ts=now,
+            codex_jsonl_path="/codex/sessions/2026/02/05/rollout-abc.jsonl",
+        )
+
+        assert session.codex_jsonl_path == "/codex/sessions/2026/02/05/rollout-abc.jsonl"
+
+    def test_recovered_session_to_dict_includes_codex_jsonl_path(self):
+        """RecoveredSession.to_dict() includes codex_jsonl_path."""
+        now = datetime.now()
+        session = RecoveredSession(
+            session_id="abc12345",
+            name="Rick",
+            project_path="/test/project",
+            terminal_id=None,
+            agent_type="codex",
+            status=SessionStatus.READY,
+            last_activity=now,
+            created_at=now,
+            event_state="idle",
+            recovered_at=now,
+            last_event_ts=now,
+            codex_jsonl_path="/codex/sessions/rollout.jsonl",
+        )
+
+        d = session.to_dict()
+
+        assert d["codex_jsonl_path"] == "/codex/sessions/rollout.jsonl"
+
+    def test_recovered_session_default_codex_jsonl_path_is_none(self):
+        """RecoveredSession.codex_jsonl_path defaults to None."""
+        now = datetime.now()
+        session = RecoveredSession(
+            session_id="abc12345",
+            name="Morty",
+            project_path="/test/project",
+            terminal_id=None,
+            agent_type="claude",
+            status=SessionStatus.READY,
+            last_activity=now,
+            created_at=now,
+            event_state="idle",
+            recovered_at=now,
+            last_event_ts=now,
+        )
+
+        assert session.codex_jsonl_path is None
+        assert session.to_dict()["codex_jsonl_path"] is None
+
+
+class TestRecoverFromEventsCodexJsonlPath:
+    """recover_from_events must propagate codex_jsonl_path to RecoveredSession."""
+
+    def test_codex_jsonl_path_recovered_from_snapshot(self):
+        """codex_jsonl_path in worker snapshot data populates RecoveredSession."""
+        from claude_team_mcp.registry import SessionRegistry
+
+        registry = SessionRegistry()
+
+        snapshot = {
+            "ts": "2026-02-05T12:00:00Z",
+            "workers": [
+                {
+                    "session_id": "codex-worker-1",
+                    "name": "Rick",
+                    "project_path": "/test/project",
+                    "agent_type": "codex",
+                    "state": "idle",
+                    "codex_jsonl_path": "/codex/sessions/2026/02/05/rollout-xyz.jsonl",
+                    "created_at": "2026-02-05T11:00:00Z",
+                    "last_activity": "2026-02-05T11:30:00Z",
+                },
+            ],
+        }
+
+        report = registry.recover_from_events(snapshot, [])
+
+        assert report.added == 1
+        recovered = registry._recovered_sessions["codex-worker-1"]
+        assert recovered.codex_jsonl_path == "/codex/sessions/2026/02/05/rollout-xyz.jsonl"
+        assert recovered.agent_type == "codex"

{claude_team_mcp-0.9.0 → claude_team_mcp-0.9.2}/uv.lock

@@ -114,7 +114,7 @@ wheels = [
 
 [[package]]
 name = "claude-team-mcp"
-version = "0.8.2"
+version = "0.9.1"
 source = { editable = "." }
 dependencies = [
     { name = "iterm2" },