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

claude_team_mcp/cli_backends/codex.py

@@ -58,10 +58,9 @@ class CodexCLI(AgentCLI):
         """
         args: list[str] = []
 
-        # Codex uses --dangerously-bypass-approvals-and-sandbox for autonomous operation
-        # (--full-auto doesn't work through happy wrapper)
+        # Codex uses --full-auto for autonomous operation.
         if dangerously_skip_permissions:
-            args.append("--dangerously-bypass-approvals-and-sandbox")
+            args.append("--full-auto")
 
         # Note: settings_file is ignored - Codex doesn't support this
         # Idle detection uses session file polling instead

claude_team_mcp/issue_tracker/__init__.py

@@ -0,0 +1,132 @@
+"""
+Issue tracker abstraction module.
+
+Defines a protocol and backend implementations for issue tracker commands.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+logger = logging.getLogger("claude-team-mcp")
+
+
+@runtime_checkable
+class IssueTrackerBackend(Protocol):
+    """
+    Protocol defining the issue tracker backend interface.
+
+    Backends provide a name, CLI command, marker directory, and command templates.
+    """
+
+    name: str
+    cli: str
+    marker_dir: str
+    commands: dict[str, str]
+
+
+@dataclass(frozen=True)
+class BeadsBackend:
+    """Beads issue tracker backend."""
+
+    name: str = "beads"
+    cli: str = "bd"
+    marker_dir: str = ".beads"
+    commands: dict[str, str] = field(
+        default_factory=lambda: {
+            "list": "bd --no-db list",
+            "ready": "bd --no-db ready",
+            "show": "bd --no-db show {issue_id}",
+            "update": "bd --no-db update {issue_id} --status {status}",
+            "close": "bd --no-db close {issue_id}",
+            "create": (
+                "bd --no-db create --title \"{title}\" --type {type} "
+                "--priority {priority} --description \"{description}\""
+            ),
+            "comment": "bd --no-db comment {issue_id} \"{comment}\"",
+            "dep_add": "bd --no-db dep add {issue_id} {dependency_id}",
+            "dep_tree": "bd --no-db dep tree {issue_id}",
+        }
+    )
+
+
+@dataclass(frozen=True)
+class PebblesBackend:
+    """Pebbles issue tracker backend."""
+
+    name: str = "pebbles"
+    cli: str = "pb"
+    marker_dir: str = ".pebbles"
+    commands: dict[str, str] = field(
+        default_factory=lambda: {
+            "list": "pb list",
+            "ready": "pb ready",
+            "show": "pb show {issue_id}",
+            "update": "pb update {issue_id} -status {status}",
+            "close": "pb close {issue_id}",
+            "create": (
+                "pb create -title \"{title}\" -type {type} -priority {priority} "
+                "-description \"{description}\""
+            ),
+            "comment": "pb comment {issue_id} -body \"{comment}\"",
+            "dep_add": "pb dep add {issue_id} {dependency_id}",
+            "dep_tree": "pb dep tree {issue_id}",
+        }
+    )
+
+
+BEADS_BACKEND = BeadsBackend()
+PEBBLES_BACKEND = PebblesBackend()
+BACKEND_REGISTRY: dict[str, IssueTrackerBackend] = {
+    BEADS_BACKEND.name: BEADS_BACKEND,
+    PEBBLES_BACKEND.name: PEBBLES_BACKEND,
+}
+
+
+def detect_issue_tracker(project_path: str) -> IssueTrackerBackend | None:
+    """
+    Detect the issue tracker backend for the given project path.
+
+    Args:
+        project_path: Absolute or relative path to the project root.
+
+    Returns:
+        The detected IssueTrackerBackend, or None if no markers are present.
+    """
+    beads_marker = os.path.join(project_path, BEADS_BACKEND.marker_dir)
+    pebbles_marker = os.path.join(project_path, PEBBLES_BACKEND.marker_dir)
+
+    # Check marker directories in the project root.
+    beads_present = os.path.isdir(beads_marker)
+    pebbles_present = os.path.isdir(pebbles_marker)
+
+    # Resolve the deterministic backend when both markers exist.
+    if beads_present and pebbles_present:
+        logger.warning(
+            "Both .beads and .pebbles found in %s; defaulting to pebbles",
+            project_path,
+        )
+        return PEBBLES_BACKEND
+
+    # Return the matching backend if only one marker exists.
+    if pebbles_present:
+        return PEBBLES_BACKEND
+
+    if beads_present:
+        return BEADS_BACKEND
+
+    return None
+
+
+__all__ = [
+    "IssueTrackerBackend",
+    "BeadsBackend",
+    "PebblesBackend",
+    "BEADS_BACKEND",
+    "PEBBLES_BACKEND",
+    "BACKEND_REGISTRY",
+    "detect_issue_tracker",
+]

claude_team_mcp/tools/__init__.py

@@ -8,7 +8,7 @@ from mcp.server.fastmcp import FastMCP
 
 from . import adopt_worker
 from . import annotate_worker
-from . import bd_help
+from . import issue_tracker_help
 from . import check_idle_workers
 from . import close_workers
 from . import discover_workers
@@ -31,7 +31,7 @@ def register_all_tools(mcp: FastMCP, ensure_connection) -> None:
     """
     # Tools that don't need ensure_connection
     annotate_worker.register_tools(mcp)
-    bd_help.register_tools(mcp)
+    issue_tracker_help.register_tools(mcp)
     check_idle_workers.register_tools(mcp)
     close_workers.register_tools(mcp)
     examine_worker.register_tools(mcp)

claude_team_mcp/tools/issue_tracker_help.py

@@ -0,0 +1,50 @@
+"""
+Issue tracker help tool.
+
+Provides issue_tracker_help for quick reference on issue tracking commands.
+"""
+
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from ..issue_tracker import BACKEND_REGISTRY, detect_issue_tracker
+from ..utils import build_issue_tracker_help_text, build_issue_tracker_quick_commands
+
+
+def register_tools(mcp: FastMCP) -> None:
+    """Register issue_tracker_help tool on the MCP server."""
+
+    @mcp.tool()
+    async def issue_tracker_help() -> dict:
+        """
+        Get a quick reference guide for using issue tracking.
+
+        Returns condensed documentation on tracker commands, workflow patterns,
+        and best practices for worker sessions. Call this tool when you need
+        guidance on tracking progress, adding comments, or managing issues.
+
+        Returns:
+            Dict with help text and key command examples
+        """
+        project_path = str(Path.cwd())
+        backend = detect_issue_tracker(project_path)
+        help_text = build_issue_tracker_help_text(backend)
+        quick_commands = build_issue_tracker_quick_commands(backend)
+
+        response = {
+            "help": help_text,
+            "quick_commands": quick_commands,
+            "worker_tip": (
+                "As a worker, add comments to track progress rather than closing issues. "
+                "The coordinator will close issues after reviewing your work."
+            ),
+        }
+
+        if backend is None:
+            response["supported_trackers"] = sorted(BACKEND_REGISTRY.keys())
+        else:
+            response["tracker"] = backend.name
+            response["cli"] = backend.cli
+
+        return response

claude_team_mcp/tools/message_workers.py

@@ -19,9 +19,10 @@ from ..idle_detection import (
     wait_for_any_idle as wait_for_any_idle_impl,
     SessionInfo,
 )
+from ..issue_tracker import detect_issue_tracker
 from ..iterm_utils import send_prompt_for_agent
 from ..registry import SessionStatus
-from ..utils import error_response, HINTS, WORKER_MESSAGE_HINT
+from ..utils import build_worker_message_hint, error_response, HINTS
 
 logger = logging.getLogger("claude-team-mcp")
 
@@ -187,8 +188,14 @@ def register_tools(mcp: FastMCP) -> None:
                 # Update status to busy
                 registry.update_status(sid, SessionStatus.BUSY)
 
-                # Append hint about bd_help tool to help workers understand beads
-                message_with_hint = message + WORKER_MESSAGE_HINT
+                # Append tracker-specific hint so workers know how to log progress.
+                tracker_path = (
+                    str(session.main_repo_path)
+                    if session.main_repo_path is not None
+                    else session.project_path
+                )
+                tracker_backend = detect_issue_tracker(tracker_path)
+                message_with_hint = message + build_worker_message_hint(tracker_backend)
 
                 # Send the message using agent-specific input handling.
                 # Codex needs a longer pre-Enter delay than Claude.

claude_team_mcp/tools/spawn_workers.py

@@ -23,6 +23,7 @@ from ..iterm_utils import (
     MAX_PANES_PER_TAB,
     create_multi_pane_layout,
     find_available_window,
+    get_window_for_session,
     send_prompt,
     send_prompt_for_agent,
     split_pane,
@@ -32,7 +33,7 @@ from ..iterm_utils import (
 from ..names import pick_names_for_count
 from ..profile import apply_appearance_colors
 from ..registry import SessionStatus
-from ..utils import HINTS, error_response, get_worktree_beads_dir
+from ..utils import HINTS, error_response, get_worktree_tracker_dir
 from ..worker_prompt import generate_worker_prompt, get_coordinator_guidance
 from ..worktree import WorktreeError, create_local_worktree
 
@@ -324,76 +325,140 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
             if layout == "auto":
                 # Try to find an existing window where the ENTIRE batch fits.
                 # This keeps spawn batches together rather than spreading across windows.
-                managed_iterm_ids: set[str] = {
-                    s.iterm_session.session_id
-                    for s in registry.list_all()
-                    if s.iterm_session is not None
-                }
-
-                # Find a window with enough space for ALL workers
-                result = await find_available_window(
-                    app,
-                    max_panes=MAX_PANES_PER_TAB,
-                    managed_session_ids=managed_iterm_ids,
-                )
-
                 target_tab = None
                 initial_pane_count = 0
                 first_session = None  # Session to split from
 
-                if result:
-                    window, tab, existing_session = result
-                    initial_pane_count = len(tab.sessions)
-                    available_slots = MAX_PANES_PER_TAB - initial_pane_count
-
-                    if worker_count <= available_slots:
-                        # Entire batch fits in this window
-                        target_tab = tab
-                        first_session = existing_session
-                        logger.debug(
-                            f"Batch of {worker_count} fits in existing window "
-                            f"({initial_pane_count} panes, {available_slots} slots)"
+                # Prefer the coordinator's window when running inside iTerm2.
+                # ITERM_SESSION_ID format is "wXtYpZ:UUID" - extract just the UUID.
+                iterm_session_env = os.environ.get("ITERM_SESSION_ID")
+                coordinator_session_id = None
+                if iterm_session_env and ":" in iterm_session_env:
+                    coordinator_session_id = iterm_session_env.split(":", 1)[1]
+                if coordinator_session_id:
+                    coordinator_session = None
+                    coordinator_tab = None
+
+                    for window in app.terminal_windows:
+                        for tab in window.tabs:
+                            for session in tab.sessions:
+                                if session.session_id == coordinator_session_id:
+                                    coordinator_session = session
+                                    coordinator_tab = tab
+                                    break
+                            if coordinator_session:
+                                break
+                        if coordinator_session:
+                            break
+
+                    if coordinator_session and coordinator_tab:
+                        coordinator_window = await get_window_for_session(
+                            app, coordinator_session
                         )
+                        if coordinator_window is not None:
+                            initial_pane_count = len(coordinator_tab.sessions)
+                            available_slots = MAX_PANES_PER_TAB - initial_pane_count
+                            if worker_count <= available_slots:
+                                target_tab = coordinator_tab
+                                first_session = coordinator_session
+                                logger.debug(
+                                    "Using coordinator window "
+                                    f"({initial_pane_count} panes, {available_slots} slots)"
+                                )
+
+                if target_tab is None:
+                    managed_iterm_ids: set[str] = {
+                        s.iterm_session.session_id
+                        for s in registry.list_all()
+                        if s.iterm_session is not None
+                    }
+
+                    # Find a window with enough space for ALL workers
+                    result = await find_available_window(
+                        app,
+                        max_panes=MAX_PANES_PER_TAB,
+                        managed_session_ids=managed_iterm_ids,
+                    )
+
+                    if result:
+                        window, tab, existing_session = result
+                        initial_pane_count = len(tab.sessions)
+                        available_slots = MAX_PANES_PER_TAB - initial_pane_count
+
+                        if worker_count <= available_slots:
+                            # Entire batch fits in this window
+                            target_tab = tab
+                            first_session = existing_session
+                            logger.debug(
+                                f"Batch of {worker_count} fits in existing window "
+                                f"({initial_pane_count} panes, {available_slots} slots)"
+                            )
 
                 if target_tab:
                     # Reuse existing window - track pane count locally (iTerm objects stale)
                     local_pane_count = initial_pane_count
-                    # Track created sessions for quad splitting
+                    final_pane_count = initial_pane_count + worker_count
+                    # Track created sessions for splitting
                     created_sessions: list = []
 
                     for i in range(worker_count):
-                        # Determine split direction based on local_pane_count
-                        # Incremental quad: TL→TR(vsplit)→BL(hsplit)→BR(hsplit)
-                        if local_pane_count == 1:
-                            # First split: vertical (left/right)
-                            new_session = await split_pane(
-                                first_session,
-                                vertical=True,
-                                before=False,
-                                profile=None,
-                                profile_customizations=profile_customizations[i],
-                            )
-                        elif local_pane_count == 2:
-                            # Second split: horizontal from left pane (creates bottom-left)
-                            # Use first_session (the original TL pane)
-                            new_session = await split_pane(
-                                first_session,
-                                vertical=False,
-                                before=False,
-                                profile=None,
-                                profile_customizations=profile_customizations[i],
-                            )
-                        else:  # local_pane_count == 3
-                            # Third split: horizontal from right pane (creates bottom-right)
-                            # The TR pane is the first one we created
-                            tr_session = created_sessions[0] if created_sessions else first_session
-                            new_session = await split_pane(
-                                tr_session,
-                                vertical=False,
-                                before=False,
-                                profile=None,
-                                profile_customizations=profile_customizations[i],
-                            )
+                        # Choose layout strategy based on final pane count:
+                        # - 3 panes: coordinator full left, workers stacked right
+                        # - 4 panes: quad (TL→TR→BL→BR)
+                        if final_pane_count == 3:
+                            # Layout: coordinator | worker1
+                            #                    |--------
+                            #                    | worker2
+                            if local_pane_count == 1:
+                                # First split: vertical from coordinator
+                                new_session = await split_pane(
+                                    first_session,
+                                    vertical=True,
+                                    before=False,
+                                    profile=None,
+                                    profile_customizations=profile_customizations[i],
+                                )
+                            else:
+                                # Second split: horizontal from first worker (stack on right)
+                                new_session = await split_pane(
+                                    created_sessions[0],
+                                    vertical=False,
+                                    before=False,
+                                    profile=None,
+                                    profile_customizations=profile_customizations[i],
+                                )
+                        else:
+                            # Quad pattern: TL→TR(vsplit)→BL(hsplit)→BR(hsplit)
+                            if local_pane_count == 1:
+                                # First split: vertical (left/right)
+                                new_session = await split_pane(
+                                    first_session,
+                                    vertical=True,
+                                    before=False,
+                                    profile=None,
+                                    profile_customizations=profile_customizations[i],
+                                )
+                            elif local_pane_count == 2:
+                                # Second split: horizontal from left pane (bottom-left)
+                                new_session = await split_pane(
+                                    first_session,
+                                    vertical=False,
+                                    before=False,
+                                    profile=None,
+                                    profile_customizations=profile_customizations[i],
+                                )
+                            else:  # local_pane_count == 3
+                                # Third split: horizontal from right pane (bottom-right)
+                                tr_session = (
+                                    created_sessions[0] if created_sessions else first_session
+                                )
+                                new_session = await split_pane(
+                                    tr_session,
+                                    vertical=False,
+                                    before=False,
+                                    profile=None,
+                                    profile_customizations=profile_customizations[i],
+                                )
 
                         pane_sessions.append(new_session)
                         created_sessions.append(new_session)
@@ -476,9 +541,13 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 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
+                # Check for worktree and set tracker env var if needed.
+                tracker_info = get_worktree_tracker_dir(project_path)
+                if tracker_info:
+                    env_var, tracker_dir = tracker_info
+                    env = {env_var: tracker_dir}
+                else:
+                    env = None
 
                 if agent_type == "codex":
                     # Start Codex in interactive mode using start_agent_in_session
@@ -560,12 +629,18 @@ def register_tools(mcp: FastMCP, ensure_connection) -> None:
                 if not bead and not custom_prompt:
                     workers_awaiting_task.append(managed.name)
 
+                tracker_path = (
+                    str(managed.main_repo_path)
+                    if managed.main_repo_path is not None
+                    else managed.project_path
+                )
                 worker_prompt = generate_worker_prompt(
                     managed.session_id,
                     resolved_names[i],
                     agent_type=managed.agent_type,
                     use_worktree=use_worktree,
                     bead=bead,
+                    project_path=tracker_path,
                     custom_prompt=custom_prompt,
                 )
 

claude_team_mcp/utils/__init__.py

@@ -2,16 +2,24 @@
 Shared utilities for Claude Team MCP tools.
 """
 
-from .constants import BEADS_HELP_TEXT, CONVERSATION_PAGE_SIZE, WORKER_MESSAGE_HINT
+from .constants import (
+    CONVERSATION_PAGE_SIZE,
+    ISSUE_TRACKER_HELP_TOOL,
+    build_issue_tracker_help_text,
+    build_issue_tracker_quick_commands,
+    build_worker_message_hint,
+)
 from .errors import error_response, HINTS, get_session_or_error
-from .worktree_detection import get_worktree_beads_dir
+from .worktree_detection import get_worktree_tracker_dir
 
 __all__ = [
-    "BEADS_HELP_TEXT",
     "CONVERSATION_PAGE_SIZE",
-    "WORKER_MESSAGE_HINT",
+    "ISSUE_TRACKER_HELP_TOOL",
+    "build_issue_tracker_help_text",
+    "build_issue_tracker_quick_commands",
+    "build_worker_message_hint",
     "error_response",
     "HINTS",
     "get_session_or_error",
-    "get_worktree_beads_dir",
+    "get_worktree_tracker_dir",
 ]

claude_team_mcp/utils/constants.py

@@ -4,6 +4,8 @@ Shared constants for Claude Team MCP tools.
 
 from pathlib import Path
 
+from ..issue_tracker import BACKEND_REGISTRY, IssueTrackerBackend
+
 # Default page size for conversation history pagination
 CONVERSATION_PAGE_SIZE = 5
 
@@ -11,23 +13,109 @@ CONVERSATION_PAGE_SIZE = 5
 # 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.)"
-
-# Condensed beads help text for workers
-BEADS_HELP_TEXT = """# Beads Quick Reference
-
-Beads is a lightweight issue tracker. Use it to track progress and communicate with the coordinator.
+# Tool name used for issue tracker help
+ISSUE_TRACKER_HELP_TOOL = "issue_tracker_help"
+
+
+def _format_tracker_command(
+    backend: IssueTrackerBackend,
+    command: str,
+    **kwargs: str,
+) -> str | None:
+    """Format a tracker command template with the provided arguments."""
+    template = backend.commands.get(command)
+    if not template:
+        return None
+    return template.format(**kwargs)
+
+
+def _supported_trackers_summary() -> str:
+    """Return a comma-separated summary of known issue trackers."""
+    return ", ".join(sorted(BACKEND_REGISTRY.keys()))
+
+
+def build_issue_tracker_help_text(backend: IssueTrackerBackend | None) -> str:
+    """Build issue tracker help text for the detected backend."""
+    if backend is None:
+        supported = _supported_trackers_summary()
+        return (
+            "# Issue Tracker Quick Reference\n\n"
+            "No issue tracker detected for this project. "
+            f"Supported trackers: {supported}.\n"
+        )
+
+    # Prepare command examples from the backend templates.
+    list_cmd = _format_tracker_command(backend, "list") or ""
+    ready_cmd = _format_tracker_command(backend, "ready") or ""
+    show_cmd = _format_tracker_command(backend, "show", issue_id="<issue-id>") or ""
+    update_cmd = (
+        _format_tracker_command(
+            backend,
+            "update",
+            issue_id="<issue-id>",
+            status="in_progress",
+        )
+        or ""
+    )
+    # Worker-focused examples reuse the comment command template.
+    comment_cmd = (
+        _format_tracker_command(
+            backend,
+            "comment",
+            issue_id="<issue-id>",
+            comment="progress message",
+        )
+        or ""
+    )
+    comment_progress_cmd = (
+        _format_tracker_command(
+            backend,
+            "comment",
+            issue_id="<issue-id>",
+            comment="Completed the API endpoint, now working on tests",
+        )
+        or ""
+    )
+    comment_final_cmd = (
+        _format_tracker_command(
+            backend,
+            "comment",
+            issue_id="<issue-id>",
+            comment=(
+                "COMPLETE: Implemented feature X. Changes in src/foo.py and "
+                "tests/test_foo.py. Ready for review."
+            ),
+        )
+        or ""
+    )
+    # Closing and creation examples round out the workflow guidance.
+    close_cmd = _format_tracker_command(backend, "close", issue_id="<issue-id>") or ""
+    create_cmd = (
+        _format_tracker_command(
+            backend,
+            "create",
+            title="Bug: X doesn't work",
+            type="bug",
+            priority="P1",
+            description="Details...",
+        )
+        or ""
+    )
+
+    # Compose the full help text with backend-specific examples.
+    return f"""# Issue Tracker Quick Reference
+
+Your project uses the `{backend.name}` issue tracker. Use it to track progress and communicate with the coordinator.
 
 ## Essential Commands
 
 ```bash
-bd list                              # List all issues
-bd ready                             # Show unblocked work
-bd show <issue-id>                   # Show issue details
-bd update <id> --status in_progress  # Mark as in-progress
-bd comment <id> "message"            # Add progress note (IMPORTANT!)
-bd close <id>                        # Close when complete
+{list_cmd}
+{ready_cmd}
+{show_cmd}
+{update_cmd}
+{comment_cmd}
+{close_cmd}
 ```
 
 ## Status Values
@@ -50,38 +138,72 @@ bd close <id>                        # Close when complete
 
 ## As a Worker
 
-**IMPORTANT**: You should NOT close beads unless explicitly told to. Instead:
-
 1. Mark your issue as in-progress when starting:
    ```bash
-   bd update <issue-id> --status in_progress
+   {update_cmd}
    ```
 
 2. Add comments to document your progress:
    ```bash
-   bd comment <issue-id> "Completed the API endpoint, now working on tests"
-   bd comment <issue-id> "Found edge case - handling null values in response"
+   {comment_progress_cmd}
    ```
 
 3. When finished, add a final summary comment:
    ```bash
-   bd comment <issue-id> "COMPLETE: Implemented feature X. Changes in src/foo.py and tests/test_foo.py. Ready for review."
+   {comment_final_cmd}
    ```
 
-4. The coordinator will review and close the bead.
+4. The coordinator will review and close the issue.
 
 ## Creating New Issues (if needed)
 
 ```bash
-bd create --title "Bug: X doesn't work" --type bug --priority P1 --description "Details..."
+{create_cmd}
 ```
+"""
 
-## Searching
 
-```bash
-bd search "keyword"          # Search by text
-bd list --status open        # Filter by status
-bd list --type bug           # Filter by type
-bd blocked                   # Show blocked issues
-```
-"""
+def build_issue_tracker_quick_commands(
+    backend: IssueTrackerBackend | None,
+) -> dict[str, str]:
+    """Return quick command examples for the detected backend."""
+    if backend is None:
+        return {}
+
+    # Map common actions to backend templates for quick reference.
+    commands = {
+        "list_issues": _format_tracker_command(backend, "list"),
+        "show_ready": _format_tracker_command(backend, "ready"),
+        "show_issue": _format_tracker_command(backend, "show", issue_id="<issue-id>"),
+        "start_work": _format_tracker_command(
+            backend,
+            "update",
+            issue_id="<issue-id>",
+            status="in_progress",
+        ),
+        "add_comment": _format_tracker_command(
+            backend,
+            "comment",
+            issue_id="<issue-id>",
+            comment="progress message",
+        ),
+        "close_issue": _format_tracker_command(backend, "close", issue_id="<issue-id>"),
+    }
+    return {key: value for key, value in commands.items() if value}
+
+
+def build_worker_message_hint(backend: IssueTrackerBackend | None) -> str:
+    """Return the issue tracker hint appended to worker messages."""
+    if backend is None:
+        supported = _supported_trackers_summary()
+        return (
+            "\n\n---\n"
+            f"(Note: Use the `{ISSUE_TRACKER_HELP_TOOL}` tool for guidance on the "
+            f"configured issue tracker. Supported trackers: {supported}.)"
+        )
+
+    return (
+        "\n\n---\n"
+        f"(Note: Use the `{ISSUE_TRACKER_HELP_TOOL}` tool for guidance on "
+        f"{backend.name} commands (CLI: `{backend.cli}`).)"
+    )

claude_team_mcp/utils/worktree_detection.py

@@ -2,19 +2,25 @@
 Git worktree detection utilities.
 
 Detects if a project path is a git worktree and locates the main repo's
-beads directory for proper issue tracking.
+issue tracker marker directory for proper issue tracking.
 """
 
 import logging
 import os
 import subprocess
 
+from claude_team_mcp.issue_tracker import (
+    BEADS_BACKEND,
+    PEBBLES_BACKEND,
+    detect_issue_tracker,
+)
+
 logger = logging.getLogger("claude-team-mcp")
 
 
-def get_worktree_beads_dir(project_path: str) -> str | None:
+def get_worktree_tracker_dir(project_path: str) -> tuple[str, str] | None:
     """
-    Detect if project_path is a git worktree and return the main repo's .beads dir.
+    Detect if project_path is a git worktree and return tracker env var + dir.
 
     Git worktrees have .git as a file (not a directory) pointing to the main repo.
     The `git rev-parse --git-common-dir` command returns the path to the shared
@@ -24,9 +30,9 @@ def get_worktree_beads_dir(project_path: str) -> str | None:
         project_path: Absolute path to the project directory
 
     Returns:
-        Path to the main repo's .beads directory if:
+        (env_var, tracker_dir) if:
         - project_path is a git worktree
-        - The main repo has a .beads directory
+        - The main repo has a tracker marker (.beads or .pebbles)
         Otherwise returns None.
     """
     try:
@@ -45,7 +51,7 @@ def get_worktree_beads_dir(project_path: str) -> str | None:
 
         git_common_dir = result.stdout.strip()
 
-        # If the result is just ".git", this is the main repo (not a worktree)
+        # If the result is just ".git", this is the main repo (not a worktree).
         if git_common_dir == ".git":
             return None
 
@@ -57,19 +63,35 @@ def get_worktree_beads_dir(project_path: str) -> str | None:
 
         git_common_dir = os.path.normpath(git_common_dir)
 
-        # Main repo is the parent directory of .git
+        # Main repo is the parent directory of .git.
         main_repo = os.path.dirname(git_common_dir)
 
-        # Check if the main repo has a .beads directory
-        beads_dir = os.path.join(main_repo, ".beads")
-        if os.path.isdir(beads_dir):
-            logger.info(
-                f"Detected git worktree. Setting BEADS_DIR={beads_dir} "
-                f"for project {project_path}"
+        # Identify which tracker is present in the main repo.
+        tracker_backend = detect_issue_tracker(main_repo)
+        if tracker_backend is None:
+            return None
+
+        # Map the detected tracker to its env var and marker directory.
+        if tracker_backend is BEADS_BACKEND:
+            env_var = "BEADS_DIR"
+        elif tracker_backend is PEBBLES_BACKEND:
+            env_var = "PEBBLES_DIR"
+        else:
+            logger.warning(
+                "Unknown issue tracker backend %s for %s",
+                tracker_backend.name,
+                main_repo,
             )
-            return beads_dir
+            return None
 
-        return None
+        tracker_dir = os.path.join(main_repo, tracker_backend.marker_dir)
+        logger.info(
+            "Detected git worktree. Setting %s=%s for project %s",
+            env_var,
+            tracker_dir,
+            project_path,
+        )
+        return env_var, tracker_dir
 
     except subprocess.TimeoutExpired:
         logger.warning(f"Timeout checking git worktree status for {project_path}")

claude_team_mcp/worker_prompt.py

@@ -2,10 +2,84 @@
 
 from typing import Literal, Optional
 
+from .issue_tracker import BACKEND_REGISTRY, IssueTrackerBackend, detect_issue_tracker
+from .utils.constants import ISSUE_TRACKER_HELP_TOOL
+
 # Valid agent types for prompt generation
 AgentType = Literal["claude", "codex"]
 
 
+def _resolve_issue_tracker_backend(
+    project_path: Optional[str],
+) -> IssueTrackerBackend | None:
+    """Detect the issue tracker backend for a project path."""
+    if not project_path:
+        return None
+    return detect_issue_tracker(project_path)
+
+
+def _format_tracker_command(
+    backend: IssueTrackerBackend,
+    command: str,
+    **kwargs: str,
+) -> str:
+    """Format a tracker command template with the provided arguments."""
+    template = backend.commands.get(command)
+    if not template:
+        return ""
+    return template.format(**kwargs)
+
+
+def _supported_tracker_list() -> str:
+    """Return a readable list of supported issue trackers."""
+    return ", ".join(sorted(BACKEND_REGISTRY.keys()))
+
+
+def _build_tracker_workflow_section(
+    issue_id: str,
+    backend: IssueTrackerBackend | None,
+    step_number: int,
+) -> tuple[str, str | None]:
+    """Build the issue tracker workflow section and show command hint."""
+    if backend:
+        update_cmd = _format_tracker_command(
+            backend,
+            "update",
+            issue_id=issue_id,
+            status="in_progress",
+        )
+        close_cmd = _format_tracker_command(
+            backend,
+            "close",
+            issue_id=issue_id,
+        )
+        show_cmd = _format_tracker_command(backend, "show", issue_id=issue_id) or None
+        # Provide backend-specific commands when a tracker is detected.
+        section = f"""
+{step_number}. **Issue tracker workflow.** You're working on `{issue_id}`. Follow this workflow:
+   - Mark in progress: `{update_cmd}`
+   - Implement the changes
+   - Close issue: `{close_cmd}`
+   - Commit with issue reference: `git add -A && git commit -m "{issue_id}: <summary>"`
+
+   Use the {backend.name} CLI (`{backend.cli}`) for issue tracker commands.
+"""
+        return section, show_cmd
+
+    supported = _supported_tracker_list()
+    # Fall back to generic instructions when no tracker is detected.
+    section = f"""
+{step_number}. **Issue tracker workflow.** You're working on `{issue_id}`. Follow this workflow:
+   - Mark in progress in the issue tracker
+   - Implement the changes
+   - Close the issue when done
+   - Commit with issue reference: `git add -A && git commit -m "{issue_id}: <summary>"`
+
+   No issue tracker detected. Supported trackers: {supported}. Use `{ISSUE_TRACKER_HELP_TOOL}` for guidance.
+"""
+    return section, None
+
+
 def generate_worker_prompt(
     session_id: str,
     name: str,
@@ -13,6 +87,7 @@ def generate_worker_prompt(
     agent_type: AgentType = "claude",
     use_worktree: bool = False,
     bead: Optional[str] = None,
+    project_path: Optional[str] = None,
     custom_prompt: Optional[str] = None,
 ) -> str:
     """Generate the pre-prompt text for a worker session.
@@ -22,7 +97,8 @@ def generate_worker_prompt(
         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)
+        bead: Optional issue tracker ID (if provided, this is the assignment)
+        project_path: Optional project path for issue tracker detection
         custom_prompt: Optional additional instructions from the coordinator
 
     Returns:
@@ -40,6 +116,7 @@ def generate_worker_prompt(
             name=name,
             use_worktree=use_worktree,
             bead=bead,
+            project_path=project_path,
             custom_prompt=custom_prompt,
         )
     # Default to Claude prompt for unknown agent types to maintain backward compatibility
@@ -48,6 +125,7 @@ def generate_worker_prompt(
         name=name,
         use_worktree=use_worktree,
         bead=bead,
+        project_path=project_path,
         custom_prompt=custom_prompt,
     )
 
@@ -57,6 +135,7 @@ def _generate_claude_worker_prompt(
     name: str,
     use_worktree: bool = False,
     bead: Optional[str] = None,
+    project_path: Optional[str] = None,
     custom_prompt: Optional[str] = None,
 ) -> str:
     """Generate the pre-prompt for a Claude Code worker session.
@@ -70,31 +149,31 @@ def _generate_claude_worker_prompt(
         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
+        bead: Optional issue tracker ID
+        project_path: Optional project path for issue tracker detection
         custom_prompt: Optional additional instructions
 
     Returns:
         Formatted pre-prompt for Claude worker
     """
+    # Detect issue tracker backend so we can use the right commands.
+    tracker_backend = _resolve_issue_tracker_backend(project_path)
+
     # Build optional sections with dynamic numbering
     next_step = 4
     extra_sections = ""
 
-    # Beads section (if bead provided)
+    # Issue tracker section (if issue ID provided)
     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
+        tracker_section, show_cmd = _build_tracker_workflow_section(
+            issue_id=bead,
+            backend=tracker_backend,
+            step_number=next_step,
+        )
+        extra_sections += tracker_section
         next_step += 1
 
-    # Commit section (if worktree but beads section didn't already cover commit)
+    # Commit section (if worktree but issue tracker 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
@@ -107,9 +186,12 @@ def _generate_claude_worker_prompt(
     # Closing/assignment section - 4 cases based on bead and custom_prompt
     if bead and custom_prompt:
         # Case 2: bead + custom instructions
+        show_hint = (
+            f"Use `{show_cmd}` for details." if show_cmd else "Use your issue tracker for details."
+        )
         closing = f"""=== YOUR ASSIGNMENT ===
 
-The coordinator assigned you `{bead}` (use `bd show {bead}` for details) and included
+The coordinator assigned you `{bead}` ({show_hint}) and included
 the following instructions:
 
 {custom_prompt}
@@ -117,9 +199,12 @@ the following instructions:
 Get to work!"""
     elif bead:
         # Case 1: bead only
+        show_hint = (
+            f"Use `{show_cmd}` for details." if show_cmd else "Use your issue tracker for details."
+        )
         closing = f"""=== YOUR ASSIGNMENT ===
 
-Your assignment is `{bead}`. Use `bd show {bead}` for details. Get to work!"""
+Your assignment is `{bead}`. {show_hint} Get to work!"""
     elif custom_prompt:
         # Case 3: custom instructions only
         closing = f"""=== YOUR ASSIGNMENT ===
@@ -161,6 +246,7 @@ def _generate_codex_worker_prompt(
     name: str,
     use_worktree: bool = False,
     bead: Optional[str] = None,
+    project_path: Optional[str] = None,
     custom_prompt: Optional[str] = None,
 ) -> str:
     """Generate the pre-prompt for an OpenAI Codex worker session.
@@ -174,31 +260,31 @@ def _generate_codex_worker_prompt(
         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
+        bead: Optional issue tracker ID
+        project_path: Optional project path for issue tracker detection
         custom_prompt: Optional additional instructions
 
     Returns:
         Formatted pre-prompt for Codex worker
     """
+    # Detect issue tracker backend so we can use the right commands.
+    tracker_backend = _resolve_issue_tracker_backend(project_path)
+
     # Build optional sections with dynamic numbering
     next_step = 4
     extra_sections = ""
 
-    # Beads section (if bead provided) - same workflow as Claude
+    # Issue tracker section (if issue ID 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
+        tracker_section, show_cmd = _build_tracker_workflow_section(
+            issue_id=bead,
+            backend=tracker_backend,
+            step_number=next_step,
+        )
+        extra_sections += tracker_section
         next_step += 1
 
-    # Commit section (if worktree but beads section didn't already cover commit)
+    # Commit section (if worktree but issue tracker 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
@@ -212,7 +298,7 @@ def _generate_codex_worker_prompt(
     if bead and custom_prompt:
         closing = f"""=== YOUR ASSIGNMENT ===
 
-The coordinator assigned you `{bead}` (use `bd show {bead}` for details) and included
+The coordinator assigned you `{bead}` ({f"Use `{show_cmd}` for details." if show_cmd else "Use your issue tracker for details."}) and included
 the following instructions:
 
 {custom_prompt}
@@ -221,7 +307,7 @@ Get to work!"""
     elif bead:
         closing = f"""=== YOUR ASSIGNMENT ===
 
-Your assignment is `{bead}`. Use `bd show {bead}` for details. Get to work!"""
+Your assignment is `{bead}`. {f"Use `{show_cmd}` for details." if show_cmd else "Use your issue tracker for details."} Get to work!"""
     elif custom_prompt:
         closing = f"""=== YOUR ASSIGNMENT ===
 
@@ -270,7 +356,7 @@ def get_coordinator_guidance(
         worker_summaries: List of dicts with keys:
             - name: Worker name
             - agent_type: Agent type ("claude" or "codex")
-            - bead: Optional bead ID
+            - bead: Optional issue tracker ID
             - custom_prompt: Optional custom instructions (truncated for display)
             - awaiting_task: True if worker has no bead and no prompt
 
@@ -309,7 +395,7 @@ def get_coordinator_guidance(
         elif bead:
             worker_lines.append(
                 f"- **{name}**{type_indicator}: `{bead}` "
-                "(beads workflow: mark in_progress -> implement -> close -> commit)"
+                "(issue tracker workflow: mark in_progress -> implement -> close -> commit)"
             )
         elif custom_prompt:
             short_prompt = (

{claude_team_mcp-0.5.0.dist-info → claude_team_mcp-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-team-mcp
-Version: 0.5.0
+Version: 0.6.0
 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
@@ -192,7 +192,7 @@ export CLAUDE_TEAM_CODEX_COMMAND="happy codex"
 | Tool | Description |
 |------|-------------|
 | `list_worktrees` | List git worktrees created by claude-team for a repository |
-| `bd_help` | Get a quick reference guide for using Beads issue tracking |
+| `bd_help` | Beads quick reference (use `pb help` for Pebbles projects) |
 
 ### Worker Identification
 
@@ -214,7 +214,6 @@ Arguments:
   skip_permissions: bool       - If True, start Claude with --dangerously-skip-permissions
   custom_names: list[str]      - Override automatic themed name selection
   custom_prompt: str           - Custom prompt instead of standard worker pre-prompt
-  include_beads_instructions: bool - Append beads guidance to custom prompt (default: True)
   use_worktrees: bool          - Create isolated git worktree for each worker
 
 Returns:
@@ -269,6 +268,20 @@ make install-commands
 | `/merge-worker` | Directly merge a worker's branch back to parent (for internal changes) |
 | `/pr-worker` | Create a pull request from a worker's branch |
 | `/team-summary` | Generate end-of-session summary of all worker activity |
+
+## Issue Tracker Support
+
+`claude-team` supports both Pebbles (`pb`) and Beads (`bd --no-db`).
+The tracker is auto-detected by marker directories in the project root:
+
+- `.pebbles` → Pebbles
+- `.beads` → Beads
+
+If both markers exist, Pebbles is selected by default. Worker prompts and
+coordination guidance use the detected tracker commands. For quick references:
+
+- Pebbles: `pb help`
+- Beads: `bd_help` tool
 | `/cleanup-worktrees` | Remove worktrees for merged branches |
 
 ## Usage Patterns

{claude_team_mcp-0.5.0.dist-info → claude_team_mcp-0.6.0.dist-info}/RECORD

@@ -10,33 +10,34 @@ claude_team_mcp/registry.py,sha256=y14ggF7qCia-xYYWJZhTsUAnBn5fFEkS7LspfEwhGQI,1
 claude_team_mcp/server.py,sha256=oOYWVJo0-P0izs1wyxeouK1MJP16-P5djRZH8trSrqM,12726
 claude_team_mcp/session_state.py,sha256=OcViByS05afdiCrBNRLR9qKrAn77H-2ALTe7yHfUUDs,34837
 claude_team_mcp/subprocess_cache.py,sha256=6Q1NIMn2X5_75S4s_a9iPBka-UCz6RW0EMxPSPEaLxo,3612
-claude_team_mcp/worker_prompt.py,sha256=Cz6yByWKVLg74_Y4DiwfO1oUel0-gkHvC8RK7h1JwzM,12594
+claude_team_mcp/worker_prompt.py,sha256=z69Dxo1kF6_JpJnxCL72T69J-J48fglOIevCiayRlmI,15740
 claude_team_mcp/worktree.py,sha256=s5X4mePVb4AlPzYsTklLGKgLD-4GJX1iokpsF6WwrdU,17015
 claude_team_mcp/cli_backends/__init__.py,sha256=9lpklc5lGWn-AdHoVqFMHau3UgzsN276grC1istHI2k,1038
 claude_team_mcp/cli_backends/base.py,sha256=dArm2Yqjzs3smN0JpSGR79e9I_kQYJFgQ8gYpNrmS-o,3923
 claude_team_mcp/cli_backends/claude.py,sha256=5axMph_IX-wX-DMulq0B_xQ3mVbhlwZjIi_WqjQwyL4,3268
-claude_team_mcp/cli_backends/codex.py,sha256=P-pj7vBJeVQTt12UdOSw9RQlRmvP4bnYNPY0kleX91I,3404
+claude_team_mcp/cli_backends/codex.py,sha256=NaBCCj1ed076cHTG44Ob1TpscwcdM3WATEqnq42kBIU,3284
+claude_team_mcp/issue_tracker/__init__.py,sha256=JYcVEdXkqDKXd9BAUoz3emYyZ9bvVRsuTB7Vxfw3jhU,3792
 claude_team_mcp/schemas/__init__.py,sha256=IingbdgdQx9C0ZLBOhZ-doqIJRbO7aeAQjuCHMuVA84,99
 claude_team_mcp/schemas/codex.py,sha256=KwUkTmD70kQLZvzl366tHAsuwKbtsk86ySTOW6b9wDk,5949
-claude_team_mcp/tools/__init__.py,sha256=_s6RJPIpzpm3eWr6stZdkvvDCISCz__tbc5MHgVl6tA,1484
+claude_team_mcp/tools/__init__.py,sha256=qILDACyNju45dX19QOmtCnVlRWCfGx7y96h5aJ_J5OU,1506
 claude_team_mcp/tools/adopt_worker.py,sha256=oWSamOzOqnLPWADWb4tk7qSPHroxIhQXkFDnhy_EOkw,4560
 claude_team_mcp/tools/annotate_worker.py,sha256=mBo4YMaaaNQxQBduYK1DPA-Ioift-ZQ9tYlBM6S15t8,1639
-claude_team_mcp/tools/bd_help.py,sha256=kA3DnMGG48ruIt7L-tcUPfevy_l-Yy22pa3I20DZU2A,1402
 claude_team_mcp/tools/check_idle_workers.py,sha256=IjDNDeal9M7lTONWjKZrt8bXu7O277ossHz_2oyLRcY,3374
 claude_team_mcp/tools/close_workers.py,sha256=glVUNM5Q32z8DyzvNKpxExN9pDR16rzjuyzEjI-eInM,6633
 claude_team_mcp/tools/discover_workers.py,sha256=PkdnURZBex_y0kFx_pv-EgWrEbtQtsg5TjqycNs7BJI,5437
 claude_team_mcp/tools/examine_worker.py,sha256=7Nd3EOdsGVDjMJ8ov9NhmcrjN8K9IE4i_noXHOP1uI8,1620
+claude_team_mcp/tools/issue_tracker_help.py,sha256=KxgjFhXp3NCUDjqTl3UnIiFV-Y5DM80C1EoZXfA82QM,1668
 claude_team_mcp/tools/list_workers.py,sha256=6cvsgHOYtakkSgoZdYez4VEQ3I8aWAKaGWhfiZyPf2c,2390
 claude_team_mcp/tools/list_worktrees.py,sha256=_EIwpwoCMLaQh4dHws-jO53MS-E-L7hC7oPT7xC26lw,3665
-claude_team_mcp/tools/message_workers.py,sha256=L9d_EE_qLqJ6Uiebux72LJ5X8wFFO3Tyyb4RFvJ6ofA,11868
+claude_team_mcp/tools/message_workers.py,sha256=02XAE2EsJkkcZdmjaxQRiyUhAFTN4uB8kYzSkOwbxk0,12220
 claude_team_mcp/tools/read_worker_logs.py,sha256=9gccM6MSaoxu97Xjsk7nUalLEU8XHV7r3SKggBRpNww,5913
-claude_team_mcp/tools/spawn_workers.py,sha256=4vvoy_jwLPWNPuVZ-r_E6JeIL0aV46H77SVXmzTJSHo,28280
+claude_team_mcp/tools/spawn_workers.py,sha256=A08erciMM-q0TCPaFeVn6KvtVerIWdlbm6bH7P_E5G8,32366
 claude_team_mcp/tools/wait_idle_workers.py,sha256=ITnhBiJYCgkz-DGJaYouAyTDh6cPIL_9RrptqC_xHu0,5232
-claude_team_mcp/utils/__init__.py,sha256=_O-de711DxfMdjCAHHoifyOtzdllciE9FFV-tZ5m2Y8,444
-claude_team_mcp/utils/constants.py,sha256=R5BRg50hAkbsZFNRZye7O8bCqsCkzMGz-re_PK14USE,2465
+claude_team_mcp/utils/__init__.py,sha256=Jyc-N1RXZnMdXLjSgRBB2ih04v-h0woUzZcVYYfc7wQ,647
+claude_team_mcp/utils/constants.py,sha256=FGDHeo0reZ89365fuXJGIl2Y5MFQAoKfWtmYr7UQzhQ,5815
 claude_team_mcp/utils/errors.py,sha256=9uPFHp7UJYB5t3p7P_5Sh3PVpYh4_vj_RLzX5GcJPEU,2738
-claude_team_mcp/utils/worktree_detection.py,sha256=NfEK8c_toFiz8dqF2ht1FJzW9a9VstVm7Y5SNXvwAD8,2564
-claude_team_mcp-0.5.0.dist-info/METADATA,sha256=_hmIf5fWm2Zm-LVyuYqkoiIayPbQlb0bMPT_kCl7aJo,15697
-claude_team_mcp-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-claude_team_mcp-0.5.0.dist-info/entry_points.txt,sha256=cmk5dmK50RVquExT-k_J72akl3qKIerPpVqfit7kQtQ,53
-claude_team_mcp-0.5.0.dist-info/RECORD,,
+claude_team_mcp/utils/worktree_detection.py,sha256=oMGcb7p1jvr7qWs06sxUMTAV8jRialcVqziCTCdW7XU,3251
+claude_team_mcp-0.6.0.dist-info/METADATA,sha256=PQ457DQFuTdb_Ua5NGvIEVl0cYKStLobxAM8DHxzidw,16020
+claude_team_mcp-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+claude_team_mcp-0.6.0.dist-info/entry_points.txt,sha256=cmk5dmK50RVquExT-k_J72akl3qKIerPpVqfit7kQtQ,53
+claude_team_mcp-0.6.0.dist-info/RECORD,,

claude_team_mcp/tools/bd_help.py

@@ -1,42 +0,0 @@
-"""
-Beads help tool.
-
-Provides bd_help for quick reference on beads issue tracking.
-"""
-
-from mcp.server.fastmcp import FastMCP
-
-from ..utils import BEADS_HELP_TEXT
-
-
-def register_tools(mcp: FastMCP) -> None:
-    """Register bd_help tool on the MCP server."""
-
-    @mcp.tool()
-    async def bd_help() -> dict:
-        """
-        Get a quick reference guide for using Beads issue tracking.
-
-        Returns condensed documentation on beads commands, workflow patterns,
-        and best practices for worker sessions. Call this tool when you need
-        guidance on tracking progress, adding comments, or managing issues.
-
-        Returns:
-            Dict with help text and key command examples
-        """
-        return {
-            "help": BEADS_HELP_TEXT,
-            "quick_commands": {
-                "list_issues": "bd list",
-                "show_ready": "bd ready",
-                "show_issue": "bd show <issue-id>",
-                "start_work": "bd update <id> --status in_progress",
-                "add_comment": 'bd comment <id> "progress message"',
-                "close_issue": "bd close <id>",
-                "search": "bd search <query>",
-            },
-            "worker_tip": (
-                "As a worker, add comments to track progress rather than closing issues. "
-                "The coordinator will close issues after reviewing your work."
-            ),
-        }