@xopcai/xopc 0.0.331 → 0.0.333

package/dist/src/automations/domain/types.d.ts

@@ -54,18 +54,54 @@ export type AutomationAction = {
     kind: 'task_command';
     taskId: string;
     command: TaskCommand;
+} | {
+    kind: 'system';
+    capability: 'home.advisor.refresh' | 'memory.temporal_sweep' | 'memory.daily_reconciliation' | 'memory.weekly_knowledge';
 };
+export type AutomationEditableField = 'enabled' | 'trigger';
+export interface AutomationManagement {
+    owner: string;
+    editable: AutomationEditableField[];
+    runnable: boolean;
+    deletable: boolean;
+}
 export type AutomationConversationMode = 'new_session' | 'continuous';
 export type AutomationNotificationPolicy = 'attention' | 'all' | 'none';
+export type AutomationDeliveryDestination = {
+    key: string;
+    kind: 'gateway_event';
+} | {
+    key: string;
+    kind: 'webhook';
+    endpoint: string;
+    secretId: string;
+} | {
+    key: string;
+    kind: 'file';
+    targetId: string;
+    pathTemplate: string;
+} | {
+    key: string;
+    kind: 'card';
+    channelId: string;
+    templateId: string;
+};
+export interface AutomationDeliveryPolicy {
+    notificationPolicy: AutomationNotificationPolicy;
+    destinations: AutomationDeliveryDestination[];
+}
+export interface AutomationRunDeliveryContext {
+    notificationPolicy: AutomationNotificationPolicy;
+    requiresAttention: boolean;
+    projectId?: string;
+}
 export interface AutomationReliability {
-    /** Overall run deadline. `timeoutSeconds` remains a read-only legacy fallback. */
     executionTimeoutSeconds?: number;
-    timeoutSeconds?: number;
     retryCount?: number;
     maxConcurrentRuns?: number;
     disableAfterConsecutiveFailures?: number;
 }
-export type AutomationRunPhase = 'queued' | 'action' | 'completion_hook' | 'cancelling' | 'completed';
+export type AutomationRunPhase = 'queued' | 'action' | 'cancelling' | 'completed';
 export interface AutomationRunTermination {
     reason: 'completed' | 'failed' | 'user_cancelled' | 'deadline_exceeded';
     component?: 'automation' | 'agent_turn' | 'tool' | 'mcp' | 'process';
@@ -94,9 +130,9 @@ export interface Automation {
     action: AutomationAction;
     safety?: AutomationSafetyPolicy;
     conversationMode: AutomationConversationMode;
-    notificationPolicy: AutomationNotificationPolicy;
-    completionWebhookUrl?: string;
+    delivery: AutomationDeliveryPolicy;
     reliability?: AutomationReliability;
+    management?: AutomationManagement;
     state: AutomationState;
     createdAtMs: number;
     updatedAtMs: number;
@@ -131,7 +167,7 @@ export interface AutomationRun {
     rootRunId?: string;
     readAtMs?: number;
 }
-export type AutomationRunEventType = 'run.queued' | 'run.started' | 'run.deadline_resolved' | 'run.cancel_requested' | 'run.cancel_confirmed' | 'run.cancellation_unconfirmed' | 'run.recovered' | 'action.started' | 'action.retry_scheduled' | 'action.completed' | 'action.failed' | 'completion_hook.started' | 'completion_hook.completed' | 'completion_hook.failed' | 'run.completed';
+export type AutomationRunEventType = 'run.queued' | 'run.started' | 'run.deadline_resolved' | 'run.cancel_requested' | 'run.cancel_confirmed' | 'run.cancellation_unconfirmed' | 'run.recovered' | 'action.started' | 'action.retry_scheduled' | 'action.completed' | 'action.failed' | 'run.completed';
 export interface AutomationRunEvent {
     id: string;
     runId: string;
@@ -146,10 +182,60 @@ export interface AutomationProductEventRun {
     triggerEvent: AutomationRunEvent;
 }
 export interface AutomationEvent {
+    id?: string;
     type: string;
     source?: string;
+    schemaVersion?: number;
+    subject?: {
+        kind: string;
+        id: string;
+    };
     payload?: Record<string, unknown>;
     occurredAtMs?: number;
+    correlationId?: string;
+    causationId?: string;
+    rootEventId?: string;
+    chainDepth?: number;
+    dedupeKey?: string;
+    trust?: 'system' | 'user' | 'connector' | 'untrusted_webhook';
+}
+export interface AutomationEventEnvelope extends AutomationEvent {
+    id: string;
+    source: string;
+    schemaVersion: number;
+    occurredAtMs: number;
+    ingestedAtMs: number;
+    correlationId: string;
+    rootEventId: string;
+    chainDepth: number;
+    trust: 'system' | 'user' | 'connector' | 'untrusted_webhook';
+    payload: Record<string, unknown>;
+}
+export type AutomationEventProjectionStatus = 'pending' | 'projecting' | 'retrying' | 'projected' | 'dead_letter';
+export type AutomationEventDeliveryStatus = 'pending' | 'retrying' | 'queued' | 'completed' | 'failed' | 'cancelled' | 'skipped' | 'dead_letter';
+export interface AutomationEventRecord {
+    event: AutomationEventEnvelope;
+    projectionStatus: AutomationEventProjectionStatus;
+    projectionAttempts: number;
+    projectionError?: string;
+    deliveries: Array<{
+        automationId: string;
+        status: AutomationEventDeliveryStatus;
+        runId?: string;
+        attempts: number;
+        lastError?: string;
+    }>;
+}
+export interface AutomationResultDeliveryRecord {
+    runId: string;
+    destinationKey: string;
+    kind: string;
+    status: 'pending' | 'delivering' | 'retrying' | 'delivered' | 'dead_letter';
+    attempts: number;
+    nextAttemptAtMs: number;
+    lastError?: string;
+    createdAtMs: number;
+    updatedAtMs: number;
 }
 export interface AutomationMetrics {
     totalAutomations: number;
@@ -161,7 +247,73 @@ export interface AutomationMetrics {
         name: string;
         runAtMs: number;
     };
+    pendingEvents: number;
+    oldestPendingEventAgeMs: number;
+    projectionDeadLetters: number;
+    pendingRunDeliveries: number;
+    runDeliveryDeadLetters: number;
+    pendingResultDeliveries: number;
+    resultDeliveryDeadLetters: number;
+    activeExecutions: number;
+    activeDeliveryLeases: number;
+}
+export type AutomationArtifact = {
+    id: string;
+    kind: 'text';
+    text: string;
+    mediaType: 'text/plain' | 'text/markdown';
+} | {
+    id: string;
+    kind: 'json';
+    schema: string;
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    kind: 'file';
+    uri: string;
+    name: string;
+    mediaType: string;
+    bytes?: number;
+    sha256?: string;
+} | {
+    id: string;
+    kind: 'card';
+    schema: string;
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    kind: 'reference';
+    resourceType: string;
+    resourceId: string;
+    url?: string;
+};
+export interface AutomationResultEnvelope {
+    schemaVersion: 1;
+    resultId: string;
+    runId: string;
+    automationId: string;
+    status: Extract<AutomationRunStatus, 'succeeded' | 'failed' | 'cancelled' | 'timeout'>;
+    summary?: string;
+    error?: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+    artifacts: AutomationArtifact[];
+    correlationId: string;
+    rootEventId: string;
+    createdAtMs: number;
+    completedAtMs: number;
 }
+export type AutomationRetrySafety = {
+    mode: 'never';
+} | {
+    mode: 'idempotent';
+    key: 'run_id';
+} | {
+    mode: 'transient_only';
+    classify: (error: unknown) => boolean;
+};
 export interface PrepareAutomationAgentSessionInput {
     automationName?: string;
     conversationId: string;
@@ -199,7 +351,16 @@ export interface AutomationDeps {
             error?: string;
         }>;
     };
-    onRunCompleted?: (run: AutomationRun) => void;
+    onRunCompleted?: (run: AutomationRun, context: AutomationRunDeliveryContext) => void | Promise<void>;
+    onEvent?: (event: AutomationEventEnvelope, signal?: AbortSignal) => void | Promise<void>;
+    onReliabilityAttention?: (input: {
+        phase: 'event_projection' | 'event_delivery' | 'result_delivery';
+        eventId?: string;
+        automationId?: string;
+        runId?: string;
+        destinationKey?: string;
+        error: string;
+    }) => void;
     executeTaskCommand?: (input: {
         taskId: string;
         idempotencyKey: string;
@@ -210,6 +371,17 @@ export interface AutomationDeps {
         reason?: string;
         runId?: string;
     };
+    executeSystemAction?: (input: {
+        capability: Extract<AutomationAction, {
+            kind: 'system';
+        }>['capability'];
+        automationId: string;
+        runId: string;
+    }) => Promise<{
+        summary?: string;
+    }> | {
+        summary?: string;
+    };
 }
 export interface AutomationActionTask {
     status: 'succeeded' | 'failed' | 'timeout' | 'cancelled';
@@ -220,6 +392,7 @@ export interface AutomationActionTask {
     model?: string;
     deadlineAtMs?: number;
     termination?: AutomationRunTermination;
+    artifacts?: AutomationArtifact[];
 }
 export interface AutomationActionExecutionHooks {
     onRunPatch?: (patch: Partial<AutomationRun>) => void | Promise<void>;

package/dist/src/automations/domain/validation.d.ts

@@ -151,10 +151,26 @@ export declare const AutomationActionSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
             outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
     }, z.core.$strip>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"system">;
+    capability: z.ZodEnum<{
+        "home.advisor.refresh": "home.advisor.refresh";
+        "memory.temporal_sweep": "memory.temporal_sweep";
+        "memory.daily_reconciliation": "memory.daily_reconciliation";
+        "memory.weekly_knowledge": "memory.weekly_knowledge";
+    }>;
 }, z.core.$strict>], "kind">;
+export declare const AutomationManagementSchema: z.ZodObject<{
+    owner: z.ZodString;
+    editable: z.ZodArray<z.ZodEnum<{
+        enabled: "enabled";
+        trigger: "trigger";
+    }>>;
+    runnable: z.ZodBoolean;
+    deletable: z.ZodBoolean;
+}, z.core.$strict>;
 export declare const AutomationReliabilitySchema: z.ZodObject<{
     executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     retryCount: z.ZodOptional<z.ZodNumber>;
     maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
     disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
@@ -166,6 +182,32 @@ export declare const AutomationSafetyPolicySchema: z.ZodObject<{
         auto_apply: "auto_apply";
     }>;
 }, z.core.$strict>;
+export declare const AutomationDeliveryPolicySchema: z.ZodObject<{
+    notificationPolicy: z.ZodDefault<z.ZodEnum<{
+        attention: "attention";
+        all: "all";
+        none: "none";
+    }>>;
+    destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"gateway_event">;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"webhook">;
+        endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        secretId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"file">;
+        targetId: z.ZodString;
+        pathTemplate: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"card">;
+        channelId: z.ZodString;
+        templateId: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
 export declare const AutomationStateSchema: z.ZodObject<{
     nextRunAtMs: z.ZodOptional<z.ZodNumber>;
     runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
@@ -328,6 +370,14 @@ export declare const AutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">;
     safety: z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
@@ -340,19 +390,47 @@ export declare const AutomationSchema: z.ZodObject<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodDefault<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
-    completionWebhookUrl: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    delivery: z.ZodDefault<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>;
     reliability: z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    management: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>;
     state: z.ZodDefault<z.ZodObject<{
         nextRunAtMs: z.ZodOptional<z.ZodNumber>;
         runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
@@ -490,6 +568,14 @@ export declare const CreateAutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">;
     trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"manual">;
@@ -528,19 +614,47 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodDefault<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
-    completionWebhookUrl: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    delivery: z.ZodDefault<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>;
     reliability: z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    management: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>;
     id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     state: z.ZodOptional<z.ZodObject<{
@@ -679,6 +793,14 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"manual">;
@@ -713,23 +835,51 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
             auto_apply: "auto_apply";
         }>;
     }, z.core.$strict>>>;
-    completionWebhookUrl: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>>;
     reliability: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         retryCount: z.ZodOptional<z.ZodNumber>;
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
+    management: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>>;
     conversationMode: z.ZodOptional<z.ZodEnum<{
         new_session: "new_session";
         continuous: "continuous";
     }>>;
-    notificationPolicy: z.ZodOptional<z.ZodEnum<{
-        attention: "attention";
-        all: "all";
-        none: "none";
-    }>>;
+    delivery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        notificationPolicy: z.ZodDefault<z.ZodEnum<{
+            attention: "attention";
+            all: "all";
+            none: "none";
+        }>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"gateway_event">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"webhook">;
+            endpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            secretId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            targetId: z.ZodString;
+            pathTemplate: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"card">;
+            channelId: z.ZodString;
+            templateId: z.ZodString;
+        }, z.core.$strict>], "kind">>>;
+    }, z.core.$strict>>>;
     state: z.ZodOptional<z.ZodObject<{
         nextRunAtMs: z.ZodOptional<z.ZodNumber>;
         runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;

package/dist/src/automations/domain/validation.js

@@ -6,6 +6,19 @@ import { CronExpressionParser } from "cron-parser";
 init_src();
 const nonEmptyString = z.string().trim().min(1);
 const optionalTrimmedString = (max) => z.string().trim().max(max).nullish().transform((value) => value || void 0);
+const httpsUrl = z.string().trim().min(1).max(2e3).transform((value, ctx) => {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "https:") throw new Error("unsupported protocol");
+		return parsed.toString();
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Webhook endpoint must be a valid HTTPS URL"
+		});
+		return z.NEVER;
+	}
+});
 const AutomationScheduleSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("once"),
@@ -89,11 +102,25 @@ const AutomationActionSchema = z.discriminatedUnion("kind", [
 		kind: z.literal("task_command"),
 		taskId: nonEmptyString.max(200),
 		command: TaskCommandSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("system"),
+		capability: z.enum([
+			"home.advisor.refresh",
+			"memory.temporal_sweep",
+			"memory.daily_reconciliation",
+			"memory.weekly_knowledge"
+		])
 	}).strict()
 ]);
+const AutomationManagementSchema = z.object({
+	owner: nonEmptyString.max(100),
+	editable: z.array(z.enum(["enabled", "trigger"])).max(2),
+	runnable: z.boolean(),
+	deletable: z.boolean()
+}).strict();
 const AutomationReliabilitySchema = z.object({
 	executionTimeoutSeconds: z.number().int().min(1).max(86400).optional(),
-	timeoutSeconds: z.number().int().min(1).max(86400).optional(),
 	retryCount: z.number().int().min(0).max(10).optional(),
 	maxConcurrentRuns: z.number().int().min(1).max(20).optional(),
 	disableAfterConsecutiveFailures: z.number().int().min(1).max(100).optional()
@@ -103,6 +130,50 @@ const AutomationSafetyPolicySchema = z.object({ mode: z.enum([
 	"ask_before_apply",
 	"auto_apply"
 ]) }).strict();
+const AutomationDeliveryPolicySchema = z.object({
+	notificationPolicy: z.enum([
+		"attention",
+		"all",
+		"none"
+	]).default("attention"),
+	destinations: z.array(z.discriminatedUnion("kind", [
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("gateway_event")
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("webhook"),
+			endpoint: httpsUrl,
+			secretId: nonEmptyString.max(200)
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("file"),
+			targetId: nonEmptyString.max(200),
+			pathTemplate: nonEmptyString.max(2e3)
+		}).strict(),
+		z.object({
+			key: nonEmptyString.max(100),
+			kind: z.literal("card"),
+			channelId: nonEmptyString.max(200),
+			templateId: nonEmptyString.max(200)
+		}).strict()
+	])).max(20).superRefine((destinations, ctx) => {
+		const keys = /* @__PURE__ */ new Set();
+		destinations.forEach((destination, index) => {
+			if (keys.has(destination.key)) ctx.addIssue({
+				code: "custom",
+				path: [index, "key"],
+				message: `Duplicate destination key: ${destination.key}`
+			});
+			keys.add(destination.key);
+		});
+	}).default([{
+		key: "gateway_event",
+		kind: "gateway_event"
+	}])
+}).strict();
 const AutomationStateSchema = z.object({
 	nextRunAtMs: z.number().int().nonnegative().optional(),
 	runningRunId: optionalTrimmedString(100),
@@ -129,13 +200,15 @@ const AutomationSchema = z.object({
 	action: AutomationActionSchema,
 	safety: AutomationSafetyPolicySchema.optional(),
 	conversationMode: z.enum(["new_session", "continuous"]).default("new_session"),
-	notificationPolicy: z.enum([
-		"attention",
-		"all",
-		"none"
-	]).default("attention"),
-	completionWebhookUrl: optionalTrimmedString(2e3),
+	delivery: AutomationDeliveryPolicySchema.default({
+		notificationPolicy: "attention",
+		destinations: [{
+			key: "gateway_event",
+			kind: "gateway_event"
+		}]
+	}),
 	reliability: AutomationReliabilitySchema.optional(),
+	management: AutomationManagementSchema.optional(),
 	state: AutomationStateSchema.default({}),
 	createdAtMs: z.number().int().nonnegative(),
 	updatedAtMs: z.number().int().nonnegative()
@@ -157,12 +230,8 @@ const UpdateAutomationSchema = AutomationSchema.omit({
 	updatedAtMs: true
 }).extend({
 	conversationMode: z.enum(["new_session", "continuous"]),
-	notificationPolicy: z.enum([
-		"attention",
-		"all",
-		"none"
-	]),
+	delivery: AutomationDeliveryPolicySchema.optional(),
 	state: AutomationStateSchema
 }).partial().refine((data) => Object.keys(data).length > 0, { message: "At least one field must be provided" });
 //#endregion
-export { AutomationActionSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };
+export { AutomationActionSchema, AutomationDeliveryPolicySchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };