@critical-path/core 0.2.0 → 0.2.1

package/src/store/index.ts

@@ -4,7 +4,9 @@ export * from './firebase.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
@@ -27,10 +29,26 @@ export interface StorageAdapter {
   updateTask(id: string, updates: Partial<Task>): Promise<Task | null>;
   deleteTask(id: string): Promise<boolean>;
 
-  // Sprints
-  getSprints(projectId: string): Promise<Sprint[]>;
-  createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint>;
-  updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null>;
+  // Teams
+  getTeams(): Promise<Team[]>;
+  getTeam(id: string): Promise<Team | null>;
+  createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team>;
+  updateTeam(id: string, updates: Partial<Team>): Promise<Team | null>;
+  deleteTeam(id: string): Promise<boolean>;
+
+  // Task Containers
+  getContainers(projectId: string): Promise<TaskContainer[]>;
+  getContainer(id: string): Promise<TaskContainer | null>;
+  createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer>;
+  updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null>;
+  deleteContainer(id: string): Promise<boolean>;
+
+  // Iterations
+  getIterations(projectId: string): Promise<Iteration[]>;
+  getIteration(id: string): Promise<Iteration | null>;
+  createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration>;
+  updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null>;
+  deleteIteration(id: string): Promise<boolean>;
 
   // Comments & Activity
   getComments(taskId: string): Promise<Comment[]>;
@@ -54,7 +72,9 @@ export interface StorageAdapter {
 export class InMemoryStore implements StorageAdapter {
   private projects = new Map<string, Project>();
   private tasks = new Map<string, Task>();
-  private sprints = new Map<string, Sprint>();
+  private teams = new Map<string, Team>();
+  private containers = new Map<string, TaskContainer>();
+  private iterations = new Map<string, Iteration>();
   private comments = new Map<string, Comment>();
   private activities: Activity[] = [];
   private timeEntries = new Map<string, TimeEntry>();
@@ -139,29 +159,97 @@ export class InMemoryStore implements StorageAdapter {
     return this.tasks.delete(id);
   }
 
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    return Array.from(this.sprints.values()).filter((s) => s.projectId === projectId);
+  // Teams
+  async getTeams(): Promise<Team[]> {
+    return Array.from(this.teams.values());
   }
 
-  async createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const id = `sprint_${Math.random().toString(36).substring(2, 9)}`;
-    const newSprint: Sprint = {
-      ...sprint,
+  async getTeam(id: string): Promise<Team | null> {
+    return this.teams.get(id) || null;
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const id = `team_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id, createdAt: now, updatedAt: now };
+    this.teams.set(id, newTeam);
+    return newTeam;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    const existing = this.teams.get(id);
+    if (!existing) return null;
+    const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    this.teams.set(id, updated);
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    return this.teams.delete(id);
+  }
+
+  // Containers
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    return Array.from(this.containers.values()).filter((c) => c.projectId === projectId);
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    return this.containers.get(id) || null;
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const id = `cnt_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id, createdAt: now, updatedAt: now };
+    this.containers.set(id, newContainer);
+    return newContainer;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    const existing = this.containers.get(id);
+    if (!existing) return null;
+    const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    this.containers.set(id, updated);
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    return this.containers.delete(id);
+  }
+
+  // Iterations
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    return Array.from(this.iterations.values()).filter((s) => s.projectId === projectId);
+  }
+
+  async getIteration(id: string): Promise<Iteration | null> {
+    return this.iterations.get(id) || null;
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const id = `iter_${Math.random().toString(36).substring(2, 9)}`;
+    const newIteration: Iteration = {
+      ...iteration,
       id,
       createdAt: new Date().toISOString()
     };
-    this.sprints.set(id, newSprint);
-    return newSprint;
+    this.iterations.set(id, newIteration);
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const existing = this.sprints.get(id);
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const existing = this.iterations.get(id);
     if (!existing) return null;
-    const updated: Sprint = { ...existing, ...updates };
-    this.sprints.set(id, updated);
+    const updated: Iteration = { ...existing, ...updates };
+    this.iterations.set(id, updated);
     return updated;
   }
 
+  async deleteIteration(id: string): Promise<boolean> {
+    return this.iterations.delete(id);
+  }
+
+  // Comments
   async getComments(taskId: string): Promise<Comment[]> {
     return Array.from(this.comments.values()).filter((c) => c.taskId === taskId);
   }
@@ -174,6 +262,7 @@ export class InMemoryStore implements StorageAdapter {
     return newComment;
   }
 
+  // Activities
   async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
     return this.activities.filter((a) => {
       if (filter?.projectId && a.projectId !== filter.projectId) return false;
@@ -189,6 +278,7 @@ export class InMemoryStore implements StorageAdapter {
     return newAct;
   }
 
+  // Time Entries
   async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
     return Array.from(this.timeEntries.values()).filter((e) => e.taskId === taskId);
   }
@@ -200,6 +290,7 @@ export class InMemoryStore implements StorageAdapter {
     return newEntry;
   }
 
+  // Dependencies
   async getDependencies(taskId: string): Promise<TaskDependency[]> {
     return Array.from(this.dependencies.values()).filter(
       (d) => d.taskId === taskId || d.dependsOnTaskId === taskId
@@ -213,6 +304,7 @@ export class InMemoryStore implements StorageAdapter {
     return newDep;
   }
 
+  // Webhooks
   async getWebhooks(): Promise<Webhook[]> {
     return Array.from(this.webhooks.values());
   }

package/src/store/sqlite.ts

@@ -3,7 +3,9 @@ import type { StorageAdapter } from './index.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
@@ -44,11 +46,36 @@ export class SQLiteStore implements StorageAdapter {
         description TEXT,
         ownerId TEXT,
         members TEXT,
+        teamIds TEXT,
+        statusDefinitions TEXT,
+        priorityDefinitions TEXT,
         customFieldDefinitions TEXT,
         createdAt TEXT NOT NULL,
         updatedAt TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS teams (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        leaderId TEXT,
+        memberIds TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS containers (
+        id TEXT PRIMARY KEY,
+        projectId TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        parentId TEXT,
+        type TEXT,
+        color TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS tasks (
         id TEXT PRIMARY KEY,
         projectId TEXT NOT NULL,
@@ -58,10 +85,22 @@ export class SQLiteStore implements StorageAdapter {
         priority TEXT NOT NULL,
         assigneeId TEXT,
         reporterId TEXT,
-        sprintId TEXT,
+        reviewerId TEXT,
+        iterationId TEXT,
+        teamId TEXT,
+        containerId TEXT,
+        plannedStartDate TEXT,
+        actualStartDate TEXT,
+        actualEndDate TEXT,
         dueDate TEXT,
         estimatedHours REAL,
         loggedHours REAL,
+        actualHours REAL,
+        billableHours REAL,
+        estimatedDurationMinutes REAL,
+        actualDurationMinutes REAL,
+        billableDurationMinutes REAL,
+        progress REAL,
         tags TEXT,
         customFields TEXT,
         parentId TEXT,
@@ -69,11 +108,12 @@ export class SQLiteStore implements StorageAdapter {
         updatedAt TEXT NOT NULL
       );
 
-      CREATE TABLE IF NOT EXISTS sprints (
+      CREATE TABLE IF NOT EXISTS iterations (
         id TEXT PRIMARY KEY,
         projectId TEXT NOT NULL,
         name TEXT NOT NULL,
         goal TEXT,
+        type TEXT,
         startDate TEXT,
         endDate TEXT,
         status TEXT NOT NULL,
@@ -104,6 +144,7 @@ export class SQLiteStore implements StorageAdapter {
         taskId TEXT NOT NULL,
         userId TEXT NOT NULL,
         hours REAL NOT NULL,
+        isBillable INTEGER,
         description TEXT,
         loggedAt TEXT NOT NULL
       );
@@ -145,8 +186,8 @@ export class SQLiteStore implements StorageAdapter {
     const newProj: Project = { ...project, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO projects (id, key, name, description, ownerId, members, customFieldDefinitions, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newProj.id,
@@ -155,6 +196,9 @@ export class SQLiteStore implements StorageAdapter {
       newProj.description || null,
       newProj.ownerId || null,
       JSON.stringify(newProj.members || []),
+      JSON.stringify(newProj.teamIds || []),
+      JSON.stringify(newProj.statusDefinitions || []),
+      JSON.stringify(newProj.priorityDefinitions || []),
       JSON.stringify(newProj.customFieldDefinitions || []),
       newProj.createdAt,
       newProj.updatedAt
@@ -174,7 +218,7 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE projects
-      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, customFieldDefinitions = ?, updatedAt = ?
+      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
@@ -183,6 +227,9 @@ export class SQLiteStore implements StorageAdapter {
       updated.description || null,
       updated.ownerId || null,
       JSON.stringify(updated.members || []),
+      JSON.stringify(updated.teamIds || []),
+      JSON.stringify(updated.statusDefinitions || []),
+      JSON.stringify(updated.priorityDefinitions || []),
       JSON.stringify(updated.customFieldDefinitions || []),
       updated.updatedAt,
       id
@@ -196,6 +243,129 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
+  // --- Teams ---
+  async getTeams(): Promise<Team[]> {
+    const stmt = this.db.prepare('SELECT * FROM teams');
+    const rows = stmt.all() as any[];
+    return rows.map((r) => this.mapTeam(r));
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    const stmt = this.db.prepare('SELECT * FROM teams WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row ? this.mapTeam(row) : null;
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const id = `team_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO teams (id, name, description, leaderId, memberIds, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newTeam.id,
+      newTeam.name,
+      newTeam.description || null,
+      newTeam.leaderId || null,
+      JSON.stringify(newTeam.memberIds || []),
+      newTeam.createdAt,
+      newTeam.updatedAt
+    );
+    return newTeam;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    const existing = await this.getTeam(id);
+    if (!existing) return null;
+
+    const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    const stmt = this.db.prepare(`
+      UPDATE teams SET name = ?, description = ?, leaderId = ?, memberIds = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      updated.leaderId || null,
+      JSON.stringify(updated.memberIds || []),
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM teams WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
+  // --- Task Containers ---
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    const stmt = this.db.prepare('SELECT * FROM containers WHERE projectId = ?');
+    const rows = stmt.all(projectId) as any[];
+    return rows;
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    const stmt = this.db.prepare('SELECT * FROM containers WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row || null;
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const id = `cnt_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO containers (id, projectId, name, description, parentId, type, color, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newContainer.id,
+      newContainer.projectId,
+      newContainer.name,
+      newContainer.description || null,
+      newContainer.parentId || null,
+      newContainer.type || null,
+      newContainer.color || null,
+      newContainer.createdAt,
+      newContainer.updatedAt
+    );
+    return newContainer;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    const existing = await this.getContainer(id);
+    if (!existing) return null;
+
+    const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    const stmt = this.db.prepare(`
+      UPDATE containers SET name = ?, description = ?, parentId = ?, type = ?, color = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      updated.parentId || null,
+      updated.type || null,
+      updated.color || null,
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM containers WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     let rows: any[];
@@ -223,8 +393,11 @@ export class SQLiteStore implements StorageAdapter {
     const stmt = this.db.prepare(`
       INSERT INTO tasks (
         id, projectId, title, description, status, priority, assigneeId, reporterId,
-        sprintId, dueDate, estimatedHours, loggedHours, tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        reviewerId, iterationId, teamId, containerId, plannedStartDate, actualStartDate, actualEndDate,
+        dueDate, estimatedHours, loggedHours, actualHours, billableHours,
+        estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes, progress,
+        tags, customFields, parentId, createdAt, updatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
@@ -235,10 +408,22 @@ export class SQLiteStore implements StorageAdapter {
       newTask.priority,
       newTask.assigneeId || null,
       newTask.reporterId || null,
-      newTask.sprintId || null,
+      newTask.reviewerId || null,
+      newTask.iterationId || null,
+      newTask.teamId || null,
+      newTask.containerId || null,
+      newTask.plannedStartDate || null,
+      newTask.actualStartDate || null,
+      newTask.actualEndDate || null,
       newTask.dueDate || null,
       newTask.estimatedHours ?? null,
       newTask.loggedHours ?? null,
+      newTask.actualHours ?? null,
+      newTask.billableHours ?? null,
+      newTask.estimatedDurationMinutes ?? null,
+      newTask.actualDurationMinutes ?? null,
+      newTask.billableDurationMinutes ?? null,
+      newTask.progress ?? null,
       JSON.stringify(newTask.tags || []),
       JSON.stringify(newTask.customFields || {}),
       newTask.parentId || null,
@@ -261,8 +446,11 @@ export class SQLiteStore implements StorageAdapter {
     const stmt = this.db.prepare(`
       UPDATE tasks SET
         projectId = ?, title = ?, description = ?, status = ?, priority = ?,
-        assigneeId = ?, reporterId = ?, sprintId = ?, dueDate = ?,
-        estimatedHours = ?, loggedHours = ?, tags = ?, customFields = ?, parentId = ?, updatedAt = ?
+        assigneeId = ?, reporterId = ?, reviewerId = ?, iterationId = ?, teamId = ?, containerId = ?,
+        plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
+        estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
+        estimatedDurationMinutes = ?, actualDurationMinutes = ?, billableDurationMinutes = ?, progress = ?,
+        tags = ?, customFields = ?, parentId = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
@@ -273,10 +461,22 @@ export class SQLiteStore implements StorageAdapter {
       updated.priority,
       updated.assigneeId || null,
       updated.reporterId || null,
-      updated.sprintId || null,
+      updated.reviewerId || null,
+      updated.iterationId || null,
+      updated.teamId || null,
+      updated.containerId || null,
+      updated.plannedStartDate || null,
+      updated.actualStartDate || null,
+      updated.actualEndDate || null,
       updated.dueDate || null,
       updated.estimatedHours ?? null,
       updated.loggedHours ?? null,
+      updated.actualHours ?? null,
+      updated.billableHours ?? null,
+      updated.estimatedDurationMinutes ?? null,
+      updated.actualDurationMinutes ?? null,
+      updated.billableDurationMinutes ?? null,
+      updated.progress ?? null,
       JSON.stringify(updated.tags || []),
       JSON.stringify(updated.customFields || {}),
       updated.parentId || null,
@@ -292,53 +492,56 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
-  // --- Sprints ---
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    const stmt = this.db.prepare('SELECT * FROM sprints WHERE projectId = ?');
+  // --- Iterations ---
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    const stmt = this.db.prepare('SELECT * FROM iterations WHERE projectId = ?');
     const rows = stmt.all(projectId) as any[];
-    return rows.map((r) => ({
-      ...r,
-      description: r.goal
-    }));
+    return rows;
   }
 
-  async createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const id = `sprint_${Math.random().toString(36).substring(2, 9)}`;
+  async getIteration(id: string): Promise<Iteration | null> {
+    const stmt = this.db.prepare('SELECT * FROM iterations WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row || null;
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const id = `iter_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
-    const newSprint: Sprint = { ...sprint, id, createdAt: now };
+    const newIteration: Iteration = { ...iteration, id, createdAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO sprints (id, projectId, name, goal, startDate, endDate, status, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO iterations (id, projectId, name, goal, type, startDate, endDate, status, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
-      newSprint.id,
-      newSprint.projectId,
-      newSprint.name,
-      newSprint.goal || null,
-      newSprint.startDate || null,
-      newSprint.endDate || null,
-      newSprint.status,
-      newSprint.createdAt
+      newIteration.id,
+      newIteration.projectId,
+      newIteration.name,
+      newIteration.goal || null,
+      newIteration.type || null,
+      newIteration.startDate || null,
+      newIteration.endDate || null,
+      newIteration.status,
+      newIteration.createdAt
     );
-    return newSprint;
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const stmt = this.db.prepare('SELECT * FROM sprints WHERE id = ?');
-    const existingRow = stmt.get(id) as any;
-    if (!existingRow) return null;
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const existing = await this.getIteration(id);
+    if (!existing) return null;
 
-    const existing: Sprint = { ...existingRow, goal: existingRow.goal };
-    const updated: Sprint = { ...existing, ...updates };
+    const updated: Iteration = { ...existing, ...updates };
 
     const updateStmt = this.db.prepare(`
-      UPDATE sprints SET name = ?, goal = ?, startDate = ?, endDate = ?, status = ?
+      UPDATE iterations SET name = ?, goal = ?, type = ?, startDate = ?, endDate = ?, status = ?
       WHERE id = ?
     `);
     updateStmt.run(
       updated.name,
       updated.goal || null,
+      updated.type || null,
       updated.startDate || null,
       updated.endDate || null,
       updated.status,
@@ -347,6 +550,12 @@ export class SQLiteStore implements StorageAdapter {
     return updated;
   }
 
+  async deleteIteration(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM iterations WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   // --- Comments & Activity ---
   async getComments(taskId: string): Promise<Comment[]> {
     const stmt = this.db.prepare('SELECT * FROM comments WHERE taskId = ?');
@@ -417,7 +626,8 @@ export class SQLiteStore implements StorageAdapter {
   // --- Time Tracking ---
   async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
     const stmt = this.db.prepare('SELECT * FROM time_entries WHERE taskId = ?');
-    return stmt.all(taskId) as any[];
+    const rows = stmt.all(taskId) as any[];
+    return rows.map((r) => ({ ...r, isBillable: r.isBillable !== null ? Boolean(r.isBillable) : undefined }));
   }
 
   async logTime(entry: Omit<TimeEntry, 'id' | 'loggedAt'>): Promise<TimeEntry> {
@@ -426,10 +636,18 @@ export class SQLiteStore implements StorageAdapter {
     const newEntry: TimeEntry = { ...entry, id, loggedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO time_entries (id, taskId, userId, hours, description, loggedAt)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO time_entries (id, taskId, userId, hours, isBillable, description, loggedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
-    stmt.run(newEntry.id, newEntry.taskId, newEntry.userId, newEntry.hours, newEntry.description || null, newEntry.loggedAt);
+    stmt.run(
+      newEntry.id,
+      newEntry.taskId,
+      newEntry.userId,
+      newEntry.hours,
+      newEntry.isBillable !== undefined ? (newEntry.isBillable ? 1 : 0) : null,
+      newEntry.description || null,
+      newEntry.loggedAt
+    );
     return newEntry;
   }
 
@@ -487,10 +705,20 @@ export class SQLiteStore implements StorageAdapter {
     return {
       ...row,
       members: row.members ? JSON.parse(row.members) : [],
+      teamIds: row.teamIds ? JSON.parse(row.teamIds) : [],
+      statusDefinitions: row.statusDefinitions ? JSON.parse(row.statusDefinitions) : [],
+      priorityDefinitions: row.priorityDefinitions ? JSON.parse(row.priorityDefinitions) : [],
       customFieldDefinitions: row.customFieldDefinitions ? JSON.parse(row.customFieldDefinitions) : []
     };
   }
 
+  private mapTeam(row: any): Team {
+    return {
+      ...row,
+      memberIds: row.memberIds ? JSON.parse(row.memberIds) : []
+    };
+  }
+
   private mapTask(row: any): Task {
     return {
       ...row,