@critical-path/core 0.2.0 → 0.2.1

package/dist/utils/status.js

@@ -0,0 +1,58 @@
+export const DEFAULT_STATUS_DEFINITIONS = {
+    backlog: { key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' },
+    todo: { key: 'todo', label: 'To Do', completionState: 'not_done', executionState: 'inactive' },
+    in_progress: { key: 'in_progress', label: 'In Progress', completionState: 'not_done', executionState: 'active' },
+    in_review: { key: 'in_review', label: 'In Review', completionState: 'not_done', executionState: 'active' },
+    done: { key: 'done', label: 'Done', completionState: 'done', executionState: 'inactive' },
+    canceled: { key: 'canceled', label: 'Canceled', completionState: 'done', executionState: 'inactive', isCancelled: true }
+};
+export function resolveStatusDefinition(statusKey, customDefinitions) {
+    if (customDefinitions) {
+        const found = customDefinitions.find((def) => def.key === statusKey);
+        if (found)
+            return found;
+    }
+    if (DEFAULT_STATUS_DEFINITIONS[statusKey]) {
+        return DEFAULT_STATUS_DEFINITIONS[statusKey];
+    }
+    // Fallback heuristic for unknown custom statuses:
+    const isDoneKey = ['done', 'completed', 'finished', 'closed', 'canceled', 'cancelled'].includes(statusKey.toLowerCase());
+    const isActiveKey = ['in_progress', 'active', 'working', 'in_review', 'review'].includes(statusKey.toLowerCase());
+    return {
+        key: statusKey,
+        label: statusKey,
+        completionState: isDoneKey ? 'done' : 'not_done',
+        executionState: isActiveKey ? 'active' : 'inactive',
+        isCancelled: statusKey.toLowerCase().includes('cancel')
+    };
+}
+export function deriveTaskLifecycleState(task, customDefinitions, referenceDate = new Date()) {
+    const def = resolveStatusDefinition(task.status, customDefinitions);
+    const isDone = def.completionState === 'done';
+    const isActive = def.executionState === 'active';
+    const isCancelled = Boolean(def.isCancelled);
+    let isOverdue = false;
+    if (!isDone && task.dueDate) {
+        const due = new Date(task.dueDate);
+        if (!isNaN(due.getTime()) && due < referenceDate) {
+            isOverdue = true;
+        }
+    }
+    let isUpcoming = false;
+    if (!isDone && !isActive && task.plannedStartDate) {
+        const plannedStart = new Date(task.plannedStartDate);
+        if (!isNaN(plannedStart.getTime()) && plannedStart > referenceDate) {
+            isUpcoming = true;
+        }
+    }
+    return {
+        completionState: def.completionState,
+        executionState: def.executionState,
+        isDone,
+        isActive,
+        isCancelled,
+        isOverdue,
+        isUpcoming
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/utils/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/utils/status.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@critical-path/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Core headless domain engine, plugin architecture, and data stores for Critical Path",
   "author": "Jack James",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pixerate/critical-path.git"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine/index.ts

@@ -1,6 +1,16 @@
-import type { CriticalPathConfig, Project, Task, WebhookEvent } from '../types/index.js';
+import type {
+  CriticalPathConfig,
+  Project,
+  Task,
+  TaskDependencyGraph,
+  Team,
+  TaskContainer,
+  Iteration,
+  WebhookEvent
+} from '../types/index.js';
 import { StorageAdapter, InMemoryStore } from '../store/index.js';
 import { PluginRegistry } from '../plugins/index.js';
+import { deriveTaskLifecycleState, type TaskLifecycleState } from '../utils/status.js';
 
 export class CriticalPathEngine {
   public readonly store: StorageAdapter;
@@ -30,6 +40,21 @@ export class CriticalPathEngine {
         await this.store.createProject(p);
       }
     }
+    if (data.teams) {
+      for (const tm of data.teams) {
+        await this.store.createTeam(tm);
+      }
+    }
+    if (data.containers) {
+      for (const c of data.containers) {
+        await this.store.createContainer(c);
+      }
+    }
+    if (data.iterations) {
+      for (const it of data.iterations) {
+        await this.store.createIteration(it);
+      }
+    }
     if (data.tasks) {
       for (const t of data.tasks) {
         await this.store.createTask(t);
@@ -37,8 +62,7 @@ export class CriticalPathEngine {
     }
   }
 
-  // --- Domain Methods with Plugin Hooks & Audit Logging ---
-
+  // --- Projects ---
   async getProjects(): Promise<Project[]> {
     return this.store.getProjects();
   }
@@ -59,6 +83,7 @@ export class CriticalPathEngine {
     return created;
   }
 
+  // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     return this.store.getTasks(projectId);
   }
@@ -68,7 +93,6 @@ export class CriticalPathEngine {
   }
 
   async createTask(taskInput: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Promise<Task> {
-    // Run plugin beforeTaskCreate hooks
     const processedInput = await this.plugins.runBeforeTaskCreate(taskInput);
 
     const created = await this.store.createTask({
@@ -79,16 +103,27 @@ export class CriticalPathEngine {
       priority: processedInput.priority || taskInput.priority || 'medium',
       assigneeId: processedInput.assigneeId ?? taskInput.assigneeId,
       reporterId: processedInput.reporterId ?? taskInput.reporterId,
-      sprintId: processedInput.sprintId ?? taskInput.sprintId,
+      reviewerId: processedInput.reviewerId ?? taskInput.reviewerId,
+      iterationId: processedInput.iterationId ?? taskInput.iterationId,
+      teamId: processedInput.teamId ?? taskInput.teamId,
+      containerId: processedInput.containerId ?? taskInput.containerId,
+      plannedStartDate: processedInput.plannedStartDate ?? taskInput.plannedStartDate,
+      actualStartDate: processedInput.actualStartDate ?? taskInput.actualStartDate,
+      actualEndDate: processedInput.actualEndDate ?? taskInput.actualEndDate,
       dueDate: processedInput.dueDate ?? taskInput.dueDate,
       estimatedHours: processedInput.estimatedHours ?? taskInput.estimatedHours,
       loggedHours: processedInput.loggedHours ?? taskInput.loggedHours ?? 0,
+      actualHours: processedInput.actualHours ?? taskInput.actualHours,
+      billableHours: processedInput.billableHours ?? taskInput.billableHours,
+      estimatedDurationMinutes: processedInput.estimatedDurationMinutes ?? taskInput.estimatedDurationMinutes,
+      actualDurationMinutes: processedInput.actualDurationMinutes ?? taskInput.actualDurationMinutes,
+      billableDurationMinutes: processedInput.billableDurationMinutes ?? taskInput.billableDurationMinutes,
+      progress: processedInput.progress ?? taskInput.progress ?? 0,
       tags: processedInput.tags ?? taskInput.tags ?? [],
       customFields: processedInput.customFields ?? taskInput.customFields ?? {},
       parentId: processedInput.parentId ?? taskInput.parentId
     });
 
-    // Run plugin afterTaskCreate hooks
     await this.plugins.runAfterTaskCreate(created);
 
     await this.store.logActivity({
@@ -151,18 +186,136 @@ export class CriticalPathEngine {
     return deleted;
   }
 
+  // --- Task Dependencies & Graph ---
+  async getTaskDependencyGraph(taskId: string): Promise<TaskDependencyGraph> {
+    const dependencies = await this.store.getDependencies(taskId);
+    const upstreamTaskIds = new Set<string>();
+    const downstreamTaskIds = new Set<string>();
+
+    for (const dep of dependencies) {
+      if (dep.taskId === taskId) {
+        upstreamTaskIds.add(dep.dependsOnTaskId);
+      } else if (dep.dependsOnTaskId === taskId) {
+        downstreamTaskIds.add(dep.taskId);
+      }
+    }
+
+    const upstreamTasks = (
+      await Promise.all(Array.from(upstreamTaskIds).map((id) => this.store.getTask(id)))
+    ).filter((t): t is Task => t !== null);
+
+    const downstreamTasks = (
+      await Promise.all(Array.from(downstreamTaskIds).map((id) => this.store.getTask(id)))
+    ).filter((t): t is Task => t !== null);
+
+    return {
+      taskId,
+      upstreamTasks,
+      downstreamTasks,
+      dependencies
+    };
+  }
+
+  async getTaskLifecycleState(taskId: string): Promise<TaskLifecycleState | null> {
+    const task = await this.getTask(taskId);
+    if (!task) return null;
+    const project = await this.getProject(task.projectId);
+    return deriveTaskLifecycleState(task, project?.statusDefinitions);
+  }
+
+  // --- Teams ---
+  async getTeams(): Promise<Team[]> {
+    return this.store.getTeams();
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    return this.store.getTeam(id);
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const created = await this.store.createTeam(team);
+    this.dispatchWebhook('team.created', { team: created });
+    return created;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    return this.store.updateTeam(id, updates);
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    return this.store.deleteTeam(id);
+  }
+
+  // --- Containers ---
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    return this.store.getContainers(projectId);
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    return this.store.getContainer(id);
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const created = await this.store.createContainer(container);
+    this.dispatchWebhook('container.created', { container: created });
+    return created;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    return this.store.updateContainer(id, updates);
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    return this.store.deleteContainer(id);
+  }
+
+  // --- Iterations ---
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    return this.store.getIterations(projectId);
+  }
+
+  async getIteration(id: string): Promise<Iteration | null> {
+    return this.store.getIteration(id);
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const created = await this.store.createIteration(iteration);
+    if (created.status === 'active') {
+      this.dispatchWebhook('iteration.started', { iteration: created });
+    }
+    return created;
+  }
+
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const existing = await this.store.getIteration(id);
+    if (!existing) return null;
+
+    const updated = await this.store.updateIteration(id, updates);
+    if (updated) {
+      if (existing.status !== 'active' && updated.status === 'active') {
+        this.dispatchWebhook('iteration.started', { iteration: updated });
+      } else if (existing.status !== 'completed' && updated.status === 'completed') {
+        this.dispatchWebhook('iteration.completed', { iteration: updated });
+      }
+    }
+    return updated;
+  }
+
+  async deleteIteration(id: string): Promise<boolean> {
+    return this.store.deleteIteration(id);
+  }
+
   private async dispatchWebhook(event: WebhookEvent, payload: Record<string, unknown>): Promise<void> {
     const webhooks = await this.store.getWebhooks();
     const active = webhooks.filter((w) => w.active && w.events.includes(event));
 
     for (const wh of active) {
-      // Fire-and-forget webhook post
       fetch(wh.url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ event, timestamp: new Date().toISOString(), data: payload })
       }).catch(() => {
-        // Silent catch for webhook delivery errors in dev
+        // Silent catch for webhook errors in dev
       });
     }
   }

package/src/index.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { CriticalPathEngine } from './engine/index.js';
+import { CriticalPathEngine, deriveTaskLifecycleState } from './index.js';
 import type { CriticalPathPlugin } from './types/index.js';
 
 describe('CriticalPathEngine Core Tests', () => {
@@ -60,4 +60,116 @@ describe('CriticalPathEngine Core Tests', () => {
     expect(hookExecuted).toBe(true);
     expect(task.tags).toContain('auto-tagged');
   });
+
+  it('handles teams, containers, and iterations', async () => {
+    const engine = new CriticalPathEngine();
+
+    const team = await engine.createTeam({
+      name: 'Engineering',
+      memberIds: ['user_1', 'user_2']
+    });
+
+    const proj = await engine.createProject({
+      key: 'ENG',
+      name: 'Engineering Project',
+      teamIds: [team.id]
+    });
+
+    const container = await engine.createContainer({
+      projectId: proj.id,
+      name: 'Core Platform Epic',
+      type: 'epic'
+    });
+
+    const iteration = await engine.createIteration({
+      projectId: proj.id,
+      name: 'Sprint 1',
+      type: 'sprint',
+      status: 'active'
+    });
+
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Setup Database Schema',
+      status: 'in_progress',
+      priority: 'urgent',
+      reviewerId: 'user_2',
+      teamId: team.id,
+      containerId: container.id,
+      iterationId: iteration.id,
+      plannedStartDate: '2026-09-01T00:00:00.000Z',
+      dueDate: '2026-09-15T00:00:00.000Z',
+      estimatedHours: 10,
+      actualHours: 8,
+      billableHours: 8,
+      estimatedDurationMinutes: 600,
+      actualDurationMinutes: 480,
+      billableDurationMinutes: 480,
+      progress: 80
+    });
+
+    expect(task.reviewerId).toBe('user_2');
+    expect(task.teamId).toBe(team.id);
+    expect(task.containerId).toBe(container.id);
+    expect(task.iterationId).toBe(iteration.id);
+    expect(task.estimatedHours).toBe(10);
+    expect(task.actualHours).toBe(8);
+    expect(task.billableHours).toBe(8);
+    expect(task.estimatedDurationMinutes).toBe(600);
+    expect(task.actualDurationMinutes).toBe(480);
+    expect(task.billableDurationMinutes).toBe(480);
+    expect(task.progress).toBe(80);
+  });
+
+  it('evaluates status definitions and task lifecycle state', async () => {
+    const engine = new CriticalPathEngine();
+
+    const proj = await engine.createProject({
+      key: 'CUST',
+      name: 'Custom Workflow Project',
+      statusDefinitions: [
+        { key: 'draft', label: 'Draft', completionState: 'not_done', executionState: 'inactive' },
+        { key: 'active_work', label: 'Active Work', completionState: 'not_done', executionState: 'active' },
+        { key: 'finished', label: 'Finished', completionState: 'done', executionState: 'inactive' }
+      ]
+    });
+
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Workflow Task',
+      status: 'active_work',
+      priority: 'medium',
+      plannedStartDate: '2026-08-01T00:00:00.000Z',
+      dueDate: '2026-08-10T00:00:00.000Z'
+    });
+
+    const state = await engine.getTaskLifecycleState(task.id);
+    expect(state).not.toBeNull();
+    expect(state?.completionState).toBe('not_done');
+    expect(state?.executionState).toBe('active');
+    expect(state?.isActive).toBe(true);
+    expect(state?.isDone).toBe(false);
+  });
+
+  it('builds task dependency graph with upstream and downstream tasks', async () => {
+    const engine = new CriticalPathEngine();
+
+    const proj = await engine.createProject({ key: 'DEP', name: 'Dependency Project' });
+
+    const taskA = await engine.createTask({ projectId: proj.id, title: 'Task A', status: 'todo', priority: 'medium' });
+    const taskB = await engine.createTask({ projectId: proj.id, title: 'Task B', status: 'todo', priority: 'medium' });
+
+    // Task B depends on Task A
+    await engine.store.addDependency({
+      taskId: taskB.id,
+      dependsOnTaskId: taskA.id,
+      type: 'blocking'
+    });
+
+    const graphA = await engine.getTaskDependencyGraph(taskA.id);
+    expect(graphA.downstreamTasks.map((t) => t.id)).toContain(taskB.id);
+
+    const graphB = await engine.getTaskDependencyGraph(taskB.id);
+    expect(graphB.upstreamTasks.map((t) => t.id)).toContain(taskA.id);
+  });
 });

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './types/index.js';
+export * from './utils/status.js';
 export * from './store/index.js';
 export * from './plugins/index.js';
 export * from './engine/index.js';

package/src/store/firebase.test.ts

@@ -1,11 +1,17 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { FirebaseStore } from './firebase.js';
+import { FirebaseStore, InMemoryFirestoreMock } from './firebase.js';
 
 describe('FirebaseStore', () => {
   let store: FirebaseStore;
 
   beforeEach(() => {
-    store = new FirebaseStore();
+    store = new FirebaseStore({ db: new InMemoryFirestoreMock() });
+  });
+
+  it('should throw an error if db is missing in config', () => {
+    expect(() => new FirebaseStore({} as any)).toThrow(
+      'FirebaseStore requires a valid Firestore db instance'
+    );
   });
 
   it('should create and retrieve projects in FirebaseStore', async () => {

package/src/store/firebase.ts

@@ -2,7 +2,9 @@ import type { StorageAdapter } from './index.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
@@ -92,16 +94,21 @@ export class InMemoryFirestoreMock implements FirestoreDBInterface {
 
 export interface FirebaseStoreConfig {
   /**
-   * Firestore instance or mockable DB interface.
+   * Firestore instance or mockable DB interface. Required.
    */
-  db?: FirestoreDBInterface;
+  db: FirestoreDBInterface;
 }
 
 export class FirebaseStore implements StorageAdapter {
   private db: FirestoreDBInterface;
 
-  constructor(config: FirebaseStoreConfig = {}) {
-    this.db = config.db || new InMemoryFirestoreMock();
+  constructor(config: FirebaseStoreConfig) {
+    if (!config?.db) {
+      throw new Error(
+        'FirebaseStore requires a valid Firestore db instance (e.g. FirebaseStoreConfig.db). Automatic fallback to InMemoryFirestoreMock has been removed.'
+      );
+    }
+    this.db = config.db;
   }
 
   // --- Projects ---
@@ -144,6 +151,78 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
+  // --- Teams ---
+  async getTeams(): Promise<Team[]> {
+    const snap = await this.db.collection('teams').get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    const snap = await this.db.collection('teams').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const docRef = this.db.collection('teams').doc();
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newTeam);
+    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() };
+    await this.db.collection('teams').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    const existing = await this.getTeam(id);
+    if (!existing) return false;
+    await this.db.collection('teams').doc(id).delete();
+    return true;
+  }
+
+  // --- Containers ---
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    const snap = await this.db.collection('containers').where('projectId', '==', projectId).get();
+    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    const snap = await this.db.collection('containers').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const docRef = this.db.collection('containers').doc();
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id: docRef.id, createdAt: now, updatedAt: now };
+    await docRef.set(newContainer);
+    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() };
+    await this.db.collection('containers').doc(id).set(updated, { merge: true });
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    const existing = await this.getContainer(id);
+    if (!existing) return false;
+    await this.db.collection('containers').doc(id).delete();
+    return true;
+  }
+
   // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     let snap;
@@ -189,29 +268,42 @@ export class FirebaseStore implements StorageAdapter {
     return true;
   }
 
-  // --- Sprints ---
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    const snap = await this.db.collection('sprints').where('projectId', '==', projectId).get();
+  // --- Iterations ---
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    const snap = await this.db.collection('iterations').where('projectId', '==', projectId).get();
     return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
   }
 
-  async createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const docRef = this.db.collection('sprints').doc();
+  async getIteration(id: string): Promise<Iteration | null> {
+    const snap = await this.db.collection('iterations').doc(id).get();
+    if (!snap.exists) return null;
+    return { ...snap.data(), id: snap.id };
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const docRef = this.db.collection('iterations').doc();
     const now = new Date().toISOString();
-    const newSprint: Sprint = { ...sprint, id: docRef.id, createdAt: now };
-    await docRef.set(newSprint);
-    return newSprint;
+    const newIteration: Iteration = { ...iteration, id: docRef.id, createdAt: now };
+    await docRef.set(newIteration);
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const snap = await this.db.collection('sprints').doc(id).get();
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const snap = await this.db.collection('iterations').doc(id).get();
     if (!snap.exists) return null;
 
-    const updated: Sprint = { ...snap.data(), id, ...updates };
-    await this.db.collection('sprints').doc(id).set(updated, { merge: true });
+    const updated: Iteration = { ...snap.data(), id, ...updates };
+    await this.db.collection('iterations').doc(id).set(updated, { merge: true });
     return updated;
   }
 
+  async deleteIteration(id: string): Promise<boolean> {
+    const existing = await this.getIteration(id);
+    if (!existing) return false;
+    await this.db.collection('iterations').doc(id).delete();
+    return true;
+  }
+
   // --- Comments & Activity ---
   async getComments(taskId: string): Promise<Comment[]> {
     const snap = await this.db.collection('comments').where('taskId', '==', taskId).get();