@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/agent-capacity/contracts/capacity/assignments/assignment-context-pack.d.ts

@@ -0,0 +1,304 @@
+import { z } from 'zod';
+export declare const contextSourceSelectorSchema: z.ZodDiscriminatedUnion<"scope", [z.ZodObject<{
+    scope: z.ZodLiteral<"current-project">;
+}, "strict", z.ZodTypeAny, {
+    scope: "current-project";
+}, {
+    scope: "current-project";
+}>, z.ZodObject<{
+    scope: z.ZodLiteral<"team-library">;
+}, "strict", z.ZodTypeAny, {
+    scope: "team-library";
+}, {
+    scope: "team-library";
+}>, z.ZodObject<{
+    scope: z.ZodLiteral<"same-team">;
+    projectIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    projectSlugs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    scope: "same-team";
+    projectIds: string[];
+    projectSlugs: string[];
+}, {
+    scope: "same-team";
+    projectIds?: string[] | undefined;
+    projectSlugs?: string[] | undefined;
+}>, z.ZodObject<{
+    scope: z.ZodLiteral<"shared-team">;
+    teamId: z.ZodString;
+    projectIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    teamId: string;
+    scope: "shared-team";
+    projectIds: string[];
+}, {
+    teamId: string;
+    scope: "shared-team";
+    projectIds?: string[] | undefined;
+}>]>;
+export declare const assignmentContextSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    layer: z.ZodEnum<["core", "agent", "activity", "live", "tool"]>;
+    kind: z.ZodString;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    path: z.ZodNullable<z.ZodString>;
+    digest: z.ZodString;
+    disposition: z.ZodEnum<["included", "summarized", "omitted", "failed"]>;
+    required: z.ZodBoolean;
+    measurement: z.ZodObject<{
+        unit: z.ZodEnum<["tokens", "bytes", "items"]>;
+        amount: z.ZodNumber;
+        provenance: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    }, {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    path: string | null;
+    id: string;
+    digest: string;
+    required: boolean;
+    projectId: string;
+    teamId: string;
+    kind: string;
+    reason: string | null;
+    metadata: Record<string, unknown>;
+    measurement: {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    };
+    layer: "live" | "core" | "tool" | "agent" | "activity";
+    disposition: "failed" | "included" | "summarized" | "omitted";
+}, {
+    path: string | null;
+    id: string;
+    digest: string;
+    required: boolean;
+    projectId: string;
+    teamId: string;
+    kind: string;
+    reason: string | null;
+    measurement: {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    };
+    layer: "live" | "core" | "tool" | "agent" | "activity";
+    disposition: "failed" | "included" | "summarized" | "omitted";
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const assignmentContextPackSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.assignment-context-pack/v1">;
+    assignmentId: z.ZodString;
+    capacity: z.ZodObject<{
+        mode: z.ZodEnum<["bounded", "unbounded"]>;
+        measurement: z.ZodNullable<z.ZodEnum<["tokens", "bytes", "items"]>>;
+        defaultInitial: z.ZodNullable<z.ZodNumber>;
+        maximum: z.ZodNullable<z.ZodNumber>;
+        reservedOutput: z.ZodNullable<z.ZodNumber>;
+        transportPayloadBytes: z.ZodNumber;
+        measurementProvenance: z.ZodObject<{
+            provider: z.ZodString;
+            implementation: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        }, {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        maximum: number | null;
+        mode: "bounded" | "unbounded";
+        measurement: "items" | "tokens" | "bytes" | null;
+        defaultInitial: number | null;
+        reservedOutput: number | null;
+        transportPayloadBytes: number;
+        measurementProvenance: {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        };
+    }, {
+        maximum: number | null;
+        mode: "bounded" | "unbounded";
+        measurement: "items" | "tokens" | "bytes" | null;
+        defaultInitial: number | null;
+        reservedOutput: number | null;
+        transportPayloadBytes: number;
+        measurementProvenance: {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        };
+    }>;
+    totals: z.ZodObject<{
+        tokens: z.ZodNumber;
+        bytes: z.ZodNumber;
+        items: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        items: number;
+        tokens: number;
+        bytes: number;
+    }, {
+        items: number;
+        tokens: number;
+        bytes: number;
+    }>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        layer: z.ZodEnum<["core", "agent", "activity", "live", "tool"]>;
+        kind: z.ZodString;
+        teamId: z.ZodString;
+        projectId: z.ZodString;
+        path: z.ZodNullable<z.ZodString>;
+        digest: z.ZodString;
+        disposition: z.ZodEnum<["included", "summarized", "omitted", "failed"]>;
+        required: z.ZodBoolean;
+        measurement: z.ZodObject<{
+            unit: z.ZodEnum<["tokens", "bytes", "items"]>;
+            amount: z.ZodNumber;
+            provenance: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        }, {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        path: string | null;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        kind: string;
+        reason: string | null;
+        metadata: Record<string, unknown>;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "live" | "core" | "tool" | "agent" | "activity";
+        disposition: "failed" | "included" | "summarized" | "omitted";
+    }, {
+        path: string | null;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        kind: string;
+        reason: string | null;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "live" | "core" | "tool" | "agent" | "activity";
+        disposition: "failed" | "included" | "summarized" | "omitted";
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.assignment-context-pack/v1";
+    sources: {
+        path: string | null;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        kind: string;
+        reason: string | null;
+        metadata: Record<string, unknown>;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "live" | "core" | "tool" | "agent" | "activity";
+        disposition: "failed" | "included" | "summarized" | "omitted";
+    }[];
+    digest: string;
+    assignmentId: string;
+    capacity: {
+        maximum: number | null;
+        mode: "bounded" | "unbounded";
+        measurement: "items" | "tokens" | "bytes" | null;
+        defaultInitial: number | null;
+        reservedOutput: number | null;
+        transportPayloadBytes: number;
+        measurementProvenance: {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        };
+    };
+    totals: {
+        items: number;
+        tokens: number;
+        bytes: number;
+    };
+}, {
+    schemaVersion: "treeseed.assignment-context-pack/v1";
+    sources: {
+        path: string | null;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        kind: string;
+        reason: string | null;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "live" | "core" | "tool" | "agent" | "activity";
+        disposition: "failed" | "included" | "summarized" | "omitted";
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    digest: string;
+    assignmentId: string;
+    capacity: {
+        maximum: number | null;
+        mode: "bounded" | "unbounded";
+        measurement: "items" | "tokens" | "bytes" | null;
+        defaultInitial: number | null;
+        reservedOutput: number | null;
+        transportPayloadBytes: number;
+        measurementProvenance: {
+            version: string | null;
+            provider: string;
+            implementation: string;
+        };
+    };
+    totals: {
+        items: number;
+        tokens: number;
+        bytes: number;
+    };
+}>;
+export type ContextSourceSelector = z.infer<typeof contextSourceSelectorSchema>;
+export type AssignmentContextSource = z.infer<typeof assignmentContextSourceSchema>;
+export type AssignmentContextPack = z.infer<typeof assignmentContextPackSchema>;

package/dist/agent-capacity/contracts/capacity/assignments/assignment-context-pack.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+const nonEmpty = z.string().trim().min(1);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const contextSourceSelectorSchema = z.discriminatedUnion("scope", [
+  z.object({ scope: z.literal("current-project") }).strict(),
+  z.object({ scope: z.literal("team-library") }).strict(),
+  z.object({ scope: z.literal("same-team"), projectIds: z.array(nonEmpty).default([]), projectSlugs: z.array(nonEmpty).default([]) }).strict(),
+  z.object({ scope: z.literal("shared-team"), teamId: nonEmpty, projectIds: z.array(nonEmpty).default([]) }).strict()
+]);
+const assignmentContextSourceSchema = z.object({
+  id: nonEmpty,
+  layer: z.enum(["core", "agent", "activity", "live", "tool"]),
+  kind: nonEmpty,
+  teamId: nonEmpty,
+  projectId: nonEmpty,
+  path: nonEmpty.nullable(),
+  digest,
+  disposition: z.enum(["included", "summarized", "omitted", "failed"]),
+  required: z.boolean(),
+  measurement: z.object({ unit: z.enum(["tokens", "bytes", "items"]), amount: z.number().int().nonnegative(), provenance: nonEmpty }).strict(),
+  reason: z.string().nullable(),
+  metadata: z.record(z.unknown()).default({})
+}).strict();
+const assignmentContextPackSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-context-pack/v1"),
+  assignmentId: nonEmpty,
+  capacity: z.object({
+    mode: z.enum(["bounded", "unbounded"]),
+    measurement: z.enum(["tokens", "bytes", "items"]).nullable(),
+    defaultInitial: z.number().int().positive().nullable(),
+    maximum: z.number().int().positive().nullable(),
+    reservedOutput: z.number().int().nonnegative().nullable(),
+    transportPayloadBytes: z.number().int().positive(),
+    measurementProvenance: z.object({ provider: nonEmpty, implementation: nonEmpty, version: z.string().nullable() }).strict()
+  }).strict(),
+  totals: z.object({ tokens: z.number().int().nonnegative(), bytes: z.number().int().nonnegative(), items: z.number().int().nonnegative() }).strict(),
+  sources: z.array(assignmentContextSourceSchema),
+  digest
+}).strict();
+export {
+  assignmentContextPackSchema,
+  assignmentContextSourceSchema,
+  contextSourceSelectorSchema
+};

package/dist/agent-capacity/contracts/capacity/assignments/assignment-records.d.ts

@@ -75,6 +75,15 @@ export interface TreeDxProxyHandle {
     allowedPaths?: string[];
     allowedReadPaths?: string[];
     allowedWritePaths?: string[];
+    readRepositories?: Array<{
+        projectId: string;
+        projectSlug: string;
+        repositoryId: string;
+        baseRef: string;
+        allowedPaths: string[];
+        allowedModels: string[];
+        source: 'team-library' | 'same-team' | 'shared-team';
+    }>;
     metadata?: Record<string, unknown>;
 }
 export interface ProviderAssignmentCapabilityHandleBase {

package/dist/agent-capacity/contracts/capacity/assignments/context-pack-compiler.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderContextCapacity } from '../../../../capacity-provider/capability-ontology.js';
+import type { AssignmentContextPack, AssignmentContextSource } from './assignment-context-pack.js';
+export interface ContextPackCandidate {
+    source: Omit<AssignmentContextSource, 'disposition' | 'measurement' | 'reason'>;
+    measurement: {
+        unit: 'tokens' | 'bytes' | 'items';
+        amount: number;
+        provenance: string;
+    };
+    priority: number;
+    mandatory?: boolean;
+    minimumBudget?: number;
+    maximumBudget?: number;
+    summaryMeasurement?: {
+        unit: 'tokens' | 'bytes' | 'items';
+        amount: number;
+        provenance: string;
+    };
+    omissionReason?: string;
+}
+export declare function compileAssignmentContextPack(input: {
+    assignmentId: string;
+    capacity: ProviderContextCapacity;
+    candidates: ContextPackCandidate[];
+}): AssignmentContextPack;

package/dist/agent-capacity/contracts/capacity/assignments/context-pack-compiler.js

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+const canonical = (value) => value === null || typeof value !== "object" ? JSON.stringify(value) : Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+function compileAssignmentContextPack(input) {
+  const capacityUnit = input.capacity.mode === "bounded" ? input.capacity.measurement : null;
+  const budgetUnit = input.capacity.mode === "bounded" ? input.capacity.measurement : "bytes";
+  const ordered = [...input.candidates].sort((left, right) => Number(Boolean(right.mandatory)) - Number(Boolean(left.mandatory)) || Number(right.source.required) - Number(left.source.required) || right.priority - left.priority || left.source.id.localeCompare(right.source.id));
+  const mandatoryAmount = ordered.filter((candidate) => candidate.mandatory && !candidate.omissionReason).reduce((sum, candidate) => {
+    if (candidate.measurement.unit !== budgetUnit) throw new Error(`Context source ${candidate.source.id} uses ${candidate.measurement.unit}, but the offer budgets ${budgetUnit}.`);
+    return sum + candidate.measurement.amount;
+  }, 0);
+  const requiredFloor = ordered.filter((candidate) => candidate.source.required && !candidate.omissionReason).reduce((sum, candidate) => {
+    if (candidate.measurement.unit !== budgetUnit) throw new Error(`Context source ${candidate.source.id} uses ${candidate.measurement.unit}, but the offer budgets ${budgetUnit}.`);
+    if (candidate.mandatory) return sum + candidate.measurement.amount;
+    const summarized = candidate.summaryMeasurement?.unit === budgetUnit && candidate.summaryMeasurement.amount >= (candidate.minimumBudget ?? 0) ? candidate.summaryMeasurement.amount : candidate.measurement.amount;
+    return sum + summarized;
+  }, 0);
+  const maximumInput = input.capacity.mode === "bounded" ? input.capacity.maximum - input.capacity.reservedOutput : input.capacity.transportPayloadBytes;
+  if (input.capacity.mode === "bounded" && mandatoryAmount > maximumInput) throw new Error("Mandatory context exceeds the selected provider offer maximum input capacity.");
+  if (input.capacity.mode === "bounded" && requiredFloor > maximumInput) throw new Error("Required context exceeds the selected provider offer maximum input capacity.");
+  const limit = input.capacity.mode === "bounded" ? Math.min(maximumInput, Math.max(input.capacity.defaultInitial, mandatoryAmount, requiredFloor)) : input.capacity.transportPayloadBytes;
+  const sources = [];
+  let consumed = 0;
+  for (const candidate of ordered) {
+    if (candidate.omissionReason) {
+      sources.push({ ...candidate.source, disposition: "omitted", measurement: { ...candidate.measurement, amount: 0 }, reason: candidate.omissionReason });
+      continue;
+    }
+    const compatible = candidate.measurement.unit === budgetUnit;
+    if (!compatible) throw new Error(`Context source ${candidate.source.id} uses ${candidate.measurement.unit}, but the offer budgets ${budgetUnit}.`);
+    if (candidate.maximumBudget !== void 0 && candidate.minimumBudget !== void 0 && candidate.minimumBudget > candidate.maximumBudget) throw new Error(`Context source ${candidate.source.id} has an invalid minimum/maximum budget.`);
+    if (candidate.minimumBudget !== void 0 && candidate.measurement.amount < candidate.minimumBudget && candidate.source.required) throw new Error(`Required context source ${candidate.source.id} cannot satisfy its minimum budget.`);
+    if (candidate.mandatory && consumed + candidate.measurement.amount > limit) throw new Error(`Mandatory context exceeds the selected provider offer default: ${candidate.source.id}.`);
+    if (consumed + candidate.measurement.amount <= limit && (candidate.maximumBudget === void 0 || candidate.measurement.amount <= candidate.maximumBudget)) {
+      sources.push({ ...candidate.source, disposition: "included", measurement: candidate.measurement, reason: null });
+      consumed += candidate.measurement.amount;
+      continue;
+    }
+    if (!candidate.mandatory && candidate.summaryMeasurement && consumed + candidate.summaryMeasurement.amount <= limit && (candidate.maximumBudget === void 0 || candidate.summaryMeasurement.amount <= candidate.maximumBudget) && (candidate.minimumBudget === void 0 || candidate.summaryMeasurement.amount >= candidate.minimumBudget)) {
+      sources.push({ ...candidate.source, disposition: "summarized", measurement: candidate.summaryMeasurement, reason: "provider_context_default" });
+      consumed += candidate.summaryMeasurement.amount;
+      continue;
+    }
+    if (candidate.source.required) throw new Error(`Mandatory context exceeds the selected provider offer default: ${candidate.source.id}.`);
+    sources.push({ ...candidate.source, disposition: "omitted", measurement: { ...candidate.measurement, amount: 0 }, reason: "provider_context_default" });
+  }
+  const totals = { tokens: 0, bytes: 0, items: 0 };
+  for (const source of sources) totals[source.measurement.unit] += source.measurement.amount;
+  const material = {
+    schemaVersion: "treeseed.assignment-context-pack/v1",
+    assignmentId: input.assignmentId,
+    capacity: {
+      mode: input.capacity.mode,
+      measurement: capacityUnit,
+      defaultInitial: input.capacity.mode === "bounded" ? input.capacity.defaultInitial : null,
+      maximum: input.capacity.mode === "bounded" ? input.capacity.maximum : null,
+      reservedOutput: input.capacity.mode === "bounded" ? input.capacity.reservedOutput : null,
+      transportPayloadBytes: input.capacity.transportPayloadBytes,
+      measurementProvenance: input.capacity.measurementProvenance
+    },
+    totals,
+    sources
+  };
+  return { ...material, digest: `sha256:${createHash("sha256").update(canonical(material)).digest("hex")}` };
+}
+export {
+  compileAssignmentContextPack
+};

package/dist/agent-capacity/contracts/capacity/communication/communication-records.d.ts

@@ -1,4 +1,4 @@
-export type ProviderLanePurpose = 'communication' | 'operation';
+export type ProviderLanePurpose = 'communication' | 'platform' | 'workday';
 export type CapacityExecutionKind = 'workday' | 'conversation' | 'simulation' | 'recovery';
 export type CapacityTriggerKind = 'scheduled' | 'manual' | 'discussion' | 'agent-handoff';
 export type CommunicationPriorityClass = 'human-interactive' | 'workday-blocking-agent' | 'agent-asynchronous' | 'operational';

package/dist/agent-capacity/contracts/capacity/providers/supply-policy.d.ts

@@ -7,9 +7,7 @@ export interface CapacitySupplyPolicy {
     allowPlanningFailover: boolean;
     allowActingFailover: boolean;
     preferredCapacityProviderIds?: string[];
-    preferredExecutionProviderIds?: string[];
     disallowedCapacityProviderIds?: string[];
-    disallowedExecutionProviderIds?: string[];
 }
 export interface CapacitySupplyCandidate {
     capacityProviderId: string;

package/dist/agent-capacity/contracts/configuration/configuration.d.ts

@@ -6,7 +6,6 @@ export interface CapacityConfigurationDescriptor {
     format: 'yaml' | 'mdx-frontmatter';
     schemaId: string;
     validator: string;
-    examplePath: string;
     runtimeOwner: '@treeseed/agent' | '@treeseed/api';
 }
 export declare const CAPACITY_CONFIGURATION_DESCRIPTORS: readonly CapacityConfigurationDescriptor[];

package/dist/agent-capacity/contracts/configuration/configuration.js

@@ -7,12 +7,12 @@ const CAPACITY_CONFIGURATION_FAMILIES = [
   "activity-profile"
 ];
 const CAPACITY_CONFIGURATION_DESCRIPTORS = [
-  { id: "provider-manifest", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-provider/v2", validator: "validateCapacityProviderManifestV2", examplePath: "examples/agent-capacity/provider-manifest.yaml", runtimeOwner: "@treeseed/agent" },
-  { id: "provider-offer", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.provider-supply-offer/v1", validator: "validateProviderSupplyOffer", examplePath: "examples/agent-capacity/provider-offer.yaml", runtimeOwner: "@treeseed/agent" },
-  { id: "capacity-grant", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-grant/v2", validator: "validateCapacityGrantV2", examplePath: "examples/agent-capacity/capacity-grant.yaml", runtimeOwner: "@treeseed/api" },
-  { id: "allocation-set", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-allocation-set/v2", validator: "validateCapacityAllocationSetV2", examplePath: "examples/agent-capacity/allocation-set.yaml", runtimeOwner: "@treeseed/api" },
-  { id: "project-agent-class", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.project-agent-class/v1", validator: "validateProjectAgentClassConfiguration", examplePath: "examples/agent-capacity/project-agent-class.yaml", runtimeOwner: "@treeseed/api" },
-  { id: "activity-profile", ownerPackage: "@treeseed/sdk", format: "mdx-frontmatter", schemaId: "treeseed.agent-activity-profiles/v1", validator: "validateAgentActivityProfilesConfiguration", examplePath: "examples/agent-capacity/activity-profiles.yaml", runtimeOwner: "@treeseed/agent" }
+  { id: "provider-manifest", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-provider/v5", validator: "validateCapacityProviderManifestV5", runtimeOwner: "@treeseed/agent" },
+  { id: "provider-offer", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.provider-supply-offer/v1", validator: "validateProviderSupplyOffer", runtimeOwner: "@treeseed/agent" },
+  { id: "capacity-grant", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-grant/v2", validator: "validateCapacityGrantV2", runtimeOwner: "@treeseed/api" },
+  { id: "allocation-set", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-allocation-set/v2", validator: "validateCapacityAllocationSetV2", runtimeOwner: "@treeseed/api" },
+  { id: "project-agent-class", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.project-agent-class/v1", validator: "validateProjectAgentClassConfiguration", runtimeOwner: "@treeseed/api" },
+  { id: "activity-profile", ownerPackage: "@treeseed/sdk", format: "mdx-frontmatter", schemaId: "treeseed.agent-activity-profiles/v1", validator: "validateAgentActivityProfilesConfiguration", runtimeOwner: "@treeseed/agent" }
 ];
 export {
   CAPACITY_CONFIGURATION_DESCRIPTORS,

package/dist/agent-capacity/contracts/projects/agents/project-agent-class.d.ts

@@ -26,7 +26,6 @@ export interface ProjectAgentClass {
     name: string;
     status: ProjectAgentClassStatus;
     allowedModes: AgentExecutionMode[];
-    requiredCapabilities: string[];
     kernelProfile: AgentKernelProfile;
     kernelPolicy: AgentKernelPolicy;
     handlerRefs: Record<string, unknown>;

package/dist/agent-capacity/contracts/support/decision-work.d.ts

@@ -1,4 +1,4 @@
-import type { ContentReference } from '../../../operations/content-operations.js';
+import type { ContentReference } from '../../../content/contracts.js';
 import type { AgentArtifactManifest } from '../../artifacts.js';
 import type { GroupMembershipSnapshot } from '../../../governance/groups/contracts.js';
 export type AgentPlanningActivityType = 'planning' | 'estimating' | 'reviewing' | 'reporting';
@@ -17,7 +17,7 @@ export interface ProviderNativeEstimateRange {
     minimum: number;
     expected: number;
     maximum: number;
-    providerClass?: string;
+    providerCapabilities?: string[];
 }
 export interface AgentOutputRequirement {
     id?: string;
@@ -34,7 +34,6 @@ export interface DecisionDependencySpec {
     optional?: boolean;
     deliverableType?: string;
     capability?: string;
-    agentClass?: string;
     contentRefs?: string[];
     humanInputPolicy?: {
         requiredFrom: 'team-human' | 'any-human' | 'any-human-or-agent';

package/dist/agent-capacity/validation/activity-profile.js

@@ -1,12 +1,12 @@
 import { AGENT_ACTIVITY_TYPES, AGENT_HANDLER_KINDS } from "../../types/agents.js";
 import { compileAgentAuthoritySnapshot } from "../authority/agent-authority-presets.js";
-const PROFILE_KEYS = /* @__PURE__ */ new Set(["activityType", "enabled", "handler", "prompt", "branchPolicy", "contextQueryRefs", "contextQuerySetRefs", "instructionTemplateRefs", "permissions", "authorityPresets", "artifactTriggers", "closeoutPolicy", "providerOverrides", "tools", "signals", "outputs", "planningIntent", "questionPolicy", "execution"]);
+const PROFILE_KEYS = /* @__PURE__ */ new Set(["activityType", "enabled", "handler", "prompt", "branchPolicy", "contextQueryRefs", "contextQuerySetRefs", "instructionTemplateRefs", "capabilityRequirements", "permissions", "authorityPresets", "artifactTriggers", "closeoutPolicy", "tools", "signals", "outputs", "planningIntent", "questionPolicy", "execution"]);
 const PROMPT_KEYS = /* @__PURE__ */ new Set(["system", "task", "templates"]);
 const TOOL_KEYS = /* @__PURE__ */ new Set(["allowed", "denied"]);
 const SIGNAL_KEYS = /* @__PURE__ */ new Set(["subscribesTo", "publishes"]);
 const SUBSCRIPTION_KEYS = /* @__PURE__ */ new Set(["contract", "groupScope", "filters", "cardinality", "producerPolicy", "quorum"]);
 const OUTPUT_KEYS = /* @__PURE__ */ new Set(["messageTypes", "modelMutations"]);
-const EXECUTION_KEYS = /* @__PURE__ */ new Set(["requiredCapabilities", "maxRuntimeSeconds", "preparationSeconds", "closeoutSeconds", "closeoutWarningSeconds", "maxRetries", "verificationRequired", "maxTotalTokens", "warningTokens", "maxCostAmount", "costCurrency", "nativeLimits", "pricingGeneration", "enforcementConfidence", "allowedPaths", "forbiddenPaths"]);
+const EXECUTION_KEYS = /* @__PURE__ */ new Set(["reasoningEffort", "maxRuntimeSeconds", "preparationSeconds", "closeoutSeconds", "closeoutWarningSeconds", "maxRetries", "verificationRequired", "maxTotalTokens", "warningTokens", "maxCostAmount", "costCurrency", "nativeLimits", "pricingGeneration", "enforcementConfidence", "allowedPaths", "forbiddenPaths"]);
 const CONTENT_ACCESS_KEYS = /* @__PURE__ */ new Set(["content", "commit", "repository", "network", "shell"]);
 const MODEL_PERMISSION_KEYS = /* @__PURE__ */ new Set(["operations", "filters"]);
 const QUESTION_KEYS = /* @__PURE__ */ new Set(["defaultAnswerPolicy", "blockExecutionWhenCreated"]);
@@ -67,9 +67,9 @@ function validateAgentActivityProfilesConfiguration(value) {
     validateContentAccess(raw.permissions, `${path}.permissions`, add);
     if (raw.authorityPresets !== void 0 && (!strings(raw.authorityPresets) || raw.authorityPresets.some((preset) => !["messaging", "direction", "influence", "estimation", "plan-contribution", "source-execution", "review-authority", "reporting"].includes(preset)))) add("agent_activity_authority_presets_invalid", `${path}.authorityPresets`, "authorityPresets must contain supported unique preset ids.");
     for (const key of ["contextQueryRefs", "contextQuerySetRefs", "instructionTemplateRefs"]) if (raw[key] !== void 0 && !exactRefs(raw[key])) add("agent_activity_revision_refs_invalid", `${path}.${key}`, `${path}.${key} must contain unique exact id and revision references.`);
+    validateCapabilityRequirements(raw.capabilityRequirements, `${path}.capabilityRequirements`, add);
     validateArtifactTriggers(raw.artifactTriggers, `${path}.artifactTriggers`, add);
     validateCloseoutPolicy(raw.closeoutPolicy, `${path}.closeoutPolicy`, add);
-    validateProviderOverrides(raw.providerOverrides, `${path}.providerOverrides`, add);
     validateQuestionPolicy(raw.questionPolicy, `${path}.questionPolicy`, add);
     validateExecution(raw.execution, `${path}.execution`, add);
     if (typeof raw.enabled === "boolean" && typeof raw.handler === "string" && record(raw.tools) && record(raw.outputs) && record(raw.branchPolicy)) {
@@ -217,16 +217,28 @@ function validateCloseoutPolicy(value, path, add) {
   if (value.warningSeconds !== void 0 && (!Number.isInteger(value.warningSeconds) || Number(value.warningSeconds) < 1)) add("agent_activity_closeout_warning_invalid", `${path}.warningSeconds`, "warningSeconds must be positive.");
   if (value.requiredArtifactKinds !== void 0 && !strings(value.requiredArtifactKinds)) add("agent_activity_string_list_invalid", `${path}.requiredArtifactKinds`, "requiredArtifactKinds must contain unique non-empty strings.");
 }
-function validateProviderOverrides(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_provider_overrides_invalid", path, "providerOverrides must be an object.");
+function validateCapabilityRequirements(value, path, add) {
+  if (value === void 0) {
+    add("agent_activity_capability_requirements_required", path, "capabilityRequirements is required.");
     return;
   }
-  unknownKeys(value, /* @__PURE__ */ new Set(["requiredCapabilities", "disallowedProviderIds", "promptRef", "instructionTemplateRefs", "maxRuntimeSeconds", "maxTotalTokens", "maxCostAmount"]), path, add);
-  for (const key of ["requiredCapabilities", "disallowedProviderIds"]) if (value[key] !== void 0 && !strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${key} must contain unique non-empty strings.`);
-  if (value.instructionTemplateRefs !== void 0 && !exactRefs(value.instructionTemplateRefs)) add("agent_activity_revision_refs_invalid", `${path}.instructionTemplateRefs`, "instructionTemplateRefs must contain unique exact id and revision references.");
-  if (value.promptRef !== void 0 && (typeof value.promptRef !== "string" || !value.promptRef.trim())) add("agent_activity_provider_prompt_invalid", `${path}.promptRef`, "promptRef must be non-empty.");
+  if (!Array.isArray(value) || value.length === 0) {
+    add("agent_activity_capability_requirements_required", path, "capabilityRequirements must be a non-empty array.");
+    return;
+  }
+  value.forEach((candidate, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!record(candidate)) {
+      add("agent_activity_capability_requirement_invalid", itemPath, "Capability requirement must be an object.");
+      return;
+    }
+    unknownKeys(candidate, /* @__PURE__ */ new Set(["capabilityId", "versionRange", "requirement", "alternativeGroup", "requiredFeatures", "configuration"]), itemPath, add);
+    if (typeof candidate.capabilityId !== "string" || !/^(?:treeseed\.|provider\.)/u.test(candidate.capabilityId)) add("agent_activity_capability_id_invalid", `${itemPath}.capabilityId`, "capabilityId must use a TreeSeed or provider namespace.");
+    if (typeof candidate.versionRange !== "string" || !candidate.versionRange.trim()) add("agent_activity_capability_version_invalid", `${itemPath}.versionRange`, "versionRange is required.");
+    if (!["required", "preferred"].includes(String(candidate.requirement))) add("agent_activity_capability_requirement_invalid", `${itemPath}.requirement`, "requirement must be required or preferred.");
+    if (candidate.requiredFeatures !== void 0 && !strings(candidate.requiredFeatures)) add("agent_activity_capability_features_invalid", `${itemPath}.requiredFeatures`, "requiredFeatures must contain unique values.");
+    if (candidate.configuration !== void 0 && !record(candidate.configuration)) add("agent_activity_capability_configuration_invalid", `${itemPath}.configuration`, "configuration must be an object.");
+  });
 }
 function validateQuestionPolicy(value, path, add) {
   if (value === void 0) return;
@@ -251,7 +263,8 @@ function validateExecution(value, path, add) {
     return;
   }
   unknownKeys(value, EXECUTION_KEYS, path, add);
-  for (const key of ["requiredCapabilities", "allowedPaths", "forbiddenPaths"]) if (value[key] !== void 0 && !strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${path}.${key} must contain unique non-empty strings.`);
+  for (const key of ["allowedPaths", "forbiddenPaths"]) if (value[key] !== void 0 && !strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${path}.${key} must contain unique non-empty strings.`);
+  if (value.reasoningEffort !== void 0 && !["minimal", "low", "medium", "high", "xhigh"].includes(String(value.reasoningEffort))) add("agent_activity_reasoning_effort_invalid", `${path}.reasoningEffort`, "reasoningEffort must be minimal, low, medium, high, or xhigh.");
   if (value.maxRuntimeSeconds !== void 0 && (!Number.isInteger(value.maxRuntimeSeconds) || Number(value.maxRuntimeSeconds) < 1)) add("agent_activity_runtime_invalid", `${path}.maxRuntimeSeconds`, "maxRuntimeSeconds must be a positive integer.");
   if (value.closeoutWarningSeconds !== void 0 && (!Number.isInteger(value.closeoutWarningSeconds) || Number(value.closeoutWarningSeconds) < 1)) add("agent_activity_closeout_warning_invalid", `${path}.closeoutWarningSeconds`, "closeoutWarningSeconds must be a positive integer.");
   if (value.preparationSeconds !== void 0 && (!Number.isInteger(value.preparationSeconds) || Number(value.preparationSeconds) < 1)) add("agent_activity_preparation_duration_invalid", `${path}.preparationSeconds`, "preparationSeconds must be a positive integer.");