@critical-path/core 0.15.0 → 0.15.2

package/src/task-state.test.ts

@@ -0,0 +1,447 @@
+import { describe, it, expect, vi } from 'vitest';
+import { CriticalPathEngine } from './engine/index.js';
+import { deriveTaskLifecycleState } from './utils/status.js';
+import type { Task, StatusDefinition, TaskUnblockedEvent } from './index.js';
+
+describe('Task State Behaviour & Dependency Validation', () => {
+  const baseTask: Task = {
+    id: 'task_target',
+    projectId: 'proj_1',
+    title: 'Implement Authentication UI',
+    status: 'todo',
+    priority: 'high',
+    createdAt: '2026-09-01T00:00:00.000Z',
+    updatedAt: '2026-09-01T00:00:00.000Z'
+  };
+
+  describe('deriveTaskLifecycleState (Pure Function)', () => {
+    it('marks a task as blocked when an upstream dependency is not complete', () => {
+      const upstreamIncomplete: Task = {
+        id: 'task_upstream',
+        projectId: 'proj_1',
+        title: 'Backend Auth API',
+        status: 'in_progress',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+
+      const state = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstreamIncomplete]
+      });
+
+      expect(state.isBlocked).toBe(true);
+      expect(state.isReady).toBe(false);
+      expect(state.blockingTaskIds).toEqual(['task_upstream']);
+    });
+
+    it('marks a task as unblocked and ready when an upstream dependency is complete (vice versa)', () => {
+      const upstreamComplete: Task = {
+        id: 'task_upstream',
+        projectId: 'proj_1',
+        title: 'Backend Auth API',
+        status: 'done',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-02T00:00:00.000Z'
+      };
+
+      const state = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstreamComplete]
+      });
+
+      expect(state.isBlocked).toBe(false);
+      expect(state.isReady).toBe(true);
+      expect(state.blockingTaskIds).toHaveLength(0);
+    });
+
+    it('marks a task as blocked again if upstream dependency transitions from complete back to incomplete', () => {
+      const upstreamTask: Task = {
+        id: 'task_upstream',
+        projectId: 'proj_1',
+        title: 'Backend Auth API',
+        status: 'done',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-02T00:00:00.000Z'
+      };
+
+      // Initially complete: target is ready
+      const initial = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstreamTask]
+      });
+      expect(initial.isBlocked).toBe(false);
+      expect(initial.isReady).toBe(true);
+
+      // Upstream reopened to in_progress
+      const reopenedUpstream: Task = {
+        ...upstreamTask,
+        status: 'in_progress',
+        updatedAt: '2026-09-03T00:00:00.000Z'
+      };
+
+      const afterReopen = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [reopenedUpstream]
+      });
+      expect(afterReopen.isBlocked).toBe(true);
+      expect(afterReopen.isReady).toBe(false);
+      expect(afterReopen.blockingTaskIds).toEqual(['task_upstream']);
+    });
+
+    it('handles multiple upstream dependencies (fan-in): blocked until ALL are complete', () => {
+      const upstreamA: Task = {
+        id: 'up_a',
+        projectId: 'proj_1',
+        title: 'API Endpoints',
+        status: 'done',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+      const upstreamB: Task = {
+        id: 'up_b',
+        projectId: 'proj_1',
+        title: 'Database Schema Migration',
+        status: 'todo',
+        priority: 'urgent',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+
+      // 1. One done, one todo -> still blocked
+      const partialState = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstreamA, upstreamB]
+      });
+      expect(partialState.isBlocked).toBe(true);
+      expect(partialState.isReady).toBe(false);
+      expect(partialState.blockingTaskIds).toEqual(['up_b']);
+
+      // 2. Both done -> now unblocked and ready
+      const allCompleteState = deriveTaskLifecycleState(baseTask, {
+        upstreamTasks: [upstreamA, { ...upstreamB, status: 'done' }]
+      });
+      expect(allCompleteState.isBlocked).toBe(false);
+      expect(allCompleteState.isReady).toBe(true);
+      expect(allCompleteState.blockingTaskIds).toHaveLength(0);
+    });
+
+    it('does not mark a completed or canceled task as blocked even if upstream is incomplete', () => {
+      const upstreamIncomplete: Task = {
+        id: 'task_upstream',
+        projectId: 'proj_1',
+        title: 'Database Setup',
+        status: 'todo',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+
+      // Target task is already done
+      const completedTask: Task = {
+        ...baseTask,
+        status: 'done'
+      };
+      const doneState = deriveTaskLifecycleState(completedTask, {
+        upstreamTasks: [upstreamIncomplete]
+      });
+      expect(doneState.isDone).toBe(true);
+      expect(doneState.isBlocked).toBe(false);
+
+      // Target task was canceled
+      const canceledTask: Task = {
+        ...baseTask,
+        status: 'canceled'
+      };
+      const canceledState = deriveTaskLifecycleState(canceledTask, {
+        upstreamTasks: [upstreamIncomplete]
+      });
+      expect(canceledState.isCancelled).toBe(true);
+      expect(canceledState.isBlocked).toBe(false);
+    });
+
+    it('correctly uses custom status definitions to determine blocking completion', () => {
+      const customDefinitions: StatusDefinition[] = [
+        { key: 'backlog', label: 'Backlog', category: 'not_started' },
+        { key: 'qa_review', label: 'QA Review', category: 'in_progress' },
+        { key: 'shipped_prod', label: 'Shipped to Production', category: 'completed' },
+        { key: 'abandoned', label: 'Abandoned', category: 'canceled' }
+      ];
+
+      const upstreamInQa: Task = {
+        id: 'up_qa',
+        projectId: 'proj_1',
+        title: 'Core Engine Feature',
+        status: 'qa_review',
+        priority: 'high',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        updatedAt: '2026-09-01T00:00:00.000Z'
+      };
+
+      // qa_review is categorized as in_progress -> blocks target
+      const blockedState = deriveTaskLifecycleState(baseTask, {
+        customDefinitions,
+        upstreamTasks: [upstreamInQa]
+      });
+      expect(blockedState.isBlocked).toBe(true);
+      expect(blockedState.blockingTaskIds).toEqual(['up_qa']);
+
+      // shipped_prod is categorized as completed -> unblocks target
+      const unblockedState = deriveTaskLifecycleState(baseTask, {
+        customDefinitions,
+        upstreamTasks: [{ ...upstreamInQa, status: 'shipped_prod' }]
+      });
+      expect(unblockedState.isBlocked).toBe(false);
+      expect(unblockedState.isReady).toBe(true);
+    });
+  });
+
+  describe('CriticalPathEngine Lifecycle & Dependency Integration', () => {
+    it('validates upstream blocking behavior and directional asymmetry', async () => {
+      const engine = new CriticalPathEngine();
+      const project = await engine.createProject({ key: 'ST', name: 'State Test Project' });
+
+      // Task A: Upstream
+      const taskA = await engine.createTask({
+        projectId: project.id,
+        title: 'Task A (Upstream)',
+        status: 'todo',
+        priority: 'high'
+      });
+
+      // Task B: Downstream dependent
+      const taskB = await engine.createTask({
+        projectId: project.id,
+        title: 'Task B (Downstream)',
+        status: 'todo',
+        priority: 'medium'
+      });
+
+      // Before dependency: both are ready, neither is blocked
+      let stateA = await engine.getTaskLifecycleState(taskA.id);
+      let stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateA?.isBlocked).toBe(false);
+      expect(stateA?.isReady).toBe(true);
+      expect(stateB?.isBlocked).toBe(false);
+      expect(stateB?.isReady).toBe(true);
+
+      // Add blocking dependency: B depends on A
+      await engine.addDependency({
+        taskId: taskB.id,
+        dependsOnTaskId: taskA.id,
+        type: 'blocking'
+      });
+
+      // Verify B is blocked by A, but A is NOT blocked by B (directional check)
+      stateA = await engine.getTaskLifecycleState(taskA.id);
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+
+      expect(stateA?.isBlocked).toBe(false);
+      expect(stateA?.isReady).toBe(true);
+      expect(stateA?.blockingTaskIds).toHaveLength(0);
+
+      expect(stateB?.isBlocked).toBe(true);
+      expect(stateB?.isReady).toBe(false);
+      expect(stateB?.blockingTaskIds).toEqual([taskA.id]);
+
+      // Complete Upstream Task A -> Task B is unblocked
+      await engine.updateTask(taskA.id, { status: 'done' });
+
+      stateA = await engine.getTaskLifecycleState(taskA.id);
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+
+      expect(stateA?.isDone).toBe(true);
+      expect(stateB?.isBlocked).toBe(false);
+      expect(stateB?.isReady).toBe(true);
+      expect(stateB?.blockingTaskIds).toHaveLength(0);
+
+      // Reopen Task A from done back to todo -> Task B becomes blocked again
+      await engine.updateTask(taskA.id, { status: 'todo' });
+
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateB?.isBlocked).toBe(true);
+      expect(stateB?.isReady).toBe(false);
+      expect(stateB?.blockingTaskIds).toEqual([taskA.id]);
+    });
+
+    it('unblocks task when blocking upstream task is deleted', async () => {
+      const engine = new CriticalPathEngine();
+      const project = await engine.createProject({ key: 'DEL', name: 'Delete Dep Project' });
+
+      const taskA = await engine.createTask({ projectId: project.id, title: 'Task A', status: 'todo' });
+      const taskB = await engine.createTask({ projectId: project.id, title: 'Task B', status: 'todo' });
+
+      await engine.addDependency({
+        taskId: taskB.id,
+        dependsOnTaskId: taskA.id,
+        type: 'blocking'
+      });
+
+      let stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateB?.isBlocked).toBe(true);
+
+      // Delete upstream task
+      await engine.deleteTask(taskA.id);
+
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+      expect(stateB?.isBlocked).toBe(false);
+      expect(stateB?.isReady).toBe(true);
+      expect(stateB?.blockingTaskIds).toHaveLength(0);
+    });
+
+    it('validates multi-level transitive dependency chain (A -> B -> C)', async () => {
+      const engine = new CriticalPathEngine();
+      const project = await engine.createProject({ key: 'CHAIN', name: 'Chain Project' });
+
+      const taskA = await engine.createTask({ projectId: project.id, title: 'Step 1: DB Schema', status: 'todo' });
+      const taskB = await engine.createTask({ projectId: project.id, title: 'Step 2: API Endpoints', status: 'todo' });
+      const taskC = await engine.createTask({ projectId: project.id, title: 'Step 3: Frontend View', status: 'todo' });
+
+      // B depends on A
+      await engine.addDependency({
+        taskId: taskB.id,
+        dependsOnTaskId: taskA.id,
+        type: 'blocking'
+      });
+
+      // C depends on B
+      await engine.addDependency({
+        taskId: taskC.id,
+        dependsOnTaskId: taskB.id,
+        type: 'blocking'
+      });
+
+      // Initial state: A is ready; B is blocked by A; C is blocked by B
+      let stateA = await engine.getTaskLifecycleState(taskA.id);
+      let stateB = await engine.getTaskLifecycleState(taskB.id);
+      let stateC = await engine.getTaskLifecycleState(taskC.id);
+
+      expect(stateA?.isReady).toBe(true);
+      expect(stateB?.isBlocked).toBe(true);
+      expect(stateB?.blockingTaskIds).toEqual([taskA.id]);
+      expect(stateC?.isBlocked).toBe(true);
+      expect(stateC?.blockingTaskIds).toEqual([taskB.id]);
+
+      // Complete A: B becomes ready; C is STILL blocked by B
+      await engine.updateTask(taskA.id, { status: 'done' });
+
+      stateB = await engine.getTaskLifecycleState(taskB.id);
+      stateC = await engine.getTaskLifecycleState(taskC.id);
+
+      expect(stateB?.isBlocked).toBe(false);
+      expect(stateB?.isReady).toBe(true);
+
+      expect(stateC?.isBlocked).toBe(true);
+      expect(stateC?.isReady).toBe(false);
+      expect(stateC?.blockingTaskIds).toEqual([taskB.id]);
+
+      // Complete B: C is finally unblocked and ready
+      await engine.updateTask(taskB.id, { status: 'done' });
+
+      stateC = await engine.getTaskLifecycleState(taskC.id);
+      expect(stateC?.isBlocked).toBe(false);
+      expect(stateC?.isReady).toBe(true);
+      expect(stateC?.blockingTaskIds).toHaveLength(0);
+    });
+
+    it('emits task.unblocked domain event and auto-transitions status from blocked to todo when dependencies complete', async () => {
+      const engine = new CriticalPathEngine();
+      const project = await engine.createProject({ key: 'UNBLK', name: 'Auto Unblock Project' });
+
+      const taskUpstream = await engine.createTask({
+        projectId: project.id,
+        title: 'Compile Library',
+        status: 'todo'
+      });
+
+      // Create downstream task with status: 'blocked' and customFields.isBlocked = true
+      const taskDownstream = await engine.createTask({
+        projectId: project.id,
+        title: 'Run Integration Tests',
+        status: 'blocked',
+        customFields: { isBlocked: true, blockedReason: 'Waiting on compilation' }
+      });
+
+      await engine.addDependency({
+        taskId: taskDownstream.id,
+        dependsOnTaskId: taskUpstream.id,
+        type: 'blocking'
+      });
+
+      // Subscribe to domain event
+      const unblockedEvents: TaskUnblockedEvent[] = [];
+      engine.events.subscribe<TaskUnblockedEvent>('task.unblocked', (event) => {
+        unblockedEvents.push(event);
+      });
+
+      // Complete upstream task
+      await engine.updateTask(taskUpstream.id, { status: 'done' });
+
+      // Verify domain event was published
+      expect(unblockedEvents).toHaveLength(1);
+      expect(unblockedEvents[0].name).toBe('task.unblocked');
+      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'
+      const updatedDownstream = await engine.getTask(taskDownstream.id);
+      expect(updatedDownstream?.status).toBe('todo');
+      expect(updatedDownstream?.customFields?.isBlocked).toBe(false);
+      expect(updatedDownstream?.customFields?.blockedReason).toBeNull();
+
+      // Verify lifecycle state is ready and unblocked
+      const lifecycle = await engine.getTaskLifecycleState(taskDownstream.id);
+      expect(lifecycle?.isBlocked).toBe(false);
+      expect(lifecycle?.isReady).toBe(true);
+    });
+
+    it('does not auto-unblock downstream task if other upstream dependencies remain incomplete', async () => {
+      const engine = new CriticalPathEngine();
+      const project = await engine.createProject({ key: 'FANIN', name: 'Fan In Project' });
+
+      const up1 = await engine.createTask({ projectId: project.id, title: 'Dependency 1', status: 'todo' });
+      const up2 = await engine.createTask({ projectId: project.id, title: 'Dependency 2', status: 'todo' });
+
+      const downstream = await engine.createTask({
+        projectId: project.id,
+        title: 'Final Assembly',
+        status: 'blocked',
+        customFields: { isBlocked: true }
+      });
+
+      await engine.addDependency({ taskId: downstream.id, dependsOnTaskId: up1.id, type: 'blocking' });
+      await engine.addDependency({ taskId: downstream.id, dependsOnTaskId: up2.id, type: 'blocking' });
+
+      const unblockedEvents: TaskUnblockedEvent[] = [];
+      engine.events.subscribe<TaskUnblockedEvent>('task.unblocked', (evt) => {
+        unblockedEvents.push(evt);
+      });
+
+      // Complete up1 only
+      await engine.updateTask(up1.id, { status: 'done' });
+
+      // Downstream should NOT be unblocked because up2 is still incomplete
+      expect(unblockedEvents).toHaveLength(0);
+
+      let taskState = await engine.getTask(downstream.id);
+      expect(taskState?.status).toBe('blocked');
+      expect(taskState?.customFields?.isBlocked).toBe(true);
+
+      let lifecycle = await engine.getTaskLifecycleState(downstream.id);
+      expect(lifecycle?.isBlocked).toBe(true);
+      expect(lifecycle?.blockingTaskIds).toEqual([up2.id]);
+
+      // Complete up2
+      await engine.updateTask(up2.id, { status: 'done' });
+
+      // Now it should be unblocked
+      expect(unblockedEvents).toHaveLength(1);
+      taskState = await engine.getTask(downstream.id);
+      expect(taskState?.status).toBe('todo');
+      expect(taskState?.customFields?.isBlocked).toBe(false);
+
+      lifecycle = await engine.getTaskLifecycleState(downstream.id);
+      expect(lifecycle?.isBlocked).toBe(false);
+      expect(lifecycle?.isReady).toBe(true);
+    });
+  });
+});

package/src/types/index.ts

@@ -369,6 +369,7 @@ export type WebhookEvent =
   | 'task.updated'
   | 'task.deleted'
   | 'task.status_changed'
+  | 'task.unblocked'
   | 'comment.created'
   | 'comment.updated'
   | 'comment.deleted'

package/src/utils/workflow.ts

@@ -101,14 +101,27 @@ export const DEFAULT_VFX_WORKFLOW: Workflow = {
   ],
   transitions: [
     { name: 'Award Bid', fromStatusKey: 'bidding', toStatusKey: 'awarded' },
+    { name: 'Start Directly from Bid', fromStatusKey: 'bidding', toStatusKey: 'in_production' },
     { name: 'Start Work', fromStatusKey: 'awarded', toStatusKey: 'in_production' },
+    { name: 'Reopen Bid', fromStatusKey: 'awarded', toStatusKey: 'bidding' },
     { name: 'Submit to Lead Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
+    { name: 'Fast-Track Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
+    { name: 'Direct Approval', fromStatusKey: 'in_production', toStatusKey: 'approved' },
     { name: 'Submit to Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
     { name: 'Request Internal Revisions', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
+    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
     { name: 'Request Client Revisions', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
-    { name: 'Address Revisions', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Return to Lead Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
     { name: 'Approve Final Shot', fromStatusKey: 'client_review', toStatusKey: 'approved' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' }
+    { name: 'Address Revisions in Production', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
+    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
+    { name: 'Reopen Shot', fromStatusKey: 'approved', toStatusKey: 'in_production' },
+    { name: 'Reopen Lead Review', fromStatusKey: 'approved', toStatusKey: 'internal_review' },
+    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
+    { name: 'Restore to Bidding', fromStatusKey: 'canceled', toStatusKey: 'bidding' },
+    { name: 'Restore to Production', fromStatusKey: 'canceled', toStatusKey: 'in_production' }
   ],
   taskTypes: [
     { key: 'vfx_task', label: 'VFX Task', description: 'Department task (e.g. Matchmove, Animation, FX, Comp)', icon: 'film' },
@@ -139,14 +152,23 @@ export const DEFAULT_CREATIVE_WORKFLOW: Workflow = {
   transitions: [
     { name: 'Start Concepts', fromStatusKey: 'briefing', toStatusKey: 'concept' },
     { name: 'Approve Concept for Production', fromStatusKey: 'concept', toStatusKey: 'in_production' },
+    { name: 'Return to Briefing', fromStatusKey: 'concept', toStatusKey: 'briefing' },
     { name: 'Submit for Internal Review', fromStatusKey: 'in_production', toStatusKey: 'internal_review' },
+    { name: 'Submit for Client Review', fromStatusKey: 'in_production', toStatusKey: 'client_review' },
     { name: 'Submit for Client Review', fromStatusKey: 'internal_review', toStatusKey: 'client_review' },
     { name: 'Request Revisions (Internal)', fromStatusKey: 'internal_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Production', fromStatusKey: 'internal_review', toStatusKey: 'in_production' },
+    { name: 'Approve from Lead Review', fromStatusKey: 'internal_review', toStatusKey: 'approved' },
     { name: 'Request Revisions (Client)', fromStatusKey: 'client_review', toStatusKey: 'revision_requested' },
+    { name: 'Return to Internal Review', fromStatusKey: 'client_review', toStatusKey: 'internal_review' },
     { name: 'Address Revisions', fromStatusKey: 'revision_requested', toStatusKey: 'in_production' },
+    { name: 'Resubmit to Lead Review', fromStatusKey: 'revision_requested', toStatusKey: 'internal_review' },
+    { name: 'Resubmit to Client Review', fromStatusKey: 'revision_requested', toStatusKey: 'client_review' },
     { name: 'Approve Work', fromStatusKey: 'client_review', toStatusKey: 'approved' },
     { name: 'Deliver Final Assets', fromStatusKey: 'approved', toStatusKey: 'delivered' },
-    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' }
+    { name: 'Reopen Deliverable', fromStatusKey: 'delivered', toStatusKey: 'in_production' },
+    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
+    { name: 'Restore', fromStatusKey: 'canceled', toStatusKey: 'briefing' }
   ],
   taskTypes: [
     { key: 'deliverable', label: 'Deliverable', description: 'Finished asset, cutdown, or packaged export', icon: 'package' },
@@ -211,6 +233,41 @@ export function getAllowedNextStatuses(
   return [allStatusKeys[currentIndex + 1]];
 }
 
+export function getAllowedTransitions(
+  workflow: Workflow | undefined,
+  currentStatus: string
+): string[] {
+  if (!workflow || !workflow.statuses || workflow.statuses.length === 0) {
+    return Object.keys(DEFAULT_STATUS_DEFINITIONS);
+  }
+
+  const allStatusKeys = workflow.statuses.map((s) => s.key);
+  if (!allStatusKeys.includes(currentStatus)) {
+    return [];
+  }
+
+  if (workflow.transitions && workflow.transitions.length > 0) {
+    const matches = workflow.transitions.filter(
+      (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
+    );
+
+    const allowed = new Set<string>();
+    for (const t of matches) {
+      if (t.toStatusKey === '*') {
+        allStatusKeys.filter((k) => k !== currentStatus).forEach((k) => allowed.add(k));
+      } else if (t.toStatusKey !== currentStatus && allStatusKeys.includes(t.toStatusKey)) {
+        allowed.add(t.toStatusKey);
+      }
+    }
+
+    return Array.from(allowed);
+  }
+
+  const next = getAllowedNextStatuses(workflow, currentStatus);
+  const prev = getAllowedPreviousStatuses(workflow, currentStatus);
+  return Array.from(new Set([...next, ...prev]));
+}
+
 export function getAllowedPreviousStatuses(
   workflow: Workflow | undefined,
   currentStatus: string

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/deliverables.test.ts","./src/index.test.ts","./src/index.ts","./src/status.test.ts","./src/use-case-validation.test.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/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/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/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"}