@xopcai/xopc 0.0.313 → 0.0.314

package/dist/src/automations/capabilities/drafts.d.ts

@@ -0,0 +1,4 @@
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import type { Config } from '../../config/schema.js';
+import type { AutomationService } from '../service/automation-service.js';
+export declare function registerAutomationDraftCapabilities(dispatcher: CapabilityDispatcher, service: AutomationService, getConfig?: () => Config | undefined): void;

package/dist/src/automations/capabilities/drafts.js

@@ -0,0 +1,95 @@
+import { AutomationDraftOutputSchema, AutomationDraftRequestSchema, AutomationRepairDraftOutputSchema, AutomationSimulationSchema } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { resolveAutomationSafetyForTrust } from "../../user-context/trust-policy.js";
+import { getUserTrustPolicy } from "../../storage/sqlite/user-trust-repository.js";
+import "../../storage/sqlite/index.js";
+import { init_agent_scope, resolveDefaultAgentId } from "../../agent/agent-scope.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { ExternalEffectNotAppliedError } from "../../capabilities/runtime/external-operations.js";
+import { defineExternalCapability, defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+import { AutomationCreateCapabilityInputSchema } from "./write.js";
+import { simulateAutomation } from "../draft/automation-draft-validator.js";
+import { AutomationDraftService } from "../draft/automation-draft-service.js";
+import "../draft/index.js";
+import { z } from "zod";
+//#region src/automations/capabilities/drafts.ts
+init_src();
+init_agent_scope();
+function registerAutomationDraftCapabilities(dispatcher, service, getConfig) {
+	const policy = {
+		majorVersion: 1,
+		effect: "external-write",
+		recovery: "manual",
+		surfaces: ["http", "agent"],
+		scopes: ["automations.write"]
+	};
+	const configuration = () => {
+		const config = getConfig?.();
+		if (!config) throw new ExternalEffectNotAppliedError("Automation draft configuration is unavailable");
+		return config;
+	};
+	dispatcher.register(defineReadCapability({
+		id: "xopc.automations.simulate",
+		majorVersion: 1,
+		effect: "read",
+		surfaces: ["http", "agent"],
+		scopes: ["automations.read"],
+		description: "Validate and explain an automation without running it or calling a model.",
+		input: AutomationCreateCapabilityInputSchema,
+		output: z.object({ simulation: AutomationSimulationSchema }),
+		execute(input) {
+			try {
+				return { simulation: simulateAutomation(input) };
+			} catch (error) {
+				throw new CapabilityError("INVALID_INPUT", error instanceof Error ? error.message : "Invalid automation");
+			}
+		}
+	}));
+	dispatcher.register(defineExternalCapability({
+		...policy,
+		id: "xopc.automations.draft",
+		description: "Generate an automation draft with a durable receipt; does not install or run the automation.",
+		input: AutomationDraftRequestSchema.extend({ prompt: z.string().trim().min(1).max(5e4) }),
+		output: z.object({ draft: AutomationDraftOutputSchema }),
+		async execute(input, context) {
+			const config = configuration();
+			const draft = await new AutomationDraftService({ config }).createDraft({
+				...input,
+				agentId: input.agentId ?? resolveDefaultAgentId(config)
+			}, context.signal);
+			draft.automation.safety = { mode: resolveAutomationSafetyForTrust(getUserTrustPolicy().defaultActionLevel, draft.automation.safety?.mode) };
+			draft.simulation = simulateAutomation(draft.automation);
+			return { draft: JSON.parse(JSON.stringify(draft)) };
+		}
+	}));
+	dispatcher.register(defineExternalCapability({
+		...policy,
+		id: "xopc.automations.repair_draft",
+		description: "Generate, but do not apply, a repair for a failed automation run.",
+		input: AutomationDraftRequestSchema.extend({ id: z.string().min(1).max(512) }),
+		output: z.object({ repair: AutomationRepairDraftOutputSchema }),
+		async execute({ id, agentId, language }, context) {
+			const config = configuration();
+			const run = await service.getRun(id);
+			if (!run) throw new ExternalEffectNotAppliedError("Run not found", { cause: new CapabilityError("NOT_FOUND", "Run not found") });
+			if (![
+				"failed",
+				"timeout",
+				"cancelled"
+			].includes(run.status)) throw new ExternalEffectNotAppliedError("Invalid repair state", { cause: new CapabilityError("INVALID_INPUT", "Repair requires a failed, timed out, or cancelled run") });
+			const automation = await service.get(run.automationId);
+			if (!automation) throw new ExternalEffectNotAppliedError("Automation not found", { cause: new CapabilityError("NOT_FOUND", "Automation not found") });
+			const events = await service.listRunEvents(id);
+			const repair = await new AutomationDraftService({ config }).createRepairDraft({
+				agentId: agentId ?? resolveDefaultAgentId(config),
+				automation,
+				run,
+				events,
+				language
+			}, context.signal);
+			return { repair: JSON.parse(JSON.stringify(repair)) };
+		}
+	}));
+}
+//#endregion
+export { registerAutomationDraftCapabilities };

package/dist/src/automations/capabilities/read.d.ts

@@ -0,0 +1,4 @@
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import type { ProjectService } from '../../projects/project-service.js';
+import type { AutomationService } from '../service/automation-service.js';
+export declare function registerAutomationReadCapabilities(dispatcher: CapabilityDispatcher, service: AutomationService, projects?: ProjectService): void;

package/dist/src/automations/capabilities/read.js

@@ -0,0 +1,119 @@
+import { ProductReadContracts } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+//#region src/automations/capabilities/read.ts
+init_src();
+function registerAutomationReadCapabilities(dispatcher, service, projects) {
+	const requireProject = (id) => {
+		if (id && !projects?.get(id)) throw new CapabilityError("NOT_FOUND", "Project not found");
+	};
+	const policy = {
+		majorVersion: 1,
+		effect: "read",
+		surfaces: [
+			"http",
+			"agent",
+			"cli"
+		],
+		scopes: ["automations.read"]
+	};
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.get_run",
+		description: "Read current run state rather than the historical submission receipt.",
+		...ProductReadContracts["xopc.automations.get_run"],
+		async execute({ id }) {
+			const run = await service.getRun(id);
+			if (!run) throw new CapabilityError("NOT_FOUND", "Run not found");
+			return {
+				ok: true,
+				run: { ...run }
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.run_events",
+		description: "Read ordered diagnostic events for an existing run.",
+		...ProductReadContracts["xopc.automations.run_events"],
+		async execute({ id }) {
+			if (!await service.getRun(id)) throw new CapabilityError("NOT_FOUND", "Run not found");
+			return {
+				ok: true,
+				events: (await service.listRunEvents(id)).map((event) => ({ ...event }))
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.metrics",
+		description: "Read automation scheduling and local runtime metrics.",
+		...ProductReadContracts["xopc.automations.metrics"],
+		async execute() {
+			return {
+				ok: true,
+				metrics: await service.getMetrics()
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.product_events",
+		description: "Find runs by their original product trigger event.",
+		...ProductReadContracts["xopc.automations.product_events"],
+		async execute(input) {
+			return {
+				ok: true,
+				items: (await service.listRunsForProductEvent(input)).map((item) => ({
+					run: { ...item.run },
+					triggerEvent: { ...item.triggerEvent }
+				}))
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.list",
+		description: "List automations, optionally scoped to a project.",
+		...ProductReadContracts["xopc.automations.list"],
+		async execute(input) {
+			requireProject(input.projectId);
+			return {
+				ok: true,
+				items: (await service.list(input)).map((item) => ({ ...item })),
+				projectId: input.projectId
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.get",
+		description: "Read an automation.",
+		...ProductReadContracts["xopc.automations.get"],
+		async execute({ id }) {
+			const automation = await service.get(id);
+			if (!automation) throw new CapabilityError("NOT_FOUND", "Automation not found");
+			return {
+				ok: true,
+				automation: { ...automation }
+			};
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.automations.history",
+		description: "Read automation execution history.",
+		...ProductReadContracts["xopc.automations.history"],
+		async execute(input) {
+			requireProject(input.projectId);
+			return {
+				ok: true,
+				items: (await service.listRuns(input)).map((item) => ({ ...item })),
+				projectId: input.projectId
+			};
+		}
+	}));
+}
+//#endregion
+export { registerAutomationReadCapabilities };

package/dist/src/automations/capabilities/write.d.ts

@@ -0,0 +1,349 @@
+import { z } from 'zod';
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import { type AutomationService } from '../service/automation-service.js';
+import type { ProjectService } from '../../projects/project-service.js';
+export declare const AutomationCreateCapabilityInputSchema: z.ZodObject<{
+    projectId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    name: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        agentId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        instruction: z.ZodString;
+        workingDirectory: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        model: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"workflow">;
+        workflowId: z.ZodString;
+        agentId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        inputEnvelope: z.ZodOptional<z.ZodObject<{
+            payload: z.ZodUnknown;
+            goal: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        goal: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        maxSubagents: z.ZodOptional<z.ZodNumber>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser_automation">;
+        automationId: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"task_command">;
+        taskId: z.ZodString;
+        command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"move">;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mark_ready">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"start">;
+            executor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                agentId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"workflow">;
+                workflowId: z.ZodString;
+                workflowVersion: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"human">;
+                actorId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"external">;
+                provider: z.ZodString;
+                config: z.ZodUnknown;
+            }, z.core.$strip>], "kind">;
+            scheduleAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"request_review">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"close">;
+            resolution: z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                duplicate: "duplicate";
+                wont_do: "wont_do";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reopen">;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"add_wait">;
+            wait: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    approval: "approval";
+                    dependency: "dependency";
+                    user_input: "user_input";
+                    external_event: "external_event";
+                    scheduled_time: "scheduled_time";
+                    retry_backoff: "retry_backoff";
+                    paused: "paused";
+                }>;
+                reason: z.ZodString;
+                condition: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                resumeAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"resolve_wait">;
+            waitId: z.ZodString;
+            resolution: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"revise_contract">;
+            contract: z.ZodObject<{
+                objective: z.ZodString;
+                expectedOutputs: z.ZodArray<z.ZodString>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                constraints: z.ZodArray<z.ZodString>;
+                approvalRequired: z.ZodArray<z.ZodString>;
+                assumptions: z.ZodArray<z.ZodString>;
+                risks: z.ZodArray<z.ZodString>;
+                acceptancePolicy: z.ZodEnum<{
+                    verified_auto: "verified_auto";
+                    verified_then_review: "verified_then_review";
+                    manual: "manual";
+                }>;
+                outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strict>], "kind">;
+    id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schedule">;
+        schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"once">;
+            at: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"interval">;
+            everyMs: z.ZodNumber;
+            anchorMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cron">;
+            expr: z.ZodString;
+            tz: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"webhook">;
+        secretId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"event">;
+        eventType: z.ZodString;
+        source: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        payloadMatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strict>], "kind">;
+    description: z.ZodOptional<z.ZodString>;
+    safety: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            suggest_only: "suggest_only";
+            ask_before_apply: "ask_before_apply";
+            auto_apply: "auto_apply";
+        }>;
+    }, z.core.$strict>>;
+    conversationMode: z.ZodDefault<z.ZodEnum<{
+        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>>;
+    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>>;
+}, z.core.$strict>;
+export declare const AutomationUpdatePatchSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>>;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    action: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        agentId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        instruction: z.ZodString;
+        workingDirectory: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        model: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"workflow">;
+        workflowId: z.ZodString;
+        agentId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        inputEnvelope: z.ZodOptional<z.ZodObject<{
+            payload: z.ZodUnknown;
+            goal: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        goal: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        maxSubagents: z.ZodOptional<z.ZodNumber>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser_automation">;
+        automationId: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"task_command">;
+        taskId: z.ZodString;
+        command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"move">;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mark_ready">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"start">;
+            executor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                agentId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"workflow">;
+                workflowId: z.ZodString;
+                workflowVersion: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"human">;
+                actorId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"external">;
+                provider: z.ZodString;
+                config: z.ZodUnknown;
+            }, z.core.$strip>], "kind">;
+            scheduleAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"request_review">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"close">;
+            resolution: z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                duplicate: "duplicate";
+                wont_do: "wont_do";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reopen">;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"add_wait">;
+            wait: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    approval: "approval";
+                    dependency: "dependency";
+                    user_input: "user_input";
+                    external_event: "external_event";
+                    scheduled_time: "scheduled_time";
+                    retry_backoff: "retry_backoff";
+                    paused: "paused";
+                }>;
+                reason: z.ZodString;
+                condition: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                resumeAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"resolve_wait">;
+            waitId: z.ZodString;
+            resolution: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"revise_contract">;
+            contract: z.ZodObject<{
+                objective: z.ZodString;
+                expectedOutputs: z.ZodArray<z.ZodString>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                constraints: z.ZodArray<z.ZodString>;
+                approvalRequired: z.ZodArray<z.ZodString>;
+                assumptions: z.ZodArray<z.ZodString>;
+                risks: z.ZodArray<z.ZodString>;
+                acceptancePolicy: z.ZodEnum<{
+                    verified_auto: "verified_auto";
+                    verified_then_review: "verified_then_review";
+                    manual: "manual";
+                }>;
+                outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strict>], "kind">>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schedule">;
+        schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"once">;
+            at: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"interval">;
+            everyMs: z.ZodNumber;
+            anchorMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cron">;
+            expr: z.ZodString;
+            tz: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"webhook">;
+        secretId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"event">;
+        eventType: z.ZodString;
+        source: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
+        payloadMatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strict>], "kind">>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    safety: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            suggest_only: "suggest_only";
+            ask_before_apply: "ask_before_apply";
+            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>>>;
+    conversationMode: z.ZodOptional<z.ZodEnum<{
+        new_session: "new_session";
+        continuous: "continuous";
+    }>>;
+    notificationPolicy: z.ZodOptional<z.ZodEnum<{
+        attention: "attention";
+        all: "all";
+        none: "none";
+    }>>;
+    state: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>;
+export declare function registerAutomationWriteCapabilities(dispatcher: CapabilityDispatcher, service: AutomationService, projects?: ProjectService): void;