@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/src/infrastructure/kanban/sqlite_repository.py

@@ -1,960 +0,0 @@
-"""
-SQLite Repository for Kanban bounded context.
-
-Handles database operations for sprints, epics, cards.
-Follows Repository pattern from DDD.
-Uses PathRegistry for governance-compliant path resolution.
-Uses MigrationRunner for automatic schema migrations on connect.
-"""
-
-import sqlite3
-import logging
-from pathlib import Path
-from datetime import datetime, timedelta
-from typing import Optional, List, Dict, Any
-from dataclasses import dataclass
-
-from src.shared.paths import PathRegistry
-from src.domain.governance.path_keys import PathKey
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class CardDTO:
-    """Data Transfer Object for Card."""
-
-    id: str
-    workspace: str
-    title: str
-    status: str
-    priority: str
-    assigned_agent: Optional[str] = None
-    epic_id: Optional[str] = None
-    sprint_id: Optional[str] = None
-    description: Optional[str] = None
-    story_points: Optional[int] = None
-    review_iterations: int = 0
-    max_review_iterations: int = 4
-
-
-@dataclass
-class SprintDTO:
-    """Data Transfer Object for Sprint."""
-
-    id: str
-    workspace: str
-    name: str
-    status: str
-    goal: Optional[str] = None
-
-
-@dataclass
-class EpicDTO:
-    """Data Transfer Object for Epic."""
-
-    id: str
-    workspace: str
-    title: str
-    status: str
-    priority: str
-    card_count: int = 0
-
-
-class KanbanRepository:
-    """Repository for Kanban entities using SQLite."""
-
-    def __init__(self, workspace: str = "default"):
-        self.workspace = workspace
-        self._conn: Optional[sqlite3.Connection] = None
-
-    def _get_db_path(self) -> Path:
-        """Get database path using workspace-local structure."""
-        # Import here to avoid circular imports
-        from src.shared.workspace_paths import WorkspacePathRegistry
-
-        # Check if workspace has been migrated to new structure
-        if WorkspacePathRegistry.is_migrated_workspace(self.workspace):
-            # Use new workspace-local path
-            db_path = WorkspacePathRegistry.get_workspace_kanban_db(self.workspace)
-            # Ensure directory exists
-            db_path.parent.mkdir(parents=True, exist_ok=True)
-            return db_path
-        else:
-            # Fallback to old centralized path for backward compatibility
-            base = PathRegistry.ensure_dir(PathKey.KANBAN_DATA)
-            return base / f"{self.workspace}_kanban.db"
-
-    def _get_schema_path(self) -> Path:
-        """Get schema path using governance PathRegistry."""
-        domain_path = PathRegistry.get(PathKey.PROJECT_DOMAIN)
-        return domain_path / "kanban" / "schema.sql"
-
-    def connect(self) -> "KanbanRepository":
-        """Connect to database with automatic schema migration."""
-        db_path = self._get_db_path()
-
-        # Lazy import to avoid circular dependency
-        from src.application.kanban.migration_runner import MigrationRunner
-
-        # Ensure schema is up-to-date before connecting
-        result = MigrationRunner.ensure_schema(db_path)
-        if not result.success:
-            logger.error(f"Schema migration failed: {result.error}")
-        elif result.migrations_applied > 0:
-            logger.info(
-                f"Applied {result.migrations_applied} migrations to {db_path.name}"
-            )
-
-        # Connect to database
-        self._conn = sqlite3.connect(str(db_path))
-        self._conn.row_factory = sqlite3.Row
-
-        # Only apply schema.sql for NEW databases (no tables yet)
-        # For existing databases, migrations handle schema updates
-        cursor = self._conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name='cards'"
-        )
-        is_new_db = not cursor.fetchone()
-
-        if is_new_db:
-            # New database - apply full schema
-            schema = self._get_schema_path()
-            if schema.exists():
-                self._conn.executescript(schema.read_text())
-                self._conn.commit()
-                logger.info(f"Applied base schema to new database: {db_path.name}")
-
-            # After applying base schema, run migrations to bring to current version
-            # This ensures new databases get latest schema without manually updating schema.sql
-            self._conn.close()
-            migration_result = MigrationRunner.ensure_schema(db_path)
-            if migration_result.migrations_applied > 0:
-                logger.info(
-                    f"Applied {migration_result.migrations_applied} migrations to new database"
-                )
-            # Reconnect after migrations
-            self._conn = sqlite3.connect(str(db_path))
-            self._conn.row_factory = sqlite3.Row
-
-        return self
-
-    def close(self) -> None:
-        if self._conn:
-            self._conn.close()
-            self._conn = None
-
-    def __enter__(self) -> "KanbanRepository":
-        return self.connect()
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        self.close()
-
-    def _now(self) -> str:
-        return datetime.utcnow().isoformat() + "Z"
-
-    def _generate_id(self, prefix: str, table: str) -> str:
-        cursor = self._conn.execute(f"SELECT id FROM {table} ORDER BY id DESC LIMIT 1")
-        row = cursor.fetchone()
-        num = int(row["id"].split("-")[1]) + 1 if row else 1
-        return f"{prefix}-{num:03d}"
-
-    # === SPRINT ===
-
-    def create_sprint(self, name: str, goal: str = "", weeks: int = 2) -> SprintDTO:
-        sprint_id = self._generate_id("SP", "sprints")
-        start = datetime.utcnow()
-        end = start + timedelta(weeks=weeks)
-        self._conn.execute(
-            "INSERT INTO sprints (id, workspace, name, goal, start_date, end_date, status) VALUES (?, ?, ?, ?, ?, ?, 'planning')",
-            (
-                sprint_id,
-                self.workspace,
-                name,
-                goal,
-                start.isoformat() + "Z",
-                end.isoformat() + "Z",
-            ),
-        )
-        self._conn.commit()
-        return SprintDTO(
-            id=sprint_id,
-            workspace=self.workspace,
-            name=name,
-            status="planning",
-            goal=goal,
-        )
-
-    def list_sprints(self, status: Optional[str] = None) -> List[SprintDTO]:
-        query = "SELECT * FROM sprints WHERE workspace = ?"
-        params = [self.workspace]
-        if status:
-            query += " AND status = ?"
-            params.append(status)
-        cursor = self._conn.execute(query + " ORDER BY created_at DESC", params)
-        return [
-            SprintDTO(
-                id=r["id"],
-                workspace=r["workspace"],
-                name=r["name"],
-                status=r["status"],
-                goal=r["goal"],
-            )
-            for r in cursor.fetchall()
-        ]
-
-    def get_sprint(self, sprint_id: str) -> Optional[SprintDTO]:
-        cursor = self._conn.execute("SELECT * FROM sprints WHERE id = ?", (sprint_id,))
-        r = cursor.fetchone()
-        return (
-            SprintDTO(
-                id=r["id"],
-                workspace=r["workspace"],
-                name=r["name"],
-                status=r["status"],
-                goal=r["goal"],
-            )
-            if r
-            else None
-        )
-
-    def activate_sprint(self, sprint_id: str) -> bool:
-        sprint = self.get_sprint(sprint_id)
-        if not sprint or sprint.status != "planning":
-            return False
-        self._conn.execute(
-            "UPDATE sprints SET status = 'closed', updated_at = ? WHERE workspace = ? AND status = 'active'",
-            (self._now(), self.workspace),
-        )
-        self._conn.execute(
-            "UPDATE sprints SET status = 'active', updated_at = ? WHERE id = ?",
-            (self._now(), sprint_id),
-        )
-        self._conn.commit()
-        return True
-
-    def close_sprint(self, sprint_id: str) -> int:
-        cursor = self._conn.execute(
-            "SELECT SUM(story_points) FROM cards WHERE sprint_id = ? AND status = 'done'",
-            (sprint_id,),
-        )
-        velocity = cursor.fetchone()[0] or 0
-        self._conn.execute(
-            "UPDATE sprints SET status = 'closed', velocity_actual = ?, updated_at = ? WHERE id = ?",
-            (velocity, self._now(), sprint_id),
-        )
-        self._conn.commit()
-        return velocity
-
-    def count_sprint_cards(self, sprint_id: str) -> int:
-        cursor = self._conn.execute(
-            "SELECT COUNT(*) FROM cards WHERE sprint_id = ?", (sprint_id,)
-        )
-        return cursor.fetchone()[0]
-
-    # === EPIC ===
-
-    def create_epic(
-        self, title: str, description: str = "", priority: str = "medium"
-    ) -> EpicDTO:
-        epic_id = self._generate_id("EP", "epics")
-        self._conn.execute(
-            "INSERT INTO epics (id, workspace, title, description, priority) VALUES (?, ?, ?, ?, ?)",
-            (epic_id, self.workspace, title, description, priority),
-        )
-        self._conn.commit()
-        return EpicDTO(
-            id=epic_id,
-            workspace=self.workspace,
-            title=title,
-            status="backlog",
-            priority=priority,
-        )
-
-    def list_epics(self) -> List[EpicDTO]:
-        cursor = self._conn.execute(
-            """
-            SELECT e.*, COUNT(c.id) as card_count FROM epics e
-            LEFT JOIN cards c ON c.epic_id = e.id WHERE e.workspace = ?
-            GROUP BY e.id ORDER BY e.priority DESC, e.created_at
-        """,
-            (self.workspace,),
-        )
-        return [
-            EpicDTO(
-                id=r["id"],
-                workspace=r["workspace"],
-                title=r["title"],
-                status=r["status"],
-                priority=r["priority"],
-                card_count=r["card_count"],
-            )
-            for r in cursor.fetchall()
-        ]
-
-    # === CARD ===
-
-    def create_card(
-        self,
-        title: str,
-        epic_id: Optional[str] = None,
-        sprint_id: Optional[str] = None,
-        description: str = "",
-        priority: str = "medium",
-        story_points: Optional[int] = None,
-        user_story_id: Optional[str] = None,
-    ) -> CardDTO:
-        card_id = self._generate_id("CD", "cards")
-        self._conn.execute(
-            "INSERT INTO cards (id, workspace, epic_id, sprint_id, user_story_id, title, description, priority, story_points) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
-            (
-                card_id,
-                self.workspace,
-                epic_id,
-                sprint_id,
-                user_story_id,
-                title,
-                description,
-                priority,
-                story_points,
-            ),
-        )
-        self._conn.commit()
-        return CardDTO(
-            id=card_id,
-            workspace=self.workspace,
-            title=title,
-            status="backlog",
-            priority=priority,
-        )
-
-    def get_card(self, card_id: str) -> Optional[CardDTO]:
-        cursor = self._conn.execute("SELECT * FROM cards WHERE id = ?", (card_id,))
-        r = cursor.fetchone()
-        if not r:
-            return None
-        return CardDTO(
-            id=r["id"],
-            workspace=r["workspace"],
-            title=r["title"],
-            status=r["status"],
-            priority=r["priority"],
-            assigned_agent=r["assigned_agent"],
-            epic_id=r["epic_id"],
-            sprint_id=r["sprint_id"],
-            description=r["description"],
-            story_points=r["story_points"],
-            review_iterations=r["review_iterations"],
-            max_review_iterations=r["max_review_iterations"],
-        )
-
-    def update_card_status(
-        self, card_id: str, status: str, previous_status: Optional[str] = None
-    ) -> bool:
-        updates = {"status": status, "updated_at": self._now()}
-        if previous_status and status == "blocked":
-            updates["previous_status"] = previous_status
-        if status == "doing":
-            updates["started_at"] = self._now()
-        elif status == "review":
-            updates["completed_at"] = self._now()
-        elif status == "done":
-            updates["completed_at"] = self._now()
-        set_clause = ", ".join(f"{k} = ?" for k in updates.keys())
-        self._conn.execute(
-            f"UPDATE cards SET {set_clause} WHERE id = ?",
-            list(updates.values()) + [card_id],
-        )
-        self._conn.commit()
-        return True
-
-    def update_card(
-        self,
-        card_id: str,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        priority: Optional[str] = None,
-        story_points: Optional[int] = None,
-        epic_id: Optional[str] = None,
-        sprint_id: Optional[str] = None,
-    ) -> bool:
-        """Update card fields. Only updates provided fields."""
-        updates = {"updated_at": self._now()}
-
-        if title is not None:
-            updates["title"] = title
-        if description is not None:
-            updates["description"] = description
-        if priority is not None:
-            if priority not in ["high", "medium", "low"]:
-                raise ValueError(
-                    f"Invalid priority: {priority}. Must be high, medium, or low"
-                )
-            updates["priority"] = priority
-        if story_points is not None:
-            if story_points not in [1, 2, 3, 5, 8, 13, 21]:
-                raise ValueError(
-                    f"Invalid story points: {story_points}. Must be 1, 2, 3, 5, 8, 13, or 21"
-                )
-            updates["story_points"] = story_points
-        if epic_id is not None:
-            updates["epic_id"] = epic_id if epic_id != "" else None
-        if sprint_id is not None:
-            updates["sprint_id"] = sprint_id if sprint_id != "" else None
-
-        if len(updates) == 1:  # Only updated_at was added
-            return False  # No actual updates to perform
-
-        set_clause = ", ".join(f"{k} = ?" for k in updates.keys())
-        self._conn.execute(
-            f"UPDATE cards SET {set_clause} WHERE id = ?",
-            list(updates.values()) + [card_id],
-        )
-        self._conn.commit()
-        return True
-
-    def assign_card(self, card_id: str, agent: str) -> bool:
-        self._conn.execute(
-            "UPDATE cards SET assigned_agent = ?, updated_at = ? WHERE id = ?",
-            (agent, self._now(), card_id),
-        )
-        self._conn.commit()
-        return True
-
-    def list_cards(
-        self,
-        status: Optional[str] = None,
-        sprint_id: Optional[str] = None,
-        agent: Optional[str] = None,
-        epic_id: Optional[str] = None,
-    ) -> List[CardDTO]:
-        query, params = "SELECT * FROM cards WHERE workspace = ?", [self.workspace]
-        if status:
-            query += " AND status = ?"
-            params.append(status)
-        if sprint_id:
-            query += " AND sprint_id = ?"
-            params.append(sprint_id)
-        if agent:
-            query += " AND assigned_agent = ?"
-            params.append(agent)
-        if epic_id:
-            query += " AND epic_id = ?"
-            params.append(epic_id)
-        cursor = self._conn.execute(
-            query + " ORDER BY priority DESC, created_at", params
-        )
-        return [
-            CardDTO(
-                id=r["id"],
-                workspace=r["workspace"],
-                title=r["title"],
-                status=r["status"],
-                priority=r["priority"],
-                assigned_agent=r["assigned_agent"],
-                epic_id=r["epic_id"],
-                sprint_id=r["sprint_id"],
-                story_points=r["story_points"],
-                review_iterations=r["review_iterations"]
-                if r["review_iterations"]
-                else 0,
-                max_review_iterations=r["max_review_iterations"]
-                if r["max_review_iterations"]
-                else 4,
-            )
-            for r in cursor.fetchall()
-        ]
-
-    def get_next_ready_card(self, agent: str) -> Optional[CardDTO]:
-        cursor = self._conn.execute(
-            "SELECT * FROM cards WHERE workspace = ? AND status = 'ready' AND (assigned_agent IS NULL OR assigned_agent = ?) ORDER BY priority DESC, created_at LIMIT 1",
-            (self.workspace, agent),
-        )
-        r = cursor.fetchone()
-        return (
-            CardDTO(
-                id=r["id"],
-                workspace=r["workspace"],
-                title=r["title"],
-                status=r["status"],
-                priority=r["priority"],
-            )
-            if r
-            else None
-        )
-
-    # === REVIEW ===
-
-    def add_review(
-        self, card_id: str, reviewer: str, passed: bool, feedback: str
-    ) -> Dict[str, Any]:
-        """
-        Add a review to a card.
-
-        Enforces:
-        - Card must exist and be in 'review' status
-        - Self-review prevention: reviewer cannot be the assigned agent
-        - Max review iterations (4) before rejection
-        """
-        card = self.get_card(card_id)
-        if not card:
-            return {"error": "card_not_found"}
-
-        if card.status != "review":
-            return {"error": f"card_not_in_review:current_status={card.status}"}
-
-        # SELF-REVIEW PREVENTION: reviewer cannot be the implementer
-        if card.assigned_agent and reviewer.lower() == card.assigned_agent.lower():
-            return {
-                "error": f"self_review_not_allowed:agent {reviewer} cannot review their own work"
-            }
-
-        iteration = card.review_iterations + 1
-        self._conn.execute(
-            "INSERT INTO reviews (card_id, iteration, reviewer, passed, feedback) VALUES (?, ?, ?, ?, ?)",
-            (card_id, iteration, reviewer, 1 if passed else 0, feedback),
-        )
-        new_status = (
-            "tested"
-            if passed
-            else ("rejected" if iteration >= card.max_review_iterations else "doing")
-        )
-        self._conn.execute(
-            "UPDATE cards SET status = ?, review_iterations = ?, updated_at = ? WHERE id = ?",
-            (new_status, iteration, self._now(), card_id),
-        )
-        self._conn.commit()
-        return {
-            "iteration": iteration,
-            "max_iterations": card.max_review_iterations,
-            "passed": passed,
-            "new_status": new_status,
-        }
-
-    # === ACTIVITY ===
-
-    def log_activity(
-        self, card_id: str, agent: str, action: str, details: str = ""
-    ) -> None:
-        self._conn.execute(
-            "INSERT INTO card_activities (card_id, agent, action, details) VALUES (?, ?, ?, ?)",
-            (card_id, agent, action, details),
-        )
-        self._conn.commit()
-
-    def get_activities(self, card_id: str, limit: int = 10) -> List[Dict[str, Any]]:
-        cursor = self._conn.execute(
-            "SELECT * FROM card_activities WHERE card_id = ? ORDER BY created_at DESC LIMIT ?",
-            (card_id, limit),
-        )
-        return [dict(r) for r in cursor.fetchall()]
-
-    # === ARTIFACTS ===
-
-    def add_artifact(
-        self,
-        card_id: str,
-        artifact_type: str,
-        title: str,
-        content: str,
-        fmt: str = "markdown",
-        created_by: str = "opencode",
-        file_path: Optional[str] = None,
-    ) -> None:
-        self._conn.execute(
-            "INSERT INTO artifacts (card_id, type, title, content, format, created_by, file_path) VALUES (?, ?, ?, ?, ?, ?, ?)",
-            (card_id, artifact_type, title, content, fmt, created_by, file_path),
-        )
-        self._conn.commit()
-
-    def add_deliverable(
-        self,
-        card_id: str,
-        deliv_type: str,
-        description: str,
-        file_path: Optional[str] = None,
-        acceptance: str = "",
-    ) -> None:
-        self._conn.execute(
-            "INSERT INTO deliverables (card_id, type, description, file_path, acceptance) VALUES (?, ?, ?, ?, ?)",
-            (card_id, deliv_type, description, file_path, acceptance),
-        )
-        self._conn.commit()
-
-    def add_acceptance_criteria(
-        self, card_id: str, given: str, when: str, then: str
-    ) -> str:
-        cursor = self._conn.execute(
-            "SELECT COUNT(*) FROM acceptance_criteria WHERE card_id = ?", (card_id,)
-        )
-        ac_id = f"AC-{cursor.fetchone()[0] + 1:03d}"
-        self._conn.execute(
-            "INSERT INTO acceptance_criteria (id, card_id, given_clause, when_clause, then_clause) VALUES (?, ?, ?, ?, ?)",
-            (ac_id, card_id, given, when, then),
-        )
-        self._conn.commit()
-        return ac_id
-
-    # === BLOCKERS ===
-
-    def block_card(
-        self, card_id: str, reason: str, blocked_by: Optional[str] = None
-    ) -> bool:
-        card = self.get_card(card_id)
-        if not card:
-            return False
-        self._conn.execute(
-            "INSERT INTO blockers (card_id, description, blocked_by) VALUES (?, ?, ?)",
-            (card_id, reason, blocked_by),
-        )
-        self._conn.execute(
-            "UPDATE cards SET status = 'blocked', previous_status = ?, updated_at = ? WHERE id = ?",
-            (card.status, self._now(), card_id),
-        )
-        self._conn.commit()
-        return True
-
-    def unblock_card(self, card_id: str) -> Optional[str]:
-        cursor = self._conn.execute(
-            "SELECT status, previous_status FROM cards WHERE id = ?", (card_id,)
-        )
-        row = cursor.fetchone()
-        if not row or row["status"] != "blocked":
-            return None
-        target = row["previous_status"] or "backlog"
-        self._conn.execute(
-            "UPDATE blockers SET resolved = 1, resolved_at = ? WHERE card_id = ? AND resolved = 0",
-            (self._now(), card_id),
-        )
-        self._conn.execute(
-            "UPDATE cards SET status = ?, previous_status = NULL, updated_at = ? WHERE id = ?",
-            (target, self._now(), card_id),
-        )
-        self._conn.commit()
-        return target
-
-    # === STATS ===
-
-    def get_board_stats(self, sprint_id: Optional[str] = None) -> Dict[str, int]:
-        query, params = (
-            "SELECT status, COUNT(*) as count FROM cards WHERE workspace = ?",
-            [self.workspace],
-        )
-        if sprint_id:
-            query += " AND sprint_id = ?"
-            params.append(sprint_id)
-        cursor = self._conn.execute(query + " GROUP BY status", params)
-        return {r["status"]: r["count"] for r in cursor.fetchall()}
-
-    def get_workspace_stats(self) -> Dict[str, Any]:
-        cursor = self._conn.execute(
-            "SELECT status, COUNT(*) FROM sprints WHERE workspace = ? GROUP BY status",
-            (self.workspace,),
-        )
-        sprint_stats = {r[0]: r[1] for r in cursor.fetchall()}
-        cursor = self._conn.execute(
-            "SELECT status, COUNT(*) FROM cards WHERE workspace = ? GROUP BY status",
-            (self.workspace,),
-        )
-        card_stats = {r[0]: r[1] for r in cursor.fetchall()}
-        cursor = self._conn.execute(
-            "SELECT AVG(velocity_actual) FROM sprints WHERE workspace = ? AND status = 'closed' AND velocity_actual > 0",
-            (self.workspace,),
-        )
-        return {
-            "sprints": sprint_stats,
-            "cards": card_stats,
-            "avg_velocity": cursor.fetchone()[0] or 0,
-        }
-
-    # === TOKEN USAGE ===
-
-    def add_token_usage(
-        self,
-        agent: str,
-        operation: str,
-        input_tokens: int,
-        output_tokens: int,
-        card_id: Optional[str] = None,
-        sprint_id: Optional[str] = None,
-        model: Optional[str] = None,
-        cost_usd: Optional[float] = None,
-        session_id: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> str:
-        """
-        Record token usage for an agent operation.
-
-        Args:
-            agent: Agent that consumed tokens
-            operation: Type of operation (implementation, review, fix, planning, grooming, other)
-            input_tokens: Number of input tokens
-            output_tokens: Number of output tokens
-            card_id: Optional card ID this usage relates to
-            sprint_id: Optional sprint ID this usage relates to
-            model: LLM model used
-            cost_usd: Estimated cost in USD
-            session_id: Session/conversation identifier
-            metadata: Additional context as JSON
-
-        Returns:
-            Token usage ID
-        """
-        import uuid
-        import json
-
-        usage_id = f"TU-{uuid.uuid4().hex[:12].upper()}"
-        metadata_json = json.dumps(metadata) if metadata else None
-
-        self._conn.execute(
-            """
-            INSERT INTO token_usage 
-            (id, workspace, card_id, sprint_id, agent, operation, 
-             input_tokens, output_tokens, model, cost_usd, session_id, metadata)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                usage_id,
-                self.workspace,
-                card_id,
-                sprint_id,
-                agent,
-                operation,
-                input_tokens,
-                output_tokens,
-                model,
-                cost_usd,
-                session_id,
-                metadata_json,
-            ),
-        )
-        self._conn.commit()
-        return usage_id
-
-    def get_token_usage(self, usage_id: str) -> Optional[Dict[str, Any]]:
-        """Get a single token usage record by ID."""
-        cursor = self._conn.execute(
-            "SELECT * FROM token_usage WHERE id = ?", (usage_id,)
-        )
-        row = cursor.fetchone()
-        return dict(row) if row else None
-
-    def list_token_usage(
-        self,
-        agent: Optional[str] = None,
-        card_id: Optional[str] = None,
-        sprint_id: Optional[str] = None,
-        operation: Optional[str] = None,
-        session_id: Optional[str] = None,
-        limit: int = 100,
-    ) -> List[Dict[str, Any]]:
-        """
-        List token usage records with optional filters.
-
-        Args:
-            agent: Filter by agent
-            card_id: Filter by card
-            sprint_id: Filter by sprint
-            operation: Filter by operation type
-            session_id: Filter by session
-            limit: Maximum records to return
-
-        Returns:
-            List of token usage records
-        """
-        query = "SELECT * FROM token_usage WHERE workspace = ? AND status = 'active'"
-        params: List[Any] = [self.workspace]
-
-        if agent:
-            query += " AND agent = ?"
-            params.append(agent)
-        if card_id:
-            query += " AND card_id = ?"
-            params.append(card_id)
-        if sprint_id:
-            query += " AND sprint_id = ?"
-            params.append(sprint_id)
-        if operation:
-            query += " AND operation = ?"
-            params.append(operation)
-        if session_id:
-            query += " AND session_id = ?"
-            params.append(session_id)
-
-        query += " ORDER BY created_at DESC LIMIT ?"
-        params.append(limit)
-
-        cursor = self._conn.execute(query, params)
-        return [dict(row) for row in cursor.fetchall()]
-
-    def get_token_metrics_by_agent(
-        self, agent: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
-        """
-        Get aggregated token metrics by agent.
-
-        Args:
-            agent: Optional specific agent to filter
-
-        Returns:
-            List of metrics per agent/operation
-        """
-        query = """
-            SELECT 
-                agent,
-                operation,
-                COUNT(*) as usage_count,
-                SUM(input_tokens) as total_input,
-                SUM(output_tokens) as total_output,
-                SUM(total_tokens) as total_tokens,
-                SUM(cost_usd) as total_cost_usd,
-                AVG(total_tokens) as avg_tokens
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active'
-        """
-        params: List[Any] = [self.workspace]
-
-        if agent:
-            query += " AND agent = ?"
-            params.append(agent)
-
-        query += " GROUP BY agent, operation ORDER BY agent, total_tokens DESC"
-
-        cursor = self._conn.execute(query, params)
-        return [dict(row) for row in cursor.fetchall()]
-
-    def get_token_metrics_by_card(
-        self, card_id: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
-        """
-        Get aggregated token metrics by card.
-
-        Args:
-            card_id: Optional specific card to filter
-
-        Returns:
-            List of metrics per card
-        """
-        query = """
-            SELECT 
-                card_id,
-                COUNT(*) as usage_count,
-                SUM(input_tokens) as total_input,
-                SUM(output_tokens) as total_output,
-                SUM(total_tokens) as total_tokens,
-                SUM(cost_usd) as total_cost_usd,
-                COUNT(DISTINCT agent) as agents_count
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active' AND card_id IS NOT NULL
-        """
-        params: List[Any] = [self.workspace]
-
-        if card_id:
-            query += " AND card_id = ?"
-            params.append(card_id)
-
-        query += " GROUP BY card_id ORDER BY total_tokens DESC"
-
-        cursor = self._conn.execute(query, params)
-        return [dict(row) for row in cursor.fetchall()]
-
-    def get_token_metrics_by_sprint(
-        self, sprint_id: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
-        """
-        Get aggregated token metrics by sprint.
-
-        Args:
-            sprint_id: Optional specific sprint to filter
-
-        Returns:
-            List of metrics per sprint
-        """
-        query = """
-            SELECT 
-                sprint_id,
-                COUNT(*) as usage_count,
-                SUM(input_tokens) as total_input,
-                SUM(output_tokens) as total_output,
-                SUM(total_tokens) as total_tokens,
-                SUM(cost_usd) as total_cost_usd,
-                COUNT(DISTINCT card_id) as cards_count,
-                COUNT(DISTINCT agent) as agents_count
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active' AND sprint_id IS NOT NULL
-        """
-        params: List[Any] = [self.workspace]
-
-        if sprint_id:
-            query += " AND sprint_id = ?"
-            params.append(sprint_id)
-
-        query += " GROUP BY sprint_id ORDER BY total_tokens DESC"
-
-        cursor = self._conn.execute(query, params)
-        return [dict(row) for row in cursor.fetchall()]
-
-    def get_token_metrics_summary(self) -> Dict[str, Any]:
-        """
-        Get overall token metrics summary for workspace.
-
-        Returns:
-            Dict with total metrics and breakdowns
-        """
-        # Overall totals
-        cursor = self._conn.execute(
-            """
-            SELECT 
-                COUNT(*) as total_records,
-                SUM(input_tokens) as total_input,
-                SUM(output_tokens) as total_output,
-                SUM(total_tokens) as total_tokens,
-                SUM(cost_usd) as total_cost_usd,
-                COUNT(DISTINCT agent) as unique_agents,
-                COUNT(DISTINCT card_id) as unique_cards,
-                COUNT(DISTINCT sprint_id) as unique_sprints
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active'
-            """,
-            (self.workspace,),
-        )
-        totals = dict(cursor.fetchone())
-
-        # By operation type
-        cursor = self._conn.execute(
-            """
-            SELECT operation, SUM(total_tokens) as tokens, COUNT(*) as count
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active'
-            GROUP BY operation
-            """,
-            (self.workspace,),
-        )
-        by_operation = {
-            row["operation"]: {"tokens": row["tokens"], "count": row["count"]}
-            for row in cursor.fetchall()
-        }
-
-        # Top agents by tokens
-        cursor = self._conn.execute(
-            """
-            SELECT agent, SUM(total_tokens) as tokens
-            FROM token_usage 
-            WHERE workspace = ? AND status = 'active'
-            GROUP BY agent
-            ORDER BY tokens DESC
-            LIMIT 5
-            """,
-            (self.workspace,),
-        )
-        top_agents = [
-            {"agent": row["agent"], "tokens": row["tokens"]}
-            for row in cursor.fetchall()
-        ]
-
-        return {
-            "workspace": self.workspace,
-            "totals": totals,
-            "by_operation": by_operation,
-            "top_agents": top_agents,
-        }