@critical-path/core 0.26.0 → 0.28.0

package/src/engine/index.ts

@@ -17,7 +17,8 @@ import type {
   PresignedUrlOptions,
   PresignedUploadResult,
   TimeEntry,
-  WebhookEvent,
+  Webhook,
+  PublicWebhook,
   Workflow,
   CreateTaskInput,
   CreateProjectInput,
@@ -82,9 +83,12 @@ import {
   AttachmentDeletedEvent
 } from '../domain/events.js';
 import { validateAttachmentUrl, AttachmentValidationError } from '../domain/entities.js';
-import { validateCustomFieldValues } from '../domain/custom-fields.js';
+import { validateCustomFieldValues, validateCustomFieldDefinitions } from '../domain/custom-fields.js';
 import { detectDependencyCycle, CircularDependencyError } from '../domain/graph.js';
 import { ValidationError, NotFoundError, ForbiddenError } from '../domain/errors.js';
+import { WebhookDispatcher, assertWebhookUrl } from '../webhooks/dispatcher.js';
+import { generateWebhookSecret } from '../webhooks/signature.js';
+import type { DomainEvent } from '../domain/events.js';
 import { calculateCPM, type CPMOptions } from '../domain/cpm.js';
 import { buildTimelineLadder, aggregateConcreteEvidenceForTask } from '../domain/ladder.js';
 import {
@@ -100,6 +104,8 @@ export class CriticalPathEngine {
   public readonly fileStorage?: FileStorageAdapter;
   public readonly plugins: PluginRegistry;
   public readonly events: DomainEventBus;
+  /** Delivers domain events to registered webhooks. Exposed for custom queues (`deliver`) and tests (`idle`). */
+  public readonly webhooks: WebhookDispatcher;
   public readonly ready: Promise<void> = Promise.resolve();
   /** The identity mutations are attributed to. Set only on views returned by `withActor`. */
   public readonly actor?: Actor;
@@ -115,6 +121,14 @@ export class CriticalPathEngine {
     this.fileStorage = config.fileStorage;
     this.plugins = new PluginRegistry();
     this.events = new DomainEventBus();
+    this.webhooks = new WebhookDispatcher(
+      {
+        listWebhooks: () => this.listAllWebhooks(),
+        resolveTenant: (event) => this.resolveEventTenant(event)
+      },
+      config.webhookDelivery
+    );
+    this.events.subscribe('*', (event) => this.webhooks.handle(event));
 
     if (config.plugins) {
       for (const plugin of config.plugins) {
@@ -122,9 +136,9 @@ export class CriticalPathEngine {
       }
     }
 
-    if (config.initialData) {
-      this.ready = this.seedInitialData(config.initialData);
-    }
+    this.ready = this.initialize(config);
+    // Callers that never await `ready` should not crash on an unhandled rejection; awaiting it still throws.
+    this.ready.catch(() => {});
   }
 
   /**
@@ -250,6 +264,15 @@ export class CriticalPathEngine {
     return rest as T;
   }
 
+  private async initialize(config: CriticalPathConfig): Promise<void> {
+    if (config.initialData) {
+      await this.seedInitialData(config.initialData);
+    }
+    for (const plugin of this.plugins.getPlugins()) {
+      await plugin.init?.(this);
+    }
+  }
+
   private async seedInitialData(data: NonNullable<CriticalPathConfig['initialData']>): Promise<void> {
     if (data.workflows) {
       for (const wf of data.workflows) {
@@ -319,7 +342,6 @@ export class CriticalPathEngine {
       action: 'workflow.created',
       details: { name: created.name }
     });
-    this.dispatchWebhook('workflow.created', { workflow: created });
     return created;
   }
 
@@ -347,7 +369,6 @@ export class CriticalPathEngine {
         action: 'workflow.updated',
         details: { name: updated.name }
       });
-      this.dispatchWebhook('workflow.updated', { workflow: updated, previous: existing });
     }
     return updated;
   }
@@ -366,7 +387,7 @@ export class CriticalPathEngine {
         aggregateId: id,
         aggregateType: 'Workflow',
         occurredAt: now,
-        payload: { workflowId: id, name: existing.name }
+        payload: { workflowId: id, name: existing.name, tenantId: existing.tenantId }
       };
       await this.events.publish(event);
 
@@ -375,7 +396,6 @@ export class CriticalPathEngine {
         action: 'workflow.deleted',
         details: { name: existing.name }
       });
-      this.dispatchWebhook('workflow.deleted', { workflowId: id, name: existing.name });
     }
     return deleted;
   }
@@ -431,6 +451,7 @@ export class CriticalPathEngine {
 
   async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
     await this.requireWorkspaceAccess('project.create');
+    validateCustomFieldDefinitions(project.customFieldDefinitions, this.plugins.getCustomFieldTypes());
     // Views always use the actor's tenant (possibly none); only trusted base-engine calls may set it.
     const input = { ...project, tenantId: this.actor ? this.actor.tenantId : project.tenantId };
     // The creator administers the project they create.
@@ -456,7 +477,6 @@ export class CriticalPathEngine {
       action: 'project.created',
       details: { name: created.name, key: created.key }
     });
-    this.dispatchWebhook('project.created', { project: created });
     return created;
   }
 
@@ -465,6 +485,7 @@ export class CriticalPathEngine {
     if (!existing) return null;
     await this.requireProjectAccess('project.update', id);
     if ('members' in updates) await this.requireProjectAccess('project.manage_members', id);
+    validateCustomFieldDefinitions(updates.customFieldDefinitions, this.plugins.getCustomFieldTypes());
     updates = this.withoutTenant(updates);
 
     const updated = await this.store.updateProject(id, updates);
@@ -486,7 +507,6 @@ export class CriticalPathEngine {
         action: 'project.updated',
         details: { name: updated.name }
       });
-      this.dispatchWebhook('project.updated', { project: updated });
     }
     return updated;
   }
@@ -519,7 +539,7 @@ export class CriticalPathEngine {
         aggregateId: id,
         aggregateType: 'Project',
         occurredAt: now,
-        payload: { projectId: id, name: existing.name, deletedTaskIds }
+        payload: { projectId: id, name: existing.name, deletedTaskIds, tenantId: existing.tenantId }
       };
       await this.events.publish(event);
 
@@ -529,7 +549,6 @@ export class CriticalPathEngine {
         action: 'project.deleted',
         details: { name: existing.name, deletedTaskCount: deletedTaskIds.length }
       });
-      this.dispatchWebhook('project.deleted', { projectId: id, name: existing.name, deletedTaskIds });
     }
     return deleted;
   }
@@ -553,17 +572,19 @@ export class CriticalPathEngine {
       taskInput = { ...taskInput, reporterId: this.actor.userId };
     }
     const processedInput = await this.plugins.runBeforeTaskCreate(taskInput);
-    const projectId = processedInput.projectId || taskInput.projectId;
+    if (processedInput.projectId && processedInput.projectId !== taskInput.projectId) {
+      throw new ValidationError('Plugins cannot move a task to another project in beforeTaskCreate.');
+    }
+    const projectId = taskInput.projectId;
     const project = await this.store.getProject(projectId);
     const workflow = await this.resolveProjectWorkflow(projectId);
 
-    // Validate custom field domain invariants
-    if (project?.customFieldDefinitions && (processedInput.customFields || taskInput.customFields)) {
-      validateCustomFieldValues(
-        project.customFieldDefinitions,
-        processedInput.customFields || taskInput.customFields
-      );
-    }
+    // Validate custom fields on the final (post-plugin) input, including required fields when none are given
+    validateCustomFieldValues(
+      project?.customFieldDefinitions,
+      processedInput.customFields ?? taskInput.customFields,
+      this.plugins.getCustomFieldTypes()
+    );
 
     const defaultStatus = workflow?.defaultStatusKey || 'todo';
     const initialStatus = processedInput.status || taskInput.status || defaultStatus;
@@ -642,7 +663,6 @@ export class CriticalPathEngine {
       details: { title: created.title, status: created.status }
     });
 
-    this.dispatchWebhook('task.created', { task: created });
     return created;
   }
 
@@ -673,24 +693,32 @@ export class CriticalPathEngine {
     const project = await this.store.getProject(existing.projectId);
     const workflow = await this.resolveProjectWorkflow(existing.projectId);
 
+    // Plugins run first; their output is then validated like caller input. Identity and
+    // ownership fields are never changed by hooks.
+    const {
+      id: _id,
+      projectId: _projectId,
+      createdAt: _createdAt,
+      ...processedUpdates
+    } = await this.plugins.runBeforeTaskUpdate(id, taskUpdates) as Partial<Task>;
+
     // Validate workflow transition invariant
-    if (taskUpdates.status && taskUpdates.status !== existing.status) {
-      const isValid = validateTransition(workflow || undefined, existing.status, taskUpdates.status);
+    if (processedUpdates.status && processedUpdates.status !== existing.status) {
+      const isValid = validateTransition(workflow || undefined, existing.status, processedUpdates.status);
       if (!isValid) {
-        throw new WorkflowValidationError(existing.status, taskUpdates.status, workflow?.id);
+        throw new WorkflowValidationError(existing.status, processedUpdates.status, workflow?.id);
       }
     }
 
     // Validate custom field invariants
-    if (project?.customFieldDefinitions && taskUpdates.customFields) {
-      validateCustomFieldValues(project.customFieldDefinitions, {
-        ...existing.customFields,
-        ...taskUpdates.customFields
-      });
+    if (processedUpdates.customFields) {
+      validateCustomFieldValues(
+        project?.customFieldDefinitions,
+        { ...existing.customFields, ...processedUpdates.customFields },
+        this.plugins.getCustomFieldTypes()
+      );
     }
 
-    const processedUpdates = await this.plugins.runBeforeTaskUpdate(id, taskUpdates);
-
     const now = new Date().toISOString();
     const existingStatusDef = resolveStatusDefinition(
       existing.status,
@@ -925,10 +953,6 @@ export class CriticalPathEngine {
         action: 'task.blocked',
         details: { reason: blockedReason, ...(actorName ? { actorName } : {}) }
       });
-      this.dispatchWebhook('task.blocked', {
-        task: updated,
-        reason: blockedReason
-      });
     } else if (wasBlocked && !isNowBlocked) {
       const unblockedEvent: TaskUnblockedEvent = {
         id: `evt_${Math.random().toString(36).substring(2, 9)}`,
@@ -951,9 +975,6 @@ export class CriticalPathEngine {
         action: 'task.unblocked',
         details: { ...(actorName ? { actorName } : {}) }
       });
-      this.dispatchWebhook('task.unblocked', {
-        task: updated
-      });
     }
 
     await this.store.logActivity({
@@ -968,10 +989,6 @@ export class CriticalPathEngine {
       }
     });
 
-    this.dispatchWebhook(isStatusChange ? 'task.status_changed' : 'task.updated', {
-      task: updated,
-      previous: existing
-    });
 
     return updated;
   }
@@ -1042,10 +1059,6 @@ export class CriticalPathEngine {
             details: { unblockedByTaskId: completedTask.id }
           });
 
-          this.dispatchWebhook('task.unblocked', {
-            task: updatedDownstream,
-            upstreamTaskId: completedTask.id
-          });
         }
       }
     } catch (err) {
@@ -1058,11 +1071,11 @@ export class CriticalPathEngine {
     if (!existing) return false;
     await this.requireProjectAccess('task.delete', existing.projectId);
 
-    await this.plugins.runBeforeTaskDelete(id);
+    await this.plugins.runBeforeTaskDelete(id, existing);
     const deleted = await this.store.deleteTask(id);
 
     if (deleted) {
-      await this.plugins.runAfterTaskDelete(id);
+      await this.plugins.runAfterTaskDelete(id, existing);
       const now = new Date().toISOString();
 
       const event: TaskDeletedEvent = {
@@ -1086,7 +1099,6 @@ export class CriticalPathEngine {
         action: 'task.deleted',
         details: { title: existing.title }
       });
-      this.dispatchWebhook('task.deleted', { taskId: id, title: existing.title });
     }
     return deleted;
   }
@@ -1297,7 +1309,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('comment.created', { comment: created });
     return created;
   }
 
@@ -1326,7 +1337,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('comment.updated', { comment: updated });
     return updated;
   }
 
@@ -1351,7 +1361,6 @@ export class CriticalPathEngine {
       };
       await this.events.publish(event);
 
-      this.dispatchWebhook('comment.deleted', { commentId: id, taskId: existing.taskId });
     }
     return deleted;
   }
@@ -1399,7 +1408,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('comment.reaction.added', { comment: updated, reaction });
     return updated;
   }
 
@@ -1432,7 +1440,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('comment.reaction.removed', { comment: updated, reaction });
     return updated;
   }
 
@@ -1481,7 +1488,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('attachment.created', { attachment: created });
     return created;
   }
 
@@ -1510,11 +1516,15 @@ export class CriticalPathEngine {
         aggregateId: id,
         aggregateType: 'Attachment',
         occurredAt: now,
-        payload: { attachmentId: id, storageKey: existing.storageKey, url: existing.url }
+        payload: {
+          attachmentId: id,
+          storageKey: existing.storageKey,
+          url: existing.url,
+          projectId: await this.projectIdOfAttachment(existing)
+        }
       };
       await this.events.publish(event);
 
-      this.dispatchWebhook('attachment.deleted', { attachmentId: id, taskId: existing.taskId, projectId: existing.projectId });
     }
     return deleted;
   }
@@ -1639,7 +1649,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('team.created', { team: created });
     return created;
   }
 
@@ -1682,7 +1691,6 @@ export class CriticalPathEngine {
     };
     await this.events.publish(event);
 
-    this.dispatchWebhook('container.created', { container: created });
     return created;
   }
 
@@ -1716,7 +1724,7 @@ export class CriticalPathEngine {
     await this.requireProjectAccess('plan.manage', input.projectId);
     const project = await this.store.getProject(input.projectId);
     if (project?.customFieldDefinitions && input.customFields) {
-      validateCustomFieldValues(project.customFieldDefinitions, input.customFields);
+      validateCustomFieldValues(project.customFieldDefinitions, input.customFields, this.plugins.getCustomFieldTypes());
     }
 
     const created = await this.store.createDeliverable({
@@ -1743,7 +1751,6 @@ export class CriticalPathEngine {
       action: 'deliverable.created',
       details: { title: created.title, format: created.format }
     });
-    this.dispatchWebhook('deliverable.created', { deliverable: created });
     return created;
   }
 
@@ -1774,11 +1781,6 @@ export class CriticalPathEngine {
           }
         };
         await this.events.publish(statusEvent);
-        this.dispatchWebhook('deliverable.status_changed', {
-          deliverable: updated,
-          previousStatus: existing.status,
-          newStatus: updated.status
-        });
       }
 
       const updateEvent: DeliverableUpdatedEvent = {
@@ -1797,7 +1799,6 @@ export class CriticalPathEngine {
         action: 'deliverable.updated',
         details: { title: updated.title, status: updated.status }
       });
-      this.dispatchWebhook('deliverable.updated', { deliverable: updated });
     }
     return updated;
   }
@@ -1826,7 +1827,6 @@ export class CriticalPathEngine {
         action: 'deliverable.deleted',
         details: { title: existing.title }
       });
-      this.dispatchWebhook('deliverable.deleted', { deliverableId: id, projectId: existing.projectId });
     }
     return deleted;
   }
@@ -1904,7 +1904,6 @@ export class CriticalPathEngine {
         payload: { iteration: created }
       };
       await this.events.publish(event);
-      this.dispatchWebhook('iteration.started', { iteration: created });
     }
     return created;
   }
@@ -1927,7 +1926,6 @@ export class CriticalPathEngine {
           payload: { iteration: updated }
         };
         await this.events.publish(event);
-        this.dispatchWebhook('iteration.started', { iteration: updated });
       } else if (existing.status !== 'completed' && updated.status === 'completed') {
         const event: IterationCompletedEvent = {
           id: `evt_${Math.random().toString(36).substring(2, 9)}`,
@@ -1938,7 +1936,6 @@ export class CriticalPathEngine {
           payload: { iteration: updated }
         };
         await this.events.publish(event);
-        this.dispatchWebhook('iteration.completed', { iteration: updated });
       }
     }
     return updated;
@@ -2123,19 +2120,108 @@ export class CriticalPathEngine {
     );
   }
 
-  private async dispatchWebhook(event: WebhookEvent, payload: Record<string, unknown>): Promise<void> {
+  // --- Webhooks ---
+
+  /** Webhooks from `config.webhooks` (static, not editable) plus those in the store. */
+  private async listAllWebhooks(): Promise<Webhook[]> {
+    const fromConfig: Webhook[] = (this.config.webhooks ?? []).map((w, i) => ({
+      ...w,
+      id: `config_${i}`,
+      createdAt: new Date(0).toISOString()
+    }));
+    return [...fromConfig, ...(await this.store.getWebhooks())];
+  }
+
+  private toPublicWebhook({ secret, ...webhook }: Webhook): PublicWebhook {
+    return { ...webhook, hasSecret: !!secret };
+  }
+
+  /** Webhooks in the actor's tenant, with secrets redacted. Requires `workspace.manage` on views. */
+  async getWebhooks(): Promise<PublicWebhook[]> {
+    await this.requireWorkspaceAccess('workspace.manage');
     const webhooks = await this.store.getWebhooks();
-    const active = webhooks.filter((w) => w.active && w.events.includes(event));
-
-    for (const wh of active) {
-      fetch(wh.url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ event, timestamp: new Date().toISOString(), data: payload })
-      }).catch(() => {
-        // Silent catch for webhook errors in dev
-      });
+    return webhooks.filter((w) => this.inActorTenant(w)).map((w) => this.toPublicWebhook(w));
+  }
+
+  async getWebhook(id: string): Promise<PublicWebhook | null> {
+    await this.requireWorkspaceAccess('workspace.manage');
+    const webhook = await this.store.getWebhook(id);
+    return webhook && this.inActorTenant(webhook) ? this.toPublicWebhook(webhook) : null;
+  }
+
+  /**
+   * Registers a webhook. The signing secret is returned only here; generate one by omitting
+   * `secret`. Deliveries carry `X-CriticalPath-Signature` (see `verifyWebhookSignature`).
+   */
+  async createWebhook(input: {
+    name: string;
+    url: string;
+    events: Webhook['events'];
+    secret?: string;
+    active?: boolean;
+  }): Promise<{ webhook: PublicWebhook; secret: string }> {
+    await this.requireWorkspaceAccess('workspace.manage');
+    this.validateWebhookUrl(input.url);
+    const secret = input.secret ?? generateWebhookSecret();
+    const created = await this.store.addWebhook({
+      name: input.name,
+      url: input.url,
+      events: input.events,
+      secret,
+      active: input.active ?? true,
+      tenantId: this.actor?.tenantId
+    });
+    this.webhooks.invalidate();
+    return { webhook: this.toPublicWebhook(created), secret };
+  }
+
+  async updateWebhook(
+    id: string,
+    updates: Partial<Pick<Webhook, 'name' | 'url' | 'events' | 'active' | 'secret'>>
+  ): Promise<PublicWebhook | null> {
+    if (!(await this.getWebhook(id))) return null;
+    if (updates.url) this.validateWebhookUrl(updates.url);
+    const { name, url, events, active, secret } = updates;
+    const updated = await this.store.updateWebhook(
+      id,
+      Object.fromEntries(Object.entries({ name, url, events, active, secret }).filter(([, v]) => v !== undefined))
+    );
+    this.webhooks.invalidate();
+    return updated ? this.toPublicWebhook(updated) : null;
+  }
+
+  async deleteWebhook(id: string): Promise<boolean> {
+    if (!(await this.getWebhook(id))) return false;
+    const deleted = await this.store.deleteWebhook(id);
+    this.webhooks.invalidate();
+    return deleted;
+  }
+
+  private validateWebhookUrl(url: string): void {
+    try {
+      assertWebhookUrl(url, this.config.webhookDelivery?.allowPrivateUrls);
+    } catch (err) {
+      throw new ValidationError((err as Error).message);
     }
   }
-}
 
+  /** Finds the tenant an event belongs to, from the entity in its payload or its project. */
+  private async resolveEventTenant(event: DomainEvent): Promise<string | undefined> {
+    const p = event.payload as Record<string, any>;
+    const owner = p.project ?? p.workflow ?? p.team;
+    if (owner) return owner.tenantId ?? undefined;
+    // Deleted projects and workflows carry their tenant in the payload.
+    if ('tenantId' in p) return p.tenantId ?? undefined;
+
+    const projectId: string | undefined =
+      p.projectId ??
+      p.task?.projectId ??
+      p.deliverable?.projectId ??
+      p.iteration?.projectId ??
+      p.container?.projectId ??
+      p.attachment?.projectId ??
+      (await this.projectIdOfTask(p.taskId ?? p.comment?.taskId ?? p.attachment?.taskId ?? p.dependency?.taskId ?? p.timeEntry?.taskId));
+    if (!projectId) return undefined;
+    return (await this.store.getProject(projectId))?.tenantId ?? undefined;
+  }
+}

package/src/index.ts

@@ -5,4 +5,5 @@ export * from './storage/index.js';
 export * from './plugins/index.js';
 export * from './engine/index.js';
 export * from './domain/index.js';
+export * from './webhooks/index.js';
 

package/src/plugins/index.ts

@@ -1,12 +1,31 @@
-import type { CriticalPathPlugin, Task } from '../types/index.js';
+import type { CriticalPathPlugin, CustomFieldType, PluginMiddleware, PluginRoute, Task } from '../types/index.js';
+
+export const BUILT_IN_CUSTOM_FIELD_TYPES = [
+  'text',
+  'number',
+  'date',
+  'boolean',
+  'single_select',
+  'multi_select',
+  'user'
+] as const;
 
 export class PluginRegistry {
   private plugins = new Map<string, CriticalPathPlugin>();
+  private fieldTypes = new Map<string, CustomFieldType>();
 
   register(plugin: CriticalPathPlugin): void {
     if (this.plugins.has(plugin.id)) {
       throw new Error(`Plugin with ID "${plugin.id}" is already registered.`);
     }
+    for (const fieldType of plugin.customFieldTypes ?? []) {
+      if ((BUILT_IN_CUSTOM_FIELD_TYPES as readonly string[]).includes(fieldType.type) || this.fieldTypes.has(fieldType.type)) {
+        throw new Error(`Plugin "${plugin.id}" registers custom field type "${fieldType.type}", which already exists.`);
+      }
+    }
+    for (const fieldType of plugin.customFieldTypes ?? []) {
+      this.fieldTypes.set(fieldType.type, fieldType);
+    }
     this.plugins.set(plugin.id, plugin);
   }
 
@@ -14,6 +33,19 @@ export class PluginRegistry {
     return Array.from(this.plugins.values());
   }
 
+  /** Custom field types contributed by plugins, keyed by `type`. */
+  getCustomFieldTypes(): ReadonlyMap<string, CustomFieldType> {
+    return this.fieldTypes;
+  }
+
+  getRoutes(): Array<PluginRoute & { pluginId: string }> {
+    return this.getPlugins().flatMap((p) => (p.routes ?? []).map((route) => ({ ...route, pluginId: p.id })));
+  }
+
+  getMiddleware(): PluginMiddleware[] {
+    return this.getPlugins().flatMap((p) => (p.middleware ? [p.middleware] : []));
+  }
+
   async runBeforeTaskCreate(task: Partial<Task>): Promise<Partial<Task>> {
     let currentTask = { ...task };
     for (const plugin of this.plugins.values()) {
@@ -25,11 +57,7 @@ export class PluginRegistry {
   }
 
   async runAfterTaskCreate(task: Task): Promise<void> {
-    for (const plugin of this.plugins.values()) {
-      if (plugin.hooks?.afterTaskCreate) {
-        await plugin.hooks.afterTaskCreate(task);
-      }
-    }
+    await this.runAfter('afterTaskCreate', (hooks) => hooks.afterTaskCreate?.(task));
   }
 
   async runBeforeTaskUpdate(id: string, updates: Partial<Task>): Promise<Partial<Task>> {
@@ -43,25 +71,32 @@ export class PluginRegistry {
   }
 
   async runAfterTaskUpdate(task: Task, previousState: Task): Promise<void> {
-    for (const plugin of this.plugins.values()) {
-      if (plugin.hooks?.afterTaskUpdate) {
-        await plugin.hooks.afterTaskUpdate(task, previousState);
-      }
-    }
+    await this.runAfter('afterTaskUpdate', (hooks) => hooks.afterTaskUpdate?.(task, previousState));
   }
 
-  async runBeforeTaskDelete(id: string): Promise<void> {
+  async runBeforeTaskDelete(id: string, task: Task): Promise<void> {
     for (const plugin of this.plugins.values()) {
       if (plugin.hooks?.beforeTaskDelete) {
-        await plugin.hooks.beforeTaskDelete(id);
+        await plugin.hooks.beforeTaskDelete(id, task);
       }
     }
   }
 
-  async runAfterTaskDelete(id: string): Promise<void> {
+  async runAfterTaskDelete(id: string, task: Task): Promise<void> {
+    await this.runAfter('afterTaskDelete', (hooks) => hooks.afterTaskDelete?.(id, task));
+  }
+
+  /** Runs an after-hook on every plugin; the change is already stored, so errors are only logged. */
+  private async runAfter(
+    name: string,
+    call: (hooks: NonNullable<CriticalPathPlugin['hooks']>) => unknown
+  ): Promise<void> {
     for (const plugin of this.plugins.values()) {
-      if (plugin.hooks?.afterTaskDelete) {
-        await plugin.hooks.afterTaskDelete(id);
+      if (!plugin.hooks) continue;
+      try {
+        await call(plugin.hooks);
+      } catch (err) {
+        console.error(`[CriticalPath] Plugin "${plugin.id}" ${name} hook failed:`, err);
       }
     }
   }