feat: Phase 3 Workspace View with activity feed

codeframe/core/workspace.py

@@ -298,46 +298,76 @@ def _ensure_schema_upgrades(db_path: Path) -> None:
         conn.commit()
 
     # Add tech_stack column to workspace table if it doesn't exist
-    cursor.execute("PRAGMA table_info(workspace)")
-    columns = {row[1] for row in cursor.fetchall()}
-    if "tech_stack" not in columns:
-        cursor.execute("ALTER TABLE workspace ADD COLUMN tech_stack TEXT")
-        conn.commit()
+    # First check if workspace table exists
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='workspace'"
+    )
+    if cursor.fetchone():
+        cursor.execute("PRAGMA table_info(workspace)")
+        columns = {row[1] for row in cursor.fetchall()}
+        if "tech_stack" not in columns:
+            cursor.execute("ALTER TABLE workspace ADD COLUMN tech_stack TEXT")
+            conn.commit()
 
     # Add versioning columns to prds table if they don't exist
-    cursor.execute("PRAGMA table_info(prds)")
-    prd_columns = {row[1] for row in cursor.fetchall()}
-    if "version" not in prd_columns:
-        cursor.execute("ALTER TABLE prds ADD COLUMN version INTEGER DEFAULT 1")
-        conn.commit()
-    if "parent_id" not in prd_columns:
-        cursor.execute("ALTER TABLE prds ADD COLUMN parent_id TEXT")
-        conn.commit()
-    if "change_summary" not in prd_columns:
-        cursor.execute("ALTER TABLE prds ADD COLUMN change_summary TEXT")
-        conn.commit()
-    if "chain_id" not in prd_columns:
-        cursor.execute("ALTER TABLE prds ADD COLUMN chain_id TEXT")
-        # Backfill chain_id for existing PRDs (set to their own id if no parent)
-        cursor.execute("""
-            UPDATE prds SET chain_id = id
-            WHERE chain_id IS NULL AND parent_id IS NULL
-        """)
-        conn.commit()
-
-    # Add depends_on column to prds table if it doesn't exist
-    # Re-check prd_columns as it may have changed
-    cursor.execute("PRAGMA table_info(prds)")
-    prd_columns = {row[1] for row in cursor.fetchall()}
-    if "depends_on" not in prd_columns:
-        cursor.execute("ALTER TABLE prds ADD COLUMN depends_on TEXT")
+    # First check if prds table exists
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='prds'"
+    )
+    if cursor.fetchone():
+        cursor.execute("PRAGMA table_info(prds)")
+        prd_columns = {row[1] for row in cursor.fetchall()}
+        if "version" not in prd_columns:
+            cursor.execute("ALTER TABLE prds ADD COLUMN version INTEGER DEFAULT 1")
+            conn.commit()
+        if "parent_id" not in prd_columns:
+            cursor.execute("ALTER TABLE prds ADD COLUMN parent_id TEXT")
+            conn.commit()
+        if "change_summary" not in prd_columns:
+            cursor.execute("ALTER TABLE prds ADD COLUMN change_summary TEXT")
+            conn.commit()
+        if "chain_id" not in prd_columns:
+            cursor.execute("ALTER TABLE prds ADD COLUMN chain_id TEXT")
+            # Backfill chain_id for existing PRDs (set to their own id if no parent)
+            cursor.execute("""
+                UPDATE prds SET chain_id = id
+                WHERE chain_id IS NULL AND parent_id IS NULL
+            """)
+            conn.commit()
+
+        # Add depends_on column to prds table if it doesn't exist
+        # Re-check prd_columns as it may have changed
+        cursor.execute("PRAGMA table_info(prds)")
+        prd_columns = {row[1] for row in cursor.fetchall()}
+        if "depends_on" not in prd_columns:
+            cursor.execute("ALTER TABLE prds ADD COLUMN depends_on TEXT")
+            conn.commit()
+
+        # Add indexes for PRD version chain queries
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_parent ON prds(parent_id)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_chain ON prds(chain_id)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_depends_on ON prds(depends_on)")
         conn.commit()
 
-    # Add indexes for PRD version chain queries
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_parent ON prds(parent_id)")
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_chain ON prds(chain_id)")
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_prds_depends_on ON prds(depends_on)")
-    conn.commit()
+    # Add new columns to tasks table if they don't exist
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='tasks'"
+    )
+    if cursor.fetchone():
+        cursor.execute("PRAGMA table_info(tasks)")
+        task_columns = {row[1] for row in cursor.fetchall()}
+        if "depends_on" not in task_columns:
+            cursor.execute("ALTER TABLE tasks ADD COLUMN depends_on TEXT DEFAULT '[]'")
+            conn.commit()
+        if "estimated_hours" not in task_columns:
+            cursor.execute("ALTER TABLE tasks ADD COLUMN estimated_hours REAL")
+            conn.commit()
+        if "complexity_score" not in task_columns:
+            cursor.execute("ALTER TABLE tasks ADD COLUMN complexity_score INTEGER")
+            conn.commit()
+        if "uncertainty_level" not in task_columns:
+            cursor.execute("ALTER TABLE tasks ADD COLUMN uncertainty_level TEXT")
+            conn.commit()
 
     # Ensure runs table exists before creating dependent tables (run_logs, diagnostic_reports)
     cursor.execute(

codeframe/persistence/schema_manager.py

@@ -60,12 +60,13 @@ def create_schema(self) -> None:
         # Metrics and audit tables
         self._create_metrics_audit_tables(cursor)
 
-        # Create all indexes
-        self._create_indexes(cursor)
-
-        # Apply schema migrations for existing databases
+        # Apply schema migrations for existing databases BEFORE creating indexes
+        # (indexes may reference columns added by migrations)
         self._apply_migrations(cursor)
 
+        # Create all indexes (after migrations so all columns exist)
+        self._create_indexes(cursor)
+
         self.conn.commit()
 
         # Ensure default admin user exists
@@ -82,6 +83,69 @@ def _apply_migrations(self, cursor: sqlite3.Cursor) -> None:
             cursor, "issues", "depends_on", "TEXT"
         )
 
+        # Migration: Add missing columns to tasks table for older databases
+        # Core columns that may be missing
+        self._add_column_if_not_exists(
+            cursor, "tasks", "project_id", "INTEGER"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "issue_id", "INTEGER"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "parent_issue_number", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "task_number", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "description", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "status", "TEXT", "'pending'"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "priority", "INTEGER", "0"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "workflow_step", "INTEGER"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "depends_on", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "created_at", "TIMESTAMP", "CURRENT_TIMESTAMP"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "completed_at", "TIMESTAMP"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "assigned_to", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "can_parallelize", "BOOLEAN", "FALSE"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "requires_mcp", "BOOLEAN", "FALSE"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "estimated_tokens", "INTEGER"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "actual_tokens", "INTEGER"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "commit_sha", "TEXT"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "quality_gate_status", "TEXT", "'pending'"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "quality_gate_failures", "JSON"
+        )
+        self._add_column_if_not_exists(
+            cursor, "tasks", "requires_human_approval", "BOOLEAN", "FALSE"
+        )
+
         # Migration: Add effort estimation columns to tasks table (Phase 1)
         self._add_column_if_not_exists(
             cursor, "tasks", "estimated_hours", "REAL"

codeframe/ui/dependencies.py

@@ -1,42 +1,22 @@
 """FastAPI dependency injection providers.
 
 This module provides dependency injection functions for accessing
-shared application state (database, workspace manager, etc.) across
-all API endpoints.
+shared application state across all API endpoints.
 
-Supports both v1 (Database, WorkspaceManager) and v2 (Workspace) patterns.
+v2-only: All dependencies use codeframe.core modules.
 """
 
 from pathlib import Path
 from typing import Optional
 
-from fastapi import HTTPException, Query, Request, WebSocket
+from fastapi import HTTPException, Query, Request
 
-from codeframe.persistence.database import Database
 from codeframe.workspace import WorkspaceManager
 
 # v2 imports
 from codeframe.core.workspace import Workspace, get_workspace, workspace_exists
 
 
-def get_db(request: Request) -> Database:
-    """Get database connection from application state.
-
-    Args:
-        request: FastAPI request object
-
-    Returns:
-        Database instance from app.state.db
-
-    Usage:
-        @router.get("/endpoint")
-        async def endpoint(db: Database = Depends(get_db)):
-            # Use db here
-            ...
-    """
-    return request.app.state.db
-
-
 def get_workspace_manager(request: Request) -> WorkspaceManager:
     """Get workspace manager from application state.
 
@@ -55,24 +35,6 @@ async def endpoint(workspace_mgr: WorkspaceManager = Depends(get_workspace_manag
     return request.app.state.workspace_manager
 
 
-def get_db_websocket(websocket: WebSocket) -> Database:
-    """Get database connection from application state for WebSocket endpoints.
-
-    Args:
-        websocket: FastAPI WebSocket object
-
-    Returns:
-        Database instance from app.state.db
-
-    Usage:
-        @router.websocket("/ws/endpoint")
-        async def websocket_endpoint(websocket: WebSocket, db: Database = Depends(get_db_websocket)):
-            # Use db here
-            ...
-    """
-    return websocket.app.state.db
-
-
 def get_v2_workspace(
     workspace_path: Optional[str] = Query(
         None,
@@ -82,8 +44,7 @@ def get_v2_workspace(
 ) -> Workspace:
     """Get v2 Workspace from path or server default.
 
-    This dependency bridges v1 routes to v2 core modules. It resolves
-    a Workspace from either:
+    This dependency resolves a Workspace from either:
     1. An explicit workspace_path query parameter
     2. The server's default workspace (from app.state.default_workspace_path)
     3. The server's current working directory
@@ -140,8 +101,6 @@ async def endpoint(workspace: Workspace = Depends(get_v2_workspace)):
 
 
 __all__ = [
-    "get_db",
-    "get_db_websocket",
     "get_workspace_manager",
     "get_v2_workspace",
 ]

codeframe/ui/routers/events_v2.py

@@ -0,0 +1,89 @@
+"""Events API router for CodeFRAME v2.
+
+Provides endpoints for fetching workspace activity/event history.
+Delegates to codeframe.core.events module.
+"""
+
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from codeframe.core.workspace import Workspace, get_workspace, workspace_exists
+from codeframe.core import events
+from pathlib import Path
+
+router = APIRouter(prefix="/api/v2/events", tags=["events"])
+
+
+class EventResponse(BaseModel):
+    """Response model for a single event."""
+
+    id: int
+    workspace_id: str
+    event_type: str
+    payload: dict
+    created_at: str  # ISO format
+
+
+class EventListResponse(BaseModel):
+    """Response model for event list."""
+
+    events: list[EventResponse]
+    total: int
+
+
+def _get_workspace_from_path(workspace_path: str) -> Workspace:
+    """Get workspace from path, raising appropriate HTTP errors."""
+    path = Path(workspace_path).resolve()
+
+    if not workspace_exists(path):
+        raise HTTPException(
+            status_code=404,
+            detail=f"Workspace not found at {path}. Initialize with 'cf init {path}'",
+        )
+
+    workspace = get_workspace(path)
+    if not workspace:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Workspace not found at {path}",
+        )
+
+    return workspace
+
+
+@router.get("", response_model=EventListResponse)
+async def list_events(
+    workspace_path: str = Query(..., description="Path to workspace directory"),
+    limit: int = Query(20, ge=1, le=100, description="Maximum events to return"),
+    since_id: Optional[int] = Query(None, description="Only return events after this ID"),
+):
+    """List recent events for a workspace.
+
+    Returns events in reverse chronological order (newest first).
+
+    Args:
+        workspace_path: Path to the workspace
+        limit: Maximum number of events (1-100, default 20)
+        since_id: Optional event ID for pagination
+
+    Returns:
+        List of events with total count
+    """
+    workspace = _get_workspace_from_path(workspace_path)
+
+    event_list = events.list_recent(workspace, limit=limit, since_id=since_id)
+
+    return EventListResponse(
+        events=[
+            EventResponse(
+                id=e.id,
+                workspace_id=e.workspace_id,
+                event_type=e.event_type,
+                payload=e.payload,
+                created_at=e.created_at.isoformat(),
+            )
+            for e in event_list
+        ],
+        total=len(event_list),
+    )

codeframe/ui/routers/tasks.py

@@ -14,7 +14,7 @@
 from datetime import datetime, UTC
 from typing import Any, List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, Request
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
 from pydantic import BaseModel, Field, ConfigDict
 
 from codeframe.core.models import Task, TaskStatus