@xopcai/xopc 0.0.331 → 0.0.333

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,9 +20,9 @@ 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) ?? {},
 		createdAtMs: row.created_at_ms,
 		updatedAtMs: row.updated_at_ms
@@ -31,14 +31,14 @@ 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,
-      reliability_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), JSON.stringify(automation.state ?? {}), automation.createdAtMs, automation.updatedAtMs);
+      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, 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,
-         reliability_json, state_json, created_at_ms, updated_at_ms
+         safety_json, conversation_mode, delivery_json,
+         reliability_json, management_json, state_json, created_at_ms, updated_at_ms
   FROM automations
 `;
 function listAutomations(options) {

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;

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

@@ -50,8 +50,15 @@ function trimRuns(db, automationId) {
 	const countRow = db.prepare(`SELECT COUNT(*) AS count FROM automation_runs WHERE automation_id = ?`).get(automationId);
 	if (countRow.count <= MAX_RUNS_PER_AUTOMATION) return;
 	const staleRunIds = db.prepare(`SELECT run_id FROM automation_runs WHERE automation_id = ? AND status NOT IN ('queued', 'running', 'cancelling')
+       AND NOT EXISTS (
+         SELECT 1 FROM automation_result_deliveries d
+         WHERE d.run_id = automation_runs.run_id AND d.status <> 'delivered'
+       )
        ORDER BY created_at_ms ASC LIMIT ?`).all(automationId, countRow.count - TRIM_TO_RUNS);
 	for (const { run_id: runId } of staleRunIds) {
+		db.prepare("DELETE FROM automation_event_deliveries WHERE run_id = ?").run(runId);
+		db.prepare("DELETE FROM automation_result_deliveries WHERE run_id = ?").run(runId);
+		db.prepare("DELETE FROM automation_results WHERE run_id = ?").run(runId);
 		db.prepare("DELETE FROM automation_run_requests WHERE run_id = ?").run(runId);
 		db.prepare(`DELETE FROM automation_run_events WHERE run_id = ?`).run(runId);
 		db.prepare(`DELETE FROM automation_runs WHERE run_id = ?`).run(runId);
@@ -175,11 +182,29 @@ function listAutomationRunsForProductEvent(options) {
 }
 function deleteAutomationRunsForAutomation(automationId) {
 	runSqliteWriteTransaction((db) => {
+		db.prepare(`DELETE FROM automation_event_deliveries
+      WHERE run_id IN (SELECT run_id FROM automation_runs WHERE automation_id = ?)`).run(automationId);
+		db.prepare(`DELETE FROM automation_result_deliveries
+      WHERE run_id IN (SELECT run_id FROM automation_runs WHERE automation_id = ?)`).run(automationId);
+		db.prepare(`DELETE FROM automation_results
+      WHERE run_id IN (SELECT run_id FROM automation_runs WHERE automation_id = ?)`).run(automationId);
 		db.prepare("DELETE FROM automation_run_requests WHERE run_id IN (SELECT run_id FROM automation_runs WHERE automation_id = ?)").run(automationId);
 		db.prepare(`DELETE FROM automation_run_events WHERE automation_id = ?`).run(automationId);
 		db.prepare(`DELETE FROM automation_runs WHERE automation_id = ?`).run(automationId);
 	});
 }
+function pruneAutomationHistory(cutoffMs = Date.now() - 720 * 60 * 6e4) {
+	return runSqliteWriteTransaction((db) => {
+		const result = db.prepare(`DELETE FROM automation_events
+      WHERE projection_status = 'projected' AND projected_at_ms < ?
+        AND NOT EXISTS (
+          SELECT 1 FROM automation_event_deliveries d
+          WHERE d.event_id = automation_events.event_id
+            AND d.status IN ('pending', 'retrying', 'queued', 'dead_letter')
+        )`).run(cutoffMs);
+		return Number(result.changes);
+	});
+}
 function markAutomationRunRead(runId, readAtMs = Date.now()) {
 	return getSqliteDatabase().prepare(`UPDATE automation_runs SET read_at_ms = COALESCE(read_at_ms, ?) WHERE run_id = ? AND ended_at_ms IS NOT NULL`).run(readAtMs, runId).changes > 0;
 }
@@ -196,4 +221,4 @@ function markAllAutomationRunsRead(options) {
 	return Number(result.changes);
 }
 //#endregion
-export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease };
+export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease };

package/dist/src/automations/storage/index.js

@@ -1,3 +1,3 @@
 import { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations } from "./automation-repository.js";
-import { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "./automation-run-repository.js";
-export { appendAutomationRunEvent, deleteAutomation, deleteAutomationRunsForAutomation, getAutomation, getAutomationRun, getAutomationRunRequest, getDeletedAutomationRevision, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listAutomations, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomation, saveAutomationRun, saveAutomationRunRequest, saveAutomations, touchAutomationRunLease };
+import { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "./automation-run-repository.js";
+export { appendAutomationRunEvent, deleteAutomation, deleteAutomationRunsForAutomation, getAutomation, getAutomationRun, getAutomationRunRequest, getDeletedAutomationRevision, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listAutomations, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomation, saveAutomationRun, saveAutomationRunRequest, saveAutomations, touchAutomationRunLease };

package/dist/src/automations/webhook-secrets.d.ts

@@ -0,0 +1 @@
+export declare function resolveAutomationWebhookSecret(secretId: string): string | undefined;

package/dist/src/automations/webhook-secrets.js

@@ -0,0 +1,16 @@
+//#region src/automations/webhook-secrets.ts
+function resolveAutomationWebhookSecret(secretId) {
+	const raw = process.env.XOPC_AUTOMATION_WEBHOOK_SECRETS?.trim();
+	if (!raw) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("XOPC_AUTOMATION_WEBHOOK_SECRETS must be a JSON object");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("XOPC_AUTOMATION_WEBHOOK_SECRETS must be a JSON object");
+	const value = parsed[secretId];
+	return typeof value === "string" && value.length >= 16 ? value : void 0;
+}
+//#endregion
+export { resolveAutomationWebhookSecret };

package/dist/src/bootstrap/application-state.js

@@ -1,9 +1,9 @@
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { AgentCatalogService } from "../agent-catalog/service.js";
+import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
 import { cutoverLegacyAgentConfig } from "../agent-catalog/migrations/legacy-config-cutover.js";
 import "../agent-catalog/index.js";
-import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 //#region src/bootstrap/application-state.ts
 init_sqlite();

package/dist/src/capabilities/runtime/dispatcher.js

@@ -1,7 +1,7 @@
 import { SqliteCommitEffectError, init_transaction } from "../../storage/sqlite/transaction.js";
-import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { CapabilityError } from "./errors.js";
 import { executeExternalOperation } from "./external-operations.js";
+import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 //#region src/capabilities/runtime/dispatcher.ts

package/dist/src/capabilities/runtime/product.js

@@ -1,6 +1,5 @@
 import { CapabilityError } from "./errors.js";
 import { CapabilityDispatcher } from "./dispatcher.js";
-import { registerAgentCapabilities } from "../../agent-catalog/capabilities.js";
 import { registerLocalAppReadCapabilities } from "../../local-apps/capabilities/read.js";
 import { registerNoteReadCapabilities } from "../../notes/capabilities/read.js";
 import { registerNoteWriteCapabilities } from "../../notes/capabilities/write.js";
@@ -19,6 +18,7 @@ import { registerSceneReadCapabilities } from "../../scenes/capabilities/read.js
 import { registerSceneWriteCapabilities } from "../../scenes/capabilities/write.js";
 import { registerSettingsCapability } from "./settings.js";
 import { registerAppContextCapability } from "./app-context.js";
+import { registerAgentCapabilities } from "../../agent-catalog/capabilities.js";
 //#region src/capabilities/runtime/product.ts
 function createProductDispatcher(getNotes, taskWrites) {
 	const dispatcher = new CapabilityDispatcher();

package/dist/src/capabilities/store-connector.d.ts

@@ -7,10 +7,26 @@ export type StoreConnectorInstallPlan = {
     definition: ConnectorDefinition;
     permissions: ConnectorPermissions;
     requiresRestart: false;
+    reviewHash: string;
 };
+export type StoreConnectorInstallCandidate = {
+    candidateRef: string;
+    source: 'store';
+    packageName: string;
+    version: string;
+    label: string;
+    summary: string;
+    capabilities: string[];
+};
+export declare function storeConnectorCandidateRef(packageName: string, version: string): string;
+export declare function parseStoreConnectorCandidateRef(ref: string): {
+    packageName: string;
+    version: string;
+} | undefined;
+export declare function searchStoreConnectorInstallCandidates(config: Config, query: string, limit?: number): Promise<StoreConnectorInstallCandidate[]>;
 export declare function listStoreConnectors(config: Config, params: SkillsStoreListParams): Promise<import("../agent/skills/skills-marketplace.js").SkillsStoreListResponse>;
 export declare function getStoreConnectorInstallPlan(config: Config, packageName: string, version?: string): Promise<StoreConnectorInstallPlan>;
-export declare function installStoreConnector(config: Config, packageName: string, input: ConnectorInstallInput, version?: string): Promise<{
+export declare function installStoreConnector(config: Config, packageName: string, input: ConnectorInstallInput, version?: string, reviewHash?: string): Promise<{
     instance: import("../connectors/types.js").ConnectorInstance;
     plan: StoreConnectorInstallPlan;
 }>;