@mc1global/opencode-jarvis 0.13.0 → 0.13.1

package/scripts/kanban_manager.py

@@ -0,0 +1,1771 @@
+#!/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()