@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

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

@@ -2,3 +2,8 @@ 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 './control-plane-operations.js';
+export * from './mcp.js';
+export * from './oauth.js';
+export * from './seed/seed-bundle.js';

package/dist/operator-contracts/index.js

@@ -2,3 +2,8 @@ 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 "./control-plane-operations.js";
+export * from "./mcp.js";
+export * from "./oauth.js";
+export * from "./seed/seed-bundle.js";

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

@@ -0,0 +1,83 @@
+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 declare function encodeConfirmationState(state: ConfirmationState): string;
+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 const TREESEED_MCP_PROMPTS: readonly McpPromptDescriptor[];
+export declare function operationToMcpResource(operation: ControlPlaneOperationDescriptor): McpResourceDescriptor | null;
+export declare function operationToMcpTool(operation: ControlPlaneOperationDescriptor): McpToolDescriptor | null;
+export declare function buildMcpTools(operations: readonly ControlPlaneOperationDescriptor[]): McpToolDescriptor[];
+export declare function buildMcpResources(operations: readonly ControlPlaneOperationDescriptor[]): McpResourceDescriptor[];
+export declare function buildMcpCatalog(operations: readonly ControlPlaneOperationDescriptor[]): McpCatalog;

package/dist/operator-contracts/mcp.js

@@ -0,0 +1,84 @@
+const MCP_PROTOCOL_VERSION = "2026-07-28";
+function encodeConfirmationState(state) {
+  const bytes = new TextEncoder().encode(JSON.stringify(state));
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/gu, "");
+}
+const TREESEED_MCP_PROMPTS = [
+  { name: "operate", description: "Operate TreeSeed through currently discoverable capabilities.", argumentSchemaId: "treeseed.prompt.objective/v1", requiredScopes: ["treeseed:read"] },
+  { name: "research", description: "Research a governed TreeSeed question and accumulate knowledge.", argumentSchemaId: "treeseed.prompt.objective/v1", requiredScopes: ["treeseed:read"] },
+  { name: "governance-review", description: "Review a proposal or decision using current governance evidence.", argumentSchemaId: "treeseed.prompt.objective/v1", requiredScopes: ["treeseed:read"] },
+  { name: "workday-planning", description: "Plan a time-based workday without bypassing API authority.", argumentSchemaId: "treeseed.prompt.objective/v1", requiredScopes: ["treeseed:read"] },
+  { name: "project-agent-chat", description: "Prepare an explicit governed project-agent chat invocation.", argumentSchemaId: "treeseed.prompt.objective/v1", requiredScopes: ["treeseed:read"] }
+];
+function resourcePath(restPath) {
+  const [root, version, ...segments] = restPath.split("/");
+  if (root !== "" || version !== "v1" || segments.length === 0) throw new Error(`MCP resource requires a versioned control-plane REST path: ${restPath}`);
+  const path = segments.join("/");
+  if (path === "me") return "accounts/current";
+  return path.replace(/^platform\/operations(?=\/|$)/u, "operations").replace(/^capacity-plans(?=\/|$)/u, "plans").replace(/\/workday-runs(?=\/|$)/u, "/workdays").replace(/\/capacity\/assignments(?=\/|$)/u, "/assignments");
+}
+function operationToMcpResource(operation) {
+  if (!operation.surfaces.includes("mcp_resource")) return null;
+  if (operation.kind !== "read" || operation.rest.method !== "GET") {
+    throw new Error(`MCP resource operation ${operation.operationId} must be a read-only GET operation.`);
+  }
+  const uriTemplate = `treeseed://${resourcePath(operation.rest.path)}`;
+  const parameters = (value) => [...value.matchAll(/\{([^}]+)\}/gu)].map((match) => match[1]).sort();
+  if (JSON.stringify(parameters(uriTemplate)) !== JSON.stringify(parameters(operation.rest.path))) {
+    throw new Error(`MCP resource ${operation.operationId} must preserve its REST path parameter names.`);
+  }
+  return {
+    uriTemplate,
+    name: operation.operationId,
+    description: operation.description,
+    mimeType: "application/json",
+    operationId: operation.operationId,
+    subscribable: true,
+    ...operation.operationId === "status.show" ? { cacheTtlSeconds: 10 } : {}
+  };
+}
+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));
+}
+function buildMcpResources(operations) {
+  const resources = operations.map(operationToMcpResource).filter((resource) => resource !== null).sort((left, right) => left.uriTemplate.localeCompare(right.uriTemplate));
+  const uriTemplates = new Set(resources.map(({ uriTemplate }) => uriTemplate));
+  if (uriTemplates.size !== resources.length) throw new Error("MCP resource URI templates must be unique.");
+  return resources;
+}
+function buildMcpCatalog(operations) {
+  return {
+    schemaVersion: "treeseed.mcp-catalog/v1",
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    tools: buildMcpTools(operations),
+    resources: buildMcpResources(operations),
+    prompts: [...TREESEED_MCP_PROMPTS],
+    capabilities: { completion: true, progress: true, cancellation: true, inputRequired: true, resourceSubscriptions: true }
+  };
+}
+export {
+  MCP_PROTOCOL_VERSION,
+  TREESEED_MCP_PROMPTS,
+  buildMcpCatalog,
+  buildMcpResources,
+  buildMcpTools,
+  encodeConfirmationState,
+  operationToMcpResource,
+  operationToMcpTool
+};

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

@@ -0,0 +1,46 @@
+import type { OAuthScope } from './control-plane-operation.js';
+export interface ApiPrincipal {
+    id: string;
+    displayName?: string;
+    scopes: string[];
+    roles: string[];
+    permissions: string[];
+    metadata?: Record<string, unknown>;
+}
+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/operation-builder.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { type ControlPlaneOperationBinding, type ControlPlaneOperationDescriptor } from './control-plane-operation.js';
+type Definition = Omit<ControlPlaneOperationDescriptor, 'schemaVersion' | 'schemas' | 'idempotency' | 'concurrency' | 'audited' | 'receipt' | 'redactedPaths' | 'authentication'> & {
+    parameters?: string;
+    redactedPaths?: string[];
+    idempotencyRequired?: boolean;
+    concurrencyRequired?: boolean;
+    authentication?: ControlPlaneOperationDescriptor['authentication'];
+};
+export declare function defineOperation<TPath, TQuery, TBody, TOutput>(definition: Definition, schema: ControlPlaneOperationBinding<TPath, TQuery, TBody, TOutput>['schema']): ControlPlaneOperationBinding<TPath, TQuery, TBody, TOutput>;
+export declare function defineTreeDxProxyOperation<T extends z.ZodRawShape>(operationId: `${string}.${string}`, upstreamOperationId: string | null, method: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT', path: `/v1/${string}`, pathShape: T, options?: {
+    read?: boolean;
+    risk?: ControlPlaneOperationDescriptor['riskClass'];
+    surfaces?: ControlPlaneOperationDescriptor['surfaces'];
+    pagination?: ControlPlaneOperationDescriptor['pagination'];
+}): ControlPlaneOperationBinding<z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+export {};

package/dist/operator-contracts/operation-builder.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { TREEDX_OPENAPI_CONTRACT } from "@treeseed/treedx/openapi";
+import {
+  CONTROL_PLANE_OPERATION_SCHEMA_VERSION
+} from "./control-plane-operation.js";
+function defineOperation(definition, schema) {
+  const { parameters, redactedPaths = [], idempotencyRequired, concurrencyRequired, ...descriptor } = definition;
+  const mutation = definition.kind === "mutation";
+  return {
+    descriptor: {
+      ...descriptor,
+      authentication: definition.authentication ?? (definition.oauthScopes.length ? "oauth" : "anonymous"),
+      schemaVersion: CONTROL_PLANE_OPERATION_SCHEMA_VERSION,
+      schemas: {
+        input: `treeseed.${definition.operationId}.input/v1`,
+        output: `treeseed.${definition.operationId}.output/v1`,
+        errors: "treeseed.problem/v1",
+        ...parameters ? { parameters } : {}
+      },
+      idempotency: { required: idempotencyRequired ?? mutation, header: "Idempotency-Key" },
+      concurrency: { required: concurrencyRequired ?? false, readHeader: "ETag", writeHeader: "If-Match" },
+      audited: definition.surfaces.some((surface) => surface !== "internal"),
+      receipt: mutation,
+      redactedPaths
+    },
+    schema
+  };
+}
+const empty = z.object({}).strict();
+const none = z.undefined();
+const record = z.record(z.unknown());
+function defineTreeDxProxyOperation(operationId, upstreamOperationId, method, path, pathShape, options = {}) {
+  const kind = options.read ?? method === "GET" ? "read" : "mutation";
+  const riskClass = options.risk ?? "ordinary";
+  return defineOperation({
+    operationId,
+    description: `${kind === "read" ? "Read" : "Apply"} ${operationId} through the project-scoped TreeDX proxy.`,
+    rest: { method, path },
+    ...Object.keys(pathShape).length ? { parameters: `treeseed.${operationId}.parameters/v1` } : {},
+    capability: kind === "read" ? "treedx.read" : "treedx.write",
+    authentication: "oauth_or_provider",
+    oauthScopes: kind === "read" ? ["treeseed:read"] : ["treeseed:projects:write"],
+    kind,
+    riskClass,
+    confirmation: riskClass === "ordinary" ? "never" : "input_required",
+    surfaces: options.surfaces ?? ["rest", "mcp_tool", ...method === "GET" ? ["mcp_resource"] : []],
+    cacheScope: kind === "read" ? "project" : "none",
+    pagination: options.pagination ?? "none",
+    ...upstreamOperationId ? { upstream: { service: "treedx", operationId: upstreamOperationId, contractVersion: TREEDX_OPENAPI_CONTRACT.openapiVersion, contractDigest: TREEDX_OPENAPI_CONTRACT.openapiSha256 } } : {}
+  }, {
+    path: z.object(pathShape).strict(),
+    query: method === "GET" ? record : empty,
+    body: method === "GET" ? none : record,
+    output: record
+  });
+}
+export {
+  defineOperation,
+  defineTreeDxProxyOperation
+};

package/dist/operator-contracts/seed/seed-bundle.d.ts

@@ -0,0 +1,123 @@
+import type { ProviderLanePurpose } from '../../agent-capacity/contracts/capacity/communication/communication-records.js';
+export declare const SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v2";
+export type SeedEnvironment = 'local' | 'staging' | 'prod' | string;
+export interface SeedTeamResource {
+    key: string;
+    slug: string;
+    name: string;
+    displayName: string;
+    profileSummary?: string;
+}
+export interface SeedUserMembershipResource {
+    key: string;
+    team: string;
+    principal: {
+        kind: 'user';
+        email: string;
+    };
+    roles: string[];
+    missingUser: 'defer' | 'reject';
+}
+export interface SeedServicePrincipalMembershipResource {
+    key: string;
+    team: string;
+    principal: {
+        kind: 'service-principal';
+        key: string;
+        displayName: string;
+        interactiveLogin: false;
+    };
+    roles: string[];
+}
+export type SeedMembershipResource = SeedUserMembershipResource | SeedServicePrincipalMembershipResource;
+export interface SeedRepositoryPolicy {
+    visibility: 'public' | 'private';
+    lifecycle: 'adopt' | 'create-or-adopt';
+    deletionPolicy: 'retain';
+    defaultBranch: string;
+    stagingBranch: string;
+    issues: boolean;
+    actions: boolean;
+    workflows: string[];
+}
+export interface SeedRepositoryResource {
+    key: string;
+    project: string;
+    role: 'primary' | 'fixture' | 'support' | 'template';
+    provider: 'github';
+    owner: string;
+    name: string;
+    gitUrl: string;
+    defaultBranch: string;
+    checkoutPath?: string;
+    submodulePath?: string;
+    repositoryPolicy: SeedRepositoryPolicy;
+    metadata?: Record<string, unknown>;
+}
+export interface SeedProjectResource {
+    key: string;
+    team: string;
+    slug: string;
+    name: string;
+    description: string;
+    kind: string;
+    primaryRepository?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SeedCapacityProviderPrerequisite {
+    key: string;
+    team: string;
+    environments: SeedEnvironment[];
+    manifestDigest: `sha256:${string}`;
+    manifestRef: string;
+    approval: 'trusted-local-owner';
+    projects: string[];
+    allowedModes: Array<'planning' | 'acting'>;
+    requiredLanePurposes: ProviderLanePurpose[];
+}
+export interface SeedBundleV2 {
+    schemaVersion: typeof SEED_BUNDLE_SCHEMA_VERSION;
+    name: string;
+    version: number;
+    description: string;
+    environments: SeedEnvironment[];
+    digest: `sha256:${string}`;
+    resources: {
+        teams: SeedTeamResource[];
+        memberships: SeedMembershipResource[];
+        projects: SeedProjectResource[];
+        repositories: SeedRepositoryResource[];
+    };
+    runtime: {
+        capacityProviders: SeedCapacityProviderPrerequisite[];
+    };
+}
+export interface SeedResourceReceipt {
+    resourceKey: string;
+    action: 'create' | 'adopt' | 'update' | 'noop' | 'blocked';
+    resourceId?: string;
+    digest: `sha256:${string}`;
+    readBackAt?: string;
+    blockers?: string[];
+}
+export interface SeedReconciliationReceipt {
+    schemaVersion: 'treeseed.seed-reconciliation-receipt/v1';
+    runId: string;
+    seedName: string;
+    seedVersion: number;
+    seedDigest: `sha256:${string}`;
+    mode: 'plan' | 'apply' | 'verify';
+    status: 'planned' | 'waiting_provider' | 'verified' | 'blocked' | 'failed';
+    resources: SeedResourceReceipt[];
+    providerRequestIds: string[];
+    createdAt: string;
+    completedAt?: string;
+}
+export interface SeedBundleDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function canonicalSeedBundlePayload(bundle: Omit<SeedBundleV2, 'digest'> | SeedBundleV2): string;
+export declare function digestSeedBundle(bundle: Omit<SeedBundleV2, 'digest'> | SeedBundleV2): Promise<`sha256:${string}`>;
+export declare function validateSeedBundle(bundle: SeedBundleV2): SeedBundleDiagnostic[];

package/dist/operator-contracts/seed/seed-bundle.js

@@ -0,0 +1,54 @@
+const SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v2";
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonical(entry)]));
+}
+function canonicalSeedBundlePayload(bundle) {
+  const { digest: _digest, ...payload } = bundle;
+  return JSON.stringify(canonical(payload));
+}
+async function digestSeedBundle(bundle) {
+  const bytes = new TextEncoder().encode(canonicalSeedBundlePayload(bundle));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return `sha256:${Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+function validateSeedBundle(bundle) {
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  if (bundle?.schemaVersion !== SEED_BUNDLE_SCHEMA_VERSION) add("seed_bundle_schema_invalid", "schemaVersion", `schemaVersion must be ${SEED_BUNDLE_SCHEMA_VERSION}.`);
+  if (!text(bundle?.name) || !Number.isInteger(bundle?.version) || bundle.version < 1) add("seed_bundle_identity_invalid", "name", "Seed name and positive version are required.");
+  if (!/^sha256:[a-f0-9]{64}$/u.test(bundle?.digest ?? "")) add("seed_bundle_digest_invalid", "digest", "Seed digest must be an exact SHA-256 digest.");
+  const teams = new Set((bundle?.resources?.teams ?? []).map((entry) => entry.key));
+  const projects = new Set((bundle?.resources?.projects ?? []).map((entry) => entry.key));
+  const repositories = new Set((bundle?.resources?.repositories ?? []).map((entry) => entry.key));
+  const allKeys = [...teams, ...projects, ...repositories, ...(bundle?.resources?.memberships ?? []).map((entry) => entry.key)];
+  if (new Set(allKeys).size !== allKeys.length) add("seed_bundle_resource_key_duplicate", "resources", "Every resource key must be globally unique.");
+  for (const [index, membership] of (bundle?.resources?.memberships ?? []).entries()) {
+    if (!teams.has(membership.team)) add("seed_bundle_membership_team_unknown", `resources.memberships[${index}].team`, "Membership references an unknown team.");
+    if (membership.principal.kind === "service-principal" && membership.principal.interactiveLogin !== false) add("seed_bundle_service_principal_interactive_forbidden", `resources.memberships[${index}].principal.interactiveLogin`, "Service principals cannot log in interactively.");
+  }
+  for (const [index, project] of (bundle?.resources?.projects ?? []).entries()) {
+    if (!teams.has(project.team)) add("seed_bundle_project_team_unknown", `resources.projects[${index}].team`, "Project references an unknown team.");
+    if (!project.primaryRepository && project.kind !== "content") add("seed_bundle_primary_repository_required", `resources.projects[${index}].primaryRepository`, "Non-content projects require a primary source repository.");
+    if (project.primaryRepository && !repositories.has(project.primaryRepository)) add("seed_bundle_primary_repository_unknown", `resources.projects[${index}].primaryRepository`, "Project primary repository is missing.");
+  }
+  for (const [index, repository] of (bundle?.resources?.repositories ?? []).entries()) {
+    if (repository.role === "content") add("seed_bundle_content_repository_forbidden", `resources.repositories[${index}].role`, "Virtual knowledge repositories are derived by TreeDX and must not be declared as Git repositories.");
+  }
+  for (const [index, provider] of (bundle?.runtime?.capacityProviders ?? []).entries()) {
+    if (!teams.has(provider.team)) add("seed_bundle_provider_team_unknown", `runtime.capacityProviders[${index}].team`, "Provider references an unknown team.");
+    for (const project of provider.projects) if (!projects.has(project)) add("seed_bundle_provider_project_unknown", `runtime.capacityProviders[${index}].projects`, `Provider references unknown project ${project}.`);
+    for (const purpose of ["communication", "platform", "workday"]) if (!provider.requiredLanePurposes.includes(purpose)) add("seed_bundle_provider_lane_required", `runtime.capacityProviders[${index}].requiredLanePurposes`, `Provider prerequisite requires the ${purpose} lane.`);
+  }
+  return diagnostics;
+}
+export {
+  SEED_BUNDLE_SCHEMA_VERSION,
+  canonicalSeedBundlePayload,
+  digestSeedBundle,
+  validateSeedBundle
+};

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/sdk-types/configuration/sdk-dispatch-credential-source.d.ts

@@ -8,7 +8,7 @@ export type SdkDispatchCredentialSource = {
 };
 export interface SdkDispatchConfig {
     projectId: string;
-    marketBaseUrl: string;
+    controlPlaneBaseUrl: string;
     policy?: SdkDispatchPolicy;
     credentialSource?: SdkDispatchCredentialSource;
     fetchImpl?: typeof fetch;

package/dist/sdk-types/{commerce/catalog/upsert-catalog-item-request.d.ts → control-plane/resource-requests.d.ts}

@@ -1,6 +1,6 @@
-import { CatalogItem } from '../../governance/commons/commons-question-input.js';
-import { ApprovalRequest } from '../../support/planning-policy.js';
-import { CatalogItemOfferMode, CommerceOfferMode } from '../../support/platform-contracts.js';
+import { CatalogItem } from '../governance/commons/commons-question-input.js';
+import { ApprovalRequest } from '../support/planning-policy.js';
+import { CatalogItemOfferMode, PublicationAccessMode } from '../support/platform-contracts.js';
 export interface UpsertCatalogItemRequest {
     id?: string;
     kind: string;
@@ -110,7 +110,7 @@ export interface SdkTemplateCatalogEntry {
         supportsReconcile: boolean;
     };
     offer?: {
-        priceModel?: CommerceOfferMode;
+        priceModel?: PublicationAccessMode;
         license?: string;
         support?: string;
     };

package/dist/sdk-types/support/platform-contracts.d.ts

@@ -173,10 +173,6 @@ export interface SdkDispatchCapability {
     defaultDispatchMode: SdkDispatchPolicy;
     summary?: string;
 }
-export declare const COMMERCE_PRODUCT_KINDS: readonly ["template", "knowledge_pack", "ui_library", "admin_interface", "api_platform", "hosted_project", "professional_hosting", "scoped_service", "capacity_listing"];
-export type CommerceProductKind = typeof COMMERCE_PRODUCT_KINDS[number];
-export declare const COMMERCE_OFFER_MODES: readonly ["free", "private", "contact", "one_time", "one_time_current_version", "subscription", "subscription_updates", "professional_hosting", "scoped_contract", "external"];
-export type CommerceOfferMode = typeof COMMERCE_OFFER_MODES[number];
-export type CatalogItemOfferMode = CommerceOfferMode;
-export declare const COMMERCE_VENDOR_TRUST_LEVELS: readonly ["public_publisher", "verified_seller", "trusted_service_vendor", "trusted_capacity_vendor", "integration_partner"];
-export type CommerceVendorTrustLevel = typeof COMMERCE_VENDOR_TRUST_LEVELS[number];
+export declare const PUBLICATION_ACCESS_MODES: readonly ["free", "private", "contact", "one_time", "one_time_current_version", "subscription", "subscription_updates", "professional_hosting", "scoped_contract", "external"];
+export type PublicationAccessMode = typeof PUBLICATION_ACCESS_MODES[number];
+export type CatalogItemOfferMode = PublicationAccessMode;

package/dist/sdk-types/support/platform-contracts.js

@@ -1,15 +1,4 @@
-const COMMERCE_PRODUCT_KINDS = [
-  "template",
-  "knowledge_pack",
-  "ui_library",
-  "admin_interface",
-  "api_platform",
-  "hosted_project",
-  "professional_hosting",
-  "scoped_service",
-  "capacity_listing"
-];
-const COMMERCE_OFFER_MODES = [
+const PUBLICATION_ACCESS_MODES = [
   "free",
   "private",
   "contact",
@@ -21,15 +10,6 @@ const COMMERCE_OFFER_MODES = [
   "scoped_contract",
   "external"
 ];
-const COMMERCE_VENDOR_TRUST_LEVELS = [
-  "public_publisher",
-  "verified_seller",
-  "trusted_service_vendor",
-  "trusted_capacity_vendor",
-  "integration_partner"
-];
 export {
-  COMMERCE_OFFER_MODES,
-  COMMERCE_PRODUCT_KINDS,
-  COMMERCE_VENDOR_TRUST_LEVELS
+  PUBLICATION_ACCESS_MODES
 };

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;