@critical-path/core 0.19.0 → 0.20.0

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,6 +401,8 @@ 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),
       tags: processedInput.tags ?? taskInput.tags ?? [],
       customFields: processedInput.customFields ?? taskInput.customFields ?? {},
@@ -431,30 +434,76 @@ export class CriticalPathEngine {
     return created;
   }
 
-  async updateTask(id: string, updates: Partial<Task>): Promise<Task | null> {
+  async updateTask(
+    id: string,
+    updates: Partial<Task> & {
+      actorId?: string;
+      actorName?: string;
+      actorType?: string;
+      actor?: { userId: string; username?: string; actorType?: string };
+    },
+    options?: {
+      actorId?: string;
+      actorName?: string;
+      actorType?: string;
+      actor?: { userId: string; username?: string; actorType?: string };
+    }
+  ): Promise<Task | null> {
     const existing = await this.store.getTask(id);
     if (!existing) return null;
 
+    const actorId =
+      options?.actorId ||
+      updates.actorId ||
+      options?.actor?.userId ||
+      updates.actor?.userId ||
+      'system';
+    const actorName =
+      options?.actorName ||
+      updates.actorName ||
+      options?.actor?.username ||
+      updates.actor?.username ||
+      (actorId === 'system' ? 'System' : undefined);
+    const actorType =
+      options?.actorType ||
+      updates.actorType ||
+      options?.actor?.actorType ||
+      updates.actor?.actorType ||
+      (actorId === 'system' ? 'system' : 'user');
+    const actorObj = options?.actor || updates.actor || {
+      userId: actorId,
+      username: actorName,
+      actorType
+    };
+
+    const {
+      actorId: _aId,
+      actorName: _aName,
+      actorType: _aType,
+      actor: _aObj,
+      ...taskUpdates
+    } = updates;
+
     const project = await this.store.getProject(existing.projectId);
     const workflow = await this.resolveProjectWorkflow(existing.projectId);
 
     // Validate workflow transition invariant
-    if (updates.status && updates.status !== existing.status) {
-      const isValid = validateTransition(workflow || undefined, existing.status, updates.status);
+    if (taskUpdates.status && taskUpdates.status !== existing.status) {
+      const isValid = validateTransition(workflow || undefined, existing.status, taskUpdates.status);
       if (!isValid) {
-        throw new WorkflowValidationError(existing.status, updates.status, workflow?.id);
+        throw new WorkflowValidationError(existing.status, taskUpdates.status, workflow?.id);
       }
     }
 
     // Validate custom field invariants
-    if (project?.customFieldDefinitions && updates.customFields) {
+    if (project?.customFieldDefinitions && taskUpdates.customFields) {
       validateCustomFieldValues(project.customFieldDefinitions, {
         ...existing.customFields,
-        ...updates.customFields
+        ...taskUpdates.customFields
       });
     }
 
-    const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, updates);
+    const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, taskUpdates);
 
     // Auto-update execution/completion timestamps if status changes
     if (processedUpdates.status && processedUpdates.status !== existing.status) {
@@ -469,17 +518,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) {
@@ -488,6 +571,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;
 
@@ -507,7 +603,10 @@ export class CriticalPathEngine {
         payload: {
           task: updated,
           previousStatus: existing.status,
-          newStatus: updated.status
+          newStatus: updated.status,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       await this.events.publish(statusEvent);
@@ -528,7 +627,10 @@ export class CriticalPathEngine {
         occurredAt: now,
         payload: {
           task: updated,
-          previous: existing
+          previous: existing,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       await this.events.publish(updateEvent);
@@ -547,16 +649,19 @@ export class CriticalPathEngine {
         occurredAt: now,
         payload: {
           task: updated,
-          reason: blockedReason
+          reason: blockedReason,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       await this.events.publish(blockedEvent);
       await this.store.logActivity({
         projectId: updated.projectId,
         taskId: updated.id,
-        actorId: updated.assigneeId || 'system',
+        actorId,
         action: 'task.blocked',
-        details: { reason: blockedReason }
+        details: { reason: blockedReason, ...(actorName ? { actorName } : {}) }
       });
       this.dispatchWebhook('task.blocked', {
         task: updated,
@@ -570,16 +675,19 @@ export class CriticalPathEngine {
         aggregateType: 'Task',
         occurredAt: now,
         payload: {
-          task: updated
+          task: updated,
+          actorId,
+          ...(actorName ? { actorName } : {}),
+          actor: actorObj
         }
       };
       await this.events.publish(unblockedEvent);
       await this.store.logActivity({
         projectId: updated.projectId,
         taskId: updated.id,
-        actorId: updated.assigneeId || 'system',
+        actorId,
         action: 'task.unblocked',
-        details: {}
+        details: { ...(actorName ? { actorName } : {}) }
       });
       this.dispatchWebhook('task.unblocked', {
         task: updated
@@ -589,9 +697,13 @@ export class CriticalPathEngine {
     await this.store.logActivity({
       projectId: updated.projectId,
       taskId: updated.id,
-      actorId: updated.assigneeId || 'system',
+      actorId,
       action: isStatusChange ? 'task.status_changed' : 'task.updated',
-      details: { fromStatus: existing.status, toStatus: updated.status }
+      details: {
+        fromStatus: existing.status,
+        toStatus: updated.status,
+        ...(actorName ? { actorName } : {})
+      }
     });
 
     this.dispatchWebhook(isStatusChange ? 'task.status_changed' : 'task.updated', {

package/src/index.test.ts

@@ -440,6 +440,54 @@ describe('CriticalPathEngine Core Tests', () => {
     const updated = await engine.updateTask(task.id, { status: 'in_production' });
     expect(updated?.status).toBe('in_production');
   });
+
+  it('attributes activities and domain events to the real actor rather than the assignee', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'ACT', name: 'Actor Attribution Project' });
+    const task = await engine.createTask({
+      projectId: proj.id,
+      title: 'Assigned Task',
+      status: 'todo',
+      assigneeId: 'agent_worker_1'
+    });
+
+    const receivedEvents: any[] = [];
+    engine.events.subscribe('task.status_changed', async (evt) => {
+      receivedEvents.push(evt);
+    });
+    engine.events.subscribe('task.updated', async (evt) => {
+      receivedEvents.push(evt);
+    });
+
+    // Update with explicit actor (e.g. human user updating an assigned agent task)
+    await engine.updateTask(task.id, {
+      status: 'in_progress',
+      actorId: 'user_human_42',
+      actorName: 'Jack James'
+    });
+
+    const activities = await engine.store.getActivities({ taskId: task.id });
+    const statusActivity = activities.find((a) => a.action === 'task.status_changed');
+    expect(statusActivity).toBeDefined();
+    expect(statusActivity?.actorId).toBe('user_human_42');
+    expect((statusActivity?.details as any)?.actorName).toBe('Jack James');
+    expect(statusActivity?.actorId).not.toBe('agent_worker_1');
+
+    expect(receivedEvents).toHaveLength(1);
+    expect(receivedEvents[0].payload.actorId).toBe('user_human_42');
+    expect(receivedEvents[0].payload.actorName).toBe('Jack James');
+
+    // Update without explicit actor - should fall back to 'system', NEVER task.assigneeId
+    await engine.updateTask(task.id, {
+      title: 'Updated title'
+    });
+
+    const updatedActivities = await engine.store.getActivities({ taskId: task.id });
+    const updateActivity = updatedActivities.find((a) => a.action === 'task.updated');
+    expect(updateActivity).toBeDefined();
+    expect(updateActivity?.actorId).toBe('system');
+    expect(updateActivity?.actorId).not.toBe('agent_worker_1');
+  });
 });
 
 

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/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/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"}