@treeseed/sdk 0.13.0-rc.64 → 0.13.0-rc.66

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

@@ -1 +1 @@
-{"completedAt":"2026-08-31T12:10:08.221Z"}
+{"completedAt":"2026-09-01T00:39:39.233Z"}

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" | "tool" | "agent" | "core" | "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" | "tool" | "agent" | "core" | "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" | "tool" | "agent" | "core" | "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" | "tool" | "agent" | "core" | "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" | "tool" | "agent" | "core" | "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" | "tool" | "agent" | "core" | "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
+};