claude-team-mcp 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

claude_team_mcp/tools/spawn_workers.py

@@ -8,7 +8,7 @@ import logging
 import os
 import uuid
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal, Optional, Required, TypedDict
+from typing import TYPE_CHECKING, Literal, Required, TypedDict
 
 from mcp.server.fastmcp import Context, FastMCP
 from mcp.server.session import ServerSession
@@ -16,25 +16,23 @@ from mcp.server.session import ServerSession
 if TYPE_CHECKING:
     from ..server import AppContext
 
+from ..cli_backends import get_cli_backend
 from ..colors import generate_tab_color
 from ..formatting import format_badge_text, format_session_title
 from ..iterm_utils import (
-    LAYOUT_PANE_NAMES,
     MAX_PANES_PER_TAB,
     create_multi_pane_layout,
     find_available_window,
     send_prompt,
+    send_prompt_for_agent,
     split_pane,
+    start_agent_in_session,
     start_claude_in_session,
 )
 from ..names import pick_names_for_count
-from ..profile import (
-    PROFILE_NAME,
-    apply_appearance_colors,
-    get_or_create_profile,
-)
+from ..profile import apply_appearance_colors
 from ..registry import SessionStatus
-from ..utils import BEADS_HELP_TEXT, HINTS, error_response, get_worktree_beads_dir
+from ..utils import HINTS, error_response, get_worktree_beads_dir
 from ..worker_prompt import generate_worker_prompt, get_coordinator_guidance
 from ..worktree import WorktreeError, create_local_worktree
 
@@ -45,6 +43,7 @@ class WorkerConfig(TypedDict, total=False):
     """Configuration for a single worker."""
 
     project_path: Required[str]  # Required: Path to repo, or "auto" to use env var
+    agent_type: str  # Optional: "claude" (default) or "codex"
     name: str  # Optional: Worker name override. None = auto-pick from themed sets.
     annotation: str  # Optional: Task description (badge, branch, worker annotation)
     bead: str  # Optional: Beads issue ID (for badge, branch naming)
@@ -100,6 +99,9 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                   }
                 }
                 ```
+            agent_type: Which agent CLI to use (default "claude").
+                - "claude": Claude Code CLI (Stop hook idle detection)
+                - "codex": OpenAI Codex CLI (JSONL streaming idle detection)
             use_worktree: Whether to create an isolated worktree (default True).
                 - True: Creates worktree at <repo>/.worktrees/<bead>-<annotation>
                   or <repo>/.worktrees/<name>-<uuid>-<annotation>
@@ -202,9 +204,6 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
         connection, app = await ensure_connection(app_ctx)
 
         try:
-            # Ensure the claude-team profile exists
-            await get_or_create_profile(connection)
-
             # Get base session index for color generation
             base_index = registry.count()
 
@@ -297,6 +296,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
 
                 bead = w.get("bead")
                 annotation = w.get("annotation")
+                agent_type = w.get("agent_type", "claude")
 
                 # Tab title
                 tab_title = format_session_title(name, issue_id=bead, annotation=annotation)
@@ -307,8 +307,10 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 customization.set_tab_color(color)
                 customization.set_use_tab_color(True)
 
-                # Badge (multi-line with bead/name and annotation)
-                badge_text = format_badge_text(name, bead=bead, annotation=annotation)
+                # Badge (multi-line with bead/name, annotation, and agent type indicator)
+                badge_text = format_badge_text(
+                    name, bead=bead, annotation=annotation, agent_type=agent_type
+                )
                 customization.set_badge_text(badge_text)
 
                 # Apply current appearance mode colors
@@ -368,7 +370,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                                 first_session,
                                 vertical=True,
                                 before=False,
-                                profile=PROFILE_NAME,
+                                profile=None,
                                 profile_customizations=profile_customizations[i],
                             )
                         elif local_pane_count == 2:
@@ -378,7 +380,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                                 first_session,
                                 vertical=False,
                                 before=False,
-                                profile=PROFILE_NAME,
+                                profile=None,
                                 profile_customizations=profile_customizations[i],
                             )
                         else:  # local_pane_count == 3
@@ -389,7 +391,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                                 tr_session,
                                 vertical=False,
                                 before=False,
-                                profile=PROFILE_NAME,
+                                profile=None,
                                 profile_customizations=profile_customizations[i],
                             )
 
@@ -422,7 +424,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                     panes = await create_multi_pane_layout(
                         connection,
                         window_layout,
-                        profile=PROFILE_NAME,
+                        profile=None,
                         profile_customizations=customizations_dict,
                     )
 
@@ -451,34 +453,54 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 panes = await create_multi_pane_layout(
                     connection,
                     window_layout,
-                    profile=PROFILE_NAME,
+                    profile=None,
                     profile_customizations=customizations_dict,
                 )
 
                 pane_sessions = [panes[name] for name in pane_names[:worker_count]]
 
-            # Start Claude in all panes
+            # Pre-calculate agent types for each worker
             import asyncio
 
-            async def start_claude_for_worker(index: int) -> None:
+            agent_types: list[str] = []
+
+            for i, w in enumerate(workers):
+                agent_type = w.get("agent_type", "claude")
+                agent_types.append(agent_type)
+
+            # Start agent in all panes (both Claude and Codex)
+            async def start_agent_for_worker(index: int) -> None:
                 session = pane_sessions[index]
                 project_path = resolved_paths[index]
                 worker_config = workers[index]
                 marker_id = session_ids[index]
+                agent_type = agent_types[index]
 
                 # Check for worktree and set BEADS_DIR if needed
                 beads_dir = get_worktree_beads_dir(project_path)
                 env = {"BEADS_DIR": beads_dir} if beads_dir else None
 
-                await start_claude_in_session(
-                    session=session,
-                    project_path=project_path,
-                    dangerously_skip_permissions=worker_config.get("skip_permissions", False),
-                    env=env,
-                    stop_hook_marker_id=marker_id,
-                )
+                if agent_type == "codex":
+                    # Start Codex in interactive mode using start_agent_in_session
+                    cli = get_cli_backend("codex")
+                    await start_agent_in_session(
+                        session=session,
+                        cli=cli,
+                        project_path=project_path,
+                        dangerously_skip_permissions=worker_config.get("skip_permissions", False),
+                        env=env,
+                    )
+                else:
+                    # For Claude: use start_claude_in_session (convenience wrapper)
+                    await start_claude_in_session(
+                        session=session,
+                        project_path=project_path,
+                        dangerously_skip_permissions=worker_config.get("skip_permissions", False),
+                        env=env,
+                        stop_hook_marker_id=marker_id,
+                    )
 
-            await asyncio.gather(*[start_claude_for_worker(i) for i in range(worker_count)])
+            await asyncio.gather(*[start_agent_for_worker(i) for i in range(worker_count)])
 
             # Register all sessions
             managed_sessions = []
@@ -491,35 +513,40 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 )
                 # Set annotation from worker config (if provided)
                 managed.coordinator_annotation = workers[i].get("annotation")
+                # Set agent type
+                managed.agent_type = agent_types[i]
                 # Store worktree info if applicable
                 if i in worktree_paths:
                     managed.worktree_path = worktree_paths[i]
                     managed.main_repo_path = main_repo_paths[i]
                 managed_sessions.append(managed)
 
-            # Send marker messages for JSONL correlation
+            # Send marker messages for JSONL correlation (Claude only)
+            # Codex doesn't use JSONL markers for session tracking
             for i, managed in enumerate(managed_sessions):
-                marker_message = generate_marker_message(
-                    managed.session_id,
-                    iterm_session_id=managed.iterm_session.session_id,
-                )
-                await send_prompt(pane_sessions[i], marker_message, submit=True)
+                if managed.agent_type == "claude":
+                    marker_message = generate_marker_message(
+                        managed.session_id,
+                        iterm_session_id=managed.iterm_session.session_id,
+                    )
+                    await send_prompt(pane_sessions[i], marker_message, submit=True)
 
-            # Wait for markers to appear in JSONL
+            # Wait for markers to appear in JSONL (Claude only)
             for i, managed in enumerate(managed_sessions):
-                claude_session_id = await await_marker_in_jsonl(
-                    managed.project_path,
-                    managed.session_id,
-                    timeout=30.0,
-                    poll_interval=0.1,
-                )
-                if claude_session_id:
-                    managed.claude_session_id = claude_session_id
-                else:
-                    logger.warning(
-                        f"Marker polling timed out for {managed.session_id}, "
-                        "JSONL correlation unavailable"
+                if managed.agent_type == "claude":
+                    claude_session_id = await await_marker_in_jsonl(
+                        managed.project_path,
+                        managed.session_id,
+                        timeout=30.0,
+                        poll_interval=0.1,
                     )
+                    if claude_session_id:
+                        managed.claude_session_id = claude_session_id
+                    else:
+                        logger.warning(
+                            f"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
@@ -536,12 +563,17 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 worker_prompt = generate_worker_prompt(
                     managed.session_id,
                     resolved_names[i],
+                    agent_type=managed.agent_type,
                     use_worktree=use_worktree,
                     bead=bead,
                     custom_prompt=custom_prompt,
                 )
 
-                await send_prompt(pane_sessions[i], worker_prompt, submit=True)
+                # Send prompt to the already-running agent (both Claude and Codex)
+                # Use agent-specific timing (Codex needs longer delay before Enter)
+                logger.info(f"Sending prompt to {managed.name} (agent_type={managed.agent_type}, chars={len(worker_prompt)})")
+                await send_prompt_for_agent(pane_sessions[i], worker_prompt, agent_type=managed.agent_type)
+                logger.info(f"Prompt sent to {managed.name}")
 
             # Mark sessions ready
             result_sessions = {}
@@ -571,6 +603,7 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
 
                 worker_summaries.append({
                     "name": name,
+                    "agent_type": agent_types[i],
                     "bead": bead,
                     "custom_prompt": custom_prompt,
                     "awaiting_task": awaiting,

claude_team_mcp/utils/constants.py

@@ -2,9 +2,15 @@
 Shared constants for Claude Team MCP tools.
 """
 
+from pathlib import Path
+
 # Default page size for conversation history pagination
 CONVERSATION_PAGE_SIZE = 5
 
+# Directory for Codex JSONL output capture
+# Codex streams JSONL to stdout; we pipe it through tee to this directory
+CODEX_JSONL_DIR = Path.home() / ".claude-team" / "codex"
+
 # Hint appended to messages sent to workers
 WORKER_MESSAGE_HINT = "\n\n---\n(Note: Use the `bd_help` tool for guidance on using beads to track progress and add comments.)"
 

claude_team_mcp/worker_prompt.py

@@ -1,11 +1,16 @@
 """Worker pre-prompt generation for coordinated team sessions."""
 
-from typing import Optional
+from typing import Literal, Optional
+
+# Valid agent types for prompt generation
+AgentType = Literal["claude", "codex"]
 
 
 def generate_worker_prompt(
     session_id: str,
     name: str,
+    *,
+    agent_type: AgentType = "claude",
     use_worktree: bool = False,
     bead: Optional[str] = None,
     custom_prompt: Optional[str] = None,
@@ -15,6 +20,7 @@ def generate_worker_prompt(
     Args:
         session_id: The unique identifier for this worker session
         name: The friendly name assigned to this worker
+        agent_type: The type of agent CLI ("claude" or "codex")
         use_worktree: Whether this worker is in an isolated worktree
         bead: Optional beads issue ID (if provided, this is the assignment)
         custom_prompt: Optional additional instructions from the coordinator
@@ -25,7 +31,50 @@ def generate_worker_prompt(
     Note:
         The iTerm-specific marker for session recovery is emitted separately
         via generate_marker_message() in session_state.py, which is called
-        before the worker prompt is sent.
+        before the worker prompt is sent. This marker is only used for Claude
+        workers since Codex doesn't parse JSONL markers.
+    """
+    if agent_type == "codex":
+        return _generate_codex_worker_prompt(
+            session_id=session_id,
+            name=name,
+            use_worktree=use_worktree,
+            bead=bead,
+            custom_prompt=custom_prompt,
+        )
+    # Default to Claude prompt for unknown agent types to maintain backward compatibility
+    return _generate_claude_worker_prompt(
+        session_id=session_id,
+        name=name,
+        use_worktree=use_worktree,
+        bead=bead,
+        custom_prompt=custom_prompt,
+    )
+
+
+def _generate_claude_worker_prompt(
+    session_id: str,
+    name: str,
+    use_worktree: bool = False,
+    bead: Optional[str] = None,
+    custom_prompt: Optional[str] = None,
+) -> str:
+    """Generate the pre-prompt for a Claude Code worker session.
+
+    Claude Code workers have access to:
+    - claude-team MCP markers for session recovery
+    - Stop hook idle detection
+    - Full MCP tool ecosystem
+
+    Args:
+        session_id: The unique identifier for this worker session
+        name: The friendly name assigned to this worker
+        use_worktree: Whether this worker is in an isolated worktree
+        bead: Optional beads issue ID
+        custom_prompt: Optional additional instructions
+
+    Returns:
+        Formatted pre-prompt for Claude worker
     """
     # Build optional sections with dynamic numbering
     next_step = 4
@@ -107,6 +156,111 @@ your session as idle to the coordinator so they can respond.
 '''
 
 
+def _generate_codex_worker_prompt(
+    session_id: str,
+    name: str,
+    use_worktree: bool = False,
+    bead: Optional[str] = None,
+    custom_prompt: Optional[str] = None,
+) -> str:
+    """Generate the pre-prompt for an OpenAI Codex worker session.
+
+    Codex workers differ from Claude:
+    - No claude-team MCP markers (Codex doesn't parse JSONL markers)
+    - No Stop hook idle detection (uses output pattern matching or timeouts)
+    - Runs with --full-auto instead of --dangerously-skip-permissions
+
+    Args:
+        session_id: The unique identifier for this worker session
+        name: The friendly name assigned to this worker
+        use_worktree: Whether this worker is in an isolated worktree
+        bead: Optional beads issue ID
+        custom_prompt: Optional additional instructions
+
+    Returns:
+        Formatted pre-prompt for Codex worker
+    """
+    # Build optional sections with dynamic numbering
+    next_step = 4
+    extra_sections = ""
+
+    # Beads section (if bead provided) - same workflow as Claude
+    if bead:
+        beads_section = f"""
+{next_step}. **Beads workflow.** You're working on `{bead}`. Follow this workflow:
+   - Mark in progress: `bd --no-db update {bead} --status in_progress`
+   - Implement the changes
+   - Close issue: `bd --no-db close {bead}`
+   - Commit with issue reference: `git add -A && git commit -m "{bead}: <summary>"`
+
+   Use `bd --no-db` for all beads commands (required in worktrees).
+"""
+        extra_sections += beads_section
+        next_step += 1
+
+    # Commit section (if worktree but beads section didn't already cover commit)
+    if use_worktree and not bead:
+        commit_section = f"""
+{next_step}. **Commit when done.** You're in an isolated worktree branch — commit your
+   completed work so it can be easily cherry-picked or merged. Use a clear
+   commit message summarizing what you did. Don't push; the coordinator
+   handles that.
+"""
+        extra_sections += commit_section
+
+    # Closing/assignment section - 4 cases based on bead and custom_prompt
+    if bead and custom_prompt:
+        closing = f"""=== YOUR ASSIGNMENT ===
+
+The coordinator assigned you `{bead}` (use `bd show {bead}` for details) and included
+the following instructions:
+
+{custom_prompt}
+
+Get to work!"""
+    elif bead:
+        closing = f"""=== YOUR ASSIGNMENT ===
+
+Your assignment is `{bead}`. Use `bd show {bead}` for details. Get to work!"""
+    elif custom_prompt:
+        closing = f"""=== YOUR ASSIGNMENT ===
+
+The coordinator assigned you the following task:
+
+{custom_prompt}
+
+Get to work!"""
+    else:
+        closing = "Alright, you're all set. The coordinator will send your first task shortly."
+
+    # Codex prompt differs from Claude in key ways:
+    # - No reference to claude-team MCP markers
+    # - No "automatically report your session as idle" - Codex doesn't use stop hooks
+    # - Simpler coordination model (output-based status checking)
+    return f'''Hey {name}! Welcome to the team.
+
+You're part of a coordinated multi-agent team. Your coordinator has tasks for you.
+Do your best to complete the work you've been assigned autonomously.
+
+If you have questions or concerns, clearly state them at the end of your response
+and wait for further instructions. The coordinator will check your progress periodically.
+
+=== THE DEAL ===
+
+1. **Do the work fully.** Either complete it or explain what's blocking you.
+   The coordinator reads your output to understand what happened.
+
+2. **When you're done,** leave a clear summary of what you accomplished.
+   End your response with "COMPLETED" or "BLOCKED: <reason>" so the coordinator
+   can easily assess your status.
+
+3. **If blocked,** explain what you need. The coordinator will read your output
+   and address it.
+{extra_sections}
+{closing}
+'''
+
+
 def get_coordinator_guidance(
     worker_summaries: list[dict],
 ) -> str:
@@ -115,6 +269,7 @@ def get_coordinator_guidance(
     Args:
         worker_summaries: List of dicts with keys:
             - name: Worker name
+            - agent_type: Agent type ("claude" or "codex")
             - bead: Optional bead ID
             - custom_prompt: Optional custom instructions (truncated for display)
             - awaiting_task: True if worker has no bead and no prompt
@@ -122,43 +277,74 @@ def get_coordinator_guidance(
     Returns:
         Formatted coordinator guidance string
     """
+    # Check if we have a mixed team
+    agent_types = {w.get("agent_type", "claude") for w in worker_summaries}
+    is_mixed_team = len(agent_types) > 1
+
     # Build per-worker summary lines
     worker_lines = []
     for w in worker_summaries:
         name = w["name"]
+        agent_type = w.get("agent_type", "claude")
         bead = w.get("bead")
         custom_prompt = w.get("custom_prompt")
         awaiting = w.get("awaiting_task", False)
 
+        # Add agent type indicator if mixed team
+        type_indicator = f" [{agent_type}]" if is_mixed_team else ""
+
         if awaiting:
-            worker_lines.append(f"- **{name}**: ⚠️ AWAITING TASK — send them instructions now")
+            worker_lines.append(
+                f"- **{name}**{type_indicator}: "
+                "AWAITING TASK - send them instructions now"
+            )
         elif bead and custom_prompt:
             # Truncate custom prompt for display
-            short_prompt = custom_prompt[:50] + "..." if len(custom_prompt) > 50 else custom_prompt
-            worker_lines.append(f"- **{name}**: `{bead}` + custom instructions: \"{short_prompt}\"")
+            short_prompt = (
+                custom_prompt[:50] + "..." if len(custom_prompt) > 50 else custom_prompt
+            )
+            worker_lines.append(
+                f"- **{name}**{type_indicator}: `{bead}` + custom: \"{short_prompt}\""
+            )
         elif bead:
-            worker_lines.append(f"- **{name}**: `{bead}` (beads workflow: mark in_progress → implement → close → commit)")
+            worker_lines.append(
+                f"- **{name}**{type_indicator}: `{bead}` "
+                "(beads workflow: mark in_progress -> implement -> close -> commit)"
+            )
         elif custom_prompt:
-            short_prompt = custom_prompt[:50] + "..." if len(custom_prompt) > 50 else custom_prompt
-            worker_lines.append(f"- **{name}**: custom task: \"{short_prompt}\"")
+            short_prompt = (
+                custom_prompt[:50] + "..." if len(custom_prompt) > 50 else custom_prompt
+            )
+            worker_lines.append(
+                f"- **{name}**{type_indicator}: custom task: \"{short_prompt}\""
+            )
 
     workers_section = "\n".join(worker_lines)
 
+    # Build mixed team guidance if applicable
+    mixed_team_section = ""
+    if is_mixed_team:
+        mixed_team_section = """
+**Mixed team note:** You have both Claude and Codex workers:
+- **Claude workers**: Idle detection via Stop hooks (automatic)
+- **Codex workers**: Check status by reading their output for "COMPLETED" or "BLOCKED"
+"""
+
     return f"""=== TEAM DISPATCHED ===
 
 {workers_section}
-
+{mixed_team_section}
 Workers will do the work and explain their output. If blocked, they'll say so.
 You review everything before it's considered done.
 
 **Coordination style reminder:** Match your approach to the task. Hands-off for exploratory
 work (check in when asked), autonomous for pipelines (wait for completion, read logs, continue).
 
-⚠️ **WORKTREE LIFECYCLE** — Workers with worktrees commit to ephemeral branches.
-BEFORE closing workers:
-1. Review their code changes (read_worker_logs or inspect worktree directly)
-2. Merge or cherry-pick their commits to a persistent branch
-3. THEN close workers
+**WORKTREE LIFECYCLE** — Workers with worktrees commit to ephemeral branches.
+When you close workers:
+1. Worktree directories are removed, but branches (and commits) are preserved
+2. Review commits on worker branches before merging
+3. Merge or cherry-pick to main, then delete the worker branch
 
-Closing workers with worktrees DESTROYS their branches. Unmerged commits will be orphaned.
+Branches persist until explicitly deleted with `git branch -d <branch>`.
 """

claude_team_mcp/worktree.py

@@ -240,6 +240,10 @@ def create_local_worktree(
     The branch name matches the worktree directory name for consistency.
     Automatically adds .worktrees to .gitignore if not present.
 
+    If a worktree path or branch already exists, appends an incrementing
+    suffix (-1, -2, etc.) until an available name is found. This allows
+    multiple workers to work on the same bead in parallel.
+
     Args:
         repo_path: Path to the main repository
         worker_name: Name of the worker (used in fallback naming)
@@ -262,6 +266,9 @@ def create_local_worktree(
         )
         # Returns: Path("/path/to/repo/.worktrees/cic-abc-add-local-worktrees")
 
+        # If called again with same bead/annotation:
+        # Returns: Path("/path/to/repo/.worktrees/cic-abc-add-local-worktrees-1")
+
         # Without bead ID
         path = create_local_worktree(
             repo_path=Path("/path/to/repo"),
@@ -290,7 +297,6 @@ def create_local_worktree(
 
     # Worktree path inside the repo
     worktrees_dir = repo_path / LOCAL_WORKTREE_DIR
-    worktree_path = worktrees_dir / dir_name
 
     # Ensure .worktrees is in .gitignore
     ensure_gitignore_entry(repo_path, LOCAL_WORKTREE_DIR)
@@ -298,29 +304,32 @@ def create_local_worktree(
     # Ensure .worktrees directory exists
     worktrees_dir.mkdir(parents=True, exist_ok=True)
 
-    # Check if worktree already exists
-    if worktree_path.exists():
-        raise WorktreeError(f"Worktree already exists at {worktree_path}")
+    # Find an available name, handling collisions with incrementing suffix.
+    # Check both path existence and branch existence (git won't allow the same
+    # branch checked out in multiple worktrees).
+    def branch_exists(name: str) -> bool:
+        result = subprocess.run(
+            ["git", "-C", str(repo_path), "rev-parse", "--verify", f"refs/heads/{name}"],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
 
-    # Branch name matches directory name for clarity
-    branch_name = dir_name
+    base_dir_name = dir_name
+    worktree_path = worktrees_dir / dir_name
+    suffix = 0
 
-    # Build the git worktree add command
-    cmd = ["git", "-C", str(repo_path), "worktree", "add"]
+    while worktree_path.exists() or branch_exists(dir_name):
+        suffix += 1
+        dir_name = f"{base_dir_name}-{suffix}"
+        worktree_path = worktrees_dir / dir_name
 
-    # Check if branch exists
-    branch_check = subprocess.run(
-        ["git", "-C", str(repo_path), "rev-parse", "--verify", f"refs/heads/{branch_name}"],
-        capture_output=True,
-        text=True,
-    )
+    # Branch name matches directory name for clarity
+    branch_name = dir_name
 
-    if branch_check.returncode == 0:
-        # Branch exists, check it out
-        cmd.extend([str(worktree_path), branch_name])
-    else:
-        # Branch doesn't exist, create it with -b
-        cmd.extend(["-b", branch_name, str(worktree_path)])
+    # Build the git worktree add command.
+    # Branch is guaranteed not to exist (collision loop checked for it).
+    cmd = ["git", "-C", str(repo_path), "worktree", "add", "-b", branch_name, str(worktree_path)]
 
     result = subprocess.run(cmd, capture_output=True, text=True)