@critical-path/core 0.2.1 → 0.4.0

package/src/store/index.ts

@@ -11,8 +11,10 @@ import type {
   TimeEntry,
   Activity,
   Webhook,
-  TaskDependency
+  TaskDependency,
+  Workflow
 } from '../types/index.js';
+import { generateProjectKey } from '../utils/key.js';
 
 export interface StorageAdapter {
   // Projects
@@ -22,6 +24,13 @@ export interface StorageAdapter {
   updateProject(id: string, updates: Partial<Project>): Promise<Project | null>;
   deleteProject(id: string): Promise<boolean>;
 
+  // Workflows
+  getWorkflows(): Promise<Workflow[]>;
+  getWorkflow(id: string): Promise<Workflow | null>;
+  createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow>;
+  updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null>;
+  deleteWorkflow(id: string): Promise<boolean>;
+
   // Tasks
   getTasks(projectId?: string): Promise<Task[]>;
   getTask(id: string): Promise<Task | null>;
@@ -71,6 +80,7 @@ export interface StorageAdapter {
 
 export class InMemoryStore implements StorageAdapter {
   private projects = new Map<string, Project>();
+  private workflows = new Map<string, Workflow>();
   private tasks = new Map<string, Task>();
   private teams = new Map<string, Team>();
   private containers = new Map<string, TaskContainer>();
@@ -92,8 +102,10 @@ export class InMemoryStore implements StorageAdapter {
   async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
     const id = `proj_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
+    const key = project.key || generateProjectKey(project.name);
     const newProject: Project = {
       ...project,
+      key,
       id,
       createdAt: now,
       updatedAt: now
@@ -118,6 +130,44 @@ export class InMemoryStore implements StorageAdapter {
     return this.projects.delete(id);
   }
 
+  // Workflows
+  async getWorkflows(): Promise<Workflow[]> {
+    return Array.from(this.workflows.values());
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    return this.workflows.get(id) || null;
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const id = `wf_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newWorkflow: Workflow = {
+      ...workflow,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.workflows.set(id, newWorkflow);
+    return newWorkflow;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = this.workflows.get(id);
+    if (!existing) return null;
+    const updated: Workflow = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    this.workflows.set(id, updated);
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    return this.workflows.delete(id);
+  }
+
   async getTasks(projectId?: string): Promise<Task[]> {
     const all = Array.from(this.tasks.values());
     if (projectId) {

package/src/store/sqlite.test.ts

@@ -75,4 +75,32 @@ describe('SQLiteStore', () => {
     const entries = await store.getTimeEntries('task_1');
     expect(entries).toHaveLength(1);
   });
+
+  it('should create, retrieve, update, and delete workflows', async () => {
+    const workflow = await store.createWorkflow({
+      name: 'SQLite Workflow',
+      isDefault: true,
+      defaultStatusKey: 'todo',
+      statuses: [{ key: 'todo', label: 'To Do', completionState: 'not_done', executionState: 'inactive' }],
+      transitions: []
+    });
+
+    expect(workflow.id).toMatch(/^wf_/);
+    expect(workflow.name).toBe('SQLite Workflow');
+
+    const fetched = await store.getWorkflow(workflow.id);
+    expect(fetched?.isDefault).toBe(true);
+
+    const updated = await store.updateWorkflow(workflow.id, { name: 'Updated SQLite Workflow' });
+    expect(updated?.name).toBe('Updated SQLite Workflow');
+
+    const all = await store.getWorkflows();
+    expect(all).toHaveLength(1);
+
+    const deleted = await store.deleteWorkflow(workflow.id);
+    expect(deleted).toBe(true);
+
+    const remaining = await store.getWorkflows();
+    expect(remaining).toHaveLength(0);
+  });
 });

package/src/store/sqlite.ts

@@ -10,8 +10,10 @@ import type {
   TimeEntry,
   Activity,
   Webhook,
-  TaskDependency
+  TaskDependency,
+  Workflow
 } from '../types/index.js';
+import { generateProjectKey } from '../utils/key.js';
 
 export interface SQLiteStoreConfig {
   /**
@@ -47,6 +49,8 @@ export class SQLiteStore implements StorageAdapter {
         ownerId TEXT,
         members TEXT,
         teamIds TEXT,
+        workflowId TEXT,
+        taskTypes TEXT,
         statusDefinitions TEXT,
         priorityDefinitions TEXT,
         customFieldDefinitions TEXT,
@@ -54,6 +58,19 @@ export class SQLiteStore implements StorageAdapter {
         updatedAt TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS workflows (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        statuses TEXT NOT NULL,
+        transitions TEXT NOT NULL,
+        taskTypes TEXT,
+        defaultStatusKey TEXT,
+        isDefault INTEGER,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS teams (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
@@ -83,6 +100,7 @@ export class SQLiteStore implements StorageAdapter {
         description TEXT,
         status TEXT NOT NULL,
         priority TEXT NOT NULL,
+        taskType TEXT,
         assigneeId TEXT,
         reporterId TEXT,
         reviewerId TEXT,
@@ -183,20 +201,23 @@ export class SQLiteStore implements StorageAdapter {
   async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
     const id = `proj_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
-    const newProj: Project = { ...project, id, createdAt: now, updatedAt: now };
+    const key = project.key || generateProjectKey(project.name);
+    const newProj: Project = { ...project, key, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, workflowId, taskTypes, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newProj.id,
-      newProj.key,
+      newProj.key || '',
       newProj.name,
       newProj.description || null,
       newProj.ownerId || null,
       JSON.stringify(newProj.members || []),
       JSON.stringify(newProj.teamIds || []),
+      newProj.workflowId || null,
+      newProj.taskTypes ? JSON.stringify(newProj.taskTypes) : null,
       JSON.stringify(newProj.statusDefinitions || []),
       JSON.stringify(newProj.priorityDefinitions || []),
       JSON.stringify(newProj.customFieldDefinitions || []),
@@ -218,16 +239,18 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE projects
-      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
+      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, workflowId = ?, taskTypes = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
-      updated.key,
+      updated.key || '',
       updated.name,
       updated.description || null,
       updated.ownerId || null,
       JSON.stringify(updated.members || []),
       JSON.stringify(updated.teamIds || []),
+      updated.workflowId || null,
+      updated.taskTypes ? JSON.stringify(updated.taskTypes) : null,
       JSON.stringify(updated.statusDefinitions || []),
       JSON.stringify(updated.priorityDefinitions || []),
       JSON.stringify(updated.customFieldDefinitions || []),
@@ -237,6 +260,77 @@ export class SQLiteStore implements StorageAdapter {
     return updated;
   }
 
+  // --- Workflows ---
+  async getWorkflows(): Promise<Workflow[]> {
+    const stmt = this.db.prepare('SELECT * FROM workflows');
+    const rows = stmt.all() as any[];
+    return rows.map((r) => this.mapWorkflow(r));
+  }
+
+  async getWorkflow(id: string): Promise<Workflow | null> {
+    const stmt = this.db.prepare('SELECT * FROM workflows WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row ? this.mapWorkflow(row) : null;
+  }
+
+  async createWorkflow(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Promise<Workflow> {
+    const id = `wf_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newWf: Workflow = { ...workflow, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, description, statuses, transitions, taskTypes, defaultStatusKey, isDefault, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newWf.id,
+      newWf.name,
+      newWf.description || null,
+      JSON.stringify(newWf.statuses || []),
+      JSON.stringify(newWf.transitions || []),
+      newWf.taskTypes ? JSON.stringify(newWf.taskTypes) : null,
+      newWf.defaultStatusKey || null,
+      newWf.isDefault ? 1 : 0,
+      newWf.createdAt,
+      newWf.updatedAt
+    );
+    return newWf;
+  }
+
+  async updateWorkflow(id: string, updates: Partial<Workflow>): Promise<Workflow | null> {
+    const existing = await this.getWorkflow(id);
+    if (!existing) return null;
+
+    const updated: Workflow = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+
+    const stmt = this.db.prepare(`
+      UPDATE workflows SET name = ?, description = ?, statuses = ?, transitions = ?, taskTypes = ?, defaultStatusKey = ?, isDefault = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      JSON.stringify(updated.statuses || []),
+      JSON.stringify(updated.transitions || []),
+      updated.taskTypes ? JSON.stringify(updated.taskTypes) : null,
+      updated.defaultStatusKey || null,
+      updated.isDefault ? 1 : 0,
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteWorkflow(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM workflows WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   async deleteProject(id: string): Promise<boolean> {
     const stmt = this.db.prepare('DELETE FROM projects WHERE id = ?');
     const result = stmt.run(id);
@@ -392,12 +486,12 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       INSERT INTO tasks (
-        id, projectId, title, description, status, priority, assigneeId, reporterId,
+        id, projectId, title, description, status, priority, taskType, assigneeId, reporterId,
         reviewerId, iterationId, teamId, containerId, plannedStartDate, actualStartDate, actualEndDate,
         dueDate, estimatedHours, loggedHours, actualHours, billableHours,
         estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes, progress,
         tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
@@ -406,6 +500,7 @@ export class SQLiteStore implements StorageAdapter {
       newTask.description || null,
       newTask.status,
       newTask.priority,
+      newTask.taskType || null,
       newTask.assigneeId || null,
       newTask.reporterId || null,
       newTask.reviewerId || null,
@@ -445,7 +540,7 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE tasks SET
-        projectId = ?, title = ?, description = ?, status = ?, priority = ?,
+        projectId = ?, title = ?, description = ?, status = ?, priority = ?, taskType = ?,
         assigneeId = ?, reporterId = ?, reviewerId = ?, iterationId = ?, teamId = ?, containerId = ?,
         plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
         estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
@@ -459,6 +554,7 @@ export class SQLiteStore implements StorageAdapter {
       updated.description || null,
       updated.status,
       updated.priority,
+      updated.taskType || null,
       updated.assigneeId || null,
       updated.reporterId || null,
       updated.reviewerId || null,
@@ -704,6 +800,8 @@ export class SQLiteStore implements StorageAdapter {
   private mapProject(row: any): Project {
     return {
       ...row,
+      workflowId: row.workflowId || undefined,
+      taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
       members: row.members ? JSON.parse(row.members) : [],
       teamIds: row.teamIds ? JSON.parse(row.teamIds) : [],
       statusDefinitions: row.statusDefinitions ? JSON.parse(row.statusDefinitions) : [],
@@ -712,6 +810,16 @@ export class SQLiteStore implements StorageAdapter {
     };
   }
 
+  private mapWorkflow(row: any): Workflow {
+    return {
+      ...row,
+      statuses: row.statuses ? JSON.parse(row.statuses) : [],
+      transitions: row.transitions ? JSON.parse(row.transitions) : [],
+      taskTypes: row.taskTypes ? JSON.parse(row.taskTypes) : undefined,
+      isDefault: row.isDefault !== null && row.isDefault !== undefined ? Boolean(row.isDefault) : undefined
+    };
+  }
+
   private mapTeam(row: any): Team {
     return {
       ...row,
@@ -722,6 +830,7 @@ export class SQLiteStore implements StorageAdapter {
   private mapTask(row: any): Task {
     return {
       ...row,
+      taskType: row.taskType || undefined,
       tags: row.tags ? JSON.parse(row.tags) : [],
       customFields: row.customFields ? JSON.parse(row.customFields) : {}
     };

package/src/types/index.ts

@@ -46,14 +46,46 @@ export interface CustomFieldDefinition {
   defaultValue?: unknown;
 }
 
+export interface WorkflowTransition {
+  id?: string;
+  name?: string;
+  fromStatusKey: string | '*';
+  toStatusKey: string;
+}
+
+export interface TaskTypeDefinition {
+  key: string;
+  label: string;
+  description?: string;
+  icon?: string;
+  defaultStatusKey?: string;
+  workflowId?: string;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  statuses: StatusDefinition[];
+  transitions: WorkflowTransition[];
+  taskTypes?: TaskTypeDefinition[];
+  defaultStatusKey?: string;
+  isDefault?: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
 export interface Project {
   id: string;
-  key: string; // e.g. "CP" or "PROJ"
+  key?: string; // e.g. "CP" or "PROJ"
   name: string;
   description?: string;
   ownerId?: string;
   members?: string[]; // user IDs
   teamIds?: string[]; // team IDs
+  workflowId?: string;
+  workflow?: Workflow;
+  taskTypes?: TaskTypeDefinition[];
   statusDefinitions?: StatusDefinition[];
   priorityDefinitions?: Array<{ key: string; label: string; level?: number }>;
   customFieldDefinitions?: CustomFieldDefinition[];
@@ -90,10 +122,12 @@ export interface TaskDependencyGraph {
 export interface Task {
   id: string;
   projectId: string;
+  key?: string; // e.g. "MOB-12"
   title: string;
   description?: string;
   status: TaskStatus;
   priority: Priority;
+  taskType?: string; // e.g. "bug", "feature", "task", "epic"
   assigneeId?: string;
   reporterId?: string;
   reviewerId?: string;
@@ -183,7 +217,10 @@ export type WebhookEvent =
   | 'iteration.started'
   | 'iteration.completed'
   | 'team.created'
-  | 'container.created';
+  | 'container.created'
+  | 'workflow.created'
+  | 'workflow.updated'
+  | 'workflow.deleted';
 
 export interface PluginHooks {
   beforeTaskCreate?: (task: Partial<Task>) => Promise<Partial<Task>> | Partial<Task>;
@@ -215,5 +252,6 @@ export interface CriticalPathConfig {
     iterations?: Iteration[];
     teams?: Team[];
     containers?: TaskContainer[];
+    workflows?: Workflow[];
   };
 }

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './status.js';
+export * from './key.js';
+export * from './workflow.js';
+

package/src/utils/key.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { generateProjectKey, validateProjectKey, formatTaskKey } from './key.js';
+
+describe('Project Key Utilities', () => {
+  describe('generateProjectKey', () => {
+    it('generates a key for a single word name', () => {
+      expect(generateProjectKey('Operative')).toBe('OPE');
+      expect(generateProjectKey('App')).toBe('APP');
+      expect(generateProjectKey('Go')).toBe('GO');
+    });
+
+    it('generates a key for multi-word names', () => {
+      expect(generateProjectKey('Mobile App')).toBe('MA');
+      expect(generateProjectKey('Frontend Core Platform')).toBe('FCP');
+      expect(generateProjectKey('Very Long Project Name Here')).toBe('VLPN');
+    });
+
+    it('handles special characters and whitespace', () => {
+      expect(generateProjectKey('  v2.0  ')).toBe('V20');
+      expect(generateProjectKey('Project #1')).toBe('P1');
+    });
+
+    it('returns default PRJ fallback for empty input', () => {
+      expect(generateProjectKey('')).toBe('PRJ');
+      expect(generateProjectKey('   ')).toBe('PRJ');
+    });
+  });
+
+  describe('validateProjectKey', () => {
+    it('returns true for valid keys', () => {
+      expect(validateProjectKey('CP')).toBe(true);
+      expect(validateProjectKey('PROJ')).toBe(true);
+      expect(validateProjectKey('APP123')).toBe(true);
+    });
+
+    it('returns false for invalid keys', () => {
+      expect(validateProjectKey('A')).toBe(false); // too short
+      expect(validateProjectKey('TOOLONGKEY')).toBe(false); // too long
+      expect(validateProjectKey('proj')).toBe(false); // lowercase
+      expect(validateProjectKey('P-1')).toBe(false); // special char
+      expect(validateProjectKey('')).toBe(false);
+    });
+  });
+
+  describe('formatTaskKey', () => {
+    it('formats project key and task number', () => {
+      expect(formatTaskKey('MOB', 42)).toBe('MOB-42');
+      expect(formatTaskKey('op', 1)).toBe('OP-1');
+    });
+
+    it('uses fallback for missing project key', () => {
+      expect(formatTaskKey('', 10)).toBe('TASK-10');
+    });
+  });
+});

package/src/utils/key.ts

@@ -0,0 +1,51 @@
+/**
+ * Generates a 2-6 character uppercase project short code/key from a project name.
+ * e.g., "Mobile App" -> "MA", "Frontend Core" -> "FC", "Operative" -> "OPE".
+ */
+export function generateProjectKey(name: string): string {
+  if (!name || !name.trim()) {
+    return 'PRJ';
+  }
+
+  const words = name.trim().split(/\s+/).filter(Boolean);
+  let rawKey = '';
+
+  if (words.length === 1) {
+    const word = words[0].replace(/[^a-zA-Z0-9]/g, '');
+    if (word.length <= 3) {
+      rawKey = word.toUpperCase();
+    } else {
+      rawKey = word.substring(0, 3).toUpperCase();
+    }
+  } else {
+    rawKey = words
+      .map((w) => w.replace(/[^a-zA-Z0-9]/g, '')[0] || '')
+      .join('')
+      .substring(0, 4)
+      .toUpperCase();
+  }
+
+  // Ensure key meets basic 2-6 char alphanumeric requirement
+  const cleanKey = rawKey.replace(/[^A-Z0-9]/g, '');
+  if (cleanKey.length >= 2 && cleanKey.length <= 6) {
+    return cleanKey;
+  }
+
+  return 'PRJ';
+}
+
+/**
+ * Validates whether a given key meets project key format rules (2-6 uppercase alphanumeric characters).
+ */
+export function validateProjectKey(key: string): boolean {
+  if (!key) return false;
+  return /^[A-Z0-9]{2,6}$/.test(key);
+}
+
+/**
+ * Formats a task key using a project key and task index (e.g. "MOB-12").
+ */
+export function formatTaskKey(projectKey: string, taskNumber: number): string {
+  const prefix = projectKey ? projectKey.toUpperCase() : 'TASK';
+  return `${prefix}-${taskNumber}`;
+}

package/src/utils/workflow.ts

@@ -0,0 +1,128 @@
+import type {
+  Workflow,
+  StatusDefinition,
+  TaskTypeDefinition
+} from '../types/index.js';
+import { DEFAULT_STATUS_DEFINITIONS } from './status.js';
+
+export class WorkflowValidationError extends Error {
+  public readonly fromStatus: string;
+  public readonly toStatus: string;
+  public readonly workflowId?: string;
+
+  constructor(fromStatus: string, toStatus: string, workflowId?: string, message?: string) {
+    const msg = message || `Illegal status transition from "${fromStatus}" to "${toStatus}"${workflowId ? ` in workflow "${workflowId}"` : ''}.`;
+    super(msg);
+    this.name = 'WorkflowValidationError';
+    this.fromStatus = fromStatus;
+    this.toStatus = toStatus;
+    this.workflowId = workflowId;
+  }
+}
+
+export const DEFAULT_TASK_TYPES: TaskTypeDefinition[] = [
+  { key: 'task', label: 'Task', description: 'A standard work item', icon: 'check-square' },
+  { key: 'bug', label: 'Bug', description: 'A problem or defect that needs fixing', icon: 'bug' },
+  { key: 'feature', label: 'Feature', description: 'A new capability or enhancement', icon: 'sparkles' },
+  { key: 'epic', label: 'Epic', description: 'A large body of work that spans multiple tasks', icon: 'layers' },
+  { key: 'subtask', label: 'Subtask', description: 'A piece of work required to complete a parent task', icon: 'corner-down-right' }
+];
+
+export const DEFAULT_SOFTWARE_WORKFLOW: Workflow = {
+  id: 'wf_software_default',
+  name: 'Software Development Workflow',
+  description: 'Standard software development lifecycle with backlog, review, and completion states.',
+  statuses: [
+    DEFAULT_STATUS_DEFINITIONS.backlog,
+    DEFAULT_STATUS_DEFINITIONS.todo,
+    DEFAULT_STATUS_DEFINITIONS.in_progress,
+    DEFAULT_STATUS_DEFINITIONS.in_review,
+    DEFAULT_STATUS_DEFINITIONS.done,
+    DEFAULT_STATUS_DEFINITIONS.canceled
+  ],
+  transitions: [
+    { name: 'Start Work', fromStatusKey: 'backlog', toStatusKey: 'todo' },
+    { name: 'Start Implementation', fromStatusKey: 'todo', toStatusKey: 'in_progress' },
+    { name: 'Complete Task', fromStatusKey: 'todo', toStatusKey: 'done' },
+    { name: 'Submit for Review', fromStatusKey: 'in_progress', toStatusKey: 'in_review' },
+    { name: 'Complete Implementation', fromStatusKey: 'in_progress', toStatusKey: 'done' },
+    { name: 'Approve & Complete', fromStatusKey: 'in_review', toStatusKey: 'done' },
+    { name: 'Request Changes', fromStatusKey: 'in_review', toStatusKey: 'in_progress' },
+    { name: 'Reopen', fromStatusKey: 'done', toStatusKey: 'todo' },
+    { name: 'Cancel', fromStatusKey: '*', toStatusKey: 'canceled' },
+    { name: 'Restore', fromStatusKey: 'canceled', toStatusKey: 'todo' }
+  ],
+  taskTypes: DEFAULT_TASK_TYPES,
+  defaultStatusKey: 'todo',
+  isDefault: true,
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-01T00:00:00.000Z'
+};
+
+export const DEFAULT_SIMPLE_WORKFLOW: Workflow = {
+  id: 'wf_simple_default',
+  name: 'Simple Task Workflow',
+  description: 'Lightweight workflow with To Do, In Progress, and Done states.',
+  statuses: [
+    DEFAULT_STATUS_DEFINITIONS.todo,
+    DEFAULT_STATUS_DEFINITIONS.in_progress,
+    DEFAULT_STATUS_DEFINITIONS.done
+  ],
+  transitions: [
+    { name: 'Start', fromStatusKey: 'todo', toStatusKey: 'in_progress' },
+    { name: 'Complete', fromStatusKey: 'todo', toStatusKey: 'done' },
+    { name: 'Complete', fromStatusKey: 'in_progress', toStatusKey: 'done' },
+    { name: 'Reopen', fromStatusKey: 'done', toStatusKey: 'todo' }
+  ],
+  taskTypes: DEFAULT_TASK_TYPES.filter((t) => ['task', 'subtask'].includes(t.key)),
+  defaultStatusKey: 'todo',
+  isDefault: true,
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-01T00:00:00.000Z'
+};
+
+export function validateTransition(
+  workflow: Workflow | undefined,
+  fromStatus: string,
+  toStatus: string
+): boolean {
+  if (fromStatus === toStatus) return true;
+  if (!workflow || !workflow.transitions || workflow.transitions.length === 0) return true;
+
+  return workflow.transitions.some(
+    (t) =>
+      (t.fromStatusKey === '*' || t.fromStatusKey === fromStatus) &&
+      (t.toStatusKey === '*' || t.toStatusKey === toStatus)
+  );
+}
+
+export function getAllowedNextStatuses(
+  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 (!workflow.transitions || workflow.transitions.length === 0) {
+    return allStatusKeys;
+  }
+
+  const matches = workflow.transitions.filter(
+    (t) => t.fromStatusKey === '*' || t.fromStatusKey === currentStatus
+  );
+
+  if (matches.some((t) => t.toStatusKey === '*')) {
+    return allStatusKeys;
+  }
+
+  const allowed = new Set<string>();
+  for (const t of matches) {
+    if (allStatusKeys.includes(t.toStatusKey)) {
+      allowed.add(t.toStatusKey);
+    }
+  }
+
+  return Array.from(allowed);
+}