@treeseed/sdk 0.13.0-rc.3 → 0.13.0-rc.6

package/dist/entrypoints/clients/control-plane-client.d.ts

@@ -0,0 +1,62 @@
+import type { ApiPrincipal } from './remote.js';
+export declare const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+export declare const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+export interface ControlPlaneServerProfile {
+    serverId: string;
+    label: string;
+    baseUrl: string;
+}
+export interface ControlPlaneServerSession {
+    serverId: string;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    principal?: ApiPrincipal | null;
+}
+export interface ControlPlaneClientOptions {
+    profile: ControlPlaneServerProfile;
+    accessToken?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export interface ControlPlaneResponseEnvelope<T> {
+    data: T;
+    meta?: Record<string, unknown>;
+    links?: Record<string, string>;
+}
+export interface ProblemDetails {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    code: string;
+    requestId?: string;
+    traceId?: string;
+    fields?: Record<string, string[]>;
+}
+export interface ControlPlaneCallOptions {
+    method?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+    path: `/v1/${string}` | '/openapi.json';
+    input?: unknown;
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+    ifMatch?: string;
+    signal?: AbortSignal;
+}
+export declare class ControlPlaneClientError extends Error {
+    readonly status: number;
+    readonly problem: ProblemDetails;
+    readonly responseHeaders: Headers;
+    constructor(message: string, status: number, problem: ProblemDetails, responseHeaders: Headers);
+}
+export declare function defaultLocalControlPlaneServer(env?: Record<string, string | undefined>): ControlPlaneServerProfile;
+export declare class ControlPlaneClient {
+    readonly options: ControlPlaneClientOptions;
+    readonly baseUrl: string;
+    readonly accessToken: string | null;
+    readonly fetchImpl: typeof fetch;
+    readonly userAgent?: string;
+    constructor(options: ControlPlaneClientOptions);
+    call<T>(options: ControlPlaneCallOptions): Promise<ControlPlaneResponseEnvelope<T>>;
+}

package/dist/entrypoints/clients/control-plane-client.js

@@ -0,0 +1,96 @@
+const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+class ControlPlaneClientError extends Error {
+  constructor(message, status, problem, responseHeaders) {
+    super(message);
+    this.status = status;
+    this.problem = problem;
+    this.responseHeaders = responseHeaders;
+    this.name = "ControlPlaneClientError";
+  }
+  status;
+  problem;
+  responseHeaders;
+}
+function normalizeBaseUrl(value) {
+  const normalized = value.trim().replace(/\/+$/u, "");
+  if (!/^https?:\/\//u.test(normalized)) throw new Error("Control-plane server URLs must use HTTP or HTTPS.");
+  return normalized;
+}
+function defaultLocalControlPlaneServer(env = process.env) {
+  return {
+    serverId: "local",
+    label: "Local TreeSeed control plane",
+    baseUrl: normalizeBaseUrl(env[CONTROL_PLANE_BASE_URL_ENV] ?? DEFAULT_CONTROL_PLANE_BASE_URL)
+  };
+}
+async function responsePayload(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("json")) return response.json();
+  const text = await response.text();
+  return text.length > 0 ? text : null;
+}
+function problemFrom(payload, status) {
+  const source = payload && typeof payload === "object" ? payload : {};
+  return {
+    type: typeof source.type === "string" ? source.type : "about:blank",
+    title: typeof source.title === "string" ? source.title : "Control-plane request failed",
+    status,
+    detail: typeof source.detail === "string" ? source.detail : void 0,
+    instance: typeof source.instance === "string" ? source.instance : void 0,
+    code: typeof source.code === "string" ? source.code : "control_plane_request_failed",
+    requestId: typeof source.requestId === "string" ? source.requestId : void 0,
+    traceId: typeof source.traceId === "string" ? source.traceId : void 0,
+    fields: source.fields && typeof source.fields === "object" ? source.fields : void 0
+  };
+}
+class ControlPlaneClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.profile.baseUrl);
+    this.accessToken = options.accessToken ?? null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  options;
+  baseUrl;
+  accessToken;
+  fetchImpl;
+  userAgent;
+  async call(options) {
+    const headers = new Headers(options.headers);
+    headers.set("accept", "application/json, application/problem+json");
+    if (this.accessToken) headers.set("authorization", `Bearer ${this.accessToken}`);
+    if (this.userAgent) headers.set("user-agent", this.userAgent);
+    if (options.idempotencyKey) headers.set("idempotency-key", options.idempotencyKey);
+    if (options.ifMatch) headers.set("if-match", options.ifMatch);
+    if (options.input !== void 0) headers.set("content-type", "application/json");
+    const response = await this.fetchImpl(`${this.baseUrl}${options.path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.input === void 0 ? void 0 : JSON.stringify(options.input),
+      signal: options.signal
+    });
+    const payload = await responsePayload(response);
+    if (!response.ok) {
+      const problem = problemFrom(payload, response.status);
+      throw new ControlPlaneClientError(problem.detail ?? problem.title, response.status, problem, response.headers);
+    }
+    if (!payload || typeof payload !== "object" || !("data" in payload)) {
+      throw new ControlPlaneClientError("The control plane returned an invalid success envelope.", 502, {
+        type: "https://treeseed.dev/problems/invalid-upstream-response",
+        title: "Invalid control-plane response",
+        status: 502,
+        code: "control_plane_response_invalid"
+      }, response.headers);
+    }
+    return payload;
+  }
+}
+export {
+  CONTROL_PLANE_BASE_URL_ENV,
+  ControlPlaneClient,
+  ControlPlaneClientError,
+  DEFAULT_CONTROL_PLANE_BASE_URL,
+  defaultLocalControlPlaneServer
+};

package/dist/market-client/interface.d.ts

@@ -119,12 +119,7 @@ declare module "../support/market-client.js" {
         createCapacityGrant: OmitThisParameter<typeof import("./capacity/allocations/creation/create-capacity-grant.js").createCapacityGrantMethod>;
         transitionCapacityGrant: OmitThisParameter<typeof import("./capacity/allocations/updates/transition-capacity-grant.js").transitionCapacityGrantMethod>;
         capacityAllocationSets: OmitThisParameter<typeof import("./capacity/allocations/contracts/capacity-allocation-sets.js").capacityAllocationSetsMethod>;
-        createCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/creation/create-capacity-allocation-set.js").createCapacityAllocationSetMethod>;
-        planCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/creation/plan-capacity-allocation-set.js").planCapacityAllocationSetMethod>;
         capacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/contracts/capacity-allocation-set.js").capacityAllocationSetMethod>;
-        activateCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/lifecycle/activate-capacity-allocation-set.js").activateCapacityAllocationSetMethod>;
-        supersedeCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/updates/supersede-capacity-allocation-set.js").supersedeCapacityAllocationSetMethod>;
-        archiveCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/retirement/archive-capacity-allocation-set.js").archiveCapacityAllocationSetMethod>;
         explainCapacityAllocationSet: OmitThisParameter<typeof import("./capacity/allocations/queries/explain-capacity-allocation-set.js").explainCapacityAllocationSetMethod>;
         providerAvailabilitySessions: OmitThisParameter<typeof import("./capacity/providers/contracts/provider-availability-sessions.js").providerAvailabilitySessionsMethod>;
         capacityProviderAssignments: OmitThisParameter<typeof import("./capacity/assignments/contracts/capacity-provider-assignments.js").capacityProviderAssignmentsMethod>;

package/dist/market-client/internal-capacity-allocation.d.ts

@@ -0,0 +1,4 @@
+import type { MarketClient } from '../entrypoints/clients/market-client.js';
+export declare function createInternalCapacityAllocationSet(client: MarketClient, teamId: string, body: Record<string, unknown>, idempotencyKey: string): any;
+export declare function activateInternalCapacityAllocationSet(client: MarketClient, teamId: string, allocationSetId: string, idempotencyKey: string): any;
+export declare function supersedeInternalCapacityAllocationSet(client: MarketClient, teamId: string, allocationSetId: string, body: Record<string, unknown>, idempotencyKey: string): any;

package/dist/market-client/internal-capacity-allocation.js

@@ -0,0 +1,17 @@
+import { createCapacityAllocationSetMethod } from "./capacity/allocations/creation/create-capacity-allocation-set.js";
+import { activateCapacityAllocationSetMethod } from "./capacity/allocations/lifecycle/activate-capacity-allocation-set.js";
+import { supersedeCapacityAllocationSetMethod } from "./capacity/allocations/updates/supersede-capacity-allocation-set.js";
+function createInternalCapacityAllocationSet(client, teamId, body, idempotencyKey) {
+  return createCapacityAllocationSetMethod.call(client, teamId, body, idempotencyKey);
+}
+function activateInternalCapacityAllocationSet(client, teamId, allocationSetId, idempotencyKey) {
+  return activateCapacityAllocationSetMethod.call(client, teamId, allocationSetId, idempotencyKey);
+}
+function supersedeInternalCapacityAllocationSet(client, teamId, allocationSetId, body, idempotencyKey) {
+  return supersedeCapacityAllocationSetMethod.call(client, teamId, allocationSetId, body, idempotencyKey);
+}
+export {
+  activateInternalCapacityAllocationSet,
+  createInternalCapacityAllocationSet,
+  supersedeInternalCapacityAllocationSet
+};

package/dist/market-client/methods.js

@@ -47,14 +47,9 @@ import { capacityAllocationSetMethod } from "./capacity/allocations/contracts/ca
 import { capacityAllocationSetsMethod } from "./capacity/allocations/contracts/capacity-allocation-sets.js";
 import { capacityGrantMethod } from "./capacity/allocations/contracts/capacity-grant.js";
 import { capacityGrantsMethod } from "./capacity/allocations/contracts/capacity-grants.js";
-import { createCapacityAllocationSetMethod } from "./capacity/allocations/creation/create-capacity-allocation-set.js";
 import { createCapacityGrantMethod } from "./capacity/allocations/creation/create-capacity-grant.js";
-import { planCapacityAllocationSetMethod } from "./capacity/allocations/creation/plan-capacity-allocation-set.js";
 import { planCapacityGrantMethod } from "./capacity/allocations/creation/plan-capacity-grant.js";
-import { activateCapacityAllocationSetMethod } from "./capacity/allocations/lifecycle/activate-capacity-allocation-set.js";
 import { explainCapacityAllocationSetMethod } from "./capacity/allocations/queries/explain-capacity-allocation-set.js";
-import { archiveCapacityAllocationSetMethod } from "./capacity/allocations/retirement/archive-capacity-allocation-set.js";
-import { supersedeCapacityAllocationSetMethod } from "./capacity/allocations/updates/supersede-capacity-allocation-set.js";
 import { transitionCapacityGrantMethod } from "./capacity/allocations/updates/transition-capacity-grant.js";
 import { capacityProviderAssignmentMethod } from "./capacity/assignments/contracts/capacity-provider-assignment.js";
 import { assignmentAuthorityProbeMethod } from "./capacity/assignments/contracts/assignment-authority-probe.js";
@@ -303,12 +298,7 @@ function installMarketClientMethods(prototype) {
   prototype.createCapacityGrant = createCapacityGrantMethod;
   prototype.transitionCapacityGrant = transitionCapacityGrantMethod;
   prototype.capacityAllocationSets = capacityAllocationSetsMethod;
-  prototype.createCapacityAllocationSet = createCapacityAllocationSetMethod;
-  prototype.planCapacityAllocationSet = planCapacityAllocationSetMethod;
   prototype.capacityAllocationSet = capacityAllocationSetMethod;
-  prototype.activateCapacityAllocationSet = activateCapacityAllocationSetMethod;
-  prototype.supersedeCapacityAllocationSet = supersedeCapacityAllocationSetMethod;
-  prototype.archiveCapacityAllocationSet = archiveCapacityAllocationSetMethod;
   prototype.explainCapacityAllocationSet = explainCapacityAllocationSetMethod;
   prototype.providerAvailabilitySessions = providerAvailabilitySessionsMethod;
   prototype.capacityProviderAssignments = capacityProviderAssignmentsMethod;

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

@@ -0,0 +1,60 @@
+export declare const CONTROL_PLANE_OPERATION_SCHEMA_VERSION: "treeseed.control-plane-operation/v1";
+export type ControlPlaneHttpMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export type ControlPlaneOperationKind = 'read' | 'mutation';
+export type ControlPlaneRiskClass = 'ordinary' | 'destructive' | 'credential' | 'authority' | 'production' | 'irreversible';
+export type ControlPlaneConfirmationPolicy = 'never' | 'input_required';
+export type ControlPlaneOperationSurface = 'rest' | 'cli' | 'mcp_tool' | 'mcp_resource' | 'internal';
+export type ControlPlaneCacheScope = 'none' | 'principal' | 'team' | 'project' | 'public';
+export type ControlPlanePaginationKind = 'none' | 'cursor';
+export interface ControlPlaneRestBinding {
+    method: ControlPlaneHttpMethod;
+    path: `/v1/${string}`;
+}
+export interface ControlPlaneSchemaBinding {
+    input: string;
+    output: string;
+    parameters?: string;
+    errors: string;
+}
+export interface ControlPlaneIdempotencyContract {
+    required: boolean;
+    header: 'Idempotency-Key';
+}
+export interface ControlPlaneConcurrencyContract {
+    required: boolean;
+    readHeader: 'ETag';
+    writeHeader: 'If-Match';
+}
+export interface ControlPlaneOperationDescriptor {
+    schemaVersion: typeof CONTROL_PLANE_OPERATION_SCHEMA_VERSION;
+    operationId: `${string}.${string}`;
+    description: string;
+    rest?: ControlPlaneRestBinding;
+    schemas: ControlPlaneSchemaBinding;
+    capability: string;
+    oauthScopes: OAuthScope[];
+    kind: ControlPlaneOperationKind;
+    riskClass: ControlPlaneRiskClass;
+    confirmation: ControlPlaneConfirmationPolicy;
+    idempotency: ControlPlaneIdempotencyContract;
+    concurrency: ControlPlaneConcurrencyContract;
+    surfaces: ControlPlaneOperationSurface[];
+    cacheScope: ControlPlaneCacheScope;
+    pagination: ControlPlanePaginationKind;
+    audited: boolean;
+    receipt: boolean;
+    redactedPaths: string[];
+}
+export declare const TREESEED_OAUTH_SCOPES: readonly ["treeseed:read", "treeseed:knowledge:write", "treeseed:governance:write", "treeseed:projects:write", "treeseed:execution", "treeseed:admin"];
+export type OAuthScope = typeof TREESEED_OAUTH_SCOPES[number];
+export interface ControlPlaneCatalog {
+    schemaVersion: 'treeseed.control-plane-catalog/v1';
+    operations: ControlPlaneOperationDescriptor[];
+}
+export interface ControlPlaneCatalogDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateControlPlaneCatalog(catalog: ControlPlaneCatalog): ControlPlaneCatalogDiagnostic[];
+export declare function indexControlPlaneCatalog(catalog: ControlPlaneCatalog): Map<`${string}.${string}`, ControlPlaneOperationDescriptor>;

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

@@ -0,0 +1,75 @@
+const CONTROL_PLANE_OPERATION_SCHEMA_VERSION = "treeseed.control-plane-operation/v1";
+const TREESEED_OAUTH_SCOPES = [
+  "treeseed:read",
+  "treeseed:knowledge:write",
+  "treeseed:governance:write",
+  "treeseed:projects:write",
+  "treeseed:execution",
+  "treeseed:admin"
+];
+const OPERATION_ID = /^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)+$/u;
+const PATH_PARAMETER = /\{([A-Za-z][A-Za-z0-9]*)\}/gu;
+function duplicates(values) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => seen.size === seen.add(value).size);
+}
+function validateControlPlaneCatalog(catalog) {
+  const diagnostics = [];
+  const operationIds = /* @__PURE__ */ new Set();
+  const restBindings = /* @__PURE__ */ new Set();
+  for (const [index, operation] of catalog.operations.entries()) {
+    const path = `operations.${index}`;
+    if (operation.schemaVersion !== CONTROL_PLANE_OPERATION_SCHEMA_VERSION) {
+      diagnostics.push({ code: "operation_schema_version_invalid", path: `${path}.schemaVersion`, message: "Operation schemaVersion is not supported." });
+    }
+    if (!OPERATION_ID.test(operation.operationId)) {
+      diagnostics.push({ code: "operation_id_invalid", path: `${path}.operationId`, message: "Operation IDs must be stable dotted lowercase words." });
+    }
+    if (operationIds.has(operation.operationId)) {
+      diagnostics.push({ code: "operation_id_duplicate", path: `${path}.operationId`, message: `Duplicate operation ID ${operation.operationId}.` });
+    }
+    operationIds.add(operation.operationId);
+    if (operation.surfaces.includes("rest") !== Boolean(operation.rest)) {
+      diagnostics.push({ code: "rest_binding_mismatch", path: `${path}.rest`, message: "REST surface and REST binding must be declared together." });
+    }
+    if (operation.rest) {
+      const binding = `${operation.rest.method} ${operation.rest.path}`;
+      if (restBindings.has(binding)) diagnostics.push({ code: "rest_binding_duplicate", path: `${path}.rest`, message: `Duplicate REST binding ${binding}.` });
+      restBindings.add(binding);
+      const parameters = [...operation.rest.path.matchAll(PATH_PARAMETER)].map((match) => match[1]);
+      if (parameters.length > 0 && !operation.schemas.parameters) {
+        diagnostics.push({ code: "parameter_schema_required", path: `${path}.schemas.parameters`, message: "Parameterized REST paths require a parameter schema." });
+      }
+    }
+    for (const scope of operation.oauthScopes) {
+      if (!TREESEED_OAUTH_SCOPES.includes(scope)) diagnostics.push({ code: "oauth_scope_invalid", path: `${path}.oauthScopes`, message: `Unknown OAuth scope ${scope}.` });
+    }
+    for (const duplicate of duplicates(operation.surfaces)) diagnostics.push({ code: "surface_duplicate", path: `${path}.surfaces`, message: `Duplicate operation surface ${duplicate}.` });
+    for (const duplicate of duplicates(operation.oauthScopes)) diagnostics.push({ code: "oauth_scope_duplicate", path: `${path}.oauthScopes`, message: `Duplicate OAuth scope ${duplicate}.` });
+    const elevatedRisk = operation.riskClass !== "ordinary";
+    if (elevatedRisk !== (operation.confirmation === "input_required")) {
+      diagnostics.push({ code: "confirmation_policy_invalid", path: `${path}.confirmation`, message: "Elevated-risk operations require input_required; ordinary operations must not." });
+    }
+    if (operation.kind === "read" && (operation.idempotency.required || operation.concurrency.required || operation.receipt)) {
+      diagnostics.push({ code: "read_mutation_contract_invalid", path, message: "Read operations cannot require mutation idempotency, write concurrency, or mutation receipts." });
+    }
+    if (operation.kind === "mutation" && operation.surfaces.some((surface) => surface !== "internal") && !operation.audited) {
+      diagnostics.push({ code: "mutation_audit_required", path: `${path}.audited`, message: "Every externally reachable mutation must be audited." });
+    }
+    if (operation.kind === "mutation" && !operation.receipt) {
+      diagnostics.push({ code: "mutation_receipt_required", path: `${path}.receipt`, message: "Mutations must return durable receipts." });
+    }
+  }
+  return diagnostics.sort((left, right) => `${left.path}:${left.code}`.localeCompare(`${right.path}:${right.code}`));
+}
+function indexControlPlaneCatalog(catalog) {
+  const diagnostics = validateControlPlaneCatalog(catalog);
+  if (diagnostics.length > 0) throw new Error(`Invalid control-plane catalog: ${diagnostics.map((entry) => entry.code).join(", ")}`);
+  return new Map(catalog.operations.map((operation) => [operation.operationId, operation]));
+}
+export {
+  CONTROL_PLANE_OPERATION_SCHEMA_VERSION,
+  TREESEED_OAUTH_SCOPES,
+  indexControlPlaneCatalog,
+  validateControlPlaneCatalog
+};

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

@@ -2,3 +2,6 @@ export * from './command-tree.js';
 export * from './canonical-command-tree.js';
 export * from './workday-profile.js';
 export * from './workday-lifecycle.js';
+export * from './control-plane-operation.js';
+export * from './mcp.js';
+export * from './oauth.js';

package/dist/operator-contracts/index.js

@@ -2,3 +2,6 @@ export * from "./command-tree.js";
 export * from "./canonical-command-tree.js";
 export * from "./workday-profile.js";
 export * from "./workday-lifecycle.js";
+export * from "./control-plane-operation.js";
+export * from "./mcp.js";
+export * from "./oauth.js";

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

@@ -0,0 +1,78 @@
+import type { ControlPlaneOperationDescriptor, OAuthScope } from './control-plane-operation.js';
+export declare const MCP_PROTOCOL_VERSION: "2026-07-28";
+export interface ResourceLink {
+    type: 'resource_link';
+    uri: `treeseed://${string}`;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface ActorChain {
+    principalId: string;
+    delegatedAgentId?: string;
+    oauthClientId: string;
+    interface: 'rest' | 'cli' | 'mcp' | 'site_bff' | 'internal';
+    conversationId?: string;
+    modelClaim?: string;
+    skillClaim?: string;
+    traceId: string;
+}
+export interface ConfirmationState {
+    schemaVersion: 'treeseed.confirmation-state/v1';
+    principalId: string;
+    clientId: string;
+    operationId: string;
+    argumentsDigest: `sha256:${string}`;
+    expiresAt: string;
+    nonce: string;
+    signature: string;
+}
+export interface InputRequired {
+    type: 'input_required';
+    requestId: string;
+    prompt: string;
+    confirmation: ConfirmationState;
+}
+export interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchemaId: string;
+    outputSchemaId: string;
+    operationId: string;
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+}
+export interface McpResourceDescriptor {
+    uriTemplate: `treeseed://${string}`;
+    name: string;
+    description: string;
+    mimeType: string;
+    operationId: string;
+    subscribable: boolean;
+    cacheTtlSeconds?: number;
+}
+export interface McpPromptDescriptor {
+    name: string;
+    description: string;
+    argumentSchemaId: string;
+    requiredScopes: OAuthScope[];
+}
+export interface McpCatalog {
+    schemaVersion: 'treeseed.mcp-catalog/v1';
+    protocolVersion: typeof MCP_PROTOCOL_VERSION;
+    tools: McpToolDescriptor[];
+    resources: McpResourceDescriptor[];
+    prompts: McpPromptDescriptor[];
+    capabilities: {
+        completion: true;
+        progress: true;
+        cancellation: true;
+        inputRequired: true;
+        resourceSubscriptions: true;
+    };
+}
+export declare function operationToMcpTool(operation: ControlPlaneOperationDescriptor): McpToolDescriptor | null;
+export declare function buildMcpTools(operations: readonly ControlPlaneOperationDescriptor[]): McpToolDescriptor[];

package/dist/operator-contracts/mcp.js

@@ -0,0 +1,23 @@
+const MCP_PROTOCOL_VERSION = "2026-07-28";
+function operationToMcpTool(operation) {
+  if (!operation.surfaces.includes("mcp_tool")) return null;
+  return {
+    name: operation.operationId,
+    description: operation.description,
+    inputSchemaId: operation.schemas.input,
+    outputSchemaId: operation.schemas.output,
+    operationId: operation.operationId,
+    readOnlyHint: operation.kind === "read",
+    destructiveHint: operation.riskClass !== "ordinary",
+    idempotentHint: operation.kind === "read" || operation.idempotency.required,
+    openWorldHint: false
+  };
+}
+function buildMcpTools(operations) {
+  return operations.map(operationToMcpTool).filter((tool) => tool !== null).sort((left, right) => left.name.localeCompare(right.name));
+}
+export {
+  MCP_PROTOCOL_VERSION,
+  buildMcpTools,
+  operationToMcpTool
+};

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

@@ -0,0 +1,38 @@
+import type { OAuthScope } from './control-plane-operation.js';
+export interface OAuthAuthorizationServerMetadata {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    device_authorization_endpoint: string;
+    revocation_endpoint: string;
+    response_types_supported: ['code'];
+    grant_types_supported: ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'];
+    code_challenge_methods_supported: ['S256'];
+    scopes_supported: OAuthScope[];
+}
+export interface OAuthProtectedResourceMetadata {
+    resource: string;
+    authorization_servers: string[];
+    scopes_supported: OAuthScope[];
+    bearer_methods_supported: ['header'];
+}
+export interface OAuthDeviceAuthorizationRequest {
+    clientId: string;
+    scope: OAuthScope[];
+}
+export interface OAuthDeviceAuthorizationResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    expiresIn: number;
+    interval: number;
+}
+export interface OAuthTokenReceipt {
+    tokenType: 'Bearer';
+    accessToken: string;
+    expiresIn: number;
+    refreshToken?: string;
+    scope: OAuthScope[];
+    audience: string;
+}

package/dist/operator-contracts/workday-profile.d.ts

@@ -24,6 +24,10 @@ export interface WorkdayAllocationProfile {
         starvationLimitSeconds: number;
     };
 }
+export interface RepositoryWorkdayProfileBundle {
+    schemaVersion: 'treeseed.workday-allocation-profile-bundle/v1';
+    profiles: WorkdayAllocationProfile[];
+}
 export interface ProjectAgentClassMembership {
     projectId: string;
     agentId: string;
@@ -63,4 +67,6 @@ export interface WorkdayBorrowingEvidence {
 export declare function validateOneClassPerProjectAgent(memberships: ProjectAgentClassMembership[], expectedAgents?: ProjectAgentIdentity[]): WorkdayProfileDiagnostic[];
 export declare function validateWorkdayAllocationProfile(profile: WorkdayAllocationProfile, classCatalogs?: ProjectClassCatalog[]): WorkdayProfileDiagnostic[];
 export declare function normalizeWorkdayAllocationProfile(profile: WorkdayAllocationProfile): WorkdayAllocationProfile;
+export declare function validateRepositoryWorkdayProfileBundle(bundle: RepositoryWorkdayProfileBundle, classCatalogs?: ProjectClassCatalog[]): WorkdayProfileDiagnostic[];
+export declare function normalizeRepositoryWorkdayProfileBundle(bundle: RepositoryWorkdayProfileBundle): RepositoryWorkdayProfileBundle;
 export declare function validateWorkdayBorrowingEvidence(evidence: WorkdayBorrowingEvidence): WorkdayProfileDiagnostic[];

package/dist/operator-contracts/workday-profile.js

@@ -71,6 +71,21 @@ function normalizeWorkdayAllocationProfile(profile) {
     demandSources: [...new Set(profile.demandSources)].sort()
   };
 }
+function validateRepositoryWorkdayProfileBundle(bundle, classCatalogs) {
+  const diagnostics = [];
+  if (bundle.schemaVersion !== "treeseed.workday-allocation-profile-bundle/v1") diagnostics.push({ code: "bundle_schema_version_invalid", path: "schemaVersion", message: "Unsupported repository workday profile bundle schema." });
+  if (!Array.isArray(bundle.profiles) || bundle.profiles.length === 0) diagnostics.push({ code: "bundle_profiles_empty", path: "profiles", message: "A repository workday profile bundle must contain at least one profile." });
+  const profileIds = /* @__PURE__ */ new Set();
+  for (const [index, profile] of (Array.isArray(bundle.profiles) ? bundle.profiles : []).entries()) {
+    if (profileIds.has(profile.id)) diagnostics.push({ code: "bundle_profile_id_duplicate", path: `profiles.${index}.id`, message: `Stable profile id ${profile.id} is declared more than once; a repository bundle contains exactly one current generation per profile.` });
+    profileIds.add(profile.id);
+    diagnostics.push(...validateWorkdayAllocationProfile(profile, classCatalogs).map((diagnostic) => ({ ...diagnostic, path: `profiles.${index}.${diagnostic.path}` })));
+  }
+  return diagnostics;
+}
+function normalizeRepositoryWorkdayProfileBundle(bundle) {
+  return { schemaVersion: "treeseed.workday-allocation-profile-bundle/v1", profiles: [...bundle.profiles].map(normalizeWorkdayAllocationProfile).sort((left, right) => left.id.localeCompare(right.id) || left.version.localeCompare(right.version)) };
+}
 function validateWorkdayBorrowingEvidence(evidence) {
   const diagnostics = [];
   if (!evidence.lendingPermitted) diagnostics.push({ code: "lending_not_permitted", path: "lendingPermitted", message: "The profile does not permit the lender to lend capacity." });
@@ -82,8 +97,10 @@ function validateWorkdayBorrowingEvidence(evidence) {
   return diagnostics;
 }
 export {
+  normalizeRepositoryWorkdayProfileBundle,
   normalizeWorkdayAllocationProfile,
   validateOneClassPerProjectAgent,
+  validateRepositoryWorkdayProfileBundle,
   validateWorkdayAllocationProfile,
   validateWorkdayBorrowingEvidence
 };

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-competition.js

@@ -1,4 +1,5 @@
 import { ProviderProtocolClient } from "../../../capacity/providers/capacity-provider.js";
+import { activateInternalCapacityAllocationSet, createInternalCapacityAllocationSet } from "../../../market-client/internal-capacity-allocation.js";
 function projectRecord(payload) {
   const project = payload.project ?? payload;
   if (!project.id) throw new Error("Capacity competition project creation omitted its project id.");
@@ -96,7 +97,7 @@ async function provisionLocalCapacityCompetition(input) {
     }, `${prefix}:grant-create`);
     grantCreated = true;
     await input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "activate", `${prefix}:grant-activate`);
-    const allocation = await input.adminClient.createCapacityAllocationSet(input.runtime.teamId, {
+    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
       id: allocationId,
       effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
       effectiveUntil: new Date(Date.now() + 10 * 6e4).toISOString(),
@@ -105,7 +106,7 @@ async function provisionLocalCapacityCompetition(input) {
       borrowingRules: [],
       metadata: { liveAcceptance: true, runId: input.runId }
     }, `${prefix}:allocation-create`);
-    const activeAllocation = await input.adminClient.activateCapacityAllocationSet(input.runtime.teamId, String(allocation.payload.id), `${prefix}:allocation-activate`);
+    const activeAllocation = await activateInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), `${prefix}:allocation-activate`);
     availability = await providerClient.refreshAvailabilitySession(sessionId, {
       expectedSequence: availability.payload.sequence,
       environment: "local",

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-proof.js

@@ -1,5 +1,6 @@
 import { ProviderProtocolClient } from "../../../capacity/providers/capacity-provider.js";
 import { MarketClient } from "../../../entrypoints/clients/market-client.js";
+import { activateInternalCapacityAllocationSet, createInternalCapacityAllocationSet } from "../../../market-client/internal-capacity-allocation.js";
 import { runLocalAutonomousStarterAcceptances } from "../../support/acceptance/live-acceptance-starters.js";
 import { configuredLiveAcceptanceValue } from "../../support/acceptance/live-acceptance-values.js";
 import { cleanupCapacityAssignmentProof } from "./live-acceptance-capacity-cleanup.js";
@@ -179,7 +180,7 @@ async function runCapacityProviderAssignmentProof(input) {
     let activeAllocation = effectiveActiveAllocation(Array.isArray(allocations.payload.items) ? allocations.payload.items : []);
     if (!activeAllocation?.id && input.environment === "local" && cleanupProvisionedProvider) {
       const allocationId = `${input.prefix}-allocation`;
-      const created = await adminClient.createCapacityAllocationSet(config.teamId, {
+      const created = await createInternalCapacityAllocationSet(adminClient, config.teamId, {
         id: allocationId,
         effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
         effectiveUntil: new Date(Date.now() + 10 * 6e4).toISOString(),
@@ -193,7 +194,8 @@ async function runCapacityProviderAssignmentProof(input) {
         borrowingRules: [],
         metadata
       }, `capacity-acceptance:${input.runId}:allocation-create`);
-      activeAllocation = (await adminClient.activateCapacityAllocationSet(
+      activeAllocation = (await activateInternalCapacityAllocationSet(
+        adminClient,
         config.teamId,
         String(created.payload.id),
         `capacity-acceptance:${input.runId}:allocation-activate`

package/dist/reconcile/runtime/live-acceptance-starter-runtime.js

@@ -3,6 +3,7 @@ import {
   ProviderProtocolClient,
   signCapacityProviderProof
 } from "../../capacity/providers/capacity-provider.js";
+import { createInternalCapacityAllocationSet, supersedeInternalCapacityAllocationSet } from "../../market-client/internal-capacity-allocation.js";
 import { bindLocalCapacityTreeDxRepository, syncLocalAcceptanceAgentClasses } from "../capacity/capacity-core/live-acceptance-capacity-context.js";
 const LIVE_PROVIDER_ASSIGNMENT_BUDGET_SECONDS = 600;
 const TERMINAL_WORKDAY_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed", "degraded"]);
@@ -192,7 +193,7 @@ async function provisionLocalStarterCapacity(input) {
     }, `${key}:grant-create`);
     grantCreated = true;
     await input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "activate", `${key}:grant-activate`);
-    const allocation = await input.adminClient.createCapacityAllocationSet(input.runtime.teamId, {
+    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
       id: allocationId,
       effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
       effectiveUntil: new Date(Date.now() + (durationSeconds + 300) * 1e3).toISOString(),
@@ -202,7 +203,7 @@ async function provisionLocalStarterCapacity(input) {
       metadata: { liveAcceptance: true, runId: input.runId, starter: input.config.starter }
     }, `${key}:allocation-create`);
     const active = (await input.adminClient.capacityAllocationSets(input.runtime.teamId, { limit: 200 })).payload.items.find((entry) => entry && typeof entry === "object" && entry.status === "active");
-    await input.adminClient.supersedeCapacityAllocationSet(input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
+    await supersedeInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
     availability = await protocol.refreshAvailabilitySession(sessionId, {
       expectedSequence: availability.payload.sequence,
       environment: "local",
@@ -372,7 +373,7 @@ async function provisionLocalStarterPortfolioCapacity(input) {
     }
     const durationSeconds = Math.max(...input.configs.map(localStarterDurationSeconds));
     const allocationId = `${key}:allocation`;
-    const allocation = await input.adminClient.createCapacityAllocationSet(input.runtime.teamId, {
+    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
       id: allocationId,
       effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
       effectiveUntil: new Date(Date.now() + (durationSeconds + 300) * 1e3).toISOString(),
@@ -382,7 +383,7 @@ async function provisionLocalStarterPortfolioCapacity(input) {
       metadata: { liveAcceptance: true, runId: input.runId, concurrentStarters: true }
     }, `${key}:allocation-create`);
     const active = (await input.adminClient.capacityAllocationSets(input.runtime.teamId, { limit: 200 })).payload.items.find((entry) => entry && typeof entry === "object" && entry.status === "active");
-    await input.adminClient.supersedeCapacityAllocationSet(input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
+    await supersedeInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
     availability = await protocol.refreshAvailabilitySession(sessionId, {
       expectedSequence: availability.payload.sequence,
       environment: "local",

package/dist/scenes/agent-lab/production-lifecycle.js

@@ -1,5 +1,6 @@
 import { ProviderProtocolClient } from "../../capacity/providers/capacity-provider.js";
 import { MarketClient } from "../../entrypoints/clients/market-client.js";
+import { createInternalCapacityAllocationSet, supersedeInternalCapacityAllocationSet } from "../../market-client/internal-capacity-allocation.js";
 import {
   provisionLocalCapacityAcceptanceProvider,
   syncLocalAcceptanceAgentClasses
@@ -288,7 +289,7 @@ function createProductionAgentLabExecutor(options) {
         }, `agent-lab:${input.runId}:grant-create`);
         await client.transitionCapacityGrant(scope.teamId, grantId, "activate", `agent-lab:${input.runId}:grant-activate`);
         const allocationId = `agent-lab:${input.runId}:allocation`;
-        allocation = (await client.createCapacityAllocationSet(scope.teamId, {
+        allocation = (await createInternalCapacityAllocationSet(client, scope.teamId, {
           id: allocationId,
           effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
           effectiveUntil: new Date(Date.now() + input.config.workdays.reduce((sum, day) => sum + day.durationSeconds, 0) * 1e3 + 6e5).toISOString(),
@@ -297,7 +298,7 @@ function createProductionAgentLabExecutor(options) {
           slices: [{ id: `${allocationId}:market`, scope: "project", targetId: scope.projectId, policy: { minPercent: 0, targetPercent: 100, maxPercent: 100, hardCapPercent: 100 } }],
           metadata: { agentLab: true, runId: input.runId }
         }, `agent-lab:${input.runId}:allocation-create`)).payload;
-        await client.supersedeCapacityAllocationSet(scope.teamId, text(allocation.id), { expectedActiveAllocationSetId: null }, `agent-lab:${input.runId}:allocation-activate`);
+        await supersedeInternalCapacityAllocationSet(client, scope.teamId, text(allocation.id), { expectedActiveAllocationSetId: null }, `agent-lab:${input.runId}:allocation-activate`);
         availability = await protocol.refreshAvailabilitySession(sessionId, {
           expectedSequence: availability.payload.sequence,
           environment: "local",

package/dist/seeds/runtime/local-capacity.js

@@ -12,6 +12,7 @@ import {
 } from "../../capacity/providers/capacity-provider.js";
 import { MarketClient } from "../../entrypoints/clients/market-client.js";
 import { MarketClientError } from "../../entrypoints/clients/market-client.js";
+import { createInternalCapacityAllocationSet, supersedeInternalCapacityAllocationSet } from "../../market-client/internal-capacity-allocation.js";
 function object(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -346,7 +347,7 @@ async function reconcilePolicy(input) {
   }
   if (!allocation) {
     const target = 100 / allocationProjectIds.length;
-    const created = await input.client.createCapacityAllocationSet(input.teamId, {
+    const created = await createInternalCapacityAllocationSet(input.client, input.teamId, {
       id: allocationId,
       effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
       effectiveUntil: "2100-01-01T00:00:00.000Z",
@@ -359,7 +360,8 @@ async function reconcilePolicy(input) {
   }
   if (string(allocation.status) !== "active") {
     const expectedActiveAllocationSetId = string(activeAllocation?.id);
-    await input.client.supersedeCapacityAllocationSet(
+    await supersedeInternalCapacityAllocationSet(
+      input.client,
       input.teamId,
       allocationId,
       { expectedActiveAllocationSetId },

package/dist/standards/mcp/compare.d.ts

@@ -0,0 +1,2 @@
+import type { McpCompatibilityComparison, McpContractModel } from './contracts.js';
+export declare function compareMcp(baseline: McpContractModel, candidate: McpContractModel): McpCompatibilityComparison;

package/dist/standards/mcp/compare.js

@@ -0,0 +1,38 @@
+const rank = { unchanged: 0, compatible_addition: 1, breaking: 2 };
+function same(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function compareMcp(baseline, candidate) {
+  const findings = [];
+  const add = (code, path, message, classification) => findings.push({ code, path, message, classification });
+  if (baseline.protocolVersion !== candidate.protocolVersion) add("mcp_protocol_changed", "protocolVersion", "The MCP protocol version changed.", "breaking");
+  for (const [name, tool] of Object.entries(baseline.tools)) {
+    const next = candidate.tools[name];
+    if (!next) {
+      add("mcp_tool_removed", `tools.${name}`, "An MCP tool was removed.", "breaking");
+      continue;
+    }
+    if (!same(tool.inputSchema, next.inputSchema)) add("mcp_tool_input_changed", `tools.${name}.inputSchema`, "Tool input changed.", "breaking");
+    if (!same(tool.outputSchema, next.outputSchema)) add("mcp_tool_output_changed", `tools.${name}.outputSchema`, "Tool output changed.", "breaking");
+    if (next.requiredScopes.some((scope) => !tool.requiredScopes.includes(scope))) add("mcp_tool_scope_escalated", `tools.${name}.requiredScopes`, "Tool scope requirements increased.", "breaking");
+    if (tool.riskClass !== next.riskClass) add("mcp_tool_risk_changed", `tools.${name}.riskClass`, "Tool risk classification changed.", "breaking");
+  }
+  for (const name of Object.keys(candidate.tools).filter((name2) => !(name2 in baseline.tools))) add("mcp_tool_added", `tools.${name}`, "An MCP tool was added.", "compatible_addition");
+  for (const [uri, resource] of Object.entries(baseline.resources)) {
+    const next = candidate.resources[uri];
+    if (!next) add("mcp_resource_removed", `resources.${uri}`, "An MCP resource was removed.", "breaking");
+    else if (!same(resource, next)) add("mcp_resource_changed", `resources.${uri}`, "An MCP resource contract changed.", "breaking");
+  }
+  for (const uri of Object.keys(candidate.resources).filter((uri2) => !(uri2 in baseline.resources))) add("mcp_resource_added", `resources.${uri}`, "An MCP resource was added.", "compatible_addition");
+  for (const [name, prompt] of Object.entries(baseline.prompts)) {
+    const next = candidate.prompts[name];
+    if (!next) add("mcp_prompt_removed", `prompts.${name}`, "An MCP prompt was removed.", "breaking");
+    else if (!same(prompt, next)) add("mcp_prompt_changed", `prompts.${name}`, "An MCP prompt contract changed.", "breaking");
+  }
+  for (const name of Object.keys(candidate.prompts).filter((name2) => !(name2 in baseline.prompts))) add("mcp_prompt_added", `prompts.${name}`, "An MCP prompt was added.", "compatible_addition");
+  findings.sort((left, right) => `${left.path}:${left.code}`.localeCompare(`${right.path}:${right.code}`));
+  return { classification: findings.reduce((value, finding) => rank[finding.classification] > rank[value] ? finding.classification : value, "unchanged"), findings };
+}
+export {
+  compareMcp
+};

package/dist/standards/mcp/contracts.d.ts

@@ -0,0 +1,34 @@
+import type { CompatibilityClassification } from '../contracts.js';
+import type { OAuthScope } from '../../operator-contracts/control-plane-operation.js';
+export interface McpNormalizedTool {
+    inputSchema: unknown;
+    outputSchema: unknown;
+    requiredScopes: OAuthScope[];
+    riskClass: string;
+}
+export interface McpNormalizedResource {
+    uriTemplate: string;
+    operationId: string;
+    subscribable: boolean;
+}
+export interface McpNormalizedPrompt {
+    argumentSchema: unknown;
+    requiredScopes: OAuthScope[];
+}
+export interface McpContractModel {
+    schemaVersion: 1;
+    protocolVersion: string;
+    tools: Record<string, McpNormalizedTool>;
+    resources: Record<string, McpNormalizedResource>;
+    prompts: Record<string, McpNormalizedPrompt>;
+}
+export interface McpCompatibilityFinding {
+    code: string;
+    path: string;
+    message: string;
+    classification: CompatibilityClassification;
+}
+export interface McpCompatibilityComparison {
+    classification: CompatibilityClassification;
+    findings: McpCompatibilityFinding[];
+}

package/dist/standards/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './contracts.js';
+export * from './normalize.js';
+export * from './compare.js';

package/dist/standards/mcp/index.js

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./normalize.js";
+export * from "./compare.js";

package/dist/standards/mcp/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { McpCatalog } from '../../operator-contracts/mcp.js';
+import type { ControlPlaneOperationDescriptor } from '../../operator-contracts/control-plane-operation.js';
+import type { McpContractModel } from './contracts.js';
+export declare function normalizeMcpCatalog(catalog: McpCatalog, operations: readonly ControlPlaneOperationDescriptor[], schemas: Readonly<Record<string, unknown>>): McpContractModel;

package/dist/standards/mcp/normalize.js

@@ -0,0 +1,30 @@
+import { canonicalizeStandardsValue } from "../canonicalize.js";
+function normalizeMcpCatalog(catalog, operations, schemas) {
+  const operationById = new Map(operations.map((operation) => [operation.operationId, operation]));
+  return {
+    schemaVersion: 1,
+    protocolVersion: catalog.protocolVersion,
+    tools: Object.fromEntries([...catalog.tools].sort((left, right) => left.name.localeCompare(right.name)).map((tool) => {
+      const operation = operationById.get(tool.operationId);
+      if (!operation) throw new Error(`MCP tool ${tool.name} references unknown operation ${tool.operationId}.`);
+      return [tool.name, {
+        inputSchema: canonicalizeStandardsValue(schemas[tool.inputSchemaId] ?? {}),
+        outputSchema: canonicalizeStandardsValue(schemas[tool.outputSchemaId] ?? {}),
+        requiredScopes: [...operation.oauthScopes].sort(),
+        riskClass: operation.riskClass
+      }];
+    })),
+    resources: Object.fromEntries([...catalog.resources].sort((left, right) => left.uriTemplate.localeCompare(right.uriTemplate)).map((resource) => [resource.uriTemplate, {
+      uriTemplate: resource.uriTemplate,
+      operationId: resource.operationId,
+      subscribable: resource.subscribable
+    }])),
+    prompts: Object.fromEntries([...catalog.prompts].sort((left, right) => left.name.localeCompare(right.name)).map((prompt) => [prompt.name, {
+      argumentSchema: canonicalizeStandardsValue(schemas[prompt.argumentSchemaId] ?? {}),
+      requiredScopes: [...prompt.requiredScopes].sort()
+    }]))
+  };
+}
+export {
+  normalizeMcpCatalog
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.3",
+	"version": "0.13.0-rc.6",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "Apache-2.0",
   "repository": {
@@ -135,6 +135,10 @@
       "types": "./dist/standards/openapi/index.d.ts",
       "default": "./dist/standards/openapi/index.js"
     },
+    "./standards/mcp": {
+      "types": "./dist/standards/mcp/index.d.ts",
+      "default": "./dist/standards/mcp/index.js"
+    },
     "./operator-contracts": {
       "types": "./dist/operator-contracts/index.d.ts",
       "default": "./dist/operator-contracts/index.js"
@@ -215,6 +219,10 @@
       "types": "./dist/entrypoints/clients/market-client.d.ts",
       "default": "./dist/entrypoints/clients/market-client.js"
     },
+    "./control-plane-client": {
+      "types": "./dist/entrypoints/clients/control-plane-client.d.ts",
+      "default": "./dist/entrypoints/clients/control-plane-client.js"
+    },
     "./market-gateway": {
       "types": "./dist/gateway/index.d.ts",
       "default": "./dist/gateway/index.js"