draft-board 0.1.0-beta.0

package/app/backend/app/models/board.py

@@ -0,0 +1,79 @@
+"""Board model - the primary permission and scoping boundary."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import JSON, DateTime, ForeignKey, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.board_repo import BoardRepo
+    from app.models.goal import Goal
+    from app.models.job import Job
+    from app.models.ticket import Ticket
+    from app.models.user import User
+    from app.models.workspace import Workspace
+
+
+class Board(Base):
+    """Board represents a project/repository boundary.
+
+    Key properties:
+    - Single repo per board (repo_root is authoritative)
+    - All goals, tickets, jobs, workspaces belong to a board
+    - board_id is the permission boundary for all operations
+
+    This prevents cross-tenant/cross-project data access.
+    """
+
+    __tablename__ = "boards"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # The authoritative repo root for this board
+    # All file operations use this path - NOT client-provided paths
+    repo_root: Mapped[str] = mapped_column(String(1024), nullable=False)
+
+    # Optional: default branch for this repo
+    default_branch: Mapped[str | None] = mapped_column(String(255), nullable=True)
+
+    # Board-level configuration overrides (JSON)
+    # Overrides settings from draft.yaml
+    config: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+
+    # Owner (nullable for backward compat with single-user setups)
+    owner_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=True,
+        index=True,
+    )
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+
+    # Relationships
+    owner: Mapped["User | None"] = relationship("User", back_populates="boards")
+    goals: Mapped[list["Goal"]] = relationship(
+        "Goal", back_populates="board", cascade="all, delete-orphan"
+    )
+    tickets: Mapped[list["Ticket"]] = relationship(
+        "Ticket", back_populates="board", cascade="all, delete-orphan"
+    )
+    jobs: Mapped[list["Job"]] = relationship(
+        "Job", back_populates="board", cascade="all, delete-orphan"
+    )
+    workspaces: Mapped[list["Workspace"]] = relationship(
+        "Workspace", back_populates="board", cascade="all, delete-orphan"
+    )
+    board_repos: Mapped[list["BoardRepo"]] = relationship(
+        "BoardRepo", back_populates="board", cascade="all, delete-orphan"
+    )

package/app/backend/app/models/board_repo.py

@@ -0,0 +1,68 @@
+"""BoardRepo junction model - Board <-> Repo many-to-many relationship."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import (
+    Boolean,
+    DateTime,
+    ForeignKey,
+    String,
+    Text,
+    UniqueConstraint,
+    func,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.board import Board
+    from app.models.repo import Repo
+
+
+class BoardRepo(Base):
+    """Junction table linking Boards to Repos (many-to-many).
+
+    Allows a board to have multiple repositories and a repo to be
+    shared across multiple boards.
+
+    Key properties:
+    - board_id + repo_id must be unique (one entry per board-repo pair)
+    - is_primary marks the primary repo for a board (used as default for operations)
+    - custom_setup_script allows per-board repo configuration overrides
+    """
+
+    __tablename__ = "board_repos"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+
+    # Foreign keys
+    board_id: Mapped[str] = mapped_column(
+        ForeignKey("boards.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    repo_id: Mapped[str] = mapped_column(
+        ForeignKey("repos.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+
+    # Primary repo flag - each board should have exactly one primary repo
+    is_primary: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    # Per-board repo overrides (optional)
+    custom_setup_script: Mapped[str | None] = mapped_column(Text, nullable=True)
+    custom_cleanup_script: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # Timestamps
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+    # Relationships
+    board: Mapped["Board"] = relationship("Board", back_populates="board_repos")
+    repo: Mapped["Repo"] = relationship("Repo", back_populates="board_repos")
+
+    # Constraints
+    __table_args__ = (UniqueConstraint("board_id", "repo_id", name="uq_board_repo"),)
+
+    def __repr__(self) -> str:
+        return f"<BoardRepo(board_id={self.board_id}, repo_id={self.repo_id}, is_primary={self.is_primary})>"

package/app/backend/app/models/cost_budget.py

@@ -0,0 +1,42 @@
+"""Cost budget model for tracking spending limits."""
+
+from datetime import datetime
+from uuid import uuid4
+
+from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, String
+from sqlalchemy.orm import relationship
+
+from app.models.base import Base
+
+
+class CostBudget(Base):
+    """Budget configuration for cost tracking."""
+
+    __tablename__ = "cost_budgets"
+
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    goal_id = Column(
+        String(36),
+        ForeignKey("goals.id", ondelete="CASCADE"),
+        nullable=True,
+        index=True,
+    )
+
+    # Budget limits (None = unlimited)
+    daily_budget = Column(Float, nullable=True)
+    weekly_budget = Column(Float, nullable=True)
+    monthly_budget = Column(Float, nullable=True)
+    total_budget = Column(Float, nullable=True)
+
+    # Alert settings
+    warning_threshold = Column(Float, default=0.8, nullable=False)  # 80% by default
+    pause_on_exceed = Column(Boolean, default=False, nullable=False)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(
+        DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False
+    )
+
+    # Relationships
+    goal = relationship("Goal", back_populates="budget")

package/app/backend/app/models/enums.py

@@ -0,0 +1,40 @@
+"""Shared enumerations for Draft models.
+
+This file contains event types and other enums that are NOT part of the
+ticket state machine. The state machine (TicketState, transitions) lives
+in state_machine.py. Event types are audit log entries, not state rules.
+"""
+
+from enum import StrEnum
+
+
+class EventType(StrEnum):
+    """Enum representing types of ticket events.
+
+    These are audit log event types, NOT state transition rules.
+    State transitions are governed by state_machine.py.
+    """
+
+    # Core lifecycle events
+    CREATED = "created"
+    TRANSITIONED = "transitioned"
+    UPDATED = "updated"
+    COMMENT = "comment"
+
+    # Merge lifecycle events
+    MERGE_REQUESTED = "merge_requested"
+    MERGE_SUCCEEDED = "merge_succeeded"
+    MERGE_FAILED = "merge_failed"
+
+    # Cleanup events (distinct types for clear analytics/UX)
+    WORKTREE_CLEANED = "worktree_cleaned"
+    WORKTREE_CLEANUP_FAILED = "worktree_cleanup_failed"
+
+
+class ActorType(StrEnum):
+    """Enum representing who performed an action."""
+
+    HUMAN = "human"
+    PLANNER = "planner"
+    SYSTEM = "system"
+    EXECUTOR = "executor"

package/app/backend/app/models/evidence.py

@@ -0,0 +1,132 @@
+"""Evidence model for storing verification command results."""
+
+import uuid
+from datetime import datetime
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.job import Job
+    from app.models.ticket import Ticket
+
+
+class EvidenceKind(StrEnum):
+    """Enum representing the kind of evidence.
+
+    Metadata evidence (JSON in stdout_path):
+    - EXECUTOR_META: JSON with exit_code, duration, executor_type, mode, command
+    - VERIFY_META: JSON with exit_code, commands_run, duration, results per command
+
+    Evidence types for execution:
+    - EXECUTOR_STDOUT: stdout from executor CLI (Claude/Cursor)
+    - EXECUTOR_STDERR: stderr from executor CLI
+    - GIT_DIFF_STAT: output of `git diff --stat`
+    - GIT_DIFF_PATCH: full git diff patch
+
+    Evidence types for verification:
+    - VERIFY_STDOUT: stdout from verification command
+    - VERIFY_STDERR: stderr from verification command
+
+    Legacy types (kept for backwards compatibility):
+    - COMMAND_LOG: generic command output
+    - TEST_REPORT: test framework report
+    """
+
+    # Metadata evidence (JSON)
+    EXECUTOR_META = (
+        "executor_meta"  # JSON: exit_code, duration_ms, executor_type, mode, command
+    )
+    VERIFY_META = "verify_meta"  # JSON: exit_code, commands, duration_ms, results
+
+    # Executor evidence
+    EXECUTOR_STDOUT = "executor_stdout"
+    EXECUTOR_STDERR = "executor_stderr"
+
+    # Git diff evidence
+    GIT_DIFF_STAT = "git_diff_stat"
+    GIT_DIFF_PATCH = "git_diff_patch"
+
+    # Verification evidence
+    VERIFY_STDOUT = "verify_stdout"
+    VERIFY_STDERR = "verify_stderr"
+
+    # Merge evidence
+    MERGE_STDOUT = "merge_stdout"
+    MERGE_STDERR = "merge_stderr"
+    MERGE_META = "merge_meta"  # JSON: strategy, branch, base_branch, exit_code, duration_ms, evidence_ids
+
+    # Legacy types (backwards compatibility)
+    COMMAND_LOG = "command_log"
+    TEST_REPORT = "test_report"
+
+
+class Evidence(Base):
+    """Evidence model representing verification command execution results."""
+
+    __tablename__ = "evidence"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    ticket_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("tickets.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    job_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("jobs.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    kind: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+        default=EvidenceKind.COMMAND_LOG.value,
+    )
+    command: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+    )
+    exit_code: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+    )
+    stdout_path: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    stderr_path: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="evidence")
+    job: Mapped["Job"] = relationship("Job", back_populates="evidence")
+
+    @property
+    def kind_enum(self) -> EvidenceKind:
+        """Get the kind as an EvidenceKind enum."""
+        return EvidenceKind(self.kind)
+
+    @property
+    def succeeded(self) -> bool:
+        """Check if the command succeeded (exit code 0)."""
+        return self.exit_code == 0
+
+    def __repr__(self) -> str:
+        return f"<Evidence(id={self.id}, command={self.command[:30]}..., exit_code={self.exit_code})>"

package/app/backend/app/models/goal.py

@@ -0,0 +1,102 @@
+"""Goal model for Draft."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.agent_conversation_history import AgentConversationHistory
+    from app.models.board import Board
+    from app.models.cost_budget import CostBudget
+    from app.models.merge_checklist import MergeChecklist
+    from app.models.ticket import Ticket
+
+
+class Goal(Base):
+    """Goal model representing a high-level objective.
+
+    IMPORTANT: Goals are scoped by board_id for permission enforcement.
+    """
+
+    __tablename__ = "goals"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    board_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("boards.id", ondelete="CASCADE"),
+        nullable=True,  # Nullable for migration compatibility
+        index=True,
+    )
+    title: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Autonomy fields
+    autonomy_enabled: Mapped[bool] = mapped_column(
+        Boolean, default=False, server_default="0", nullable=False
+    )
+    auto_approve_tickets: Mapped[bool] = mapped_column(
+        Boolean, default=False, server_default="0", nullable=False
+    )
+    auto_approve_revisions: Mapped[bool] = mapped_column(
+        Boolean, default=False, server_default="0", nullable=False
+    )
+    auto_merge: Mapped[bool] = mapped_column(
+        Boolean, default=False, server_default="0", nullable=False
+    )
+    auto_approve_followups: Mapped[bool] = mapped_column(
+        Boolean, default=False, server_default="0", nullable=False
+    )
+    max_auto_approvals: Mapped[int | None] = mapped_column(
+        Integer, default=None, nullable=True
+    )
+    auto_approval_count: Mapped[int] = mapped_column(
+        Integer, default=0, server_default="0", nullable=False
+    )
+
+    # Relationships
+    board: Mapped["Board | None"] = relationship("Board", back_populates="goals")
+    tickets: Mapped[list["Ticket"]] = relationship(
+        "Ticket",
+        back_populates="goal",
+        cascade="all, delete-orphan",
+    )
+    budget: Mapped["CostBudget | None"] = relationship(
+        "CostBudget",
+        back_populates="goal",
+        uselist=False,
+        cascade="all, delete-orphan",
+    )
+    merge_checklist: Mapped["MergeChecklist | None"] = relationship(
+        "MergeChecklist",
+        back_populates="goal",
+        uselist=False,
+        cascade="all, delete-orphan",
+    )
+    agent_conversation_history: Mapped[list["AgentConversationHistory"]] = relationship(
+        "AgentConversationHistory",
+        back_populates="goal",
+        cascade="all, delete-orphan",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Goal(id={self.id}, title={self.title})>"

package/app/backend/app/models/idempotency_entry.py

@@ -0,0 +1,30 @@
+"""SQLite-backed idempotency cache model (replaces Redis SETNX)."""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.models.base import Base
+
+
+class IdempotencyEntry(Base):
+    """Idempotency lock and result cache entry.
+
+    Replaces Redis SETNX + result cache. Lock acquisition is atomic
+    via INSERT OR IGNORE (rowcount == 1 means acquired).
+    """
+
+    __tablename__ = "idempotency_cache"
+
+    cache_key: Mapped[str] = mapped_column(String(512), primary_key=True)
+    lock_value: Mapped[str | None] = mapped_column(Text, nullable=True)
+    result_value: Mapped[str | None] = mapped_column(Text, nullable=True)
+    lock_expires_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    result_expires_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=func.now()
+    )
+
+    def __repr__(self) -> str:
+        return f"<IdempotencyEntry(key={self.cache_key[:30]}...)>"

package/app/backend/app/models/job.py

@@ -0,0 +1,163 @@
+"""Job model for tracking long-running task executions."""
+
+import uuid
+from datetime import datetime
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.board import Board
+    from app.models.evidence import Evidence
+    from app.models.normalized_log import NormalizedLogEntry
+    from app.models.revision import Revision
+    from app.models.ticket import Ticket
+
+
+class JobKind(StrEnum):
+    """Enum representing the kind of job."""
+
+    EXECUTE = "execute"
+    VERIFY = "verify"
+    RESUME = "resume"  # Resume after interactive (human) completion
+
+
+class JobStatus(StrEnum):
+    """Enum representing the status of a job."""
+
+    QUEUED = "queued"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELED = "canceled"
+
+
+class Job(Base):
+    """Job model representing a long-running task execution.
+
+    IMPORTANT: Jobs are scoped by board_id for permission enforcement.
+    """
+
+    __tablename__ = "jobs"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    board_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("boards.id", ondelete="CASCADE"),
+        nullable=True,  # Nullable for migration compatibility
+        index=True,
+    )
+    ticket_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("tickets.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    kind: Mapped[str] = mapped_column(
+        String(20),
+        nullable=False,
+    )
+    status: Mapped[str] = mapped_column(
+        String(20),
+        default=JobStatus.QUEUED.value,
+        nullable=False,
+        index=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+    started_at: Mapped[datetime | None] = mapped_column(
+        DateTime,
+        nullable=True,
+    )
+    finished_at: Mapped[datetime | None] = mapped_column(
+        DateTime,
+        nullable=True,
+    )
+    exit_code: Mapped[int | None] = mapped_column(
+        Integer,
+        nullable=True,
+    )
+    log_path: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    celery_task_id: Mapped[str | None] = mapped_column(
+        String(255),
+        nullable=True,
+    )
+    # For jobs triggered by review feedback, tracks which revision is being addressed
+    source_revision_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("revisions.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True,
+    )
+    # Session ID for executor session resume (e.g. Claude --resume)
+    session_id: Mapped[str | None] = mapped_column(
+        String(255),
+        nullable=True,
+    )
+    # Health monitoring fields
+    last_heartbeat_at: Mapped[datetime | None] = mapped_column(
+        DateTime,
+        nullable=True,
+        index=True,
+    )
+    timeout_seconds: Mapped[int | None] = mapped_column(
+        Integer,
+        nullable=True,
+    )
+
+    # Relationships
+    board: Mapped["Board | None"] = relationship("Board", back_populates="jobs")
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="jobs")
+    evidence: Mapped[list["Evidence"]] = relationship(
+        "Evidence",
+        back_populates="job",
+        cascade="all, delete-orphan",
+        order_by="Evidence.created_at.desc()",
+    )
+    # The revision created by this job (via Revision.job_id -> Job.id)
+    revision: Mapped["Revision | None"] = relationship(
+        "Revision",
+        back_populates="job",
+        uselist=False,
+        foreign_keys="Revision.job_id",
+    )
+    # For jobs triggered by review, the revision being addressed
+    source_revision: Mapped["Revision | None"] = relationship(
+        "Revision",
+        foreign_keys="Job.source_revision_id",
+        viewonly=True,  # Don't allow writes through this relationship
+    )
+    # Normalized log entries for this job
+    normalized_logs: Mapped[list["NormalizedLogEntry"]] = relationship(
+        "NormalizedLogEntry",
+        back_populates="job",
+        cascade="all, delete-orphan",
+        order_by="NormalizedLogEntry.sequence",
+    )
+
+    @property
+    def kind_enum(self) -> JobKind:
+        """Get the kind as a JobKind enum."""
+        return JobKind(self.kind)
+
+    @property
+    def status_enum(self) -> JobStatus:
+        """Get the status as a JobStatus enum."""
+        return JobStatus(self.status)
+
+    def __repr__(self) -> str:
+        return f"<Job(id={self.id}, kind={self.kind}, status={self.status})>"