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

package/dist/operator-contracts/workday-lifecycle.d.ts

@@ -1,4 +1,3 @@
-import { type WorkdayBorrowingEvidence } from './workday-profile.js';
 import type { WorkdayAgentSelection } from '../agent-capacity/workday.js';
 export { normalizeWorkdayAgentSelection } from '../agent-capacity/workday.js';
 export type WorkdayDemandMode = 'planning' | 'acting';
@@ -7,14 +6,22 @@ export interface WorkdayIntent {
     teamId: string;
     profileId: string;
     projects: 'all' | string[];
+    /** Selects the existing execution custody mode; omission defaults safely to simulation. */
+    executionMode?: 'simulation' | 'production';
     startsAt: string;
     endsAt?: string;
     durationSeconds?: number;
     objectiveFilters?: string[];
+    /** Runs cooperative planning profiles without admitting accepted acting work. */
+    planningOnly?: boolean;
+    /** Selects exact governed proposals for cooperative planning and estimating. */
+    proposalIds?: string[];
     /** Selects accepted decisions for API-derived acting work; it does not grant acting authority. */
     decisionIds?: string[];
     /** Limits cooperative planning; acting still requires accepted decision/estimate authority. */
     agentSelection?: Partial<WorkdayAgentSelection>;
+    /** High-level overrides of the canonical workday allocation policy. */
+    allocation?: Partial<Pick<import('../agent-capacity/contracts/capacity/workdays/workday-allocation.js').WorkdayPolicy, 'planningPercent' | 'allocationWeight' | 'planningTurnMaximumSeconds' | 'projectPercentages' | 'agentClassPercentages'>>;
     operatorConstraints?: {
         providerIds?: string[];
         maxConcurrency?: number;
@@ -42,8 +49,6 @@ export interface WorkdaySelectedDemand {
 export interface WorkdayClassAccounting {
     classSlug: string;
     allocatedSeconds: number;
-    borrowedSeconds: number;
-    lentSeconds: number;
     idleSeconds: number;
     reservedSeconds: number;
     activeSeconds: number;
@@ -65,11 +70,9 @@ export interface WorkdayPreflightReceipt {
     reservationDigest: string;
     selectedDemands: WorkdaySelectedDemand[];
     classAccounting: WorkdayClassAccounting[];
-    borrowing: WorkdayBorrowingEvidence[];
     startsAt: string;
     endsAt: string;
     maxConcurrency: number;
-    reserveSeconds: number;
     preflightDigest: string;
     expiresAt: string;
 }
@@ -98,21 +101,6 @@ export interface WorkdayStartReceipt {
     providerReceiptRefs: string[];
     transactionReceiptId: string;
 }
-export interface WorkdaySchedule {
-    schemaVersion: 'treeseed.workday-schedule/v1';
-    id: string;
-    teamId: string;
-    profileId: string;
-    profileVersion: string;
-    projectScope: 'all' | string[];
-    cadence: {
-        timezone: string;
-        expression: string;
-    };
-    durationSeconds: number;
-    status: 'active' | 'paused' | 'retired';
-    nextStartAt: string | null;
-}
 export interface WorkdaySettlement {
     schemaVersion: 'treeseed.workday-settlement/v1';
     workdayId: string;

package/dist/operator-contracts/workday-lifecycle.js

@@ -1,19 +1,32 @@
-import { validateWorkdayBorrowingEvidence } from "./workday-profile.js";
+import { workdayAllocationOverridesSchema } from "../agent-capacity/contracts/capacity/workdays/workday-allocation.js";
 import { normalizeWorkdayAgentSelection } from "../agent-capacity/workday.js";
 function validateWorkdayIntent(intent) {
   const diagnostics = [];
   if (intent.schemaVersion !== "treeseed.workday-intent/v1") diagnostics.push({ code: "schema_version_invalid", path: "schemaVersion", message: "Unsupported workday intent schema." });
   if (!intent.teamId.trim()) diagnostics.push({ code: "team_required", path: "teamId", message: "Team identity is required." });
   if (!intent.profileId.trim()) diagnostics.push({ code: "profile_required", path: "profileId", message: "Allocation profile identity is required." });
-  if (intent.endsAt === void 0 === (intent.durationSeconds === void 0)) diagnostics.push({ code: "time_range_ambiguous", path: "endsAt", message: "Specify exactly one of endsAt or durationSeconds." });
+  if (intent.executionMode !== void 0 && !["simulation", "production"].includes(intent.executionMode)) diagnostics.push({ code: "execution_mode_invalid", path: "executionMode", message: "Select simulation or production custody." });
+  if (intent.endsAt !== void 0 && intent.durationSeconds !== void 0) diagnostics.push({ code: "time_range_ambiguous", path: "endsAt", message: "Specify endsAt or durationSeconds, not both; omission uses the team policy duration." });
   const start = Date.parse(intent.startsAt);
   if (!Number.isFinite(start)) diagnostics.push({ code: "start_invalid", path: "startsAt", message: "startsAt must be an ISO timestamp." });
   if (intent.endsAt !== void 0 && (!Number.isFinite(Date.parse(intent.endsAt)) || Date.parse(intent.endsAt) <= start)) diagnostics.push({ code: "end_invalid", path: "endsAt", message: "endsAt must be a valid timestamp after startsAt." });
   if (intent.durationSeconds !== void 0 && (!Number.isInteger(intent.durationSeconds) || intent.durationSeconds <= 0)) diagnostics.push({ code: "duration_invalid", path: "durationSeconds", message: "durationSeconds must be a positive integer." });
+  if (intent.planningOnly !== void 0 && typeof intent.planningOnly !== "boolean") diagnostics.push({ code: "planning_only_invalid", path: "planningOnly", message: "planningOnly must be boolean." });
+  if (intent.proposalIds !== void 0 && (!Array.isArray(intent.proposalIds) || intent.proposalIds.length === 0 || intent.proposalIds.length > 64 || intent.proposalIds.some((entry) => typeof entry !== "string" || !entry.trim() || entry.length > 128))) {
+    diagnostics.push({ code: "proposal_selection_invalid", path: "proposalIds", message: "Proposal selection must be a bounded nonempty array of proposal identities." });
+  }
   if (intent.decisionIds !== void 0 && (!Array.isArray(intent.decisionIds) || intent.decisionIds.length === 0 || intent.decisionIds.length > 64 || intent.decisionIds.some((entry) => typeof entry !== "string" || !entry.trim() || entry.length > 128))) {
     diagnostics.push({ code: "decision_selection_invalid", path: "decisionIds", message: "Decision selection must be a bounded nonempty array of decision identities." });
   }
   if (intent.agentSelection !== void 0) diagnostics.push(...validateWorkdayIntentSelection(intent.agentSelection));
+  if (intent.allocation !== void 0) {
+    const result = workdayAllocationOverridesSchema.safeParse(intent.allocation);
+    if (!result.success) diagnostics.push(...result.error.issues.map((issue) => ({
+      code: "allocation_invalid",
+      path: `allocation.${issue.path.join(".")}`,
+      message: issue.message
+    })));
+  }
   return diagnostics;
 }
 function validateWorkdayIntentSelection(value) {
@@ -57,8 +70,6 @@ function validateWorkdayPreflight(receipt, now = /* @__PURE__ */ new Date()) {
   else if (expiry <= now.getTime()) diagnostics.push({ code: "preflight_expired", path: "expiresAt", message: "Workday preflight has expired and must be regenerated." });
   if (!Number.isFinite(Date.parse(receipt.startsAt)) || !Number.isFinite(Date.parse(receipt.endsAt)) || Date.parse(receipt.endsAt) <= Date.parse(receipt.startsAt)) diagnostics.push({ code: "preflight_time_range_invalid", path: "endsAt", message: "Preflight must bind a valid time range." });
   if (!Number.isInteger(receipt.maxConcurrency) || receipt.maxConcurrency <= 0) diagnostics.push({ code: "preflight_concurrency_invalid", path: "maxConcurrency", message: "Preflight concurrency must be a positive integer." });
-  if (!Number.isFinite(receipt.reserveSeconds) || receipt.reserveSeconds < 0) diagnostics.push({ code: "preflight_reserve_invalid", path: "reserveSeconds", message: "Preflight reserve seconds must be finite and non-negative." });
-  for (const [index, evidence] of receipt.borrowing.entries()) diagnostics.push(...validateWorkdayBorrowingEvidence(evidence).map((diagnostic) => ({ ...diagnostic, path: `borrowing.${index}.${diagnostic.path}` })));
   if (new Set(receipt.selectedDemands.map((demand) => demand.id)).size !== receipt.selectedDemands.length) diagnostics.push({ code: "preflight_demand_duplicate", path: "selectedDemands", message: "Preflight demand identities must be unique." });
   return diagnostics;
 }
@@ -76,7 +87,6 @@ function validateWorkdaySettlement(settlement) {
     for (const [field, value] of Object.entries(accounting).filter(([field2]) => field2 !== "classSlug")) {
       if (!Number.isFinite(value) || value < 0) diagnostics.push({ code: "settlement_accounting_invalid", path: `classAccounting.${index}.${field}`, message: "Settlement seconds must be finite and non-negative." });
     }
-    if (accounting.lentSeconds > accounting.allocatedSeconds + accounting.borrowedSeconds) diagnostics.push({ code: "settlement_lending_invalid", path: `classAccounting.${index}.lentSeconds`, message: "A class cannot lend more capacity than it held." });
   }
   if (!settlement.preflightDigest.trim() || !settlement.settlementDigest.trim()) diagnostics.push({ code: "settlement_digest_required", path: "settlementDigest", message: "Settlement must bind its preflight and final accounting digests." });
   if (!Number.isFinite(Date.parse(settlement.startedAt)) || !Number.isFinite(Date.parse(settlement.completedAt)) || Date.parse(settlement.completedAt) < Date.parse(settlement.startedAt)) diagnostics.push({ code: "settlement_time_range_invalid", path: "completedAt", message: "Settlement must bind a valid completion time at or after workday start." });

package/dist/secrets-capability/shared-resources.d.ts

@@ -151,13 +151,13 @@ export declare const sharedResourceGrantSchema: z.ZodEffects<z.ZodObject<{
         assignmentIds: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     }, {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     }>;
     limits: z.ZodObject<{
@@ -192,8 +192,8 @@ export declare const sharedResourceGrantSchema: z.ZodEffects<z.ZodObject<{
     expiresAt: string | null;
     scope: {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     };
     origin: "explicit" | "default-policy";
@@ -228,8 +228,8 @@ export declare const sharedResourceGrantSchema: z.ZodEffects<z.ZodObject<{
     expiresAt: string | null;
     scope: {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     };
     origin: "explicit" | "default-policy";
@@ -264,8 +264,8 @@ export declare const sharedResourceGrantSchema: z.ZodEffects<z.ZodObject<{
     expiresAt: string | null;
     scope: {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     };
     origin: "explicit" | "default-policy";
@@ -300,8 +300,8 @@ export declare const sharedResourceGrantSchema: z.ZodEffects<z.ZodObject<{
     expiresAt: string | null;
     scope: {
         environment: "production" | "staging" | "shared";
-        projectIds: string[];
         assignmentIds: string[];
+        projectIds: string[];
         resourceIds: string[];
     };
     origin: "explicit" | "default-policy";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.119",
+  "version": "0.13.0-rc.120",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {

package/dist/agent-capacity/policy/capacity/allocations/allocation-hierarchy.d.ts

@@ -1,29 +0,0 @@
-import type { CapacityAdmissionCounterClaim, CapacityAdmissionReasonCode, CapacityAllocationSetV2 } from '../../../allocation.js';
-interface AllocationHierarchyInput {
-    allocation: CapacityAllocationSetV2;
-    workdayId: string;
-    totalSeconds: number;
-    requestedSeconds: number;
-    selectedSliceIds: string[];
-    committedBySlice: Record<string, number>;
-    committedBorrowedByRule?: Record<string, number>;
-    reserveCommittedSeconds?: number;
-    approvedBorrowingRuleIds?: string[];
-}
-export interface AllocationHierarchyDecision {
-    reasons: CapacityAdmissionReasonCode[];
-    explanation: Array<{
-        gate: string;
-        allowed: boolean;
-        remaining?: number;
-        detail?: string;
-    }>;
-    counterClaims: CapacityAdmissionCounterClaim[];
-    maxReservableSeconds: number;
-    requiresApproval: boolean;
-    calculations: Record<string, unknown>;
-    priorityBand: 'minimum' | 'target' | 'normal' | 'overflow';
-    priorityScore: number;
-}
-export declare function evaluateAllocationHierarchy(input: AllocationHierarchyInput): AllocationHierarchyDecision;
-export {};

package/dist/agent-capacity/policy/capacity/allocations/allocation-hierarchy.js

@@ -1,110 +0,0 @@
-function sliceLimits(allocation, totalSeconds, slice, cache = /* @__PURE__ */ new Map()) {
-  const cached = cache.get(slice.id);
-  if (cached) return cached;
-  const parent = slice.parentSliceId ? allocation.slices.find((candidate) => candidate.id === slice.parentSliceId) : null;
-  const basis = parent ? sliceLimits(allocation, totalSeconds, parent, cache).target : totalSeconds;
-  const limits = {
-    min: basis * slice.policy.minPercent / 100,
-    target: basis * slice.policy.targetPercent / 100,
-    max: basis * slice.policy.maxPercent / 100,
-    hard: basis * slice.policy.hardCapPercent / 100
-  };
-  cache.set(slice.id, limits);
-  return limits;
-}
-function claim(id, scope, scopeId, periodKey, hardLimit, amount) {
-  return amount > 0 ? { id, scope, scopeId, periodKey, hardLimit, amount, release: "settlement-difference" } : null;
-}
-function evaluateAllocationHierarchy(input) {
-  const reasons = [];
-  const explanation = [];
-  const counterClaims = [];
-  const calculations = {};
-  const approved = new Set(input.approvedBorrowingRuleIds ?? []);
-  const cache = /* @__PURE__ */ new Map();
-  let remaining = Number.POSITIVE_INFINITY;
-  let requiresApproval = false;
-  let priorityScore = 4;
-  for (const sliceId of input.selectedSliceIds) {
-    const slice = input.allocation.slices.find((candidate) => candidate.id === sliceId);
-    if (!slice) {
-      reasons.push("allocation_slice_missing");
-      explanation.push({ gate: `allocation:${sliceId}`, allowed: false, detail: "selected slice does not exist" });
-      continue;
-    }
-    const limits = sliceLimits(input.allocation, input.totalSeconds, slice, cache);
-    const committed = input.committedBySlice[sliceId] ?? 0;
-    const normalAvailable = Math.max(0, limits.max - committed);
-    const overflowAvailable = Math.max(0, limits.hard - Math.max(committed, limits.max));
-    let available = normalAvailable;
-    let overflowSource = "none";
-    let overflowRuleId = null;
-    let overflowSourceAvailable = 0;
-    if (overflowAvailable > 0) {
-      const rule = input.allocation.borrowingRules.find((candidate) => candidate.toSliceId === sliceId);
-      if (rule) {
-        const donor = input.allocation.slices.find((candidate) => candidate.id === rule.fromSliceId);
-        if (donor) {
-          const donorLimits = sliceLimits(input.allocation, input.totalSeconds, donor, cache);
-          const donorCommitted = input.committedBySlice[donor.id] ?? 0;
-          const donorAvailable = Math.max(0, donorLimits.target - Math.max(donorCommitted, donorLimits.min));
-          const ruleLimit = donorLimits.target * rule.maxPercent / 100;
-          const ruleAvailable = Math.max(0, ruleLimit - (input.committedBorrowedByRule?.[rule.id] ?? 0));
-          overflowSource = "borrowing-rule";
-          overflowRuleId = rule.id;
-          overflowSourceAvailable = Math.min(donorAvailable, ruleAvailable);
-        }
-      } else if (!slice.parentSliceId) {
-        overflowSource = "reserve";
-        overflowSourceAvailable = Math.max(0, input.totalSeconds * input.allocation.reservePolicy.percent / 100 - (input.reserveCommittedSeconds ?? 0));
-      }
-    }
-    const usableOverflow = Math.min(overflowAvailable, overflowSourceAvailable);
-    if (input.allocation.reservePolicy.overflow === "borrow") available += usableOverflow;
-    else if (input.requestedSeconds > normalAvailable && input.allocation.reservePolicy.overflow === "approval-required") {
-      requiresApproval = true;
-      reasons.push("allocation_borrowing_approval_required");
-    }
-    if (overflowRuleId) {
-      const rule = input.allocation.borrowingRules.find((candidate) => candidate.id === overflowRuleId);
-      if (rule.requiresApproval && !approved.has(rule.id) && input.requestedSeconds > normalAvailable) {
-        requiresApproval = true;
-        reasons.push("allocation_borrowing_approval_required");
-        available = normalAvailable;
-      }
-    }
-    if (input.requestedSeconds > available && !reasons.includes("allocation_borrowing_approval_required")) {
-      reasons.push(input.allocation.reservePolicy.overflow === "deny" ? "allocation_borrowing_denied" : "allocation_hard_cap_exhausted");
-    }
-    remaining = Math.min(remaining, available);
-    const ownAmount = Math.min(input.requestedSeconds, normalAvailable);
-    const overflowAmount = Math.max(0, input.requestedSeconds - ownAmount);
-    const ownClaim = claim(`allocation-slice:${input.allocation.id}:${slice.id}:${input.workdayId}`, "allocation-slice", `${input.allocation.id}:${slice.id}`, input.workdayId, limits.max, ownAmount);
-    if (ownClaim) counterClaims.push(ownClaim);
-    if (overflowAmount > 0 && overflowAmount <= usableOverflow && input.allocation.reservePolicy.overflow === "borrow") {
-      const overflowClaim = claim(`allocation-overflow:${input.allocation.id}:${slice.id}:${input.workdayId}`, "allocation-overflow", `${input.allocation.id}:${slice.id}`, input.workdayId, Math.max(0, limits.hard - limits.max), overflowAmount);
-      if (overflowClaim) counterClaims.push(overflowClaim);
-      if (overflowSource === "reserve") {
-        const reserveClaim = claim(`allocation-reserve:${input.allocation.id}:${input.workdayId}`, "allocation-reserve", input.allocation.id, input.workdayId, input.totalSeconds * input.allocation.reservePolicy.percent / 100, overflowAmount);
-        if (reserveClaim) counterClaims.push(reserveClaim);
-      } else if (overflowRuleId) {
-        const rule = input.allocation.borrowingRules.find((candidate) => candidate.id === overflowRuleId);
-        const donor = input.allocation.slices.find((candidate) => candidate.id === rule.fromSliceId);
-        const donorLimits = sliceLimits(input.allocation, input.totalSeconds, donor, cache);
-        const donorClaim = claim(`allocation-slice:${input.allocation.id}:${donor.id}:${input.workdayId}`, "allocation-slice", `${input.allocation.id}:${donor.id}`, input.workdayId, donorLimits.target, overflowAmount);
-        const ruleClaim = claim(`allocation-borrow:${input.allocation.id}:${rule.id}:${input.workdayId}`, "allocation-borrow", `${input.allocation.id}:${rule.id}`, input.workdayId, donorLimits.target * rule.maxPercent / 100, overflowAmount);
-        if (donorClaim) counterClaims.push(donorClaim);
-        if (ruleClaim) counterClaims.push(ruleClaim);
-      }
-    }
-    const position = committed < limits.min ? "below-minimum" : committed < limits.target ? "below-target" : committed < limits.max ? "above-target" : "overflow";
-    priorityScore = Math.min(priorityScore, position === "below-minimum" ? 4 : position === "below-target" ? 3 : position === "above-target" ? 2 : 1);
-    calculations[sliceId] = { committed, ...limits, normalAvailable, overflowAvailable, overflowSource, overflowSourceAvailable, usableOverflow, position };
-    explanation.push({ gate: `allocation:${sliceId}`, allowed: input.requestedSeconds <= available, remaining: available, detail: JSON.stringify(calculations[sliceId]) });
-  }
-  const priorityBand = priorityScore === 4 ? "minimum" : priorityScore === 3 ? "target" : priorityScore === 2 ? "normal" : "overflow";
-  return { reasons: [...new Set(reasons)], explanation, counterClaims, maxReservableSeconds: Number.isFinite(remaining) ? Math.max(0, remaining) : 0, requiresApproval, calculations, priorityBand, priorityScore };
-}
-export {
-  evaluateAllocationHierarchy
-};

package/dist/operator-contracts/workday-profile.d.ts

@@ -1,72 +0,0 @@
-export type WorkdayDemandSourcePolicy = 'approved-decisions' | 'planning-inputs' | 'questions' | 'proposals' | 'knowledge-gaps' | 'reliability-campaigns';
-export interface WorkdayClassAllocation {
-    classSlug: string;
-    minimumPercent: number;
-    targetPercent: number;
-    maximumPercent: number;
-    mayLend: boolean;
-    mayBorrow: boolean;
-}
-export interface WorkdayAllocationProfile {
-    schemaVersion: 'treeseed.workday-allocation-profile/v1';
-    id: string;
-    version: string;
-    projects: 'all' | string[];
-    excludedClassSlugs?: Record<string, string[]>;
-    classes: WorkdayClassAllocation[];
-    demandSources: WorkdayDemandSourcePolicy[];
-    actingDecisionRequired: true;
-    defaultDurationSeconds: number;
-    maxConcurrency: number;
-    reservePercent: number;
-    prioritization: {
-        strategy: 'priority-then-age' | 'age-then-priority' | 'weighted-fair';
-        starvationLimitSeconds: number;
-    };
-}
-export interface RepositoryWorkdayProfileBundle {
-    schemaVersion: 'treeseed.workday-allocation-profile-bundle/v1';
-    profiles: WorkdayAllocationProfile[];
-}
-export interface ProjectAgentClassMembership {
-    projectId: string;
-    agentId: string;
-    classSlug: string;
-    status: 'active' | 'paused' | 'archived';
-}
-export interface ProjectAgentIdentity {
-    projectId: string;
-    agentId: string;
-}
-export interface ProjectClassCatalog {
-    projectId: string;
-    classSlugs: string[];
-}
-export interface WorkdayProfileDiagnostic {
-    code: string;
-    path: string;
-    message: string;
-}
-export interface WorkdayBorrowingEvidence {
-    workdayId: string;
-    borrowerClassSlug: string;
-    lenderClassSlug: string;
-    borrowedSeconds: number;
-    lendingPermitted: boolean;
-    borrowingPermitted: boolean;
-    lenderAllocatedSecondsBefore: number;
-    lenderAllocatedSecondsAfter: number;
-    lenderMinimumSeconds: number;
-    borrowerAllocatedSecondsBefore: number;
-    borrowerAllocatedSecondsAfter: number;
-    borrowerMaximumSeconds: number;
-    profileId: string;
-    profileVersion: string;
-    profileDigest: string;
-}
-export declare function validateOneClassPerProjectAgent(memberships: ProjectAgentClassMembership[], expectedAgents?: ProjectAgentIdentity[]): WorkdayProfileDiagnostic[];
-export declare function validateWorkdayAllocationProfile(profile: WorkdayAllocationProfile, classCatalogs?: ProjectClassCatalog[]): WorkdayProfileDiagnostic[];
-export declare function normalizeWorkdayAllocationProfile(profile: WorkdayAllocationProfile): WorkdayAllocationProfile;
-export declare function validateRepositoryWorkdayProfileBundle(bundle: RepositoryWorkdayProfileBundle, classCatalogs?: ProjectClassCatalog[]): WorkdayProfileDiagnostic[];
-export declare function normalizeRepositoryWorkdayProfileBundle(bundle: RepositoryWorkdayProfileBundle): RepositoryWorkdayProfileBundle;
-export declare function validateWorkdayBorrowingEvidence(evidence: WorkdayBorrowingEvidence): WorkdayProfileDiagnostic[];

package/dist/operator-contracts/workday-profile.js

@@ -1,106 +0,0 @@
-const PERCENT_TOLERANCE = 1e-6;
-const PROFILE_VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-function validateOneClassPerProjectAgent(memberships, expectedAgents = []) {
-  const diagnostics = [];
-  const byAgent = /* @__PURE__ */ new Map();
-  for (const membership of memberships) {
-    const key = `${membership.projectId}:${membership.agentId}`;
-    byAgent.set(key, [...byAgent.get(key) ?? [], membership]);
-  }
-  for (const [key, values] of byAgent) {
-    if (values.length !== 1) diagnostics.push({ code: "agent_class_membership_multiple", path: `memberships.${key}`, message: "Each project agent must have exactly one allocation-class membership." });
-    if (values.some((value) => value.status !== "active")) diagnostics.push({ code: "agent_class_membership_inactive", path: `memberships.${key}`, message: "The single allocation-class membership must be active." });
-  }
-  for (const agent of expectedAgents) {
-    const key = `${agent.projectId}:${agent.agentId}`;
-    if (!byAgent.has(key)) diagnostics.push({ code: "agent_class_membership_missing", path: `memberships.${key}`, message: "Each project agent must have exactly one allocation-class membership." });
-  }
-  return diagnostics;
-}
-function validateWorkdayAllocationProfile(profile, classCatalogs) {
-  const diagnostics = [];
-  if (profile.schemaVersion !== "treeseed.workday-allocation-profile/v1") diagnostics.push({ code: "schema_version_invalid", path: "schemaVersion", message: "Unsupported workday allocation profile schema." });
-  if (!profile.id.trim()) diagnostics.push({ code: "profile_id_required", path: "id", message: "Profile id is required." });
-  if (!PROFILE_VERSION.test(profile.version)) diagnostics.push({ code: "profile_version_invalid", path: "version", message: "Profile version must be a semantic version." });
-  if (profile.actingDecisionRequired !== true) diagnostics.push({ code: "acting_decision_requirement_invalid", path: "actingDecisionRequired", message: "Acting work must require an approved decision." });
-  if (profile.projects !== "all" && profile.projects.length === 0) diagnostics.push({ code: "project_scope_empty", path: "projects", message: "Profile project scope must select at least one project or all." });
-  if (profile.demandSources.length === 0) diagnostics.push({ code: "demand_sources_empty", path: "demandSources", message: "At least one governed demand source is required." });
-  if (new Set(profile.demandSources).size !== profile.demandSources.length) diagnostics.push({ code: "demand_source_duplicate", path: "demandSources", message: "Demand sources must be unique." });
-  if (!Number.isInteger(profile.defaultDurationSeconds) || profile.defaultDurationSeconds <= 0) diagnostics.push({ code: "duration_invalid", path: "defaultDurationSeconds", message: "Default duration must be a positive integer number of seconds." });
-  if (!Number.isInteger(profile.maxConcurrency) || profile.maxConcurrency <= 0) diagnostics.push({ code: "concurrency_invalid", path: "maxConcurrency", message: "Maximum concurrency must be a positive integer." });
-  if (!Number.isFinite(profile.reservePercent) || profile.reservePercent < 0 || profile.reservePercent > 100) diagnostics.push({ code: "reserve_invalid", path: "reservePercent", message: "Reserve percent must be between 0 and 100." });
-  if (!Number.isFinite(profile.prioritization.starvationLimitSeconds) || profile.prioritization.starvationLimitSeconds <= 0) diagnostics.push({ code: "starvation_limit_invalid", path: "prioritization.starvationLimitSeconds", message: "Starvation limit must be positive." });
-  const classSlugs = /* @__PURE__ */ new Set();
-  let minimumTotal = 0;
-  let targetTotal = 0;
-  let maximumTotal = 0;
-  for (const [index, allocation] of profile.classes.entries()) {
-    const path = `classes.${index}`;
-    if (!allocation.classSlug.trim()) diagnostics.push({ code: "class_slug_required", path: `${path}.classSlug`, message: "Class slug is required." });
-    if (classSlugs.has(allocation.classSlug)) diagnostics.push({ code: "class_slug_duplicate", path: `${path}.classSlug`, message: `Class ${allocation.classSlug} is declared more than once.` });
-    classSlugs.add(allocation.classSlug);
-    const values = [allocation.minimumPercent, allocation.targetPercent, allocation.maximumPercent];
-    if (values.some((value) => !Number.isFinite(value) || value < 0 || value > 100) || allocation.minimumPercent > allocation.targetPercent || allocation.targetPercent > allocation.maximumPercent) diagnostics.push({ code: "class_allocation_invalid", path, message: "Class allocation must satisfy 0 <= minimum <= target <= maximum <= 100." });
-    minimumTotal += allocation.minimumPercent;
-    targetTotal += allocation.targetPercent;
-    maximumTotal += allocation.maximumPercent;
-  }
-  if (minimumTotal > 100 + PERCENT_TOLERANCE) diagnostics.push({ code: "minimum_total_invalid", path: "classes", message: "Class minimum percentages cannot total more than 100." });
-  if (Math.abs(targetTotal - 100) > PERCENT_TOLERANCE) diagnostics.push({ code: "target_total_invalid", path: "classes", message: "Class target percentages must total exactly 100." });
-  if (maximumTotal < 100 - PERCENT_TOLERANCE) diagnostics.push({ code: "maximum_total_invalid", path: "classes", message: "Class maximum percentages must total at least 100." });
-  const selectedProjects = classCatalogs === void 0 ? [] : profile.projects === "all" ? classCatalogs.map((catalog) => catalog.projectId) : profile.projects;
-  for (const projectId of selectedProjects) {
-    const catalog = classCatalogs?.find((candidate) => candidate.projectId === projectId);
-    if (!catalog) {
-      diagnostics.push({ code: "project_class_catalog_missing", path: `projects.${projectId}`, message: `No class catalog exists for selected project ${projectId}.` });
-      continue;
-    }
-    const exclusions = new Set(profile.excludedClassSlugs?.[projectId] ?? []);
-    for (const classSlug of classSlugs) {
-      if (!catalog.classSlugs.includes(classSlug) && !exclusions.has(classSlug)) diagnostics.push({ code: "class_missing_from_project", path: `projects.${projectId}.${classSlug}`, message: `Class ${classSlug} is missing from project ${projectId} and is not explicitly excluded.` });
-    }
-  }
-  return diagnostics;
-}
-function normalizeWorkdayAllocationProfile(profile) {
-  return {
-    ...profile,
-    projects: profile.projects === "all" ? "all" : [...new Set(profile.projects)].sort(),
-    excludedClassSlugs: profile.excludedClassSlugs ? Object.fromEntries(Object.entries(profile.excludedClassSlugs).sort(([left], [right]) => left.localeCompare(right)).map(([projectId, slugs]) => [projectId, [...new Set(slugs)].sort()])) : void 0,
-    classes: [...profile.classes].sort((left, right) => left.classSlug.localeCompare(right.classSlug)),
-    demandSources: [...new Set(profile.demandSources)].sort()
-  };
-}
-function validateRepositoryWorkdayProfileBundle(bundle, classCatalogs) {
-  const diagnostics = [];
-  if (bundle.schemaVersion !== "treeseed.workday-allocation-profile-bundle/v1") diagnostics.push({ code: "bundle_schema_version_invalid", path: "schemaVersion", message: "Unsupported repository workday profile bundle schema." });
-  if (!Array.isArray(bundle.profiles) || bundle.profiles.length === 0) diagnostics.push({ code: "bundle_profiles_empty", path: "profiles", message: "A repository workday profile bundle must contain at least one profile." });
-  const profileIds = /* @__PURE__ */ new Set();
-  for (const [index, profile] of (Array.isArray(bundle.profiles) ? bundle.profiles : []).entries()) {
-    if (profileIds.has(profile.id)) diagnostics.push({ code: "bundle_profile_id_duplicate", path: `profiles.${index}.id`, message: `Stable profile id ${profile.id} is declared more than once; a repository bundle contains exactly one current generation per profile.` });
-    profileIds.add(profile.id);
-    diagnostics.push(...validateWorkdayAllocationProfile(profile, classCatalogs).map((diagnostic) => ({ ...diagnostic, path: `profiles.${index}.${diagnostic.path}` })));
-  }
-  return diagnostics;
-}
-function normalizeRepositoryWorkdayProfileBundle(bundle) {
-  return { schemaVersion: "treeseed.workday-allocation-profile-bundle/v1", profiles: [...bundle.profiles].map(normalizeWorkdayAllocationProfile).sort((left, right) => left.id.localeCompare(right.id) || left.version.localeCompare(right.version)) };
-}
-function validateWorkdayBorrowingEvidence(evidence) {
-  const diagnostics = [];
-  if (!evidence.lendingPermitted) diagnostics.push({ code: "lending_not_permitted", path: "lendingPermitted", message: "The profile does not permit the lender to lend capacity." });
-  if (!evidence.borrowingPermitted) diagnostics.push({ code: "borrowing_not_permitted", path: "borrowingPermitted", message: "The profile does not permit the borrower to borrow capacity." });
-  if (evidence.borrowedSeconds <= 0) diagnostics.push({ code: "borrowed_seconds_invalid", path: "borrowedSeconds", message: "Borrowed seconds must be positive." });
-  if (evidence.lenderAllocatedSecondsAfter < evidence.lenderMinimumSeconds) diagnostics.push({ code: "lender_minimum_violated", path: "lenderAllocatedSecondsAfter", message: "Borrowing cannot reduce the lender below its minimum." });
-  if (evidence.borrowerAllocatedSecondsAfter > evidence.borrowerMaximumSeconds) diagnostics.push({ code: "borrower_maximum_violated", path: "borrowerAllocatedSecondsAfter", message: "Borrowing cannot raise the borrower above its maximum." });
-  if (evidence.lenderAllocatedSecondsBefore - evidence.lenderAllocatedSecondsAfter !== evidence.borrowedSeconds || evidence.borrowerAllocatedSecondsAfter - evidence.borrowerAllocatedSecondsBefore !== evidence.borrowedSeconds) diagnostics.push({ code: "borrowing_accounting_mismatch", path: "borrowedSeconds", message: "Lender and borrower deltas must exactly equal the borrowed seconds." });
-  return diagnostics;
-}
-export {
-  normalizeRepositoryWorkdayProfileBundle,
-  normalizeWorkdayAllocationProfile,
-  validateOneClassPerProjectAgent,
-  validateRepositoryWorkdayProfileBundle,
-  validateWorkdayAllocationProfile,
-  validateWorkdayBorrowingEvidence
-};