@treeseed/sdk 0.13.0-rc.12 → 0.13.0-rc.121

package/dist/agent-capacity/contracts/capacity/assignments/agent-execution.js

@@ -0,0 +1,176 @@
+import { z } from "zod";
+import { activityProfileSchema } from "../../../validation/agent-definition-schema.js";
+const identifier = z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+const timestamp = z.string().datetime({ offset: true });
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const commit = z.string().regex(/^[a-f0-9]{40}$/u);
+const uniqueStrings = z.array(z.string().min(1)).superRefine((items, context) => {
+  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+});
+const exactEntityReferenceSchema = z.object({
+  store: z.enum(["treedx", "postgresql", "git", "url"]),
+  model: z.string().min(1),
+  id: identifier,
+  revision: z.number().int().positive().optional(),
+  digest: digest.optional(),
+  repository: z.string().min(1).optional(),
+  commit: commit.optional(),
+  path: z.string().min(1).optional(),
+  anchor: z.string().min(1).optional(),
+  startLine: z.number().int().positive().optional(),
+  endLine: z.number().int().positive().optional(),
+  url: z.string().url().optional()
+}).strict().superRefine((reference, context) => {
+  if (reference.endLine && !reference.startLine) context.addIssue({ code: z.ZodIssueCode.custom, path: ["startLine"], message: "startLine is required with endLine." });
+  if (reference.store === "treedx" && !(reference.commit || reference.revision && reference.digest)) context.addIssue({ code: z.ZodIssueCode.custom, message: "TreeDX references require commit or revision and digest." });
+  if (reference.store === "git" && !(reference.repository && reference.commit)) context.addIssue({ code: z.ZodIssueCode.custom, message: "Git references require repository and commit." });
+  if (reference.store === "url" && !reference.url) context.addIssue({ code: z.ZodIssueCode.custom, message: "URL references require url." });
+});
+const assignmentReferenceSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("git"), repository: z.string().min(1), commit, branch: z.string().min(1).optional(), path: z.string().min(1).optional() }).strict(),
+  z.object({ kind: z.literal("treedx"), projectId: identifier, repository: z.string().min(1), commit, path: z.string().min(1), workspaceId: identifier.optional() }).strict(),
+  z.object({ kind: z.literal("url"), url: z.string().url(), digest: digest.optional() }).strict()
+]);
+const exactGrantSchema = z.object({
+  contentRead: z.array(exactEntityReferenceSchema),
+  contentWrite: z.array(exactEntityReferenceSchema),
+  sourceRead: uniqueStrings,
+  sourceWrite: uniqueStrings,
+  tools: uniqueStrings
+}).strict();
+const assignmentWorkspaceSchema = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("read-only") }).strict(),
+  z.object({ mode: z.literal("treedx"), workspaceId: identifier, repository: z.string().min(1), baseCommit: commit, writablePaths: uniqueStrings.refine((paths) => paths.length > 0) }).strict(),
+  z.object({ mode: z.literal("git"), repository: z.string().min(1), baseCommit: commit, branch: z.string().min(1), writablePaths: uniqueStrings.refine((paths) => paths.length > 0) }).strict()
+]);
+const estimateSchema = z.object({
+  minimumSeconds: z.number().int().positive(),
+  expectedSeconds: z.number().int().positive(),
+  maximumSeconds: z.number().int().positive(),
+  rationale: z.string().optional()
+}).strict().refine((value) => value.minimumSeconds <= value.expectedSeconds && value.expectedSeconds <= value.maximumSeconds, {
+  message: "Estimate must satisfy minimumSeconds <= expectedSeconds <= maximumSeconds."
+});
+const effectiveActivityProfileSchema = activityProfileSchema.omit({ dependsOn: true }).extend({
+  profileRef: exactEntityReferenceSchema,
+  activity: z.enum(["planning", "estimating", "acting", "reviewing", "reporting", "chat"]),
+  handlerOrigin: z.enum(["agent-package", "project-runtime"]),
+  permissionCeiling: activityProfileSchema.shape.permissions
+}).omit({ permissions: true }).strict();
+const providerSelectionSchema = z.object({
+  providerId: identifier,
+  offerId: identifier,
+  executionProviderId: identifier,
+  modelConfigurationId: identifier,
+  executionCapabilityId: identifier,
+  offerRevision: z.number().int().positive(),
+  runtimeBuild: digest
+}).strict();
+const limitsSchema = z.object({
+  maximumSeconds: z.number().int().positive(),
+  maximumContextBytes: z.number().int().positive(),
+  maximumContextTokens: z.number().int().positive().optional(),
+  maximumContextItems: z.number().int().positive()
+}).strict();
+const assignmentAttemptSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-attempt/v1"),
+  id: identifier,
+  idempotencyKey: identifier,
+  teamId: identifier,
+  projectId: identifier,
+  workdayId: identifier,
+  nodeId: identifier,
+  workItemId: identifier.optional(),
+  nodeRevision: z.number().int().positive(),
+  graphRevision: z.number().int().positive(),
+  sourceRef: exactEntityReferenceSchema,
+  authorityRefs: z.array(exactEntityReferenceSchema).min(1),
+  effectiveProfile: effectiveActivityProfileSchema,
+  requiredCapabilities: uniqueStrings,
+  grant: exactGrantSchema,
+  provider: providerSelectionSchema,
+  contextRefs: z.array(exactEntityReferenceSchema),
+  predecessorResultIds: uniqueStrings,
+  acceptanceCriteria: z.array(z.string().trim().min(1)).min(1).optional(),
+  workspace: assignmentWorkspaceSchema,
+  estimate: estimateSchema,
+  limits: limitsSchema,
+  deadline: timestamp,
+  leaseId: identifier,
+  reservationId: identifier,
+  attempt: z.number().int().positive(),
+  status: z.enum(["created", "leased", "running", "completed", "blocked", "failed", "cancelled", "expired"]),
+  createdAt: timestamp,
+  startedAt: timestamp.optional(),
+  finishedAt: timestamp.optional()
+}).strict();
+const verificationRecordSchema = z.object({
+  command: z.string().min(1),
+  status: z.enum(["passed", "failed", "skipped"]),
+  exitCode: z.number().int(),
+  outputDigest: digest,
+  durationSeconds: z.number().int().nonnegative().optional()
+}).strict();
+const usageSchema = z.object({
+  elapsedSeconds: z.number().int().nonnegative(),
+  modelInputTokens: z.number().int().nonnegative().optional(),
+  modelOutputTokens: z.number().int().nonnegative().optional(),
+  native: z.record(z.number().nonnegative()).optional()
+}).strict();
+const diagnosticSchema = z.object({
+  code: identifier,
+  severity: z.enum(["info", "warning", "error"]),
+  message: z.string().min(1),
+  ref: exactEntityReferenceSchema.optional()
+}).strict();
+const assignmentTimingAwarenessReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-timing-awareness/v1"),
+  requiredChecks: z.literal(2),
+  completedChecks: z.number().int().min(2),
+  firstTool: z.literal("treedx:treeseed_time_status"),
+  firstToolSucceeded: z.literal(true),
+  lastTool: z.literal("treedx:treeseed_time_status"),
+  lastToolSucceeded: z.literal(true),
+  firstToolCompliant: z.literal(true),
+  finalToolCompliant: z.literal(true)
+}).strict();
+const assignmentResultSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-result/v1"),
+  id: identifier,
+  assignmentId: identifier,
+  status: z.enum(["completed", "blocked", "failed"]),
+  summary: z.string().min(1),
+  references: z.array(assignmentReferenceSchema),
+  verification: z.array(verificationRecordSchema),
+  usage: usageSchema,
+  diagnostics: z.array(diagnosticSchema),
+  timingAwareness: assignmentTimingAwarenessReceiptSchema.optional(),
+  completedAt: timestamp
+}).strict();
+const authorizedContextItemSchema = z.object({
+  ref: exactEntityReferenceSchema,
+  mediaType: z.string().min(1),
+  digest,
+  value: z.any()
+}).strict();
+const assignmentContextSchema = z.object({
+  assignment: assignmentAttemptSchema,
+  context: z.array(authorizedContextItemSchema),
+  predecessorResults: z.array(assignmentResultSchema)
+}).strict();
+export {
+  assignmentAttemptSchema,
+  assignmentContextSchema,
+  assignmentReferenceSchema,
+  assignmentResultSchema,
+  assignmentTimingAwarenessReceiptSchema,
+  assignmentWorkspaceSchema,
+  authorizedContextItemSchema,
+  diagnosticSchema,
+  effectiveActivityProfileSchema,
+  estimateSchema,
+  exactEntityReferenceSchema,
+  exactGrantSchema,
+  usageSchema,
+  verificationRecordSchema
+};

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,9 +1,9 @@
 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';
-export type ProviderAssignmentSynthesisSource = 'approved_decision' | 'planning_input_request' | 'capacity_plan' | 'workday_demand' | 'verification_failure' | 'fallback_queue';
+export type ProviderAssignmentSynthesisSource = 'approved_decision' | 'planning_input_request' | 'capacity_plan' | 'living_execution_graph' | 'workday_demand' | 'verification_failure' | 'fallback_queue';
 export declare const AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES: readonly ["context_only", "workspace_write", "brokered_workspace", "full_workspace_no_credentials", "trusted_direct"];
 export type AgentAssignmentWorkspaceAccessMode = (typeof AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES)[number];
 export type AgentAssignmentCapabilityHandleKind = 'repository_access' | 'treedx_workspace' | 'workflow_operation' | 'secret_use';
@@ -59,6 +59,7 @@ export interface TreeDxProxyHandle {
     assignmentId?: string | null;
     executionMode?: AgentWorkExecutionMode;
     repositoryId?: string | null;
+    repositoryProjectId?: string | null;
     workspaceId?: string | null;
     baseCommitSha?: string | null;
     baseRef?: string | null;
@@ -75,6 +76,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 {
@@ -189,6 +199,11 @@ export interface ProviderAssignment {
     synthesisKey: string | null;
     decisionId: string | null;
     proposalId: string | null;
+    graphRevision?: number | null;
+    executionNodeId?: string | null;
+    executionNodeRevision?: number | null;
+    assignmentAttempt?: import('./agent-execution.js').AssignmentAttempt | null;
+    assignmentResult?: import('./agent-execution.js').AssignmentResult | null;
     fallbackOutputId: string | null;
     treedxProxyHandle: TreeDxProxyHandle | Record<string, unknown> | null;
     capabilityHandles: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
@@ -197,6 +212,11 @@ export interface ProviderAssignment {
     updatedAt: string;
 }
 export interface ProviderAssignmentLifecycleRequest {
+    activeSeconds?: number | null;
+    elapsedSeconds?: number | null;
+    actualUsd?: number | null;
+    providerUnits?: number | null;
+    usage?: Record<string, unknown> | null;
     runnerId?: string | null;
     leaseToken?: string | null;
     leaseSeconds?: number | null;

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
+};