@xopcai/xopc 0.0.332 → 0.0.334

package/dist/src/automations/service/action-executor.js

@@ -70,6 +70,36 @@ async function executeWithDeadline(operation, timeoutMs, parentSignal, deadlineA
 }
 var AutomationActionExecutor = class {
 	deps = {};
+	handlers = /* @__PURE__ */ new Map();
+	constructor() {
+		this.register("agent", { mode: "never" }, (input, action) => this.executeAgent(input.automation, action, input.run, input.signal, input.hooks, input.deadlineAtMs, input.context));
+		this.register("workflow", {
+			mode: "idempotent",
+			key: "run_id"
+		}, (input, action) => this.executeWorkflow(input.automation, action, input.run, input.signal, input.hooks, input.context));
+		this.register("browser_automation", { mode: "never" }, (input, action) => this.executeBrowserAutomation(input.automation, action, input.signal, input.hooks, input.context));
+		this.register("task_command", {
+			mode: "idempotent",
+			key: "run_id"
+		}, (input, action) => this.executeTaskCommand(input, action));
+		this.register("system", {
+			mode: "transient_only",
+			classify: (error) => /temporar|timeout|timed out|unavailable|busy|rate limit|econn|network/i.test(String(error))
+		}, (input, action) => this.executeSystemAction(input, action));
+	}
+	register(kind, retrySafety, handler) {
+		if (this.handlers.has(kind)) throw new Error(`Automation executor already registered: ${kind}`);
+		this.handlers.set(kind, {
+			retrySafety,
+			handler: (input) => handler(input, input.automation.action)
+		});
+	}
+	canRetry(kind, error) {
+		const retrySafety = this.handlers.get(kind)?.retrySafety ?? { mode: "never" };
+		if (retrySafety.mode === "never") return false;
+		if (retrySafety.mode === "idempotent") return true;
+		return retrySafety.classify(error);
+	}
 	setDeps(deps) {
 		this.deps = {
 			...this.deps,
@@ -105,46 +135,56 @@ var AutomationActionExecutor = class {
 			status: "cancelled",
 			error: "Automation run was cancelled"
 		};
-		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run, signal, hooks, context);
-		if (automation.action.kind === "browser_automation") return this.executeBrowserAutomation(automation, automation.action, signal, hooks, context);
-		if (automation.action.kind === "task_command") {
-			await hooks.onRunPatch?.({ currentPhase: "action" });
-			const execute = this.deps.executeTaskCommand;
-			if (!execute) return {
-				status: "failed",
-				error: "Task command executor is unavailable"
-			};
-			const result = execute({
-				taskId: automation.action.taskId,
-				idempotencyKey: `automation:${automation.id}:${run.id}`,
-				command: automation.action.command,
-				...context.triggerEvent ? { triggerEvent: context.triggerEvent } : {}
-			});
-			return result.ok ? {
-				status: "succeeded",
-				summary: result.runId ? `TaskRun ${result.runId} queued` : "Task command applied"
-			} : {
-				status: "failed",
-				error: result.reason ?? "Task command failed"
-			};
-		}
-		if (automation.action.kind === "system") {
-			await hooks.onRunPatch?.({ currentPhase: "action" });
-			const execute = this.deps.executeSystemAction;
-			if (!execute) return {
-				status: "failed",
-				error: "System action executor is unavailable"
-			};
-			return {
-				status: "succeeded",
-				summary: (await execute({
-					capability: automation.action.capability,
-					automationId: automation.id,
-					runId: run.id
-				})).summary ?? "System action completed"
-			};
-		}
-		return this.executeAgent(automation, automation.action, run, signal, hooks, deadlineAtMs, context);
+		const registration = this.handlers.get(automation.action.kind);
+		if (!registration) return {
+			status: "failed",
+			error: `Automation executor is unavailable: ${automation.action.kind}`
+		};
+		return registration.handler({
+			automation,
+			run,
+			signal,
+			hooks,
+			deadlineAtMs,
+			context
+		});
+	}
+	async executeTaskCommand(input, action) {
+		await input.hooks.onRunPatch?.({ currentPhase: "action" });
+		const execute = this.deps.executeTaskCommand;
+		if (!execute) return {
+			status: "failed",
+			error: "Task command executor is unavailable"
+		};
+		const result = execute({
+			taskId: action.taskId,
+			idempotencyKey: `automation:${input.automation.id}:${input.run.id}`,
+			command: action.command,
+			...input.context.triggerEvent ? { triggerEvent: input.context.triggerEvent } : {}
+		});
+		return result.ok ? {
+			status: "succeeded",
+			summary: result.runId ? `TaskRun ${result.runId} queued` : "Task command applied"
+		} : {
+			status: "failed",
+			error: result.reason ?? "Task command failed"
+		};
+	}
+	async executeSystemAction(input, action) {
+		await input.hooks.onRunPatch?.({ currentPhase: "action" });
+		const execute = this.deps.executeSystemAction;
+		if (!execute) return {
+			status: "failed",
+			error: "System action executor is unavailable"
+		};
+		return {
+			status: "succeeded",
+			summary: (await execute({
+				capability: action.capability,
+				automationId: input.automation.id,
+				runId: input.run.id
+			})).summary ?? "System action completed"
+		};
 	}
 	async executeBrowserAutomation(automation, action, signal, hooks, context) {
 		await hooks.onRunPatch?.({ currentPhase: "action" });

package/dist/src/automations/service/automation-service.d.ts

@@ -11,12 +11,15 @@ export declare class AutomationAlreadyExistsError extends Error {
 }
 export declare class AutomationService {
     private readonly executor;
+    private readonly eventDispatcher;
+    private readonly deliveryRouter;
     private timer;
     private stopped;
     private runningScheduler;
     private deps;
     private maxConcurrentRuns;
     private readonly activeRuns;
+    private readonly activeRunTasks;
     private readonly heartbeatTimers;
     private readonly leaseOwner;
     setDeps(deps: AutomationDeps): void;
@@ -49,14 +52,30 @@ export declare class AutomationService {
     resume(id: string): Promise<Automation | null>;
     runNow(id: string): Promise<AutomationRun>;
     rerunFromRun(runId: string): Promise<AutomationRun>;
-    queueRerunAtomically(runId: string): AutomationRun;
+    ingestEvent(event: AutomationEvent, targetAutomationIds?: string[]): import("../index.js").AutomationEventIngestResult;
+    dispatchEvents(): Promise<number>;
+    replayEventAtomically(eventId: string): boolean;
+    retryResultDeliveryAtomically(runId: string, destinationKey: string): boolean;
+    dispatchRecoveryWork(): void;
+    listEventRecords(input?: {
+        type?: string;
+        source?: string;
+        limit?: number;
+    }): import("../index.js").AutomationEventRecord[];
+    listResultDeliveries(input?: {
+        runId?: string;
+        status?: 'pending' | 'delivering' | 'retrying' | 'delivered' | 'dead_letter';
+        limit?: number;
+    }): import("../index.js").AutomationResultDeliveryRecord[];
+    private ingestTargetedTrigger;
+    queueTriggerAtomically(automationId: string, input: AutomationEvent, executionEvent?: AutomationEvent): AutomationRun;
     queueRunAtomically(id: string, opts?: {
         manual: boolean;
         event?: AutomationEvent;
     }): AutomationRun;
     /** Claim before invoking external work; replays never restart running or completed runs. */
     dispatchQueuedRun(runId: string): void;
-    triggerEvent(event: AutomationEvent): Promise<AutomationRun[]>;
+    availableRunSlots(): number;
     listRuns(options?: {
         automationId?: string;
         projectId?: string;
@@ -85,12 +104,10 @@ export declare class AutomationService {
     private recomputeNextRuns;
     private armTimer;
     private onTimer;
-    private startRun;
     private persistQueuedRun;
     private executeRun;
     private recoverInterruptedRuns;
     private waitForRetry;
     private appendRunEvent;
     private finishAutomationRun;
-    private postCompletionWebhook;
 }

package/dist/src/automations/service/automation-service.js

@@ -3,10 +3,15 @@ import { init_logger } from "../../utils/logger.js";
 import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { AutomationSchema, CreateAutomationSchema, UpdateAutomationSchema } from "../domain/validation.js";
 import { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations } from "../storage/automation-repository.js";
-import { appendAutomationRunEvent, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "../storage/automation-run-repository.js";
+import { appendAutomationRunEvent, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "../storage/automation-run-repository.js";
 import "../storage/index.js";
+import { getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, markAutomationEventDeliveryQueued, replayAutomationEvent } from "../events/event-repository.js";
 import { computeNextAutomationRunAtMs, timerDelayUntil } from "../domain/schedule.js";
 import { AutomationActionExecutor } from "./action-executor.js";
+import { AutomationEventDispatcher } from "../events/event-dispatcher.js";
+import "../events/index.js";
+import { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery } from "../delivery/delivery-router.js";
+import "../delivery/index.js";
 import { randomUUID } from "node:crypto";
 //#region src/automations/service/automation-service.ts
 init_logger();
@@ -17,12 +22,6 @@ const MISSED_RUN_STAGGER_MS = 5e3;
 const RUN_HEARTBEAT_INTERVAL_MS = 1e4;
 const RUN_LEASE_DURATION_MS = 3e4;
 const RETRY_BASE_DELAY_MS = 1e3;
-var AutomationDeadlineExceededError = class extends Error {
-	constructor() {
-		super("Automation deadline exceeded while calling the completion webhook");
-		this.name = "AutomationDeadlineExceededError";
-	}
-};
 var AutomationAlreadyRunningError = class extends Error {
 	constructor(automationId, runningRunId) {
 		super(`Automation is already running: ${automationId}`);
@@ -40,12 +39,21 @@ var AutomationAlreadyExistsError = class extends Error {
 };
 var AutomationService = class {
 	executor = new AutomationActionExecutor();
+	eventDispatcher = new AutomationEventDispatcher(this, {
+		onEvent: (event, signal) => this.deps.onEvent?.(event, signal),
+		onDeadLetter: (input) => this.deps.onReliabilityAttention?.(input)
+	});
+	deliveryRouter = new AutomationDeliveryRouter({
+		deliverGatewayEvent: (run, context) => this.deps.onRunCompleted?.(run, context),
+		onDeadLetter: (input) => this.deps.onReliabilityAttention?.(input)
+	});
 	timer = null;
 	stopped = true;
 	runningScheduler = false;
 	deps = {};
 	maxConcurrentRuns = DEFAULT_MAX_CONCURRENT_RUNS;
 	activeRuns = /* @__PURE__ */ new Map();
+	activeRunTasks = /* @__PURE__ */ new Map();
 	heartbeatTimers = /* @__PURE__ */ new Map();
 	leaseOwner = `automation-service:${process.pid}:${randomUUID()}`;
 	setDeps(deps) {
@@ -59,8 +67,11 @@ var AutomationService = class {
 		this.maxConcurrentRuns = Math.max(1, Math.floor(options?.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS));
 		this.stopped = false;
 		await this.recoverInterruptedRuns();
+		pruneAutomationHistory();
 		await this.recomputeNextRuns({ catchUp: true });
 		this.armTimer();
+		this.eventDispatcher.start();
+		this.deliveryRouter.start();
 		log.info("Automation service initialized");
 	}
 	async stop() {
@@ -69,9 +80,10 @@ var AutomationService = class {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
-		for (const controller of this.activeRuns.values()) controller.abort();
-		for (const timer of this.heartbeatTimers.values()) clearInterval(timer);
-		this.heartbeatTimers.clear();
+		await this.eventDispatcher.stop();
+		for (const controller of this.activeRuns.values()) controller.abort(/* @__PURE__ */ new Error("Automation service stopped"));
+		await Promise.allSettled(this.activeRunTasks.values());
+		await this.deliveryRouter.stop();
 		log.info("Automation service stopped");
 	}
 	async create(input) {
@@ -92,7 +104,13 @@ var AutomationService = class {
 			enabled: parsed.enabled ?? true,
 			safety: parsed.safety ?? { mode: "auto_apply" },
 			conversationMode: parsed.conversationMode ?? "new_session",
-			notificationPolicy: parsed.notificationPolicy ?? "attention",
+			delivery: parsed.delivery ?? {
+				notificationPolicy: "attention",
+				destinations: [{
+					key: "gateway_event",
+					kind: "gateway_event"
+				}]
+			},
 			state: parsed.state ?? {},
 			createdAtMs: now,
 			updatedAtMs: now
@@ -188,24 +206,80 @@ var AutomationService = class {
 		return this.update(id, { enabled: true });
 	}
 	async runNow(id) {
-		const run = this.queueRunAtomically(id);
+		return this.ingestTargetedTrigger(id, {
+			type: "automation.manual.requested",
+			source: "user",
+			trust: "user",
+			payload: { automationId: id }
+		});
+	}
+	async rerunFromRun(runId) {
+		const previous = getAutomationRun(runId);
+		if (!previous) throw new Error(`Automation run not found: ${runId}`);
+		const request = {
+			type: "automation.rerun.requested",
+			source: "user",
+			trust: "user",
+			payload: {
+				automationId: previous.automationId,
+				previousRunId: runId
+			}
+		};
+		const run = this.queueTriggerAtomically(previous.automationId, request, getAutomationEventForRun(runId) ?? request);
 		this.dispatchQueuedRun(run.id);
 		return run;
 	}
-	async rerunFromRun(runId) {
-		const run = this.queueRerunAtomically(runId);
+	ingestEvent(event, targetAutomationIds) {
+		const result = ingestAutomationEvent(event, targetAutomationIds ? { targetAutomationIds } : void 0);
+		this.eventDispatcher.dispatch();
+		return result;
+	}
+	dispatchEvents() {
+		return this.eventDispatcher.dispatch();
+	}
+	replayEventAtomically(eventId) {
+		return replayAutomationEvent(eventId);
+	}
+	retryResultDeliveryAtomically(runId, destinationKey) {
+		return retryAutomationResultDelivery(runId, destinationKey);
+	}
+	dispatchRecoveryWork() {
+		this.eventDispatcher.dispatch();
+		this.deliveryRouter.dispatch();
+	}
+	listEventRecords(input) {
+		return listAutomationEventRecords(input);
+	}
+	listResultDeliveries(input) {
+		return listAutomationResultDeliveries(input);
+	}
+	async ingestTargetedTrigger(automationId, event) {
+		const run = this.queueTriggerAtomically(automationId, event);
 		this.dispatchQueuedRun(run.id);
 		return run;
 	}
-	queueRerunAtomically(runId) {
+	queueTriggerAtomically(automationId, input, executionEvent = input) {
 		return runSqliteWriteTransaction(() => {
-			const previous = getAutomationRun(runId);
-			if (!previous) throw new Error(`Automation run not found: ${runId}`);
-			const event = listAutomationRunEvents(runId).map(readAutomationEventFromRunEvent).find((item) => item !== null);
-			return this.queueRunAtomically(previous.automationId, event ? {
-				manual: false,
-				event
-			} : { manual: true });
+			const eventId = input.id?.trim() || randomUUID();
+			const result = ingestAutomationEvent({
+				...input,
+				id: eventId,
+				subject: input.subject ?? {
+					kind: "automation",
+					id: automationId
+				},
+				correlationId: input.correlationId ?? eventId
+			}, { targetAutomationIds: [automationId] });
+			const existingRunId = getAutomationEventDeliveryRunId(result.event.id, automationId);
+			const existingRun = existingRunId ? getAutomationRun(existingRunId) : null;
+			if (existingRun) return existingRun;
+			const manual = result.event.type === "automation.manual.requested" || result.event.type === "automation.rerun.requested";
+			const run = this.queueRunAtomically(automationId, {
+				manual,
+				event: executionEvent
+			});
+			markAutomationEventDeliveryQueued(result.event.id, automationId, run.id);
+			return run;
 		});
 	}
 	queueRunAtomically(id, opts = { manual: true }) {
@@ -242,26 +316,18 @@ var AutomationService = class {
 			};
 		});
 		if (!claimed) return;
-		this.executeRun(claimed.automation, claimed.run).catch((err) => {
+		const task = this.executeRun(claimed.automation, claimed.run).catch((err) => {
 			log.error({
 				err,
 				runId
 			}, "Queued automation run failed");
+		}).finally(() => {
+			this.activeRunTasks.delete(runId);
 		});
+		this.activeRunTasks.set(runId, task);
 	}
-	async triggerEvent(event) {
-		const normalized = {
-			...event,
-			occurredAtMs: event.occurredAtMs ?? Date.now()
-		};
-		const automations = listAutomations().filter((automation) => automation.enabled && automation.trigger.kind === "event" && !automation.state.runningRunId && matchesAutomationEvent(automation.trigger, normalized));
-		const availableSlots = Math.max(0, this.maxConcurrentRuns - this.activeRuns.size);
-		const started = [];
-		for (const automation of automations.slice(0, availableSlots)) started.push(await this.startRun(automation, {
-			manual: false,
-			event: normalized
-		}));
-		return started;
+	availableRunSlots() {
+		return Math.max(0, this.maxConcurrentRuns - this.activeRuns.size);
 	}
 	async listRuns(options) {
 		return listAutomationRuns(options);
@@ -288,6 +354,8 @@ var AutomationService = class {
 	}
 	dispatchCancellation(runId) {
 		this.activeRuns.get(runId)?.abort(/* @__PURE__ */ new Error("Automation run was cancelled by the user"));
+		const run = getAutomationRun(runId);
+		if (run?.status === "cancelled") this.eventDispatcher.runCompleted(run);
 		this.refreshSchedule();
 	}
 	cancelRunAtomically(runId) {
@@ -336,6 +404,8 @@ var AutomationService = class {
 			this.appendRunEvent(cancelled, "run.cancel_confirmed", "Queued automation cancelled before execution");
 			this.appendRunEvent(cancelled, "run.completed", "Automation run cancelled", { status: "cancelled" });
 			this.finishAutomationRun(current.automationId, runId, "cancelled", void 0, now);
+			const automation = getAutomation(current.automationId);
+			if (automation) this.deliveryRouter.enqueue(cancelled, automation);
 			return {
 				cancelled: true,
 				confirmed: true
@@ -347,6 +417,8 @@ var AutomationService = class {
 		const enabled = automations.filter((automation) => automation.enabled);
 		const next = enabled.filter((automation) => automation.state.nextRunAtMs != null).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
 		const oneHourAgo = Date.now() - 60 * 6e4;
+		const eventMetrics = getAutomationEventQueueMetrics();
+		const deliveryMetrics = getAutomationResultDeliveryMetrics();
 		return {
 			totalAutomations: automations.length,
 			enabledAutomations: enabled.length,
@@ -356,7 +428,16 @@ var AutomationService = class {
 				automationId: next.id,
 				name: next.name,
 				runAtMs: next.state.nextRunAtMs
-			} : void 0
+			} : void 0,
+			pendingEvents: eventMetrics.pending,
+			oldestPendingEventAgeMs: eventMetrics.oldestPendingAgeMs,
+			projectionDeadLetters: eventMetrics.projectionDeadLetters,
+			pendingRunDeliveries: eventMetrics.pendingDeliveries,
+			runDeliveryDeadLetters: eventMetrics.deliveryDeadLetters,
+			pendingResultDeliveries: deliveryMetrics.pending,
+			resultDeliveryDeadLetters: deliveryMetrics.deadLetters,
+			activeExecutions: this.activeRuns.size,
+			activeDeliveryLeases: eventMetrics.activeLeases + deliveryMetrics.activeLeases
 		};
 	}
 	async recomputeNextRuns(options) {
@@ -400,17 +481,28 @@ var AutomationService = class {
 		try {
 			const now = Date.now();
 			const due = listAutomations().filter((automation) => automation.enabled && automation.trigger.kind === "schedule" && automation.state.nextRunAtMs != null && automation.state.nextRunAtMs <= now && !automation.state.runningRunId).slice(0, this.maxConcurrentRuns);
-			await Promise.all(due.map((automation) => this.startRun(automation, { manual: false })));
+			await Promise.all(due.map((automation) => this.ingestTargetedTrigger(automation.id, {
+				id: `schedule:${automation.id}:${automation.state.nextRunAtMs}`,
+				type: "automation.schedule.due",
+				source: "scheduler",
+				subject: {
+					kind: "automation",
+					id: automation.id
+				},
+				correlationId: `schedule:${automation.id}:${automation.state.nextRunAtMs}`,
+				dedupeKey: `${automation.id}:${automation.state.nextRunAtMs}`,
+				trust: "system",
+				payload: {
+					automationId: automation.id,
+					dueAtMs: automation.state.nextRunAtMs
+				},
+				occurredAtMs: automation.state.nextRunAtMs
+			})));
 		} finally {
 			this.runningScheduler = false;
 			this.armTimer();
 		}
 	}
-	async startRun(automation, opts) {
-		const run = this.queueRunAtomically(automation.id, opts);
-		this.dispatchQueuedRun(run.id);
-		return run;
-	}
 	persistQueuedRun(automation, opts) {
 		const now = Date.now();
 		const run = {
@@ -420,7 +512,7 @@ var AutomationService = class {
 			status: "queued",
 			triggerSnapshot: automation.trigger,
 			actionSnapshot: automation.action,
-			manual: opts.manual,
+			manual: opts.manual || opts.event?.type === "automation.manual.requested" || opts.event?.type === "automation.rerun.requested",
 			createdAtMs: now,
 			attemptNumber: 1
 		};
@@ -465,7 +557,7 @@ var AutomationService = class {
 		this.heartbeatTimers.set(run.id, heartbeat);
 		let status = "failed";
 		let error;
-		let activePhase = "action";
+		let artifacts;
 		const triggerEvent = listAutomationRunEvents(run.id).map(readAutomationEventFromRunEvent).find((item) => item !== null);
 		try {
 			const maxAttempts = Math.max(1, (automation.reliability?.retryCount ?? 0) + 1);
@@ -494,7 +586,7 @@ var AutomationService = class {
 						timeoutMs: patch.deadlineAtMs - startedAtMs
 					});
 				} }, { triggerEvent });
-				if (!(task.status === "failed") || attempt >= maxAttempts || controller.signal.aborted) break;
+				if (!(task.status === "failed" && this.executor.canRetry(automation.action.kind, task.error)) || attempt >= maxAttempts || controller.signal.aborted) break;
 				const delayMs = Math.min(RETRY_BASE_DELAY_MS * 2 ** (attempt - 1), 3e4);
 				this.appendRunEvent(run, "action.retry_scheduled", "Automation action retry scheduled", {
 					attempt,
@@ -506,8 +598,10 @@ var AutomationService = class {
 				});
 				await this.waitForRetry(delayMs, controller.signal);
 			}
+			this.deliveryRouter.validateArtifacts(task.artifacts ?? []);
 			status = task.status;
 			error = task.error;
+			artifacts = task.artifacts;
 			const persistedRun = getAutomationRun(run.id);
 			if (persistedRun) run = {
 				...run,
@@ -547,18 +641,6 @@ var AutomationService = class {
 				};
 				this.appendRunEvent(run, task.termination.cancellationConfirmed ? "run.cancel_confirmed" : "run.cancellation_unconfirmed", task.termination.cancellationConfirmed ? "Automation cancellation confirmed" : "Automation cancellation was not confirmed within the cleanup grace period", { termination: task.termination });
 			}
-			if (controller.signal.aborted || status === "timeout" || status === "cancelled") {} else if ((automation.safety?.mode ?? "auto_apply") !== "auto_apply" && automation.completionWebhookUrl) this.appendRunEvent(run, "completion_hook.completed", "Completion webhook skipped by safety mode", { safety: automation.safety ?? { mode: "auto_apply" } });
-			else if (automation.completionWebhookUrl) {
-				activePhase = "completion_hook";
-				run = {
-					...run,
-					currentPhase: "completion_hook"
-				};
-				saveAutomationRun(run);
-				this.appendRunEvent(run, "completion_hook.started", "Calling completion webhook", { url: automation.completionWebhookUrl });
-				await this.postCompletionWebhook(automation.completionWebhookUrl, run, controller.signal);
-				this.appendRunEvent(run, "completion_hook.completed", "Completion webhook completed");
-			}
 		} catch (err) {
 			const persistedRun = getAutomationRun(run.id);
 			if (persistedRun) run = {
@@ -566,16 +648,16 @@ var AutomationService = class {
 				...persistedRun
 			};
 			error = err instanceof Error ? err.message : String(err);
-			const deadlineExceeded = err instanceof AutomationDeadlineExceededError || run.deadlineAtMs !== void 0 && Date.now() >= run.deadlineAtMs;
+			const deadlineExceeded = run.deadlineAtMs !== void 0 && Date.now() >= run.deadlineAtMs;
 			status = controller.signal.aborted ? "cancelled" : deadlineExceeded ? "timeout" : "failed";
-			this.appendRunEvent(run, activePhase === "completion_hook" ? "completion_hook.failed" : "action.failed", `Automation run ${status}`, { error });
+			this.appendRunEvent(run, "action.failed", `Automation run ${status}`, { error });
 			run = {
 				...run,
 				status,
 				error,
 				termination: {
 					reason: status === "cancelled" ? "user_cancelled" : status === "timeout" ? "deadline_exceeded" : "failed",
-					component: activePhase === "completion_hook" ? "automation" : run.termination?.component,
+					component: run.termination?.component,
 					cancellationConfirmed: status !== "cancelled" || controller.signal.aborted
 				}
 			};
@@ -606,17 +688,11 @@ var AutomationService = class {
 					error
 				});
 				this.finishAutomationRun(automation.id, run.id, status, error, endedAtMs);
+				this.deliveryRouter.enqueue(run, automation, artifacts);
 			});
 			this.refreshSchedule();
-			try {
-				this.deps.onRunCompleted?.(run);
-			} catch (err) {
-				log.warn({
-					err,
-					automationId: automation.id,
-					runId: run.id
-				}, "Automation completion hook failed");
-			}
+			this.eventDispatcher.runCompleted(run);
+			this.deliveryRouter.dispatch();
 		}
 	}
 	async recoverInterruptedRuns() {
@@ -656,7 +732,10 @@ var AutomationService = class {
 				status,
 				error
 			});
-			if (automation) this.finishAutomationRun(automation.id, run.id, status, error, now);
+			if (automation) {
+				this.finishAutomationRun(automation.id, run.id, status, error, now);
+				this.deliveryRouter.enqueue(recovered, automation);
+			}
 		}
 	}
 	waitForRetry(delayMs, signal) {
@@ -706,36 +785,7 @@ var AutomationService = class {
 		next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, finishedAtMs);
 		saveAutomation(next);
 	}
-	async postCompletionWebhook(url, run, signal) {
-		const remainingMs = run.deadlineAtMs === void 0 ? 3e4 : Math.max(1, run.deadlineAtMs - Date.now());
-		const deadlineSignal = AbortSignal.timeout(remainingMs);
-		const requestSignal = AbortSignal.any([signal, deadlineSignal]);
-		let response;
-		try {
-			response = await fetch(url, {
-				method: "POST",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({ run }),
-				signal: requestSignal
-			});
-		} catch (err) {
-			if (!signal.aborted && deadlineSignal.aborted) throw new AutomationDeadlineExceededError();
-			throw err;
-		}
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			throw new Error(`Automation webhook failed: HTTP ${response.status}${text ? ` ${text.slice(0, 200)}` : ""}`);
-		}
-	}
 };
-function matchesAutomationEvent(trigger, event) {
-	if (trigger.eventType !== event.type) return false;
-	if (trigger.source && trigger.source !== event.source) return false;
-	const payloadMatch = trigger.payloadMatch;
-	if (!payloadMatch) return true;
-	const payload = event.payload ?? {};
-	return Object.entries(payloadMatch).every(([key, expected]) => Object.is(payload[key], expected));
-}
 function readAutomationEventFromRunEvent(event) {
 	if (!event.data || typeof event.data !== "object" || Array.isArray(event.data)) return null;
 	const raw = event.data.event;

package/dist/src/automations/storage/automation-repository.js

@@ -20,8 +20,7 @@ function rowToAutomation(row) {
 		action: parseJson(row.action_json),
 		safety: parseJson(row.safety_json) ?? { mode: "auto_apply" },
 		conversationMode: row.conversation_mode,
-		notificationPolicy: row.notification_policy,
-		completionWebhookUrl: row.completion_webhook_url ?? void 0,
+		delivery: parseJson(row.delivery_json),
 		reliability: parseJson(row.reliability_json),
 		management: parseJson(row.management_json),
 		state: parseJson(row.state_json) ?? {},
@@ -32,13 +31,13 @@ function rowToAutomation(row) {
 function upsertAutomation(db, automation) {
 	db.prepare(`INSERT OR REPLACE INTO automations (
       automation_id, name, description, project_id, enabled, trigger_json, action_json,
-      safety_json, conversation_mode, notification_policy, completion_webhook_url,
+      safety_json, conversation_mode, delivery_json,
       reliability_json, management_json, state_json, created_at_ms, updated_at_ms
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(automation.id, automation.name, automation.description ?? null, automation.projectId ?? null, automation.enabled ? 1 : 0, JSON.stringify(automation.trigger), JSON.stringify(automation.action), bindJson(automation.safety ?? { mode: "auto_apply" }), automation.conversationMode, automation.notificationPolicy, automation.completionWebhookUrl ?? null, bindJson(automation.reliability), bindJson(automation.management), JSON.stringify(automation.state ?? {}), automation.createdAtMs, automation.updatedAtMs);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(automation.id, automation.name, automation.description ?? null, automation.projectId ?? null, automation.enabled ? 1 : 0, JSON.stringify(automation.trigger), JSON.stringify(automation.action), bindJson(automation.safety ?? { mode: "auto_apply" }), automation.conversationMode, bindJson(automation.delivery), bindJson(automation.reliability), bindJson(automation.management), JSON.stringify(automation.state ?? {}), automation.createdAtMs, automation.updatedAtMs);
 }
 const AUTOMATION_SELECT = `
   SELECT automation_id, name, description, project_id, enabled, trigger_json, action_json,
-         safety_json, conversation_mode, notification_policy, completion_webhook_url,
+         safety_json, conversation_mode, delivery_json,
          reliability_json, management_json, state_json, created_at_ms, updated_at_ms
   FROM automations
 `;

package/dist/src/automations/storage/automation-run-repository.d.ts

@@ -20,6 +20,7 @@ export declare function listAutomationRunsForProductEvent(options: {
     limit?: number;
 }): AutomationProductEventRun[];
 export declare function deleteAutomationRunsForAutomation(automationId: string): void;
+export declare function pruneAutomationHistory(cutoffMs?: number): number;
 export declare function markAutomationRunRead(runId: string, readAtMs?: number): boolean;
 export declare function markAllAutomationRunsRead(options?: {
     projectId?: string;