@critical-path/core 0.20.0 → 0.20.2

package/src/domain/entities.ts

@@ -89,7 +89,11 @@ export class TaskEntity extends BaseEntity {
   public billableDurationMinutes?: number;
   public actualDurationSeconds?: number;
   public inProgressSince?: string | null;
+  public blockedDurationSeconds?: number;
+  public blockedSince?: string | null;
   public progress?: number;
+  public isBlocked?: boolean;
+  public blockedReason?: string | null;
   public tags?: string[];
   public todos?: TaskTodoItem[];
   public customFields?: Record<string, unknown>;
@@ -125,7 +129,11 @@ export class TaskEntity extends BaseEntity {
     this.billableDurationMinutes = data.billableDurationMinutes;
     this.actualDurationSeconds = data.actualDurationSeconds;
     this.inProgressSince = data.inProgressSince;
+    this.blockedDurationSeconds = data.blockedDurationSeconds;
+    this.blockedSince = data.blockedSince;
     this.progress = data.progress ?? 0;
+    this.isBlocked = data.isBlocked;
+    this.blockedReason = data.blockedReason;
     this.tags = data.tags ? [...data.tags] : [];
     this.todos = data.todos ? data.todos.map((t) => ({ ...t })) : [];
     this.customFields = data.customFields ? { ...data.customFields } : {};
@@ -149,6 +157,8 @@ export class TaskEntity extends BaseEntity {
     const actualStartDate = input.actualStartDate ?? (semanticStatus === 'in_progress' ? now : undefined);
     const inProgressSince = input.inProgressSince ?? (semanticStatus === 'in_progress' ? now : undefined);
     const actualEndDate = input.actualEndDate ?? ((semanticStatus === 'completed' || semanticStatus === 'canceled') ? now : undefined);
+    const isBlocked = input.isBlocked ?? false;
+    const blockedSince = input.blockedSince ?? (isBlocked && semanticStatus === 'in_progress' ? now : undefined);
 
     const task = new TaskEntity({
       ...input,
@@ -161,6 +171,10 @@ export class TaskEntity extends BaseEntity {
       inProgressSince,
       actualEndDate,
       actualDurationSeconds: input.actualDurationSeconds,
+      blockedDurationSeconds: input.blockedDurationSeconds,
+      blockedSince,
+      isBlocked,
+      blockedReason: input.blockedReason ?? null,
       priority: input.priority || 'medium',
       loggedHours: input.loggedHours ?? 0,
       progress: input.progress ?? 0,
@@ -216,6 +230,15 @@ export class TaskEntity extends BaseEntity {
         }
         this.inProgressSince = null;
       }
+      if (this.blockedSince) {
+        const startMs = new Date(this.blockedSince).getTime();
+        const endMs = new Date(now).getTime();
+        if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+          const blockedSeconds = Math.max(0, (endMs - startMs) / 1000);
+          this.blockedDurationSeconds = (this.blockedDurationSeconds || 0) + blockedSeconds;
+        }
+        this.blockedSince = null;
+      }
     }
 
     // 2. Entering in_progress: retain earliest start date & start session timer
@@ -226,6 +249,9 @@ export class TaskEntity extends BaseEntity {
       if (!this.inProgressSince) {
         this.inProgressSince = now;
       }
+      if (this.isBlocked && !this.blockedSince) {
+        this.blockedSince = now;
+      }
       if (prevStatusDef.category === 'completed' || prevStatusDef.category === 'canceled') {
         this.actualEndDate = undefined;
       }
@@ -394,6 +420,32 @@ export class TaskEntity extends BaseEntity {
       });
     }
 
+    const wasBlocked = Boolean(this.isBlocked);
+    const isNowBlocked = updates.isBlocked !== undefined ? Boolean(updates.isBlocked) : wasBlocked;
+    const now = new Date().toISOString();
+    const effectiveSemantic = updates.semanticStatus ?? this.semanticStatus;
+
+    if (effectiveSemantic === 'in_progress') {
+      if (!wasBlocked && isNowBlocked) {
+        if (!updates.blockedSince) {
+          updates.blockedSince = now;
+        }
+      } else if (wasBlocked && !isNowBlocked) {
+        if (this.blockedSince) {
+          const startMs = new Date(this.blockedSince).getTime();
+          const endMs = new Date(now).getTime();
+          if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+            const sessionSeconds = Math.max(0, (endMs - startMs) / 1000);
+            updates.blockedDurationSeconds =
+              (updates.blockedDurationSeconds ?? this.blockedDurationSeconds ?? 0) + sessionSeconds;
+          }
+          updates.blockedSince = null;
+        }
+      }
+    } else if (!isNowBlocked && this.blockedSince) {
+      updates.blockedSince = null;
+    }
+
     Object.assign(this, updates);
     if (updates.actualDurationSeconds !== undefined && updates.actualHours === undefined) {
       this.actualHours = Math.round((updates.actualDurationSeconds / 3600) * 100) / 100;
@@ -451,7 +503,11 @@ export class TaskEntity extends BaseEntity {
       billableDurationMinutes: this.billableDurationMinutes,
       actualDurationSeconds: this.actualDurationSeconds,
       inProgressSince: this.inProgressSince,
+      blockedDurationSeconds: this.blockedDurationSeconds,
+      blockedSince: this.blockedSince,
       progress: this.progress,
+      isBlocked: this.isBlocked,
+      blockedReason: this.blockedReason,
       tags: this.tags ? [...this.tags] : [],
       todos: this.todos ? this.todos.map((t) => ({ ...t })) : [],
       customFields: this.customFields ? { ...this.customFields } : {},

package/src/domain/metrics.ts

@@ -478,7 +478,8 @@ export function calculateTaskMetrics(
     isEndDateInferred: Boolean(task.actualEndDate && task.semanticStatus === 'completed'),
     activeWorkingHours,
     calendarDurationHours,
-    actualDurationSeconds: task.actualDurationSeconds
+    actualDurationSeconds: task.actualDurationSeconds,
+    blockedDurationSeconds: task.blockedDurationSeconds
   };
 
   const progress = inferTaskProgress(task, options);

package/src/domain/task-duration.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { TaskEntity } from './entities.js';
 import { CriticalPathEngine } from '../engine/index.js';
 import { InMemoryStore } from '../store/index.js';
+import { SQLiteStore } from '../store/sqlite.js';
 import { DEFAULT_SOFTWARE_WORKFLOW } from '../utils/workflow.js';
 
 describe('Task Execution Timestamps & Cumulative In-Progress Duration', () => {
@@ -167,4 +168,151 @@ describe('Task Execution Timestamps & Cumulative In-Progress Duration', () => {
       vi.useRealTimers();
     }
   });
+
+  it('tracks blocked duration while task is in_progress', async () => {
+    vi.useFakeTimers();
+    try {
+      const store = new InMemoryStore();
+      const engine = new CriticalPathEngine({ store });
+
+      const project = await engine.createProject({
+        name: 'Blocked Project'
+      });
+
+      vi.setSystemTime(new Date('2026-09-24T10:00:00Z'));
+      const task = await engine.createTask({
+        projectId: project.id,
+        title: 'Blocked Tracking Feature'
+      });
+
+      // 1. Being blocked in 'todo' does NOT accumulate blocked duration or stamp blockedSince
+      await engine.updateTask(task.id, { isBlocked: true, blockedReason: 'Waiting for spec' });
+      const todoBlocked = await engine.getTask(task.id);
+      expect(todoBlocked?.isBlocked).toBe(true);
+      expect(todoBlocked?.blockedSince).toBeUndefined();
+      expect(todoBlocked?.blockedDurationSeconds).toBeUndefined();
+
+      // 2. Unblock while still in todo
+      await engine.updateTask(task.id, { isBlocked: false, blockedReason: null });
+
+      // 3. Start task at 10:00:00 (in_progress)
+      const started = await engine.updateTask(task.id, { status: 'in_progress' });
+      expect(started?.inProgressSince).toBe('2026-09-24T10:00:00.000Z');
+      expect(started?.blockedSince).toBeUndefined();
+
+      // 4. Block task at 10:00:30 (30 seconds in)
+      vi.setSystemTime(new Date('2026-09-24T10:00:30Z'));
+      const blocked = await engine.updateTask(task.id, { isBlocked: true, blockedReason: 'API down' });
+      expect(blocked?.isBlocked).toBe(true);
+      expect(blocked?.blockedSince).toBe('2026-09-24T10:00:30.000Z');
+
+      // 5. Unblock task at 10:01:00 (30 seconds blocked)
+      vi.setSystemTime(new Date('2026-09-24T10:01:00Z'));
+      const unblocked = await engine.updateTask(task.id, { isBlocked: false, blockedReason: null });
+      expect(unblocked?.isBlocked).toBe(false);
+      expect(unblocked?.blockedSince).toBeNull();
+      expect(unblocked?.blockedDurationSeconds).toBe(30);
+
+      // 6. Block again at 10:01:10
+      vi.setSystemTime(new Date('2026-09-24T10:01:10Z'));
+      const blockedAgain = await engine.updateTask(task.id, { isBlocked: true, blockedReason: 'Review pending' });
+      expect(blockedAgain?.blockedSince).toBe('2026-09-24T10:01:10.000Z');
+
+      // 7. Complete task at 10:01:24 while still blocked (14 seconds blocked)
+      // Total gross in-progress: 84s (1m 24s)
+      // Total blocked duration: 30s + 14s = 44s
+      vi.setSystemTime(new Date('2026-09-24T10:01:24Z'));
+      const completed = await engine.updateTask(task.id, { status: 'done' });
+      expect(completed?.status).toBe('done');
+      expect(completed?.actualDurationSeconds).toBe(84);
+      expect(completed?.blockedDurationSeconds).toBe(44);
+      expect(completed?.blockedSince).toBeNull();
+
+      // 8. Verify metrics
+      const metrics = await engine.getTaskMetrics(task.id);
+      expect(metrics?.inferredActuals.actualDurationSeconds).toBe(84);
+      expect(metrics?.inferredActuals.blockedDurationSeconds).toBe(44);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('persists and retrieves blocked duration fields in SQLiteStore', async () => {
+    const store = new SQLiteStore({ filename: ':memory:' });
+    const project = await store.createProject({ key: 'SQL', name: 'SQLite Project' });
+
+    const task = await store.createTask({
+      projectId: project.id,
+      title: 'SQLite Blocked Task',
+      status: 'in_progress',
+      priority: 'medium',
+      isBlocked: true,
+      blockedReason: 'Third party dependency',
+      blockedSince: '2026-09-24T12:00:00.000Z',
+      blockedDurationSeconds: 120
+    });
+
+    const retrieved = await store.getTask(task.id);
+    expect(retrieved?.isBlocked).toBe(true);
+    expect(retrieved?.blockedReason).toBe('Third party dependency');
+    expect(retrieved?.blockedSince).toBe('2026-09-24T12:00:00.000Z');
+    expect(retrieved?.blockedDurationSeconds).toBe(120);
+
+    const updated = await store.updateTask(task.id, {
+      isBlocked: false,
+      blockedReason: null,
+      blockedSince: null,
+      blockedDurationSeconds: 180
+    });
+    expect(updated?.isBlocked).toBe(false);
+    expect(updated?.blockedReason).toBeFalsy();
+    expect(updated?.blockedSince).toBeFalsy();
+    expect(updated?.blockedDurationSeconds).toBe(180);
+
+    const reloaded = await store.getTask(task.id);
+    expect(reloaded?.isBlocked).toBe(false);
+    expect(reloaded?.blockedReason).toBeUndefined();
+    expect(reloaded?.blockedSince).toBeUndefined();
+    expect(reloaded?.blockedDurationSeconds).toBe(180);
+  });
+
+  it('manages blocked state directly on TaskEntity transitions and updates', () => {
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(new Date('2026-09-24T12:00:00Z'));
+      const task = TaskEntity.create({
+        projectId: 'proj_blk',
+        title: 'Entity Blocked Test',
+        status: 'in_progress'
+      });
+
+      // Block while in progress
+      vi.setSystemTime(new Date('2026-09-24T12:00:30Z'));
+      task.update({ isBlocked: true, blockedReason: 'Database migration' });
+      expect(task.isBlocked).toBe(true);
+      expect(task.blockedSince).toBe('2026-09-24T12:00:30.000Z');
+
+      // Unblock while in progress
+      vi.setSystemTime(new Date('2026-09-24T12:01:00Z'));
+      task.update({ isBlocked: false, blockedReason: null });
+      expect(task.isBlocked).toBe(false);
+      expect(task.blockedSince).toBeNull();
+      expect(task.blockedDurationSeconds).toBe(30);
+
+      // Block again
+      vi.setSystemTime(new Date('2026-09-24T12:01:10Z'));
+      task.update({ isBlocked: true, blockedReason: 'Code review' });
+      expect(task.blockedSince).toBe('2026-09-24T12:01:10.000Z');
+
+      // Transition to completed (done) while blocked
+      vi.setSystemTime(new Date('2026-09-24T12:01:30Z'));
+      task.transitionTo('done', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.status).toBe('done');
+      expect(task.actualDurationSeconds).toBe(90);
+      expect(task.blockedDurationSeconds).toBe(50); // 30s + 20s
+      expect(task.blockedSince).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });

package/src/engine/index.ts

@@ -374,6 +374,10 @@ export class CriticalPathEngine {
     const inProgressSince = processedInput.inProgressSince ?? taskInput.inProgressSince ?? (statusDef.category === 'in_progress' ? now : undefined);
     const actualEndDate = processedInput.actualEndDate ?? taskInput.actualEndDate ?? ((statusDef.category === 'completed' || statusDef.category === 'canceled') ? now : undefined);
 
+    const isInitialBlocked = processedInput.isBlocked ?? taskInput.isBlocked ?? false;
+    const blockedSince = processedInput.blockedSince ?? taskInput.blockedSince ?? (isInitialBlocked && statusDef.category === 'in_progress' ? now : undefined);
+    const blockedDurationSeconds = processedInput.blockedDurationSeconds ?? taskInput.blockedDurationSeconds;
+
     const created = await this.store.createTask({
       projectId,
       title: processedInput.title || taskInput.title,
@@ -403,7 +407,11 @@ export class CriticalPathEngine {
       billableDurationMinutes: processedInput.billableDurationMinutes ?? taskInput.billableDurationMinutes,
       actualDurationSeconds: processedInput.actualDurationSeconds ?? taskInput.actualDurationSeconds,
       inProgressSince,
+      blockedDurationSeconds,
+      blockedSince,
       progress: processedInput.progress ?? taskInput.progress ?? (statusDef.category === 'completed' ? 100 : 0),
+      isBlocked: isInitialBlocked,
+      blockedReason: processedInput.blockedReason ?? taskInput.blockedReason ?? null,
       tags: processedInput.tags ?? taskInput.tags ?? [],
       customFields: processedInput.customFields ?? taskInput.customFields ?? {},
       parentId: processedInput.parentId ?? taskInput.parentId
@@ -505,22 +513,25 @@ export class CriticalPathEngine {
 
     const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, taskUpdates);
 
-    // Auto-update execution/completion timestamps if status changes
-    if (processedUpdates.status && processedUpdates.status !== existing.status) {
-      const statusDef = resolveStatusDefinition(
-        processedUpdates.status,
-        project?.statusDefinitions || workflow?.statuses
-      );
-      processedUpdates.semanticStatus = processedUpdates.semanticStatus ?? statusDef.category;
-      const now = new Date().toISOString();
+    const now = new Date().toISOString();
+    const existingStatusDef = resolveStatusDefinition(
+      existing.status,
+      project?.statusDefinitions || workflow?.statuses
+    );
+    const newStatusDef = processedUpdates.status
+      ? resolveStatusDefinition(
+          processedUpdates.status,
+          project?.statusDefinitions || workflow?.statuses
+        )
+      : undefined;
+    const effectiveCategory = newStatusDef?.category ?? existingStatusDef.category;
 
-      const existingStatusDef = resolveStatusDefinition(
-        existing.status,
-        project?.statusDefinitions || workflow?.statuses
-      );
+    // Auto-update execution/completion timestamps if status changes
+    if (processedUpdates.status && processedUpdates.status !== existing.status && newStatusDef) {
+      processedUpdates.semanticStatus = processedUpdates.semanticStatus ?? newStatusDef.category;
 
-      // 1. Leaving in_progress: finalize active session duration
-      if (existingStatusDef.category === 'in_progress' && statusDef.category !== 'in_progress') {
+      // 1. Leaving in_progress: finalize active session duration and blocked duration
+      if (existingStatusDef.category === 'in_progress' && newStatusDef.category !== 'in_progress') {
         const inProgressSince = existing.inProgressSince;
         if (inProgressSince) {
           const startMs = new Date(inProgressSince).getTime();
@@ -538,16 +549,34 @@ export class CriticalPathEngine {
           }
           processedUpdates.inProgressSince = null;
         }
+
+        const blockedSince = processedUpdates.blockedSince ?? existing.blockedSince;
+        if (blockedSince) {
+          const startMs = new Date(blockedSince).getTime();
+          const endMs = new Date(now).getTime();
+          if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+            const sessionSeconds = Math.max(0, (endMs - startMs) / 1000);
+            processedUpdates.blockedDurationSeconds =
+              (processedUpdates.blockedDurationSeconds ?? existing.blockedDurationSeconds ?? 0) + sessionSeconds;
+          }
+          processedUpdates.blockedSince = null;
+        }
       }
 
-      // 2. Entering in_progress: retain earliest start date & start session timer
-      if (statusDef.category === 'in_progress') {
+      // 2. Entering in_progress: retain earliest start date & start session timer (and blocked timer if blocked)
+      if (newStatusDef.category === 'in_progress') {
         if (!existing.actualStartDate && !processedUpdates.actualStartDate) {
           processedUpdates.actualStartDate = now;
         }
         if (!processedUpdates.inProgressSince) {
           processedUpdates.inProgressSince = now;
         }
+        const isTaskBlocked = processedUpdates.isBlocked !== undefined
+          ? Boolean(processedUpdates.isBlocked)
+          : Boolean(existing.isBlocked);
+        if (isTaskBlocked && !processedUpdates.blockedSince) {
+          processedUpdates.blockedSince = now;
+        }
         if (
           (existingStatusDef.category === 'completed' || existingStatusDef.category === 'canceled') &&
           processedUpdates.actualEndDate === undefined
@@ -556,21 +585,49 @@ export class CriticalPathEngine {
         }
       } else if (
         (existingStatusDef.category === 'completed' || existingStatusDef.category === 'canceled') &&
-        statusDef.category === 'not_started' &&
+        newStatusDef.category === 'not_started' &&
         processedUpdates.actualEndDate === undefined
       ) {
         processedUpdates.actualEndDate = undefined;
       }
 
       // 3. Entering completed or canceled
-      if ((statusDef.category === 'completed' || statusDef.category === 'canceled') && !processedUpdates.actualEndDate) {
+      if ((newStatusDef.category === 'completed' || newStatusDef.category === 'canceled') && !processedUpdates.actualEndDate) {
         processedUpdates.actualEndDate = now;
-        if (statusDef.category === 'completed' && processedUpdates.progress === undefined && (existing.progress || 0) < 100) {
+        if (newStatusDef.category === 'completed' && processedUpdates.progress === undefined && (existing.progress || 0) < 100) {
           processedUpdates.progress = 100;
         }
       }
     }
 
+    // Handle isBlocked transitions while in_progress (when in_progress, whether status changed or not)
+    if (effectiveCategory === 'in_progress') {
+      const wasBlocked = Boolean(existing.isBlocked);
+      const isNowBlocked = processedUpdates.isBlocked !== undefined
+        ? Boolean(processedUpdates.isBlocked)
+        : wasBlocked;
+
+      if (!wasBlocked && isNowBlocked) {
+        if (!processedUpdates.blockedSince) {
+          processedUpdates.blockedSince = now;
+        }
+      } else if (wasBlocked && !isNowBlocked) {
+        const blockedSince = existing.blockedSince ?? processedUpdates.blockedSince;
+        if (blockedSince) {
+          const startMs = new Date(blockedSince).getTime();
+          const endMs = new Date(now).getTime();
+          if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+            const sessionSeconds = Math.max(0, (endMs - startMs) / 1000);
+            processedUpdates.blockedDurationSeconds =
+              (processedUpdates.blockedDurationSeconds ?? existing.blockedDurationSeconds ?? 0) + sessionSeconds;
+          }
+          processedUpdates.blockedSince = null;
+        }
+      }
+    } else if (processedUpdates.isBlocked === false && (existing.blockedSince || processedUpdates.blockedSince)) {
+      processedUpdates.blockedSince = null;
+    }
+
     // Mutual sync for manual duration/effort edits
     if (processedUpdates.actualDurationSeconds !== undefined && processedUpdates.actualHours === undefined) {
       processedUpdates.actualHours = Math.round((processedUpdates.actualDurationSeconds / 3600) * 100) / 100;
@@ -589,7 +646,6 @@ export class CriticalPathEngine {
 
     await this.plugins.runAfterTaskUpdate(updated, existing);
 
-    const now = new Date().toISOString();
     const isStatusChange = existing.status !== updated.status;
 
     // Publish typed Domain Events
@@ -636,11 +692,11 @@ export class CriticalPathEngine {
       await this.events.publish(updateEvent);
     }
 
-    const wasBlocked = Boolean(existing.isBlocked || existing.customFields?.isBlocked || existing.status === 'blocked');
-    const isNowBlocked = Boolean(updated.isBlocked || updated.customFields?.isBlocked || updated.status === 'blocked');
+    const wasBlocked = Boolean(existing.isBlocked);
+    const isNowBlocked = Boolean(updated.isBlocked);
 
     if (!wasBlocked && isNowBlocked) {
-      const blockedReason = updated.blockedReason ?? (updated.customFields?.blockedReason as string | undefined) ?? null;
+      const blockedReason = updated.blockedReason ?? null;
       const blockedEvent: TaskBlockedEvent = {
         id: `evt_${Math.random().toString(36).substring(2, 9)}`,
         name: 'task.blocked',
@@ -739,22 +795,18 @@ export class CriticalPathEngine {
           let updatedDownstream = downstream;
           const updates: Partial<Task> = {};
 
-          if (downstream.status === 'blocked') {
-            const defaultStatus = downstreamWorkflow?.defaultStatusKey || 'todo';
-            updates.status = defaultStatus;
-          }
-
-          if (downstream.isBlocked || downstream.blockedReason) {
+          if (downstream.isBlocked || downstream.blockedReason || downstream.blockedSince) {
             updates.isBlocked = false;
             updates.blockedReason = null;
-          }
-
-          if (downstream.customFields?.isBlocked || downstream.customFields?.blockedReason) {
-            updates.customFields = {
-              ...downstream.customFields,
-              isBlocked: false,
-              blockedReason: null
-            };
+            if (downstream.blockedSince) {
+              const startMs = new Date(downstream.blockedSince).getTime();
+              const endMs = new Date().getTime();
+              if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+                const blockedSeconds = Math.max(0, (endMs - startMs) / 1000);
+                updates.blockedDurationSeconds = (downstream.blockedDurationSeconds ?? 0) + blockedSeconds;
+              }
+              updates.blockedSince = null;
+            }
           }
 
           if (Object.keys(updates).length > 0) {

package/src/index.test.ts

@@ -386,8 +386,9 @@ describe('CriticalPathEngine Core Tests', () => {
     const downstream = await engine.createTask({
       projectId: proj.id,
       title: 'Downstream Task',
-      status: 'blocked',
-      customFields: { isBlocked: true, blockedReason: 'Waiting on upstream' }
+      status: 'todo',
+      isBlocked: true,
+      blockedReason: 'Waiting on upstream'
     });
 
     await engine.addDependency({
@@ -412,7 +413,7 @@ describe('CriticalPathEngine Core Tests', () => {
 
     const refreshedDownstream = await engine.getTask(downstream.id);
     expect(refreshedDownstream?.status).toBe('todo');
-    expect(refreshedDownstream?.customFields?.isBlocked).toBe(false);
+    expect(refreshedDownstream?.isBlocked).toBe(false);
   });
 
   it('allows VFX workflow transitions from revision_requested to in_production', async () => {

package/src/store/sqlite.ts

@@ -133,6 +133,8 @@ export class SQLiteStore implements StorageAdapter {
         billableDurationMinutes REAL,
         actualDurationSeconds REAL,
         inProgressSince TEXT,
+        blockedDurationSeconds REAL,
+        blockedSince TEXT,
         progress REAL,
         isBlocked INTEGER,
         blockedReason TEXT,
@@ -663,18 +665,18 @@ export class SQLiteStore implements StorageAdapter {
         reviewerId, iterationId, teamId, containerId, deliverableId, plannedStartDate, actualStartDate, actualEndDate,
         dueDate, estimatedHours, loggedHours, actualHours, billableHours,
         estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes,
-        actualDurationSeconds, inProgressSince, progress,
+        actualDurationSeconds, inProgressSince, blockedDurationSeconds, blockedSince, progress,
         isBlocked, blockedReason,
         tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
       newTask.projectId,
       newTask.title,
       newTask.description || null,
-      newTask.status,
-      newTask.priority,
+      newTask.status || 'todo',
+      newTask.priority || 'medium',
       newTask.taskType || null,
       newTask.assigneeId || null,
       newTask.assignees ? JSON.stringify(newTask.assignees) : null,
@@ -697,6 +699,8 @@ export class SQLiteStore implements StorageAdapter {
       newTask.billableDurationMinutes ?? null,
       newTask.actualDurationSeconds ?? null,
       newTask.inProgressSince ?? null,
+      newTask.blockedDurationSeconds ?? null,
+      newTask.blockedSince ?? null,
       newTask.progress ?? null,
       newTask.isBlocked !== undefined ? (newTask.isBlocked ? 1 : 0) : null,
       newTask.blockedReason ?? null,
@@ -726,7 +730,7 @@ export class SQLiteStore implements StorageAdapter {
         plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
         estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
         estimatedDurationMinutes = ?, actualDurationMinutes = ?, billableDurationMinutes = ?,
-        actualDurationSeconds = ?, inProgressSince = ?, progress = ?,
+        actualDurationSeconds = ?, inProgressSince = ?, blockedDurationSeconds = ?, blockedSince = ?, progress = ?,
         isBlocked = ?, blockedReason = ?,
         tags = ?, customFields = ?, parentId = ?, updatedAt = ?
       WHERE id = ?
@@ -759,6 +763,8 @@ export class SQLiteStore implements StorageAdapter {
       updated.billableDurationMinutes ?? null,
       updated.actualDurationSeconds ?? null,
       updated.inProgressSince ?? null,
+      updated.blockedDurationSeconds ?? null,
+      updated.blockedSince ?? null,
       updated.progress ?? null,
       updated.isBlocked !== undefined ? (updated.isBlocked ? 1 : 0) : null,
       updated.blockedReason ?? null,
@@ -1204,6 +1210,10 @@ export class SQLiteStore implements StorageAdapter {
   private mapTask(row: any): Task {
     return {
       ...row,
+      actualDurationSeconds: row.actualDurationSeconds ?? undefined,
+      inProgressSince: row.inProgressSince || undefined,
+      blockedDurationSeconds: row.blockedDurationSeconds ?? undefined,
+      blockedSince: row.blockedSince || undefined,
       isBlocked: row.isBlocked !== null && row.isBlocked !== undefined ? Boolean(row.isBlocked) : undefined,
       blockedReason: row.blockedReason || undefined,
       taskType: row.taskType || undefined,

package/src/task-state.test.ts

@@ -353,12 +353,13 @@ describe('Task State Behaviour & Dependency Validation', () => {
         status: 'todo'
       });
 
-      // Create downstream task with status: 'blocked' and customFields.isBlocked = true
+      // Create downstream task with isBlocked = true
       const taskDownstream = await engine.createTask({
         projectId: project.id,
         title: 'Run Integration Tests',
-        status: 'blocked',
-        customFields: { isBlocked: true, blockedReason: 'Waiting on compilation' }
+        status: 'todo',
+        isBlocked: true,
+        blockedReason: 'Waiting on compilation'
       });
 
       await engine.addDependency({
@@ -382,11 +383,11 @@ describe('Task State Behaviour & Dependency Validation', () => {
       expect(unblockedEvents[0].aggregateId).toBe(taskDownstream.id);
       expect(unblockedEvents[0].payload.upstreamTaskId).toBe(taskUpstream.id);
 
-      // Verify downstream task was automatically transitioned from 'blocked' to 'todo'
+      // Verify downstream task is unblocked
       const updatedDownstream = await engine.getTask(taskDownstream.id);
       expect(updatedDownstream?.status).toBe('todo');
-      expect(updatedDownstream?.customFields?.isBlocked).toBe(false);
-      expect(updatedDownstream?.customFields?.blockedReason).toBeNull();
+      expect(updatedDownstream?.isBlocked).toBe(false);
+      expect(updatedDownstream?.blockedReason).toBeNull();
 
       // Verify lifecycle state is ready and unblocked
       const lifecycle = await engine.getTaskLifecycleState(taskDownstream.id);
@@ -404,8 +405,8 @@ describe('Task State Behaviour & Dependency Validation', () => {
       const downstream = await engine.createTask({
         projectId: project.id,
         title: 'Final Assembly',
-        status: 'blocked',
-        customFields: { isBlocked: true }
+        status: 'todo',
+        isBlocked: true
       });
 
       await engine.addDependency({ taskId: downstream.id, dependsOnTaskId: up1.id, type: 'blocking' });
@@ -423,8 +424,7 @@ describe('Task State Behaviour & Dependency Validation', () => {
       expect(unblockedEvents).toHaveLength(0);
 
       let taskState = await engine.getTask(downstream.id);
-      expect(taskState?.status).toBe('blocked');
-      expect(taskState?.customFields?.isBlocked).toBe(true);
+      expect(taskState?.isBlocked).toBe(true);
 
       let lifecycle = await engine.getTaskLifecycleState(downstream.id);
       expect(lifecycle?.isBlocked).toBe(true);
@@ -437,7 +437,7 @@ describe('Task State Behaviour & Dependency Validation', () => {
       expect(unblockedEvents).toHaveLength(1);
       taskState = await engine.getTask(downstream.id);
       expect(taskState?.status).toBe('todo');
-      expect(taskState?.customFields?.isBlocked).toBe(false);
+      expect(taskState?.isBlocked).toBe(false);
 
       lifecycle = await engine.getTaskLifecycleState(downstream.id);
       expect(lifecycle?.isBlocked).toBe(false);

package/src/types/index.ts

@@ -218,6 +218,10 @@ export interface Task {
   actualDurationSeconds?: number;
   /** Transient ISO timestamp marking the start of current 'in_progress' session (null when not in_progress) */
   inProgressSince?: string | null;
+  /** Cumulative duration spent in blocked state while in progress (in seconds) */
+  blockedDurationSeconds?: number;
+  /** Transient ISO timestamp marking when the task became blocked while in progress (null when not blocked or not in_progress) */
+  blockedSince?: string | null;
   // Progress (0 to 100 percentage)
   progress?: number;
   isBlocked?: boolean;
@@ -634,6 +638,8 @@ export interface TaskInferredActuals {
   calendarDurationHours?: number;
   /** Cumulative active execution duration in seconds */
   actualDurationSeconds?: number;
+  /** Cumulative duration spent in blocked state while in progress (in seconds) */
+  blockedDurationSeconds?: number;
 }
 
 export interface TaskMetrics {