@treeseed/sdk 0.13.0-rc.34 → 0.13.0-rc.36

package/dist/deployment/schemas.d.ts

@@ -425,12 +425,26 @@ export declare const hostConfigurationSchema: z.ZodObject<{
         role: string;
         architecture: "amd64";
     }>;
-    runtime: z.ZodObject<{
+    runtime: z.ZodEffects<z.ZodObject<{
         management: z.ZodEnum<["managed", "external"]>;
+        environment: z.ZodDefault<z.ZodEnum<["production", "development"]>>;
+        dataRoot: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         management: "managed" | "external";
+        environment: "development" | "production";
+        dataRoot?: string | undefined;
+    }, {
+        management: "managed" | "external";
+        environment?: "development" | "production" | undefined;
+        dataRoot?: string | undefined;
+    }>, {
+        management: "managed" | "external";
+        environment: "development" | "production";
+        dataRoot?: string | undefined;
     }, {
         management: "managed" | "external";
+        environment?: "development" | "production" | undefined;
+        dataRoot?: string | undefined;
     }>;
     updates: z.ZodObject<{
         defaultTrack: z.ZodEnum<["stable", "development"]>;
@@ -1145,6 +1159,8 @@ export declare const hostConfigurationSchema: z.ZodObject<{
     };
     runtime: {
         management: "managed" | "external";
+        environment: "development" | "production";
+        dataRoot?: string | undefined;
     };
     updates: {
         stable: {
@@ -1253,6 +1269,8 @@ export declare const hostConfigurationSchema: z.ZodObject<{
     };
     runtime: {
         management: "managed" | "external";
+        environment?: "development" | "production" | undefined;
+        dataRoot?: string | undefined;
     };
     updates: {
         stable: {

package/dist/deployment/schemas.js

@@ -69,7 +69,14 @@ const hostConfigurationSchema = z.object({
     role: hostRoleSchema,
     architecture: z.literal("amd64")
   }).strict(),
-  runtime: z.object({ management: z.enum(["managed", "external"]) }).strict(),
+  runtime: z.object({
+    management: z.enum(["managed", "external"]),
+    environment: z.enum(["production", "development"]).default("production"),
+    dataRoot: z.string().startsWith("/").regex(/\/\.treeseed\/data$/u, "Development dataRoot must end with /.treeseed/data.").optional()
+  }).strict().superRefine((runtime, context) => {
+    if (runtime.environment === "development" && !runtime.dataRoot) context.addIssue({ code: z.ZodIssueCode.custom, path: ["dataRoot"], message: "Development hosts require an explicit workspace-visible dataRoot." });
+    if (runtime.environment === "production" && runtime.dataRoot) context.addIssue({ code: z.ZodIssueCode.custom, path: ["dataRoot"], message: "Production hosts use manager-owned /var/lib state and cannot override dataRoot." });
+  }),
   updates: z.object({
     defaultTrack: deploymentTrackSchema,
     stable: z.object({

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

@@ -98,6 +98,23 @@ const operationBindings = {
   "projects treedx workspaces list": operation("treedx.workspaces.list", [field("path", "projectId", "argument", "project", true), ...page()]),
   "projects treedx workspaces show": operation("treedx.workspaces.show", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
   "projects treedx workspaces abandon": operation("treedx.workspaces.abandon", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
+  "library show": local("local.library.show"),
+  "library status": local("local.library.status"),
+  "library paths": local("local.library.paths"),
+  "library read": local("local.library.read"),
+  "library search": local("local.library.search"),
+  "library query": local("local.library.query"),
+  "library context": local("local.library.context"),
+  "library workspace create": operation("knowledge.workspaces.create", [field("path", "projectId", "argument", "project", true), field("body", "requestId", "option", "request")]),
+  "library workspace show": operation("knowledge.workspaces.show", [field("path", "workspaceId", "argument", "workspace", true)]),
+  "library workspace read": operation("knowledge.workspaces.content.show", [field("path", "workspaceId", "argument", "workspace", true), field("query", "path", "argument", "path", true)]),
+  "library workspace diff": operation("knowledge.workspaces.diff", [field("path", "workspaceId", "argument", "workspace", true)]),
+  "library workspace write": operation("knowledge.workspaces.content.update", [field("path", "workspaceId", "argument", "workspace", true), field("body", "file", "option", "input", true)]),
+  "library workspace submit": operation("knowledge.workspaces.submit", [field("path", "workspaceId", "argument", "workspace", true), field("body", "version", "option", "version", true, "integer"), field("body", "message", "option"), field("body", "notes", "option"), field("body", "contextDigest", "option", "contextDigest")]),
+  "library workspace abandon": operation("knowledge.workspaces.abandon", [field("path", "workspaceId", "argument", "workspace", true), field("body", "version", "option", "version", true, "integer")]),
+  "library reviews list": operation("knowledge.reviews.list", [field("path", "teamId", "context", "team", true), ...page()]),
+  "library reviews decide": operation("knowledge.reviews.decide", [field("path", "reviewId", "argument", "review", true), field("body", "file", "option", "input", true)]),
+  "library reviews publish": operation("knowledge.reviews.publish", [field("path", "reviewId", "argument", "review", true), field("body", "file", "option", "input")]),
   "status": operation("status.show"),
   "save": unavailable("Unified GitHub-backed save is intentionally fail-closed during this cutover."),
   "stage": unavailable("Unified GitHub-backed stage is intentionally fail-closed during this cutover."),
@@ -134,23 +151,49 @@ function hostReset() {
   return value;
 }
 function userCreate() {
-  const value = leaf("create", "mutation", void 0, "credential");
+  const value = leaf("create", "mutation");
   if (value.nodeType !== "leaf") throw new Error("User creation must be a leaf command.");
   value.description = "Create a local TreeSeed user with a securely prompted password.";
   value.options = [
     ...value.options ?? [],
     { name: "--email", description: "Email address for the new user.", type: "string" },
     { name: "--username", description: "Unique username for the new user.", type: "string" },
-    { name: "--display-name", description: "Human-readable display name.", type: "string" }
+    { name: "--display-name", description: "Human-readable display name.", type: "string" },
+    { name: "--timeout", description: "Maximum seconds to wait for registration.", type: "number" }
   ];
   return value;
 }
+function authLogin() {
+  const value = leaf("login", "mutation");
+  if (value.nodeType !== "leaf") throw new Error("Authentication login must be a leaf command.");
+  value.options = [
+    ...value.options ?? [],
+    { name: "--timeout", description: "Maximum seconds to wait for device authorization.", type: "number" }
+  ];
+  return value;
+}
+function libraryRead(segment, extraArguments = [], extraOptions = []) {
+  return {
+    nodeType: "leaf",
+    segment,
+    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],
+    resultSchemaId: `treeseed.command.library.${segment}/v1`,
+    execution: local(`local.library.${segment}`)
+  };
+}
+function addOptions(node, options) {
+  if (node.nodeType === "leaf") node.options = [...node.options ?? [], ...options];
+  return node;
+}
 const commandTree = {
   schemaVersion: "treeseed.command-tree/v1",
   executable: "trsd",
   commands: [
     { nodeType: "leaf", segment: "send", description: "Send a message to project agents through a team discussion channel.", kind: "mutation", arguments: [{ name: "channel", description: "Team discussion channel.", required: true }, { name: "message", description: "Markdown message to send.", required: true }], options: [planOption, { name: "--team", description: "Team identity or slug.", type: "string" }, { name: "--project", description: "Default project for unqualified agent names.", type: "string" }, { name: "--to", description: "Agent target; use project/agent when names may be ambiguous.", type: "string[]" }, { name: "--topic", description: "Optional discussion topic.", type: "string" }, { name: "--wait", description: "Seconds to wait for durable responses.", type: "number", defaultValue: 0 }], authorization: { capability: "agents.execute", confirmation: "never" }, resultSchemaId: "treeseed.communication-send-receipt/v1", execution: unavailable() },
-    branch("auth", [leaf("login", "mutation", void 0, "credential"), leaf("logout", "mutation"), leaf("status")]),
+    branch("auth", [authLogin(), leaf("logout", "mutation"), leaf("status")]),
     branch("users", [userCreate()]),
     branch("secrets", [leaf("list"), leaf("status"), leaf("unlock", "mutation", void 0, "credential"), leaf("lock", "mutation"), leaf("rotate", "mutation", void 0, "credential")]),
     branch("host", [
@@ -217,6 +260,25 @@ const commandTree = {
       leaf("capabilities", "read", "project"),
       branch("workspaces", [leaf("list", "read", "project"), leaf("show", "read", "workspace"), leaf("abandon", "mutation", "workspace", "destructive")])
     ])]),
+    branch("library", [
+      libraryRead("show"),
+      libraryRead("status"),
+      libraryRead("paths", [], [{ name: "--prefix", description: "Repository-relative path prefix.", type: "string" }, { name: "--limit", description: "Page size.", type: "number" }, { name: "--cursor", description: "Opaque page cursor.", type: "string" }]),
+      libraryRead("read", ["path"]),
+      libraryRead("search", ["query"], [{ name: "--path", description: "Restrict search to a repository-relative path.", type: "string" }, { name: "--limit", description: "Page size.", type: "number" }, { name: "--cursor", description: "Opaque page cursor.", type: "string" }]),
+      libraryRead("query", ["query"], [{ name: "--model", description: "TreeDX content model.", type: "string" }, { name: "--input", description: "YAML or JSON query body.", type: "string" }]),
+      libraryRead("context", ["query"], [{ name: "--max-items", description: "Maximum context items.", type: "number" }, { name: "--max-tokens", description: "Maximum context tokens.", type: "number" }]),
+      branch("workspace", [
+        addOptions(leaf("create", "mutation", "project"), [{ name: "--request", description: "Replay-safe UUID request identity.", type: "string" }]),
+        leaf("show", "read", "workspace"),
+        { nodeType: "leaf", segment: "read", description: "Read a file from a governed library workspace.", kind: "read", arguments: [{ name: "workspace", description: "Workspace identity.", required: true }, { name: "path", description: "Repository-relative path.", required: true }], resultSchemaId: "treeseed.command.library.workspace.read/v1", execution: unavailable() },
+        leaf("diff", "read", "workspace"),
+        addOptions(leaf("write", "mutation", "workspace"), [{ name: "--input", description: "YAML or JSON draft body.", type: "string", required: true }]),
+        addOptions(leaf("submit", "mutation", "workspace"), [{ name: "--version", description: "Expected workspace version.", type: "number", required: true }, { name: "--message", description: "Commit message.", type: "string" }, { name: "--notes", description: "Review notes.", type: "string" }, { name: "--context-digest", description: "Verified editorial context digest.", type: "string" }]),
+        addOptions(leaf("abandon", "mutation", "workspace", "destructive"), [{ name: "--version", description: "Expected workspace version.", type: "number", required: true }])
+      ]),
+      branch("reviews", [leaf("list"), addOptions(leaf("decide", "mutation", "review"), [{ name: "--input", description: "YAML or JSON review decision.", type: "string", required: true }]), addOptions(leaf("publish", "mutation", "review"), [{ name: "--input", description: "Optional YAML or JSON publication body.", type: "string" }])])
+    ]),
     leaf("save", "mutation"),
     leaf("stage", "mutation", void 0, "authority"),
     leaf("release", "mutation", void 0, "production"),

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

@@ -184,17 +184,17 @@ const CONTROL_PLANE_OPERATIONS = {
     search: resource("knowledge.search", "GET", "/v1/knowledge/search", {}, { capability: "knowledge.read", surfaces: ["rest", "mcp_tool"], pagination: "cursor" }),
     teamCatalog: resource("knowledge.catalog.team", "GET", "/v1/teams/{teamId}/knowledge/catalog", { teamId: z.string().min(1) }, { capability: "knowledge.read", pagination: "cursor" }),
     projectCatalog: resource("knowledge.catalog.project", "GET", "/v1/projects/{projectId}/knowledge/catalog", { projectId: z.string().min(1) }, { capability: "knowledge.read", pagination: "cursor" }),
-    createWorkspace: resource("knowledge.workspaces.create", "POST", "/v1/projects/{projectId}/knowledge/workspaces", { projectId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"] }),
-    workspace: resource("knowledge.workspaces.show", "GET", "/v1/knowledge/workspaces/{workspaceId}", { workspaceId: z.string().min(1) }, { capability: "knowledge.read" }),
-    workspaceContent: resource("knowledge.workspaces.content.show", "GET", "/v1/knowledge/workspaces/{workspaceId}/content", { workspaceId: z.string().min(1) }, { capability: "knowledge.read" }),
-    updateWorkspaceContent: resource("knowledge.workspaces.content.update", "PUT", "/v1/knowledge/workspaces/{workspaceId}/content", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], concurrency: true }),
-    workspaceDiff: resource("knowledge.workspaces.diff", "GET", "/v1/knowledge/workspaces/{workspaceId}/diff", { workspaceId: z.string().min(1) }, { capability: "knowledge.read" }),
-    abandonWorkspace: resource("knowledge.workspaces.abandon", "POST", "/v1/knowledge/workspaces/{workspaceId}/abandon", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], risk: "destructive", concurrency: true }),
-    submitWorkspace: resource("knowledge.workspaces.submit", "POST", "/v1/knowledge/workspaces/{workspaceId}/submit", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], concurrency: true }),
-    reviews: resource("knowledge.reviews.list", "GET", "/v1/teams/{teamId}/knowledge/reviews", { teamId: z.string().min(1) }, { capability: "knowledge.review", pagination: "cursor" }),
+    createWorkspace: resource("knowledge.workspaces.create", "POST", "/v1/projects/{projectId}/knowledge/workspaces", { projectId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"] }),
+    workspace: resource("knowledge.workspaces.show", "GET", "/v1/knowledge/workspaces/{workspaceId}", { workspaceId: z.string().min(1) }, { capability: "knowledge.read", surfaces: ["rest", "cli"] }),
+    workspaceContent: resource("knowledge.workspaces.content.show", "GET", "/v1/knowledge/workspaces/{workspaceId}/content", { workspaceId: z.string().min(1) }, { capability: "knowledge.read", surfaces: ["rest", "cli"] }),
+    updateWorkspaceContent: resource("knowledge.workspaces.content.update", "PUT", "/v1/knowledge/workspaces/{workspaceId}/content", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"], concurrency: true }),
+    workspaceDiff: resource("knowledge.workspaces.diff", "GET", "/v1/knowledge/workspaces/{workspaceId}/diff", { workspaceId: z.string().min(1) }, { capability: "knowledge.read", surfaces: ["rest", "cli"] }),
+    abandonWorkspace: resource("knowledge.workspaces.abandon", "POST", "/v1/knowledge/workspaces/{workspaceId}/abandon", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"], risk: "destructive", concurrency: true }),
+    submitWorkspace: resource("knowledge.workspaces.submit", "POST", "/v1/knowledge/workspaces/{workspaceId}/submit", { workspaceId: z.string().min(1) }, { capability: "knowledge.write", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"], concurrency: true }),
+    reviews: resource("knowledge.reviews.list", "GET", "/v1/teams/{teamId}/knowledge/reviews", { teamId: z.string().min(1) }, { capability: "knowledge.review", surfaces: ["rest", "cli"], pagination: "cursor" }),
     commentReview: resource("knowledge.reviews.comments.create", "POST", "/v1/knowledge/reviews/{reviewId}/comments", { reviewId: z.string().min(1) }, { capability: "knowledge.review", scopes: ["treeseed:knowledge:write"] }),
-    decideReview: resource("knowledge.reviews.decide", "POST", "/v1/knowledge/reviews/{reviewId}/decision", { reviewId: z.string().min(1) }, { capability: "knowledge.review", scopes: ["treeseed:knowledge:write"], concurrency: true }),
-    publishReview: resource("knowledge.reviews.publish", "POST", "/v1/knowledge/reviews/{reviewId}/publish", { reviewId: z.string().min(1) }, { capability: "knowledge.publish", scopes: ["treeseed:knowledge:write"], concurrency: true })
+    decideReview: resource("knowledge.reviews.decide", "POST", "/v1/knowledge/reviews/{reviewId}/decision", { reviewId: z.string().min(1) }, { capability: "knowledge.review", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"], concurrency: true }),
+    publishReview: resource("knowledge.reviews.publish", "POST", "/v1/knowledge/reviews/{reviewId}/publish", { reviewId: z.string().min(1) }, { capability: "knowledge.publish", scopes: ["treeseed:knowledge:write"], surfaces: ["rest", "cli"], concurrency: true })
   },
   governance: {
     proposals: resource("governance.proposals.list", "GET", "/v1/projects/{projectId}/proposals", { projectId: z.string().min(1) }, { capability: "governance.read", surfaces: ["rest", "mcp_tool", "mcp_resource"], pagination: "cursor" }),

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

@@ -1,5 +1,6 @@
 import type { ProviderLanePurpose } from '../../agent-capacity/contracts/capacity/communication/communication-records.js';
-export declare const SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v2";
+export declare const SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v3";
+export declare const HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v2";
 export type SeedEnvironment = 'local' | 'staging' | 'prod' | string;
 export interface SeedTeamResource {
     key: string;
@@ -43,7 +44,7 @@ export interface SeedRepositoryPolicy {
 export interface SeedRepositoryResource {
     key: string;
     project: string;
-    role: 'primary' | 'fixture' | 'support' | 'template';
+    role: 'primary' | 'library' | 'fixture' | 'support' | 'template';
     provider: 'github';
     owner: string;
     name: string;
@@ -62,6 +63,7 @@ export interface SeedProjectResource {
     description: string;
     kind: string;
     primaryRepository?: string;
+    libraryRepository: string;
     metadata?: Record<string, unknown>;
 }
 export interface SeedCapacityProviderPrerequisite {
@@ -75,8 +77,7 @@ export interface SeedCapacityProviderPrerequisite {
     allowedModes: Array<'planning' | 'acting'>;
     requiredLanePurposes: ProviderLanePurpose[];
 }
-export interface SeedBundleV2 {
-    schemaVersion: typeof SEED_BUNDLE_SCHEMA_VERSION;
+interface SeedBundleBody {
     name: string;
     version: number;
     description: string;
@@ -92,6 +93,19 @@ export interface SeedBundleV2 {
         capacityProviders: SeedCapacityProviderPrerequisite[];
     };
 }
+export interface SeedBundleV3 extends SeedBundleBody {
+    schemaVersion: typeof SEED_BUNDLE_SCHEMA_VERSION;
+}
+/** Historical receipt shape. It is decodable, but cannot be planned or applied. */
+export interface SeedBundleV2 extends Omit<SeedBundleBody, 'resources'> {
+    schemaVersion: typeof HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION;
+    resources: Omit<SeedBundleBody['resources'], 'projects'> & {
+        projects: Array<Omit<SeedProjectResource, 'libraryRepository'> & {
+            libraryRepository?: string;
+        }>;
+    };
+}
+export type SeedBundle = SeedBundleV3 | SeedBundleV2;
 export interface SeedResourceReceipt {
     resourceKey: string;
     action: 'create' | 'adopt' | 'update' | 'noop' | 'blocked';
@@ -118,6 +132,7 @@ export interface SeedBundleDiagnostic {
     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[];
+export declare function canonicalSeedBundlePayload(bundle: Omit<SeedBundle, 'digest'> | SeedBundle): string;
+export declare function digestSeedBundle(bundle: Omit<SeedBundle, 'digest'> | SeedBundle): Promise<`sha256:${string}`>;
+export declare function validateSeedBundle(bundle: SeedBundle): SeedBundleDiagnostic[];
+export {};

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

@@ -1,4 +1,5 @@
-const SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v2";
+const SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v3";
+const HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v2";
 function text(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
@@ -19,7 +20,11 @@ async function digestSeedBundle(bundle) {
 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 (bundle?.schemaVersion === HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION) {
+    add("seed_bundle_v2_migration_required", "schemaVersion", `Historical v2 bundles remain readable but must be migrated to ${SEED_BUNDLE_SCHEMA_VERSION} before planning or apply.`);
+  } else 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));
@@ -35,9 +40,17 @@ function validateSeedBundle(bundle) {
     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.");
+    if (!project.libraryRepository) add("seed_bundle_library_repository_required", `resources.projects[${index}].libraryRepository`, "Every project requires one library repository.");
+    if (project.libraryRepository && !repositories.has(project.libraryRepository)) add("seed_bundle_library_repository_unknown", `resources.projects[${index}].libraryRepository`, "Project library 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.");
+    if (repository.role === "content") add("seed_bundle_content_repository_renamed", `resources.repositories[${index}].role`, "Repository-backed knowledge uses role library.");
+  }
+  for (const [index, project] of (bundle?.resources?.projects ?? []).entries()) {
+    const library = (bundle?.resources?.repositories ?? []).find((entry) => entry.key === project.libraryRepository);
+    if (library && (library.role !== "library" || library.project !== project.key)) add("seed_bundle_library_repository_mismatch", `resources.projects[${index}].libraryRepository`, "libraryRepository must reference a library-role repository owned by this project.");
+    const projectLibraries = (bundle?.resources?.repositories ?? []).filter((entry) => entry.project === project.key && entry.role === "library");
+    if (projectLibraries.length !== 1) add("seed_bundle_library_repository_count_invalid", `resources.projects[${index}].libraryRepository`, "Every project must declare exactly one library-role repository.");
   }
   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.");
@@ -47,6 +60,7 @@ function validateSeedBundle(bundle) {
   return diagnostics;
 }
 export {
+  HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION,
   SEED_BUNDLE_SCHEMA_VERSION,
   canonicalSeedBundlePayload,
   digestSeedBundle,

package/package.json

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