@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/kanban_manager.py

@@ -1,1771 +0,0 @@
-#!/usr/bin/env python3
-"""
-Kanban Manager CLI - Agile+Kanban workflow for JARVIS Software Factory.
-
-Thin CLI that delegates to application services and repositories.
-
-Supports 3 output modes:
-- Interactive terminal → Rich Trello-like UI
-- Piped/LLM agent → TOON format (token-efficient)
-- --verbose → Legacy logging
-
-Usage:
-    python scripts/kanban_manager.py board -w JARVIS              # Auto: UI or TOON
-    python scripts/kanban_manager.py --toon board -w JARVIS       # Force TOON
-    python scripts/kanban_manager.py --verbose board -w JARVIS    # Debug logging
-    python scripts/kanban_manager.py card start CD-001 -a agent1 -w JARVIS
-"""
-
-import click
-import json
-import logging
-import sys
-import warnings
-from pathlib import Path
-from typing import List, Optional
-
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from src.infrastructure.kanban import KanbanRepository
-from src.application.kanban import KanbanService
-from src.application.kanban.artifact_service import ArtifactService
-from src.domain.user_stories.value_objects import CardStatus
-from src.shared.cli import OutputMode, detect_output_mode
-from src.shared.ui.kanban_ui import (
-    CardDisplay,
-    EpicDisplay,
-    SprintDisplay,
-    KanbanBoardUI,
-    EpicListUI,
-    CardListUI,
-    board_toon,
-    epic_list_toon,
-    card_list_toon,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def setup_logging(verbose: bool = False) -> None:
-    """Configure logging for CLI."""
-    if verbose:
-        logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
-    else:
-        logging.basicConfig(level=logging.WARNING)
-        warnings.filterwarnings("ignore")
-
-
-@click.group()
-@click.option("--verbose", is_flag=True, help="Enable verbose logging (debug mode)")
-@click.option(
-    "--toon", is_flag=True, help="Force TOON output (token-optimized for LLM agents)"
-)
-@click.pass_context
-def cli(ctx: click.Context, verbose: bool, toon: bool):
-    """Kanban Manager - Agile+Kanban workflow for JARVIS.
-
-    Output Modes (auto-detected):
-        - Interactive terminal → Rich Trello-like UI
-        - Piped/LLM agent → TOON format (token-efficient)
-        - --verbose → Legacy logging
-        - --toon → Force TOON output
-
-    Examples:
-        python kanban_manager.py board -w JARVIS           # Auto mode
-        python kanban_manager.py --toon board -w JARVIS    # Force TOON
-        python kanban_manager.py card list -w JARVIS       # Auto mode
-    """
-    ctx.ensure_object(dict)
-    ctx.obj["verbose"] = verbose
-    ctx.obj["toon"] = toon
-    setup_logging(verbose)
-
-
-# === SPRINT ===
-
-
-@cli.group()
-def sprint():
-    """Sprint management."""
-    pass
-
-
-@sprint.command("create")
-@click.option("--workspace", "-w", required=True)
-@click.option("--name", "-n", required=True)
-@click.option("--goal", "-g", default="")
-@click.option("--weeks", type=int, default=2)
-def sprint_create(workspace, name, goal, weeks):
-    """Create sprint."""
-    with KanbanRepository(workspace) as repo:
-        s = repo.create_sprint(name, goal, weeks)
-        click.echo(f"ok:sprint:{s.id},workspace:{workspace},status:planning")
-
-
-@sprint.command("list")
-@click.option("--workspace", "-w", required=True)
-@click.option("--status", "-s", default=None)
-def sprint_list(workspace, status):
-    """List sprints."""
-    with KanbanRepository(workspace) as repo:
-        sprints = repo.list_sprints(status)
-        click.echo(f"ok:count:{len(sprints)},workspace:{workspace}")
-        for s in sprints:
-            click.echo(
-                f"  {s.id}|{s.status}|{s.name}|cards:{repo.count_sprint_cards(s.id)}"
-            )
-
-
-@sprint.command("activate")
-@click.argument("sprint_id")
-@click.option("--workspace", "-w", required=True)
-def sprint_activate(sprint_id, workspace):
-    """Activate sprint."""
-    with KanbanRepository(workspace) as repo:
-        if repo.activate_sprint(sprint_id):
-            click.echo(f"ok:sprint:{sprint_id},status:active")
-        else:
-            click.echo(f"error:cannot_activate:{sprint_id}")
-
-
-@sprint.command("close")
-@click.argument("sprint_id")
-@click.option("--workspace", "-w", required=True)
-def sprint_close(sprint_id, workspace):
-    """Close sprint."""
-    with KanbanRepository(workspace) as repo:
-        velocity = repo.close_sprint(sprint_id)
-        click.echo(f"ok:sprint:{sprint_id},status:closed,velocity:{velocity}")
-
-
-# === EPIC ===
-
-
-@cli.group()
-def epic():
-    """Epic management."""
-    pass
-
-
-@epic.command("create")
-@click.option("--workspace", "-w", required=True)
-@click.option("--title", "-t", required=True)
-@click.option("--description", "-d", default="")
-@click.option(
-    "--priority", "-p", type=click.Choice(["high", "medium", "low"]), default="medium"
-)
-def epic_create(workspace, title, description, priority):
-    """Create epic."""
-    with KanbanRepository(workspace) as repo:
-        e = repo.create_epic(title, description, priority)
-        click.echo(f"ok:epic:{e.id},workspace:{workspace}")
-
-
-@epic.command("list")
-@click.option("--workspace", "-w", required=True)
-@click.pass_context
-def epic_list(ctx: click.Context, workspace: str):
-    """List epics.
-
-    Examples:
-        python kanban_manager.py epic list -w JARVIS           # Rich UI
-        python kanban_manager.py --toon epic list -w JARVIS    # TOON output
-    """
-    verbose = ctx.obj.get("verbose", False)
-    toon = ctx.obj.get("toon", False)
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    with KanbanRepository(workspace) as repo:
-        epics_data = repo.list_epics()
-
-        # Get done counts for each epic (need to query cards)
-        epics = []
-        for e in epics_data:
-            # Get cards for this epic to calculate done count
-            epic_cards = repo.list_cards(epic_id=e.id)
-            done_count = sum(1 for c in epic_cards if c.status.lower() == "done")
-            total_points = sum(c.story_points or 0 for c in epic_cards)
-            done_points = sum(
-                c.story_points or 0 for c in epic_cards if c.status.lower() == "done"
-            )
-
-            epics.append(
-                EpicDisplay(
-                    id=e.id,
-                    title=e.title,
-                    status=e.status,
-                    priority=e.priority,
-                    card_count=e.card_count,
-                    done_count=done_count,
-                    total_points=total_points,
-                    done_points=done_points,
-                )
-            )
-
-        # Output based on mode
-        if mode == OutputMode.LEGACY:
-            click.echo(f"ok:count:{len(epics)},workspace:{workspace}")
-            for e in epics:
-                click.echo(
-                    f"  {e.id}|{e.status}|{e.priority}|{e.title[:40]}|cards:{e.card_count}"
-                )
-        elif mode == OutputMode.TOON:
-            logging.disable(logging.CRITICAL)
-            epic_list_toon(epics, workspace)
-        else:
-            # MODERN - Rich UI
-            ui = EpicListUI()
-            ui.render_list(epics, workspace)
-
-
-# === CARD ===
-
-
-@cli.group()
-def card():
-    """Card management."""
-    pass
-
-
-@card.command("create")
-@click.option("--workspace", "-w", required=True)
-@click.option("--title", "-t", required=True)
-@click.option("--epic", "-e", default=None)
-@click.option("--sprint", "-s", default=None)
-@click.option(
-    "--story", default=None, help="User story ID (ST-XXX) to bind this card to"
-)
-@click.option("--description", "-d", default="")
-@click.option(
-    "--priority", "-p", type=click.Choice(["high", "medium", "low"]), default="medium"
-)
-@click.option(
-    "--points", type=click.Choice(["1", "2", "3", "5", "8", "13", "21"]), default=None
-)
-def card_create(workspace, title, epic, sprint, story, description, priority, points):
-    """Create card."""
-    with KanbanRepository(workspace) as repo:
-        c = repo.create_card(
-            title,
-            epic,
-            sprint,
-            description,
-            priority,
-            int(points) if points else None,
-            user_story_id=story,
-        )
-        story_info = f",story:{story}" if story else ""
-        click.echo(f"ok:card:{c.id},workspace:{workspace},status:backlog{story_info}")
-
-
-@card.command("move")
-@click.argument("card_id")
-@click.option(
-    "--to",
-    "-t",
-    "target",
-    required=True,
-    type=click.Choice(
-        [
-            "backlog",
-            "grooming",
-            "ready",
-            "doing",
-            "review",
-            "technical_review",
-            "tested",
-            "blocked",
-            "done",
-            "rejected",
-            "archived",
-        ]
-    ),
-)
-@click.option("--workspace", "-w", required=True)
-@click.option(
-    "--force",
-    "-f",
-    is_flag=True,
-    help="Skip workflow validation (requires --reason and --justification)",
-)
-@click.option(
-    "--reason",
-    type=click.Choice(["migration", "correction", "external_completion", "emergency"]),
-    help="Reason for using --force (required with --force)",
-)
-@click.option(
-    "--justification",
-    help="Detailed explanation for --force usage (required with --force)",
-)
-def card_move(card_id, target, workspace, force, reason, justification):
-    """Move card to new status."""
-    # CRITICAL: Block --force in non-interactive mode (agent execution)
-    if force and not sys.stdin.isatty():
-        click.echo("error:force_not_allowed_in_non_interactive_mode")
-        click.echo(
-            "help:Agents cannot use --force. User must authorize workflow bypasses."
-        )
-        sys.exit(1)
-
-    # Validate --force parameters
-    if force:
-        if not reason:
-            click.echo("error:--force requires --reason")
-            click.echo(
-                "help:Valid reasons: migration, correction, external_completion, emergency"
-            )
-            sys.exit(1)
-
-        if not justification:
-            # Interactive mode: prompt for justification
-            justification = click.prompt(
-                "Justification for --force (detailed explanation required)"
-            )
-            if not justification.strip():
-                click.echo("error:justification cannot be empty")
-                sys.exit(1)
-
-        # Show consequences and require confirmation
-        click.echo("\n⚠️  WARNING: --force will:")
-        click.echo("  - Bypass workflow validation rules")
-        click.echo("  - Potentially corrupt sprint metrics if used incorrectly")
-        click.echo("  - Be logged to force_operations audit table")
-        click.echo(f"  - Reason: {reason}")
-        click.echo(f"  - Justification: {justification}")
-        click.echo("")
-
-        if not click.confirm("Proceed with --force?", default=False):
-            click.echo("cancelled:operation aborted by user")
-            sys.exit(0)
-
-    with KanbanService(workspace) as svc:
-        result = svc.move_card(
-            card_id,
-            target,
-            force=force,
-            reason=reason,
-            justification=justification,
-            authorized_by="cli_user",
-        )
-        if result.success:
-            forced_flag = ""
-            if result.data.get("forced"):
-                forced_flag = f",forced:true,reason:{reason},audit_logged:true"
-            click.echo(
-                f"ok:card:{card_id},status:{target},from:{result.data['from']}{forced_flag}"
-            )
-        else:
-            click.echo(f"error:{result.error}")
-
-
-@card.command("assign")
-@click.argument("card_id")
-@click.option("--agent", "-a", required=True)
-@click.option("--workspace", "-w", required=True)
-def card_assign(card_id, agent, workspace):
-    """Assign card to agent."""
-    with KanbanRepository(workspace) as repo:
-        repo.assign_card(card_id, agent)
-        repo.log_activity(card_id, agent, "assigned", f"Assigned to {agent}")
-        click.echo(f"ok:card:{card_id},assigned:{agent}")
-
-
-@card.command("start")
-@click.argument("card_id")
-@click.option("--agent", "-a", required=True)
-@click.option("--workspace", "-w", required=True)
-def card_start(card_id, agent, workspace):
-    """Start working on card (READY->DOING + context_memory)."""
-    with KanbanService(workspace) as svc:
-        result = svc.start_card(card_id, agent)
-        if result.success:
-            cm = ",cm:ok" if result.cm_logged else ",cm:warn"
-            click.echo(f"ok:card:{card_id},status:doing,agent:{agent}{cm}")
-        else:
-            click.echo(f"error:{result.error}")
-
-
-@card.command("pause")
-@click.argument("card_id")
-@click.option("--agent", "-a", required=True)
-@click.option("--reason", "-r", default="")
-@click.option("--workspace", "-w", required=True)
-def card_pause(card_id, agent, reason, workspace):
-    """Pause work on card."""
-    with KanbanService(workspace) as svc:
-        result = svc.pause_card(card_id, agent, reason)
-        click.echo(f"ok:card:{card_id},paused,agent:{agent}")
-
-
-@card.command("resume")
-@click.argument("card_id")
-@click.option("--agent", "-a", required=True)
-@click.option("--workspace", "-w", required=True)
-def card_resume(card_id, agent, workspace):
-    """Resume work on card."""
-    with KanbanService(workspace) as svc:
-        result = svc.resume_card(card_id, agent)
-        click.echo(f"ok:card:{card_id},resumed,agent:{agent}")
-
-
-@card.command("complete")
-@click.argument("card_id")
-@click.option("--agent", "-a", required=True)
-@click.option("--summary", "-s", default="")
-@click.option("--reviewer", "-r", default="opencode")
-@click.option("--workspace", "-w", required=True)
-def card_complete(card_id, agent, summary, reviewer, workspace):
-    """Complete work (DOING->REVIEW + notify reviewer)."""
-    with KanbanService(workspace) as svc:
-        result = svc.complete_card(card_id, agent, summary, reviewer)
-        if result.success:
-            msg = ",msg:sent" if result.data.get("msg_sent") else ",msg:warn"
-            click.echo(f"ok:card:{card_id},status:review,reviewer:{reviewer}{msg}")
-        else:
-            click.echo(f"error:{result.error}")
-
-
-@card.command("review")
-@click.argument("card_id")
-@click.option("--pass", "passed", is_flag=True)
-@click.option("--fail", "failed", is_flag=True)
-@click.option("--feedback", "-f", default="")
-@click.option("--reviewer", "-r", default="opencode")
-@click.option("--workspace", "-w", required=True)
-def card_review(card_id, passed, failed, feedback, reviewer, workspace):
-    """Record review result."""
-    if not passed and not failed:
-        click.echo("error:must_specify_--pass_or_--fail")
-        return
-    with KanbanRepository(workspace) as repo:
-        card = repo.get_card(card_id)
-        if not card or card.status != "review":
-            click.echo(f"error:card_not_in_review")
-            return
-        result = repo.add_review(card_id, reviewer, passed, feedback)
-        click.echo(
-            f"ok:card:{card_id},review:{result['iteration']}/{result['max_iterations']},passed:{passed},status:{result['new_status']}"
-        )
-
-
-@card.command("show")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-def card_show(card_id, workspace):
-    """Show card details."""
-    with KanbanRepository(workspace) as repo:
-        c = repo.get_card(card_id)
-        if not c:
-            click.echo(f"error:card_not_found:{card_id}")
-            return
-        click.echo(
-            f"id:{c.id}\ntitle:{c.title}\nstatus:{c.status}\npriority:{c.priority}"
-        )
-        click.echo(
-            f"agent:{c.assigned_agent or 'unassigned'}\npoints:{c.story_points or 'unestimated'}"
-        )
-        click.echo(f"reviews:{c.review_iterations}/{c.max_review_iterations}")
-
-
-
-# Alias 'get' -> 'show' for convenience
-@card.command("get")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-def card_get(card_id, workspace):
-    """Get card details (alias for 'show')."""
-    ctx = click.get_current_context()
-    ctx.invoke(card_show, card_id=card_id, workspace=workspace)
-
-@card.command("update")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-@click.option("--title", "-t", default=None, help="Update card title")
-@click.option("--description", "-d", default=None, help="Update card description")
-@click.option(
-    "--priority",
-    "-p",
-    type=click.Choice(["high", "medium", "low"]),
-    default=None,
-    help="Update card priority",
-)
-@click.option(
-    "--points",
-    type=click.Choice(["1", "2", "3", "5", "8", "13", "21"]),
-    default=None,
-    help="Update story points",
-)
-@click.option(
-    "--epic", "-e", default=None, help="Update epic ID (use empty string to remove)"
-)
-@click.option(
-    "--sprint", "-s", default=None, help="Update sprint ID (use empty string to remove)"
-)
-@click.pass_context
-def card_update(
-    ctx: click.Context,
-    card_id: str,
-    workspace: str,
-    title: Optional[str],
-    description: Optional[str],
-    priority: Optional[str],
-    points: Optional[str],
-    epic: Optional[str],
-    sprint: Optional[str],
-):
-    """Update card fields.
-
-    Examples:
-        python kanban_manager.py card update CD-001 -w JARVIS --title "New Title"
-        python kanban_manager.py card update CD-001 -w JARVIS --priority high --points 5
-        python kanban_manager.py card update CD-001 -w JARVIS --epic EP-002
-        python kanban_manager.py card update CD-001 -w JARVIS --epic "" # Remove epic
-    """
-    verbose = ctx.obj.get("verbose", False)
-    toon = ctx.obj.get("toon", False)
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    # Check if at least one field is provided
-    update_fields = [title, description, priority, points, epic, sprint]
-    if all(field is None for field in update_fields):
-        if mode == OutputMode.TOON:
-            click.echo("err:no_updates,req:at_least_one_field")
-        else:
-            click.echo("error:no_updates_provided")
-            click.echo(
-                "help:Provide at least one field to update (--title, --description, --priority, --points, --epic, --sprint)"
-            )
-        return
-
-    with KanbanRepository(workspace) as repo:
-        # Verify card exists
-        card = repo.get_card(card_id)
-        if not card:
-            if mode == OutputMode.TOON:
-                click.echo(f"err:card_not_found,id:{card_id}")
-            else:
-                click.echo(f"error:card_not_found:{card_id}")
-            return
-
-        try:
-            # Convert points to int if provided
-            story_points = int(points) if points else None
-
-            # Perform update
-            updated = repo.update_card(
-                card_id=card_id,
-                title=title,
-                description=description,
-                priority=priority,
-                story_points=story_points,
-                epic_id=epic,
-                sprint_id=sprint,
-            )
-
-            if updated:
-                # Log activity
-                changes = []
-                if title is not None:
-                    changes.append(f"title:{title[:30]}")
-                if description is not None:
-                    changes.append(f"desc:{'set' if description else 'cleared'}")
-                if priority is not None:
-                    changes.append(f"priority:{priority}")
-                if story_points is not None:
-                    changes.append(f"points:{story_points}")
-                if epic is not None:
-                    changes.append(f"epic:{epic if epic else 'removed'}")
-                if sprint is not None:
-                    changes.append(f"sprint:{sprint if sprint else 'removed'}")
-
-                repo.log_activity(
-                    card_id,
-                    "kanban-manager",
-                    "updated",
-                    f"Updated: {', '.join(changes)}",
-                )
-
-                if mode == OutputMode.TOON:
-                    click.echo(
-                        f"ok:card:{card_id},updated:{len(changes)}_fields,ws:{workspace}"
-                    )
-                else:
-                    click.echo(f"ok:card:{card_id},updated:{len(changes)}_fields")
-                    click.echo(f"  changes: {', '.join(changes)}")
-            else:
-                if mode == OutputMode.TOON:
-                    click.echo(f"warn:card:{card_id},no_changes")
-                else:
-                    click.echo(f"warning:no_changes_applied:card_already_up_to_date")
-
-        except ValueError as e:
-            if mode == OutputMode.TOON:
-                click.echo(f"err:invalid_value,msg:{str(e)}")
-            else:
-                click.echo(f"error:invalid_value:{str(e)}")
-        except Exception as e:
-            if mode == OutputMode.TOON:
-                click.echo(f"err:update_failed,msg:{str(e)}")
-            else:
-                click.echo(f"error:update_failed:{str(e)}")
-
-
-@card.command("list")
-@click.option("--workspace", "-w", required=True)
-@click.option("--status", "-s", default=None)
-@click.option("--sprint", default=None)
-@click.option("--agent", "-a", default=None)
-@click.option("--epic", "-e", default=None, help="Filter by epic ID")
-@click.pass_context
-def card_list(
-    ctx: click.Context,
-    workspace: str,
-    status: Optional[str],
-    sprint: Optional[str],
-    agent: Optional[str],
-    epic: Optional[str],
-):
-    """List cards.
-
-    Examples:
-        python kanban_manager.py card list -w JARVIS           # Rich table
-        python kanban_manager.py --toon card list -w JARVIS    # TOON output
-        python kanban_manager.py card list -w JARVIS -s doing  # Filter by status
-    """
-    verbose = ctx.obj.get("verbose", False)
-    toon = ctx.obj.get("toon", False)
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    with KanbanRepository(workspace) as repo:
-        cards_data = repo.list_cards(status, sprint, agent, epic)
-
-        # Convert to display objects
-        cards = [
-            CardDisplay(
-                id=c.id,
-                title=c.title,
-                status=c.status,
-                priority=c.priority,
-                assigned_agent=c.assigned_agent,
-                story_points=c.story_points,
-                epic_id=c.epic_id,
-                sprint_id=c.sprint_id,
-                review_iterations=c.review_iterations,
-                max_review_iterations=c.max_review_iterations,
-                is_blocked=(c.status.lower() == "blocked"),
-            )
-            for c in cards_data
-        ]
-
-        # Build title with filters
-        title = "Cards"
-        filters = []
-        if status:
-            filters.append(f"status={status}")
-        if sprint:
-            filters.append(f"sprint={sprint}")
-        if agent:
-            filters.append(f"agent={agent}")
-        if epic:
-            filters.append(f"epic={epic}")
-        if filters:
-            title += f" ({', '.join(filters)})"
-
-        # Output based on mode
-        if mode == OutputMode.LEGACY:
-            click.echo(f"ok:count:{len(cards)}")
-            for c in cards:
-                agent_str = f"@{c.assigned_agent}" if c.assigned_agent else ""
-                pts = f"[{c.story_points}pts]" if c.story_points else ""
-                click.echo(
-                    f"  {c.id}|{c.status}|{c.priority}|{c.title[:35]}{agent_str}{pts}"
-                )
-        elif mode == OutputMode.TOON:
-            logging.disable(logging.CRITICAL)
-            card_list_toon(cards, workspace)
-        else:
-            # MODERN - Rich UI
-            ui = CardListUI()
-            ui.render_list(cards, workspace, title)
-
-
-@card.command("message")
-@click.argument("card_id")
-@click.option("--from", "-f", "from_agent", required=True)
-@click.option("--to", "-t", "to_agent", required=True)
-@click.option("--subject", "-s", required=True)
-@click.option("--content", "-c", required=True)
-@click.option("--workspace", "-w", required=True)
-def card_message(card_id, from_agent, to_agent, subject, content, workspace):
-    """Send message about card."""
-    with KanbanService(workspace) as svc:
-        result = svc.send_card_message(card_id, from_agent, to_agent, subject, content)
-        if result.success:
-            click.echo(f"ok:card:{card_id},msg:sent,from:{from_agent},to:{to_agent}")
-        else:
-            click.echo(f"error:{result.error}")
-
-
-@card.command("activity")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-@click.option("--limit", "-l", type=int, default=10)
-def card_activity(card_id, workspace, limit):
-    """Show card activity log."""
-    with KanbanService(workspace) as svc:
-        result = svc.get_card_activities(card_id, limit)
-        activities = result.data["activities"]
-        click.echo(f"ok:card:{card_id},activities:{len(activities)}")
-        for a in activities:
-            ts = a["created_at"][:16] if a.get("created_at") else "N/A"
-            click.echo(
-                f"  {ts}|{a['agent']}|{a['action']}|{(a.get('details') or '')[:40]}"
-            )
-
-
-# === GROOMING ===
-
-
-@card.command("add-artifact")
-@click.argument("card_id")
-@click.option(
-    "--type",
-    "-t",
-    "artifact_type",
-    required=True,
-    type=click.Choice(
-        [
-            "scope_doc",
-            "diagram",
-            "wireframe",
-            "api_spec",
-            "data_model",
-            "test_plan",
-            "other",
-        ]
-    ),
-)
-@click.option("--title", required=True)
-@click.option("--content", "-c", required=True)
-@click.option(
-    "--file-path",
-    "-f",
-    default=None,
-    help="Path to artifact file (relative to workspace)",
-)
-@click.option("--workspace", "-w", required=True)
-def card_add_artifact(card_id, artifact_type, title, content, file_path, workspace):
-    """Add grooming artifact with Obsidian integration."""
-    # Import Obsidian config manager for integration check
-    try:
-        sys.path.append(str(Path(__file__).parent / "managers"))
-        from obsidian_config_manager import ObsidianConfigManager
-
-        obsidian_manager = ObsidianConfigManager()
-    except ImportError:
-        obsidian_manager = None
-
-    with KanbanRepository(workspace) as repo:
-        repo.add_artifact(card_id, artifact_type, title, content, file_path=file_path)
-
-        # Check if Obsidian integration is enabled for this workspace
-        obsidian_path = None
-        if (
-            obsidian_manager
-            and obsidian_manager.is_obsidian_enabled()
-            and obsidian_manager.is_workspace_enabled(workspace)
-        ):
-            try:
-                # Create artifact in Obsidian vault if enabled
-                vault_path = obsidian_manager.get_vault_path()
-                if vault_path and obsidian_manager.get_sync_preference(
-                    "artifacts_to_vault"
-                ):
-                    obsidian_path = _create_obsidian_artifact(
-                        vault_path, workspace, card_id, artifact_type, title, content
-                    )
-            except Exception as e:
-                logger.warning(f"Failed to sync artifact to Obsidian: {e}")
-
-        # Format response
-        path_info = f",file:{file_path}" if file_path else ""
-        obsidian_info = f",obsidian:{obsidian_path}" if obsidian_path else ""
-        click.echo(
-            f"ok:card:{card_id},artifact:{artifact_type}{path_info}{obsidian_info}"
-        )
-
-
-def _create_obsidian_artifact(
-    vault_path, workspace, card_id, artifact_type, title, content
-):
-    """
-    Create artifact file in Obsidian vault.
-
-    Args:
-        vault_path: Path to Obsidian vault
-        workspace: Workspace name
-        card_id: Card ID (e.g., CD-123)
-        artifact_type: Type of artifact
-        title: Artifact title
-        content: Artifact content
-
-    Returns:
-        Path to created file in vault
-    """
-    from datetime import datetime
-
-    # Create artifact path structure: vault/workspace/artifacts/
-    vault = Path(vault_path)
-    artifact_dir = vault / workspace / "artifacts"
-    artifact_dir.mkdir(parents=True, exist_ok=True)
-
-    # Generate filename: CD-123_scope_doc.md
-    filename = f"{card_id}_{artifact_type}.md"
-    artifact_path = artifact_dir / filename
-
-    # Create markdown content with Obsidian frontmatter
-    frontmatter = f"""---
-id: {card_id}
-type: {artifact_type}
-title: {title}
-workspace: {workspace}
-created: {datetime.now().strftime("%Y-%m-%d")}
-status: active
-tags:
-  - artifact
-  - {workspace.lower()}
-  - {artifact_type}
----
-
-# {title}
-
-{content}
-
----
-*Generated by JARVIS Framework - Card: [[{card_id}]]*
-"""
-
-    # Write file
-    with open(artifact_path, "w", encoding="utf-8") as f:
-        f.write(frontmatter)
-
-    return str(artifact_path.relative_to(vault))
-
-
-@card.command("groom")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-@click.option("--complete", is_flag=True, help="Mark grooming as complete if valid")
-def card_groom(card_id, workspace, complete):
-    """Show grooming checklist or mark grooming complete."""
-    from src.application.kanban.grooming_validator import GroomingValidator
-
-    with GroomingValidator(workspace) as validator:
-        result = validator.get_grooming_status(card_id)
-
-        if result.errors:
-            click.echo(f"error:{','.join(result.errors)}")
-            return
-
-        # Build checklist output
-        check_artifacts = (
-            "[✓]" if result.artifacts_count >= validator.MIN_ARTIFACTS else "[ ]"
-        )
-        check_desc = "[✓]" if result.has_description else "[ ]"
-        check_ac = "[✓]" if result.has_acceptance_criteria else "[ ]"
-
-        click.echo(f"grooming_checklist:{card_id}")
-        click.echo(
-            f"  {check_artifacts} artifacts:{result.artifacts_count} (min:{validator.MIN_ARTIFACTS})"
-        )
-        click.echo(
-            f"  {check_desc} description:{'present' if result.has_description else 'missing'}"
-        )
-        click.echo(
-            f"  {check_ac} acceptance_criteria:{'present' if result.has_acceptance_criteria else 'none'} (recommended)"
-        )
-
-        if complete:
-            if result.valid:
-                complete_result = validator.complete_grooming(card_id)
-                if complete_result.valid:
-                    click.echo(
-                        f"ok:grooming_completed,artifacts:{result.artifacts_count}"
-                    )
-                else:
-                    click.echo(
-                        f"error:complete_failed:{','.join(complete_result.errors)}"
-                    )
-            else:
-                click.echo(f"error:cannot_complete:requirements_not_met")
-        else:
-            status = "ready_for_promotion" if result.valid else "needs_more_work"
-            click.echo(f"status:{status}")
-
-
-@card.command("add-deliverable")
-@click.argument("card_id")
-@click.option(
-    "--type",
-    "-t",
-    "deliv_type",
-    required=True,
-    type=click.Choice(
-        ["code", "test", "doc", "config", "migration", "script", "other"]
-    ),
-)
-@click.option("--description", "-d", required=True)
-@click.option("--path", "-p", default=None)
-@click.option("--workspace", "-w", required=True)
-def card_add_deliverable(card_id, deliv_type, description, path, workspace):
-    """Add expected deliverable."""
-    with KanbanRepository(workspace) as repo:
-        repo.add_deliverable(card_id, deliv_type, description, path)
-        click.echo(f"ok:card:{card_id},deliverable:{deliv_type}")
-
-
-@card.command("add-ac")
-@click.argument("card_id")
-@click.option("--given", "-g", required=True)
-@click.option("--when", "-w", "when_clause", required=True)
-@click.option("--then", "-t", required=True)
-@click.option("--workspace", required=True)
-def card_add_ac(card_id, given, when_clause, then, workspace):
-    """Add acceptance criteria."""
-    with KanbanRepository(workspace) as repo:
-        ac_id = repo.add_acceptance_criteria(card_id, given, when_clause, then)
-        click.echo(f"ok:card:{card_id},ac:{ac_id}")
-
-
-# === BLOCKERS ===
-
-
-@card.command("block")
-@click.argument("card_id")
-@click.option("--reason", "-r", required=True)
-@click.option("--by", default=None)
-@click.option("--workspace", "-w", required=True)
-def card_block(card_id, reason, by, workspace):
-    """Block card."""
-    with KanbanRepository(workspace) as repo:
-        if repo.block_card(card_id, reason, by):
-            click.echo(f"ok:card:{card_id},blocked,reason:{reason[:40]}")
-        else:
-            click.echo(f"error:card_not_found:{card_id}")
-
-
-@card.command("unblock")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-def card_unblock(card_id, workspace):
-    """Unblock card."""
-    with KanbanRepository(workspace) as repo:
-        target = repo.unblock_card(card_id)
-        if target:
-            click.echo(f"ok:card:{card_id},unblocked,status:{target}")
-        else:
-            click.echo(f"error:card_not_blocked:{card_id}")
-
-
-@card.command("code-review")
-@click.argument("card_id")
-@click.option("--file", "-f", required=True, help="File path to review")
-@click.option("--workspace", "-w", required=True)
-@click.option("--description", "-d", help="Review description")
-@click.option(
-    "--priority", "-p", type=click.Choice(["low", "medium", "high"]), default="medium"
-)
-def card_code_review(card_id, file, workspace, description, priority):
-    """Request code review for a file in this card."""
-    try:
-        # Import here to avoid circular imports
-        from src.application.quality.code_review_system import (
-            get_review_service,
-            ReviewRequest,
-        )
-        from pathlib import Path
-
-        # Validate file exists
-        file_path = Path(file)
-        if not file_path.exists():
-            click.echo(f"error:file_not_found:{file}")
-            return
-
-        # Validate card exists and is in review status
-        with KanbanRepository(workspace) as repo:
-            card = repo.get_card(card_id)
-            if not card:
-                click.echo(f"error:card_not_found:{card_id}")
-                return
-
-            if card.status != "review":
-                click.echo(f"error:card_not_in_review:current_status={card.status}")
-                return
-
-        # Detect content type from file extension
-        extension = file_path.suffix.lower()
-        content_type_map = {
-            ".py": "python",
-            ".js": "javascript",
-            ".ts": "typescript",
-            ".tsx": "typescript",
-            ".jsx": "javascript",
-            ".kt": "kotlin",
-            ".java": "java",
-            ".swift": "swift",
-            ".go": "go",
-            ".rs": "rust",
-            ".md": "markdown",
-            ".yaml": "yaml",
-            ".yml": "yaml",
-            ".json": "json",
-        }
-        content_type = content_type_map.get(extension, "unknown")
-
-        # Create review request
-        review_service = get_review_service(workspace)
-        request = review_service.create_review_request(
-            card_id=card_id,
-            producer_agent="kanban-manual",
-            implementation_files=[str(file_path)],
-            acceptance_criteria=[description or f"Code review for {file_path.name}"],
-        )
-
-        # Start the first review cycle
-        cycle = review_service.start_review_cycle(card_id)
-        assigned_reviewer = cycle.reviewer_id if cycle else "auto-assigned"
-
-        click.echo(
-            f"ok:card:{card_id},code_review:created,file:{file},reviewer:{assigned_reviewer}"
-        )
-
-    except Exception as e:
-        click.echo(f"error:code_review_failed:{str(e)}")
-
-
-@card.command("code-review-status")
-@click.argument("card_id")
-@click.option("--workspace", "-w", required=True)
-def card_code_review_status(card_id, workspace):
-    """Check status of a code review for a card."""
-    try:
-        from src.application.quality.code_review_system import get_review_service
-
-        review_service = get_review_service(workspace)
-        request = review_service.active_requests.get(card_id)
-
-        if not request:
-            click.echo(f"error:no_review_found_for_card:{card_id}")
-            return
-
-        current_cycle = request.current_cycle
-        max_cycles = request.max_cycles
-
-        if request.cycles:
-            latest_cycle = request.cycles[-1]
-            status = (
-                "completed"
-                if latest_cycle.status in ["approved", "rejected"]
-                else "in_progress"
-            )
-            reviewer = latest_cycle.reviewer_id
-        else:
-            status = "pending"
-            reviewer = "unassigned"
-
-        click.echo(
-            f"ok:card:{card_id},review_status:{status},cycle:{current_cycle}/{max_cycles},reviewer:{reviewer}"
-        )
-
-        # If completed, show final result
-        if request.cycles and request.cycles[-1].status in ["approved", "rejected"]:
-            final_cycle = request.cycles[-1]
-            approved = final_cycle.status == "approved"
-            click.echo(f"result:{'approved' if approved else 'rejected'}")
-            if final_cycle.feedback:
-                feedback_preview = str(final_cycle.feedback)[:100]
-                click.echo(f"feedback:{feedback_preview}...")
-
-    except Exception as e:
-        click.echo(f"error:review_status_failed:{str(e)}")
-
-
-# === BOARD & STATS ===
-
-
-@cli.command("board")
-@click.option("--workspace", "-w", required=True)
-@click.option("--sprint", "-s", default=None)
-@click.pass_context
-def board(ctx: click.Context, workspace: str, sprint: Optional[str]):
-    """Display Kanban board.
-
-    Examples:
-        python kanban_manager.py board -w JARVIS           # Rich UI
-        python kanban_manager.py --toon board -w JARVIS    # TOON output
-    """
-    verbose = ctx.obj.get("verbose", False)
-    toon = ctx.obj.get("toon", False)
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    with KanbanRepository(workspace) as repo:
-        # Get sprint info
-        if sprint:
-            s = repo.get_sprint(sprint)
-        else:
-            sprints = repo.list_sprints("active")
-            s = sprints[0] if sprints else None
-
-        sprint_id = s.id if s else None
-
-        # Get cards
-        cards_data = repo.list_cards(sprint_id=sprint_id)
-
-        # Convert to display objects
-        cards = [
-            CardDisplay(
-                id=c.id,
-                title=c.title,
-                status=c.status,
-                priority=c.priority,
-                assigned_agent=c.assigned_agent,
-                story_points=c.story_points,
-                epic_id=c.epic_id,
-                sprint_id=c.sprint_id,
-                review_iterations=c.review_iterations,
-                max_review_iterations=c.max_review_iterations,
-            )
-            for c in cards_data
-        ]
-
-        # Check for blocked cards
-        for card in cards:
-            # Simple heuristic: if status is 'blocked', mark as blocked
-            if card.status.lower() == "blocked":
-                card.is_blocked = True
-
-        sprint_display = None
-        if s:
-            sprint_display = SprintDisplay(
-                id=s.id,
-                name=s.name,
-                status=s.status,
-                goal=s.goal,
-                velocity=0,  # TODO: get from stats
-                card_count=len(cards),
-            )
-
-        # Output based on mode
-        if mode == OutputMode.LEGACY:
-            _board_legacy(repo, workspace, s, sprint_id)
-        elif mode == OutputMode.TOON:
-            logging.disable(logging.CRITICAL)
-            board_toon(cards, sprint_display, workspace)
-        else:
-            # MODERN - Rich UI
-            ui = KanbanBoardUI()
-            ui.render_board(cards, sprint_display, workspace)
-
-
-def _board_legacy(repo, workspace: str, sprint, sprint_id: Optional[str]) -> None:
-    """Legacy board output for verbose mode."""
-    if sprint:
-        logger.info(f"Sprint: {sprint.id} - {sprint.name}")
-        logger.info(f"Goal: {sprint.goal or 'N/A'}")
-    else:
-        logger.info(f"Workspace: {workspace} (no active sprint)")
-
-    stats = repo.get_board_stats(sprint_id)
-    statuses = [
-        "backlog",
-        "grooming",
-        "ready",
-        "doing",
-        "review",
-        "tech_rev",  # Abbreviated for display
-        "tested",
-        "blocked",
-        "done",
-    ]
-
-    header = "|".join(f"{s[:7]:^9}" for s in statuses)
-    click.echo(f"|{header}|")
-    click.echo("|" + "---------+" * len(statuses))
-    counts = "|".join(f"{stats.get(s, 0):^9}" for s in statuses)
-    click.echo(f"|{counts}|")
-
-
-@cli.command("stats")
-@click.option("--workspace", "-w", required=True)
-def stats(workspace):
-    """Show workspace statistics."""
-    with KanbanRepository(workspace) as repo:
-        s = repo.get_workspace_stats()
-        click.echo(f"workspace:{workspace}")
-        click.echo(
-            f"sprints:{sum(s['sprints'].values())},active:{s['sprints'].get('active', 0)}"
-        )
-        click.echo(f"cards:{sum(s['cards'].values())}")
-        for status in [
-            "backlog",
-            "grooming",
-            "ready",
-            "doing",
-            "review",
-            "technical_review",
-            "tested",
-            "done",
-        ]:
-            click.echo(f"  {status}:{s['cards'].get(status, 0)}")
-        click.echo(f"avg_velocity:{s['avg_velocity']:.1f}")
-
-
-@cli.command("next-card")
-@click.option("--workspace", "-w", required=True)
-@click.option("--agent", "-a", required=True)
-def next_card(workspace, agent):
-    """Get next ready card for agent."""
-    with KanbanRepository(workspace) as repo:
-        c = repo.get_next_ready_card(agent)
-        if c:
-            click.echo(f"ok:card:{c.id},title:{c.title},priority:{c.priority}")
-        else:
-            click.echo("ok:no_ready_cards")
-
-
-# === ARTIFACTS ===
-
-
-@cli.group()
-def artifact():
-    """Technical artifact management for tech leads and data engineers."""
-    pass
-
-
-@artifact.command("create")
-@click.option("--workspace", "-w", required=True, help="Workspace name")
-@click.option(
-    "--type",
-    "-t",
-    "art_type",
-    required=True,
-    type=click.Choice(
-        [
-            "technical_spec",
-            "algorithm",
-            "architecture_decision",
-            "data_schema",
-            "interface_contract",
-            "implementation_guide",
-            "validation_rules",
-            "migration_plan",
-            "scope_doc",
-            "diagram",
-            "wireframe",
-            "api_spec",
-            "data_model",
-            "test_plan",
-            "other",
-        ]
-    ),
-)
-@click.option("--title", required=True, help="Artifact title")
-@click.option("--content", required=True, help="Artifact content (or @file.md)")
-@click.option("--created-by", required=True, help="Creator agent or role")
-@click.option(
-    "--role",
-    default="developer",
-    type=click.Choice(
-        [
-            "tech_lead",
-            "data_engineer",
-            "solution_architect",
-            "product_owner",
-            "developer",
-            "other",
-        ]
-    ),
-)
-@click.option("--card", default=None, help="Link to card ID")
-@click.option("--epic", default=None, help="Link to epic ID")
-@click.option("--sprint", default=None, help="Link to sprint ID")
-@click.option("--description", "-d", default=None, help="Short description")
-@click.option(
-    "--format",
-    "-f",
-    "fmt",
-    default="markdown",
-    type=click.Choice(["markdown", "mermaid", "json", "yaml", "sql", "python", "toon"]),
-)
-@click.option("--tags", default=None, help="Comma-separated tags")
-def artifact_create(
-    workspace,
-    art_type,
-    title,
-    content,
-    created_by,
-    role,
-    card,
-    epic,
-    sprint,
-    description,
-    fmt,
-    tags,
-):
-    """Create a technical artifact."""
-    # Handle @file.md syntax for content
-    if content.startswith("@") and Path(content[1:]).exists():
-        content = Path(content[1:]).read_text()
-
-    with ArtifactService(workspace) as svc:
-        result = svc.create(
-            type=art_type,
-            title=title,
-            content=content,
-            created_by=created_by,
-            owner_role=role,
-            card_id=card,
-            epic_id=epic,
-            sprint_id=sprint,
-            description=description,
-            format=fmt,
-            tags=tags,
-        )
-        if result.success:
-            click.echo(f"ok:artifact:{result.data['id']},type:{art_type},title:{title}")
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-@artifact.command("list")
-@click.option("--workspace", "-w", required=True)
-@click.option("--card", default=None, help="Filter by card ID")
-@click.option("--epic", default=None, help="Filter by epic ID")
-@click.option("--type", "-t", "art_type", default=None, help="Filter by type")
-def artifact_list(workspace, card, epic, art_type):
-    """List artifacts for card, epic, or by type."""
-    with ArtifactService(workspace) as svc:
-        if card:
-            result = svc.list_for_card(card)
-        elif epic:
-            result = svc.list_for_epic(epic)
-        elif art_type:
-            result = svc.list_by_type(art_type)
-        else:
-            click.echo("error:must_specify_card_epic_or_type")
-            sys.exit(1)
-
-        if result.success:
-            click.echo(f"ok:count:{result.data['count']}")
-            for a in result.data["artifacts"]:
-                click.echo(f"  {a['id']}|{a['type']}|{a['title']}|{a['owner_role']}")
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-@artifact.command("get")
-@click.option("--workspace", "-w", required=True)
-@click.argument("artifact_id", type=int)
-@click.option("--content/--no-content", default=False, help="Include full content")
-def artifact_get(workspace, artifact_id, content):
-    """Get artifact details."""
-    with ArtifactService(workspace) as svc:
-        result = svc.get(artifact_id)
-        if result.success:
-            a = result.data["artifact"]
-            click.echo(f"id:{a['id']}")
-            click.echo(f"type:{a['type']}")
-            click.echo(f"title:{a['title']}")
-            click.echo(f"format:{a['format']}")
-            click.echo(f"owner:{a['owner_role']}")
-            click.echo(
-                f"card:{a['card_id']},epic:{a['epic_id']},sprint:{a['sprint_id']}"
-            )
-            click.echo(f"tags:{a['tags']}")
-            if content:
-                click.echo("---CONTENT---")
-                # Get content from DB (need to fetch full artifact)
-                repo = svc._get_repo()
-                cursor = repo._conn.execute(
-                    "SELECT content FROM technical_artifacts WHERE id = ?",
-                    (artifact_id,),
-                )
-                row = cursor.fetchone()
-                if row:
-                    click.echo(row["content"])
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-@artifact.command("context")
-@click.option("--workspace", "-w", required=True)
-@click.argument("card_id")
-@click.option("--verbose", "-v", is_flag=True, help="Show full content")
-def artifact_context(workspace, card_id, verbose):
-    """Get all artifacts context for a card (main discovery for agents)."""
-    with ArtifactService(workspace) as svc:
-        result = svc.get_context_for_card(card_id)
-        if result.success:
-            d = result.data
-            click.echo(
-                f"ok:card:{d['card_id']},epic:{d['epic_id']},sprint:{d['sprint_id']}"
-            )
-            click.echo(f"artifacts:{d['count']}")
-            for item in d["artifacts"]:
-                a = item["artifact"]
-                src = item["source"]
-                click.echo(f"  [{src}]{a['id']}|{a['type']}|{a['title']}|{a['format']}")
-                if verbose:
-                    # Fetch content for verbose output
-                    repo = svc._get_repo()
-                    cursor = repo._conn.execute(
-                        "SELECT content FROM technical_artifacts WHERE id = ?",
-                        (a["id"],),
-                    )
-                    row = cursor.fetchone()
-                    if row:
-                        click.echo(f"    content_preview:{row['content'][:200]}...")
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-@artifact.command("search")
-@click.option("--workspace", "-w", required=True)
-@click.argument("query")
-def artifact_search(workspace, query):
-    """Search artifacts by title, description, tags, or content."""
-    with ArtifactService(workspace) as svc:
-        result = svc.search(query)
-        if result.success:
-            click.echo(f"ok:query:{query},count:{result.data['count']}")
-            for a in result.data["artifacts"]:
-                click.echo(f"  {a['id']}|{a['type']}|{a['title']}|{a['tags']}")
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-@artifact.command("deprecate")
-@click.option("--workspace", "-w", required=True)
-@click.argument("artifact_id", type=int)
-def artifact_deprecate(workspace, artifact_id):
-    """Mark artifact as deprecated."""
-    with ArtifactService(workspace) as svc:
-        result = svc.deprecate(artifact_id)
-        if result.success:
-            click.echo(f"ok:artifact:{artifact_id},status:deprecated")
-        else:
-            click.echo(f"error:{result.error}")
-            sys.exit(1)
-
-
-# === BATCH IMPORT/EXPORT ===
-
-
-@cli.group()
-def batch():
-    """Batch import/export operations."""
-    pass
-
-
-@batch.command("validate")
-@click.option("--workspace", "-w", required=True)
-@click.option("--file", "-f", "file_path", required=True, help="JSON file to validate")
-def batch_validate(workspace, file_path):
-    """Validate JSON file structure without importing.
-
-    Examples:
-        python kanban_manager.py batch validate -w JARVIS -f epics.json
-    """
-    from src.application.kanban.batch_service import BatchService
-
-    file_path = Path(file_path)
-    if not file_path.exists():
-        click.echo(f"error:file_not_found:{file_path}")
-        sys.exit(1)
-
-    try:
-        data = json.loads(file_path.read_text())
-    except json.JSONDecodeError as e:
-        click.echo(f"error:invalid_json:{e}")
-        sys.exit(1)
-
-    with BatchService(workspace) as svc:
-        result = svc.validate_json(data)
-
-        if result.success:
-            click.echo(f"ok:validation:passed")
-            click.echo(
-                f"  epics:{result.epics_created},sprints:{result.sprints_created},cards:{result.cards_created}"
-            )
-            if result.warnings:
-                click.echo(f"warnings:{len(result.warnings)}")
-                for w in result.warnings:
-                    click.echo(f"  - {w}")
-        else:
-            click.echo(f"error:validation:failed")
-            for e in result.errors:
-                click.echo(f"  - {e}")
-            sys.exit(1)
-
-
-@batch.command("import")
-@click.option("--workspace", "-w", required=True)
-@click.option("--file", "-f", "file_path", required=True, help="JSON file to import")
-@click.option(
-    "--type",
-    "-t",
-    "import_type",
-    type=click.Choice(["epics", "cards", "sprints", "full", "auto"]),
-    default="auto",
-    help="Import type (auto-detects from JSON structure)",
-)
-@click.option("--epic", "-e", default=None, help="Default epic ID for cards")
-@click.option("--sprint", "-s", default=None, help="Default sprint ID for cards")
-@click.option("--dry-run", is_flag=True, help="Validate without importing")
-def batch_import(workspace, file_path, import_type, epic, sprint, dry_run):
-    """Import epics, cards, or sprints from JSON file.
-
-    Examples:
-        # Import epics with nested cards
-        python kanban_manager.py batch import -w JARVIS -f epics.json -t epics
-
-        # Import cards into specific epic
-        python kanban_manager.py batch import -w JARVIS -f cards.json -t cards -e EP-001
-
-        # Import full structure (auto-detect)
-        python kanban_manager.py batch import -w JARVIS -f full.json
-
-        # Dry run (validate only)
-        python kanban_manager.py batch import -w JARVIS -f data.json --dry-run
-
-    JSON Formats:
-
-        # epics.json
-        {"epics": [{"title": "Epic 1", "priority": "high", "cards": [...]}]}
-
-        # cards.json
-        {"cards": [{"title": "Card 1", "points": 3, "epic_id": "EP-001"}]}
-
-        # sprints.json
-        {"sprints": [{"name": "Sprint 1", "goal": "...", "cards": [...]}]}
-
-        # full.json (combined)
-        {"epics": [...], "sprints": [...], "cards": [...]}
-    """
-    from src.application.kanban.batch_service import BatchService
-
-    file_path = Path(file_path)
-    if not file_path.exists():
-        click.echo(f"error:file_not_found:{file_path}")
-        sys.exit(1)
-
-    try:
-        data = json.loads(file_path.read_text())
-    except json.JSONDecodeError as e:
-        click.echo(f"error:invalid_json:{e}")
-        sys.exit(1)
-
-    with BatchService(workspace) as svc:
-        # Auto-detect type if not specified
-        if import_type == "auto":
-            if "epics" in data and "cards" not in data and "sprints" not in data:
-                import_type = "epics"
-            elif "cards" in data and "epics" not in data and "sprints" not in data:
-                import_type = "cards"
-            elif "sprints" in data and "epics" not in data and "cards" not in data:
-                import_type = "sprints"
-            else:
-                import_type = "full"
-
-        # Execute import
-        if import_type == "epics":
-            result = svc.import_epics(data.get("epics", []), dry_run=dry_run)
-        elif import_type == "cards":
-            result = svc.import_cards(
-                data.get("cards", []), epic_id=epic, sprint_id=sprint, dry_run=dry_run
-            )
-        elif import_type == "sprints":
-            result = svc.import_sprints(data.get("sprints", []), dry_run=dry_run)
-        else:
-            result = svc.import_full(data, dry_run=dry_run)
-
-        # Output result
-        mode = "dry_run" if dry_run else "imported"
-        if result.success:
-            click.echo(f"ok:batch:{mode}")
-            click.echo(
-                f"  epics:{result.epics_created},sprints:{result.sprints_created},cards:{result.cards_created}"
-            )
-            if result.warnings:
-                click.echo(f"warnings:{len(result.warnings)}")
-                for w in result.warnings[:5]:  # Limit warnings shown
-                    click.echo(f"  - {w}")
-                if len(result.warnings) > 5:
-                    click.echo(f"  ... and {len(result.warnings) - 5} more")
-        else:
-            click.echo(f"error:batch:{mode}:failed")
-            for e in result.errors:
-                click.echo(f"  - {e}")
-            sys.exit(1)
-
-
-@batch.command("export")
-@click.option("--workspace", "-w", required=True)
-@click.option("--output", "-o", "output_path", required=True, help="Output JSON file")
-@click.option(
-    "--type",
-    "-t",
-    "export_type",
-    type=click.Choice(["epics", "cards", "sprints", "full"]),
-    default="full",
-)
-@click.option("--status", "-s", default=None, help="Filter cards by status")
-@click.option("--epic", "-e", default=None, help="Filter cards by epic ID")
-@click.option("--sprint", default=None, help="Filter cards by sprint ID")
-@click.option(
-    "--include-cards/--no-cards",
-    default=True,
-    help="Include nested cards in epics/sprints",
-)
-def batch_export(
-    workspace, output_path, export_type, status, epic, sprint, include_cards
-):
-    """Export epics, cards, or sprints to JSON file.
-
-    Examples:
-        # Export full workspace
-        python kanban_manager.py batch export -w JARVIS -o backup.json
-
-        # Export only epics with cards
-        python kanban_manager.py batch export -w JARVIS -o epics.json -t epics
-
-        # Export cards filtered by status
-        python kanban_manager.py batch export -w JARVIS -o doing.json -t cards -s doing
-
-        # Export epics without nested cards
-        python kanban_manager.py batch export -w JARVIS -o epics.json -t epics --no-cards
-    """
-    from src.application.kanban.batch_service import BatchService
-
-    with BatchService(workspace) as svc:
-        if export_type == "epics":
-            result = svc.export_epics(include_cards=include_cards)
-        elif export_type == "cards":
-            result = svc.export_cards(status=status, epic_id=epic, sprint_id=sprint)
-        elif export_type == "sprints":
-            result = svc.export_sprints(include_cards=include_cards)
-        else:
-            result = svc.export_full()
-
-        if result.success:
-            output_path = Path(output_path)
-            output_path.write_text(
-                json.dumps(result.data, indent=2, ensure_ascii=False)
-            )
-
-            # Count items
-            data = result.data
-            epics_count = len(data.get("epics", []))
-            sprints_count = len(data.get("sprints", []))
-            cards_count = len(data.get("cards", []))
-
-            # Count nested cards
-            for e in data.get("epics", []):
-                cards_count += len(e.get("cards", []))
-            for s in data.get("sprints", []):
-                cards_count += len(s.get("cards", []))
-
-            click.echo(f"ok:batch:exported:{output_path}")
-            click.echo(
-                f"  epics:{epics_count},sprints:{sprints_count},cards:{cards_count}"
-            )
-        else:
-            click.echo(f"error:batch:export:{result.error}")
-            sys.exit(1)
-
-
-@batch.command("schema")
-@click.option(
-    "--type",
-    "-t",
-    "schema_type",
-    type=click.Choice(["epics", "cards", "sprints", "full"]),
-    default="full",
-)
-def batch_schema(schema_type):
-    """Show JSON schema examples for batch import.
-
-    Examples:
-        python kanban_manager.py batch schema -t epics
-        python kanban_manager.py batch schema -t full
-    """
-    schemas = {
-        "epics": {
-            "epics": [
-                {
-                    "title": "Epic Title (required)",
-                    "description": "Epic description (optional)",
-                    "priority": "high | medium | low (default: medium)",
-                    "cards": [
-                        {
-                            "title": "Card Title (required)",
-                            "description": "Card description (optional)",
-                            "priority": "high | medium | low",
-                            "story_points": "1 | 2 | 3 | 5 | 8 | 13 | 21 (optional)",
-                        }
-                    ],
-                }
-            ]
-        },
-        "cards": {
-            "cards": [
-                {
-                    "title": "Card Title (required)",
-                    "description": "Card description (optional)",
-                    "priority": "high | medium | low",
-                    "story_points": "1 | 2 | 3 | 5 | 8 | 13 | 21",
-                    "epic_id": "EP-XXX (optional, reference to existing epic)",
-                    "sprint_id": "SP-XXX (optional, reference to existing sprint)",
-                }
-            ]
-        },
-        "sprints": {
-            "sprints": [
-                {
-                    "name": "Sprint Name (required)",
-                    "goal": "Sprint goal (optional)",
-                    "weeks": "Duration in weeks (default: 2)",
-                    "cards": [
-                        {
-                            "title": "Card Title (required)",
-                            "epic_id": "EP-XXX (optional)",
-                            "story_points": "1 | 2 | 3 | 5 | 8 | 13 | 21",
-                        }
-                    ],
-                }
-            ]
-        },
-        "full": {
-            "workspace": "JARVIS (informational, not used on import)",
-            "epics": [{"title": "Epic 1", "priority": "high"}],
-            "sprints": [{"name": "Sprint 1", "goal": "Complete feature X"}],
-            "cards": [
-                {
-                    "title": "Standalone Card",
-                    "epic_id": "EP-001",
-                    "sprint_id": "SP-001",
-                }
-            ],
-        },
-    }
-
-    click.echo(json.dumps(schemas.get(schema_type, schemas["full"]), indent=2))
-
-
-if __name__ == "__main__":
-    cli()