@critical-path/core 0.19.1 → 0.20.1

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

@@ -0,0 +1,170 @@
+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 { DEFAULT_SOFTWARE_WORKFLOW } from '../utils/workflow.js';
+
+describe('Task Execution Timestamps & Cumulative In-Progress Duration', () => {
+  it('stamps actualStartDate and inProgressSince when moving to in_progress', () => {
+    const task = TaskEntity.create({
+      projectId: 'proj_1',
+      title: 'Implement Task Timestamps',
+      status: 'todo'
+    });
+
+    expect(task.actualStartDate).toBeUndefined();
+    expect(task.actualEndDate).toBeUndefined();
+    expect(task.inProgressSince).toBeUndefined();
+    expect(task.actualDurationSeconds).toBeUndefined();
+
+    task.transitionTo('in_progress', DEFAULT_SOFTWARE_WORKFLOW);
+
+    expect(task.actualStartDate).toBeDefined();
+    expect(task.inProgressSince).toBeDefined();
+    expect(task.actualEndDate).toBeUndefined();
+  });
+
+  it('accumulates in-progress duration across pause/resume cycles and retains earliest actualStartDate', async () => {
+    vi.useFakeTimers();
+    try {
+      const now = new Date('2026-09-23T10:00:00Z');
+      vi.setSystemTime(now);
+
+      const task = TaskEntity.create({
+        projectId: 'proj_1',
+        title: 'Work Tracking',
+        status: 'todo'
+      });
+
+      // 1. Start working at 10:00
+      task.transitionTo('in_progress', DEFAULT_SOFTWARE_WORKFLOW);
+      const initialStartDate = task.actualStartDate;
+      expect(initialStartDate).toBe(now.toISOString());
+      expect(task.inProgressSince).toBe(now.toISOString());
+
+      // Fast-forward 30 minutes (1800s)
+      vi.setSystemTime(new Date('2026-09-23T10:30:00Z'));
+
+      // 2. Pause: move to todo
+      task.transitionTo('todo', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.inProgressSince).toBeNull();
+      expect(task.actualDurationSeconds).toBe(1800);
+      expect(task.actualHours).toBe(0.5);
+      expect(task.actualDurationMinutes).toBe(30);
+      expect(task.actualStartDate).toBe(initialStartDate); // Retains earliest
+
+      // Paused for 1 hour
+      vi.setSystemTime(new Date('2026-09-23T11:30:00Z'));
+
+      // 3. Resume: move back to in_progress
+      task.transitionTo('in_progress', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.actualStartDate).toBe(initialStartDate); // Still retains earliest
+      expect(task.inProgressSince).toBe(new Date('2026-09-23T11:30:00Z').toISOString());
+      expect(task.actualDurationSeconds).toBe(1800); // Unchanged until leaving
+
+      // Fast-forward another 45 minutes (2700s)
+      vi.setSystemTime(new Date('2026-09-23T12:15:00Z'));
+
+      // 4. Complete: move to done
+      task.transitionTo('done', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.inProgressSince).toBeNull();
+      // Total duration = 1800s + 2700s = 4500s = 1.25h
+      expect(task.actualDurationSeconds).toBe(4500);
+      expect(task.actualHours).toBe(1.25);
+      expect(task.actualDurationMinutes).toBe(75);
+      expect(task.actualStartDate).toBe(initialStartDate);
+      expect(task.actualEndDate).toBe(new Date('2026-09-23T12:15:00Z').toISOString());
+      expect(task.progress).toBe(100);
+
+      // 5. Reopen: move from done to todo, then to in_progress
+      vi.setSystemTime(new Date('2026-09-23T14:00:00Z'));
+      task.transitionTo('todo', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.actualEndDate).toBeUndefined(); // Reset upon reopen
+      expect(task.actualStartDate).toBe(initialStartDate); // Retains earliest
+
+      vi.setSystemTime(new Date('2026-09-23T14:15:00Z'));
+      task.transitionTo('in_progress', DEFAULT_SOFTWARE_WORKFLOW);
+      expect(task.actualEndDate).toBeUndefined();
+      expect(task.actualStartDate).toBe(initialStartDate); // Retains earliest
+      expect(task.inProgressSince).toBe(new Date('2026-09-23T14:15:00Z').toISOString());
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('keeps actualDurationSeconds and actualHours synchronized on manual updates', () => {
+    const task = TaskEntity.create({
+      projectId: 'proj_1',
+      title: 'Manual Adjustments',
+      status: 'todo'
+    });
+
+    // Update actualDurationSeconds directly
+    task.update({ actualDurationSeconds: 7200 });
+    expect(task.actualHours).toBe(2);
+    expect(task.actualDurationMinutes).toBe(120);
+
+    // Update actualHours directly
+    task.update({ actualHours: 1.5 });
+    expect(task.actualDurationSeconds).toBe(5400);
+    expect(task.actualDurationMinutes).toBe(90);
+  });
+
+  it('integrates with CriticalPathEngine updateTask and metrics calculation', async () => {
+    vi.useFakeTimers();
+    try {
+      const store = new InMemoryStore();
+      const engine = new CriticalPathEngine({ store });
+
+      const project = await engine.createProject({ name: 'Engine Duration Test' });
+
+      vi.setSystemTime(new Date('2026-09-23T09:00:00Z'));
+      const task = await engine.createTask({
+        projectId: project.id,
+        title: 'Build Feature',
+        estimatedHours: 8
+      });
+
+      // 1. Move to in_progress
+      const started = await engine.updateTask(task.id, { status: 'in_progress' });
+      expect(started?.actualStartDate).toBe('2026-09-23T09:00:00.000Z');
+      expect(started?.inProgressSince).toBe('2026-09-23T09:00:00.000Z');
+      expect(started?.actualEndDate).toBeUndefined();
+
+      // 2. Work for 2 hours (7200s), then move to todo (pause)
+      vi.setSystemTime(new Date('2026-09-23T11:00:00Z'));
+      const paused = await engine.updateTask(task.id, { status: 'todo' });
+      expect(paused?.inProgressSince).toBeNull();
+      expect(paused?.actualDurationSeconds).toBe(7200);
+      expect(paused?.actualHours).toBe(2);
+
+      // 3. Complete task at 14:00 (move from todo to done)
+      vi.setSystemTime(new Date('2026-09-23T14:00:00Z'));
+      const completed = await engine.updateTask(task.id, { status: 'done' });
+      expect(completed?.actualEndDate).toBe('2026-09-23T14:00:00.000Z');
+      // in-progress duration should still be 7200s (since time in todo was paused)
+      expect(completed?.actualDurationSeconds).toBe(7200);
+
+      // 4. Verify metrics calculation
+      const metrics = await engine.getTaskMetrics(task.id);
+      expect(metrics?.inferredActuals.actualDurationSeconds).toBe(7200);
+      expect(metrics?.inferredActuals.activeWorkingHours).toBe(2);
+      // Calendar duration: 09:00 to 14:00 = 5.0 hours
+      expect(metrics?.inferredActuals.calendarDurationHours).toBe(5);
+
+      // 5. Reopen task (done -> todo -> in_progress): actualEndDate must be cleared (undefined)
+      vi.setSystemTime(new Date('2026-09-23T15:00:00Z'));
+      const reopenedTodo = await engine.updateTask(task.id, { status: 'todo' });
+      expect(reopenedTodo?.actualEndDate).toBeUndefined();
+
+      vi.setSystemTime(new Date('2026-09-23T15:30:00Z'));
+      const reopenedProgress = await engine.updateTask(task.id, { status: 'in_progress' });
+      expect(reopenedProgress?.actualEndDate).toBeUndefined();
+      expect(reopenedProgress?.actualStartDate).toBe('2026-09-23T09:00:00.000Z'); // Earliest preserved
+      expect(reopenedProgress?.inProgressSince).toBe('2026-09-23T15:30:00.000Z');
+      expect(reopenedProgress?.actualDurationSeconds).toBe(7200);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/src/engine/index.ts

@@ -371,6 +371,7 @@ export class CriticalPathEngine {
     const statusDef = resolveStatusDefinition(initialStatus, project?.statusDefinitions || workflow?.statuses);
     const semanticStatus = processedInput.semanticStatus ?? taskInput.semanticStatus ?? statusDef.category;
     const actualStartDate = processedInput.actualStartDate ?? taskInput.actualStartDate ?? (statusDef.category === 'in_progress' ? now : undefined);
+    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 created = await this.store.createTask({
@@ -400,7 +401,11 @@ export class CriticalPathEngine {
       estimatedDurationMinutes: processedInput.estimatedDurationMinutes ?? taskInput.estimatedDurationMinutes,
       actualDurationMinutes: processedInput.actualDurationMinutes ?? taskInput.actualDurationMinutes,
       billableDurationMinutes: processedInput.billableDurationMinutes ?? taskInput.billableDurationMinutes,
+      actualDurationSeconds: processedInput.actualDurationSeconds ?? taskInput.actualDurationSeconds,
+      inProgressSince,
       progress: processedInput.progress ?? taskInput.progress ?? (statusDef.category === 'completed' ? 100 : 0),
+      isBlocked: processedInput.isBlocked ?? taskInput.isBlocked ?? false,
+      blockedReason: processedInput.blockedReason ?? taskInput.blockedReason ?? null,
       tags: processedInput.tags ?? taskInput.tags ?? [],
       customFields: processedInput.customFields ?? taskInput.customFields ?? {},
       parentId: processedInput.parentId ?? taskInput.parentId
@@ -515,17 +520,51 @@ export class CriticalPathEngine {
         existing.status,
         project?.statusDefinitions || workflow?.statuses
       );
-      if (
+
+      // 1. Leaving in_progress: finalize active session duration
+      if (existingStatusDef.category === 'in_progress' && statusDef.category !== 'in_progress') {
+        const inProgressSince = existing.inProgressSince;
+        if (inProgressSince) {
+          const startMs = new Date(inProgressSince).getTime();
+          const endMs = new Date(now).getTime();
+          if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+            const sessionSeconds = Math.max(0, (endMs - startMs) / 1000);
+            processedUpdates.actualDurationSeconds =
+              (processedUpdates.actualDurationSeconds ?? existing.actualDurationSeconds ?? 0) + sessionSeconds;
+            if (processedUpdates.actualHours === undefined) {
+              processedUpdates.actualHours = Math.round((processedUpdates.actualDurationSeconds / 3600) * 100) / 100;
+            }
+            if (processedUpdates.actualDurationMinutes === undefined) {
+              processedUpdates.actualDurationMinutes = Math.round(processedUpdates.actualDurationSeconds / 60);
+            }
+          }
+          processedUpdates.inProgressSince = null;
+        }
+      }
+
+      // 2. Entering in_progress: retain earliest start date & start session timer
+      if (statusDef.category === 'in_progress') {
+        if (!existing.actualStartDate && !processedUpdates.actualStartDate) {
+          processedUpdates.actualStartDate = now;
+        }
+        if (!processedUpdates.inProgressSince) {
+          processedUpdates.inProgressSince = now;
+        }
+        if (
+          (existingStatusDef.category === 'completed' || existingStatusDef.category === 'canceled') &&
+          processedUpdates.actualEndDate === undefined
+        ) {
+          processedUpdates.actualEndDate = undefined;
+        }
+      } else if (
         (existingStatusDef.category === 'completed' || existingStatusDef.category === 'canceled') &&
-        (statusDef.category === 'in_progress' || statusDef.category === 'not_started') &&
+        statusDef.category === 'not_started' &&
         processedUpdates.actualEndDate === undefined
       ) {
         processedUpdates.actualEndDate = undefined;
       }
 
-      if (statusDef.category === 'in_progress' && !existing.actualStartDate && !processedUpdates.actualStartDate) {
-        processedUpdates.actualStartDate = now;
-      }
+      // 3. Entering completed or canceled
       if ((statusDef.category === 'completed' || statusDef.category === 'canceled') && !processedUpdates.actualEndDate) {
         processedUpdates.actualEndDate = now;
         if (statusDef.category === 'completed' && processedUpdates.progress === undefined && (existing.progress || 0) < 100) {
@@ -534,6 +573,19 @@ export class CriticalPathEngine {
       }
     }
 
+    // Mutual sync for manual duration/effort edits
+    if (processedUpdates.actualDurationSeconds !== undefined && processedUpdates.actualHours === undefined) {
+      processedUpdates.actualHours = Math.round((processedUpdates.actualDurationSeconds / 3600) * 100) / 100;
+      if (processedUpdates.actualDurationMinutes === undefined) {
+        processedUpdates.actualDurationMinutes = Math.round(processedUpdates.actualDurationSeconds / 60);
+      }
+    } else if (processedUpdates.actualHours !== undefined && processedUpdates.actualDurationSeconds === undefined) {
+      processedUpdates.actualDurationSeconds = Math.round(processedUpdates.actualHours * 3600);
+      if (processedUpdates.actualDurationMinutes === undefined) {
+        processedUpdates.actualDurationMinutes = Math.round(processedUpdates.actualHours * 60);
+      }
+    }
+
     const updated = await this.store.updateTask(id, processedUpdates);
     if (!updated) return null;
 
@@ -586,11 +638,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',
@@ -689,24 +741,11 @@ 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) {
             updates.isBlocked = false;
             updates.blockedReason = null;
           }
 
-          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;

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

@@ -131,6 +131,8 @@ export class SQLiteStore implements StorageAdapter {
         estimatedDurationMinutes REAL,
         actualDurationMinutes REAL,
         billableDurationMinutes REAL,
+        actualDurationSeconds REAL,
+        inProgressSince TEXT,
         progress REAL,
         isBlocked INTEGER,
         blockedReason TEXT,
@@ -660,10 +662,11 @@ export class SQLiteStore implements StorageAdapter {
         id, projectId, title, description, status, priority, taskType, assigneeId, assignees, reporterId,
         reviewerId, iterationId, teamId, containerId, deliverableId, plannedStartDate, actualStartDate, actualEndDate,
         dueDate, estimatedHours, loggedHours, actualHours, billableHours,
-        estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes, progress,
+        estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes,
+        actualDurationSeconds, inProgressSince, progress,
         isBlocked, blockedReason,
         tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
@@ -692,6 +695,8 @@ export class SQLiteStore implements StorageAdapter {
       newTask.estimatedDurationMinutes ?? null,
       newTask.actualDurationMinutes ?? null,
       newTask.billableDurationMinutes ?? null,
+      newTask.actualDurationSeconds ?? null,
+      newTask.inProgressSince ?? null,
       newTask.progress ?? null,
       newTask.isBlocked !== undefined ? (newTask.isBlocked ? 1 : 0) : null,
       newTask.blockedReason ?? null,
@@ -720,7 +725,8 @@ export class SQLiteStore implements StorageAdapter {
         assigneeId = ?, assignees = ?, reporterId = ?, reviewerId = ?, iterationId = ?, teamId = ?, containerId = ?, deliverableId = ?,
         plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
         estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
-        estimatedDurationMinutes = ?, actualDurationMinutes = ?, billableDurationMinutes = ?, progress = ?,
+        estimatedDurationMinutes = ?, actualDurationMinutes = ?, billableDurationMinutes = ?,
+        actualDurationSeconds = ?, inProgressSince = ?, progress = ?,
         isBlocked = ?, blockedReason = ?,
         tags = ?, customFields = ?, parentId = ?, updatedAt = ?
       WHERE id = ?
@@ -751,6 +757,8 @@ export class SQLiteStore implements StorageAdapter {
       updated.estimatedDurationMinutes ?? null,
       updated.actualDurationMinutes ?? null,
       updated.billableDurationMinutes ?? null,
+      updated.actualDurationSeconds ?? null,
+      updated.inProgressSince ?? null,
       updated.progress ?? null,
       updated.isBlocked !== undefined ? (updated.isBlocked ? 1 : 0) : null,
       updated.blockedReason ?? null,

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

@@ -214,6 +214,10 @@ export interface Task {
   estimatedDurationMinutes?: number;
   actualDurationMinutes?: number;
   billableDurationMinutes?: number;
+  /** Cumulative active execution time spent in 'in_progress' status (in seconds) */
+  actualDurationSeconds?: number;
+  /** Transient ISO timestamp marking the start of current 'in_progress' session (null when not in_progress) */
+  inProgressSince?: string | null;
   // Progress (0 to 100 percentage)
   progress?: number;
   isBlocked?: boolean;
@@ -626,6 +630,10 @@ export interface TaskInferredActuals {
   isStartDateInferred: boolean;
   isEndDateInferred: boolean;
   activeWorkingHours?: number;
+  /** Calendar elapsed hours between actualStartDate and actualEndDate */
+  calendarDurationHours?: number;
+  /** Cumulative active execution duration in seconds */
+  actualDurationSeconds?: number;
 }
 
 export interface TaskMetrics {

package/src/utils/status.ts

@@ -88,11 +88,7 @@ export function deriveTaskLifecycleState(
     return upstreamDef.category !== 'completed';
   });
   const blockingTaskIds = blockingTasks.map((t) => t.id);
-  const isExplicitlyBlocked = Boolean(
-    task.isBlocked === true ||
-    task.customFields?.isBlocked === true ||
-    task.status === 'blocked'
-  );
+  const isExplicitlyBlocked = Boolean(task.isBlocked === true);
   const isBlocked = !isDone && (blockingTaskIds.length > 0 || isExplicitlyBlocked);
   const isReady = semanticStatus === 'not_started' && !isBlocked;
 

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/deliverables.test.ts","./src/index.test.ts","./src/index.ts","./src/status.test.ts","./src/task-state.test.ts","./src/use-case-validation.test.ts","./src/domain/calendar.test.ts","./src/domain/calendar.ts","./src/domain/cpm.test.ts","./src/domain/cpm.ts","./src/domain/custom-fields.ts","./src/domain/ddd.test.ts","./src/domain/entities.ts","./src/domain/events.ts","./src/domain/graph.ts","./src/domain/index.ts","./src/domain/ladder.test.ts","./src/domain/ladder.ts","./src/domain/metrics.test.ts","./src/domain/metrics.ts","./src/domain/workload.test.ts","./src/domain/workload.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/storage/file-storage.ts","./src/storage/firebase-storage.ts","./src/storage/index.ts","./src/storage/s3.ts","./src/storage/storage.test.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/mentions.test.ts","./src/utils/mentions.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}
+{"root":["./src/deliverables.test.ts","./src/index.test.ts","./src/index.ts","./src/status.test.ts","./src/task-state.test.ts","./src/use-case-validation.test.ts","./src/domain/calendar.test.ts","./src/domain/calendar.ts","./src/domain/cpm.test.ts","./src/domain/cpm.ts","./src/domain/custom-fields.ts","./src/domain/ddd.test.ts","./src/domain/entities.ts","./src/domain/events.ts","./src/domain/graph.ts","./src/domain/index.ts","./src/domain/ladder.test.ts","./src/domain/ladder.ts","./src/domain/metrics.test.ts","./src/domain/metrics.ts","./src/domain/task-duration.test.ts","./src/domain/workload.test.ts","./src/domain/workload.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/storage/file-storage.ts","./src/storage/firebase-storage.ts","./src/storage/index.ts","./src/storage/s3.ts","./src/storage/storage.test.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/mentions.test.ts","./src/utils/mentions.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}