@fungi.computer/workflows-wire 0.0.0-stage → 0.0.1

package/dist/library-contracts.js

@@ -0,0 +1,211 @@
+import * as z from "zod";
+import { runDeliverySchema } from "./trigger-contracts.js";
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+import * as S from "effect/Schema";
+import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
+import { gitAccessSchema, bindingsSelectionSchema, } from "@fungi.computer/braid/git-access";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { workflowIdSchema, workflowIssueSchema as issueSchema, } from "./outcomes.js";
+export const provenanceSchema = z.union([
+    z.strictObject({
+        kind: z.literal("import"),
+        workflowId: workflowIdSchema,
+        version: z.number().int().positive(),
+        commit: gitSha1Schema,
+        sha256: z.string().refine(S.is(sha256DigestSchema)),
+        origin: z.string().max(256).optional(),
+    }),
+    z.strictObject({
+        kind: z.literal("fork"),
+        workflowId: workflowIdSchema,
+        commit: gitSha1Schema,
+    }),
+]);
+const identity = z.string().min(1).max(256);
+export const runBase = z.strictObject({
+    requestId: identity,
+    workflowId: workflowIdSchema,
+    bindings: bindingsSelectionSchema,
+    input: z.record(z.string(), z.json()),
+    delivery: runDeliverySchema.optional(),
+});
+export const publishedRun = z.union([
+    runBase.extend({ version: z.number().int().positive() }),
+    runBase.extend({ commit: gitSha1Schema }),
+]);
+export const document = z.strictObject({
+    provenance: provenanceSchema.optional(),
+    definition: z.record(z.string(), z.json()),
+    layout: z.record(z.string(), z.strictObject({ x: z.number(), y: z.number() })),
+    commit: gitSha1Schema,
+});
+const invalid = z.strictObject({
+    kind: z.literal("invalid"),
+    issues: z.array(issueSchema),
+});
+export const revisionSchema = z.number().int().nonnegative();
+export const draftDocument = document
+    .omit({ commit: true })
+    .extend({ revision: revisionSchema });
+export const publishedDocument = document.extend({
+    workflowId: workflowIdSchema,
+    version: z.number().int().positive(),
+    digest: z.string().refine(S.is(sha256DigestSchema)),
+});
+export const saveReply = z.union([
+    z.strictObject({ kind: z.literal("saved"), revision: revisionSchema }),
+    z.strictObject({
+        kind: z.literal("conflict"),
+        current: draftDocument.nullable(),
+    }),
+    invalid,
+]);
+const reviewedNode = { graph: z.string(), node: z.string() };
+export const shareReview = z.strictObject({
+    gitAccess: z.array(z.union([
+        gitAccessSchema.options[0].extend(reviewedNode),
+        gitAccessSchema.options[1].extend(reviewedNode),
+    ])),
+    writeNodes: z.array(z.strictObject({
+        graph: z.string(),
+        node: z.string(),
+        appId: z.string(),
+        method: z.string(),
+        effect: z.enum(["write", "external"]),
+    })),
+    // Definition decoding owns trigger grammar; this reply transports configuration only.
+    triggers: z.array(z.json()),
+});
+export const shareCopyReply = z.union([
+    z.strictObject({
+        kind: z.literal("saved"),
+        revision: revisionSchema,
+        title: z.string(),
+        review: shareReview,
+    }),
+    saveReply.options[1],
+    invalid,
+    z.strictObject({
+        kind: z.literal("missing_apps"),
+        appIds: z.array(z.string()),
+    }),
+    z.strictObject({
+        kind: z.enum([
+            "too_large",
+            "digest_mismatch",
+            "invalid_bundle",
+            "not_found",
+        ]),
+    }),
+]);
+export const shareExportReply = z.union([
+    z.strictObject({
+        bytes: z.string(),
+        sha256: z.string().refine(S.is(sha256DigestSchema)),
+    }),
+    z.strictObject({ kind: z.enum(["not_found", "too_large"]) }),
+]);
+export const publicationIds = defineIdFamily({
+    family: "workflow-publication",
+    version: 1,
+    kinds: { publication: { prefix: "publication" } },
+});
+export const publicationIdSchema = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => publicationIds.publication.is(value));
+export const publicationFailure = z.enum([
+    "git_conflict",
+    "publication_failed",
+    "too_large",
+    "access_changed",
+]);
+export const publicationComplete = z.strictObject({
+    kind: z.literal("published"),
+    commit: gitSha1Schema,
+    version: z.number().int().positive(),
+});
+export const publicationPending = z.strictObject({
+    kind: z.literal("publishing"),
+    publicationId: publicationIdSchema,
+});
+export const publicationFailed = z.strictObject({
+    kind: z.literal("failed"),
+    reason: publicationFailure,
+});
+export const publicationStatus = z.union([
+    publicationPending,
+    publicationComplete,
+    publicationFailed,
+    z.strictObject({ kind: z.literal("not_found") }),
+]);
+export const publicationElsewhere = z.strictObject({
+    kind: z.literal("publishing_elsewhere"),
+});
+export const publishReply = z.union([
+    publicationElsewhere,
+    publicationComplete,
+    publicationPending,
+    publicationFailed,
+    z.strictObject({
+        kind: z.literal("conflict"),
+        head: gitSha1Schema.nullable(),
+    }),
+    invalid,
+]);
+export const version = z.strictObject({
+    version: z.number().int().positive(),
+    commit: gitSha1Schema,
+    committedAt: z.number(),
+    message: z.string(),
+});
+export const workflow = z.strictObject({ workflowId: workflowIdSchema });
+export const listings = z
+    .array(z.strictObject({
+    workflowId: workflowIdSchema,
+    title: z.string(),
+    draftRevision: revisionSchema.nullable(),
+    published: z
+        .strictObject({
+        commit: gitSha1Schema,
+        version: z.number().int().positive().nullable(),
+    })
+        .nullable(),
+}))
+    .max(100);
+export const history = z.array(version.omit({ version: true })).max(50);
+/** A missing index is not an empty Git repository; only write paths reconstruct it. */
+export const libraryPageInput = z.strictObject({
+    limit: z.number().int().min(1).max(100).default(100),
+    after: workflowIdSchema.optional(),
+});
+export const libraryPage = z.strictObject({
+    items: listings,
+    next: workflowIdSchema.optional(),
+});
+export const libraryListing = z.union([
+    libraryPage,
+    z.strictObject({ kind: z.literal("unindexed") }),
+]);
+/** A missing screen copy needs an explicit foreground rebuild, never a hidden Git read. */
+export const rebuilding = z.strictObject({ kind: z.literal("rebuilding") });
+export const documentRead = z.union([
+    draftDocument,
+    document,
+    z.null(),
+    rebuilding,
+]);
+export const versionsRead = z.union([z.array(version), rebuilding]);
+export const rebuildCopiesInput = z.strictObject({
+    cursor: z.string().max(1024).nullable(),
+    target: workflow
+        .extend({
+        at: z.strictObject({ commit: gitSha1Schema }),
+    })
+        .optional(),
+});
+export const rebuildCopiesReply = z.strictObject({
+    done: z.boolean(),
+    cursor: z.string().max(1024).nullable(),
+});

package/dist/outcomes.d.ts

@@ -0,0 +1,292 @@
+import * as z from "zod";
+export declare const workflowIdSchema: z.ZodString;
+export declare const catalogInputSchema: z.ZodObject<{
+    installationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** App method declarations admitted by the host for the current invocation. */
+export declare const catalogReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    apps: z.ZodArray<z.ZodObject<{
+        methods: z.ZodRecord<z.ZodString, z.ZodObject<{
+            pending: z.ZodOptional<z.ZodLiteral<true>>;
+            description: z.ZodString;
+            effect: z.ZodEnum<{
+                read: "read";
+                write: "write";
+                external: "external";
+            }>;
+            approval: z.ZodEnum<{
+                none: "none";
+                queue: "queue";
+                simulate: "simulate";
+            }>;
+            requires: z.ZodArray<z.ZodString>;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>>;
+        installationId: z.ZodString;
+        appId: z.ZodString;
+        displayName: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "agent.list": "agent.list";
+            "agent.manage": "agent.manage";
+            "agent.rename": "agent.rename";
+            "agent.toolPolicy": "agent.toolPolicy";
+            "agent.read": "agent.read";
+            "agent.send": "agent.send";
+            "computer.list": "computer.list";
+            "computer.readFile": "computer.readFile";
+            "computer.writeFile": "computer.writeFile";
+            "computer.execute": "computer.execute";
+            "llm.generation": "llm.generation";
+            "media.generation": "media.generation";
+            "games:servers": "games:servers";
+            "git.repository": "git.repository";
+            "apps.open": "apps.open";
+            "apps.call": "apps.call";
+            "app.storage": "app.storage";
+            "app.events.emit": "app.events.emit";
+            "team.workbenchHost": "team.workbenchHost";
+            "marketplace.browse": "marketplace.browse";
+            "marketplace.purchase": "marketplace.purchase";
+            "workflow.run": "workflow.run";
+            "workflow.publish": "workflow.publish";
+            "workflow.arm": "workflow.arm";
+            world: "world";
+            "channels.read": "channels.read";
+            "channels.personal.manage": "channels.personal.manage";
+        }>>>;
+        workflowPublishGranted: z.ZodOptional<z.ZodBoolean>;
+        workflowRunGranted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    app: z.ZodObject<{
+        methods: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        installationId: z.ZodString;
+        appId: z.ZodString;
+        displayName: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "agent.list": "agent.list";
+            "agent.manage": "agent.manage";
+            "agent.rename": "agent.rename";
+            "agent.toolPolicy": "agent.toolPolicy";
+            "agent.read": "agent.read";
+            "agent.send": "agent.send";
+            "computer.list": "computer.list";
+            "computer.readFile": "computer.readFile";
+            "computer.writeFile": "computer.writeFile";
+            "computer.execute": "computer.execute";
+            "llm.generation": "llm.generation";
+            "media.generation": "media.generation";
+            "games:servers": "games:servers";
+            "git.repository": "git.repository";
+            "apps.open": "apps.open";
+            "apps.call": "apps.call";
+            "app.storage": "app.storage";
+            "app.events.emit": "app.events.emit";
+            "team.workbenchHost": "team.workbenchHost";
+            "marketplace.browse": "marketplace.browse";
+            "marketplace.purchase": "marketplace.purchase";
+            "workflow.run": "workflow.run";
+            "workflow.publish": "workflow.publish";
+            "workflow.arm": "workflow.arm";
+            world: "world";
+            "channels.read": "channels.read";
+            "channels.personal.manage": "channels.personal.manage";
+        }>>>;
+        workflowPublishGranted: z.ZodOptional<z.ZodBoolean>;
+        workflowRunGranted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const workflowIssueSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    graph: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodString>;
+    edge: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const runReply: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        started: "started";
+        replay: "replay";
+        conflict: "conflict";
+    }>;
+    runId: z.ZodString;
+    planDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"invalid">;
+    issues: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        graph: z.ZodOptional<z.ZodString>;
+        node: z.ZodOptional<z.ZodString>;
+        trigger: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodString>;
+        edge: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const cancelReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        cancelled: "cancelled";
+        terminal: "terminal";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    reason: z.ZodLiteral<"denied">;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const runOutcomeSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    terminal: "terminal";
+    active: "active";
+}>;
+export declare const statusReply: z.ZodUnion<readonly [z.ZodObject<{
+    runId: z.ZodString;
+    planDigest: z.ZodString;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        terminal: "terminal";
+        active: "active";
+    }>;
+    title: z.ZodString;
+    events: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    reviews: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    status: z.ZodString;
+    output: z.ZodJSONSchema;
+    error: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const answerReviewReply: z.ZodUnion<readonly [z.ZodObject<{
+    result: z.ZodEnum<{
+        invalid: "invalid";
+        denied: "denied";
+        accepted: "accepted";
+        not_waiting: "not_waiting";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const scheduleArmReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"armed">;
+    scheduleId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    reason: z.ZodString;
+    issues: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const triggerDisarmReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        disarmed: "disarmed";
+        not_found: "not_found";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const schedulesReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    schedules: z.ZodArray<z.ZodObject<{
+        scheduleId: z.ZodString;
+        workflowId: z.ZodString;
+        triggerId: z.ZodString;
+        nextDueAt: z.ZodNumber;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            active: "active";
+            paused: "paused";
+            finished: "finished";
+        }>;
+        lastError: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const workflowRunSourceSchema: z.ZodEnum<{
+    manual: "manual";
+    schedule: "schedule";
+    event: "event";
+    agent: "agent";
+    key: "key";
+}>;
+/** The Agent Session (`sessionId`) stays host-side; the wire names only the Agent/key and its grantor. */
+export declare const workflowRunInitiatedBySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"member">;
+    memberId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+    agentId: z.ZodString;
+    grantorMemberId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"key">;
+    keyId: z.ZodString;
+    grantorMemberId: z.ZodString;
+}, z.core.$strict>]>;
+export declare const runsReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        workflowId: z.ZodString;
+        commit: z.ZodString;
+        source: z.ZodEnum<{
+            manual: "manual";
+            schedule: "schedule";
+            event: "event";
+            agent: "agent";
+            key: "key";
+        }>;
+        triggerId: z.ZodOptional<z.ZodString>;
+        initiatedBy: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"member">;
+            memberId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            agentId: z.ZodString;
+            grantorMemberId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key">;
+            keyId: z.ZodString;
+            grantorMemberId: z.ZodString;
+        }, z.core.$strict>]>;
+        startedAt: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const eventArmReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"armed">;
+    eventTriggerId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    reason: z.ZodString;
+    issues: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;
+export declare const eventTriggersReplySchema: z.ZodUnion<readonly [z.ZodObject<{
+    eventTriggers: z.ZodArray<z.ZodObject<{
+        eventTriggerId: z.ZodString;
+        workflowId: z.ZodString;
+        triggerId: z.ZodString;
+        emitterInstallationId: z.ZodString;
+        event: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        lastError: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>;

package/dist/outcomes.js

@@ -0,0 +1,183 @@
+import * as z from "zod";
+import { appCapabilityIds } from "@fungi.computer/puffball";
+export const workflowIdSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/);
+const identity = z.string().min(1).max(256);
+const refusal = z.strictObject({ error: identity });
+/** What the palette shows before a method's ports are ever fetched. */
+const methodSummarySchema = z.strictObject({
+    pending: z.literal(true).optional(),
+    description: z.string().max(1000),
+    effect: z.enum(["read", "write", "external"]),
+    approval: z.enum(["none", "queue", "simulate"]),
+    requires: z.array(z.string().max(80)).max(64),
+    digest: z.string().max(128),
+});
+const eventSummarySchema = z.strictObject({
+    description: z.string().max(1000),
+    digest: z.string().max(128),
+});
+const entryIdentity = {
+    installationId: identity,
+    appId: identity,
+    displayName: z.string().max(256),
+    icon: z.string().min(1).max(80).optional(),
+    capabilities: z.array(z.enum(appCapabilityIds)).optional(),
+    workflowPublishGranted: z.boolean().optional(),
+    workflowRunGranted: z.boolean().optional(),
+};
+/** `catalog({})`: a palette index over every installation, with no port schemas. */
+const catalogIndexEntrySchema = z.strictObject({
+    ...entryIdentity,
+    methods: z.record(z.string(), methodSummarySchema),
+    events: z.record(z.string(), eventSummarySchema).optional(),
+});
+/** `catalog({installationId})`: that one installation's full declared ports. */
+const catalogFullEntrySchema = z.strictObject({
+    ...entryIdentity,
+    methods: z.record(z.string(), z.json()),
+    events: z.record(z.string(), z.json()).optional(),
+});
+export const catalogInputSchema = z.strictObject({
+    installationId: identity.optional(),
+});
+/** App method declarations admitted by the host for the current invocation. */
+export const catalogReplySchema = z.union([
+    z.strictObject({ apps: z.array(catalogIndexEntrySchema).max(200) }),
+    z.strictObject({ app: catalogFullEntrySchema }),
+    refusal,
+]);
+export const workflowIssueSchema = z.object({
+    code: z.string(),
+    message: z.string(),
+    graph: z.string().optional(),
+    node: z.string().optional(),
+    trigger: z.string().optional(),
+    port: z.string().optional(),
+    edge: z.number().optional(),
+});
+export const runReply = z.union([
+    z.strictObject({
+        kind: z.enum(["started", "replay", "conflict"]),
+        runId: identity,
+        planDigest: identity,
+    }),
+    z.strictObject({
+        kind: z.literal("invalid"),
+        issues: z.array(workflowIssueSchema),
+    }),
+    z.strictObject({ error: identity }),
+]);
+export const cancelReplySchema = z.union([
+    z.strictObject({ kind: z.enum(["cancelled", "terminal"]) }),
+    z.strictObject({ kind: z.literal("refused"), reason: z.literal("denied") }),
+    z.strictObject({ error: z.string() }),
+]);
+export const runOutcomeSchema = z.enum(["active", "terminal", "cancelled"]);
+export const statusReply = z.union([
+    z.strictObject({
+        runId: identity,
+        planDigest: identity,
+        outcome: runOutcomeSchema,
+        title: z.string().max(120),
+        events: z.array(z.record(z.string(), z.json())).max(4096),
+        reviews: z.array(z.record(z.string(), z.json())).max(256),
+        status: identity,
+        output: z.json(),
+        error: z.json(),
+    }),
+    refusal,
+]);
+export const answerReviewReply = z.union([
+    z.strictObject({
+        result: z.enum(["accepted", "denied", "not_waiting", "invalid"]),
+    }),
+    refusal,
+]);
+const id = z.string().min(1).max(256);
+const denied = z.strictObject({ error: id });
+export const scheduleArmReplySchema = z.union([
+    z.strictObject({ kind: z.literal("armed"), scheduleId: id }),
+    z.strictObject({
+        kind: z.literal("refused"),
+        reason: z.string(),
+        issues: z.array(z.json()).optional(),
+    }),
+    denied,
+]);
+export const triggerDisarmReplySchema = z.union([
+    z.strictObject({ kind: z.enum(["disarmed", "not_found"]) }),
+    denied,
+]);
+export const schedulesReplySchema = z.union([
+    z.strictObject({
+        schedules: z.array(z.strictObject({
+            scheduleId: id,
+            workflowId: workflowIdSchema,
+            triggerId: id,
+            nextDueAt: z.number().int(),
+            state: z.enum(["active", "paused", "cancelled", "finished"]),
+            lastError: z.string().nullable(),
+        })),
+    }),
+    denied,
+]);
+export const workflowRunSourceSchema = z.enum([
+    "manual",
+    "schedule",
+    "event",
+    "agent",
+    "key",
+]);
+/** The Agent Session (`sessionId`) stays host-side; the wire names only the Agent/key and its grantor. */
+export const workflowRunInitiatedBySchema = z.union([
+    z.strictObject({ kind: z.literal("member"), memberId: id }),
+    z.strictObject({
+        kind: z.literal("agent"),
+        agentId: id,
+        grantorMemberId: id,
+    }),
+    z.strictObject({
+        kind: z.literal("key"),
+        keyId: id,
+        grantorMemberId: id,
+    }),
+]);
+export const runsReplySchema = z.union([
+    z.strictObject({
+        runs: z
+            .array(z.strictObject({
+            runId: id,
+            workflowId: workflowIdSchema,
+            commit: z.string(),
+            source: workflowRunSourceSchema,
+            triggerId: id.optional(),
+            initiatedBy: workflowRunInitiatedBySchema,
+            startedAt: z.number(),
+        }))
+            .max(50),
+    }),
+    denied,
+]);
+export const eventArmReplySchema = z.union([
+    z.strictObject({ kind: z.literal("armed"), eventTriggerId: id }),
+    z.strictObject({
+        kind: z.literal("refused"),
+        reason: z.string(),
+        issues: z.array(z.json()).optional(),
+    }),
+    denied,
+]);
+export const eventTriggersReplySchema = z.union([
+    z.strictObject({
+        eventTriggers: z.array(z.strictObject({
+            eventTriggerId: id,
+            workflowId: workflowIdSchema,
+            triggerId: id,
+            emitterInstallationId: id,
+            event: id,
+            state: z.enum(["active", "paused"]),
+            lastError: z.string().nullable(),
+        })),
+    }),
+    denied,
+]);