bumblebee-cli 0.1.1 → 0.3.0

package/python/bb_cli/commands/agent.py

@@ -1,1030 +0,0 @@
-import json
-import os
-import shutil
-import subprocess
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-
-import typer
-from rich import print as rprint
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.table import Table
-
-from ..api_client import api_get, api_post, api_put
-from ..config import CONFIG_DIR, get_api_url, get_current_project, get_project_path, get_token
-from .item import _resolve_item
-
-app = typer.Typer(help="Agent session management")
-
-WORKTREES_DIR = CONFIG_DIR / "worktrees"
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _require_project() -> str:
-    slug = get_current_project()
-    if not slug:
-        rprint("[red]No project selected. Run [bold]bb project switch <slug>[/bold] first.[/red]")
-        raise typer.Exit(1)
-    return slug
-
-
-def _require_project_path(slug: str) -> str:
-    path = get_project_path(slug)
-    if not path:
-        rprint("[red]No source code directory linked to this project.[/red]")
-        rprint("[yellow]Run [bold]bb project link <path>[/bold] to set it.[/yellow]")
-        raise typer.Exit(1)
-    if not Path(path).is_dir():
-        rprint(f"[red]Linked directory not found: {path}[/red]")
-        raise typer.Exit(1)
-    return path
-
-
-def _read_knowledge(project_path: str) -> str:
-    """Read knowledge base files from the project directory."""
-    candidates = [
-        "CLAUDE.md",
-        "docs/knowledge.md",
-        ".claude/lessons-learned.md",
-    ]
-    parts = []
-    for rel in candidates:
-        fp = Path(project_path) / rel
-        if fp.exists():
-            try:
-                text = fp.read_text(encoding="utf-8", errors="replace").strip()
-                if text:
-                    parts.append(f"### {rel}\n\n{text}")
-            except Exception:
-                pass
-    return "\n\n---\n\n".join(parts)
-
-
-def _get_item_comments(item_id: str) -> list[dict]:
-    try:
-        return api_get(f"/api/work-items/{item_id}/comments")
-    except Exception:
-        return []
-
-
-def _claude_env() -> dict[str, str]:
-    """Return env dict with CLAUDECODE unset so we can spawn a new Claude session."""
-    env = os.environ.copy()
-    env.pop("CLAUDECODE", None)
-    return env
-
-
-def _format_comments_context(comments: list[dict]) -> str:
-    if not comments:
-        return ""
-    parts = ["## Previous Comments / Progress"]
-    for c in comments:
-        author = c.get("author", "unknown")
-        ctype = c.get("type", "discussion")
-        tag = f" [{ctype}]" if ctype != "discussion" else ""
-        body = c.get("body", "")
-        created = c.get("created_at", "")
-        parts.append(f"\n### {author}{tag} -- {created}\n{body}")
-    return "\n".join(parts)
-
-
-# ---------------------------------------------------------------------------
-# Prompt builders
-# ---------------------------------------------------------------------------
-
-
-def _build_suggest_prompt(item: dict, knowledge: str, comments_ctx: str) -> str:
-    """Phase 1 prompt -- analyse only, no code changes."""
-    key = item.get("key") or f"#{item['number']}"
-    parts = [
-        f"You are analysing {item['type']} {key}: {item['title']}",
-        "",
-        f"Type: {item['type']}  |  Priority: {item['priority']}  |  Status: {item['status']}",
-    ]
-    if item.get("description"):
-        parts.extend(["", "## Description", item["description"]])
-    if item.get("acceptance_criteria"):
-        parts.extend(["", "## Acceptance Criteria", item["acceptance_criteria"]])
-    if item.get("plan"):
-        parts.extend(["", "## Existing Plan", item["plan"]])
-    if comments_ctx:
-        parts.extend(["", comments_ctx])
-    if knowledge:
-        parts.extend(["", "## Project Knowledge Base", knowledge])
-    parts.extend([
-        "",
-        "## Your Task",
-        "",
-        "Analyse this work item **and** the project source code. Return a Markdown plan:",
-        "",
-        "1. **Root Cause / Analysis** -- what needs to change and why",
-        "2. **Files to Modify** -- list every file with a short description of the change",
-        "3. **Implementation Steps** -- numbered, concrete steps",
-        "4. **Testing Strategy** -- how to verify the changes",
-        "5. **Risks & Considerations** -- edge cases, breaking changes",
-        "",
-        "IMPORTANT: Do NOT modify any files. Only analyse and produce the plan.",
-    ])
-    return "\n".join(parts)
-
-
-def _build_execute_prompt(item: dict, knowledge: str, comments_ctx: str) -> str:
-    """Phase 2 prompt -- implement the changes."""
-    key = item.get("key") or f"#{item['number']}"
-    parts = [
-        f"You are implementing {item['type']} {key}: {item['title']}",
-        "",
-        f"Type: {item['type']}  |  Priority: {item['priority']}",
-    ]
-    if item.get("description"):
-        parts.extend(["", "## Description", item["description"]])
-    if item.get("acceptance_criteria"):
-        parts.extend(["", "## Acceptance Criteria", item["acceptance_criteria"]])
-    if item.get("plan"):
-        parts.extend(["", "## Implementation Plan", item["plan"]])
-    if comments_ctx:
-        parts.extend(["", comments_ctx])
-    if knowledge:
-        parts.extend(["", "## Project Knowledge Base", knowledge])
-    parts.extend([
-        "",
-        "## Instructions",
-        "",
-        "Implement the changes described in the plan / comments above.",
-        "",
-        "1. Follow the project's existing coding conventions and patterns",
-        "2. Work through changes one file at a time",
-        "3. Run existing tests after your changes and fix any failures",
-        "4. Add new tests where appropriate",
-        "5. Commit your work with a clear, descriptive commit message",
-        "6. If you hit a blocker, document it clearly so the next run can continue",
-    ])
-    return "\n".join(parts)
-
-
-# ---------------------------------------------------------------------------
-# Git worktree utilities
-# ---------------------------------------------------------------------------
-
-
-def _worktree_path(slug: str, item_number: int) -> Path:
-    return WORKTREES_DIR / slug / f"item-{item_number}"
-
-
-def _create_worktree(project_path: str, slug: str, item_number: int) -> tuple[str, str]:
-    """Create (or reuse) a git worktree. Returns (worktree_path, branch_name)."""
-    branch = f"bb/item-{item_number}"
-    wt = _worktree_path(slug, item_number)
-    wt.parent.mkdir(parents=True, exist_ok=True)
-
-    # Already exists and valid?
-    if wt.exists():
-        probe = subprocess.run(
-            ["git", "worktree", "list", "--porcelain"],
-            cwd=project_path, capture_output=True, text=True,
-        )
-        # Normalise to forward-slash for reliable comparison
-        wt_norm = str(wt).replace("\\", "/")
-        if any(wt_norm in ln.replace("\\", "/") for ln in probe.stdout.splitlines()):
-            return str(wt), branch
-        # Stale -- clean up
-        subprocess.run(["git", "worktree", "prune"], cwd=project_path, capture_output=True)
-        if wt.exists():
-            shutil.rmtree(wt)
-
-    # Does branch already exist?
-    check = subprocess.run(
-        ["git", "rev-parse", "--verify", branch],
-        cwd=project_path, capture_output=True, text=True,
-    )
-
-    if check.returncode == 0:
-        subprocess.run(
-            ["git", "worktree", "add", str(wt), branch],
-            cwd=project_path, check=True, capture_output=True, text=True,
-        )
-    else:
-        subprocess.run(
-            ["git", "worktree", "add", "-b", branch, str(wt)],
-            cwd=project_path, check=True, capture_output=True, text=True,
-        )
-
-    return str(wt), branch
-
-
-def _remove_worktree(project_path: str, wt_path: str):
-    subprocess.run(
-        ["git", "worktree", "remove", "--force", wt_path],
-        cwd=project_path, capture_output=True,
-    )
-    subprocess.run(["git", "worktree", "prune"], cwd=project_path, capture_output=True)
-
-
-# ---------------------------------------------------------------------------
-# Batch internal helpers (thread-safe, no rich print inside workers)
-# ---------------------------------------------------------------------------
-
-
-def _suggest_one(slug: str, project_path: str, id_or_number: str) -> dict:
-    """Run suggest for a single item. Thread-safe — returns result dict."""
-    try:
-        item = _resolve_item(slug, id_or_number)
-    except Exception as e:
-        return {"key": id_or_number, "status": "failed", "error": f"Resolve failed: {e}"}
-
-    item_id = item["id"]
-    key = item.get("key") or f"#{item['number']}"
-
-    knowledge = _read_knowledge(project_path)
-    comments = _get_item_comments(item_id)
-    comments_ctx = _format_comments_context(comments)
-    prompt = _build_suggest_prompt(item, knowledge, comments_ctx)
-
-    try:
-        result = subprocess.run(
-            ["claude", "-p", prompt, "--output-format", "text"],
-            cwd=project_path,
-            capture_output=True,
-            text=True,
-            timeout=600,
-            env=_claude_env(),
-        )
-    except FileNotFoundError:
-        return {"key": key, "status": "failed", "error": "'claude' CLI not found"}
-    except subprocess.TimeoutExpired:
-        return {"key": key, "status": "failed", "error": "Timed out (10 min)"}
-
-    if result.returncode != 0:
-        return {"key": key, "status": "failed", "error": result.stderr[:200]}
-
-    suggestion = result.stdout.strip()
-    if not suggestion:
-        return {"key": key, "status": "failed", "error": "Empty response"}
-
-    # Post comment
-    api_post(f"/api/work-items/{item_id}/comments", json={
-        "body": suggestion,
-        "author": "bb-agent",
-        "type": "proposal",
-    })
-
-    # Advance status
-    if item["status"] == "open":
-        api_put(f"/api/work-items/{item_id}", json={"status": "confirmed"})
-
-    return {"key": key, "status": "ok", "suggestion": suggestion[:200]}
-
-
-def _execute_one(slug: str, project_path: str, id_or_number: str) -> dict:
-    """Run execute for a single item in its own worktree. Thread-safe."""
-    try:
-        item = _resolve_item(slug, id_or_number)
-    except Exception as e:
-        return {"key": id_or_number, "status": "failed", "error": f"Resolve failed: {e}"}
-
-    item_id = item["id"]
-    item_number = item["number"]
-    key = item.get("key") or f"#{item_number}"
-    knowledge = _read_knowledge(project_path)
-    comments = _get_item_comments(item_id)
-    comments_ctx = _format_comments_context(comments)
-    prompt = _build_execute_prompt(item, knowledge, comments_ctx)
-
-    # Create worktree
-    try:
-        work_dir, branch_name = _create_worktree(project_path, slug, item_number)
-    except subprocess.CalledProcessError as e:
-        return {"key": key, "status": "failed", "error": f"Worktree failed: {e.stderr or e}"}
-
-    # Agent session
-    try:
-        session = api_post(
-            "/api/agent-sessions/start",
-            json={"work_item_id": item_id, "origin": "cli"},
-            params={"project_slug": slug},
-        )
-        session_id = session["id"]
-    except Exception as e:
-        return {"key": key, "status": "failed", "error": f"Session start failed: {e}", "branch": branch_name}
-
-    # Status -> in_progress
-    if item["status"] in ("open", "confirmed", "approved"):
-        api_put(f"/api/work-items/{item_id}", json={"status": "in_progress"})
-
-    # MCP config
-    api_url = get_api_url()
-    token = get_token()
-    mcp_cfg = json.dumps({
-        "mcpServers": {
-            "bumblebee": {
-                "url": f"{api_url}/mcp",
-                "headers": {"Authorization": f"Bearer {token}"} if token else {},
-            }
-        }
-    })
-
-    try:
-        proc = subprocess.Popen(
-            [
-                "claude",
-                "--output-format", "stream-json",
-                "--verbose",
-                "--permission-mode", "bypassPermissions",
-                "--mcp-config", "-",
-                "-p", prompt,
-            ],
-            cwd=work_dir,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            env=_claude_env(),
-        )
-
-        proc.stdin.write(mcp_cfg)
-        proc.stdin.close()
-
-        text_blocks: list[str] = []
-        for line in proc.stdout:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                payload = json.loads(line)
-                if payload.get("type") == "assistant":
-                    for block in payload.get("content", []):
-                        if block.get("type") == "text":
-                            text_blocks.append(block["text"])
-                try:
-                    api_post(f"/api/agent-sessions/{session_id}/relay", json=payload)
-                except Exception:
-                    pass
-            except json.JSONDecodeError:
-                pass
-
-        proc.wait()
-
-        # Post completion comment
-        tail = "\n\n".join(text_blocks[-3:]) if text_blocks else "No text output captured."
-        body_lines = [
-            "## Agent Execution Report\n",
-            f"**Branch**: `{branch_name}`\n",
-            f"**Exit code**: `{proc.returncode}`\n",
-            f"\n### Output (last messages)\n\n{tail}",
-        ]
-        api_post(f"/api/work-items/{item_id}/comments", json={
-            "body": "\n".join(body_lines),
-            "author": "bb-agent",
-            "type": "agent_output",
-        })
-
-        if proc.returncode == 0:
-            api_put(f"/api/work-items/{item_id}", json={"status": "in_review"})
-            return {"key": key, "status": "ok", "branch": branch_name, "worktree": work_dir}
-        else:
-            return {"key": key, "status": "failed", "error": f"Exit code {proc.returncode}", "branch": branch_name}
-
-    except FileNotFoundError:
-        return {"key": key, "status": "failed", "error": "'claude' CLI not found"}
-
-
-# ---------------------------------------------------------------------------
-# Commands
-# ---------------------------------------------------------------------------
-
-
-@app.command()
-def suggest(
-    id_or_number: str = typer.Argument(..., help="Work item ID, number, or KEY-number to analyse"),
-):
-    """Phase 1: Analyse a work item and post a solution plan as a comment."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    rprint(f"[cyan]Fetching work item {id_or_number}...[/cyan]")
-    item = _resolve_item(slug, id_or_number)
-    item_id = item["id"]
-    knowledge = _read_knowledge(project_path)
-    comments = _get_item_comments(item_id)
-    comments_ctx = _format_comments_context(comments)
-    prompt = _build_suggest_prompt(item, knowledge, comments_ctx)
-
-    rprint(f"[cyan]Running Claude Code analysis in {project_path}...[/cyan]")
-
-    try:
-        result = subprocess.run(
-            ["claude", "-p", prompt, "--output-format", "text"],
-            cwd=project_path,
-            capture_output=True,
-            text=True,
-            timeout=600,
-            env=_claude_env(),
-        )
-
-        if result.returncode != 0:
-            rprint(f"[red]Claude analysis failed:[/red]\n{result.stderr}")
-            raise typer.Exit(1)
-
-        suggestion = result.stdout.strip()
-        if not suggestion:
-            rprint("[red]Claude returned an empty response.[/red]")
-            raise typer.Exit(1)
-
-        rprint()
-        key = item.get("key") or f"#{item['number']}"
-        rprint(Panel(
-            Markdown(suggestion),
-            title=f"Suggested Solution -- {key}",
-            border_style="green",
-        ))
-
-        # Post as agent comment
-        api_post(f"/api/work-items/{item_id}/comments", json={
-            "body": suggestion,
-            "author": "bb-agent",
-            "type": "proposal",
-        })
-        rprint("[green]Suggestion posted as comment on the work item.[/green]")
-
-        # Advance status open -> confirmed
-        if item["status"] == "open":
-            api_put(f"/api/work-items/{item_id}", json={"status": "confirmed"})
-            rprint("[dim]Status -> confirmed[/dim]")
-
-    except FileNotFoundError:
-        rprint("[red]'claude' CLI not found. Install Claude Code first.[/red]")
-        raise typer.Exit(1)
-    except subprocess.TimeoutExpired:
-        rprint("[red]Analysis timed out (10 min limit).[/red]")
-        raise typer.Exit(1)
-
-
-@app.command()
-def execute(
-    id_or_number: str = typer.Argument(..., help="Work item ID, number, or KEY-number to implement"),
-    no_worktree: bool = typer.Option(False, "--no-worktree", help="Work in main directory (skip worktree)"),
-    cleanup: bool = typer.Option(False, "--cleanup", help="Remove worktree after completion"),
-):
-    """Phase 2: Create a worktree and implement the work item with Claude Code."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    # Context
-    item = _resolve_item(slug, id_or_number)
-    item_id = item["id"]
-    item_number = item["number"]
-    knowledge = _read_knowledge(project_path)
-    comments = _get_item_comments(item_id)
-    comments_ctx = _format_comments_context(comments)
-    prompt = _build_execute_prompt(item, knowledge, comments_ctx)
-
-    # Worktree
-    work_dir = project_path
-    branch_name = None
-
-    if not no_worktree:
-        try:
-            key = item.get("key") or f"#{item_number}"
-            rprint(f"[cyan]Creating worktree for {key}...[/cyan]")
-            work_dir, branch_name = _create_worktree(project_path, slug, item_number)
-            rprint(f"[green]Worktree: {work_dir}[/green]")
-            rprint(f"[green]Branch:   {branch_name}[/green]")
-        except subprocess.CalledProcessError as e:
-            rprint(f"[red]Worktree failed: {e.stderr or e}[/red]")
-            rprint("[yellow]Falling back to main directory.[/yellow]")
-
-    # Agent session
-    session = api_post(
-        "/api/agent-sessions/start",
-        json={"work_item_id": item_id, "origin": "cli"},
-        params={"project_slug": slug},
-    )
-    session_id = session["id"]
-    rprint(f"[green]Session:  {session_id}[/green]")
-
-    # Status -> in_progress
-    if item["status"] in ("open", "confirmed", "approved"):
-        api_put(f"/api/work-items/{item_id}", json={"status": "in_progress"})
-        rprint("[dim]Status -> in_progress[/dim]")
-
-    # MCP config (Bumblebee tools for Claude)
-    api_url = get_api_url()
-    token = get_token()
-    mcp_cfg = json.dumps({
-        "mcpServers": {
-            "bumblebee": {
-                "url": f"{api_url}/mcp",
-                "headers": {"Authorization": f"Bearer {token}"} if token else {},
-            }
-        }
-    })
-
-    rprint(f"\n[cyan]Spawning Claude Code agent in {work_dir}...[/cyan]\n")
-
-    try:
-        proc = subprocess.Popen(
-            [
-                "claude",
-                "--output-format", "stream-json",
-                "--verbose",
-                "--permission-mode", "bypassPermissions",
-                "--mcp-config", "-",
-                "-p", prompt,
-            ],
-            cwd=work_dir,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            env=_claude_env(),
-        )
-
-        proc.stdin.write(mcp_cfg)
-        proc.stdin.close()
-
-        # Stream output -> terminal + API relay
-        text_blocks: list[str] = []
-        for line in proc.stdout:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                payload = json.loads(line)
-                if payload.get("type") == "assistant":
-                    for block in payload.get("content", []):
-                        if block.get("type") == "text":
-                            rprint(block["text"])
-                            text_blocks.append(block["text"])
-                try:
-                    api_post(f"/api/agent-sessions/{session_id}/relay", json=payload)
-                except Exception:
-                    pass
-            except json.JSONDecodeError:
-                rprint(f"[dim]{line}[/dim]")
-
-        proc.wait()
-
-        # Completion comment
-        tail = "\n\n".join(text_blocks[-3:]) if text_blocks else "No text output captured."
-        body_lines = ["## Agent Execution Report\n"]
-        if branch_name:
-            body_lines.append(f"**Branch**: `{branch_name}`\n")
-        body_lines.append(f"**Exit code**: `{proc.returncode}`\n")
-        body_lines.append(f"\n### Output (last messages)\n\n{tail}")
-
-        api_post(f"/api/work-items/{item_id}/comments", json={
-            "body": "\n".join(body_lines),
-            "author": "bb-agent",
-            "type": "agent_output",
-        })
-
-        if proc.returncode == 0:
-            rprint("\n[green]Agent completed successfully.[/green]")
-            api_put(f"/api/work-items/{item_id}", json={"status": "in_review"})
-            rprint("[dim]Status -> in_review[/dim]")
-        else:
-            rprint(f"\n[yellow]Agent exited with code {proc.returncode}.[/yellow]")
-
-        # Worktree post-run
-        if branch_name and work_dir != project_path:
-            if cleanup:
-                _remove_worktree(project_path, work_dir)
-                rprint("[dim]Worktree removed.[/dim]")
-            else:
-                rprint(f"\n[dim]Worktree: {work_dir}[/dim]")
-                rprint(f"[dim]Merge:    cd {project_path} && git merge {branch_name}[/dim]")
-                rprint(f"[dim]Cleanup:  bb agent cleanup {item_number}[/dim]")
-
-    except FileNotFoundError:
-        rprint("[red]'claude' CLI not found. Install Claude Code first.[/red]")
-        raise typer.Exit(1)
-    except KeyboardInterrupt:
-        rprint("\n[yellow]Agent interrupted.[/yellow]")
-        api_post(f"/api/agent-sessions/{session_id}/abort")
-        api_post(f"/api/work-items/{item_id}/comments", json={
-            "body": "## Agent Interrupted\n\nManually stopped by user.",
-            "author": "bb-agent",
-            "type": "agent_output",
-        })
-
-
-@app.command()
-def run(
-    id_or_number: str = typer.Argument(..., help="Work item ID, number, or KEY-number"),
-    skip_suggest: bool = typer.Option(False, "--skip-suggest", help="Skip the analysis phase"),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Auto-confirm the suggestion"),
-    no_worktree: bool = typer.Option(False, "--no-worktree", help="Skip worktree creation"),
-):
-    """Full loop: analyse -> confirm -> implement."""
-    _require_project()
-
-    if not skip_suggest:
-        suggest(id_or_number)
-        if not yes:
-            rprint()
-            if not typer.confirm("Proceed with implementation?"):
-                rprint(f"[yellow]Aborted. Run [bold]bb agent execute {id_or_number}[/bold] when ready.[/yellow]")
-                raise typer.Exit()
-
-    execute(id_or_number, no_worktree=no_worktree, cleanup=False)
-
-
-@app.command(name="continue")
-def continue_work(
-    id_or_number: str = typer.Argument(..., help="Work item ID, number, or KEY-number to continue"),
-):
-    """Continue a previous agent run (reads prior comments for context)."""
-    execute(id_or_number, no_worktree=False, cleanup=False)
-
-
-@app.command(name="status")
-def agent_status():
-    """Show agent sessions for the current project."""
-    slug = _require_project()
-    sessions = api_get("/api/agent-sessions", params={"project_slug": slug})
-    if not sessions:
-        rprint("[dim]No agent sessions.[/dim]")
-        return
-    for s in sessions:
-        color = {"running": "yellow", "completed": "green", "failed": "red"}.get(
-            s["status"], "white"
-        )
-        rprint(
-            f"  [{color}]{s['status']:>10}[/{color}]  "
-            f"{s['id'][:8]}  item: {s.get('work_item_id', '--')}"
-        )
-
-
-@app.command()
-def abort(session_id: str = typer.Argument(...)):
-    """Abort a running agent session."""
-    api_post(f"/api/agent-sessions/{session_id}/abort")
-    rprint(f"[yellow]Session {session_id[:8]} aborted.[/yellow]")
-
-
-@app.command(name="cleanup")
-def cleanup_worktree(
-    item_number: int = typer.Argument(..., help="Work item number whose worktree to remove"),
-    delete_branch: bool = typer.Option(False, "--delete-branch", "-D", help="Also delete the git branch"),
-):
-    """Remove the worktree created for a work item."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    wt = _worktree_path(slug, item_number)
-    branch = f"bb/item-{item_number}"
-
-    if not wt.exists():
-        rprint(f"[yellow]No worktree found for item #{item_number}.[/yellow]")
-        raise typer.Exit()
-
-    _remove_worktree(project_path, str(wt))
-    rprint(f"[green]Worktree removed: {wt}[/green]")
-
-    if delete_branch:
-        subprocess.run(
-            ["git", "branch", "-D", branch],
-            cwd=project_path, capture_output=True,
-        )
-        rprint(f"[green]Branch deleted: {branch}[/green]")
-    else:
-        rprint(f"[dim]Branch '{branch}' kept. Delete with: git branch -D {branch}[/dim]")
-
-
-@app.command(name="worktrees")
-def list_worktrees():
-    """List active agent worktrees for the current project."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    result = subprocess.run(
-        ["git", "worktree", "list"],
-        cwd=project_path, capture_output=True, text=True,
-    )
-    if result.returncode != 0:
-        rprint("[red]Failed to list worktrees.[/red]")
-        raise typer.Exit(1)
-
-    lines = result.stdout.strip().splitlines()
-    bb_lines = [ln for ln in lines if "bb/item-" in ln]
-
-    if not bb_lines:
-        rprint("[dim]No agent worktrees.[/dim]")
-        return
-
-    rprint("[bold]Agent worktrees:[/bold]")
-    for ln in bb_lines:
-        rprint(f"  {ln}")
-
-
-# ---------------------------------------------------------------------------
-# Batch (parallel) commands
-# ---------------------------------------------------------------------------
-
-
-@app.command(name="batch-suggest")
-def batch_suggest(
-    items: list[str] = typer.Argument(..., help="Work item IDs/numbers to analyse (e.g. BD-2 BD-3 BD-4)"),
-    max_parallel: int = typer.Option(3, "--parallel", "-P", help="Max parallel Claude analyses"),
-):
-    """Analyse multiple work items in parallel. Each gets a proposal comment."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    rprint(f"[cyan]Suggesting {len(items)} items (max {max_parallel} parallel)...[/cyan]\n")
-
-    results: list[dict] = []
-    with ThreadPoolExecutor(max_workers=max_parallel) as pool:
-        futures = {
-            pool.submit(_suggest_one, slug, project_path, item): item
-            for item in items
-        }
-        for future in as_completed(futures):
-            item_ref = futures[future]
-            try:
-                r = future.result()
-                results.append(r)
-                color = "green" if r["status"] == "ok" else "red"
-                rprint(f"  [{color}]{r['key']:>8} -- {r['status']}[/{color}]"
-                       + (f" ({r.get('error', '')})" if r["status"] != "ok" else ""))
-            except Exception as e:
-                results.append({"key": item_ref, "status": "error", "error": str(e)})
-                rprint(f"  [red]{item_ref:>8} -- error: {e}[/red]")
-
-    ok = sum(1 for r in results if r["status"] == "ok")
-    rprint(f"\n[bold]Done: {ok}/{len(items)} succeeded.[/bold]")
-
-    if ok > 0:
-        rprint("\n[dim]Review suggestions, then run:[/dim]")
-        suggested = [r["key"] for r in results if r["status"] == "ok"]
-        rprint(f"[dim]  bb agent batch-execute {' '.join(suggested)}[/dim]")
-
-
-@app.command(name="batch-execute")
-def batch_execute(
-    items: list[str] = typer.Argument(..., help="Work item IDs/numbers to implement (e.g. BD-2 BD-3 BD-4)"),
-    max_parallel: int = typer.Option(2, "--parallel", "-P", help="Max parallel Claude agents"),
-):
-    """Implement multiple work items in parallel. Each gets its own git worktree."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    rprint(f"[cyan]Executing {len(items)} items (max {max_parallel} parallel, each in own worktree)...[/cyan]\n")
-
-    results: list[dict] = []
-    with ThreadPoolExecutor(max_workers=max_parallel) as pool:
-        futures = {
-            pool.submit(_execute_one, slug, project_path, item): item
-            for item in items
-        }
-        for future in as_completed(futures):
-            item_ref = futures[future]
-            try:
-                r = future.result()
-                results.append(r)
-                if r["status"] == "ok":
-                    rprint(f"  [green]{r['key']:>8} -- ok  branch: {r.get('branch', '?')}[/green]")
-                else:
-                    rprint(f"  [red]{r['key']:>8} -- {r.get('error', 'unknown error')}[/red]")
-            except Exception as e:
-                results.append({"key": item_ref, "status": "error", "error": str(e)})
-                rprint(f"  [red]{item_ref:>8} -- error: {e}[/red]")
-
-    ok = sum(1 for r in results if r["status"] == "ok")
-    rprint(f"\n[bold]Done: {ok}/{len(items)} succeeded.[/bold]")
-
-    branches = [r["branch"] for r in results if r.get("branch")]
-    if branches:
-        table = Table(title="Branches Created", show_header=True)
-        table.add_column("Item")
-        table.add_column("Branch")
-        table.add_column("Status")
-        for r in results:
-            if r.get("branch"):
-                color = "green" if r["status"] == "ok" else "red"
-                table.add_row(r["key"], r["branch"], f"[{color}]{r['status']}[/{color}]")
-        rprint(table)
-        rprint(f"\n[dim]Merge all with: bb agent merge --target release/dev[/dim]")
-
-
-@app.command(name="batch-run")
-def batch_run(
-    items: list[str] = typer.Argument(..., help="Work item IDs/numbers for full loop"),
-    max_parallel: int = typer.Option(2, "--parallel", "-P", help="Max parallel agents"),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Auto-confirm after suggest phase"),
-):
-    """Full loop for multiple items: suggest all -> review -> execute all."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    # Phase 1: parallel suggest
-    rprint("[bold cyan]Phase 1: Analysing...[/bold cyan]\n")
-    suggest_results: list[dict] = []
-    with ThreadPoolExecutor(max_workers=max_parallel) as pool:
-        futures = {
-            pool.submit(_suggest_one, slug, project_path, item): item
-            for item in items
-        }
-        for future in as_completed(futures):
-            item_ref = futures[future]
-            try:
-                r = future.result()
-                suggest_results.append(r)
-                color = "green" if r["status"] == "ok" else "red"
-                rprint(f"  [{color}]{r['key']:>8} -- {r['status']}[/{color}]")
-            except Exception as e:
-                suggest_results.append({"key": item_ref, "status": "error"})
-                rprint(f"  [red]{item_ref:>8} -- error: {e}[/red]")
-
-    succeeded = [r["key"] for r in suggest_results if r["status"] == "ok"]
-    if not succeeded:
-        rprint("\n[red]No items analysed successfully. Aborting.[/red]")
-        raise typer.Exit(1)
-
-    rprint(f"\n[bold]Suggest done: {len(succeeded)}/{len(items)} ready.[/bold]")
-
-    # Confirmation gate
-    if not yes:
-        rprint("\n[yellow]Review the suggestions in the web UI or via 'bb comment list <item>'.[/yellow]")
-        if not typer.confirm(f"Proceed to execute {len(succeeded)} items?"):
-            rprint("[yellow]Aborted. Run 'bb agent batch-execute' when ready.[/yellow]")
-            raise typer.Exit()
-
-    # Phase 2: parallel execute
-    rprint("\n[bold cyan]Phase 2: Implementing...[/bold cyan]\n")
-    exec_results: list[dict] = []
-    with ThreadPoolExecutor(max_workers=max_parallel) as pool:
-        futures = {
-            pool.submit(_execute_one, slug, project_path, item): item
-            for item in succeeded
-        }
-        for future in as_completed(futures):
-            item_ref = futures[future]
-            try:
-                r = future.result()
-                exec_results.append(r)
-                if r["status"] == "ok":
-                    rprint(f"  [green]{r['key']:>8} -- ok  branch: {r.get('branch', '?')}[/green]")
-                else:
-                    rprint(f"  [red]{r['key']:>8} -- {r.get('error', '?')}[/red]")
-            except Exception as e:
-                rprint(f"  [red]{item_ref:>8} -- error: {e}[/red]")
-
-    ok = sum(1 for r in exec_results if r["status"] == "ok")
-    rprint(f"\n[bold]Execute done: {ok}/{len(succeeded)} succeeded.[/bold]")
-    if ok > 0:
-        rprint("[dim]Merge with: bb agent merge --target release/dev[/dim]")
-
-
-# ---------------------------------------------------------------------------
-# Merge command
-# ---------------------------------------------------------------------------
-
-
-@app.command(name="merge")
-def merge_branches(
-    target: str = typer.Option("release/dev", "--target", "-t", help="Target branch to merge into"),
-    items: list[str] = typer.Argument(None, help="Specific item numbers (default: all bb/item-* branches)"),
-    cleanup_after: bool = typer.Option(False, "--cleanup", help="Remove worktrees + branches after successful merge"),
-    use_agent: bool = typer.Option(False, "--agent", help="Use Claude to resolve merge conflicts"),
-):
-    """Merge agent branches into a target branch (e.g. release/dev)."""
-    slug = _require_project()
-    project_path = _require_project_path(slug)
-
-    # Remember current branch
-    current = subprocess.run(
-        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-        cwd=project_path, capture_output=True, text=True,
-    ).stdout.strip()
-
-    # List all bb/item-* branches
-    result = subprocess.run(
-        ["git", "branch", "--list", "bb/item-*"],
-        cwd=project_path, capture_output=True, text=True,
-    )
-    all_branches = [b.strip().lstrip("* ") for b in result.stdout.strip().splitlines() if b.strip()]
-
-    if items:
-        wanted = {f"bb/item-{n}" for n in items}
-        branches = [b for b in all_branches if b in wanted]
-    else:
-        branches = all_branches
-
-    if not branches:
-        rprint("[yellow]No agent branches found to merge.[/yellow]")
-        return
-
-    rprint(f"[cyan]Merging {len(branches)} branches into {target}...[/cyan]\n")
-    for b in branches:
-        rprint(f"  {b}")
-    rprint()
-
-    # Ensure target branch exists
-    check = subprocess.run(
-        ["git", "rev-parse", "--verify", target],
-        cwd=project_path, capture_output=True, text=True,
-    )
-    if check.returncode != 0:
-        rprint(f"[yellow]Branch '{target}' does not exist. Creating from HEAD...[/yellow]")
-        subprocess.run(
-            ["git", "branch", target],
-            cwd=project_path, check=True, capture_output=True,
-        )
-
-    # Prune stale worktrees
-    subprocess.run(["git", "worktree", "prune"], cwd=project_path, capture_output=True)
-
-    # Checkout target branch
-    co = subprocess.run(
-        ["git", "checkout", target],
-        cwd=project_path, capture_output=True, text=True,
-    )
-    if co.returncode != 0:
-        rprint(f"[red]Failed to checkout {target}: {co.stderr}[/red]")
-        return
-
-    merged: list[str] = []
-    failed: list[tuple[str, str]] = []
-
-    for branch in branches:
-        rprint(f"  Merging {branch}...", end=" ")
-        merge_result = subprocess.run(
-            ["git", "merge", branch, "--no-ff", "-m", f"Merge {branch} into {target}"],
-            cwd=project_path, capture_output=True, text=True,
-        )
-        if merge_result.returncode == 0:
-            rprint("[green]ok[/green]")
-            merged.append(branch)
-        else:
-            if use_agent:
-                rprint("[yellow]conflict -> resolving with Claude...[/yellow]")
-                resolve = subprocess.run(
-                    ["claude", "-p",
-                     f"Resolve all merge conflicts in this git repo. The merge of '{branch}' into '{target}' has conflicts. "
-                     f"Use 'git diff' to find conflicts, resolve them keeping both sets of changes where possible, "
-                     f"then stage and commit. Do NOT abort the merge.",
-                     "--output-format", "text",
-                     "--permission-mode", "bypassPermissions"],
-                    cwd=project_path, capture_output=True, text=True,
-                    timeout=300, env=_claude_env(),
-                )
-                # Check if conflicts are resolved
-                status_check = subprocess.run(
-                    ["git", "diff", "--name-only", "--diff-filter=U"],
-                    cwd=project_path, capture_output=True, text=True,
-                )
-                if status_check.stdout.strip() == "":
-                    rprint(f"    [green]Conflict resolved by agent[/green]")
-                    merged.append(branch)
-                else:
-                    rprint(f"    [red]Agent could not resolve all conflicts[/red]")
-                    subprocess.run(["git", "merge", "--abort"], cwd=project_path, capture_output=True)
-                    failed.append((branch, "conflict (agent failed)"))
-            else:
-                rprint("[red]CONFLICT[/red]")
-                subprocess.run(["git", "merge", "--abort"], cwd=project_path, capture_output=True)
-                failed.append((branch, "conflict"))
-
-    # Summary
-    rprint()
-    table = Table(title=f"Merge Results -> {target}", show_header=True)
-    table.add_column("Branch")
-    table.add_column("Status")
-    for b in merged:
-        table.add_row(b, "[green]merged[/green]")
-    for b, reason in failed:
-        table.add_row(b, f"[red]{reason}[/red]")
-    rprint(table)
-
-    # Cleanup if requested
-    if cleanup_after and merged:
-        for branch in merged:
-            num_str = branch.replace("bb/item-", "")
-            try:
-                wt = _worktree_path(slug, int(num_str))
-                if wt.exists():
-                    _remove_worktree(project_path, str(wt))
-                subprocess.run(
-                    ["git", "branch", "-D", branch],
-                    cwd=project_path, capture_output=True,
-                )
-            except (ValueError, Exception):
-                pass
-        rprint("[dim]Cleaned up merged worktrees and branches.[/dim]")
-
-    if failed:
-        rprint("\n[yellow]Failed branches can be retried:[/yellow]")
-        rprint("[dim]  bb agent merge --agent  (use Claude to resolve conflicts)[/dim]")
-        rprint("[dim]  or resolve manually: git checkout {target} && git merge {branch}[/dim]")
-
-    # Return to original branch
-    subprocess.run(
-        ["git", "checkout", current],
-        cwd=project_path, capture_output=True,
-    )