draft-board 0.1.0-beta.0

package/app/backend/app/models/job_queue.py

@@ -0,0 +1,39 @@
+"""SQLite-backed job queue model (replaces Celery/Redis broker)."""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, Index, Integer, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.models.base import Base
+
+
+class JobQueueEntry(Base):
+    """A queued task for the SQLite worker to process.
+
+    Replaces the Celery broker queue. Tasks are claimed atomically
+    via UPDATE...WHERE status='pending' ORDER BY priority DESC, created_at ASC.
+    """
+
+    __tablename__ = "job_queue"
+    __table_args__ = (
+        Index("ix_job_queue_claim_order", "status", "priority", "created_at"),
+    )
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    task_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    args_json: Mapped[str] = mapped_column(Text, nullable=False, default="[]")
+    status: Mapped[str] = mapped_column(
+        String(20), nullable=False, default="pending", index=True
+    )
+    claimed_by: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    claimed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    completed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    result_json: Mapped[str | None] = mapped_column(Text, nullable=True)
+    priority: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=func.now()
+    )
+
+    def __repr__(self) -> str:
+        return f"<JobQueueEntry(id={self.id}, task={self.task_name}, status={self.status})>"

package/app/backend/app/models/kv_store.py

@@ -0,0 +1,28 @@
+"""SQLite-backed key-value store model (replaces Redis GET/SET)."""
+
+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 KVStoreEntry(Base):
+    """Generic key-value store with optional TTL.
+
+    Replaces Redis GET/SET for queued messages and follow-up prompts.
+    Expired entries are cleaned up inline on access.
+    """
+
+    __tablename__ = "kv_store"
+
+    key: Mapped[str] = mapped_column(String(512), primary_key=True)
+    value: Mapped[str] = mapped_column(Text, nullable=False)
+    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"<KVStoreEntry(key={self.key[:30]}...)>"

package/app/backend/app/models/merge_checklist.py

@@ -0,0 +1,87 @@
+"""Merge checklist model for tracking merge readiness."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Boolean, DateTime, Float, 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.goal import Goal
+
+
+class MergeChecklist(Base):
+    """Tracks merge readiness for a goal's tickets.
+
+    Combines automatic checks (tests, cost) and manual checks (review, security).
+    """
+
+    __tablename__ = "merge_checklists"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    goal_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("goals.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+
+    # Auto-checks (computed from system state)
+    all_tests_passed: Mapped[bool] = mapped_column(Boolean, default=False)
+    total_files_changed: Mapped[int] = mapped_column(Integer, default=0)
+    total_lines_changed: Mapped[int] = mapped_column(Integer, default=0)
+    total_cost_usd: Mapped[float | None] = mapped_column(Float, nullable=True)
+    budget_exceeded: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    # Manual checks (require human confirmation)
+    code_reviewed: Mapped[bool] = mapped_column(Boolean, default=False)
+    no_sensitive_data: Mapped[bool] = mapped_column(Boolean, default=False)
+    rollback_plan_understood: Mapped[bool] = mapped_column(Boolean, default=False)
+    documentation_updated: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    # Rollback plan
+    rollback_plan_json: Mapped[str | None] = mapped_column(Text, nullable=True)
+    risk_level: Mapped[str] = mapped_column(
+        String(20),
+        default="low",  # low, medium, high
+    )
+
+    # Status
+    ready_to_merge: Mapped[bool] = mapped_column(Boolean, default=False)
+    merged_at: Mapped[datetime | None] = mapped_column(DateTime, 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
+    )
+
+    # Relationships
+    goal: Mapped["Goal"] = relationship("Goal", back_populates="merge_checklist")
+
+    def __repr__(self) -> str:
+        return f"<MergeChecklist(id={self.id}, goal_id={self.goal_id}, ready={self.ready_to_merge})>"
+
+    def is_ready_to_merge(self) -> bool:
+        """Check if all conditions are met for merging."""
+        # All auto-checks must pass
+        if not self.all_tests_passed:
+            return False
+        if self.budget_exceeded:
+            return False
+
+        # All manual checks must be confirmed
+        if not (
+            self.code_reviewed
+            and self.no_sensitive_data
+            and self.rollback_plan_understood
+        ):
+            return False
+
+        return True

package/app/backend/app/models/normalized_log.py

@@ -0,0 +1,100 @@
+"""Database models for normalized log entries."""
+
+import enum
+from datetime import datetime
+
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Column,
+    DateTime,
+    Enum,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+)
+from sqlalchemy.orm import relationship
+
+from app.models.base import Base
+
+
+class LogEntryType(enum.StrEnum):
+    """Semantic types for normalized log entries."""
+
+    THINKING = "thinking"
+    ASSISTANT_MESSAGE = "assistant_message"  # Agent's response/reasoning
+    FILE_EDIT = "file_edit"
+    FILE_CREATE = "file_create"
+    FILE_DELETE = "file_delete"
+    COMMAND_RUN = "command_run"
+    TOOL_CALL = "tool_call"
+    ERROR = "error"
+    USER_MESSAGE = "user_message"
+    SYSTEM_MESSAGE = "system_message"
+    LOADING = "loading"
+    TODO_LIST = "todo_list"  # Agent's todo/task list
+
+    # UDAR agent entry types
+    AGENT_UNDERSTANDING = "agent_understanding"  # Context gathered in Understand phase
+    AGENT_DECISION = "agent_decision"  # LLM reasoning in Decide phase
+    AGENT_VALIDATION = "agent_validation"  # Validation results in Validate phase
+    AGENT_TOOL_CALL = "agent_tool_call"  # Tool invocations (deterministic)
+
+
+class NormalizedLogEntry(Base):
+    """Structured, semantic log entry parsed from raw agent output."""
+
+    __tablename__ = "normalized_log_entries"
+
+    id = Column(
+        String(36), primary_key=True, default=lambda: str(__import__("uuid").uuid4())
+    )
+
+    # Foreign key to job
+    job_id = Column(String, ForeignKey("jobs.id"), nullable=False, index=True)
+    job = relationship("Job", back_populates="normalized_logs")
+
+    # Sequence number for ordering
+    sequence = Column(Integer, nullable=False)
+
+    # Timestamp of the entry
+    timestamp = Column(DateTime, nullable=False, default=datetime.utcnow)
+
+    # Entry type (semantic category)
+    entry_type = Column(Enum(LogEntryType), nullable=False, index=True)
+
+    # Text content (can be markdown, code, etc.)
+    content = Column(Text, nullable=False)
+
+    # Structured metadata (JSON)
+    # Examples:
+    # - file_edit: {"file_path": "app/auth.py", "diff": "...", "language": "python"}
+    # - command_run: {"command": "pytest", "exit_code": 0, "output": "..."}
+    # - tool_call: {"tool_name": "web_search", "args": {...}, "result": {...}}
+    # - error: {"error_type": "SyntaxError", "traceback": "..."}
+    # Note: "metadata" is reserved in SQLAlchemy, so using "entry_metadata"
+    entry_metadata = Column(JSON, nullable=True)
+
+    # Display flags
+    collapsed = Column(Boolean, default=False)  # Start collapsed?
+    highlight = Column(Boolean, default=False)  # Highlight in UI?
+
+    __table_args__ = (
+        Index("ix_normalized_log_entries_job_sequence", "job_id", "sequence"),
+    )
+
+    def to_dict(self):
+        """Convert to dictionary for API responses."""
+        return {
+            "id": self.id,
+            "job_id": self.job_id,
+            "sequence": self.sequence,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+            "entry_type": self.entry_type.value if self.entry_type else None,
+            "content": self.content,
+            "metadata": self.entry_metadata or {},  # Return as "metadata" for frontend
+            "collapsed": self.collapsed,
+            "highlight": self.highlight,
+        }

package/app/backend/app/models/planner_lock.py

@@ -0,0 +1,43 @@
+"""Planner lock model for ensuring single-tick execution."""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, String, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.models.base import Base
+
+
+class PlannerLock(Base):
+    """Single-row lock table to prevent concurrent planner ticks.
+
+    This ensures that only one planner tick can run at a time,
+    preventing race conditions where two ticks might both see
+    "no executing ticket" and both enqueue jobs.
+
+    Usage:
+        - Acquire: INSERT with lock_key="planner_tick"
+        - Release: DELETE the row
+        - Check: SELECT to see if lock is held
+    """
+
+    __tablename__ = "planner_locks"
+
+    # Fixed key for the planner lock
+    lock_key: Mapped[str] = mapped_column(
+        String(50),
+        primary_key=True,
+        default="planner_tick",
+    )
+    acquired_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+    owner_id: Mapped[str | None] = mapped_column(
+        String(255),
+        nullable=True,
+    )
+
+    def __repr__(self) -> str:
+        return f"<PlannerLock(key={self.lock_key}, acquired={self.acquired_at})>"

package/app/backend/app/models/rate_limit_entry.py

@@ -0,0 +1,25 @@
+"""SQLite-backed rate limit entry model (replaces Redis sorted sets)."""
+
+from sqlalchemy import Float, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.models.base import Base
+
+
+class RateLimitEntry(Base):
+    """A rate limit cost entry.
+
+    Replaces Redis sorted sets. Entries are cleaned up inline
+    (DELETE WHERE expires_at < now) before checking budget.
+    """
+
+    __tablename__ = "rate_limit_entries"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    client_key: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    cost: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+    recorded_at: Mapped[float] = mapped_column(Float, nullable=False)
+    expires_at: Mapped[float] = mapped_column(Float, nullable=False, index=True)
+
+    def __repr__(self) -> str:
+        return f"<RateLimitEntry(key={self.client_key}, cost={self.cost})>"

package/app/backend/app/models/repo.py

@@ -0,0 +1,66 @@
+"""Repo model - global repository registry."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, 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
+
+
+class Repo(Base):
+    """Global repository registry.
+
+    Each Repo represents a git repository on the filesystem.
+    Repos can be associated with multiple boards via BoardRepo junction table.
+
+    Key properties:
+    - path is unique - only one Repo per filesystem path
+    - display_name is user-friendly name for UI
+    - Optional scripts for setup/cleanup/dev server
+    - Git metadata (default_branch, remote_url) cached for performance
+    """
+
+    __tablename__ = "repos"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+
+    # Filesystem path to git repository (unique)
+    path: Mapped[str] = mapped_column(
+        String(1024), unique=True, nullable=False, index=True
+    )
+
+    # Repository name (derived from path, e.g., "my-project")
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+
+    # User-friendly display name (editable)
+    display_name: Mapped[str] = mapped_column(String(255), nullable=False)
+
+    # Optional per-repo scripts
+    setup_script: Mapped[str | None] = mapped_column(Text, nullable=True)
+    cleanup_script: Mapped[str | None] = mapped_column(Text, nullable=True)
+    dev_server_script: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # Git metadata (cached)
+    default_branch: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    remote_url: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+
+    # Timestamps
+    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
+    board_repos: Mapped[list["BoardRepo"]] = relationship(
+        "BoardRepo", back_populates="repo", cascade="all, delete-orphan"
+    )
+
+    def __repr__(self) -> str:
+        return f"<Repo(id={self.id}, name={self.name}, path={self.path})>"

package/app/backend/app/models/review_comment.py

@@ -0,0 +1,91 @@
+"""ReviewComment model for inline comments on revision diffs."""
+
+import uuid
+from datetime import datetime
+from enum import StrEnum
+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.revision import Revision
+
+
+class AuthorType(StrEnum):
+    """Enum representing the type of author for a review comment."""
+
+    HUMAN = "human"
+    AGENT = "agent"
+    SYSTEM = "system"
+
+
+class ReviewComment(Base):
+    """ReviewComment model representing inline comments on a revision diff.
+
+    Comments are anchored using a sha1 hash of (file_path + hunk_header + line_content)
+    to survive small line shifts between revisions.
+    """
+
+    __tablename__ = "review_comments"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    revision_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("revisions.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    file_path: Mapped[str] = mapped_column(
+        String(500),
+        nullable=False,
+    )
+    line_number: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+    )
+    anchor: Mapped[str] = mapped_column(
+        String(40),  # sha1 hex digest (truncated to 16 chars in practice)
+        nullable=False,
+        index=True,
+    )
+    line_content: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    body: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+    )
+    author_type: Mapped[str] = mapped_column(
+        String(20),
+        default=AuthorType.HUMAN.value,
+        nullable=False,
+    )
+    resolved: Mapped[bool] = mapped_column(
+        Boolean,
+        default=False,
+        nullable=False,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    revision: Mapped["Revision"] = relationship("Revision", back_populates="comments")
+
+    @property
+    def author_type_enum(self) -> AuthorType:
+        """Get the author_type as an AuthorType enum."""
+        return AuthorType(self.author_type)
+
+    def __repr__(self) -> str:
+        return f"<ReviewComment(id={self.id}, file={self.file_path}, line={self.line_number}, resolved={self.resolved})>"

package/app/backend/app/models/review_summary.py

@@ -0,0 +1,69 @@
+"""ReviewSummary model for overall review decisions on revisions."""
+
+import uuid
+from datetime import datetime
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import 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.revision import Revision
+
+
+class ReviewDecision(StrEnum):
+    """Enum representing the review decision."""
+
+    APPROVED = "approved"
+    CHANGES_REQUESTED = "changes_requested"
+
+
+class ReviewSummary(Base):
+    """ReviewSummary model representing the overall review decision for a revision.
+
+    Only one ReviewSummary per revision is allowed.
+    """
+
+    __tablename__ = "review_summaries"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    revision_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("revisions.id", ondelete="CASCADE"),
+        nullable=False,
+        unique=True,
+        index=True,
+    )
+    decision: Mapped[str] = mapped_column(
+        String(30),
+        nullable=False,
+    )
+    body: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    revision: Mapped["Revision"] = relationship(
+        "Revision", back_populates="review_summary"
+    )
+
+    @property
+    def decision_enum(self) -> ReviewDecision:
+        """Get the decision as a ReviewDecision enum."""
+        return ReviewDecision(self.decision)
+
+    def __repr__(self) -> str:
+        return f"<ReviewSummary(id={self.id}, revision_id={self.revision_id}, decision={self.decision})>"

package/app/backend/app/models/revision.py

@@ -0,0 +1,130 @@
+"""Revision model for tracking agent code change iterations."""
+
+import uuid
+from datetime import datetime
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, UniqueConstraint, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.evidence import Evidence
+    from app.models.job import Job
+    from app.models.review_comment import ReviewComment
+    from app.models.review_summary import ReviewSummary
+    from app.models.ticket import Ticket
+
+
+class RevisionStatus(StrEnum):
+    """Enum representing the status of a revision."""
+
+    OPEN = "open"
+    CHANGES_REQUESTED = "changes_requested"
+    APPROVED = "approved"
+    SUPERSEDED = "superseded"
+
+
+class Revision(Base):
+    """Revision model representing one agent iteration for a ticket.
+
+    A revision is similar to a GitHub PR snapshot - it contains:
+    - A diff (stat + patch as evidence)
+    - Review comments
+    - A final review decision
+
+    Only one revision per ticket can be 'open' at a time.
+    When a new revision is created, previous open revision becomes 'superseded'.
+    """
+
+    __tablename__ = "revisions"
+    __table_args__ = (
+        UniqueConstraint("ticket_id", "number", name="uq_revision_ticket_number"),
+        UniqueConstraint("ticket_id", "job_id", name="uq_revision_ticket_job"),
+    )
+
+    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,
+    )
+    number: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+    )
+    status: Mapped[str] = mapped_column(
+        String(50),
+        default=RevisionStatus.OPEN.value,
+        nullable=False,
+        index=True,
+    )
+    diff_stat_evidence_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("evidence.id", ondelete="SET NULL"),
+        nullable=True,
+    )
+    diff_patch_evidence_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("evidence.id", ondelete="SET NULL"),
+        nullable=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="revisions")
+    job: Mapped["Job"] = relationship(
+        "Job",
+        back_populates="revision",
+        foreign_keys=[job_id],
+    )
+    diff_stat_evidence: Mapped["Evidence | None"] = relationship(
+        "Evidence",
+        foreign_keys=[diff_stat_evidence_id],
+    )
+    diff_patch_evidence: Mapped["Evidence | None"] = relationship(
+        "Evidence",
+        foreign_keys=[diff_patch_evidence_id],
+    )
+    comments: Mapped[list["ReviewComment"]] = relationship(
+        "ReviewComment",
+        back_populates="revision",
+        cascade="all, delete-orphan",
+        order_by="ReviewComment.created_at",
+    )
+    review_summary: Mapped["ReviewSummary | None"] = relationship(
+        "ReviewSummary",
+        back_populates="revision",
+        cascade="all, delete-orphan",
+        uselist=False,
+    )
+
+    @property
+    def status_enum(self) -> RevisionStatus:
+        """Get the status as a RevisionStatus enum."""
+        return RevisionStatus(self.status)
+
+    @property
+    def unresolved_comment_count(self) -> int:
+        """Get count of unresolved comments."""
+        return sum(1 for c in self.comments if not c.resolved)
+
+    def __repr__(self) -> str:
+        return f"<Revision(id={self.id}, ticket_id={self.ticket_id}, number={self.number}, status={self.status})>"