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

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

@@ -1,72 +1,178 @@
 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;
-    planningSecondsPerAgent: z.ZodNumber;
+    planningPercent: z.ZodDefault<z.ZodNumber>;
+    allocationWeight: z.ZodDefault<z.ZodNumber>;
+    planningTurnMaximumSeconds: z.ZodDefault<z.ZodNumber>;
     communicationConcurrency: z.ZodNumber;
-    projectWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
-    agentClassWeights: z.ZodRecord<z.ZodString, 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;
-    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>;
+    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;
-        planningSecondsPerAgent: z.ZodNumber;
+        planningPercent: z.ZodDefault<z.ZodNumber>;
+        allocationWeight: z.ZodDefault<z.ZodNumber>;
+        planningTurnMaximumSeconds: z.ZodDefault<z.ZodNumber>;
         communicationConcurrency: z.ZodNumber;
-        projectWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
-        agentClassWeights: z.ZodRecord<z.ZodString, 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;
-        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>;
+        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.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        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: 1 | 2;
+        round: number;
         assignmentIds: string[];
         completedAt?: string | undefined;
         startedAt?: string | undefined;
     }, {
         state: "active" | "pending" | "complete";
-        round: 1 | 2;
+        round: number;
         assignmentIds: string[];
         completedAt?: string | undefined;
         startedAt?: string | undefined;
@@ -81,21 +187,24 @@ export declare const appliedWorkdaySchema: z.ZodObject<{
     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;
-        planningSecondsPerAgent: number;
         communicationConcurrency: number;
-        projectWeights: Record<string, number>;
-        agentClassWeights: Record<string, number>;
     };
     planningRounds: {
         state: "active" | "pending" | "complete";
-        round: 1 | 2;
+        round: number;
         assignmentIds: string[];
         completedAt?: string | undefined;
         startedAt?: string | undefined;
@@ -110,6 +219,7 @@ export declare const appliedWorkdaySchema: z.ZodObject<{
     state: "active" | "planned" | "closing" | "ended";
     schemaVersion: "treeseed.workday/v1";
     teamId: string;
+    executionMode: "production" | "simulation";
     startsAt: string;
     endsAt: string;
     policyId: string;
@@ -117,14 +227,16 @@ export declare const appliedWorkdaySchema: z.ZodObject<{
     policySnapshot: {
         durationSeconds: number;
         maximumConcurrency: number;
-        planningSecondsPerAgent: number;
         communicationConcurrency: number;
-        projectWeights: Record<string, number>;
-        agentClassWeights: Record<string, 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: 1 | 2;
+        round: number;
         assignmentIds: string[];
         completedAt?: string | undefined;
         startedAt?: string | undefined;
@@ -148,43 +260,63 @@ export interface FairUsage {
     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): {
+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;
-        planningSecondsPerAgent: number;
         communicationConcurrency: number;
-        projectWeights: Record<string, number>;
-        agentClassWeights: Record<string, number>;
     };
     planningRounds: {
         state: "active" | "pending" | "complete";
-        round: 1 | 2;
+        round: number;
         assignmentIds: string[];
         completedAt?: string | undefined;
         startedAt?: string | undefined;

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

@@ -1,18 +1,40 @@
 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(),
-  planningSecondsPerAgent: 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(),
-  projectWeights: positiveWeights,
-  agentClassWeights: positiveWeights
+  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,
@@ -20,12 +42,12 @@ const appliedWorkdaySchema = z.object({
   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)]),
+    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()).length(2),
+  }).strict()),
   admittedSecondsByProject: z.record(z.number().int().nonnegative()),
   admittedSecondsByAgentClass: z.record(z.number().int().nonnegative()),
   activatedAt: z.string().datetime({ offset: true }).optional(),
@@ -46,51 +68,68 @@ function selectFairReadyNode(nodes, usage, policy) {
     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 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.agentClassWeights[agentClass] ?? 1]));
+  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));
-  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;
+  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, planningSecondsPerAgent) {
+function compilePlanningRounds(workdayId, agentIds, planningTurnMaximumSeconds, round = 1) {
   const agents = [...new Set(agentIds)].sort();
-  return [1, 2].flatMap((round) => agents.map((agentId) => ({
+  return agents.map((agentId) => ({
     id: `planning:${workdayId}:${round}:${agentId}`,
     agentId,
     round,
-    maximumSeconds: planningSecondsPerAgent,
-    dependsOn: round === 1 ? [] : agents.map((candidate) => `planning:${workdayId}:1:${candidate}`)
-  })));
+    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 = compilePlanningRounds(input.id, input.agentIds, policy.planningSecondsPerAgent);
+  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: [1, 2].map((round) => ({
-      round,
-      state: "pending",
-      assignmentIds: assignments.filter((assignment) => assignment.round === round).map((assignment) => assignment.id)
-    })),
+    planningRounds: assignments.length ? [{ round: 1, state: "pending", assignmentIds: assignments.map((assignment) => assignment.id) }] : [],
     admittedSecondsByProject: {},
     admittedSecondsByAgentClass: {}
   });
 }
 export {
+  DEFAULT_WORKDAY_POLICY,
   appliedWorkdaySchema,
   compilePlanningRounds,
   compileWorkday,
   selectFairReadyNode,
-  workdayPolicySchema
+  workdayAllocationOverridesSchema,
+  workdayPhase,
+  workdayPlanningEndsAt,
+  workdayPolicySchema,
+  workdayProfileSchema
 };

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

@@ -1,5 +1,3 @@
-/** Portable durable records shared by workday control-plane and operator consumers. */
-import type { WorkdayAgentSelection } from '../../../workday.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';
@@ -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/support/execution-graph.d.ts

@@ -277,26 +277,26 @@ export declare const executionNodeSchema: z.ZodEffects<z.ZodObject<{
     requiredCapabilities: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
     requestedPermissions: z.ZodOptional<z.ZodObject<{
         content: z.ZodObject<{
-            read: z.ZodEffects<z.ZodArray<z.ZodEnum<["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"]>, "many">, ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[], ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[]>;
-            write: z.ZodEffects<z.ZodArray<z.ZodEnum<["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"]>, "many">, ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[], ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[]>;
+            read: z.ZodEffects<z.ZodArray<z.ZodEnum<["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"]>, "many">, ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[], ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[]>;
+            write: z.ZodEffects<z.ZodArray<z.ZodEnum<["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"]>, "many">, ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[], ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[]>;
         }, "strict", z.ZodTypeAny, {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         }, {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         }>;
         tools: z.ZodEffects<z.ZodArray<z.ZodEnum<["discussion", "source.read", "source.write", "verification", "release"]>, "many">, ("release" | "verification" | "discussion" | "source.read" | "source.write")[], ("release" | "verification" | "discussion" | "source.read" | "source.write")[]>;
     }, "strict", z.ZodTypeAny, {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     }, {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     }>>;
@@ -481,8 +481,8 @@ export declare const executionNodeSchema: z.ZodEffects<z.ZodObject<{
     } | undefined;
     requestedPermissions?: {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     } | undefined;
@@ -559,8 +559,8 @@ export declare const executionNodeSchema: z.ZodEffects<z.ZodObject<{
     } | undefined;
     requestedPermissions?: {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     } | undefined;
@@ -637,8 +637,8 @@ export declare const executionNodeSchema: z.ZodEffects<z.ZodObject<{
     } | undefined;
     requestedPermissions?: {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     } | undefined;
@@ -715,8 +715,8 @@ export declare const executionNodeSchema: z.ZodEffects<z.ZodObject<{
     } | undefined;
     requestedPermissions?: {
         content: {
-            read: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
-            write: ("agent" | "knowledge" | "decision" | "proposal" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            read: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
+            write: ("agent" | "knowledge" | "proposal" | "decision" | "objective" | "question" | "discussion" | "note" | "book" | "discussion-message")[];
         };
         tools: ("release" | "verification" | "discussion" | "source.read" | "source.write")[];
     } | undefined;

package/dist/agent-capacity/contracts/support/time-capacity.d.ts

@@ -146,18 +146,4 @@ export interface AssignmentPerformanceSummary {
     };
     downstreamOutcomes: AssignmentDownstreamOutcome[];
 }
-export interface WorkdayTimePolicy {
-    cooperativePlanningPercent: number;
-    governedExecutionPercent: number;
-    reservePercent: number;
-}
-export declare function validateWorkdayTimePolicy(policy: WorkdayTimePolicy): {
-    ok: boolean;
-    diagnostics: Array<{
-        code: string;
-        path: string;
-        message: string;
-    }>;
-    value?: WorkdayTimePolicy;
-};
 export declare function emptyCapacityBudget(deadline: string, requestedSeconds: number): CapacityBudgetV2;

package/dist/agent-capacity/contracts/support/time-capacity.js

@@ -38,12 +38,6 @@ const ASSIGNMENT_TERMINAL_DISPOSITIONS = [
   "failed"
 ];
 const ASSIGNMENT_PERFORMANCE_SCHEMA = "treeseed.assignment-performance/v2";
-function validateWorkdayTimePolicy(policy) {
-  const values = [policy.cooperativePlanningPercent, policy.governedExecutionPercent, policy.reservePercent];
-  if (values.some((value) => !Number.isFinite(value) || value < 0 || value > 100)) return { ok: false, diagnostics: [{ code: "workday_time_percent_invalid", path: "timePolicy", message: "Workday time percentages must be finite values from 0 through 100." }] };
-  if (Math.abs(values.reduce((sum, value) => sum + value, 0) - 100) >= 1e-6) return { ok: false, diagnostics: [{ code: "workday_time_total_invalid", path: "timePolicy", message: "Workday time percentages must total exactly 100%." }] };
-  return { ok: true, diagnostics: [], value: policy };
-}
 function emptyCapacityBudget(deadline, requestedSeconds) {
   return {
     schemaVersion: CAPACITY_BUDGET_SCHEMA,
@@ -58,6 +52,5 @@ export {
   ASSIGNMENT_TERMINAL_DISPOSITIONS,
   CAPACITY_BUDGET_SCHEMA,
   assignmentTimeWindow,
-  emptyCapacityBudget,
-  validateWorkdayTimePolicy
+  emptyCapacityBudget
 };