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

package/dist/agent-capacity/validation/agent-definition-schema.js

@@ -1,198 +1,88 @@
 import { z } from "zod";
-import { AGENT_ACTIVITY_TYPES, AGENT_HANDLER_KINDS } from "../../types/agents.js";
-import { validateAgentActivityProfilesConfiguration } from "./activity-profile.js";
+import { AGENT_CONTENT_MODELS, AGENT_TOOL_GROUPS } from "../../types/agents.js";
+const identifier = z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+const agentClass = z.string().trim().min(1).max(100).regex(/^[a-z][a-z0-9-]*$/u);
 const nonEmpty = z.string().trim().min(1);
-const stringList = z.array(nonEmpty).superRefine((items, context) => {
-  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
-});
-const nonEmptyStringList = z.array(nonEmpty).min(1).superRefine((items, context) => {
-  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+const unique = (item) => z.array(item).superRefine((items, context) => {
+  if (new Set(items.map((value) => JSON.stringify(value))).size !== items.length) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+  }
 });
-const exactRevisionRefSchema = z.object({ id: nonEmpty, revision: z.number().int().positive() }).strict();
-const exactRevisionRefList = z.array(exactRevisionRefSchema).superRefine((items, context) => {
-  if (new Set(items.map((item) => `${item.id}@${item.revision}`)).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Exact revision references must be unique." });
+const dependenciesSchema = z.object({
+  agents: unique(agentClass).optional(),
+  events: unique(z.literal("workday-closing")).optional()
+}).strict().refine((value) => Boolean(value.agents?.length || value.events?.length), {
+  message: "At least one dependency selector is required."
 });
-const promptSchema = z.object({ system: nonEmpty, task: z.string().optional(), templates: z.record(z.string()).optional() }).strict();
-const toolPolicySchema = z.object({ allowed: stringList, denied: stringList.optional() }).strict();
-const modelPermissionSchema = z.object({ operations: nonEmptyStringList, filters: z.record(z.unknown()).optional() }).strict();
-const permissionsSchema = z.object({
-  content: z.record(modelPermissionSchema).optional(),
-  commit: z.object({ allowed: z.boolean() }).strict().optional(),
-  repository: z.object({ readPaths: stringList.optional(), writePaths: stringList.optional(), allowCodeMutation: z.boolean().optional() }).strict().optional(),
-  network: z.object({ allowWeb: z.boolean().optional(), allowedDomains: stringList.optional() }).strict().optional(),
-  shell: z.object({ allowCommands: z.boolean().optional(), allowedCommands: stringList.optional(), deniedCommands: stringList.optional() }).strict().optional()
-}).strict();
-const artifactTriggerSchema = z.object({
-  event: nonEmpty,
-  artifactKind: nonEmpty,
-  model: nonEmpty.optional(),
-  required: z.boolean().optional()
-}).strict();
-const closeoutPolicySchema = z.object({
-  warningSeconds: z.number().int().positive().optional(),
-  summaryRequired: z.boolean().optional(),
-  requiredArtifactKinds: stringList.optional(),
-  blockOnOpenQuestions: z.boolean().optional()
-}).strict();
-const providerOverridesSchema = z.object({
-  requiredCapabilities: stringList.optional(),
-  disallowedProviderIds: stringList.optional(),
-  promptRef: nonEmpty.optional(),
-  instructionTemplateRefs: exactRevisionRefList.optional(),
-  maxRuntimeSeconds: z.number().int().positive().optional(),
-  maxTotalTokens: z.number().int().positive().optional(),
-  maxCostAmount: z.number().nonnegative().optional()
-}).strict();
-const branchPolicySchema = z.object({
-  kind: z.enum(["read-only", "main-planning-content", "staging-content", "assignment-feature", "staging-release"]),
-  base: z.enum(["main", "staging"]),
-  target: z.enum(["main", "staging"]).optional(),
-  prefix: z.string().optional(),
-  branchNameTemplate: z.string().optional(),
-  worktree: z.string().optional(),
-  updateBaseBeforeRun: z.boolean().optional(),
-  mergeTargetBeforeSave: z.boolean().optional()
-}).strict();
-const signalPolicySchema = z.object({
-  subscribesTo: z.array(z.object({
-    contract: nonEmpty,
-    groupScope: z.object({ mode: nonEmpty, projectId: nonEmpty.optional(), groupRefs: z.array(z.object({ projectId: nonEmpty, groupId: nonEmpty }).strict()).optional() }).strict().optional(),
-    filters: z.record(z.unknown()).optional(),
-    cardinality: z.enum(["single", "each"]).optional(),
-    producerPolicy: z.enum(["any", "all", "quorum"]).optional(),
-    quorum: z.number().int().positive().optional()
-  }).strict()).optional(),
-  publishes: stringList.optional()
+const permissionSetSchema = z.object({
+  content: z.object({
+    read: unique(z.enum(AGENT_CONTENT_MODELS)),
+    write: unique(z.enum(AGENT_CONTENT_MODELS))
+  }).strict(),
+  tools: unique(z.enum(AGENT_TOOL_GROUPS))
 }).strict();
-const planningSignalsSchema = signalPolicySchema.optional();
-const planningIntentSchema = z.object({
-  objective: nonEmpty.optional(),
-  proposalTypes: stringList.optional(),
-  artifactKind: nonEmpty.optional(),
-  subjectModel: nonEmpty.optional(),
-  subjectId: nonEmpty.nullable().optional(),
-  includeWorkdayArtifacts: z.boolean().optional(),
-  stage: z.enum(["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"]).optional(),
-  stages: z.array(z.object({
-    stage: z.enum(["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"]),
-    promptTask: nonEmpty.optional(),
-    signals: planningSignalsSchema
-  }).strict()).min(1).optional(),
-  requiresArtifactKinds: stringList.optional()
-}).strict();
-const answerPolicySchema = z.object({
-  kind: z.enum(["team-human", "human-or-agent", "specific-human", "specific-agent"]),
-  teamId: nonEmpty.optional(),
-  requiredRoles: stringList.optional(),
-  allowedRoles: stringList.optional(),
-  allowedAgentIds: stringList.optional(),
-  allowedAgentClasses: stringList.optional(),
-  allowedActivityProfiles: stringList.optional(),
-  teamMemberId: nonEmpty.optional(),
-  projectId: nonEmpty.optional(),
-  agentSlug: nonEmpty.optional()
-}).strict();
-const executionSchema = z.object({
-  requiredCapabilities: stringList.optional(),
-  maxRuntimeSeconds: z.number().int().positive().optional(),
-  closeoutWarningSeconds: z.number().int().positive().optional(),
-  preparationSeconds: z.number().int().positive().optional(),
-  closeoutSeconds: z.number().int().positive().optional(),
-  maxRetries: z.number().int().nonnegative().optional(),
-  verificationRequired: z.boolean().optional(),
-  maxTotalTokens: z.number().int().positive().optional(),
-  warningTokens: z.number().int().positive().optional(),
-  maxCostAmount: z.number().nonnegative().optional(),
-  costCurrency: z.string().length(3).optional(),
-  nativeLimits: z.array(z.object({ unit: nonEmpty, amount: z.number().nonnegative(), enforceable: z.boolean().optional() }).strict()).optional(),
-  pricingGeneration: z.string().optional(),
-  enforcementConfidence: z.enum(["exact", "bounded", "estimated", "opaque"]).optional(),
-  allowedPaths: stringList.optional(),
-  forbiddenPaths: stringList.optional()
+const promptSchema = z.object({
+  system: z.string().trim().min(20),
+  instructions: z.array(nonEmpty).optional()
 }).strict();
 const activityProfileSchema = z.object({
-  activityType: z.enum(AGENT_ACTIVITY_TYPES).optional(),
-  enabled: z.boolean(),
-  handler: z.enum(AGENT_HANDLER_KINDS),
+  handler: identifier,
+  dependsOn: dependenciesSchema.optional(),
+  permissions: permissionSetSchema,
   prompt: promptSchema,
-  branchPolicy: branchPolicySchema,
-  contextQueryRefs: exactRevisionRefList.optional(),
-  contextQuerySetRefs: exactRevisionRefList.optional(),
-  instructionTemplateRefs: exactRevisionRefList.optional(),
-  permissions: permissionsSchema.optional(),
-  artifactTriggers: z.array(artifactTriggerSchema).optional(),
-  closeoutPolicy: closeoutPolicySchema.optional(),
-  providerOverrides: providerOverridesSchema.optional(),
-  tools: toolPolicySchema,
-  signals: signalPolicySchema.optional(),
-  outputs: z.object({ messageTypes: stringList, modelMutations: stringList }).strict(),
-  planningIntent: planningIntentSchema.optional(),
-  questionPolicy: z.object({ blockExecutionWhenCreated: z.boolean().optional(), defaultAnswerPolicy: answerPolicySchema.optional() }).strict().optional(),
-  execution: executionSchema.optional()
-}).strict().superRefine((profile, context) => {
-  const overrides = profile.providerOverrides;
-  if (!overrides) return;
-  for (const key of ["maxRuntimeSeconds", "maxTotalTokens", "maxCostAmount"]) {
-    if (overrides[key] !== void 0 && (profile.execution?.[key] === void 0 || overrides[key] > profile.execution[key])) {
-      context.addIssue({ code: z.ZodIssueCode.custom, path: ["providerOverrides", key], message: `${key} must narrow an explicit profile execution limit.` });
-    }
-  }
-  if (overrides.promptRef && !Object.hasOwn(profile.prompt.templates ?? {}, overrides.promptRef)) {
-    context.addIssue({ code: z.ZodIssueCode.custom, path: ["providerOverrides", "promptRef"], message: "Provider promptRef must select a declared profile prompt template." });
-  }
+  additionalContext: unique(identifier).optional(),
+  parameters: z.record(z.unknown()).optional()
+}).strict();
+const activityProfilesSchema = z.object({
+  planning: activityProfileSchema.optional(),
+  estimating: activityProfileSchema.optional(),
+  acting: activityProfileSchema.optional(),
+  reviewing: activityProfileSchema.optional(),
+  reporting: activityProfileSchema.optional(),
+  chat: activityProfileSchema.optional()
+}).strict().refine((value) => Object.keys(value).length > 0, {
+  message: "At least one activity profile is required."
 });
 const agentDefinitionSchema = z.object({
-  id: nonEmpty,
-  slug: nonEmpty,
-  title: nonEmpty,
+  schemaVersion: z.literal("treeseed.agent/v1"),
+  id: identifier,
   name: nonEmpty,
-  description: nonEmpty,
-  summary: nonEmpty,
-  agentClass: nonEmpty,
-  projectAgentClassId: nonEmpty,
-  projectAgentClassSlug: nonEmpty,
-  template: z.string().optional(),
-  enabled: z.boolean(),
-  designMaturity: z.enum(["draft", "validated", "simulated", "proven"]).optional(),
-  runtimeStatus: z.enum(["active", "experimental", "dormant"]).optional(),
-  groupIds: nonEmptyStringList,
-  topicIds: stringList.optional(),
-  contextQueryRefs: exactRevisionRefList.optional(),
-  contextQuerySetRefs: exactRevisionRefList.optional(),
-  instructionTemplateRefs: exactRevisionRefList.optional(),
-  identity: z.object({ purpose: nonEmpty, responsibilities: stringList, durableInstructions: nonEmpty }).passthrough(),
-  capabilities: z.array(z.union([nonEmpty, z.object({ id: nonEmpty }).passthrough()])).optional(),
-  activityProfiles: z.record(activityProfileSchema)
-}).passthrough().superRefine((agent, context) => {
-  const raw = agent;
-  for (const legacy of ["primaryGroupId", "permissionPolicy", "contentAccess"]) if (legacy in raw) context.addIssue({ code: z.ZodIssueCode.custom, path: [legacy], message: `${legacy} is not part of the canonical agent contract.` });
-  for (const [profileName, profile] of Object.entries(agent.activityProfiles)) {
-    const key = (ref) => `${ref.id}@${ref.revision}`;
-    const allowed = new Set([...agent.instructionTemplateRefs ?? [], ...profile.instructionTemplateRefs ?? []].map(key));
-    if (profile.providerOverrides?.instructionTemplateRefs?.some((ref) => !allowed.has(key(ref)))) context.addIssue({
+  agentClass,
+  purpose: nonEmpty,
+  responsibilities: z.array(nonEmpty).min(1),
+  capabilities: unique(identifier).refine((value) => value.length > 0, "At least one capability is required."),
+  context: z.object({ include: unique(identifier).refine((value) => value.length > 0) }).strict(),
+  activityProfiles: activityProfilesSchema
+}).strict().superRefine((agent, context) => {
+  if (agent.agentClass !== "reviewer" && agent.activityProfiles.reviewing) {
+    context.addIssue({
       code: z.ZodIssueCode.custom,
-      path: ["activityProfiles", profileName, "providerOverrides", "instructionTemplateRefs"],
-      message: "Provider instruction templates must narrow common or profile instruction templates."
+      path: ["activityProfiles", "reviewing"],
+      message: "Only the Reviewer agent class may enable reviewing."
     });
   }
 });
 function issuePath(path) {
-  return path.reduce((current, segment) => typeof segment === "number" ? `${current}[${segment}]` : current ? `${current}.${segment}` : segment, "");
+  return path.reduce((current, segment) => typeof segment === "number" ? `${current}[${segment}]` : current ? `${current}.${String(segment)}` : String(segment), "");
+}
+function diagnosticsFromZod(error, prefix = "") {
+  return error.issues.map((issue) => {
+    const suffix = issuePath(issue.path);
+    return {
+      code: `agent_schema_${issue.code}`,
+      path: prefix && suffix ? `${prefix}.${suffix}` : prefix || suffix,
+      message: issue.message
+    };
+  });
 }
 function validateAgentDefinitionModel(value) {
   const parsed = agentDefinitionSchema.safeParse(value);
-  const diagnostics = parsed.success ? [] : parsed.error.issues.map((issue) => ({
-    code: `agent_zod_${issue.code}`,
-    path: issuePath(issue.path),
-    message: issue.message
-  }));
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    diagnostics.push(...validateAgentActivityProfilesConfiguration(value.activityProfiles).diagnostics);
-  }
-  const unique = new Map(diagnostics.map((diagnostic) => [`${diagnostic.code}:${diagnostic.path}:${diagnostic.message}`, diagnostic]));
-  return { ok: unique.size === 0, diagnostics: [...unique.values()], data: parsed.success ? parsed.data : null };
+  return parsed.success ? { ok: true, diagnostics: [], data: parsed.data } : { ok: false, diagnostics: diagnosticsFromZod(parsed.error), data: null };
 }
 export {
+  activityProfileSchema,
+  activityProfilesSchema,
   agentDefinitionSchema,
+  diagnosticsFromZod,
   validateAgentDefinitionModel
 };

package/dist/agent-capacity/validation/agent-lab-forensics-schema.d.ts

@@ -13,15 +13,15 @@ export declare const agentActivityQuerySchema: z.ZodObject<{
     after: number;
     type?: string | string[] | undefined;
     agent?: string | string[] | undefined;
-    agentClass?: string | string[] | undefined;
     severity?: string | string[] | undefined;
+    agentClass?: string | string[] | undefined;
 }, {
     type?: string | string[] | undefined;
     agent?: string | string[] | undefined;
     limit?: number | undefined;
-    agentClass?: string | string[] | undefined;
-    severity?: string | string[] | undefined;
     after?: number | undefined;
+    severity?: string | string[] | undefined;
+    agentClass?: string | string[] | undefined;
 }>;
 export declare const agentActivityPageSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodType<AgentActivityEvent, z.ZodTypeDef, AgentActivityEvent>, "many">;
@@ -74,19 +74,19 @@ export declare const agentTranscriptPayloadSchema: z.ZodObject<{
         nextCursor: z.ZodNullable<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         limit: number;
-        hasMore: boolean;
         nextCursor: string | null;
+        hasMore: boolean;
     }, {
         limit: number;
-        hasMore: boolean;
         nextCursor: string | null;
+        hasMore: boolean;
     }>;
 }, "strict", z.ZodTypeAny, {
     entries: Record<string, unknown>[];
     page: {
         limit: number;
-        hasMore: boolean;
         nextCursor: string | null;
+        hasMore: boolean;
     };
     executionRunId: string;
     redactionStatus: "sanitized" | "partially-redacted" | "withheld";
@@ -94,8 +94,8 @@ export declare const agentTranscriptPayloadSchema: z.ZodObject<{
     entries: Record<string, unknown>[];
     page: {
         limit: number;
-        hasMore: boolean;
         nextCursor: string | null;
+        hasMore: boolean;
     };
     executionRunId: string;
     redactionStatus: "sanitized" | "partially-redacted" | "withheld";
@@ -114,19 +114,19 @@ export declare const agentForensicPayloadSchema: z.ZodObject<{
             nextCursor: z.ZodNullable<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         }, {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         }>;
     }, "strict", z.ZodTypeAny, {
         entries: Record<string, unknown>[];
         page: {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         };
         executionRunId: string;
         redactionStatus: "sanitized" | "partially-redacted" | "withheld";
@@ -134,8 +134,8 @@ export declare const agentForensicPayloadSchema: z.ZodObject<{
         entries: Record<string, unknown>[];
         page: {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         };
         executionRunId: string;
         redactionStatus: "sanitized" | "partially-redacted" | "withheld";
@@ -157,7 +157,6 @@ export declare const agentForensicPayloadSchema: z.ZodObject<{
         severity: "error" | "warning" | "info";
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
-    contract: "treeseed.agent-forensic-payload/v1";
     activity: AgentActivityEvent;
     diagnostics: {
         code: string;
@@ -165,37 +164,38 @@ export declare const agentForensicPayloadSchema: z.ZodObject<{
         message: string;
         severity: "error" | "warning" | "info";
     }[];
+    contract: "treeseed.agent-forensic-payload/v1";
     payload?: Record<string, unknown> | undefined;
     transcript?: {
         entries: Record<string, unknown>[];
         page: {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         };
         executionRunId: string;
         redactionStatus: "sanitized" | "partially-redacted" | "withheld";
     } | undefined;
 }, {
-    contract: "treeseed.agent-forensic-payload/v1";
     activity: AgentActivityEvent;
+    contract: "treeseed.agent-forensic-payload/v1";
     payload?: Record<string, unknown> | undefined;
+    diagnostics?: {
+        code: string;
+        path: string;
+        message: string;
+        severity: "error" | "warning" | "info";
+    }[] | undefined;
     transcript?: {
         entries: Record<string, unknown>[];
         page: {
             limit: number;
-            hasMore: boolean;
             nextCursor: string | null;
+            hasMore: boolean;
         };
         executionRunId: string;
         redactionStatus: "sanitized" | "partially-redacted" | "withheld";
     } | undefined;
-    diagnostics?: {
-        code: string;
-        path: string;
-        message: string;
-        severity: "error" | "warning" | "info";
-    }[] | undefined;
 }>;
 export type AgentActivityQuery = z.infer<typeof agentActivityQuerySchema>;
 export type AgentActivityPage = z.infer<typeof agentActivityPageSchema>;
@@ -208,8 +208,8 @@ export declare function parseAgentActivityQuery(value: unknown): {
     after: number;
     type?: string | string[] | undefined;
     agent?: string | string[] | undefined;
-    agentClass?: string | string[] | undefined;
     severity?: string | string[] | undefined;
+    agentClass?: string | string[] | undefined;
 };
 export declare function parseAgentActivityPage(value: unknown): {
     items: AgentActivityEvent[];
@@ -226,8 +226,8 @@ export declare function parseAgentTranscriptPayload(value: unknown): {
     entries: Record<string, unknown>[];
     page: {
         limit: number;
-        hasMore: boolean;
         nextCursor: string | null;
+        hasMore: boolean;
     };
     executionRunId: string;
     redactionStatus: "sanitized" | "partially-redacted" | "withheld";

package/dist/agent-capacity/validation/assignment-records.js

@@ -1,7 +1,7 @@
 const ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["pending", "leased", "running", "completed", "failed", "returned", "expired", "cancelled"]);
 const LEASE_STATES = /* @__PURE__ */ new Set(["unleased", "leased", "released", "expired"]);
 const MODE_RUN_STATUSES = /* @__PURE__ */ new Set(["queued", "running", "succeeded", "failed", "cancelled"]);
-const SYNTHESIS_SOURCES = /* @__PURE__ */ new Set(["approved_decision", "planning_input_request", "capacity_plan", "workday_demand", "verification_failure", "fallback_queue"]);
+const SYNTHESIS_SOURCES = /* @__PURE__ */ new Set(["approved_decision", "planning_input_request", "capacity_plan", "living_execution_graph", "workday_demand", "verification_failure", "fallback_queue"]);
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }

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

@@ -10,5 +10,5 @@ export interface CapacityConfigurationValidation {
     diagnostics: CapacityConfigurationDiagnostic[];
 }
 export declare function validateProjectAgentClassConfiguration(value: unknown): CapacityConfigurationValidation;
-export type ProjectAgentClassConfiguration = Pick<ProjectAgentClass, 'id' | 'slug' | 'name' | 'status' | 'allowedModes' | 'requiredCapabilities' | 'kernelProfile' | 'kernelPolicy' | 'handlerRefs' | 'outputContracts' | 'metadata'>;
+export type ProjectAgentClassConfiguration = Pick<ProjectAgentClass, 'id' | 'slug' | 'name' | 'status' | 'allowedModes' | 'kernelProfile' | 'kernelPolicy' | 'handlerRefs' | 'outputContracts' | 'metadata'>;
 export type PortableActivityProfilesConfiguration = AgentActivityProfilesConfiguration;

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

@@ -8,13 +8,12 @@ function validateProjectAgentClassConfiguration(value) {
   const diagnostics = [];
   const add = (code, path, message) => diagnostics.push({ code, path, message });
   if (!record(value)) return { ok: false, diagnostics: [{ code: "project_agent_class_configuration_invalid", path: "", message: "Project agent class configuration must be an object." }] };
-  const allowed = /* @__PURE__ */ new Set(["id", "slug", "name", "status", "allowedModes", "requiredCapabilities", "kernelProfile", "kernelPolicy", "handlerRefs", "outputContracts", "metadata"]);
+  const allowed = /* @__PURE__ */ new Set(["id", "slug", "name", "status", "allowedModes", "kernelProfile", "kernelPolicy", "handlerRefs", "outputContracts", "metadata"]);
   for (const key of Object.keys(value)) if (!allowed.has(key)) add("project_agent_class_configuration_unknown_field", key, `Unknown project agent class field ${key}.`);
   for (const key of ["id", "slug"]) if (typeof value[key] !== "string" || !String(value[key]).trim()) add("project_agent_class_configuration_field_required", key, `${key} is required.`);
   if (value.name !== void 0 && (typeof value.name !== "string" || !value.name.trim())) add("project_agent_class_configuration_name_invalid", "name", "name must be a non-empty string.");
   if (value.status !== void 0 && !["active", "paused", "archived"].includes(String(value.status))) add("project_agent_class_configuration_status_invalid", "status", "status is invalid.");
   if (!strings(value.allowedModes) || value.allowedModes.some((mode) => mode !== "planning" && mode !== "acting")) add("project_agent_class_configuration_modes_invalid", "allowedModes", "allowedModes must contain unique planning and/or acting values.");
-  if (!strings(value.requiredCapabilities)) add("project_agent_class_configuration_capabilities_invalid", "requiredCapabilities", "requiredCapabilities must contain unique non-empty strings.");
   for (const key of ["kernelProfile", "kernelPolicy", "handlerRefs", "outputContracts", "metadata"]) if (value[key] !== void 0 && !record(value[key])) add("project_agent_class_configuration_object_invalid", key, `${key} must be an object.`);
   return { ok: diagnostics.length === 0, diagnostics };
 }

package/dist/agent-capacity/validation/execution/execution-graph.d.ts

@@ -0,0 +1 @@
+export { conditionDefinitionSchema, executionEdgeSchema, executionNodeSchema, graphChangeSetSchema, graphRevisionSchema, validateExecutionGraph, } from '../../contracts/support/execution-graph.js';

package/dist/agent-capacity/validation/execution/execution-graph.js

@@ -0,0 +1,16 @@
+import {
+  conditionDefinitionSchema,
+  executionEdgeSchema,
+  executionNodeSchema,
+  graphChangeSetSchema,
+  graphRevisionSchema,
+  validateExecutionGraph
+} from "../../contracts/support/execution-graph.js";
+export {
+  conditionDefinitionSchema,
+  executionEdgeSchema,
+  executionNodeSchema,
+  graphChangeSetSchema,
+  graphRevisionSchema,
+  validateExecutionGraph
+};

package/dist/agent-capacity/validation/index.d.ts

@@ -8,4 +8,5 @@ export * from './configuration.js';
 export * from './research/citation.js';
 export * from './research/source-policy.js';
 export * from './research/workflow.js';
-export * from './workflow-promotion.js';
+export * from './execution/execution-graph.js';
+export * from '../contracts/capacity/assignments/agent-execution.js';

package/dist/agent-capacity/validation/index.js

@@ -8,4 +8,5 @@ export * from "./configuration.js";
 export * from "./research/citation.js";
 export * from "./research/source-policy.js";
 export * from "./research/workflow.js";
-export * from "./workflow-promotion.js";
+export * from "./execution/execution-graph.js";
+export * from "../contracts/capacity/assignments/agent-execution.js";

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

@@ -1,16 +1,24 @@
 export type { AgentKernelPolicy, AgentKernelProfile, ProjectAgentClass, ProjectAgentClassStatus } from '../../agent-capacity/contracts/projects/agents/project-agent-class.js';
+export type { AgentDefinition, AgentActivityProfile } from '../../types/agents.js';
 export * from '../../agent-capacity/allocation.js';
+export * from '../../agent-capacity/artifacts.js';
 export * from '../../agent-capacity/validation/index.js';
 export * from '../../agent-capacity/contracts/capacity/assignments/assignment-records.js';
+export * from '../../agent-capacity/contracts/capacity/assignments/assignment-context-pack.js';
+export * from '../../agent-capacity/contracts/capacity/assignments/context-pack-compiler.js';
 export * from '../../agent-capacity/contracts/capacity/communication/communication-records.js';
 export * from '../../agent-capacity/contracts/capacity/providers/supply-policy.js';
 export * from '../../agent-capacity/contracts/capacity/workdays/workday-records.js';
+export * from '../../agent-capacity/contracts/capacity/workdays/workday-allocation.js';
+export * from '../../agent-capacity/contracts/capacity/workdays/assignment-allocation.js';
+export * from '../../agent-capacity/contracts/capacity/workdays/capability-accounting.js';
 export * from '../../agent-capacity/contracts/configuration/configuration.js';
 export * from '../../agent-capacity/contracts/operations/research-workflow.js';
-export * from '../../agent-capacity/contracts/operations/workflow-promotion.js';
+export * from '../../agent-capacity/contracts/operations/agent-team-clone.js';
 export * from '../../agent-capacity/contracts/projects/agents/project-agent-class.js';
 export * from '../../agent-capacity/contracts/runtime/runtime-observability.js';
 export * from '../../agent-capacity/contracts/support/decision-work.js';
+export * from '../../agent-capacity/contracts/support/execution-graph.js';
 export * from '../../agent-capacity/contracts/support/agent-lab-monitoring.js';
 export * from '../../agent-capacity/contracts/support/agent-atlas.js';
 export * from '../../agent-capacity/contracts/support/failure-records.js';

package/dist/capacity/agents/agent-capacity.js

@@ -1,15 +1,22 @@
 export * from "../../agent-capacity/allocation.js";
+export * from "../../agent-capacity/artifacts.js";
 export * from "../../agent-capacity/validation/index.js";
 export * from "../../agent-capacity/contracts/capacity/assignments/assignment-records.js";
+export * from "../../agent-capacity/contracts/capacity/assignments/assignment-context-pack.js";
+export * from "../../agent-capacity/contracts/capacity/assignments/context-pack-compiler.js";
 export * from "../../agent-capacity/contracts/capacity/communication/communication-records.js";
 export * from "../../agent-capacity/contracts/capacity/providers/supply-policy.js";
 export * from "../../agent-capacity/contracts/capacity/workdays/workday-records.js";
+export * from "../../agent-capacity/contracts/capacity/workdays/workday-allocation.js";
+export * from "../../agent-capacity/contracts/capacity/workdays/assignment-allocation.js";
+export * from "../../agent-capacity/contracts/capacity/workdays/capability-accounting.js";
 export * from "../../agent-capacity/contracts/configuration/configuration.js";
 export * from "../../agent-capacity/contracts/operations/research-workflow.js";
-export * from "../../agent-capacity/contracts/operations/workflow-promotion.js";
+export * from "../../agent-capacity/contracts/operations/agent-team-clone.js";
 export * from "../../agent-capacity/contracts/projects/agents/project-agent-class.js";
 export * from "../../agent-capacity/contracts/runtime/runtime-observability.js";
 export * from "../../agent-capacity/contracts/support/decision-work.js";
+export * from "../../agent-capacity/contracts/support/execution-graph.js";
 export * from "../../agent-capacity/contracts/support/agent-lab-monitoring.js";
 export * from "../../agent-capacity/contracts/support/agent-atlas.js";
 export * from "../../agent-capacity/contracts/support/failure-records.js";