@treeseed/sdk 0.13.0-rc.65 → 0.13.0-rc.66

package/dist/graph/context-query-contracts.d.ts

@@ -23,9 +23,24 @@ export interface DeclarativeContextQuery {
         maxCharacters?: number;
     };
     tokenBudget?: number;
+    sources?: Array<{
+        scope: 'current-project' | 'team-library';
+    } | {
+        scope: 'same-team';
+        projectIds?: string[];
+        projectSlugs?: string[];
+    } | {
+        scope: 'shared-team';
+        teamId: string;
+        projectIds?: string[];
+    }>;
+    requirement?: 'required' | 'preferred';
+    priority?: number;
+    minimumBudget?: number;
+    maximumBudget?: number;
+    summarization?: 'none' | 'deterministic' | 'provider';
     format?: DeclarativeContextQueryFormat;
     filters?: Record<string, unknown>;
-    required?: boolean;
 }
 export type HandlerContextPackSource = 'agent_spec' | 'content_frontmatter' | 'work_package' | 'task_payload' | 'default_role_context';
 export interface DeclarativeContextQuerySourceRef {

package/dist/graph/context-query-contracts.js

@@ -68,6 +68,11 @@ function compileDeclarativeContextQuery(query, options = {}) {
   }
   if (query.resultLimit !== void 0 && !asPositiveInteger(query.resultLimit)) errors.push(`Context query "${id || "<unknown>"}" resultLimit must be a positive integer.`);
   if (query.tokenBudget !== void 0 && !asPositiveInteger(query.tokenBudget)) errors.push(`Context query "${id || "<unknown>"}" tokenBudget must be a positive integer.`);
+  if (query.minimumBudget !== void 0 && !asPositiveInteger(query.minimumBudget)) errors.push(`Context query "${id || "<unknown>"}" minimumBudget must be a positive integer.`);
+  if (query.maximumBudget !== void 0 && !asPositiveInteger(query.maximumBudget)) errors.push(`Context query "${id || "<unknown>"}" maximumBudget must be a positive integer.`);
+  if (query.minimumBudget !== void 0 && query.maximumBudget !== void 0 && query.minimumBudget > query.maximumBudget) errors.push(`Context query "${id || "<unknown>"}" minimumBudget cannot exceed maximumBudget.`);
+  if (query.priority !== void 0 && (!Number.isInteger(query.priority) || query.priority < 0 || query.priority > 100)) errors.push(`Context query "${id || "<unknown>"}" priority must be an integer from 0 through 100.`);
+  if (query.sources?.some((source) => source.scope === "shared-team" && !source.teamId.trim())) errors.push(`Context query "${id || "<unknown>"}" shared-team sources require a teamId.`);
   const scope = query.scope === void 0 ? void 0 : normalizeString(query.scope);
   if (scope !== void 0 && (!scope || !scope.startsWith("/"))) {
     errors.push(`Context query "${id || "<unknown>"}" scope must start with "/".`);

package/dist/model-registry/agent-operational-models.js

@@ -23,7 +23,7 @@ const data = (key, alias = key) => field(key, { aliases: alias === key ? [] : [a
 function buildAgentOperationalModelRegistry(repoRoot) {
   const lifecycle = { id: id(), title: title(), status: field("status", { filterable: true, contentKeys: ["status"], writeContentKey: "status" }), team_id: ref("team_id", "teamId"), project_id: ref("project_id", "projectId"), workday_id: ref("workday_id", "workdayId"), assignment_id: ref("assignment_id", "assignmentId"), updated_at: updated() };
   return {
-    agent_context_query: model({ name: "agent_context_query", aliases: ["agent_context_queries"], collection: "agent-context-queries", entityType: "AgentContextQuery", repoRoot, fields: { id: id(), title: title(), description: data("description"), revision: data("revision"), maturity: data("maturity"), purpose: data("purpose"), query: data("query"), target: data("target"), scope: data("scope"), code_scopes: data("code_scopes", "codeScopes"), relations: refs("relations", "relations"), depth: data("depth"), result_limit: data("result_limit", "resultLimit"), context_budget: data("context_budget", "contextBudget"), token_budget: data("token_budget", "tokenBudget"), format: data("format"), filters: data("filters"), required: data("required") } }),
+    agent_context_query: model({ name: "agent_context_query", aliases: ["agent_context_queries"], collection: "agent-context-queries", entityType: "AgentContextQuery", repoRoot, fields: { id: id(), title: title(), description: data("description"), revision: data("revision"), maturity: data("maturity"), purpose: data("purpose"), query: data("query"), target: data("target"), scope: data("scope"), code_scopes: data("code_scopes", "codeScopes"), relations: refs("relations", "relations"), depth: data("depth"), result_limit: data("result_limit", "resultLimit"), context_budget: data("context_budget", "contextBudget"), token_budget: data("token_budget", "tokenBudget"), format: data("format"), filters: data("filters"), sources: data("sources"), requirement: data("requirement"), priority: data("priority"), minimum_budget: data("minimum_budget", "minimumBudget"), maximum_budget: data("maximum_budget", "maximumBudget"), summarization: data("summarization") } }),
     agent_context_query_set: model({ name: "agent_context_query_set", aliases: ["agent_context_query_sets"], collection: "agent-context-query-sets", entityType: "AgentContextQuerySet", repoRoot, fields: { id: id(), title: title(), description: data("description"), revision: data("revision"), query_refs: refs("query_refs", "queryRefs"), merge_policy: data("merge_policy", "mergePolicy") }, references: [{ field: "query_refs", edgeType: "REFERENCES", targetModels: ["agent_context_query"], multiple: true }] }),
     agent_instruction_template: model({ name: "agent_instruction_template", aliases: ["agent_instruction_templates"], collection: "agent-instruction-templates", entityType: "AgentInstructionTemplate", repoRoot, fields: { id: id(), title: title(), description: data("description"), revision: data("revision"), kind: data("kind"), instructions: data("instructions"), output_skeleton: data("output_skeleton", "outputSkeleton"), variables: refs("variables", "variables"), applies_to_profiles: refs("applies_to_profiles", "appliesToProfiles") } }),
     discussion_topic: model({ name: "discussion_topic", aliases: ["discussion_topics"], collection: "discussion-topics", entityType: "DiscussionTopic", repoRoot, fields: { id: id(), title: title(), description: data("description"), slug: field("slug", { filterable: true, contentKeys: ["slug"], writeContentKey: "slug" }), group_ids: refs("group_ids", "groupIds"), parent_topic_id: ref("parent_topic_id", "parentTopicId"), status: field("status", { filterable: true, contentKeys: ["status"], writeContentKey: "status" }) }, references: [{ field: "parent_topic_id", edgeType: "PARENT_OF", targetModels: ["discussion_topic"] }] }),

package/dist/operator-contracts/canonical-command-tree.js

@@ -309,7 +309,7 @@ function libraryRead(segment, extraArguments = [], extraOptions = []) {
     description: `${segment[0].toUpperCase()}${segment.slice(1)} project library knowledge.`,
     kind: "read",
     arguments: ["project", ...extraArguments].map((name) => ({ name, description: `${name} value.`, required: true })),
-    options: [{ name: "--ref", description: "Exact commit or protected library ref.", type: "string" }, ...extraOptions],
+    options: [{ name: "--ref", description: "Earlier historical revision; omit for the current library.", type: "string" }, ...extraOptions],
     resultSchemaId: `treeseed.command.library.${segment}/v1`,
     execution: local(`local.library.${segment}`)
   };

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: "revoked" | "active" | "expired";
+                schemaVersion: "treeseed.knowledge-share/v1";
+                id: string;
+                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: "revoked" | "active" | "expired";
+            schemaVersion: "treeseed.knowledge-share/v1";
+            id: string;
+            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: "revoked" | "active" | "expired";
+            schemaVersion: "treeseed.knowledge-share/v1";
+            id: string;
+            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: "revoked" | "active" | "expired";
+            schemaVersion: "treeseed.knowledge-share/v1";
+            id: string;
+            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/control-plane-operations.d.ts

@@ -645,6 +645,131 @@ export declare const CONTROL_PLANE_OPERATIONS: {
         readonly publishReview: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             reviewId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly shares: {
+            list: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+            }, {}, undefined, {
+                items: {
+                    status: "revoked" | "active" | "expired";
+                    schemaVersion: "treeseed.knowledge-share/v1";
+                    id: string;
+                    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: "revoked" | "active" | "expired";
+                schemaVersion: "treeseed.knowledge-share/v1";
+                id: string;
+                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: "revoked" | "active" | "expired";
+                schemaVersion: "treeseed.knowledge-share/v1";
+                id: string;
+                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: "revoked" | "active" | "expired";
+                schemaVersion: "treeseed.knowledge-share/v1";
+                id: string;
+                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;
+            }>;
+        };
+        readonly 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>>;
+        readonly 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>>;
+        readonly 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>>;
+        readonly 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>>;
     };
     readonly governance: {
         readonly proposals: import("./control-plane-operation.js").ControlPlaneOperationBinding<{

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

@@ -5,6 +5,7 @@ import { inboxOperations } from "./catalog/inbox-operations.js";
 import { adminAccountOperations, adminTeamOperations } from "./catalog/admin-account-team-operations.js";
 import { TREEAI_CONTROL_PLANE_OPERATIONS } from "./catalog/treeai-operations.js";
 import { capabilityOntologyOperations } from "./catalog/capability-ontology-operations.js";
+import { knowledgeShareOperations } from "./catalog/knowledge-share-operations.js";
 import { buildControlPlaneCatalog, flattenControlPlaneOperations } from "./catalog/control-plane-catalog.js";
 const empty = z.object({}).strict();
 const none = z.undefined();
@@ -187,6 +188,7 @@ const CONTROL_PLANE_OPERATIONS = {
     updateStatus: resource("discussions.status.update", "POST", "/v1/discussions/{discussionId}/status", { discussionId: z.string().min(1) }, { capability: "discussions.write", scopes: ["treeseed:knowledge:write"], concurrency: true })
   },
   knowledge: {
+    ...knowledgeShareOperations(),
     library: resource("knowledge.library.list", "GET", "/v1/knowledge/library", {}, { capability: "knowledge.read", surfaces: ["rest", "mcp_tool", "mcp_resource"], pagination: "cursor" }),
     reader: resource("knowledge.reader.show", "GET", "/v1/knowledge/reader", {}, { capability: "knowledge.read", surfaces: ["rest", "mcp_resource"] }),
     context: resource("knowledge.context.show", "GET", "/v1/knowledge/context", {}, { capability: "knowledge.read", surfaces: ["rest", "mcp_tool"] }),

package/dist/operator-contracts/index.d.ts

@@ -9,5 +9,6 @@ export * from './oauth.js';
 export * from './communication/contracts.js';
 export * from './communication/addressing.js';
 export * from './inbox/contracts.js';
+export * from './knowledge/contracts.js';
 export * from '../capacity-provider/capability-ontology.js';
 export * from './seed/seed-bundle.js';

package/dist/operator-contracts/index.js

@@ -9,5 +9,6 @@ export * from "./oauth.js";
 export * from "./communication/contracts.js";
 export * from "./communication/addressing.js";
 export * from "./inbox/contracts.js";
+export * from "./knowledge/contracts.js";
 export * from "../capacity-provider/capability-ontology.js";
 export * from "./seed/seed-bundle.js";

package/dist/operator-contracts/knowledge/contracts.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const knowledgeShareOperationSchema: z.ZodEnum<["read", "query", "context", "graph"]>;
+export declare const knowledgeShareGrantInputSchema: z.ZodObject<{
+    targetTeamId: z.ZodString;
+    projectIds: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    contentModels: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    paths: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    operations: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEnum<["read", "query", "context", "graph"]>, "many">, ("read" | "context" | "query" | "graph")[], ("read" | "context" | "query" | "graph")[]>>;
+    expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    expiresAt: string | null;
+    operations: ("read" | "context" | "query" | "graph")[];
+    paths: string[];
+    targetTeamId: string;
+    projectIds: string[];
+    contentModels: string[];
+}, {
+    targetTeamId: string;
+    projectIds: string[];
+    expiresAt?: string | null | undefined;
+    operations?: ("read" | "context" | "query" | "graph")[] | undefined;
+    paths?: string[] | undefined;
+    contentModels?: string[] | undefined;
+}>;
+export declare const knowledgeShareSchema: z.ZodEffects<z.ZodObject<{
+    targetTeamId: z.ZodString;
+    projectIds: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    contentModels: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    paths: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    operations: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEnum<["read", "query", "context", "graph"]>, "many">, ("read" | "context" | "query" | "graph")[], ("read" | "context" | "query" | "graph")[]>>;
+    expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+} & {
+    schemaVersion: z.ZodLiteral<"treeseed.knowledge-share/v1">;
+    id: z.ZodString;
+    sourceTeamId: z.ZodString;
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    revokedAt: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "revoked" | "active" | "expired";
+    schemaVersion: "treeseed.knowledge-share/v1";
+    id: string;
+    createdAt: string;
+    expiresAt: string | null;
+    operations: ("read" | "context" | "query" | "graph")[];
+    paths: string[];
+    updatedAt: string;
+    targetTeamId: string;
+    projectIds: string[];
+    contentModels: string[];
+    sourceTeamId: string;
+    revokedAt: string | null;
+}, {
+    status: "revoked" | "active" | "expired";
+    schemaVersion: "treeseed.knowledge-share/v1";
+    id: string;
+    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;
+}>, {
+    status: "revoked" | "active" | "expired";
+    schemaVersion: "treeseed.knowledge-share/v1";
+    id: string;
+    createdAt: string;
+    expiresAt: string | null;
+    operations: ("read" | "context" | "query" | "graph")[];
+    paths: string[];
+    updatedAt: string;
+    targetTeamId: string;
+    projectIds: string[];
+    contentModels: string[];
+    sourceTeamId: string;
+    revokedAt: string | null;
+}, {
+    status: "revoked" | "active" | "expired";
+    schemaVersion: "treeseed.knowledge-share/v1";
+    id: string;
+    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;
+}>;
+export declare const teamKnowledgeRequestSchema: z.ZodObject<{
+    projectIds: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    projectSlugs: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    sharedSources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        teamId: z.ZodString;
+        projectIds: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    }, "strict", z.ZodTypeAny, {
+        teamId: string;
+        projectIds: string[];
+    }, {
+        teamId: string;
+        projectIds?: string[] | undefined;
+    }>, "many">>;
+    request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strict", z.ZodTypeAny, {
+    request: Record<string, unknown>;
+    projectIds: string[];
+    projectSlugs: string[];
+    sharedSources: {
+        teamId: string;
+        projectIds: string[];
+    }[];
+}, {
+    request: Record<string, unknown>;
+    projectIds?: string[] | undefined;
+    projectSlugs?: string[] | undefined;
+    sharedSources?: {
+        teamId: string;
+        projectIds?: string[] | undefined;
+    }[] | undefined;
+}>;
+export type KnowledgeShare = z.infer<typeof knowledgeShareSchema>;
+export type KnowledgeShareGrantInput = z.infer<typeof knowledgeShareGrantInputSchema>;
+export type TeamKnowledgeRequest = z.infer<typeof teamKnowledgeRequestSchema>;

package/dist/operator-contracts/knowledge/contracts.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+const nonEmpty = z.string().trim().min(1);
+const uniqueStrings = (minimum = 0) => z.array(nonEmpty).min(minimum).superRefine((values, context) => {
+  if (new Set(values).size !== values.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+});
+const knowledgeShareOperationSchema = z.enum(["read", "query", "context", "graph"]);
+const knowledgeShareGrantInputSchema = z.object({
+  targetTeamId: nonEmpty,
+  projectIds: uniqueStrings(1),
+  contentModels: uniqueStrings().default([]),
+  paths: uniqueStrings(1).default(["**"]),
+  operations: z.array(knowledgeShareOperationSchema).min(1).superRefine((values, context) => {
+    if (new Set(values).size !== values.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Operations must be unique." });
+  }).default(["read", "query", "context", "graph"]),
+  expiresAt: z.string().datetime({ offset: true }).nullable().default(null)
+}).strict();
+const knowledgeShareSchema = knowledgeShareGrantInputSchema.extend({
+  schemaVersion: z.literal("treeseed.knowledge-share/v1"),
+  id: nonEmpty,
+  sourceTeamId: nonEmpty,
+  status: z.enum(["active", "revoked", "expired"]),
+  createdAt: z.string().datetime({ offset: true }),
+  updatedAt: z.string().datetime({ offset: true }),
+  revokedAt: z.string().datetime({ offset: true }).nullable()
+}).strict().superRefine((value, context) => {
+  if (value.sourceTeamId === value.targetTeamId) context.addIssue({ code: z.ZodIssueCode.custom, path: ["targetTeamId"], message: "Knowledge shares are only for another team." });
+});
+const teamKnowledgeRequestSchema = z.object({
+  projectIds: uniqueStrings().default([]),
+  projectSlugs: uniqueStrings().default([]),
+  sharedSources: z.array(z.object({ teamId: nonEmpty, projectIds: uniqueStrings().default([]) }).strict()).default([]),
+  request: z.record(z.unknown())
+}).strict();
+export {
+  knowledgeShareGrantInputSchema,
+  knowledgeShareOperationSchema,
+  knowledgeShareSchema,
+  teamKnowledgeRequestSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.65",
+  "version": "0.13.0-rc.66",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {