@treeseed/sdk 0.13.0-rc.118 → 0.13.0-rc.119

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

@@ -0,0 +1,155 @@
+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, 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 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),
+  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,
+  assignmentWorkspaceSchema,
+  authorizedContextItemSchema,
+  diagnosticSchema,
+  effectiveActivityProfileSchema,
+  estimateSchema,
+  exactEntityReferenceSchema,
+  exactGrantSchema,
+  usageSchema,
+  verificationRecordSchema
+};

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

@@ -3,7 +3,7 @@ import type { AgentWorkExecutionMode } from '../../support/authority/execution-m
 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;
@@ -198,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;

package/dist/agent-capacity/contracts/capacity/workdays/workday-allocation.d.ts

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+export declare const workdayPolicySchema: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+    maximumConcurrency: z.ZodNumber;
+    planningSecondsPerAgent: z.ZodNumber;
+    communicationConcurrency: z.ZodNumber;
+    projectWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    agentClassWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    durationSeconds: number;
+    maximumConcurrency: number;
+    planningSecondsPerAgent: number;
+    communicationConcurrency: number;
+    projectWeights: Record<string, number>;
+    agentClassWeights: Record<string, number>;
+}, {
+    durationSeconds: number;
+    maximumConcurrency: number;
+    planningSecondsPerAgent: number;
+    communicationConcurrency: number;
+    projectWeights: Record<string, number>;
+    agentClassWeights: Record<string, number>;
+}>;
+export declare const appliedWorkdaySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.workday/v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    policyId: z.ZodString;
+    policyRevision: z.ZodNumber;
+    policySnapshot: z.ZodObject<{
+        durationSeconds: z.ZodNumber;
+        maximumConcurrency: z.ZodNumber;
+        planningSecondsPerAgent: z.ZodNumber;
+        communicationConcurrency: z.ZodNumber;
+        projectWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        agentClassWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        planningSecondsPerAgent: number;
+        communicationConcurrency: number;
+        projectWeights: Record<string, number>;
+        agentClassWeights: Record<string, number>;
+    }, {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        planningSecondsPerAgent: number;
+        communicationConcurrency: number;
+        projectWeights: Record<string, number>;
+        agentClassWeights: Record<string, number>;
+    }>;
+    state: z.ZodEnum<["planned", "active", "closing", "ended"]>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    planningRounds: z.ZodArray<z.ZodObject<{
+        round: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        state: z.ZodEnum<["pending", "active", "complete"]>;
+        assignmentIds: z.ZodArray<z.ZodString, "many">;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        state: "active" | "pending" | "complete";
+        round: 1 | 2;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }, {
+        state: "active" | "pending" | "complete";
+        round: 1 | 2;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }>, "many">;
+    admittedSecondsByProject: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    admittedSecondsByAgentClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    activatedAt: z.ZodOptional<z.ZodString>;
+    closingAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    state: "active" | "planned" | "closing" | "ended";
+    schemaVersion: "treeseed.workday/v1";
+    teamId: string;
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        planningSecondsPerAgent: number;
+        communicationConcurrency: number;
+        projectWeights: Record<string, number>;
+        agentClassWeights: Record<string, number>;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: 1 | 2;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }[];
+    admittedSecondsByProject: Record<string, number>;
+    admittedSecondsByAgentClass: Record<string, number>;
+    activatedAt?: string | undefined;
+    closingAt?: string | undefined;
+    endedAt?: string | undefined;
+}, {
+    id: string;
+    state: "active" | "planned" | "closing" | "ended";
+    schemaVersion: "treeseed.workday/v1";
+    teamId: string;
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        planningSecondsPerAgent: number;
+        communicationConcurrency: number;
+        projectWeights: Record<string, number>;
+        agentClassWeights: Record<string, number>;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: 1 | 2;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }[];
+    admittedSecondsByProject: Record<string, number>;
+    admittedSecondsByAgentClass: Record<string, number>;
+    activatedAt?: string | undefined;
+    closingAt?: string | undefined;
+    endedAt?: string | undefined;
+}>;
+export interface FairReadyNode {
+    id: string;
+    projectId: string;
+    agentClass: string;
+    graphPriority: number;
+    readyAt: string;
+}
+export interface FairUsage {
+    projectId: string;
+    agentClass: string;
+    seconds: number;
+}
+/** Select work only; provider selection is a later hard-gated admission step. */
+export declare function selectFairReadyNode(nodes: FairReadyNode[], usage: FairUsage[], policy: z.infer<typeof workdayPolicySchema>): FairReadyNode | null;
+export declare function compilePlanningRounds(workdayId: string, agentIds: string[], planningSecondsPerAgent: number): {
+    id: string;
+    agentId: string;
+    round: number;
+    maximumSeconds: number;
+    dependsOn: string[];
+}[];
+/** Shared by read-only plan and mutating start; callers persist this exact value. */
+export declare function compileWorkday(input: {
+    id: string;
+    teamId: string;
+    policyId: string;
+    policyRevision: number;
+    policy: z.input<typeof workdayPolicySchema>;
+    agentIds: string[];
+    startsAt: string;
+}): {
+    id: string;
+    state: "active" | "planned" | "closing" | "ended";
+    schemaVersion: "treeseed.workday/v1";
+    teamId: string;
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        planningSecondsPerAgent: number;
+        communicationConcurrency: number;
+        projectWeights: Record<string, number>;
+        agentClassWeights: Record<string, number>;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: 1 | 2;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }[];
+    admittedSecondsByProject: Record<string, number>;
+    admittedSecondsByAgentClass: Record<string, number>;
+    activatedAt?: string | undefined;
+    closingAt?: string | undefined;
+    endedAt?: string | undefined;
+};
+export type WorkdayPolicy = z.infer<typeof workdayPolicySchema>;
+export type AppliedWorkday = z.infer<typeof appliedWorkdaySchema>;

package/dist/agent-capacity/contracts/capacity/workdays/workday-allocation.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+const identifier = z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+const positiveWeights = z.record(z.number().positive());
+const workdayPolicySchema = z.object({
+  durationSeconds: z.number().int().positive(),
+  maximumConcurrency: z.number().int().positive(),
+  planningSecondsPerAgent: z.number().int().positive(),
+  communicationConcurrency: z.number().int().positive(),
+  projectWeights: positiveWeights,
+  agentClassWeights: positiveWeights
+}).strict();
+const appliedWorkdaySchema = z.object({
+  schemaVersion: z.literal("treeseed.workday/v1"),
+  id: identifier,
+  teamId: identifier,
+  policyId: identifier,
+  policyRevision: z.number().int().positive(),
+  policySnapshot: workdayPolicySchema,
+  state: z.enum(["planned", "active", "closing", "ended"]),
+  startsAt: z.string().datetime({ offset: true }),
+  endsAt: z.string().datetime({ offset: true }),
+  planningRounds: z.array(z.object({
+    round: z.union([z.literal(1), z.literal(2)]),
+    state: z.enum(["pending", "active", "complete"]),
+    assignmentIds: z.array(identifier),
+    startedAt: z.string().datetime({ offset: true }).optional(),
+    completedAt: z.string().datetime({ offset: true }).optional()
+  }).strict()).length(2),
+  admittedSecondsByProject: z.record(z.number().int().nonnegative()),
+  admittedSecondsByAgentClass: z.record(z.number().int().nonnegative()),
+  activatedAt: z.string().datetime({ offset: true }).optional(),
+  closingAt: z.string().datetime({ offset: true }).optional(),
+  endedAt: z.string().datetime({ offset: true }).optional()
+}).strict();
+function shareDebt(id, weights, actual) {
+  const weight = weights[id] ?? 1;
+  const totalWeight = Object.values(weights).reduce((sum, value) => sum + value, 0) || 1;
+  const totalActual = [...actual.values()].reduce((sum, value) => sum + value, 0);
+  return totalActual * weight / totalWeight - (actual.get(id) ?? 0);
+}
+function selectFairReadyNode(nodes, usage, policy) {
+  if (!nodes.length) return null;
+  const projectActual = /* @__PURE__ */ new Map();
+  const classActual = /* @__PURE__ */ new Map();
+  for (const entry of usage) {
+    projectActual.set(entry.projectId, (projectActual.get(entry.projectId) ?? 0) + entry.seconds);
+    classActual.set(`${entry.projectId}:${entry.agentClass}`, (classActual.get(`${entry.projectId}:${entry.agentClass}`) ?? 0) + entry.seconds);
+  }
+  const projects = [...new Set(nodes.map((node) => node.projectId))].sort((left, right) => shareDebt(right, policy.projectWeights, projectActual) - shareDebt(left, policy.projectWeights, projectActual) || left.localeCompare(right));
+  const projectId = projects[0];
+  const projectNodes = nodes.filter((node) => node.projectId === projectId);
+  const classWeights = Object.fromEntries([...new Set(projectNodes.map((node) => node.agentClass))].map((agentClass) => [agentClass, policy.agentClassWeights[agentClass] ?? 1]));
+  const projectClassActual = new Map([...classActual].filter(([key]) => key.startsWith(`${projectId}:`)).map(([key, value]) => [key.slice(projectId.length + 1), value]));
+  const classes = [...new Set(projectNodes.map((node) => node.agentClass))].sort((left, right) => shareDebt(right, classWeights, projectClassActual) - shareDebt(left, classWeights, projectClassActual) || left.localeCompare(right));
+  return projectNodes.filter((node) => node.agentClass === classes[0]).sort((left, right) => right.graphPriority - left.graphPriority || Date.parse(left.readyAt) - Date.parse(right.readyAt) || left.id.localeCompare(right))[0] ?? null;
+}
+function compilePlanningRounds(workdayId, agentIds, planningSecondsPerAgent) {
+  const agents = [...new Set(agentIds)].sort();
+  return [1, 2].flatMap((round) => agents.map((agentId) => ({
+    id: `planning:${workdayId}:${round}:${agentId}`,
+    agentId,
+    round,
+    maximumSeconds: planningSecondsPerAgent,
+    dependsOn: round === 1 ? [] : agents.map((candidate) => `planning:${workdayId}:1:${candidate}`)
+  })));
+}
+function compileWorkday(input) {
+  const policy = workdayPolicySchema.parse(input.policy);
+  const assignments = compilePlanningRounds(input.id, input.agentIds, policy.planningSecondsPerAgent);
+  const startsAt = new Date(input.startsAt).toISOString();
+  return appliedWorkdaySchema.parse({
+    schemaVersion: "treeseed.workday/v1",
+    id: input.id,
+    teamId: input.teamId,
+    policyId: input.policyId,
+    policyRevision: input.policyRevision,
+    policySnapshot: policy,
+    state: "planned",
+    startsAt,
+    endsAt: new Date(Date.parse(startsAt) + policy.durationSeconds * 1e3).toISOString(),
+    planningRounds: [1, 2].map((round) => ({
+      round,
+      state: "pending",
+      assignmentIds: assignments.filter((assignment) => assignment.round === round).map((assignment) => assignment.id)
+    })),
+    admittedSecondsByProject: {},
+    admittedSecondsByAgentClass: {}
+  });
+}
+export {
+  appliedWorkdaySchema,
+  compilePlanningRounds,
+  compileWorkday,
+  selectFairReadyNode,
+  workdayPolicySchema
+};