@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

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

@@ -0,0 +1,261 @@
+export declare function inboxOperations(): {
+    list: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {
+        kind?: "all" | "proposal" | "question" | undefined;
+        state?: "all" | "outstanding" | undefined;
+        projectId?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, undefined, {
+        schemaVersion: "treeseed.inbox-page/v1";
+        items: {
+            status: "approved" | "rejected" | "outstanding" | "answered" | "closed" | "deleted";
+            kind: "proposal" | "question";
+            id: string;
+            version: number;
+            projectId: string;
+            teamId: string;
+            createdAt: string;
+            projectSlug: string;
+            updatedAt: string;
+            authorId: string;
+            authorLabel: string;
+            title: string;
+            etag: string;
+        }[];
+        cursor: string | null;
+    }>;
+    show: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        itemId: string;
+    }, {}, undefined, {
+        status: "approved" | "rejected" | "outstanding" | "answered" | "closed" | "deleted";
+        kind: "proposal" | "question";
+        id: string;
+        version: number;
+        schemaVersion: "treeseed.inbox-item/v1";
+        projectId: string;
+        teamId: string;
+        createdAt: string;
+        provenance: {
+            digest: string | null;
+            repositoryId: string | null;
+            contentPath: string | null;
+            commitSha: string | null;
+        };
+        projectSlug: string;
+        updatedAt: string;
+        markdown: string;
+        discussionId: string | null;
+        authorId: string;
+        authorLabel: string;
+        title: string;
+        availableActions: {
+            enabled: boolean;
+            action: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen";
+            reason: string | null;
+            label: string;
+            confirmation: "never" | "input_required";
+            requiresFeedback: boolean;
+        }[];
+        comments: {
+            kind: "comment" | "answer" | "reply";
+            id: string;
+            createdAt: string;
+            provenance: {
+                digest: string | null;
+                repositoryId: string | null;
+                contentPath: string | null;
+                commitSha: string | null;
+            };
+            markdown: string;
+            parentId: string | null;
+            authorId: string;
+            authorLabel: string;
+        }[];
+        etag: string;
+    }>;
+    events: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {
+        limit?: number | undefined;
+        after?: string | undefined;
+        waitSeconds?: number | undefined;
+    }, undefined, {
+        cursor: string;
+        events: {
+            type: "item.created" | "item.updated" | "item.deleted" | "draft.updated" | "comment.created" | "question.answered" | "question.reopened" | "proposal.revised" | "proposal.decided";
+            id: string;
+            schemaVersion: "treeseed.inbox-event/v1";
+            teamId: string;
+            sequence: string;
+            payload: Record<string, unknown>;
+            summary: string;
+            occurredAt: string;
+            itemId: string | null;
+            actorId: string;
+        }[];
+    }>;
+    createQuestion: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, {
+        projectId: string;
+        markdown: string;
+        title: string;
+        recipients?: string[] | undefined;
+        relatedObjectives?: string[] | undefined;
+    }, {
+        schemaVersion: "treeseed.inbox-mutation-receipt/v1";
+        item: {
+            status: "approved" | "rejected" | "outstanding" | "answered" | "closed" | "deleted";
+            kind: "proposal" | "question";
+            id: string;
+            version: number;
+            schemaVersion: "treeseed.inbox-item/v1";
+            projectId: string;
+            teamId: string;
+            createdAt: string;
+            provenance: {
+                digest: string | null;
+                repositoryId: string | null;
+                contentPath: string | null;
+                commitSha: string | null;
+            };
+            projectSlug: string;
+            updatedAt: string;
+            markdown: string;
+            discussionId: string | null;
+            authorId: string;
+            authorLabel: string;
+            title: string;
+            availableActions: {
+                enabled: boolean;
+                action: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen";
+                reason: string | null;
+                label: string;
+                confirmation: "never" | "input_required";
+                requiresFeedback: boolean;
+            }[];
+            comments: {
+                kind: "comment" | "answer" | "reply";
+                id: string;
+                createdAt: string;
+                provenance: {
+                    digest: string | null;
+                    repositoryId: string | null;
+                    contentPath: string | null;
+                    commitSha: string | null;
+                };
+                markdown: string;
+                parentId: string | null;
+                authorId: string;
+                authorLabel: string;
+            }[];
+            etag: string;
+        };
+        replayed: boolean;
+        action?: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen" | undefined;
+        receipts?: Record<string, unknown>[] | undefined;
+    }>;
+    getDraft: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        purpose: "feedback" | "proposal_revision";
+        itemId: string;
+    }, {}, undefined, {
+        schemaVersion: "treeseed.inbox-draft/v1";
+        purpose: "feedback" | "proposal_revision";
+        revision: number;
+        updatedAt: string;
+        markdown: string;
+        etag: string;
+        itemId: string;
+        baseVersion: number;
+    } | null>;
+    putDraft: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        purpose: "feedback" | "proposal_revision";
+        itemId: string;
+    }, {}, {
+        markdown: string;
+        baseVersion: number;
+    }, {
+        schemaVersion: "treeseed.inbox-draft/v1";
+        purpose: "feedback" | "proposal_revision";
+        revision: number;
+        updatedAt: string;
+        markdown: string;
+        etag: string;
+        itemId: string;
+        baseVersion: number;
+    }>;
+    deleteDraft: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        purpose: "feedback" | "proposal_revision";
+        itemId: string;
+    }, {}, {}, {
+        deleted: boolean;
+    }>;
+    action: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        itemId: string;
+    }, {}, {
+        action: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen";
+        markdown?: string | undefined;
+        parentId?: string | undefined;
+        changeReason?: string | undefined;
+        draftRevision?: number | undefined;
+    }, {
+        schemaVersion: "treeseed.inbox-mutation-receipt/v1";
+        item: {
+            status: "approved" | "rejected" | "outstanding" | "answered" | "closed" | "deleted";
+            kind: "proposal" | "question";
+            id: string;
+            version: number;
+            schemaVersion: "treeseed.inbox-item/v1";
+            projectId: string;
+            teamId: string;
+            createdAt: string;
+            provenance: {
+                digest: string | null;
+                repositoryId: string | null;
+                contentPath: string | null;
+                commitSha: string | null;
+            };
+            projectSlug: string;
+            updatedAt: string;
+            markdown: string;
+            discussionId: string | null;
+            authorId: string;
+            authorLabel: string;
+            title: string;
+            availableActions: {
+                enabled: boolean;
+                action: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen";
+                reason: string | null;
+                label: string;
+                confirmation: "never" | "input_required";
+                requiresFeedback: boolean;
+            }[];
+            comments: {
+                kind: "comment" | "answer" | "reply";
+                id: string;
+                createdAt: string;
+                provenance: {
+                    digest: string | null;
+                    repositoryId: string | null;
+                    contentPath: string | null;
+                    commitSha: string | null;
+                };
+                markdown: string;
+                parentId: string | null;
+                authorId: string;
+                authorLabel: string;
+            }[];
+            etag: string;
+        };
+        replayed: boolean;
+        action?: "approve" | "reject" | "publish_revision" | "comment" | "answer" | "reply" | "reopen" | undefined;
+        receipts?: Record<string, unknown>[] | undefined;
+    }>;
+};

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+import {
+  inboxActionRequestSchema,
+  inboxDraftPurposeSchema,
+  inboxDraftSchema,
+  inboxDraftWriteSchema,
+  inboxItemPageSchema,
+  inboxItemSchema,
+  inboxMutationReceiptSchema,
+  inboxQuestionCreateSchema,
+  inboxTimelineSchema
+} from "../inbox/contracts.js";
+const empty = z.object({}).strict();
+const none = z.undefined();
+const itemPath = z.object({ teamId: z.string().min(1), itemId: z.string().min(1) }).strict();
+function inboxOperations() {
+  return {
+    list: defineOperation({ operationId: "inbox.items.list", description: "List the active team governance inbox.", rest: { method: "GET", path: "/v1/teams/{teamId}/inbox/items" }, parameters: "treeseed.inbox.items.list.parameters/v1", capability: "governance.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({ projectId: z.string().optional(), kind: z.enum(["proposal", "question", "all"]).optional(), state: z.enum(["outstanding", "all"]).optional(), limit: z.coerce.number().int().min(1).max(500).optional(), cursor: z.string().optional() }).strict(),
+      body: none,
+      output: inboxItemPageSchema
+    }),
+    show: defineOperation({ operationId: "inbox.items.show", description: "Read one inbox item and its thread.", rest: { method: "GET", path: "/v1/teams/{teamId}/inbox/items/{itemId}" }, parameters: "treeseed.inbox.items.show.parameters/v1", capability: "governance.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_resource"], cacheScope: "principal", pagination: "none" }, { path: itemPath, query: empty, body: none, output: inboxItemSchema }),
+    events: defineOperation({ operationId: "inbox.events.list", description: "Long-poll ordered inbox events.", rest: { method: "GET", path: "/v1/teams/{teamId}/inbox/events" }, parameters: "treeseed.inbox.events.list.parameters/v1", capability: "governance.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_resource"], cacheScope: "principal", pagination: "cursor" }, { path: z.object({ teamId: z.string() }).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() }).strict(), body: none, output: inboxTimelineSchema }),
+    createQuestion: defineOperation({ operationId: "inbox.questions.create", description: "Create and route a TreeDX-backed project question.", rest: { method: "POST", path: "/v1/teams/{teamId}/inbox/questions" }, parameters: "treeseed.inbox.questions.create.parameters/v1", capability: "governance.write", authentication: "oauth", oauthScopes: ["treeseed:knowledge:write", "treeseed:execution"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, { path: z.object({ teamId: z.string() }).strict(), query: empty, body: inboxQuestionCreateSchema, output: inboxMutationReceiptSchema }),
+    getDraft: defineOperation({ operationId: "inbox.drafts.show", description: "Read the current principal private inbox draft.", rest: { method: "GET", path: "/v1/teams/{teamId}/inbox/items/{itemId}/drafts/{purpose}" }, parameters: "treeseed.inbox.drafts.show.parameters/v1", capability: "governance.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli"], cacheScope: "principal", pagination: "none" }, { path: itemPath.extend({ purpose: inboxDraftPurposeSchema }), query: empty, body: none, output: inboxDraftSchema.nullable() }),
+    putDraft: defineOperation({ operationId: "inbox.drafts.put", description: "Save a private inbox draft.", rest: { method: "PUT", path: "/v1/teams/{teamId}/inbox/items/{itemId}/drafts/{purpose}" }, parameters: "treeseed.inbox.drafts.put.parameters/v1", capability: "governance.write", authentication: "oauth", oauthScopes: ["treeseed:governance:write"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli"], cacheScope: "none", pagination: "none", concurrencyRequired: true }, { path: itemPath.extend({ purpose: inboxDraftPurposeSchema }), query: empty, body: inboxDraftWriteSchema, output: inboxDraftSchema }),
+    deleteDraft: defineOperation({ operationId: "inbox.drafts.delete", description: "Delete a private inbox draft.", rest: { method: "DELETE", path: "/v1/teams/{teamId}/inbox/items/{itemId}/drafts/{purpose}" }, parameters: "treeseed.inbox.drafts.delete.parameters/v1", capability: "governance.write", authentication: "oauth", oauthScopes: ["treeseed:governance:write"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli"], cacheScope: "none", pagination: "none" }, { path: itemPath.extend({ purpose: inboxDraftPurposeSchema }), query: empty, body: empty, output: z.object({ deleted: z.boolean() }).strict() }),
+    action: defineOperation({ operationId: "inbox.items.action", description: "Apply an exact-version inbox action.", rest: { method: "POST", path: "/v1/teams/{teamId}/inbox/items/{itemId}/actions" }, parameters: "treeseed.inbox.items.action.parameters/v1", capability: "governance.write", authentication: "oauth", oauthScopes: ["treeseed:governance:write"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none", concurrencyRequired: true }, { path: itemPath, query: empty, body: inboxActionRequestSchema, output: inboxMutationReceiptSchema })
+  };
+}
+export {
+  inboxOperations
+};

package/dist/operator-contracts/catalog/infrastructure/ai-instance-operations.d.ts

@@ -0,0 +1,53 @@
+export declare const AI_INSTANCE_OPERATIONS: {
+    storageShow: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, undefined, Record<string, unknown>>;
+    storagePut: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, {
+        connectionId: string;
+        bucket: string;
+    }, Record<string, unknown>>;
+    storageRemove: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, {}, Record<string, unknown>>;
+    register: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, {
+        name: string;
+        projectId: string;
+        purpose: "inference" | "training" | "both";
+        model: string;
+    }, Record<string, unknown>>;
+    list: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, undefined, Record<string, unknown>>;
+    show: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, undefined, Record<string, unknown>>;
+    put: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, {
+        name: string;
+        projectId: string;
+        purpose: "inference" | "training" | "both";
+        timeZone: string;
+        schedule: "weekdays" | "always";
+        hostingConnectionId: string;
+        storageConnectionId: string | null;
+        model: string;
+    }, Record<string, unknown>>;
+    remove: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        instanceId: string;
+    }, {}, {}, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/infrastructure/ai-instance-operations.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { defineOperation } from "../../operation-builder.js";
+import { aiInstanceDraftSchema, aiNodeRegistrationSchema } from "../../../deployment/ai-instance.js";
+import { aiStorageBindingSchema } from "../../../deployment/ai/storage.js";
+const team = z.object({ teamId: z.string().min(1) }).strict(), instance = team.extend({ instanceId: z.string().uuid() });
+const empty = z.object({}).strict(), record = z.record(z.unknown());
+function descriptor(action, method, path) {
+  const read = method === "GET";
+  return { operationId: `ai.instances.${action}`, description: `${action} a team-owned AI configuration; no cloud provisioning.`, rest: { method, path }, parameters: `treeseed.ai.instances.${action}.parameters/v1`, capability: read ? "infrastructure.read" : "infrastructure.write", authentication: "oauth", oauthScopes: read ? ["treeseed:read"] : ["treeseed:admin"], kind: read ? "read" : "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli"], cacheScope: read ? "principal" : "none", pagination: "none", concurrencyRequired: !read };
+}
+const AI_INSTANCE_OPERATIONS = {
+  storageShow: defineOperation({ ...descriptor("storageShow", "GET", "/v1/teams/{teamId}/ai-instances/{instanceId}/storage"), operationId: "ai.instances.storage.show", parameters: "treeseed.ai.instances.storage.show.parameters/v1" }, { path: instance, query: empty, body: z.undefined(), output: record }),
+  storagePut: defineOperation({ ...descriptor("storagePut", "PUT", "/v1/teams/{teamId}/ai-instances/{instanceId}/storage"), operationId: "ai.instances.storage.put", parameters: "treeseed.ai.instances.storage.put.parameters/v1" }, { path: instance, query: empty, body: aiStorageBindingSchema, output: record }),
+  storageRemove: defineOperation({ ...descriptor("storageRemove", "DELETE", "/v1/teams/{teamId}/ai-instances/{instanceId}/storage"), operationId: "ai.instances.storage.remove", parameters: "treeseed.ai.instances.storage.remove.parameters/v1" }, { path: instance, query: empty, body: empty, output: record }),
+  register: defineOperation(descriptor("register", "PUT", "/v1/teams/{teamId}/ai-instances/{instanceId}/registration"), { path: instance, query: empty, body: aiNodeRegistrationSchema, output: record }),
+  list: defineOperation({ ...descriptor("list", "GET", "/v1/teams/{teamId}/ai-instances"), pagination: "cursor" }, { path: team, query: z.object({ cursor: z.string().optional(), limit: z.coerce.number().int().min(1).max(100).optional() }).strict(), body: z.undefined(), output: record }),
+  show: defineOperation(descriptor("show", "GET", "/v1/teams/{teamId}/ai-instances/{instanceId}"), { path: instance, query: empty, body: z.undefined(), output: record }),
+  put: defineOperation(descriptor("put", "PUT", "/v1/teams/{teamId}/ai-instances/{instanceId}"), { path: instance, query: empty, body: aiInstanceDraftSchema, output: record }),
+  remove: defineOperation(descriptor("remove", "DELETE", "/v1/teams/{teamId}/ai-instances/{instanceId}"), { path: instance, query: empty, body: empty, output: record })
+};
+export {
+  AI_INSTANCE_OPERATIONS
+};

package/dist/operator-contracts/catalog/infrastructure/command-tree-paths.d.ts

@@ -0,0 +1,3 @@
+import type { CommandTreeDescriptor } from '../../command-tree.js';
+/** Enumerate leaves without depending on the canonical command inventory. */
+export declare function commandPaths(tree: CommandTreeDescriptor): string[];

package/dist/operator-contracts/catalog/infrastructure/command-tree-paths.js

@@ -0,0 +1,15 @@
+function commandPaths(tree) {
+  const paths = [];
+  const visit = (nodes, parent) => {
+    for (const node of nodes) {
+      const path = [...parent, node.segment];
+      if (node.nodeType === "leaf") paths.push(path.join(" "));
+      else visit(node.children, path);
+    }
+  };
+  visit(tree.commands, []);
+  return paths;
+}
+export {
+  commandPaths
+};

package/dist/operator-contracts/catalog/knowledge-share-operations.d.ts

@@ -0,0 +1,127 @@
+export declare function knowledgeShareOperations(): {
+    shares: {
+        list: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+        }, {}, undefined, {
+            items: {
+                status: "active" | "revoked" | "expired";
+                id: string;
+                schemaVersion: "treeseed.knowledge-share/v1";
+                createdAt: string;
+                updatedAt: string;
+                targetTeamId: string;
+                projectIds: string[];
+                sourceTeamId: string;
+                revokedAt: string | null;
+                expiresAt?: string | null | undefined;
+                operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+                paths?: string[] | undefined;
+                contentModels?: string[] | undefined;
+            }[];
+        }>;
+        show: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            shareId: string;
+        }, {}, undefined, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            schemaVersion: "treeseed.knowledge-share/v1";
+            createdAt: string;
+            updatedAt: string;
+            targetTeamId: string;
+            projectIds: string[];
+            sourceTeamId: string;
+            revokedAt: string | null;
+            expiresAt?: string | null | undefined;
+            operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+            paths?: string[] | undefined;
+            contentModels?: string[] | undefined;
+        }>;
+        grant: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+        }, {}, {
+            targetTeamId: string;
+            projectIds: string[];
+            expiresAt?: string | null | undefined;
+            operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+            paths?: string[] | undefined;
+            contentModels?: string[] | undefined;
+        }, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            schemaVersion: "treeseed.knowledge-share/v1";
+            createdAt: string;
+            updatedAt: string;
+            targetTeamId: string;
+            projectIds: string[];
+            sourceTeamId: string;
+            revokedAt: string | null;
+            expiresAt?: string | null | undefined;
+            operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+            paths?: string[] | undefined;
+            contentModels?: string[] | undefined;
+        }>;
+        revoke: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            shareId: string;
+        }, {}, {}, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            schemaVersion: "treeseed.knowledge-share/v1";
+            createdAt: string;
+            updatedAt: string;
+            targetTeamId: string;
+            projectIds: string[];
+            sourceTeamId: string;
+            revokedAt: string | null;
+            expiresAt?: string | null | undefined;
+            operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+            paths?: string[] | undefined;
+            contentModels?: string[] | undefined;
+        }>;
+    };
+    teamSearch: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, {
+        request: Record<string, unknown>;
+        projectIds?: string[] | undefined;
+        projectSlugs?: string[] | undefined;
+        sharedSources?: {
+            teamId: string;
+            projectIds?: string[] | undefined;
+        }[] | undefined;
+    }, Record<string, unknown>>;
+    teamQuery: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, {
+        request: Record<string, unknown>;
+        projectIds?: string[] | undefined;
+        projectSlugs?: string[] | undefined;
+        sharedSources?: {
+            teamId: string;
+            projectIds?: string[] | undefined;
+        }[] | undefined;
+    }, Record<string, unknown>>;
+    teamContext: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, {
+        request: Record<string, unknown>;
+        projectIds?: string[] | undefined;
+        projectSlugs?: string[] | undefined;
+        sharedSources?: {
+            teamId: string;
+            projectIds?: string[] | undefined;
+        }[] | undefined;
+    }, Record<string, unknown>>;
+    teamGraph: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, {
+        request: Record<string, unknown>;
+        projectIds?: string[] | undefined;
+        projectSlugs?: string[] | undefined;
+        sharedSources?: {
+            teamId: string;
+            projectIds?: string[] | undefined;
+        }[] | undefined;
+    }, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/knowledge-share-operations.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { defineOperation as define } from "../operation-builder.js";
+import { knowledgeShareGrantInputSchema, knowledgeShareSchema, teamKnowledgeRequestSchema } from "../knowledge/contracts.js";
+const none = z.undefined(), empty = z.object({}).strict(), teamPath = z.object({ teamId: z.string().min(1) }).strict();
+const sharePath = z.object({ teamId: z.string().min(1), shareId: z.string().min(1) }).strict();
+const parameters = (operationId) => `treeseed.${operationId}.parameters/v1`;
+const readDescriptor = (operationId, path) => ({ operationId, description: `Read ${operationId}.`, rest: { method: "GET", path }, parameters: parameters(operationId), capability: "knowledge.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "principal", pagination: "none" });
+const execute = (operationId, path) => define({ operationId, description: `Execute ${operationId} across authorized team knowledge.`, rest: { method: "POST", path }, parameters: parameters(operationId), capability: "knowledge.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "mcp_tool"], cacheScope: "none", pagination: "none" }, { path: teamPath, query: empty, body: teamKnowledgeRequestSchema, output: z.record(z.unknown()) });
+function knowledgeShareOperations() {
+  return {
+    shares: {
+      list: define(readDescriptor("knowledge.shares.list", "/v1/teams/{teamId}/knowledge/shares"), { path: teamPath, query: empty, body: none, output: z.object({ items: z.array(knowledgeShareSchema) }).strict() }),
+      show: define(readDescriptor("knowledge.shares.show", "/v1/teams/{teamId}/knowledge/shares/{shareId}"), { path: sharePath, query: empty, body: none, output: knowledgeShareSchema }),
+      grant: define({ operationId: "knowledge.shares.grant", description: "Grant bounded read-only knowledge access to another team.", rest: { method: "POST", path: "/v1/teams/{teamId}/knowledge/shares" }, parameters: parameters("knowledge.shares.grant"), capability: "knowledge.share", authentication: "oauth", oauthScopes: ["treeseed:projects:write"], kind: "mutation", riskClass: "authority", confirmation: "input_required", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, { path: teamPath, query: empty, body: knowledgeShareGrantInputSchema, output: knowledgeShareSchema }),
+      revoke: define({ operationId: "knowledge.shares.revoke", description: "Revoke a cross-team knowledge share.", rest: { method: "DELETE", path: "/v1/teams/{teamId}/knowledge/shares/{shareId}" }, parameters: parameters("knowledge.shares.revoke"), capability: "knowledge.share", authentication: "oauth", oauthScopes: ["treeseed:projects:write"], kind: "mutation", riskClass: "authority", confirmation: "input_required", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, { path: sharePath, query: empty, body: empty, output: knowledgeShareSchema })
+    },
+    teamSearch: execute("knowledge.team.search", "/v1/teams/{teamId}/knowledge/search"),
+    teamQuery: execute("knowledge.team.query", "/v1/teams/{teamId}/knowledge/query"),
+    teamContext: execute("knowledge.team.context", "/v1/teams/{teamId}/knowledge/context"),
+    teamGraph: execute("knowledge.team.graph", "/v1/teams/{teamId}/knowledge/graph")
+  };
+}
+export {
+  knowledgeShareOperations
+};

package/dist/operator-contracts/catalog/provider-environment-commands.d.ts

@@ -0,0 +1,4 @@
+import type { CommandExecutionBinding, CommandNodeDescriptor } from '../command-tree.js';
+export declare const PROVIDER_ENVIRONMENT_COMMAND_BINDINGS: Record<string, CommandExecutionBinding>;
+export declare function hostProviderEnvironmentBranch(): CommandNodeDescriptor;
+export declare function providerEnvironmentBranches(): CommandNodeDescriptor[];

package/dist/operator-contracts/catalog/provider-environment-commands.js

@@ -0,0 +1,69 @@
+const plan = { name: "--plan", description: "Return the exact proposed outcome without mutation.", type: "boolean" };
+const local = (handlerId) => ({ kind: "local", handlerId });
+const operation = (operationId, input) => ({ kind: "operation", operationId, input });
+const path = (field, source, name, required = true) => ({ target: "path", field, source, name, required, transform: "identity" });
+const PROVIDER_ENVIRONMENT_COMMAND_BINDINGS = {
+  "host provider environment list": local("local.host.provider.environment.list"),
+  "host provider environment show": local("local.host.provider.environment.show"),
+  "host provider environment status": local("local.host.provider.environment.status"),
+  "host provider environment set": local("local.host.provider.environment.set"),
+  "host provider environment import": local("local.host.provider.environment.import"),
+  "host provider environment unset": local("local.host.provider.environment.unset"),
+  "host provider environment rotate": local("local.host.provider.environment.rotate"),
+  "host provider environment verify": local("local.host.provider.environment.verify"),
+  "providers registration code status": operation("providers.registration.code.status", [path("teamId", "context", "team")]),
+  "providers registration code reveal": operation("providers.registration.code.reveal", [path("teamId", "context", "team")]),
+  "providers registration code rotate": operation("providers.registration.code.rotate", [path("teamId", "context", "team")]),
+  "providers environments list": operation("providers.environment.profiles.list", [path("teamId", "context", "team"), path("providerId", "argument", "provider"), { target: "query", field: "status", source: "option", name: "status", transform: "identity" }, { target: "query", field: "limit", source: "option", name: "limit", transform: "integer" }, { target: "query", field: "cursor", source: "option", name: "cursor", transform: "identity" }]),
+  "providers environments show": operation("providers.environment.profiles.show", [path("teamId", "context", "team"), path("providerId", "argument", "provider"), path("profileId", "argument", "profile")]),
+  "providers environments grant": operation("providers.environment.grants.put", [path("teamId", "context", "team"), path("assignmentId", "argument", "assignment"), { target: "body", field: "file", source: "option", name: "input", required: true, transform: "identity" }]),
+  "providers environments revoke": operation("providers.environment.grants.revoke", [path("teamId", "context", "team"), path("assignmentId", "argument", "assignment")])
+};
+const profileArguments = [{ name: "profile", description: "Provider-local environment profile.", required: true }];
+const valueArguments = [...profileArguments, { name: "name", description: "Environment variable name.", required: true }];
+const localMutation = (segment, confirmation, description) => ({
+  segment,
+  description,
+  kind: "mutation",
+  arguments: valueArguments,
+  options: [plan, ...segment === "unset" ? [] : [{ name: "--stdin", description: "Read the replacement value from standard input instead of the hidden prompt.", type: "boolean" }]],
+  authorization: { capability: "host.provider.environment.write", confirmation },
+  resultSchemaId: "treeseed.provider-environment-profile/v1",
+  execution: local(`local.host.provider.environment.${segment}`)
+});
+function hostProviderEnvironmentBranch() {
+  const read = (segment) => ({ segment, description: `${segment} a provider-local environment profile.`, kind: "read", arguments: profileArguments, resultSchemaId: "treeseed.provider-environment-profile/v1", execution: local(`local.host.provider.environment.${segment}`) });
+  return { nodeType: "branch", segment: "environment", description: "Provider-local environment profile operations.", children: [
+    { nodeType: "leaf", segment: "list", description: "List provider-local environment profiles without values.", kind: "read", resultSchemaId: "treeseed.provider-environment-profile-page/v1", execution: local("local.host.provider.environment.list") },
+    { nodeType: "leaf", ...read("show") },
+    { nodeType: "leaf", ...read("status") },
+    { nodeType: "leaf", ...localMutation("set", "credential", "Set one provider-local environment value through a hidden prompt or standard input.") },
+    {
+      nodeType: "leaf",
+      segment: "import",
+      description: "Import provider-local environment values from an env file.",
+      kind: "mutation",
+      arguments: profileArguments,
+      options: [plan, { name: "--env-file", description: "Local env file whose values remain under provider custody.", type: "string", required: true }],
+      authorization: { capability: "host.provider.environment.write", confirmation: "credential" },
+      resultSchemaId: "treeseed.provider-environment-profile/v1",
+      execution: local("local.host.provider.environment.import")
+    },
+    { nodeType: "leaf", ...localMutation("unset", "destructive", "Remove one provider-local environment value.") },
+    { nodeType: "leaf", ...localMutation("rotate", "credential", "Replace one provider-local environment value and advance its generation.") },
+    { nodeType: "leaf", ...read("verify") }
+  ] };
+}
+function providerEnvironmentBranches() {
+  const remote = { kind: "unavailable", code: "standards_migration_not_enabled", reason: "Execution binding is attached from the canonical operation map." };
+  const leaf = (segment, kind, arguments_, confirmation = "never", options = kind === "mutation" ? [plan] : void 0) => ({ nodeType: "leaf", segment, description: `${segment} provider environment authority.`, kind, arguments: arguments_, options, authorization: kind === "mutation" ? { capability: `command.${segment}`, confirmation } : void 0, resultSchemaId: `treeseed.command.${segment}/v1`, execution: remote });
+  return [
+    { nodeType: "branch", segment: "registration", description: "Team provider registration operations.", children: [{ nodeType: "branch", segment: "code", description: "Team provider registration-code operations.", children: [leaf("status", "read", void 0), leaf("reveal", "mutation", void 0, "credential"), leaf("rotate", "mutation", void 0, "credential")] }] },
+    { nodeType: "branch", segment: "environments", description: "Provider environment descriptor and grant operations.", children: [leaf("list", "read", [{ name: "provider", description: "Provider identity.", required: true }]), leaf("show", "read", [{ name: "provider", description: "Provider identity.", required: true }, { name: "profile", description: "Profile identity.", required: true }]), leaf("grant", "mutation", [{ name: "assignment", description: "Assignment identity.", required: true }], "authority", [plan, { name: "--input", description: "Digest-bound environment grant document.", type: "string", required: true }]), leaf("revoke", "mutation", [{ name: "assignment", description: "Assignment identity.", required: true }], "destructive")] }
+  ];
+}
+export {
+  PROVIDER_ENVIRONMENT_COMMAND_BINDINGS,
+  hostProviderEnvironmentBranch,
+  providerEnvironmentBranches
+};