jettypod 4.4.118 → 4.4.121

package/apps/dashboard/lib/db.ts

@@ -1,1305 +1,109 @@
-// Dashboard database access layer
-// Reads from JettyPod SQLite database
+// Database types for the dashboard UI layer
+// Server-side implementation moved to Tauri IPC (data-bridge.ts)
+// WorkItem matches the shape components expect (with .type field).
+// data-bridge.ts WorkItemData has .type (matching Rust serde rename).
 
-import Database from 'better-sqlite3';
-import path from 'path';
-import fs from 'fs';
-import { execSync } from 'child_process';
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const { runMigrations } = require('./run-migrations');
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const { ensureSchema } = require('../../../lib/schema');
-
-// Types matching JettyPod schema
 export interface WorkItem {
   id: number;
-  type: 'epic' | 'feature' | 'chore' | 'bug';
+  type: string;
   title: string;
   description: string | null;
-  status: 'backlog' | 'todo' | 'in_progress' | 'done' | 'cancelled';
+  status: string;
   parent_id: number | null;
   epic_id: number | null;
   branch_name: string | null;
-  mode: 'speed' | 'stable' | 'production' | null;
+  mode: string | null;
   phase: string | null;
   completed_at: string | null;
   rejection_reason: string | null;
-  rejected_at: string | null;
   ready_for_review: number;
+  rejection_count: number;
+  rejection_round: number | null;
+  rejection_history: string | null;
+  needs_discovery?: number;
   created_at: string;
   display_order: number | null;
-  conversational: number;
+  conversational?: number;
+  current_step?: number | null;
+  total_steps?: number | null;
   children?: WorkItem[];
   chores?: WorkItem[];
   bugs?: WorkItem[];
-  current_step?: number | null;
-  total_steps?: number | null;
-}
-
-export interface Decision {
-  id: number;
-  work_item_id: number;
-  aspect: string;
-  decision: string;
-  rationale: string;
-  created_at: string;
-}
-
-export function getProjectRoot(): string | null {
-  // Use JETTYPOD_PROJECT_PATH if set (passed by Electron main process)
-  if (process.env.JETTYPOD_PROJECT_PATH) {
-    return process.env.JETTYPOD_PROJECT_PATH;
-  }
-
-  // In packaged Electron app, JETTYPOD_PROJECT_PATH is the only source of truth.
-  // Don't fall back to git rev-parse - if no project is selected, return null.
-  // This prevents the app from accidentally using whatever git repo the user
-  // happens to run the app from.
-  // JETTYPOD_IS_PACKAGED is set by electron/main.js in production mode.
-  if (process.env.JETTYPOD_IS_PACKAGED) {
-    return null;
-  }
-
-  // Development mode only: fall back to git rev-parse for convenience
-  try {
-    return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
-  } catch {
-    return null;
-  }
-}
-
-function getDbPath(): string | null {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    return null;  // No project selected
-  }
-  return path.join(projectRoot, '.jettypod', 'work.db');
-}
-
-// Check if a project is currently selected
-export function hasProject(): boolean {
-  return getProjectRoot() !== null;
-}
-
-export function getProjectName(): string {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    return 'No Project';  // Pre-project state (welcome/install screens)
-  }
-  const configPath = path.join(projectRoot, '.jettypod', 'config.json');
-  if (fs.existsSync(configPath)) {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    return config.name || 'Untitled Project';
-  }
-  return 'Untitled Project';
-}
-
-// Ensure critical columns exist via ALTER TABLE, catching "duplicate column" errors.
-// Handles databases where migrations were falsely recorded as applied
-// (the shim was missing db.serialize(), so migrations using it silently failed).
-function ensureColumns(db: Database.Database): void {
-  const tryAddTo = (table: string, col: string, type: string) => {
-    try {
-      db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${type}`);
-    } catch {
-      // Column already exists - expected for healthy databases
-    }
-  };
-  try {
-    tryAddTo('work_items', 'display_order', 'INTEGER DEFAULT NULL');
-    tryAddTo('work_items', 'rejection_reason', 'TEXT');
-    tryAddTo('work_items', 'rejected_at', 'TEXT');
-    tryAddTo('work_items', 'conversational', 'INTEGER DEFAULT 0');
-    tryAddTo('work_items', 'plan_at_creation', 'TEXT DEFAULT NULL');
-    tryAddTo('work_items', 'ready_for_review', 'INTEGER DEFAULT 0');
-  } catch {
-    // Table might not exist yet - ensureSchema will handle it
-  }
-
-  // claude_sessions columns from migrations 022-024 (used db.serialize which was missing)
-  try {
-    tryAddTo('claude_sessions', 'session_title', 'TEXT');
-    tryAddTo('claude_sessions', 'content', 'TEXT');
-  } catch {
-    // Table might not exist yet - migration 021 will create it
-  }
-
-  // Clear falsely-recorded migrations that used db.serialize() so they re-run properly.
-  // Only clear if we detect the column was actually missing (i.e. we just added it).
-  try {
-    const cols = db.prepare("PRAGMA table_info(claude_sessions)").all() as Array<{ name: string }>;
-    const hasSessionTitle = cols.some(c => c.name === 'session_title');
-    if (hasSessionTitle) {
-      // Check if work_item_id is still NOT NULL (migration 022 should make it nullable)
-      const workItemCol = cols.find(c => c.name === 'work_item_id') as { name: string; notnull: number } | undefined;
-      if (workItemCol && workItemCol.notnull === 1) {
-        // Column was added by our ALTER TABLE but migration 022 didn't actually run
-        // (it recreates the table with nullable work_item_id). Clear so it re-runs.
-        db.exec("DELETE FROM migrations WHERE id IN ('022-independent-sessions', '023-session-content-column', '024-session-orphaned-status')");
-      }
-    }
-  } catch {
-    // migrations table might not exist yet
-  }
-}
-
-// Check if a project folder has no implementation code
-export function isBlankProject(projectPath: string): boolean {
-  const IMPL_PATTERNS = [
-    /\.js$/, /\.ts$/, /\.jsx$/, /\.tsx$/, /\.mjs$/, /\.cjs$/,
-    /\.py$/, /\.rb$/, /\.go$/, /\.rs$/, /\.java$/, /\.kt$/,
-    /\.c$/, /\.cpp$/, /\.h$/, /\.swift$/, /\.php$/,
-    /^src\//, /^lib\//, /^app\//,
-    /^package\.json$/, /^Cargo\.toml$/, /^requirements\.txt$/,
-    /^Gemfile$/, /^go\.mod$/, /^pom\.xml$/, /^build\.gradle$/,
-  ];
-  const IGNORE = [/^\.git\//, /^\.jettypod\//, /^\.claude\//, /^node_modules\//];
-
-  function scan(dir: string, baseDir: string): boolean {
-    if (!fs.existsSync(dir)) return false;
-    let entries: fs.Dirent[];
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return false; }
-    for (const entry of entries) {
-      const rel = path.relative(baseDir, path.join(dir, entry.name));
-      if (IGNORE.some(p => p.test(rel) || p.test(entry.name))) continue;
-      if (entry.isDirectory()) {
-        if (IMPL_PATTERNS.some(p => p.test(rel + '/'))) return true;
-        if (scan(path.join(dir, entry.name), baseDir)) return true;
-      } else {
-        if (IMPL_PATTERNS.some(p => p.test(rel))) return true;
-      }
-    }
-    return false;
-  }
-
-  return !scan(projectPath, projectPath);
-}
-
-// Seed onboarding epic into a blank project's database if not already present
-function seedOnboardingIfBlank(db: Database.Database, dbPath: string): void {
-  try {
-    const projectPath = path.dirname(path.dirname(dbPath)); // .jettypod/work.db -> project root
-    if (!isBlankProject(projectPath)) return;
-
-    const existing = db.prepare("SELECT id FROM work_items WHERE type = 'epic' AND title = 'Project Onboarding'").get();
-    if (existing) return;
-
-    const insert = db.prepare(
-      'INSERT INTO work_items (type, title, description, parent_id, status, created_at, conversational) VALUES (?, ?, ?, ?, ?, ?, ?)'
-    );
-    const now = new Date().toISOString();
-
-    const epicResult = insert.run('epic', 'Project Onboarding',
-      'Get your project set up and planned. Work through these chores one at a time — each one is a short conversation.', null, 'backlog', now, 0);
-    const epicId = epicResult.lastInsertRowid;
-
-    const chores = [
-      { title: 'Align on the user journey', desc: 'Help the user define what their product does.\n\nCLAUDE SESSION GUIDANCE:\nOpen with: "What do users DO in this product?"\n\nOUTCOME:\n- A clear description of the core user journey' },
-      { title: 'Explore UX approaches', desc: 'Help the user decide how the product should feel.\n\nCONTEXT FROM PREVIOUS CHORE:\nRead previous decisions first.\n\nCLAUDE SESSION GUIDANCE:\nPresent 3 UX approaches.\n\nOUTCOME:\n- 3 UX options compared\n- A winner chosen' },
-      { title: 'Choose a tech stack', desc: 'Help the user pick the right tech stack.\n\nCONTEXT FROM PREVIOUS CHORES:\nRead previous decisions first.\n\nCLAUDE SESSION GUIDANCE:\nPresent 3 tech stack options.\n\nOUTCOME:\n- A tech stack chosen with rationale' },
-      { title: 'Break the project into epics', desc: 'Break the project into buildable phases.\n\nCONTEXT FROM PREVIOUS CHORES:\nRead all previous decisions.\n\nCLAUDE SESSION GUIDANCE:\nPropose 3-5 epics.\n\nOUTCOME:\n- 3-5 epics created in the backlog' },
-    ];
-
-    for (const chore of chores) {
-      insert.run('chore', chore.title, chore.desc, epicId, 'backlog', now, 1);
-    }
-  } catch (err) {
-    console.error('Could not seed onboarding:', err instanceof Error ? err.message : err);
-  }
-}
-
-// Singleton database connection - reused across all operations
-let cachedDb: Database.Database | null = null;
-let cachedDbPath: string | null = null;
-
-function getDb(): Database.Database {
-  const dbPath = getDbPath();
-
-  // No project selected - can't access database
-  if (!dbPath) {
-    throw new Error('No project selected. Please select a project first.');
-  }
-
-  // If project path changed, close old connection and reconnect
-  if (cachedDb && cachedDbPath !== dbPath) {
-    cachedDb.close();
-    cachedDb = null;
-    cachedDbPath = null;
-  }
-
-  if (!cachedDb) {
-    // Auto-create .jettypod directory if missing (handles projects without one)
-    const dbDir = path.dirname(dbPath);
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true });
-    }
-    try {
-      cachedDb = new Database(dbPath);
-      cachedDbPath = dbPath;
-      // Enable WAL mode for better concurrent performance
-      cachedDb.pragma('journal_mode = WAL');
-      // Enable foreign key constraints - required for ON DELETE CASCADE/SET NULL to work
-      cachedDb.pragma('foreign_keys = ON');
-      // Ensure core tables exist (handles empty/old databases)
-      ensureSchema(cachedDb);
-      // Defense-in-depth: ensure critical columns exist even if migrations
-      // were falsely recorded as applied (run-migrations.js has a known
-      // sync/async bug where Promise rejections aren't caught synchronously)
-      ensureColumns(cachedDb);
-      // Run pending migrations to handle old project databases
-      try {
-        runMigrations(cachedDb);
-      } catch (err) {
-        console.error('Failed to run migrations:', err);
-      }
-      // Seed onboarding epic for blank projects (no implementation code detected)
-      seedOnboardingIfBlank(cachedDb, dbPath);
-    } catch (err) {
-      // Clean up failed connection to avoid caching a broken db
-      if (cachedDb) {
-        try { cachedDb.close(); } catch { /* ignore close errors */ }
-      }
-      cachedDb = null;
-      cachedDbPath = null;
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Database error: ${message}`);
-    }
-  }
-  return cachedDb;
-}
-
-// Close database connection - call when switching projects or shutting down
-export function closeDb(): void {
-  if (cachedDb) {
-    cachedDb.close();
-    cachedDb = null;
-    cachedDbPath = null;
-  }
-}
-
-// For backwards compatibility - now returns same connection as getDb()
-// SQLite with WAL mode handles reads and writes on same connection safely
-function getWriteDb(): Database.Database {
-  return getDb();
-}
-
-export function getAllWorkItems(): WorkItem[] {
-  const db = getDb();
-  const items = db.prepare(`
-    SELECT id, type, title, description, status, parent_id, epic_id,
-           branch_name, mode, phase, completed_at, created_at, conversational
-    FROM work_items
-    ORDER BY id
-  `).all() as WorkItem[];
-  return items;
-}
-
-export function getWorkItem(id: number): WorkItem | null {
-  const db = getDb();
-  const item = db.prepare(`
-    SELECT id, type, title, description, status, parent_id, epic_id,
-           branch_name, mode, phase, completed_at, created_at, conversational
-    FROM work_items
-    WHERE id = ?
-  `).get(id) as WorkItem | undefined;
-  return item || null;
-}
-
-export function getChildWorkItems(parentId: number): WorkItem[] {
-  const db = getDb();
-  const items = db.prepare(`
-    SELECT id, type, title, description, status, parent_id, epic_id,
-           branch_name, mode, phase, completed_at, created_at, conversational
-    FROM work_items
-    WHERE parent_id = ?
-    ORDER BY id
-  `).all(parentId) as WorkItem[];
-  return items;
-}
-
-export function getDecisionsForWorkItem(workItemId: number): Decision[] {
-  const db = getDb();
-  const decisions = db.prepare(`
-    SELECT id, work_item_id, aspect, decision, rationale, created_at
-    FROM discovery_decisions
-    WHERE work_item_id = ?
-    ORDER BY created_at
-  `).all(workItemId) as Decision[];
-  return decisions;
-}
-
-export function getDecision(id: number): (Decision & { work_item_title?: string }) | null {
-  const db = getDb();
-  if (id > 0) {
-    // Regular decision from discovery_decisions table
-    const decision = db.prepare(`
-      SELECT d.id, d.work_item_id, d.aspect, d.decision, d.rationale, d.created_at,
-             w.title as work_item_title
-      FROM discovery_decisions d
-      LEFT JOIN work_items w ON d.work_item_id = w.id
-      WHERE d.id = ?
-    `).get(id) as (Decision & { work_item_title?: string }) | undefined;
-    return decision || null;
-  } else {
-    // Negative ID = UX decision from work_items table (id * -1)
-    const workItemId = Math.abs(id);
-    const decision = db.prepare(`
-      SELECT
-        id * -1 as id,
-        id as work_item_id,
-        'UX Approach' as aspect,
-        discovery_winner as decision,
-        discovery_rationale as rationale,
-        COALESCE(discovery_completed_at, created_at) as created_at,
-        title as work_item_title
-      FROM work_items
-      WHERE id = ? AND discovery_winner IS NOT NULL
-    `).get(workItemId) as (Decision & { work_item_title?: string }) | undefined;
-    return decision || null;
-  }
 }
 
-// Build a tree structure from flat work items
-export function buildWorkItemTree(items: WorkItem[]): WorkItem[] {
-  const itemMap = new Map<number, WorkItem>();
-  const roots: WorkItem[] = [];
+// Re-export kanban types from data-bridge (single source of truth)
+export type {
+  InFlightItem,
+  KanbanGroup,
+  KanbanData,
+} from './data-bridge';
 
-  // First pass: create map and initialize children arrays
-  for (const item of items) {
-    itemMap.set(item.id, { ...item, children: [] });
-  }
-
-  // Second pass: build tree structure
-  for (const item of items) {
-    const node = itemMap.get(item.id)!;
-    if (item.parent_id && itemMap.has(item.parent_id)) {
-      const parent = itemMap.get(item.parent_id)!;
-      parent.children!.push(node);
-    } else {
-      roots.push(node);
-    }
-  }
-
-  return roots;
-}
-
-export function getBacklogTree(): WorkItem[] {
-  const items = getAllWorkItems();
-  return buildWorkItemTree(items);
-}
-
-export function getActiveWork(): WorkItem[] {
-  const db = getDb();
-  const items = db.prepare(`
-    SELECT id, type, title, description, status, parent_id, epic_id,
-           branch_name, mode, phase, completed_at, created_at, conversational
-    FROM work_items
-    WHERE status = 'in_progress'
-    ORDER BY id
-  `).all() as WorkItem[];
-  return items;
-}
-
-export function getRecentlyCompleted(limit: number = 10): WorkItem[] {
-  const db = getDb();
-  const items = db.prepare(`
-    SELECT id, type, title, description, status, parent_id, epic_id,
-           branch_name, mode, phase, completed_at, created_at, conversational
-    FROM work_items
-    WHERE status = 'done'
-    ORDER BY completed_at DESC
-    LIMIT ?
-  `).all(limit) as WorkItem[];
-  return items;
-}
-
-// Get items for Kanban view - features, standalone chores, bugs (not feature children)
-export interface KanbanGroup {
-  epicId: number | null;
-  epicTitle: string | null;
-  items: WorkItem[];
-}
-
-export interface InFlightItem extends WorkItem {
-  epicTitle: string | null;
-}
-
-export interface KanbanData {
-  inFlight: InFlightItem[];
-  backlog: Map<string, KanbanGroup>;
-  done: Map<string, KanbanGroup>;
-}
-
-export function getKanbanData(doneLimit: number = 50): KanbanData {
-  const db = getDb();
-  // Get all epics for lookup
-    const epics = db.prepare(`
-      SELECT id, title FROM work_items WHERE type = 'epic'
-    `).all() as { id: number; title: string }[];
-    const epicMap = new Map(epics.map(e => [e.id, e.title]));
-
-    // Get all chores that belong to features (for chore expansion)
-    const featureChores = db.prepare(`
-      SELECT c.id, c.type, c.title, c.description, c.status, c.parent_id, c.epic_id,
-             c.branch_name, c.mode, c.phase, c.completed_at, c.created_at, c.conversational,
-             wc.current_step, wc.total_steps
-      FROM work_items c
-      INNER JOIN work_items f ON c.parent_id = f.id
-      LEFT JOIN workflow_checkpoints wc ON wc.work_item_id = c.id
-      WHERE c.type = 'chore' AND f.type = 'feature'
-      ORDER BY c.id
-    `).all() as WorkItem[];
-
-    // Group chores by parent feature ID
-    const choresByFeature = new Map<number, WorkItem[]>();
-    for (const chore of featureChores) {
-      if (chore.parent_id) {
-        const existing = choresByFeature.get(chore.parent_id) || [];
-        existing.push(chore);
-        choresByFeature.set(chore.parent_id, existing);
-      }
-    }
-
-    // Get all bugs that belong to features (for bug expansion)
-    const featureBugs = db.prepare(`
-      SELECT b.id, b.type, b.title, b.description, b.status, b.parent_id, b.epic_id,
-             b.branch_name, b.mode, b.phase, b.completed_at, b.created_at, b.conversational
-      FROM work_items b
-      INNER JOIN work_items f ON b.parent_id = f.id
-      WHERE b.type = 'bug' AND f.type = 'feature'
-      ORDER BY b.id
-    `).all() as WorkItem[];
-
-    // Group bugs by parent feature ID
-    const bugsByFeature = new Map<number, WorkItem[]>();
-    for (const bug of featureBugs) {
-      if (bug.parent_id) {
-        const existing = bugsByFeature.get(bug.parent_id) || [];
-        existing.push(bug);
-        bugsByFeature.set(bug.parent_id, existing);
-      }
-    }
-
-    // Get kanban-eligible items:
-    // - Features (type = 'feature')
-    // - Chores that are NOT children of features (parent is null, or parent is an epic)
-    // - Bugs if they exist
-    const allItems = db.prepare(`
-      SELECT w.id, w.type, w.title, w.description, w.status, w.parent_id, w.epic_id,
-             w.branch_name, w.mode, w.phase, w.completed_at, w.created_at, w.conversational, w.display_order,
-             w.ready_for_review,
-             p.type as parent_type,
-             wc.current_step, wc.total_steps
-      FROM work_items w
-      LEFT JOIN work_items p ON w.parent_id = p.id
-      LEFT JOIN workflow_checkpoints wc ON wc.work_item_id = w.id
-      WHERE w.type IN ('feature', 'chore', 'bug')
-        AND (w.parent_id IS NULL OR p.type = 'epic')
-      ORDER BY COALESCE(w.display_order, w.id)
-    `).all() as (WorkItem & { parent_type: string | null })[];
-
-    const inFlight: InFlightItem[] = [];
-    const backlogGroups = new Map<string, KanbanGroup>();
-    const doneGroups = new Map<string, KanbanGroup>();
-
-    // Helper to get or create group
-    function getGroup(groups: Map<string, KanbanGroup>, item: WorkItem): KanbanGroup {
-      const epicId = item.parent_id || item.epic_id;
-      const key = epicId ? `epic-${epicId}` : 'ungrouped';
-
-      if (!groups.has(key)) {
-        groups.set(key, {
-          epicId: epicId,
-          epicTitle: epicId ? epicMap.get(epicId) || null : null,
-          items: []
-        });
-      }
-      return groups.get(key)!;
-    }
-
-    for (const item of allItems) {
-      // Strip parent_type from the item
-      const { parent_type, ...cleanItem } = item;
-
-      // Attach chores and bugs to features
-      if (cleanItem.type === 'feature') {
-        cleanItem.chores = choresByFeature.get(cleanItem.id) || [];
-        cleanItem.bugs = bugsByFeature.get(cleanItem.id) || [];
-      }
-
-      if (cleanItem.status === 'in_progress') {
-        const epicId = cleanItem.parent_id || cleanItem.epic_id;
-        const epicTitle = epicId ? epicMap.get(epicId) || null : null;
-        inFlight.push({ ...cleanItem, epicTitle });
-      } else if (cleanItem.status === 'backlog' || cleanItem.status === 'todo' || cleanItem.status === null) {
-        const group = getGroup(backlogGroups, cleanItem);
-        group.items.push(cleanItem);
-      } else if (cleanItem.status === 'done') {
-        const epicId = cleanItem.parent_id || cleanItem.epic_id;
-        if (epicId) {
-          // Epic children group together under their epic
-          const group = getGroup(doneGroups, cleanItem);
-          group.items.push(cleanItem);
-        } else {
-          // Standalone items get their own group for chronological interleaving
-          const key = `item-${cleanItem.id}`;
-          doneGroups.set(key, {
-            epicId: null,
-            epicTitle: null,
-            items: [cleanItem]
-          });
-        }
-      }
-    }
-
-    // Always ensure an ungrouped entry exists in backlog for drag-drop target
-    if (!backlogGroups.has('ungrouped')) {
-      backlogGroups.set('ungrouped', {
-        epicId: null,
-        epicTitle: null,
-        items: []
-      });
-    }
-
-    // Sort done items by completed_at DESC (newest first) within each group
-    for (const [, group] of doneGroups) {
-      group.items.sort((a, b) => {
-        const dateA = a.completed_at ? new Date(a.completed_at).getTime() : 0;
-        const dateB = b.completed_at ? new Date(b.completed_at).getTime() : 0;
-        return dateB - dateA; // DESC order
-      });
-    }
-
-    // Sort epic groups by most recent completion date (newest first)
-    const sortedDoneGroups = new Map(
-      Array.from(doneGroups.entries()).sort(([, groupA], [, groupB]) => {
-        const mostRecentA = groupA.items[0]?.completed_at
-          ? new Date(groupA.items[0].completed_at).getTime()
-          : 0;
-        const mostRecentB = groupB.items[0]?.completed_at
-          ? new Date(groupB.items[0].completed_at).getTime()
-          : 0;
-        return mostRecentB - mostRecentA; // DESC order
-      })
-    );
-
-    // Limit done items per group to ensure every group gets representation
-    const perGroupLimit = doneLimit;
-    const limitedDoneGroups = new Map<string, KanbanGroup>();
-    for (const [key, group] of sortedDoneGroups) {
-      if (group.items.length > perGroupLimit) {
-        limitedDoneGroups.set(key, { ...group, items: group.items.slice(0, perGroupLimit) });
-      } else {
-        limitedDoneGroups.set(key, group);
-      }
-    }
-
-  return { inFlight, backlog: backlogGroups, done: limitedDoneGroups };
-}
-
-export function updateWorkItemTitle(id: number, title: string): boolean {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE work_items SET title = ? WHERE id = ?
-  `).run(title, id);
-  return result.changes > 0;
-}
-
-export function updateWorkItemDescription(id: number, description: string): boolean {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE work_items SET description = ? WHERE id = ?
-  `).run(description, id);
-  return result.changes > 0;
-}
-
-export function updateWorkItemStatus(id: number, status: string, rejectionReason?: string): boolean {
-  const db = getWriteDb();
-  // Normalize rejection reason: treat empty/whitespace-only as no rejection
-  const normalizedRejection = rejectionReason?.trim() || undefined;
-  const completedAt = status === 'done' ? new Date().toISOString() : null;
-  const rejectedAt = normalizedRejection ? new Date().toISOString() : null;
-  // Clear ready_for_review when rejecting
-  const readyForReview = normalizedRejection ? 0 : undefined;
-  const result = readyForReview !== undefined
-    ? db.prepare(`
-        UPDATE work_items SET status = ?, completed_at = ?, rejection_reason = ?, rejected_at = ?, ready_for_review = ? WHERE id = ?
-      `).run(status, completedAt, normalizedRejection ?? null, rejectedAt, readyForReview, id)
-    : db.prepare(`
-        UPDATE work_items SET status = ?, completed_at = ?, rejection_reason = ?, rejected_at = ? WHERE id = ?
-      `).run(status, completedAt, normalizedRejection ?? null, rejectedAt, id);
-
-  // When work item is cancelled, mark any linked sessions as orphaned
-  if (status === 'cancelled' && result.changes > 0) {
-    orphanSessionsByWorkItem(id);
-  }
-
-  // When a chore is marked done, check if all sibling chores are done
-  // and set ready_for_review on the parent feature.
-  // Edge cases: no chores (length 0) → no auto-set; cancelled chores ≠ done → no auto-set
-  if (status === 'done' && result.changes > 0) {
-    const item = db.prepare('SELECT parent_id, type FROM work_items WHERE id = ?').get(id) as { parent_id: number | null; type: string } | undefined;
-    if (item?.parent_id && item.type === 'chore') {
-      const parent = db.prepare('SELECT id, type FROM work_items WHERE id = ?').get(item.parent_id) as { id: number; type: string } | undefined;
-      if (parent?.type === 'feature') {
-        const siblings = db.prepare('SELECT status FROM work_items WHERE parent_id = ? AND type = ?').all(parent.id, 'chore') as { status: string }[];
-        const allDone = siblings.length > 0 && siblings.every(s => s.status === 'done');
-        if (allDone) {
-          db.prepare('UPDATE work_items SET ready_for_review = 1 WHERE id = ?').run(parent.id);
-        }
-      }
-    }
-  }
-
-  return result.changes > 0;
-}
-
-export function updateWorkItemOrder(id: number, displayOrder: number): boolean {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE work_items SET display_order = ? WHERE id = ?
-  `).run(displayOrder, id);
-  return result.changes > 0;
-}
-
-export function updateWorkItemEpic(id: number, epicId: number | null): boolean {
-  const db = getWriteDb();
-  // Update parent_id for features/chores to assign them to an epic
-  const result = db.prepare(`
-    UPDATE work_items SET parent_id = ? WHERE id = ? AND type IN ('feature', 'chore', 'bug')
-  `).run(epicId, id);
-  return result.changes > 0;
-}
-
-// Claude session types
-export type SessionStatus = 'active' | 'completed' | 'error' | 'orphaned';
-
-export interface ClaudeSession {
-  id: number;
-  work_item_id: number | null;
+// Test dashboard types
+export interface TestScenario {
+  id: string;
   title: string;
-  session_title: string | null;
-  status: SessionStatus;
-  started_at: string;
-  completed_at: string | null;
-  content: string | null;
-}
-
-// Conversation turn for session content
-// Supports user messages, assistant responses, and errors (#1000099)
-export interface ConversationTurn {
-  role: 'user' | 'assistant' | 'error';
-  content: string;
-  timestamp: string;
+  status: 'pass' | 'fail' | 'pending';
+  duration: string;
+  lastRun: string | null;
+  error?: string;
+  failedStep?: string;
+  steps: string[];
+  undefinedSteps: string[];
 }
 
-// Extended session info for list display
-export interface SessionWithFeature {
-  id: number;
+export interface TestFeature {
+  id: string;
   title: string;
-  featureId: number | null;
-  featureTitle: string | null;
-  status: SessionStatus;
-  updatedAt: string;
+  description: string;
+  featureFile: string;
+  scenarios: TestScenario[];
 }
 
-export function getActiveSessions(): ClaudeSession[] {
-  const db = getDb();
-  const sessions = db.prepare(`
-    SELECT id, work_item_id, title, status, started_at, completed_at
-    FROM claude_sessions
-    WHERE status IN ('active', 'completed')
-    ORDER BY started_at DESC
-  `).all() as ClaudeSession[];
-  return sessions;
-}
-
-export function registerSession(workItemId: number, title: string): number {
-  const db = getWriteDb();
-  // Use INSERT OR REPLACE to handle existing sessions for same work item
-  const result = db.prepare(`
-    INSERT OR REPLACE INTO claude_sessions (work_item_id, title, status, started_at)
-    VALUES (?, ?, 'active', datetime('now'))
-  `).run(workItemId, title);
-  return result.lastInsertRowid as number;
-}
-
-export function updateSessionStatus(workItemId: number, status: SessionStatus): boolean {
-  const db = getWriteDb();
-  const completedAt = status !== 'active' ? "datetime('now')" : null;
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET status = ?, completed_at = ${completedAt ? "datetime('now')" : 'NULL'}
-    WHERE work_item_id = ?
-  `).run(status, workItemId);
-  return result.changes > 0;
-}
-
-// Mark all sessions linked to a work item as orphaned (used when work item is cancelled/deleted)
-export function orphanSessionsByWorkItem(workItemId: number): number {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET status = 'orphaned', completed_at = datetime('now')
-    WHERE work_item_id = ? AND status = 'active'
-  `).run(workItemId);
-  return result.changes;
-}
-
-// Cleanup stale sessions: delete orphaned, old completed, and old error sessions
-// Returns count of deleted sessions
-export function cleanupStaleSessions(retentionDays: number = 30): number {
-  const db = getWriteDb();
-
-  // Delete orphaned sessions (immediately) and old completed/error sessions (after retention period)
-  const result = db.prepare(`
-    DELETE FROM claude_sessions
-    WHERE status = 'orphaned'
-       OR (status = 'completed' AND completed_at < datetime('now', '-' || ? || ' days'))
-       OR (status = 'error' AND completed_at < datetime('now', '-' || ? || ' days'))
-  `).run(retentionDays, retentionDays);
-
-  return result.changes;
-}
-
-// List all sessions with linked feature info
-export function listSessions(): SessionWithFeature[] {
-  const db = getDb();
-  const sessions = db.prepare(`
-    SELECT
-      cs.id,
-      COALESCE(w.title, cs.session_title, 'Untitled Session') as title,
-      cs.work_item_id as featureId,
-      w.title as featureTitle,
-      cs.status,
-      COALESCE(cs.completed_at, cs.started_at) as updatedAt
-    FROM claude_sessions cs
-    LEFT JOIN work_items w ON cs.work_item_id = w.id
-    WHERE cs.status = 'active'
-    ORDER BY COALESCE(cs.completed_at, cs.started_at) DESC
-  `).all() as SessionWithFeature[];
-  return sessions;
-}
-
-// Count active sessions
-export function countActiveSessions(): number {
-  const db = getDb();
-  const result = db.prepare(`
-    SELECT COUNT(*) as count FROM claude_sessions WHERE status = 'active'
-  `).get() as { count: number };
-  return result.count;
-}
-
-// Create a new unlinked session
-export function createSession(title: string): number {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    INSERT INTO claude_sessions (work_item_id, title, session_title, status, started_at)
-    VALUES (NULL, ?, ?, 'active', datetime('now'))
-  `).run(title, title);
-  return result.lastInsertRowid as number;
-}
-
-// Check if a work item is linkable (can have a session attached)
-// Linkable: feature, standalone chore (no parent or epic parent), bug
-// NOT linkable: epic, chore under a feature (uses feature's session)
-export function isLinkableWorkItem(workItemId: number): { linkable: boolean; reason?: string; redirectToId?: number } {
-  const db = getDb();
-  const workItem = db.prepare(`
-    SELECT w.id, w.type, w.parent_id, p.type as parent_type
-    FROM work_items w
-    LEFT JOIN work_items p ON w.parent_id = p.id
-    WHERE w.id = ?
-  `).get(workItemId) as { id: number; type: string; parent_id: number | null; parent_type: string | null } | undefined;
-
-  if (!workItem) {
-    return { linkable: false, reason: 'Work item not found' };
-  }
-
-  // Epics are never linkable
-  if (workItem.type === 'epic') {
-    return { linkable: false, reason: 'Epics cannot have sessions - link to a feature or chore instead' };
-  }
-
-  // Chores under features use the feature's session
-  if (workItem.type === 'chore' && workItem.parent_type === 'feature') {
-    return {
-      linkable: false,
-      reason: 'Chores under features use the feature\'s session',
-      redirectToId: workItem.parent_id!
-    };
-  }
-
-  // Features, bugs, and standalone chores (no parent or epic parent) are linkable
-  return { linkable: true };
-}
-
-// Link a session to a work item
-// Only links to: features, standalone chores, bugs
-// Rejects: epics, chores under features
-export function linkSession(sessionId: number, workItemId: number): { success: boolean; error?: string; redirectToId?: number } {
-  // First check if this work item is linkable
-  const linkCheck = isLinkableWorkItem(workItemId);
-  if (!linkCheck.linkable) {
-    return {
-      success: false,
-      error: linkCheck.reason,
-      redirectToId: linkCheck.redirectToId
-    };
-  }
-
-  const db = getWriteDb();
-  // Get the work item title
-  const workItem = db.prepare(`SELECT title FROM work_items WHERE id = ?`).get(workItemId) as { title: string } | undefined;
-  if (!workItem) {
-    return { success: false, error: 'Work item not found' };
-  }
-
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET work_item_id = ?, title = ?
-    WHERE id = ? AND work_item_id IS NULL
-  `).run(workItemId, workItem.title, sessionId);
-
-  if (result.changes === 0) {
-    return { success: false, error: 'Session already linked or not found' };
-  }
-
-  return { success: true };
-}
-
-// Get ACTIVE session by work item ID (for one-session-per-work-item check)
-// Only returns sessions with status='active', ignores completed/error sessions
-// Note: Does NOT include content - use getSessionContent() to load content lazily
-export function getActiveSessionByWorkItem(workItemId: number): ClaudeSession | null {
-  const db = getDb();
-  const session = db.prepare(`
-    SELECT id, work_item_id, title, session_title, status, started_at, completed_at
-    FROM claude_sessions
-    WHERE work_item_id = ? AND status = 'active'
-  `).get(workItemId) as ClaudeSession | undefined;
-  return session || null;
-}
-
-// Get or create active session for a linkable work item
-// Returns existing active session if one exists, otherwise creates a new one
-// Returns null if work item is not linkable (epic, chore under feature)
-// Note: Does NOT include content - use getSessionContent() to load content lazily
-export function getOrCreateSessionForWorkItem(workItemId: number): { session: ClaudeSession | null; created: boolean; error?: string; redirectToId?: number } {
-  // Check if work item is linkable
-  const linkCheck = isLinkableWorkItem(workItemId);
-  if (!linkCheck.linkable) {
-    return {
-      session: null,
-      created: false,
-      error: linkCheck.reason,
-      redirectToId: linkCheck.redirectToId
-    };
-  }
-
-  // Check for existing active session
-  const existingSession = getActiveSessionByWorkItem(workItemId);
-  if (existingSession) {
-    return { session: existingSession, created: false };
-  }
-
-  // Create new session and link it
-  const db = getWriteDb();
-  // Get work item title
-  const workItem = db.prepare(`SELECT title FROM work_items WHERE id = ?`).get(workItemId) as { title: string } | undefined;
-  if (!workItem) {
-    return { session: null, created: false, error: 'Work item not found' };
-  }
-
-  // Create linked session directly
-  const result = db.prepare(`
-    INSERT INTO claude_sessions (work_item_id, title, status, started_at)
-    VALUES (?, ?, 'active', datetime('now'))
-  `).run(workItemId, workItem.title);
-
-  const sessionId = result.lastInsertRowid as number;
-
-  // Fetch and return the created session (without content - load lazily)
-  const newSession = db.prepare(`
-    SELECT id, work_item_id, title, session_title, status, started_at, completed_at
-    FROM claude_sessions
-    WHERE id = ?
-  `).get(sessionId) as ClaudeSession;
-
-  return { session: newSession, created: true };
-}
-
-// Get session by ID
-export function getSession(sessionId: number): ClaudeSession | null {
-  const db = getDb();
-  const session = db.prepare(`
-    SELECT id, work_item_id, title, session_title, status, started_at, completed_at
-    FROM claude_sessions
-    WHERE id = ?
-  `).get(sessionId) as ClaudeSession | undefined;
-  return session || null;
-}
-
-// Close a session by ID (mark as completed)
-export function closeSession(sessionId: number): boolean {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET status = 'completed', completed_at = datetime('now')
-    WHERE id = ?
-  `).run(sessionId);
-  return result.changes > 0;
-}
-
-// Close a session by work item ID (for work-item sessions)
-export function closeSessionByWorkItem(workItemId: number): boolean {
-  const db = getWriteDb();
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET status = 'completed', completed_at = datetime('now')
-    WHERE work_item_id = ? AND status = 'active'
-  `).run(workItemId);
-  return result.changes > 0;
+export interface TestEpic {
+  id: string;
+  title: string;
+  healthBadge: { passing: number; failing: number };
+  features: TestFeature[];
 }
 
-// Get session content (conversation history) by session ID
-export function getSessionContent(sessionId: number): ConversationTurn[] {
-  const db = getDb();
-  const session = db.prepare(`
-    SELECT content FROM claude_sessions WHERE id = ?
-  `).get(sessionId) as { content: string | null } | undefined;
-
-  if (!session?.content) {
-    return [];
-  }
-
-  try {
-    return JSON.parse(session.content) as ConversationTurn[];
-  } catch {
-    return [];
-  }
+export interface TestSummary {
+  total: number;
+  passing: number;
+  failing: number;
+  pending: number;
+  lastRun: string | null;
 }
 
-// Get session content (conversation history) by work item ID
-export function getSessionContentByWorkItem(workItemId: number): ConversationTurn[] {
-  const db = getDb();
-  const session = db.prepare(`
-    SELECT content FROM claude_sessions WHERE work_item_id = ? AND status = 'active'
-  `).get(workItemId) as { content: string | null } | undefined;
-
-  if (!session?.content) {
-    return [];
-  }
-
-  try {
-    return JSON.parse(session.content) as ConversationTurn[];
-  } catch {
-    return [];
-  }
+export interface TestDashboardData {
+  summary: TestSummary;
+  epics: TestEpic[];
+  standaloneFeatures: TestFeature[];
 }
 
-// Append a conversation turn to session content
-// Uses atomic JSON operation to prevent race conditions
-export function appendSessionContent(sessionId: number, turn: ConversationTurn): boolean {
-  const db = getWriteDb();
-
-  // Atomic append using json_insert with $[#] path (appends to end of array)
-  // COALESCE handles NULL content by starting with empty array
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET content = json_insert(COALESCE(content, '[]'), '$[#]', json(?))
-    WHERE id = ?
-  `).run(JSON.stringify(turn), sessionId);
-
-  return result.changes > 0;
-}
-
-// Append a conversation turn to session content by work item ID
-// Uses atomic JSON operation to prevent race conditions
-export function appendSessionContentByWorkItem(workItemId: number, turn: ConversationTurn): boolean {
-  const db = getWriteDb();
-
-  // Atomic append using json_insert with $[#] path (appends to end of array)
-  // Updates directly by work_item_id without separate SELECT
-  const result = db.prepare(`
-    UPDATE claude_sessions
-    SET content = json_insert(COALESCE(content, '[]'), '$[#]', json(?))
-    WHERE work_item_id = ? AND status = 'active'
-  `).run(JSON.stringify(turn), workItemId);
-
-  return result.changes > 0;
-}
-
-// Environment Variables - backed by .env files on disk
-export interface EnvVar {
+// Prototype dashboard types
+export interface PrototypeFile {
   name: string;
-  value: string;
-}
-
-export interface ValidationResult {
-  valid: boolean;
-  error?: string;
-}
-
-// Validate env var name - rejects empty/whitespace-only names
-export function validateEnvVarName(name: string | undefined | null): ValidationResult {
-  if (!name || !name.trim()) {
-    return { valid: false, error: 'Variable name is required' };
-  }
-  return { valid: true };
-}
-
-// Validate env var value - rejects undefined/null (empty string is valid)
-export function validateEnvVarValue(value: string | undefined | null): ValidationResult {
-  if (value === undefined || value === null) {
-    return { valid: false, error: 'Variable value is required' };
-  }
-  return { valid: true };
-}
-
-// Check if a variable name already exists in a .env file
-export function checkDuplicateEnvVar(name: string, filename?: string): boolean {
-  const vars = getEnvVars(filename);
-  return vars.some(v => v.name === name);
-}
-
-function getConfigPath(): string | null {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    return null;
-  }
-  return path.join(projectRoot, '.jettypod', 'config.json');
-}
-
-function readConfig(): Record<string, unknown> {
-  const configPath = getConfigPath();
-  if (!configPath) {
-    return {};  // No project selected
-  }
-  if (fs.existsSync(configPath)) {
-    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  }
-  return {};
-}
-
-function writeConfig(config: Record<string, unknown>): void {
-  const configPath = getConfigPath();
-  if (!configPath) {
-    throw new Error('No project selected. Cannot write config.');
-  }
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-// Parse .env file content into key-value pairs (skips comments and blank lines)
-export function parseEnvFile(content: string): EnvVar[] {
-  const vars: EnvVar[] = [];
-  const lines = content.split('\n');
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eqIndex = trimmed.indexOf('=');
-    if (eqIndex > 0) {
-      vars.push({
-        name: trimmed.substring(0, eqIndex),
-        value: trimmed.substring(eqIndex + 1),
-      });
-    }
-  }
-  return vars;
-}
-
-// Discover .env files in the project root
-export function discoverEnvFiles(): string[] {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    return [];  // No project selected
-  }
-  const files = fs.readdirSync(projectRoot);
-  return files.filter((f: string) => f === '.env' || f.startsWith('.env.')).sort();
-}
-
-// Get the currently selected .env file from config.json
-export function getSelectedEnvFile(): string | null {
-  const config = readConfig();
-  return (config.selectedEnvFile as string) || null;
-}
-
-// Persist the selected .env file in config.json
-export function setSelectedEnvFile(filename: string): void {
-  const config = readConfig();
-  config.selectedEnvFile = filename;
-  writeConfig(config);
-}
-
-// Create a new .env file in the project root
-export function createEnvFile(filename: string = '.env'): void {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    throw new Error('No project selected. Cannot create env file.');
-  }
-  const filePath = path.join(projectRoot, filename);
-  fs.writeFileSync(filePath, '', 'utf-8');
-}
-
-// Read env vars from a specific .env file on disk
-export function getEnvVars(filename?: string): EnvVar[] {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    return [];  // No project selected
-  }
-  const file = filename || getSelectedEnvFile() || '.env';
-  const filePath = path.join(projectRoot, file);
-  if (!fs.existsSync(filePath)) {
-    return [];
-  }
-  const content = fs.readFileSync(filePath, 'utf-8');
-  return parseEnvFile(content);
-}
-
-// Add or update an env var in a .env file, preserving comments and blank lines
-export function setEnvVar(name: string, value: string, filename?: string): void {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    throw new Error('No project selected. Cannot set env var.');
-  }
-  const file = filename || getSelectedEnvFile() || '.env';
-  const filePath = path.join(projectRoot, file);
-
-  if (!fs.existsSync(filePath)) {
-    fs.writeFileSync(filePath, `${name}=${value}\n`, 'utf-8');
-    return;
-  }
-
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const lines = content.split('\n');
-  let found = false;
-  const updatedLines = lines.map(line => {
-    if (line.startsWith(name + '=')) {
-      found = true;
-      return `${name}=${value}`;
-    }
-    return line;
-  });
-
-  if (!found) {
-    // Append new variable
-    const trimmed = updatedLines.join('\n').trimEnd();
-    fs.writeFileSync(filePath, trimmed + '\n' + `${name}=${value}` + '\n', 'utf-8');
-  } else {
-    fs.writeFileSync(filePath, updatedLines.join('\n'), 'utf-8');
-  }
-}
-
-// Delete an env var from a .env file
-export function deleteEnvVar(name: string, filename?: string): void {
-  const projectRoot = getProjectRoot();
-  if (!projectRoot) {
-    throw new Error('No project selected. Cannot delete env var.');
-  }
-  const file = filename || getSelectedEnvFile() || '.env';
-  const filePath = path.join(projectRoot, file);
-
-  if (!fs.existsSync(filePath)) return;
-
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const lines = content.split('\n');
-  const filteredLines = lines.filter(line => !line.startsWith(name + '='));
-  fs.writeFileSync(filePath, filteredLines.join('\n'), 'utf-8');
+  type: string;
+  path: string;
 }
 
-// General Settings - Main Branch Configuration
-
-function detectMainBranch(): string {
-  const projectRoot = getProjectRoot();
-  const opts = { encoding: 'utf-8' as const, stdio: ['pipe', 'pipe', 'pipe'] as ['pipe', 'pipe', 'pipe'], cwd: projectRoot || undefined };
-  try {
-    const ref = execSync('git symbolic-ref refs/remotes/origin/HEAD', opts).toString().trim();
-    return ref.replace('refs/remotes/origin/', '');
-  } catch {
-    try {
-      execSync('git rev-parse --verify main', opts);
-      return 'main';
-    } catch {
-      try {
-        execSync('git rev-parse --verify master', opts);
-        return 'master';
-      } catch {
-        return 'main';
-      }
-    }
-  }
-}
-
-export interface MainBranchInfo {
-  branch: string;
-  source: 'configured' | 'detected';
-}
-
-export function getMainBranch(): MainBranchInfo {
-  const config = readConfig();
-  const configured = typeof config.mainBranch === 'string' ? config.mainBranch.trim() : undefined;
-  if (configured) {
-    return { branch: configured, source: 'configured' };
-  }
-  return { branch: detectMainBranch(), source: 'detected' };
-}
-
-export function setMainBranch(branch: string | null): void {
-  const config = readConfig();
-  const trimmed = typeof branch === 'string' ? branch.trim() : branch;
-  if (!trimmed) {
-    delete config.mainBranch;
-  } else {
-    config.mainBranch = trimmed;
-  }
-  writeConfig(config);
-}
-
-// ==================== Usage Tracking ====================
-
-const FREE_WEEKLY_LIMIT = 20;
-
-/**
- * Get the Monday 00:00:00 UTC of the current week.
- * Returns format matching SQLite's CURRENT_TIMESTAMP ("YYYY-MM-DD HH:MM:SS")
- * so lexicographic comparison in WHERE clauses works correctly.
- */
-function getCurrentWeekStart(): string {
-  const now = new Date();
-  const day = now.getUTCDay(); // 0=Sun, 1=Mon, ...
-  const diff = day === 0 ? 6 : day - 1; // days since Monday
-  const monday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - diff));
-  return monday.toISOString().replace('T', ' ').replace('.000Z', '');
+export interface Prototype {
+  id: string;
+  title: string;
+  date: string;
+  month: string;
+  description: string;
+  feature: { id: number; title: string } | null;
+  files: PrototypeFile[];
+  path: string;
 }
 
-export interface WeeklyUsage {
-  used: number;
-  limit: number;
-  remaining: number;
-  allowed: boolean;
+export interface PrototypeSummary {
+  total: number;
+  byMonth: Record<string, number>;
 }
 
-/**
- * Count work items created on the free plan during the current week.
- */
-export function getWeeklyUsage(): WeeklyUsage {
-  const db = getDb();
-  const weekStart = getCurrentWeekStart();
-  const projectRoot = getProjectRoot();
-
-  console.log('[usage] getWeeklyUsage called', { projectRoot, weekStart });
-
-  const row = db.prepare(
-    `SELECT COUNT(*) as count FROM work_items
-     WHERE plan_at_creation = 'free' AND created_at >= ?`
-  ).get(weekStart) as { count: number } | undefined;
-
-  const used = row?.count ?? 0;
-  const remaining = Math.max(0, FREE_WEEKLY_LIMIT - used);
-  const result = { used, limit: FREE_WEEKLY_LIMIT, remaining, allowed: remaining > 0 };
-
-  console.log('[usage] getWeeklyUsage result', { row, result });
-
-  return result;
+export interface PrototypeDashboardData {
+  prototypes: Prototype[];
+  summary: PrototypeSummary;
 }