@treeseed/sdk 0.13.0-rc.12 → 0.13.0-rc.120

package/dist/operator-contracts/catalog/communication-operations.d.ts

@@ -0,0 +1,439 @@
+export declare function communicationOperations(): {
+    send: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {}, {
+        message: string;
+        timeoutSeconds?: number | undefined;
+        recipients?: string[] | undefined;
+        proposalId?: string | undefined;
+        parentWorkdayId?: string | undefined;
+    }, {
+        status: "failed" | "running" | "partial" | "complete" | "queued";
+        schemaVersion: "treeseed.communication-send-receipt/v4";
+        targets: {
+            status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
+            projectId: string;
+            invocationId: string | null;
+            completedAt: string | null;
+            requirement: "required" | "optional";
+            agentSlug: string;
+            capacity: {
+                status: string | null;
+                providerId: string | null;
+                assignmentId: string | null;
+                completedAt: string | null;
+                executionProviderId: string | null;
+                laneId: string | null;
+                lanePurpose: string | null;
+                assignedAt: string | null;
+                claimedAt: string | null;
+                returnedAt: string | null;
+                failedAt: string | null;
+            };
+            diagnostics: {
+                provider: {
+                    providerId: string | null;
+                    executionProviderId: string | null;
+                    runtimeVersion: string | null;
+                };
+                resources: Record<string, unknown>;
+                selection: {
+                    capabilities: string[];
+                    model: string | null;
+                    parameters: Record<string, unknown>;
+                };
+                reason: string | null;
+                usage: Record<string, unknown>[];
+                availability: "available" | "unavailable" | "partial";
+                identityManifest: Record<string, unknown>;
+                contextManifest: Record<string, unknown>[];
+                timing: Record<string, unknown>;
+                traceEvents: Record<string, unknown>[];
+                fullPayload?: Record<string, unknown> | undefined;
+            };
+            projectSlug: string;
+            definitionRevision: string;
+            revisions: {
+                project: string;
+                library: string;
+                agentDefinition: string;
+                chatProfile: string;
+            };
+            parentInvocationId: string | null;
+            depth: number;
+            requestedAt: string;
+            updatedAt: string;
+            failure: {
+                code: string;
+                message: string | null;
+            } | null;
+            acknowledgedAt: string | null;
+            leaseAcceptedAt: string | null;
+        }[];
+        teamId: string;
+        createdAt: string;
+        sendId: string;
+        responses: {
+            status: "failed" | "cancelled" | "responded" | "abstained";
+            projectId: string;
+            createdAt: string;
+            assignmentId: string | null;
+            invocationId: string;
+            requirement: "required" | "optional";
+            agentSlug: string;
+            projectSlug: string;
+            messageRef: string;
+            markdown: string;
+        }[];
+        channel: string;
+        topic: {
+            id: string;
+            slug: string;
+        };
+        events: {
+            type: "message.posted" | "mention.acknowledged" | "response_lease.accepted" | "agent.progress" | "agent.response" | "agent.abstained" | "agent.failed";
+            actor: {
+                kind: "provider" | "agent" | "control-plane" | "user";
+                id: string;
+                handle: string | null;
+            };
+            id: string;
+            teamId: string;
+            assignmentId: string | null;
+            topicId: string;
+            sendId: string | null;
+            invocationId: string | null;
+            sequence: number;
+            payload: Record<string, unknown>;
+            summary: string;
+            channel: string;
+            occurredAt: string;
+        }[];
+        updatedAt: string;
+        projectStreams: {
+            id: string;
+            projectId: string;
+            projectSlug: string;
+            messageRef: string;
+            discussionId: string;
+        }[];
+        replayed: boolean;
+    }>;
+    sendStatus: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        sendId: string;
+    }, {
+        diagnostics?: "metadata" | "full" | undefined;
+    }, undefined, {
+        status: "failed" | "running" | "partial" | "complete" | "queued";
+        schemaVersion: "treeseed.communication-send-receipt/v4";
+        targets: {
+            status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
+            projectId: string;
+            invocationId: string | null;
+            completedAt: string | null;
+            requirement: "required" | "optional";
+            agentSlug: string;
+            capacity: {
+                status: string | null;
+                providerId: string | null;
+                assignmentId: string | null;
+                completedAt: string | null;
+                executionProviderId: string | null;
+                laneId: string | null;
+                lanePurpose: string | null;
+                assignedAt: string | null;
+                claimedAt: string | null;
+                returnedAt: string | null;
+                failedAt: string | null;
+            };
+            diagnostics: {
+                provider: {
+                    providerId: string | null;
+                    executionProviderId: string | null;
+                    runtimeVersion: string | null;
+                };
+                resources: Record<string, unknown>;
+                selection: {
+                    capabilities: string[];
+                    model: string | null;
+                    parameters: Record<string, unknown>;
+                };
+                reason: string | null;
+                usage: Record<string, unknown>[];
+                availability: "available" | "unavailable" | "partial";
+                identityManifest: Record<string, unknown>;
+                contextManifest: Record<string, unknown>[];
+                timing: Record<string, unknown>;
+                traceEvents: Record<string, unknown>[];
+                fullPayload?: Record<string, unknown> | undefined;
+            };
+            projectSlug: string;
+            definitionRevision: string;
+            revisions: {
+                project: string;
+                library: string;
+                agentDefinition: string;
+                chatProfile: string;
+            };
+            parentInvocationId: string | null;
+            depth: number;
+            requestedAt: string;
+            updatedAt: string;
+            failure: {
+                code: string;
+                message: string | null;
+            } | null;
+            acknowledgedAt: string | null;
+            leaseAcceptedAt: string | null;
+        }[];
+        teamId: string;
+        createdAt: string;
+        sendId: string;
+        responses: {
+            status: "failed" | "cancelled" | "responded" | "abstained";
+            projectId: string;
+            createdAt: string;
+            assignmentId: string | null;
+            invocationId: string;
+            requirement: "required" | "optional";
+            agentSlug: string;
+            projectSlug: string;
+            messageRef: string;
+            markdown: string;
+        }[];
+        channel: string;
+        topic: {
+            id: string;
+            slug: string;
+        };
+        events: {
+            type: "message.posted" | "mention.acknowledged" | "response_lease.accepted" | "agent.progress" | "agent.response" | "agent.abstained" | "agent.failed";
+            actor: {
+                kind: "provider" | "agent" | "control-plane" | "user";
+                id: string;
+                handle: string | null;
+            };
+            id: string;
+            teamId: string;
+            assignmentId: string | null;
+            topicId: string;
+            sendId: string | null;
+            invocationId: string | null;
+            sequence: number;
+            payload: Record<string, unknown>;
+            summary: string;
+            channel: string;
+            occurredAt: string;
+        }[];
+        updatedAt: string;
+        projectStreams: {
+            id: string;
+            projectId: string;
+            projectSlug: string;
+            messageRef: string;
+            discussionId: string;
+        }[];
+        replayed: boolean;
+    }>;
+    topicsList: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {
+        status?: "active" | "archived" | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, undefined, {
+        items: {
+            status: "active" | "archived";
+            id: string;
+            slug: string;
+            teamId: string;
+            createdAt: string;
+            updatedAt: string;
+            streams: {
+                id: string;
+                projectId: string;
+                projectSlug: string;
+                discussionId: string;
+            }[];
+            listeners: {
+                status: "active" | "removed";
+                projectId: string;
+                source: "seed" | "operator" | "mention";
+                agentSlug: string;
+                projectSlug: string;
+                updatedAt: string;
+                agentHandle: string;
+                subscribedAt: string;
+            }[];
+        }[];
+        cursor: string | null;
+    }>;
+    topicsShow: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {}, undefined, {
+        status: "active" | "archived";
+        id: string;
+        slug: string;
+        teamId: string;
+        createdAt: string;
+        updatedAt: string;
+        streams: {
+            id: string;
+            projectId: string;
+            projectSlug: string;
+            discussionId: string;
+        }[];
+        listeners: {
+            status: "active" | "removed";
+            projectId: string;
+            source: "seed" | "operator" | "mention";
+            agentSlug: string;
+            projectSlug: string;
+            updatedAt: string;
+            agentHandle: string;
+            subscribedAt: string;
+        }[];
+    }>;
+    topicsTimeline: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {
+        limit?: number | undefined;
+        waitSeconds?: number | undefined;
+        diagnostics?: "metadata" | "full" | undefined;
+        after?: string | undefined;
+    }, undefined, {
+        cursor: string | null;
+        topic: {
+            status: "active" | "archived";
+            id: string;
+            slug: string;
+            teamId: string;
+            createdAt: string;
+            updatedAt: string;
+            streams: {
+                id: string;
+                projectId: string;
+                projectSlug: string;
+                discussionId: string;
+            }[];
+            listeners: {
+                status: "active" | "removed";
+                projectId: string;
+                source: "seed" | "operator" | "mention";
+                agentSlug: string;
+                projectSlug: string;
+                updatedAt: string;
+                agentHandle: string;
+                subscribedAt: string;
+            }[];
+        };
+        events: {
+            type: "message.posted" | "mention.acknowledged" | "response_lease.accepted" | "agent.progress" | "agent.response" | "agent.abstained" | "agent.failed";
+            actor: {
+                kind: "provider" | "agent" | "control-plane" | "user";
+                id: string;
+                handle: string | null;
+            };
+            id: string;
+            teamId: string;
+            assignmentId: string | null;
+            topicId: string;
+            sendId: string | null;
+            invocationId: string | null;
+            sequence: number;
+            payload: Record<string, unknown>;
+            summary: string;
+            channel: string;
+            occurredAt: string;
+        }[];
+    }>;
+    topicsSubscribe: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {}, {
+        agent: string;
+    }, {
+        topicId: string;
+        replayed: boolean;
+        listener: {
+            status: "active" | "removed";
+            projectId: string;
+            source: "seed" | "operator" | "mention";
+            agentSlug: string;
+            projectSlug: string;
+            updatedAt: string;
+            agentHandle: string;
+            subscribedAt: string;
+        };
+    }>;
+    topicsUnsubscribe: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {}, {
+        agent: string;
+    }, {
+        topicId: string;
+        replayed: boolean;
+        listener: {
+            status: "active" | "removed";
+            projectId: string;
+            source: "seed" | "operator" | "mention";
+            agentSlug: string;
+            projectSlug: string;
+            updatedAt: string;
+            agentHandle: string;
+            subscribedAt: string;
+        };
+    }>;
+};
+export declare function providerDiscussionResponseOperation(): import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+    assignmentId: string;
+}, {}, {
+    runnerId: string;
+    leaseToken: string;
+    summary?: string | undefined;
+    usage?: Record<string, unknown> | undefined;
+    markdown?: string | undefined;
+    outcome?: "responded" | "abstained" | undefined;
+}, {
+    status: "responded" | "abstained";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
+    assignmentId: string;
+    invocationId: string;
+    messageRef: string;
+    settledAt: string;
+}>;
+export declare function providerCommunicationLifecycleOperations(): {
+    notificationAcknowledge: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        assignmentId: string;
+    }, {}, {
+        providerId: string;
+        observedAt: string;
+        runnerId: string;
+    }, {
+        assignmentId: string;
+        acknowledgedAt: string;
+        replayed: boolean;
+    }>;
+    traceEvent: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        assignmentId: string;
+    }, {}, {
+        type: string;
+        sequence: number;
+        payload: Record<string, unknown>;
+        summary: string;
+        occurredAt: string;
+        runnerId: string;
+        leaseToken: string;
+        protectedPayload?: Record<string, unknown> | undefined;
+    }, {
+        assignmentId: string;
+        sequence: number;
+        replayed: boolean;
+        acceptedAt: string;
+    }>;
+};

package/dist/operator-contracts/catalog/communication-operations.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+import {
+  communicationSendReceiptSchema,
+  communicationSendRequestSchema,
+  communicationTopicPageSchema,
+  communicationTopicSchema,
+  communicationTopicSubscriptionReceiptSchema,
+  communicationTopicSubscriptionRequestSchema,
+  communicationTopicTimelineSchema,
+  providerCommunicationNotificationAcknowledgeRequestSchema,
+  providerCommunicationTraceEventRequestSchema,
+  providerDiscussionResponseReceiptSchema,
+  providerDiscussionResponseRequestSchema
+} from "../communication/contracts.js";
+const empty = z.object({}).strict();
+const none = z.undefined();
+function communicationOperations() {
+  return {
+    send: defineOperation({ operationId: "communications.send", description: "Post a team discussion-topic message and admit every addressed team agent to its project communication stream.", rest: { method: "POST", path: "/v1/teams/{teamId}/discussion-topics/{channel}/messages" }, parameters: "treeseed.communications.send.parameters/v3", capability: "agents.execute", authentication: "oauth", oauthScopes: ["treeseed:execution"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().trim().min(1).max(120) }).strict(),
+      query: empty,
+      body: communicationSendRequestSchema,
+      output: communicationSendReceiptSchema
+    }),
+    sendStatus: defineOperation({ operationId: "communications.sends.show", description: "Read a communication send and its durable agent responses.", rest: { method: "GET", path: "/v1/teams/{teamId}/communication-sends/{sendId}" }, parameters: "treeseed.communications.sends.show.parameters/v1", capability: "agents.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "mcp_tool", "mcp_resource"], cacheScope: "principal", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), sendId: z.string().min(1) }).strict(),
+      query: z.object({ diagnostics: z.enum(["metadata", "full"]).optional() }).strict(),
+      body: none,
+      output: communicationSendReceiptSchema
+    }),
+    topicsList: defineOperation({ operationId: "communications.topics.list", description: "List team discussion topics and active listeners.", rest: { method: "GET", path: "/v1/teams/{teamId}/discussion-topics" }, parameters: "treeseed.communications.topics.list.parameters/v1", capability: "agents.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool", "mcp_resource"], cacheScope: "principal", pagination: "cursor" }, {
+      path: z.object({ teamId: z.string().min(1) }).strict(),
+      query: z.object({ status: z.enum(["active", "archived"]).optional(), limit: z.coerce.number().int().min(1).max(200).optional(), cursor: z.string().optional() }).strict(),
+      body: none,
+      output: communicationTopicPageSchema
+    }),
+    topicsShow: defineOperation({ operationId: "communications.topics.show", description: "Show one discussion topic, streams, and listeners.", rest: { method: "GET", path: "/v1/teams/{teamId}/discussion-topics/{channel}" }, parameters: "treeseed.communications.topics.show.parameters/v1", capability: "agents.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool", "mcp_resource"], cacheScope: "principal", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().min(1) }).strict(),
+      query: empty,
+      body: none,
+      output: communicationTopicSchema
+    }),
+    topicsTimeline: defineOperation({ operationId: "communications.topics.timeline", description: "Read the ordered durable timeline for a discussion topic.", rest: { method: "GET", path: "/v1/teams/{teamId}/discussion-topics/{channel}/timeline" }, parameters: "treeseed.communications.topics.timeline.parameters/v1", capability: "agents.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "mcp_tool", "mcp_resource"], cacheScope: "principal", pagination: "cursor" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().min(1) }).strict(),
+      query: z.object({ after: z.string().optional(), waitSeconds: z.coerce.number().int().min(0).max(30).optional(), limit: z.coerce.number().int().min(1).max(500).optional(), diagnostics: z.enum(["metadata", "full"]).optional() }).strict(),
+      body: none,
+      output: communicationTopicTimelineSchema
+    }),
+    topicsSubscribe: defineOperation({ operationId: "communications.topics.subscriptions.put", description: "Subscribe an agent to a discussion topic.", rest: { method: "PUT", path: "/v1/teams/{teamId}/discussion-topics/{channel}/subscriptions" }, parameters: "treeseed.communications.topics.subscriptions.put.parameters/v1", capability: "agents.execute", authentication: "oauth", oauthScopes: ["treeseed:execution"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().min(1) }).strict(),
+      query: empty,
+      body: communicationTopicSubscriptionRequestSchema,
+      output: communicationTopicSubscriptionReceiptSchema
+    }),
+    topicsUnsubscribe: defineOperation({ operationId: "communications.topics.subscriptions.delete", description: "Remove an agent subscription from a discussion topic.", rest: { method: "DELETE", path: "/v1/teams/{teamId}/discussion-topics/{channel}/subscriptions" }, parameters: "treeseed.communications.topics.subscriptions.delete.parameters/v1", capability: "agents.execute", authentication: "oauth", oauthScopes: ["treeseed:execution"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().min(1) }).strict(),
+      query: empty,
+      body: communicationTopicSubscriptionRequestSchema,
+      output: communicationTopicSubscriptionReceiptSchema
+    })
+  };
+}
+function providerDiscussionResponseOperation() {
+  return defineOperation({ operationId: "providers.assignments.discussion.respond", description: "Commit and settle an assignment-scoped discussion response.", rest: { method: "POST", path: "/v1/provider/assignments/{assignmentId}/discussion-response" }, parameters: "treeseed.providers.assignments.discussion.respond.parameters/v1", capability: "providers.execute", authentication: "provider", oauthScopes: [], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest"], cacheScope: "none", pagination: "none" }, {
+    path: z.object({ assignmentId: z.string().min(1) }).strict(),
+    query: empty,
+    body: providerDiscussionResponseRequestSchema,
+    output: providerDiscussionResponseReceiptSchema
+  });
+}
+function providerCommunicationLifecycleOperations() {
+  return {
+    notificationAcknowledge: defineOperation({ operationId: "providers.assignments.communication.acknowledge", description: "Acknowledge provider observation of an addressed communication mention.", rest: { method: "POST", path: "/v1/provider/assignments/{assignmentId}/communication-acknowledgement" }, parameters: "treeseed.providers.assignments.communication.acknowledge.parameters/v1", capability: "providers.execute", authentication: "provider", oauthScopes: [], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ assignmentId: z.string().min(1) }).strict(),
+      query: empty,
+      body: providerCommunicationNotificationAcknowledgeRequestSchema,
+      output: z.object({ assignmentId: z.string(), acknowledgedAt: z.string().datetime(), replayed: z.boolean() }).strict()
+    }),
+    traceEvent: defineOperation({ operationId: "providers.assignments.communication.trace.create", description: "Append one provider-authored communication execution trace event.", rest: { method: "POST", path: "/v1/provider/assignments/{assignmentId}/communication-trace-events" }, parameters: "treeseed.providers.assignments.communication.trace.create.parameters/v1", capability: "providers.execute", authentication: "provider", oauthScopes: [], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ assignmentId: z.string().min(1) }).strict(),
+      query: empty,
+      body: providerCommunicationTraceEventRequestSchema,
+      output: z.object({ assignmentId: z.string(), sequence: z.number().int().nonnegative(), acceptedAt: z.string().datetime(), replayed: z.boolean() }).strict()
+    })
+  };
+}
+export {
+  communicationOperations,
+  providerCommunicationLifecycleOperations,
+  providerDiscussionResponseOperation
+};

package/dist/operator-contracts/catalog/control-plane-catalog.d.ts

@@ -0,0 +1,6 @@
+import type { ControlPlaneOperationBinding, ControlPlaneOperationDescriptor } from '../control-plane-operation.js';
+export declare function flattenControlPlaneOperations(value: unknown, output?: ControlPlaneOperationBinding<any, any, any, any>[]): ControlPlaneOperationBinding<any, any, any, any>[];
+export declare function buildControlPlaneCatalog(operations: readonly ControlPlaneOperationBinding<any, any, any, any>[]): Readonly<{
+    schemaVersion: "treeseed.control-plane-catalog/v1";
+    operations: ControlPlaneOperationDescriptor[];
+}>;

package/dist/operator-contracts/catalog/control-plane-catalog.js

@@ -0,0 +1,18 @@
+function flattenControlPlaneOperations(value, output = []) {
+  if (value && typeof value === "object" && "descriptor" in value && "schema" in value) {
+    output.push(value);
+  } else if (value && typeof value === "object") {
+    for (const child of Object.values(value)) flattenControlPlaneOperations(child, output);
+  }
+  return output;
+}
+function buildControlPlaneCatalog(operations) {
+  return Object.freeze({
+    schemaVersion: "treeseed.control-plane-catalog/v1",
+    operations: operations.map((operation) => operation.descriptor)
+  });
+}
+export {
+  buildControlPlaneCatalog,
+  flattenControlPlaneOperations
+};

package/dist/operator-contracts/catalog/execution/execution-operations.d.ts

@@ -0,0 +1,36 @@
+export declare const EXECUTION_OPERATIONS: {
+    readonly graph: {
+        readonly show: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly watch: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, Record<string, unknown> | undefined, Record<string, unknown>>;
+    };
+    readonly nodes: {
+        readonly show: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly explain: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, Record<string, unknown> | undefined, Record<string, unknown>>;
+    };
+    readonly reconcile: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly assignments: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }, Record<string, unknown> | undefined, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/execution/execution-operations.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineOperation } from "../../operation-builder.js";
+const record = z.record(z.unknown()), team = { teamId: z.string().min(1) };
+function operation(operationId, method, path, pathShape, surfaces, pagination = "none", queryShape = {}) {
+  const mutation = method === "POST";
+  return defineOperation(
+    {
+      operationId,
+      description: `${mutation ? "Apply" : "Read"} ${operationId}.`,
+      rest: { method, path },
+      parameters: `treeseed.${operationId}.parameters/v1`,
+      capability: mutation ? "assignments.execute" : "assignments.read",
+      authentication: "oauth",
+      oauthScopes: mutation ? ["treeseed:execution"] : ["treeseed:read"],
+      kind: mutation ? "mutation" : "read",
+      riskClass: "ordinary",
+      confirmation: "never",
+      surfaces,
+      cacheScope: mutation ? "none" : "principal",
+      pagination
+    },
+    { path: z.object(pathShape).strict(), query: z.object(queryShape).strict(), body: mutation ? record : z.undefined(), output: record }
+  );
+}
+const EXECUTION_OPERATIONS = {
+  graph: {
+    show: operation("execution.graph.show", "GET", "/v1/teams/{teamId}/execution-graph", team, ["rest", "cli", "mcp_tool", "mcp_resource"], "none", { projectId: z.string().optional(), decisionId: z.string().optional() }),
+    watch: operation("execution.graph.watch", "GET", "/v1/teams/{teamId}/execution-graph/events", team, ["rest", "cli", "mcp_tool"], "cursor", { cursor: z.string().optional(), waitSeconds: z.coerce.number().int().positive().optional() })
+  },
+  nodes: {
+    show: operation("execution.nodes.show", "GET", "/v1/teams/{teamId}/execution-nodes/{nodeId}", { ...team, nodeId: z.string().min(1) }, ["rest", "cli", "mcp_resource"]),
+    explain: operation("execution.nodes.explain", "GET", "/v1/teams/{teamId}/execution-nodes/{nodeId}/explanation", { ...team, nodeId: z.string().min(1) }, ["rest", "cli", "mcp_tool", "mcp_resource"])
+  },
+  reconcile: operation("execution.reconcile", "POST", "/v1/teams/{teamId}/execution-graph/reconcile", team, ["rest", "cli", "mcp_tool"]),
+  assignments: operation("execution.assignments.list", "GET", "/v1/teams/{teamId}/execution-assignments", team, ["rest", "cli", "mcp_tool"], "cursor", { status: z.string().optional(), limit: z.coerce.number().int().positive().optional(), cursor: z.string().optional() })
+};
+export {
+  EXECUTION_OPERATIONS
+};