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

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

@@ -0,0 +1,331 @@
+import { z } from 'zod';
+import { type AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
+export declare const workdayPolicySchema: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+    maximumConcurrency: z.ZodNumber;
+    planningPercent: z.ZodDefault<z.ZodNumber>;
+    allocationWeight: z.ZodDefault<z.ZodNumber>;
+    planningTurnMaximumSeconds: z.ZodDefault<z.ZodNumber>;
+    communicationConcurrency: z.ZodNumber;
+    projectPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    agentClassPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+}, "strict", z.ZodTypeAny, {
+    planningPercent: number;
+    allocationWeight: number;
+    planningTurnMaximumSeconds: number;
+    projectPercentages: Record<string, number>;
+    agentClassPercentages: Record<string, Record<string, number>>;
+    durationSeconds: number;
+    maximumConcurrency: number;
+    communicationConcurrency: number;
+}, {
+    durationSeconds: number;
+    maximumConcurrency: number;
+    communicationConcurrency: number;
+    planningPercent?: number | undefined;
+    allocationWeight?: number | undefined;
+    planningTurnMaximumSeconds?: number | undefined;
+    projectPercentages?: Record<string, number> | undefined;
+    agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+}>;
+export declare const workdayAllocationOverridesSchema: z.ZodObject<{
+    planningPercent: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    allocationWeight: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    planningTurnMaximumSeconds: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    projectPercentages: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    agentClassPercentages: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>>;
+}, "strict", z.ZodTypeAny, {
+    planningPercent?: number | undefined;
+    allocationWeight?: number | undefined;
+    planningTurnMaximumSeconds?: number | undefined;
+    projectPercentages?: Record<string, number> | undefined;
+    agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+}, {
+    planningPercent?: number | undefined;
+    allocationWeight?: number | undefined;
+    planningTurnMaximumSeconds?: number | undefined;
+    projectPercentages?: Record<string, number> | undefined;
+    agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+}>;
+/** One canonical default; team-owned overrides use this same policy contract. */
+export declare const DEFAULT_WORKDAY_POLICY: Readonly<{
+    planningPercent: number;
+    allocationWeight: number;
+    planningTurnMaximumSeconds: number;
+    projectPercentages: Record<string, number>;
+    agentClassPercentages: Record<string, Record<string, number>>;
+    durationSeconds: number;
+    maximumConcurrency: number;
+    communicationConcurrency: number;
+}>;
+export declare const workdayProfileSchema: z.ZodObject<{
+    id: z.ZodLiteral<"default">;
+    teamId: z.ZodString;
+    revision: z.ZodNumber;
+    policy: z.ZodObject<{
+        durationSeconds: z.ZodNumber;
+        maximumConcurrency: z.ZodNumber;
+        planningPercent: z.ZodDefault<z.ZodNumber>;
+        allocationWeight: z.ZodDefault<z.ZodNumber>;
+        planningTurnMaximumSeconds: z.ZodDefault<z.ZodNumber>;
+        communicationConcurrency: z.ZodNumber;
+        projectPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        agentClassPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    }, "strict", z.ZodTypeAny, {
+        planningPercent: number;
+        allocationWeight: number;
+        planningTurnMaximumSeconds: number;
+        projectPercentages: Record<string, number>;
+        agentClassPercentages: Record<string, Record<string, number>>;
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+    }, {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+        planningPercent?: number | undefined;
+        allocationWeight?: number | undefined;
+        planningTurnMaximumSeconds?: number | undefined;
+        projectPercentages?: Record<string, number> | undefined;
+        agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    id: "default";
+    teamId: string;
+    revision: number;
+    policy: {
+        planningPercent: number;
+        allocationWeight: number;
+        planningTurnMaximumSeconds: number;
+        projectPercentages: Record<string, number>;
+        agentClassPercentages: Record<string, Record<string, number>>;
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+    };
+}, {
+    id: "default";
+    teamId: string;
+    revision: number;
+    policy: {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+        planningPercent?: number | undefined;
+        allocationWeight?: number | undefined;
+        planningTurnMaximumSeconds?: number | undefined;
+        projectPercentages?: Record<string, number> | undefined;
+        agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+    };
+}>;
+export type WorkdayProfile = z.infer<typeof workdayProfileSchema>;
+export declare const appliedWorkdaySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.workday/v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    executionMode: z.ZodEnum<["simulation", "production"]>;
+    policyId: z.ZodString;
+    policyRevision: z.ZodNumber;
+    policySnapshot: z.ZodObject<{
+        durationSeconds: z.ZodNumber;
+        maximumConcurrency: z.ZodNumber;
+        planningPercent: z.ZodDefault<z.ZodNumber>;
+        allocationWeight: z.ZodDefault<z.ZodNumber>;
+        planningTurnMaximumSeconds: z.ZodDefault<z.ZodNumber>;
+        communicationConcurrency: z.ZodNumber;
+        projectPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        agentClassPercentages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    }, "strict", z.ZodTypeAny, {
+        planningPercent: number;
+        allocationWeight: number;
+        planningTurnMaximumSeconds: number;
+        projectPercentages: Record<string, number>;
+        agentClassPercentages: Record<string, Record<string, number>>;
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+    }, {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+        planningPercent?: number | undefined;
+        allocationWeight?: number | undefined;
+        planningTurnMaximumSeconds?: number | undefined;
+        projectPercentages?: Record<string, number> | undefined;
+        agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+    }>;
+    state: z.ZodEnum<["planned", "active", "closing", "ended"]>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    planningRounds: z.ZodArray<z.ZodObject<{
+        round: z.ZodNumber;
+        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: number;
+        assignmentIds: string[];
+        completedAt?: string | undefined;
+        startedAt?: string | undefined;
+    }, {
+        state: "active" | "pending" | "complete";
+        round: number;
+        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;
+    executionMode: "production" | "simulation";
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        planningPercent: number;
+        allocationWeight: number;
+        planningTurnMaximumSeconds: number;
+        projectPercentages: Record<string, number>;
+        agentClassPercentages: Record<string, Record<string, number>>;
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: number;
+        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;
+    executionMode: "production" | "simulation";
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+        planningPercent?: number | undefined;
+        allocationWeight?: number | undefined;
+        planningTurnMaximumSeconds?: number | undefined;
+        projectPercentages?: Record<string, number> | undefined;
+        agentClassPercentages?: Record<string, Record<string, number>> | undefined;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: number;
+        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>): {
+    explanation: {
+        projectTargetPercent: number;
+        projectDeficitSeconds: number;
+        classTargetPercent: number;
+        classDeficitSeconds: number;
+        readyNodeCount: number;
+    };
+    id: string;
+    projectId: string;
+    agentClass: string;
+    graphPriority: number;
+    readyAt: string;
+} | null;
+export declare function compilePlanningRounds(workdayId: string, agentIds: string[], planningTurnMaximumSeconds: number, round?: number): {
+    id: string;
+    agentId: string;
+    round: number;
+    maximumSeconds: number;
+    dependsOn: string[];
+}[];
+export declare function workdayPlanningEndsAt(plan: Pick<AppliedWorkday, 'startsAt' | 'policySnapshot'>): string;
+export declare function workdayPhase(plan: Pick<AppliedWorkday, 'startsAt' | 'endsAt' | 'policySnapshot'>, now: string): 'planning' | 'acting' | 'ended';
+/** 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;
+    executionMode: AgentWorkExecutionMode;
+    policy: z.input<typeof workdayPolicySchema>;
+    agentIds: string[];
+    startsAt: string;
+    activityTypes?: string[];
+}): {
+    id: string;
+    state: "active" | "planned" | "closing" | "ended";
+    schemaVersion: "treeseed.workday/v1";
+    teamId: string;
+    executionMode: "production" | "simulation";
+    startsAt: string;
+    endsAt: string;
+    policyId: string;
+    policyRevision: number;
+    policySnapshot: {
+        planningPercent: number;
+        allocationWeight: number;
+        planningTurnMaximumSeconds: number;
+        projectPercentages: Record<string, number>;
+        agentClassPercentages: Record<string, Record<string, number>>;
+        durationSeconds: number;
+        maximumConcurrency: number;
+        communicationConcurrency: number;
+    };
+    planningRounds: {
+        state: "active" | "pending" | "complete";
+        round: number;
+        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,135 @@
+import { z } from "zod";
+import { AGENT_WORK_EXECUTION_MODES } from "../../support/authority/execution-mode.js";
+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(),
+  planningPercent: z.number().min(0).max(100).default(20),
+  allocationWeight: z.number().positive().default(1),
+  planningTurnMaximumSeconds: z.number().int().positive().default(180),
+  communicationConcurrency: z.number().int().positive(),
+  projectPercentages: positiveWeights.default({}),
+  agentClassPercentages: z.record(positiveWeights).default({})
+}).strict();
+const workdayAllocationOverridesSchema = workdayPolicySchema.pick({
+  planningPercent: true,
+  allocationWeight: true,
+  planningTurnMaximumSeconds: true,
+  projectPercentages: true,
+  agentClassPercentages: true
+}).partial();
+const DEFAULT_WORKDAY_POLICY = Object.freeze(workdayPolicySchema.parse({
+  durationSeconds: 28800,
+  maximumConcurrency: 1,
+  communicationConcurrency: 1
+}));
+const workdayProfileSchema = z.object({
+  id: z.literal("default"),
+  teamId: identifier,
+  revision: z.number().int().positive(),
+  policy: workdayPolicySchema
+}).strict();
+const appliedWorkdaySchema = z.object({
+  schemaVersion: z.literal("treeseed.workday/v1"),
+  id: identifier,
+  teamId: identifier,
+  executionMode: z.enum(AGENT_WORK_EXECUTION_MODES),
+  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.number().int().positive(),
+    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()),
+  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 projectWeights = Object.fromEntries([...new Set(nodes.map((node) => node.projectId))].map((projectId2) => [projectId2, policy.projectPercentages[projectId2] ?? 1]));
+  const projects = Object.keys(projectWeights).sort((left, right) => shareDebt(right, projectWeights, projectActual) - shareDebt(left, 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.agentClassPercentages[projectId]?.[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));
+  const selected = 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.id))[0] ?? null;
+  return selected ? { ...selected, explanation: {
+    projectTargetPercent: 100 * projectWeights[projectId] / Object.values(projectWeights).reduce((sum, weight) => sum + weight, 0),
+    projectDeficitSeconds: shareDebt(projectId, projectWeights, projectActual),
+    classTargetPercent: 100 * classWeights[selected.agentClass] / Object.values(classWeights).reduce((sum, weight) => sum + weight, 0),
+    classDeficitSeconds: shareDebt(selected.agentClass, classWeights, projectClassActual),
+    readyNodeCount: nodes.length
+  } } : null;
+}
+function compilePlanningRounds(workdayId, agentIds, planningTurnMaximumSeconds, round = 1) {
+  const agents = [...new Set(agentIds)].sort();
+  return agents.map((agentId) => ({
+    id: `planning:${workdayId}:${round}:${agentId}`,
+    agentId,
+    round,
+    maximumSeconds: planningTurnMaximumSeconds,
+    dependsOn: round === 1 ? [] : agents.map((candidate) => `planning:${workdayId}:${round - 1}:${candidate}`)
+  }));
+}
+function workdayPlanningEndsAt(plan) {
+  return new Date(Date.parse(plan.startsAt) + plan.policySnapshot.durationSeconds * plan.policySnapshot.planningPercent * 10).toISOString();
+}
+function workdayPhase(plan, now) {
+  if (Date.parse(now) >= Date.parse(plan.endsAt)) return "ended";
+  return Date.parse(now) < Date.parse(workdayPlanningEndsAt(plan)) ? "planning" : "acting";
+}
+function compileWorkday(input) {
+  const policy = workdayPolicySchema.parse(input.policy);
+  const assignments = policy.planningPercent > 0 ? compilePlanningRounds(input.id, input.agentIds, policy.planningTurnMaximumSeconds) : [];
+  const startsAt = new Date(input.startsAt).toISOString();
+  return appliedWorkdaySchema.parse({
+    schemaVersion: "treeseed.workday/v1",
+    id: input.id,
+    teamId: input.teamId,
+    executionMode: input.executionMode,
+    policyId: input.policyId,
+    policyRevision: input.policyRevision,
+    policySnapshot: policy,
+    state: "planned",
+    startsAt,
+    endsAt: new Date(Date.parse(startsAt) + policy.durationSeconds * 1e3).toISOString(),
+    planningRounds: assignments.length ? [{ round: 1, state: "pending", assignmentIds: assignments.map((assignment) => assignment.id) }] : [],
+    admittedSecondsByProject: {},
+    admittedSecondsByAgentClass: {}
+  });
+}
+export {
+  DEFAULT_WORKDAY_POLICY,
+  appliedWorkdaySchema,
+  compilePlanningRounds,
+  compileWorkday,
+  selectFairReadyNode,
+  workdayAllocationOverridesSchema,
+  workdayPhase,
+  workdayPlanningEndsAt,
+  workdayPolicySchema,
+  workdayProfileSchema
+};

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

@@ -1,6 +1,4 @@
-/** Portable durable records shared by workday control-plane and operator consumers. */
-import type { WorkdayAgentSelection } from '../../../workday.js';
-import type { AgentWorkExecutionMode } from '../../support/execution-mode.js';
+import type { AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
 export type CapacityWorkdayRunStatus = 'queued' | 'running' | 'completed' | 'cancelled' | 'failed' | 'degraded';
 export type CapacityWorkdayEventStatus = 'recorded' | 'active' | 'completed' | 'warning' | 'error' | 'failed';
 export type CapacityWorkdayDemandSource = 'objective' | 'question' | 'proposal' | 'decision-review' | 'knowledge-gap' | 'release-readiness' | 'idle-intent' | 'planning-input' | 'capacity-plan' | 'assignment-completion' | 'assignment-blockage' | 'workday-summary' | 'handoff' | 'research-workflow';
@@ -14,7 +12,7 @@ export interface CapacityWorkdayRunRecord {
     scenarioId: string;
     status: CapacityWorkdayRunStatus;
     environment: string;
-    executionMode?: AgentWorkExecutionMode;
+    executionMode: AgentWorkExecutionMode;
     executionKind?: import('../communication/communication-records.js').CapacityExecutionKind;
     triggerKind?: import('../communication/communication-records.js').CapacityTriggerKind;
     hidden?: boolean;
@@ -98,27 +96,10 @@ export interface ProviderRuntimeEventInput {
 export interface CapacityWorkdayScheduleRecord {
     id: string;
     teamId: string;
-    projectIds: string[];
     status: 'active' | 'paused' | 'completed' | 'failed';
     purpose: string;
-    capacityProviderId: string;
-    agentSelection: WorkdayAgentSelection;
     cadenceSeconds: number;
-    durationSeconds: number;
-    maxActiveAssignments: number;
-    availableSeconds: number;
-    timePolicy: import('../../support/time-capacity.js').WorkdayTimePolicy;
-    planningOnly: boolean;
-    executionMode?: AgentWorkExecutionMode;
-    publicationPolicy: {
-        bookIds: string[];
-        target: 'staging' | 'production';
-        cohortMode: 'accepted';
-        requireTechnicalReview: boolean;
-        requireAudienceReview: boolean;
-        requireGraphReviewWhenStructural: boolean;
-        simulatedHumanApproval: boolean;
-    };
+    intent: import('../../../../operator-contracts/workday-lifecycle.js').WorkdayIntent;
     lastRunId: string | null;
     nextRunAt: string;
     stateVersion: number;

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

@@ -7,7 +7,7 @@ const CAPACITY_CONFIGURATION_FAMILIES = [
   "activity-profile"
 ];
 const CAPACITY_CONFIGURATION_DESCRIPTORS = [
-  { id: "provider-manifest", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-provider/v2", validator: "validateCapacityProviderManifestV2", runtimeOwner: "@treeseed/agent" },
+  { id: "provider-manifest", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-provider/v5", validator: "validateCapacityProviderManifestV5", runtimeOwner: "@treeseed/agent" },
   { id: "provider-offer", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.provider-supply-offer/v1", validator: "validateProviderSupplyOffer", runtimeOwner: "@treeseed/agent" },
   { id: "capacity-grant", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-grant/v2", validator: "validateCapacityGrantV2", runtimeOwner: "@treeseed/api" },
   { id: "allocation-set", ownerPackage: "@treeseed/sdk", format: "yaml", schemaId: "treeseed.capacity-allocation-set/v2", validator: "validateCapacityAllocationSetV2", runtimeOwner: "@treeseed/api" },