@critical-path/core 0.14.0 → 0.15.1

package/src/engine/index.ts

@@ -20,15 +20,17 @@ import type {
   CreateProjectInput,
   Deliverable,
   DeliverableSummary,
-  CreateDeliverableInput
+  CreateDeliverableInput,
+  TaskLifecycleState
 } from '../types/index.js';
 import { StorageAdapter, InMemoryStore } from '../store/index.js';
 import { PluginRegistry } from '../plugins/index.js';
-import { deriveTaskLifecycleState, type TaskLifecycleState, resolveStatusDefinition } from '../utils/status.js';
+import { deriveTaskLifecycleState, resolveStatusDefinition } from '../utils/status.js';
 import {
   validateTransition,
   getAllowedNextStatuses,
   getAllowedPreviousStatuses,
+  getAllowedTransitions,
   WorkflowValidationError,
   DEFAULT_SOFTWARE_WORKFLOW
 } from '../utils/workflow.js';
@@ -38,6 +40,7 @@ import {
   TaskCreatedEvent,
   TaskUpdatedEvent,
   TaskStatusChangedEvent,
+  TaskUnblockedEvent,
   TaskDeletedEvent,
   ProjectCreatedEvent,
   ProjectUpdatedEvent,
@@ -234,6 +237,13 @@ export class CriticalPathEngine {
   }
 
   async getAllowedTaskTransitions(taskId: string): Promise<string[]> {
+    const task = await this.store.getTask(taskId);
+    if (!task) return [];
+    const workflow = await this.resolveProjectWorkflow(task.projectId);
+    return getAllowedTransitions(workflow || undefined, task.status);
+  }
+
+  async getAllowedNextTaskTransitions(taskId: string): Promise<string[]> {
     const task = await this.store.getTask(taskId);
     if (!task) return [];
     const workflow = await this.resolveProjectWorkflow(task.projectId);
@@ -335,16 +345,18 @@ export class CriticalPathEngine {
     const initialStatus = processedInput.status || taskInput.status || defaultStatus;
     const now = new Date().toISOString();
 
-    // Derive initial lifecycle timestamps
+    // Derive initial lifecycle timestamps and semantic status
     const statusDef = resolveStatusDefinition(initialStatus, project?.statusDefinitions || workflow?.statuses);
-    const actualStartDate = processedInput.actualStartDate ?? taskInput.actualStartDate ?? (statusDef.executionState === 'active' ? now : undefined);
-    const actualEndDate = processedInput.actualEndDate ?? taskInput.actualEndDate ?? (statusDef.completionState === 'done' ? now : undefined);
+    const semanticStatus = processedInput.semanticStatus ?? taskInput.semanticStatus ?? statusDef.category;
+    const actualStartDate = processedInput.actualStartDate ?? taskInput.actualStartDate ?? (statusDef.category === 'in_progress' ? now : undefined);
+    const actualEndDate = processedInput.actualEndDate ?? taskInput.actualEndDate ?? ((statusDef.category === 'completed' || statusDef.category === 'canceled') ? now : undefined);
 
     const created = await this.store.createTask({
       projectId,
       title: processedInput.title || taskInput.title,
       description: processedInput.description ?? taskInput.description,
       status: initialStatus,
+      semanticStatus,
       priority: processedInput.priority || taskInput.priority || 'medium',
       taskType: processedInput.taskType || taskInput.taskType || 'task',
       assigneeId: processedInput.assigneeId ?? taskInput.assigneeId,
@@ -366,7 +378,7 @@ export class CriticalPathEngine {
       estimatedDurationMinutes: processedInput.estimatedDurationMinutes ?? taskInput.estimatedDurationMinutes,
       actualDurationMinutes: processedInput.actualDurationMinutes ?? taskInput.actualDurationMinutes,
       billableDurationMinutes: processedInput.billableDurationMinutes ?? taskInput.billableDurationMinutes,
-      progress: processedInput.progress ?? taskInput.progress ?? (statusDef.completionState === 'done' ? 100 : 0),
+      progress: processedInput.progress ?? taskInput.progress ?? (statusDef.category === 'completed' ? 100 : 0),
       tags: processedInput.tags ?? taskInput.tags ?? [],
       customFields: processedInput.customFields ?? taskInput.customFields ?? {},
       parentId: processedInput.parentId ?? taskInput.parentId
@@ -428,13 +440,14 @@ export class CriticalPathEngine {
         processedUpdates.status,
         project?.statusDefinitions || workflow?.statuses
       );
+      processedUpdates.semanticStatus = processedUpdates.semanticStatus ?? statusDef.category;
       const now = new Date().toISOString();
-      if (statusDef.executionState === 'active' && !existing.actualStartDate && !processedUpdates.actualStartDate) {
+      if (statusDef.category === 'in_progress' && !existing.actualStartDate && !processedUpdates.actualStartDate) {
         processedUpdates.actualStartDate = now;
       }
-      if (statusDef.completionState === 'done' && !processedUpdates.actualEndDate) {
+      if ((statusDef.category === 'completed' || statusDef.category === 'canceled') && !processedUpdates.actualEndDate) {
         processedUpdates.actualEndDate = now;
-        if (processedUpdates.progress === undefined && (existing.progress || 0) < 100) {
+        if (statusDef.category === 'completed' && processedUpdates.progress === undefined && (existing.progress || 0) < 100) {
           processedUpdates.progress = 100;
         }
       }
@@ -463,6 +476,14 @@ export class CriticalPathEngine {
         }
       };
       await this.events.publish(statusEvent);
+
+      const statusDef = resolveStatusDefinition(
+        updated.status,
+        project?.statusDefinitions || workflow?.statuses
+      );
+      if (statusDef.category === 'completed') {
+        await this.checkAndUnblockDownstreamTasks(updated);
+      }
     } else {
       const updateEvent: TaskUpdatedEvent = {
         id: `evt_${Math.random().toString(36).substring(2, 9)}`,
@@ -494,6 +515,82 @@ export class CriticalPathEngine {
     return updated;
   }
 
+  private async checkAndUnblockDownstreamTasks(completedTask: Task): Promise<void> {
+    try {
+      const graph = await this.getTaskDependencyGraph(completedTask.id);
+      if (!graph.downstreamTasks || graph.downstreamTasks.length === 0) return;
+
+      for (const downstream of graph.downstreamTasks) {
+        const downstreamProject = await this.store.getProject(downstream.projectId);
+        const downstreamWorkflow = await this.resolveProjectWorkflow(downstream.projectId);
+        const downstreamStatusDefs = downstreamProject?.statusDefinitions || downstreamWorkflow?.statuses;
+        const downstreamStatusDef = resolveStatusDefinition(downstream.status, downstreamStatusDefs);
+
+        if (downstreamStatusDef.category === 'completed' || downstreamStatusDef.category === 'canceled') {
+          continue;
+        }
+
+        const downstreamGraph = await this.getTaskDependencyGraph(downstream.id);
+        const allUpstreamsCompleted = downstreamGraph.upstreamTasks.every((up) => {
+          const upDef = resolveStatusDefinition(up.status, downstreamStatusDefs);
+          return upDef.category === 'completed';
+        });
+
+        if (allUpstreamsCompleted) {
+          let updatedDownstream = downstream;
+          const updates: Partial<Task> = {};
+
+          if (downstream.status === 'blocked') {
+            const defaultStatus = downstreamWorkflow?.defaultStatusKey || 'todo';
+            updates.status = defaultStatus;
+          }
+
+          if (downstream.customFields?.isBlocked || downstream.customFields?.blockedReason) {
+            updates.customFields = {
+              ...downstream.customFields,
+              isBlocked: false,
+              blockedReason: null
+            };
+          }
+
+          if (Object.keys(updates).length > 0) {
+            const res = await this.store.updateTask(downstream.id, updates);
+            if (res) updatedDownstream = res;
+          }
+
+          const now = new Date().toISOString();
+          const unblockedEvent: TaskUnblockedEvent = {
+            id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+            name: 'task.unblocked',
+            aggregateId: downstream.id,
+            aggregateType: 'Task',
+            occurredAt: now,
+            payload: {
+              task: updatedDownstream,
+              upstreamTaskId: completedTask.id
+            }
+          };
+          await this.events.publish(unblockedEvent);
+
+          await this.store.logActivity({
+            projectId: downstream.projectId,
+            taskId: downstream.id,
+            actorId: 'system',
+            action: 'task.unblocked',
+            details: { unblockedByTaskId: completedTask.id }
+          });
+
+          this.dispatchWebhook('task.unblocked', {
+            task: updatedDownstream,
+            upstreamTaskId: completedTask.id
+          });
+        }
+      }
+    } catch (err) {
+      console.error(`[CriticalPathEngine] Error during auto-unblocking for task ${completedTask.id}:`, err);
+    }
+  }
+
   async deleteTask(id: string): Promise<boolean> {
     const existing = await this.store.getTask(id);
     if (!existing) return false;
@@ -590,13 +687,25 @@ export class CriticalPathEngine {
     };
   }
 
-  async getTaskLifecycleState(taskId: string): Promise<TaskLifecycleState | null> {
+  async getTaskLifecycleState(
+    taskId: string,
+    options?: { referenceDate?: Date; stalledThresholdDays?: number }
+  ): Promise<TaskLifecycleState | null> {
     const task = await this.getTask(taskId);
     if (!task) return null;
     const project = await this.getProject(task.projectId);
     const workflow = await this.resolveProjectWorkflow(task.projectId);
     const statusDefs = project?.statusDefinitions || workflow?.statuses;
-    return deriveTaskLifecycleState(task, statusDefs);
+
+    const graph = await this.getTaskDependencyGraph(taskId);
+    const upstreamTasks = graph.upstreamTasks;
+
+    return deriveTaskLifecycleState(task, {
+      customDefinitions: statusDefs,
+      referenceDate: options?.referenceDate,
+      stalledThresholdDays: options?.stalledThresholdDays,
+      upstreamTasks
+    });
   }
 
   // --- Time Tracking ---
@@ -1142,9 +1251,9 @@ export class CriticalPathEngine {
 
     for (const task of tasks) {
       const statusDef = resolveStatusDefinition(task.status, project?.statusDefinitions || workflow?.statuses);
-      if (statusDef.completionState === 'done') {
+      if (statusDef.category === 'completed') {
         completedTasks++;
-      } else if (statusDef.executionState === 'active') {
+      } else if (statusDef.category === 'in_progress') {
         activeTasks++;
       }
 
@@ -1154,7 +1263,7 @@ export class CriticalPathEngine {
       if (typeof task.progress === 'number') {
         totalProgress += task.progress;
       } else {
-        totalProgress += statusDef.completionState === 'done' ? 100 : 0;
+        totalProgress += statusDef.category === 'completed' ? 100 : 0;
       }
     }
 

package/src/index.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { CriticalPathEngine, deriveTaskLifecycleState } from './index.js';
+import { CriticalPathEngine, deriveTaskLifecycleState, DEFAULT_VFX_WORKFLOW } from './index.js';
 import type { CriticalPathPlugin } from './types/index.js';
 
 describe('CriticalPathEngine Core Tests', () => {
@@ -128,9 +128,9 @@ describe('CriticalPathEngine Core Tests', () => {
       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' }
+        { key: 'draft', label: 'Draft', category: 'not_started' },
+        { key: 'active_work', label: 'Active Work', category: 'in_progress' },
+        { key: 'finished', label: 'Finished', category: 'completed' }
       ]
     });
 
@@ -145,10 +145,10 @@ describe('CriticalPathEngine Core Tests', () => {
 
     const state = await engine.getTaskLifecycleState(task.id);
     expect(state).not.toBeNull();
-    expect(state?.completionState).toBe('not_done');
-    expect(state?.executionState).toBe('active');
+    expect(state?.semanticStatus).toBe('in_progress');
     expect(state?.isActive).toBe(true);
     expect(state?.isDone).toBe(false);
+    expect(state?.isBlocked).toBe(false);
   });
 
   it('builds task dependency graph with upstream and downstream tasks', async () => {
@@ -181,9 +181,9 @@ describe('CriticalPathEngine Core Tests', () => {
       name: 'Strict Software Workflow',
       defaultStatusKey: 'backlog',
       statuses: [
-        { key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' },
-        { key: 'in_progress', label: 'In Progress', completionState: 'not_done', executionState: 'active' },
-        { key: 'done', label: 'Done', completionState: 'done', executionState: 'inactive' }
+        { key: 'backlog', label: 'Backlog', category: 'not_started' },
+        { key: 'in_progress', label: 'In Progress', category: 'in_progress' },
+        { key: 'done', label: 'Done', category: 'completed' }
       ],
       transitions: [
         { id: 't1', fromStatusKey: 'backlog', toStatusKey: 'in_progress', name: 'Start Work' },
@@ -372,6 +372,74 @@ describe('CriticalPathEngine Core Tests', () => {
     const backlogPrev = await engine.getAllowedPreviousTaskTransitions(backlogTask.id);
     expect(backlogPrev).toEqual([]);
   });
+
+  it('automatically unblocks downstream tasks and publishes task.unblocked event when upstream task completes', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'UNBLK', name: 'Auto-Unblock Project' });
+
+    const upstream = await engine.createTask({
+      projectId: proj.id,
+      title: 'Upstream Task',
+      status: 'in_progress'
+    });
+
+    const downstream = await engine.createTask({
+      projectId: proj.id,
+      title: 'Downstream Task',
+      status: 'blocked',
+      customFields: { isBlocked: true, blockedReason: 'Waiting on upstream' }
+    });
+
+    await engine.addDependency({
+      taskId: downstream.id,
+      dependsOnTaskId: upstream.id,
+      type: 'blocking'
+    });
+
+    const unblockedEvents: any[] = [];
+    engine.events.subscribe('task.unblocked', async (evt) => {
+      unblockedEvents.push(evt);
+    });
+
+    // Complete upstream task
+    const completedUpstream = await engine.updateTask(upstream.id, { status: 'done' });
+    expect(completedUpstream?.status).toBe('done');
+
+    // Downstream task should now be unblocked
+    expect(unblockedEvents).toHaveLength(1);
+    expect(unblockedEvents[0].payload.task.id).toBe(downstream.id);
+    expect(unblockedEvents[0].payload.upstreamTaskId).toBe(upstream.id);
+
+    const refreshedDownstream = await engine.getTask(downstream.id);
+    expect(refreshedDownstream?.status).toBe('todo');
+    expect(refreshedDownstream?.customFields?.isBlocked).toBe(false);
+  });
+
+  it('allows VFX workflow transitions from revision_requested to in_production', async () => {
+    const engine = new CriticalPathEngine();
+    const vfxWorkflow = await engine.createWorkflow(DEFAULT_VFX_WORKFLOW);
+    const proj = await engine.createProject({
+      key: 'VFX',
+      name: 'VFX Film Project',
+      workflowId: vfxWorkflow.id
+    });
+
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Compositing Shot 010',
+      status: 'revision_requested'
+    });
+
+    const allowed = await engine.getAllowedTaskTransitions(task.id);
+    expect(allowed).toContain('in_production');
+    expect(allowed).toContain('internal_review');
+
+    const allowedPrevious = await engine.getAllowedPreviousTaskTransitions(task.id);
+    expect(allowedPrevious).toContain('in_production');
+
+    const updated = await engine.updateTask(task.id, { status: 'in_production' });
+    expect(updated?.status).toBe('in_production');
+  });
 });
 
 

package/src/status.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from 'vitest';
+import { CriticalPathEngine } from './engine/index.js';
+import { resolveStatusDefinition, deriveTaskLifecycleState } from './utils/status.js';
+import type { Task, StatusDefinition } from './types/index.js';
+
+describe('Universal Semantic Statuses & Implied Statuses', () => {
+  describe('resolveStatusDefinition', () => {
+    it('resolves core standard statuses to their semantic category', () => {
+      expect(resolveStatusDefinition('todo').category).toBe('not_started');
+      expect(resolveStatusDefinition('backlog').category).toBe('not_started');
+      expect(resolveStatusDefinition('in_progress').category).toBe('in_progress');
+      expect(resolveStatusDefinition('in_review').category).toBe('in_progress');
+      expect(resolveStatusDefinition('done').category).toBe('completed');
+      expect(resolveStatusDefinition('canceled').category).toBe('canceled');
+    });
+
+    it('resolves custom status definitions when provided', () => {
+      const customDefs: StatusDefinition[] = [
+        { key: 'concept', label: 'Concept & Brainstorming', category: 'not_started' },
+        { key: 'client_review', label: 'Client Feedback Session', category: 'in_progress' },
+        { key: 'shipped', label: 'Shipped to Customer', category: 'completed' },
+        { key: 'abandoned', label: 'Abandoned Initiative', category: 'canceled' }
+      ];
+
+      expect(resolveStatusDefinition('concept', customDefs).category).toBe('not_started');
+      expect(resolveStatusDefinition('client_review', customDefs).category).toBe('in_progress');
+      expect(resolveStatusDefinition('shipped', customDefs).category).toBe('completed');
+      expect(resolveStatusDefinition('abandoned', customDefs).category).toBe('canceled');
+    });
+
+    it('infers category heuristically when unknown status key is provided', () => {
+      expect(resolveStatusDefinition('draft_v2').category).toBe('not_started');
+      expect(resolveStatusDefinition('final_approved').category).toBe('completed');
+      expect(resolveStatusDefinition('active_development').category).toBe('in_progress');
+      expect(resolveStatusDefinition('rejected_proposal').category).toBe('canceled');
+      expect(resolveStatusDefinition('custom_arbitrary_key').category).toBe('not_started');
+    });
+  });
+
+  describe('deriveTaskLifecycleState', () => {
+    const baseTask: Task = {
+      id: 'task_1',
+      projectId: 'proj_1',
+      title: 'Design Wireframes',
+      status: 'todo',
+      priority: 'high',
+      createdAt: '2026-09-01T00:00:00.000Z',
+      updatedAt: '2026-09-01T00:00:00.000Z'
+    };
+
+    it('derives basic state for not_started task', () => {
+      const derived = deriveTaskLifecycleState(baseTask);
+      expect(derived.semanticStatus).toBe('not_started');
+      expect(derived.isActive).toBe(false);
+      expect(derived.isDone).toBe(false);
+      expect(derived.isCancelled).toBe(false);
+      expect(derived.isReady).toBe(true);
+      expect(derived.isBlocked).toBe(false);
+      expect(derived.isUnassigned).toBe(true);
+      expect(derived.isUnplanned).toBe(true);
+    });
+
+    it('derives blocked and ready states based on upstream tasks', () => {
+      const upstream1: Task = {
+        ...baseTask,
+        id: 'task_up1',
+        status: 'in_progress',
+        semanticStatus: 'in_progress'
+      };
+      const upstream2: Task = {
+        ...baseTask,
+        id: 'task_up2',
+        status: 'done',
+        semanticStatus: 'completed'
+      };
+
+      // When upstream1 is in progress, task_1 is blocked
+      const blockedState = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstream1, upstream2]
+      });
+      expect(blockedState.isBlocked).toBe(true);
+      expect(blockedState.isReady).toBe(false);
+      expect(blockedState.blockingTaskIds).toEqual(['task_up1']);
+
+      // When all upstream tasks are completed, task_1 becomes ready
+      const allDoneState = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [
+          { ...upstream1, status: 'done', semanticStatus: 'completed' },
+          upstream2
+        ]
+      });
+      expect(allDoneState.isBlocked).toBe(false);
+      expect(allDoneState.isReady).toBe(true);
+      expect(allDoneState.blockingTaskIds).toHaveLength(0);
+    });
+
+    it('derives schedule indicators: overdue, upcoming, unplanned', () => {
+      const refDate = new Date('2026-09-10T12:00:00.000Z');
+
+      // Overdue task
+      const overdueTask: Task = {
+        ...baseTask,
+        dueDate: '2026-09-08T00:00:00.000Z'
+      };
+      const overdueDerived = deriveTaskLifecycleState(overdueTask, { referenceDate: refDate });
+      expect(overdueDerived.isOverdue).toBe(true);
+      expect(overdueDerived.isUnplanned).toBe(false);
+
+      // Completed task is not overdue even if dueDate is past
+      const completedTask: Task = {
+        ...overdueTask,
+        status: 'done'
+      };
+      const completedDerived = deriveTaskLifecycleState(completedTask, { referenceDate: refDate });
+      expect(completedDerived.isOverdue).toBe(false);
+      expect(completedDerived.isDone).toBe(true);
+
+      // Upcoming task
+      const upcomingTask: Task = {
+        ...baseTask,
+        plannedStartDate: '2026-09-12T00:00:00.000Z' // within 3 days of Sept 10
+      };
+      const upcomingDerived = deriveTaskLifecycleState(upcomingTask, { referenceDate: refDate });
+      expect(upcomingDerived.isUpcoming).toBe(true);
+    });
+
+    it('derives resource indicators: unassigned and stalled', () => {
+      const refDate = new Date('2026-09-15T12:00:00.000Z');
+
+      // Assigned via assigneeId
+      const assignedTask1: Task = {
+        ...baseTask,
+        assigneeId: 'user_alice'
+      };
+      expect(deriveTaskLifecycleState(assignedTask1).isUnassigned).toBe(false);
+
+      // Assigned via assignees array
+      const assignedTask2: Task = {
+        ...baseTask,
+        assignees: [{ id: 'user_bob' }]
+      };
+      expect(deriveTaskLifecycleState(assignedTask2).isUnassigned).toBe(false);
+
+      // Stalled task: in_progress with no update in > 7 days
+      const stalledTask: Task = {
+        ...baseTask,
+        status: 'in_progress',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+      const stalledDerived = deriveTaskLifecycleState(stalledTask, { referenceDate: refDate, stalledThresholdDays: 7 });
+      expect(stalledDerived.isStalled).toBe(true);
+
+      // Not stalled if updated recently
+      const activeTask: Task = {
+        ...stalledTask,
+        updatedAt: '2026-09-14T00:00:00.000Z'
+      };
+      expect(deriveTaskLifecycleState(activeTask, { referenceDate: refDate, stalledThresholdDays: 7 }).isStalled).toBe(false);
+    });
+
+    it('derives estimate indicators: isOverEstimate and isPaceWarning', () => {
+      // Over estimate by logged hours
+      const overEstimateTask: Task = {
+        ...baseTask,
+        status: 'in_progress',
+        estimatedHours: 10,
+        loggedHours: 12
+      };
+      const overEstDerived = deriveTaskLifecycleState(overEstimateTask);
+      expect(overEstDerived.isOverEstimate).toBe(true);
+
+      // Pace warning: in_progress task that has been active longer than estimated duration
+      const refDate = new Date('2026-09-10T00:00:00.000Z');
+      const paceWarningTask: Task = {
+        ...baseTask,
+        status: 'in_progress',
+        actualStartDate: '2026-09-01T00:00:00.000Z', // 9 days = 216 hours elapsed
+        estimatedHours: 40 // only 40 hours estimated
+      };
+      const paceDerived = deriveTaskLifecycleState(paceWarningTask, { referenceDate: refDate });
+      expect(paceDerived.isPaceWarning).toBe(true);
+    });
+  });
+
+  describe('Engine Integration', () => {
+    it('computes full lifecycle state with dependency graph integration', async () => {
+      const engine = new CriticalPathEngine();
+      const proj = await engine.createProject({ key: 'LIFECYCLE', name: 'Lifecycle Test' });
+
+      const taskA = await engine.createTask({
+        projectId: proj.id,
+        title: 'Task A (Dependency)',
+        status: 'todo',
+        priority: 'high'
+      });
+
+      const taskB = await engine.createTask({
+        projectId: proj.id,
+        title: 'Task B (Dependent)',
+        status: 'todo',
+        priority: 'medium'
+      });
+
+      await engine.store.addDependency({
+        taskId: taskB.id,
+        dependsOnTaskId: taskA.id,
+        type: 'blocking'
+      });
+
+      // Task B should be blocked by Task A
+      let stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateB?.isBlocked).toBe(true);
+      expect(stateB?.isReady).toBe(false);
+      expect(stateB?.blockingTaskIds).toEqual([taskA.id]);
+
+      // Complete Task A
+      await engine.updateTask(taskA.id, { status: 'done' });
+
+      // Task B should now be ready
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateB?.isBlocked).toBe(false);
+      expect(stateB?.isReady).toBe(true);
+      expect(stateB?.blockingTaskIds).toEqual([]);
+    });
+  });
+});

package/src/store/firebase.test.ts

@@ -62,7 +62,7 @@ describe('FirebaseStore', () => {
       name: 'Firebase Workflow',
       isDefault: false,
       defaultStatusKey: 'backlog',
-      statuses: [{ key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' }],
+      statuses: [{ key: 'backlog', label: 'Backlog', category: 'not_started' }],
       transitions: []
     });
 
@@ -91,5 +91,21 @@ describe('FirebaseStore', () => {
     expect(doc?.name).toBe('Undefined Test');
     expect('description' in (doc as any)).toBe(false);
   });
+
+  it('should retrieve dependencies when queried as taskId or dependsOnTaskId', async () => {
+    const dep = await store.addDependency({
+      taskId: 'task-downstream',
+      dependsOnTaskId: 'task-upstream',
+      type: 'blocking'
+    });
+
+    const byDownstream = await store.getDependencies('task-downstream');
+    expect(byDownstream).toHaveLength(1);
+    expect(byDownstream[0].id).toBe(dep.id);
+
+    const byUpstream = await store.getDependencies('task-upstream');
+    expect(byUpstream).toHaveLength(1);
+    expect(byUpstream[0].id).toBe(dep.id);
+  });
 });
 

package/src/store/firebase.ts

@@ -546,8 +546,18 @@ export class FirebaseStore implements StorageAdapter {
 
   // --- Dependencies ---
   async getDependencies(taskId: string): Promise<TaskDependency[]> {
-    const snap = await this.db.collection('dependencies').where('taskId', '==', taskId).get();
-    return snap.docs.map((doc) => ({ ...doc.data(), id: doc.id }));
+    const [snap1, snap2] = await Promise.all([
+      this.db.collection('dependencies').where('taskId', '==', taskId).get(),
+      this.db.collection('dependencies').where('dependsOnTaskId', '==', taskId).get()
+    ]);
+    const depMap = new Map<string, TaskDependency>();
+    for (const doc of snap1.docs) {
+      depMap.set(doc.id, { ...doc.data(), id: doc.id } as TaskDependency);
+    }
+    for (const doc of snap2.docs) {
+      depMap.set(doc.id, { ...doc.data(), id: doc.id } as TaskDependency);
+    }
+    return Array.from(depMap.values());
   }
 
   async addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency> {

package/src/store/sqlite.test.ts

@@ -155,7 +155,7 @@ describe('SQLiteStore', () => {
       name: 'SQLite Workflow',
       isDefault: true,
       defaultStatusKey: 'todo',
-      statuses: [{ key: 'todo', label: 'To Do', completionState: 'not_done', executionState: 'inactive' }],
+      statuses: [{ key: 'todo', label: 'To Do', category: 'not_started' }],
       transitions: []
     });