@treeseed/sdk 0.13.0-rc.10 → 0.13.0-rc.101

package/README.md

@@ -1,5 +1,7 @@
 # `@treeseed/sdk`
 
+The operator catalog includes versioned `inbox.*` operations for unified team inbox queries, ordered events, private drafts, routed question creation, and exact-version governance actions.
+
 `@treeseed/sdk` is TreeSeed's portable contract and remote API package. It gives API, CLI, Agent, browser, and external integrations one versioned description of the control plane and typed conduits to remote TreeSeed and TreeDX services.
 
 The SDK does not own control-plane persistence, scheduling, repository mutation, content publication, deployment, provider runtimes, or server-side business workflows. Those implementations belong to the API or their dedicated runtime packages.
@@ -19,32 +21,44 @@ import {
   ControlPlaneClient,
   defaultLocalControlPlaneServer,
 } from '@treeseed/sdk/control-plane-client';
+import { CONTROL_PLANE_OPERATIONS } from '@treeseed/sdk/operator-contracts';
 
 const client = new ControlPlaneClient({
   profile: defaultLocalControlPlaneServer(),
   accessToken: process.env.TREESEED_ACCESS_TOKEN,
 });
 
-const health = await client.call({ method: 'GET', path: '/v1/health' });
+const health = await client.invoke(CONTROL_PLANE_OPERATIONS.health.readiness, {
+  path: {},
+  query: {},
+  body: undefined,
+});
 ```
 
-The client provides typed operation dispatch, RFC 9457 problem handling, OAuth device and refresh flows, server-profile normalization, idempotency keys, optimistic-concurrency headers, and request cancellation. Generated operation bindings come from the versioned operation catalog; the generic `call` method accepts only the public REST path shape. Token and profile persistence belong to the consuming CLI, application, or host credential store.
+The client provides typed operation dispatch, RFC 9457 problem handling, OAuth device and refresh flows, server-profile normalization, idempotency keys, optimistic-concurrency headers, and request cancellation. Operation bindings come from the versioned operation catalog; callers do not construct control-plane paths. Token and profile persistence belong to the consuming CLI, application, or host credential store.
+
+Communication contracts treat discussion topics as team-wide coordination scopes. Qualified `@project/agent` addresses select one agent, while unqualified `@agent` addresses expand to every matching chat-enabled agent across active team projects. The API maintains a project-local TreeDX discussion stream for each addressed project and aggregates their invocations under one send identity.
 
 ## TreeDX API
 
 ```ts
-import { TreeDxClient } from '@treeseed/sdk/treedx/client';
+import { ControlPlaneClient } from '@treeseed/sdk/control-plane-client';
+import { TreeSeedTreeDxClient } from '@treeseed/sdk/treedx';
 
-const treeDx = new TreeDxClient({
-  baseUrl: 'http://127.0.0.1:4000',
-  token: process.env.TREEDX_TOKEN,
-  repoId: 'repo_123',
+const controlPlane = new ControlPlaneClient({
+  profile: defaultLocalControlPlaneServer(),
+  accessToken: process.env.TREESEED_ACCESS_TOKEN,
 });
+const treeDx = new TreeSeedTreeDxClient(controlPlane);
 
-const result = await treeDx.searchRepositoryFiles({ query: 'release' });
+const result = await treeDx.proxy.repositories.searchFiles({
+  path: { projectId: 'project_123', repositoryId: 'repository_123' },
+  query: { query: 'release' },
+  body: undefined,
+});
 ```
 
-TreeDX remains a remote service. Its client and transport types are retained here so consumers do not duplicate protocol code.
+TreeDX remains an independently released remote service. This package imports its authoritative payload types but exposes only the project-scoped TreeSeed proxy facade. Direct TreeDX transport, endpoints, topology, and credentials remain confined to trusted control-plane infrastructure.
 
 ## Public boundaries
 

package/dist/.treeseed-build-complete.json

@@ -0,0 +1 @@
+{"completedAt":"2026-09-09T04:49:43.782Z"}

package/dist/accounts/account-contracts.d.ts

@@ -83,11 +83,15 @@ export interface AccountIdentity {
         linkedAt: string;
         canUnlink: boolean;
     }>;
+    /** Exact account revision supplied as If-Match for concurrent identity mutations. */
+    updatedAt?: string;
 }
 export interface AccountPreferences {
     timeZone: string;
     realTimeUpdates: boolean;
     realTimePollingIntervalSeconds: 2 | 5 | 15 | 30;
+    /** Exact preference revision supplied as If-Match for concurrent preference mutations. */
+    updatedAt?: string;
 }
 export type AccountPreferencesUpdate = Partial<AccountPreferences>;
 export interface AccountWebSession {
@@ -130,6 +134,8 @@ export interface NotificationPreferences {
     emailCadence: NotificationEmailCadence;
     globalContentTypes: string[];
     projectOverrides: NotificationProjectOverride[];
+    /** Exact notification-preference revision supplied as If-Match for concurrent updates. */
+    updatedAt?: string;
 }
 export interface AccountNotification {
     id: string;

package/dist/agent-capacity/artifact-mutation-receipt.d.ts

@@ -1,7 +1,7 @@
 export declare const ARTIFACT_MUTATION_RECEIPT_SCHEMA: "treeseed.artifact-mutation-receipt/v1";
 export type ArtifactMutationKind = 'treedx-content' | 'source-checkpoint';
 export type ArtifactMutationPhase = 'provisional' | 'integrated';
-import type { AgentWorkExecutionMode, UpstreamMutationPolicy } from './contracts/support/execution-mode.js';
+import type { AgentWorkExecutionMode, UpstreamMutationPolicy } from './contracts/support/authority/execution-mode.js';
 export interface ArtifactMutationEvidence {
     ref: string;
     digest?: string | null;

package/dist/agent-capacity/artifacts.d.ts

@@ -1,6 +1,5 @@
 import type { ExecutionUsageActual } from '../types/agents.js';
 import type { ResearchCitation } from './contracts/support/research-citation.js';
-import type { ArtifactRef } from '../treedx/types.js';
 import { type ArtifactMutationReceipt } from './artifact-mutation-receipt.js';
 export interface AgentToolEventReference {
     id: string;
@@ -62,6 +61,23 @@ export interface AgentDiagnosticReference {
     retryable?: boolean | null;
     evidenceRef?: string | null;
 }
+export interface ArtifactRef {
+    contract: 'treeseed.artifact-ref/v1';
+    kind: 'treedx-content' | 'repository-file' | 'r2-object' | 'verification-evidence' | 'provider-input' | 'provider-output' | 'citation' | 'source-commit';
+    repositoryId?: string;
+    workspaceId?: string;
+    path?: string;
+    commitSha?: string | null;
+    objectKey?: string;
+    sha256: string | null;
+    byteLength?: number;
+    mediaType?: string;
+    visibility: 'private' | 'assignment' | 'project' | 'team' | 'public';
+    assignmentId?: string;
+    toolCallId?: string;
+    eventId?: string;
+    provenance?: Record<string, string>;
+}
 /** Portable, secret-free terminal evidence emitted by AgentKernel. */
 export interface AgentArtifactManifest {
     schemaVersion: 1;

package/dist/agent-capacity/authority/agent-authority-presets.js

@@ -18,6 +18,7 @@ const CHAT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
   ...OPERATIONAL_TOOLS,
   ...MESSAGING_TOOLS,
   ...CONTENT_TOOLS,
+  ...SOURCE_READ_TOOLS,
   "treedx.build_context",
   "treedx.read_repository_files",
   "treedx.search_workspace",
@@ -32,7 +33,7 @@ const PROFILE_PRESETS = {
   acting: ["source-execution", "influence"],
   reviewing: ["review-authority", "plan-contribution"],
   reporting: ["messaging", "reporting"],
-  chat: ["influence"]
+  chat: ["review-authority"]
 };
 function toolsForPreset(preset) {
   if (preset === "messaging") return MESSAGING_TOOLS;

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;
+    kind: string;
+    id: string;
+    digest: string;
+    required: boolean;
+    projectId: string;
+    teamId: string;
+    reason: string | null;
+    metadata: Record<string, unknown>;
+    measurement: {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    };
+    layer: "agent" | "live" | "core" | "tool" | "activity";
+    disposition: "failed" | "included" | "summarized" | "omitted";
+}, {
+    path: string | null;
+    kind: string;
+    id: string;
+    digest: string;
+    required: boolean;
+    projectId: string;
+    teamId: string;
+    reason: string | null;
+    measurement: {
+        provenance: string;
+        amount: number;
+        unit: "items" | "tokens" | "bytes";
+    };
+    layer: "agent" | "live" | "core" | "tool" | "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, {
+            provider: string;
+            version: string | null;
+            implementation: string;
+        }, {
+            provider: string;
+            version: string | null;
+            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: {
+            provider: string;
+            version: string | null;
+            implementation: string;
+        };
+    }, {
+        maximum: number | null;
+        mode: "bounded" | "unbounded";
+        measurement: "items" | "tokens" | "bytes" | null;
+        defaultInitial: number | null;
+        reservedOutput: number | null;
+        transportPayloadBytes: number;
+        measurementProvenance: {
+            provider: string;
+            version: string | null;
+            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;
+        kind: string;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        reason: string | null;
+        metadata: Record<string, unknown>;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "agent" | "live" | "core" | "tool" | "activity";
+        disposition: "failed" | "included" | "summarized" | "omitted";
+    }, {
+        path: string | null;
+        kind: string;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        reason: string | null;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "agent" | "live" | "core" | "tool" | "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;
+        kind: string;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        reason: string | null;
+        metadata: Record<string, unknown>;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "agent" | "live" | "core" | "tool" | "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: {
+            provider: string;
+            version: string | null;
+            implementation: string;
+        };
+    };
+    totals: {
+        items: number;
+        tokens: number;
+        bytes: number;
+    };
+}, {
+    schemaVersion: "treeseed.assignment-context-pack/v1";
+    sources: {
+        path: string | null;
+        kind: string;
+        id: string;
+        digest: string;
+        required: boolean;
+        projectId: string;
+        teamId: string;
+        reason: string | null;
+        measurement: {
+            provenance: string;
+            amount: number;
+            unit: "items" | "tokens" | "bytes";
+        };
+        layer: "agent" | "live" | "core" | "tool" | "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: {
+            provider: string;
+            version: string | null;
+            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

@@ -1,5 +1,5 @@
 export type AgentExecutionMode = 'planning' | 'acting';
-export type AgentWorkExecutionMode = import('../../support/execution-mode.js').AgentWorkExecutionMode;
+import type { AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
 export type ProviderAssignmentStatus = 'pending' | 'leased' | 'running' | 'completed' | 'failed' | 'returned' | 'expired' | 'cancelled';
 export type ProviderAssignmentLeaseState = 'unleased' | 'leased' | 'released' | 'expired';
 export type AgentModeRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
@@ -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/capacity/workdays/workday-records.d.ts

@@ -1,6 +1,6 @@
 /** Portable durable records shared by workday control-plane and operator consumers. */
 import type { WorkdayAgentSelection } from '../../../workday.js';
-import type { AgentWorkExecutionMode } from '../../support/execution-mode.js';
+import type { AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
 export type CapacityWorkdayRunStatus = 'queued' | 'running' | 'completed' | 'cancelled' | 'failed' | 'degraded';
 export type CapacityWorkdayEventStatus = 'recorded' | 'active' | 'completed' | 'warning' | 'error' | 'failed';
 export type CapacityWorkdayDemandSource = 'objective' | 'question' | 'proposal' | 'decision-review' | 'knowledge-gap' | 'release-readiness' | 'idle-intent' | 'planning-input' | 'capacity-plan' | 'assignment-completion' | 'assignment-blockage' | 'workday-summary' | 'handoff' | 'research-workflow';

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

@@ -7,7 +7,7 @@ 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", 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" },