draft-board 0.1.0-beta.0

package/app/backend/alembic/versions/012_add_boards_table.py

@@ -0,0 +1,102 @@
+"""Add boards table and board_id to goals/tickets/jobs/workspaces.
+
+Revision ID: 012
+Revises: 011
+Create Date: 2026-01-08
+
+The Board is the primary permission boundary in Draft:
+- All goals, tickets, jobs, workspaces belong to a board
+- board_id is the authorization check for all operations
+- repo_root is a property of the board (single repo per board)
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "012"
+down_revision: str | None = "011"
+branch_labels: str | tuple[str, ...] | None = None
+depends_on: str | tuple[str, ...] | None = None
+
+
+def upgrade() -> None:
+    # Create boards table
+    op.create_table(
+        "boards",
+        sa.Column("id", sa.String(36), primary_key=True),
+        sa.Column("name", sa.String(255), nullable=False),
+        sa.Column("description", sa.Text(), nullable=True),
+        sa.Column("repo_root", sa.String(1024), nullable=False),
+        sa.Column("default_branch", sa.String(255), nullable=True),
+        sa.Column(
+            "created_at", sa.DateTime(timezone=True), server_default=sa.func.now()
+        ),
+        sa.Column(
+            "updated_at", sa.DateTime(timezone=True), server_default=sa.func.now()
+        ),
+    )
+
+    # Add board_id to goals (using batch mode for SQLite compatibility)
+    with op.batch_alter_table("goals") as batch_op:
+        batch_op.add_column(sa.Column("board_id", sa.String(36), nullable=True))
+        batch_op.create_index("ix_goals_board_id", ["board_id"])
+        batch_op.create_foreign_key(
+            "fk_goals_board_id", "boards", ["board_id"], ["id"], ondelete="CASCADE"
+        )
+
+    # Add board_id to tickets
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.add_column(sa.Column("board_id", sa.String(36), nullable=True))
+        batch_op.create_index("ix_tickets_board_id", ["board_id"])
+        batch_op.create_foreign_key(
+            "fk_tickets_board_id", "boards", ["board_id"], ["id"], ondelete="CASCADE"
+        )
+
+    # Add board_id to jobs
+    with op.batch_alter_table("jobs") as batch_op:
+        batch_op.add_column(sa.Column("board_id", sa.String(36), nullable=True))
+        batch_op.create_index("ix_jobs_board_id", ["board_id"])
+        batch_op.create_foreign_key(
+            "fk_jobs_board_id", "boards", ["board_id"], ["id"], ondelete="CASCADE"
+        )
+
+    # Add board_id to workspaces
+    with op.batch_alter_table("workspaces") as batch_op:
+        batch_op.add_column(sa.Column("board_id", sa.String(36), nullable=True))
+        batch_op.create_index("ix_workspaces_board_id", ["board_id"])
+        batch_op.create_foreign_key(
+            "fk_workspaces_board_id", "boards", ["board_id"], ["id"], ondelete="CASCADE"
+        )
+
+
+def downgrade() -> None:
+    # Drop foreign keys and columns in reverse order (using batch mode for SQLite)
+
+    # workspaces
+    with op.batch_alter_table("workspaces") as batch_op:
+        batch_op.drop_constraint("fk_workspaces_board_id", type_="foreignkey")
+        batch_op.drop_index("ix_workspaces_board_id")
+        batch_op.drop_column("board_id")
+
+    # jobs
+    with op.batch_alter_table("jobs") as batch_op:
+        batch_op.drop_constraint("fk_jobs_board_id", type_="foreignkey")
+        batch_op.drop_index("ix_jobs_board_id")
+        batch_op.drop_column("board_id")
+
+    # tickets
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.drop_constraint("fk_tickets_board_id", type_="foreignkey")
+        batch_op.drop_index("ix_tickets_board_id")
+        batch_op.drop_column("board_id")
+
+    # goals
+    with op.batch_alter_table("goals") as batch_op:
+        batch_op.drop_constraint("fk_goals_board_id", type_="foreignkey")
+        batch_op.drop_index("ix_goals_board_id")
+        batch_op.drop_column("board_id")
+
+    # boards table
+    op.drop_table("boards")

package/app/backend/alembic/versions/013_add_ticket_blocking.py

@@ -0,0 +1,45 @@
+"""Add ticket blocking/dependency support.
+
+Revision ID: 013
+Revises: 012
+Create Date: 2026-01-11
+
+Adds blocked_by_ticket_id to tickets table to support ticket dependencies.
+When a ticket is blocked by another ticket, it cannot be queued for execution
+until the blocking ticket is completed.
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "013"
+down_revision: str | None = "012"
+branch_labels: str | tuple[str, ...] | None = None
+depends_on: str | tuple[str, ...] | None = None
+
+
+def upgrade() -> None:
+    # Add blocked_by_ticket_id to tickets (self-referential FK)
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.add_column(
+            sa.Column("blocked_by_ticket_id", sa.String(36), nullable=True)
+        )
+        batch_op.create_index(
+            "ix_tickets_blocked_by_ticket_id", ["blocked_by_ticket_id"]
+        )
+        batch_op.create_foreign_key(
+            "fk_tickets_blocked_by_ticket_id",
+            "tickets",
+            ["blocked_by_ticket_id"],
+            ["id"],
+            ondelete="SET NULL",  # If blocker is deleted, unblock this ticket
+        )
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.drop_constraint("fk_tickets_blocked_by_ticket_id", type_="foreignkey")
+        batch_op.drop_index("ix_tickets_blocked_by_ticket_id")
+        batch_op.drop_column("blocked_by_ticket_id")

package/app/backend/alembic/versions/014_add_agent_sessions.py

@@ -0,0 +1,220 @@
+"""Add agent sessions and messages tables for conversation continuity and cost tracking.
+
+Revision ID: 014
+Revises: 013
+Create Date: 2026-01-12
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "014"
+down_revision: str | None = "013"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def table_exists(table_name: str) -> bool:
+    """Check if a table exists in SQLite."""
+    from alembic import op
+
+    conn = op.get_bind()
+    result = conn.execute(
+        sa.text(
+            f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table_name}'"
+        )
+    )
+    return result.fetchone() is not None
+
+
+def column_exists(table_name: str, column_name: str) -> bool:
+    """Check if a column exists in a SQLite table."""
+    from alembic import op
+
+    conn = op.get_bind()
+    result = conn.execute(sa.text(f"PRAGMA table_info({table_name})"))
+    columns = [row[1] for row in result.fetchall()]
+    return column_name in columns
+
+
+def index_exists(index_name: str) -> bool:
+    """Check if an index exists in SQLite."""
+    from alembic import op
+
+    conn = op.get_bind()
+    result = conn.execute(
+        sa.text(
+            f"SELECT name FROM sqlite_master WHERE type='index' AND name='{index_name}'"
+        )
+    )
+    return result.fetchone() is not None
+
+
+def upgrade() -> None:
+    # Create agent_sessions table if it doesn't exist
+    if not table_exists("agent_sessions"):
+        op.create_table(
+            "agent_sessions",
+            sa.Column("id", sa.String(36), primary_key=True),
+            sa.Column(
+                "ticket_id",
+                sa.String(36),
+                sa.ForeignKey("tickets.id", ondelete="CASCADE"),
+                nullable=False,
+                index=True,
+            ),
+            sa.Column(
+                "job_id",
+                sa.String(36),
+                sa.ForeignKey("jobs.id", ondelete="SET NULL"),
+                nullable=True,
+                index=True,
+            ),
+            # Agent identification
+            sa.Column("agent_type", sa.String(50), nullable=False),
+            sa.Column(
+                "agent_session_id", sa.String(255), nullable=True
+            ),  # External session ID
+            # Session state
+            sa.Column("is_active", sa.Boolean, default=True, nullable=False),
+            sa.Column("turn_count", sa.Integer, default=0, nullable=False),
+            # Token tracking
+            sa.Column("total_input_tokens", sa.Integer, default=0, nullable=False),
+            sa.Column("total_output_tokens", sa.Integer, default=0, nullable=False),
+            sa.Column("estimated_cost_usd", sa.Float, default=0.0, nullable=False),
+            # Context
+            sa.Column("last_prompt", sa.Text, nullable=True),
+            sa.Column("last_response_summary", sa.Text, nullable=True),
+            sa.Column("metadata", sa.JSON, nullable=True),
+            # Timestamps
+            sa.Column(
+                "created_at", sa.DateTime, server_default=sa.func.now(), nullable=False
+            ),
+            sa.Column(
+                "updated_at",
+                sa.DateTime,
+                server_default=sa.func.now(),
+                onupdate=sa.func.now(),
+                nullable=False,
+            ),
+            sa.Column("ended_at", sa.DateTime, nullable=True),
+        )
+
+    # Create agent_messages table if it doesn't exist
+    if not table_exists("agent_messages"):
+        op.create_table(
+            "agent_messages",
+            sa.Column("id", sa.String(36), primary_key=True),
+            sa.Column(
+                "session_id",
+                sa.String(36),
+                sa.ForeignKey("agent_sessions.id", ondelete="CASCADE"),
+                nullable=False,
+                index=True,
+            ),
+            # Message content
+            sa.Column(
+                "role", sa.String(20), nullable=False
+            ),  # user, assistant, system, tool
+            sa.Column("content", sa.Text, nullable=False),
+            # Token counts
+            sa.Column("input_tokens", sa.Integer, default=0, nullable=False),
+            sa.Column("output_tokens", sa.Integer, default=0, nullable=False),
+            # Tool tracking
+            sa.Column("tool_name", sa.String(100), nullable=True),
+            sa.Column("tool_input", sa.JSON, nullable=True),
+            sa.Column("tool_output", sa.Text, nullable=True),
+            # Metadata
+            sa.Column("metadata", sa.JSON, nullable=True),
+            sa.Column(
+                "created_at", sa.DateTime, server_default=sa.func.now(), nullable=False
+            ),
+        )
+
+    # Create cost_budgets table if it doesn't exist
+    if not table_exists("cost_budgets"):
+        op.create_table(
+            "cost_budgets",
+            sa.Column("id", sa.String(36), primary_key=True),
+            sa.Column(
+                "goal_id",
+                sa.String(36),
+                sa.ForeignKey("goals.id", ondelete="CASCADE"),
+                nullable=True,
+                index=True,
+            ),
+            # Budget limits
+            sa.Column("daily_budget", sa.Float, nullable=True),
+            sa.Column("weekly_budget", sa.Float, nullable=True),
+            sa.Column("monthly_budget", sa.Float, nullable=True),
+            sa.Column("total_budget", sa.Float, nullable=True),
+            # Alerts
+            sa.Column(
+                "warning_threshold", sa.Float, default=0.8, nullable=False
+            ),  # 80%
+            sa.Column("pause_on_exceed", sa.Boolean, default=False, nullable=False),
+            # Timestamps
+            sa.Column(
+                "created_at", sa.DateTime, server_default=sa.func.now(), nullable=False
+            ),
+            sa.Column(
+                "updated_at",
+                sa.DateTime,
+                server_default=sa.func.now(),
+                onupdate=sa.func.now(),
+                nullable=False,
+            ),
+        )
+
+    # Add agent_type column to jobs table if it doesn't exist
+    if not column_exists("jobs", "agent_type"):
+        op.add_column("jobs", sa.Column("agent_type", sa.String(50), nullable=True))
+    if not column_exists("jobs", "agent_session_id"):
+        op.add_column(
+            "jobs", sa.Column("agent_session_id", sa.String(36), nullable=True)
+        )
+
+    # Add cost tracking to tickets if it doesn't exist
+    if not column_exists("tickets", "total_cost_usd"):
+        op.add_column(
+            "tickets", sa.Column("total_cost_usd", sa.Float, default=0.0, nullable=True)
+        )
+
+    # Create indexes for performance if they don't exist
+    if not index_exists("ix_agent_sessions_created_at"):
+        op.create_index(
+            "ix_agent_sessions_created_at", "agent_sessions", ["created_at"]
+        )
+    if not index_exists("ix_agent_sessions_agent_type"):
+        op.create_index(
+            "ix_agent_sessions_agent_type", "agent_sessions", ["agent_type"]
+        )
+
+
+def downgrade() -> None:
+    # Drop indexes if they exist
+    if index_exists("ix_agent_sessions_agent_type"):
+        op.drop_index("ix_agent_sessions_agent_type", "agent_sessions")
+    if index_exists("ix_agent_sessions_created_at"):
+        op.drop_index("ix_agent_sessions_created_at", "agent_sessions")
+
+    # Drop columns from existing tables if they exist
+    if column_exists("tickets", "total_cost_usd"):
+        op.drop_column("tickets", "total_cost_usd")
+    if column_exists("jobs", "agent_session_id"):
+        op.drop_column("jobs", "agent_session_id")
+    if column_exists("jobs", "agent_type"):
+        op.drop_column("jobs", "agent_type")
+
+    # Drop new tables if they exist
+    if table_exists("cost_budgets"):
+        op.drop_table("cost_budgets")
+    if table_exists("agent_messages"):
+        op.drop_table("agent_messages")
+    if table_exists("agent_sessions"):
+        op.drop_table("agent_sessions")

package/app/backend/alembic/versions/015_add_ticket_sort_order.py

@@ -0,0 +1,33 @@
+"""Add sort_order column to tickets for drag-and-drop ordering.
+
+Revision ID: 015
+Revises: 774dc335c679
+Create Date: 2026-03-01
+
+Adds a sort_order integer column to the tickets table so that users
+can manually reorder tickets within a state column via drag-and-drop.
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "015"
+down_revision: str | None = "774dc335c679"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.add_column(sa.Column("sort_order", sa.Integer(), nullable=True))
+        batch_op.create_index("ix_tickets_sort_order", ["sort_order"])
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("tickets") as batch_op:
+        batch_op.drop_index("ix_tickets_sort_order")
+        batch_op.drop_column("sort_order")

package/app/backend/alembic/versions/03220f0b93ae_add_pr_fields_to_ticket.py

@@ -0,0 +1,49 @@
+"""add_pr_fields_to_ticket
+
+Revision ID: 03220f0b93ae
+Revises: 8ef5054dc280
+Create Date: 2026-01-12 11:20:58.959405
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "03220f0b93ae"
+down_revision: str | None = "8ef5054dc280"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Add PR fields to tickets table
+    op.add_column("tickets", sa.Column("pr_number", sa.Integer(), nullable=True))
+    op.add_column("tickets", sa.Column("pr_url", sa.String(length=500), nullable=True))
+    op.add_column("tickets", sa.Column("pr_state", sa.String(length=20), nullable=True))
+    op.add_column("tickets", sa.Column("pr_created_at", sa.DateTime(), nullable=True))
+    op.add_column("tickets", sa.Column("pr_merged_at", sa.DateTime(), nullable=True))
+    op.add_column(
+        "tickets", sa.Column("pr_head_branch", sa.String(length=255), nullable=True)
+    )
+    op.add_column(
+        "tickets", sa.Column("pr_base_branch", sa.String(length=255), nullable=True)
+    )
+    op.create_index(
+        op.f("ix_tickets_pr_number"), "tickets", ["pr_number"], unique=False
+    )
+
+
+def downgrade() -> None:
+    # Remove PR fields from tickets table
+    op.drop_index(op.f("ix_tickets_pr_number"), table_name="tickets")
+    op.drop_column("tickets", "pr_base_branch")
+    op.drop_column("tickets", "pr_head_branch")
+    op.drop_column("tickets", "pr_merged_at")
+    op.drop_column("tickets", "pr_created_at")
+    op.drop_column("tickets", "pr_state")
+    op.drop_column("tickets", "pr_url")
+    op.drop_column("tickets", "pr_number")

package/app/backend/alembic/versions/0c2d89fff3b1_seed_board_configs_from_yaml.py

@@ -0,0 +1,206 @@
+"""seed_board_configs_from_yaml
+
+Revision ID: 0c2d89fff3b1
+Revises: 82ecd978cc70
+Create Date: 2026-03-01 12:00:00.000000
+
+Seed migration: populates Board.config for all existing boards.
+
+For each board:
+  1. Load draft.yaml from board.repo_root (if it exists)
+  2. Deep-merge: DraftConfig defaults ← YAML values ← existing board.config overrides
+  3. Write the full merged config back to Board.config
+
+This ensures every board has a complete, self-contained config in the DB
+so the system no longer needs to read from YAML at runtime.
+"""
+
+import json
+import logging
+from pathlib import Path
+
+import yaml
+from sqlalchemy import text
+
+from alembic import op
+
+logger = logging.getLogger(__name__)
+
+# revision identifiers, used by Alembic.
+revision: str = "0c2d89fff3b1"
+down_revision: str | None = "82ecd978cc70"
+branch_labels: str | None = None
+depends_on: str | None = None
+
+CONFIG_FILENAME = "draft.yaml"
+
+
+def deep_merge_dicts(base: dict, override: dict) -> dict:
+    """Deep merge two dicts. override wins on conflicts."""
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = deep_merge_dicts(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _load_yaml_config(repo_root: str) -> dict | None:
+    """Try to load draft.yaml from a repo root. Returns None on failure."""
+    config_path = Path(repo_root) / CONFIG_FILENAME
+    if not config_path.exists():
+        return None
+    try:
+        with open(config_path) as f:
+            data = yaml.safe_load(f)
+        if isinstance(data, dict):
+            return data
+    except Exception as e:
+        logger.warning("Failed to load %s: %s", config_path, e)
+    return None
+
+
+def _get_defaults() -> dict:
+    """Build the full default config dict.
+
+    We inline the defaults here to make the migration self-contained and
+    deterministic — importing from app code could break if the dataclass
+    structure changes in a future version.
+    """
+    return {
+        "project": {
+            "name": "Draft Project",
+            "repo_root": ".",
+        },
+        "execute_config": {
+            "executor": "claude",
+            "executor_model": "sonnet",
+            "timeout": 600,
+            "max_retries": 2,
+            "use_yolo": False,
+            "yolo_allowlist": [],
+        },
+        "verify_config": {
+            "commands": [],
+            "timeout": 300,
+            "stop_on_first_failure": True,
+        },
+        "planner_config": {
+            "enabled": False,
+            "model": "anthropic/claude-sonnet-4-20250514",
+            "interval_seconds": 2,
+            "max_followups_per_ticket": 2,
+            "max_followups_per_tick": 3,
+            "reflection_enabled": True,
+            "auto_verify": True,
+            "max_parallel_jobs": 1,
+            "features": {
+                "auto_execute": False,
+                "auto_followup": True,
+                "auto_reflection": True,
+                "validate_tickets": False,
+            },
+            "udar": {
+                "enabled": False,
+                "max_self_corrections": 3,
+                "significance_threshold": 0.2,
+            },
+        },
+        "cleanup_config": {
+            "worktree_ttl_days": 7,
+            "evidence_ttl_days": 30,
+            "auto_cleanup_terminal": True,
+        },
+        "merge_config": {
+            "strategy": "merge",
+            "delete_branch_after_merge": True,
+            "pull_before_merge": True,
+            "require_pull_success": False,
+        },
+        "autonomy_config": {
+            "enabled": False,
+            "max_diff_lines": 500,
+            "sensitive_file_patterns": [
+                "*.env*",
+                "*secret*",
+                "*credential*",
+                "*password*",
+                "*.pem",
+                "*.key",
+            ],
+        },
+        "executor_profiles": {},
+    }
+
+
+def upgrade() -> None:
+    """Seed Board.config for all existing boards."""
+    conn = op.get_bind()
+
+    rows = conn.execute(text("SELECT id, repo_root, config FROM boards")).fetchall()
+
+    if not rows:
+        logger.info("No boards found — nothing to seed.")
+        return
+
+    defaults = _get_defaults()
+    updated = 0
+
+    for row in rows:
+        board_id = row[0]
+        repo_root = row[1]
+        existing_config = row[2]
+
+        # Parse existing config (may be JSON string or dict depending on driver)
+        if existing_config is None:
+            existing = {}
+        elif isinstance(existing_config, str):
+            try:
+                existing = json.loads(existing_config)
+            except (json.JSONDecodeError, TypeError):
+                existing = {}
+        elif isinstance(existing_config, dict):
+            existing = existing_config
+        else:
+            existing = {}
+
+        # Try loading YAML from repo_root
+        yaml_config = _load_yaml_config(repo_root) if repo_root else None
+
+        # Deep-merge: defaults ← YAML ← existing board overrides
+        merged = defaults.copy()
+        if yaml_config:
+            merged = deep_merge_dicts(merged, yaml_config)
+        if existing:
+            merged = deep_merge_dicts(merged, existing)
+
+        # Write back
+        conn.execute(
+            text("UPDATE boards SET config = :config WHERE id = :id"),
+            {"config": json.dumps(merged), "id": board_id},
+        )
+        updated += 1
+
+        source = "defaults"
+        if yaml_config and existing:
+            source = "defaults + YAML + existing overrides"
+        elif yaml_config:
+            source = "defaults + YAML"
+        elif existing:
+            source = "defaults + existing overrides"
+        logger.info("Board %s: seeded config from %s", board_id, source)
+
+    logger.info("Seeded config for %d board(s).", updated)
+
+
+def downgrade() -> None:
+    """Revert boards to their pre-seed config state.
+
+    We cannot perfectly restore the original state (we don't know what
+    it was), so we set config to NULL which means 'use defaults'.
+    This is safe because the old code path falls back to defaults anyway.
+    """
+    conn = op.get_bind()
+    conn.execute(text("UPDATE boards SET config = NULL"))
+    logger.info("Cleared Board.config for all boards (reverted to NULL/defaults).")