@treeseed/sdk 0.12.62 → 0.13.0-rc.10

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

@@ -0,0 +1,157 @@
+import { type WorkdayBorrowingEvidence } from './workday-profile.js';
+export type WorkdayDemandMode = 'planning' | 'acting';
+export interface WorkdayIntent {
+    schemaVersion: 'treeseed.workday-intent/v1';
+    teamId: string;
+    profileId: string;
+    projects: 'all' | string[];
+    startsAt: string;
+    endsAt?: string;
+    durationSeconds?: number;
+    objectiveFilters?: string[];
+    operatorConstraints?: {
+        providerIds?: string[];
+        maxConcurrency?: number;
+        reservePercent?: number;
+    };
+}
+export interface WorkdayActingAuthorityEvidence {
+    decisionId: string;
+    decisionStatus: 'approved';
+    executionInputId: string;
+    executionInputStatus: 'accepted';
+    estimateId: string;
+    capacityPlanId: string;
+    capacityPlanDigest: string;
+}
+export interface WorkdaySelectedDemand {
+    id: string;
+    projectId: string;
+    sourceType: string;
+    sourceId: string;
+    mode: WorkdayDemandMode;
+    classSlug: string;
+    requestedSeconds: number;
+    priority: number;
+    actingAuthority?: WorkdayActingAuthorityEvidence;
+}
+export interface WorkdayClassAccounting {
+    classSlug: string;
+    allocatedSeconds: number;
+    borrowedSeconds: number;
+    lentSeconds: number;
+    idleSeconds: number;
+    reservedSeconds: number;
+    activeSeconds: number;
+    releasedSeconds: number;
+    overrunSeconds: number;
+}
+export interface WorkdayPreflightReceipt {
+    schemaVersion: 'treeseed.workday-preflight/v1';
+    id: string;
+    teamId: string;
+    intentDigest: string;
+    profileId: string;
+    profileVersion: string;
+    profileGeneration: number;
+    profileDigest: string;
+    demandSetDigest: string;
+    providerCapacityDigest: string;
+    authorizationDigest: string;
+    reservationDigest: string;
+    selectedDemands: WorkdaySelectedDemand[];
+    classAccounting: WorkdayClassAccounting[];
+    borrowing: WorkdayBorrowingEvidence[];
+    startsAt: string;
+    endsAt: string;
+    maxConcurrency: number;
+    reserveSeconds: number;
+    preflightDigest: string;
+    expiresAt: string;
+}
+export interface WorkdayPreflightObservation {
+    profileGeneration: number;
+    profileDigest: string;
+    demandSetDigest: string;
+    providerCapacityDigest: string;
+    authorizationDigest: string;
+    reservationDigest: string;
+}
+export interface WorkdayStartRequest {
+    preflightId: string;
+    preflightDigest: string;
+    idempotencyKey: string;
+}
+export interface WorkdayStartReceipt {
+    schemaVersion: 'treeseed.workday-start-receipt/v1';
+    workdayId: string;
+    preflightId: string;
+    preflightDigest: string;
+    acceptedCapacityPlanIds: string[];
+    assignmentIds: string[];
+    reservationIds: string[];
+    startedAt: string;
+    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;
+    status: 'completed' | 'cancelled' | 'failed' | 'degraded';
+    preflightDigest: string;
+    classAccounting: WorkdayClassAccounting[];
+    assignmentIds: string[];
+    releasedReservationIds: string[];
+    artifactRefs: string[];
+    startedAt: string;
+    completedAt: string;
+    settlementDigest: string;
+}
+export interface RepositoryProfileGenerationReceipt {
+    schemaVersion: 'treeseed.repository-profile-generation/v1';
+    repository: string;
+    ref: string;
+    commit: string;
+    path: string;
+    profileId: string;
+    profileVersion: string;
+    profileDigest: string;
+    generation: number;
+    indexedAt: string;
+}
+export interface RepositoryProfileReconciliationReceipt {
+    schemaVersion: 'treeseed.repository-profile-reconciliation/v1';
+    repository: string;
+    observedCommit: string;
+    previousGeneration: number | null;
+    acceptedGeneration: number;
+    profileDigests: string[];
+    status: 'created' | 'updated' | 'unchanged' | 'rejected';
+    diagnostics: string[];
+    receiptDigest: string;
+}
+export interface WorkdayLifecycleDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateWorkdayIntent(intent: WorkdayIntent): WorkdayLifecycleDiagnostic[];
+export declare function validateSelectedDemand(demand: WorkdaySelectedDemand): WorkdayLifecycleDiagnostic[];
+export declare function validateWorkdayPreflight(receipt: WorkdayPreflightReceipt, now?: Date): WorkdayLifecycleDiagnostic[];
+export declare function validateWorkdayPreflightFreshness(receipt: WorkdayPreflightReceipt, observed: WorkdayPreflightObservation): WorkdayLifecycleDiagnostic[];
+export declare function validateWorkdaySettlement(settlement: WorkdaySettlement): WorkdayLifecycleDiagnostic[];

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

@@ -0,0 +1,65 @@
+import { validateWorkdayBorrowingEvidence } from "./workday-profile.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." });
+  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." });
+  return diagnostics;
+}
+function validateSelectedDemand(demand) {
+  const diagnostics = [];
+  if (demand.requestedSeconds <= 0 || !Number.isInteger(demand.requestedSeconds)) diagnostics.push({ code: "requested_seconds_invalid", path: "requestedSeconds", message: "Demand duration must be a positive integer." });
+  if (demand.mode === "acting" && !demand.actingAuthority) diagnostics.push({ code: "acting_authority_required", path: "actingAuthority", message: "Acting demand requires approved decision, accepted execution input, estimate, and API-derived capacity plan evidence." });
+  if (demand.mode === "acting" && demand.actingAuthority && (demand.actingAuthority.decisionStatus !== "approved" || demand.actingAuthority.executionInputStatus !== "accepted")) diagnostics.push({ code: "acting_authority_invalid", path: "actingAuthority", message: "Acting authority must bind an approved decision and accepted execution input." });
+  if (demand.mode === "acting" && demand.actingAuthority && [demand.actingAuthority.decisionId, demand.actingAuthority.executionInputId, demand.actingAuthority.estimateId, demand.actingAuthority.capacityPlanId, demand.actingAuthority.capacityPlanDigest].some((value) => !value.trim())) diagnostics.push({ code: "acting_authority_identity_missing", path: "actingAuthority", message: "Acting authority must bind non-empty decision, execution, estimate, capacity-plan, and plan-digest identities." });
+  return diagnostics;
+}
+function validateWorkdayPreflight(receipt, now = /* @__PURE__ */ new Date()) {
+  const diagnostics = receipt.selectedDemands.flatMap((demand, index) => validateSelectedDemand(demand).map((diagnostic) => ({ ...diagnostic, path: `selectedDemands.${index}.${diagnostic.path}` })));
+  if (receipt.schemaVersion !== "treeseed.workday-preflight/v1") diagnostics.push({ code: "schema_version_invalid", path: "schemaVersion", message: "Unsupported workday preflight schema." });
+  if (!Number.isInteger(receipt.profileGeneration) || receipt.profileGeneration <= 0) diagnostics.push({ code: "profile_generation_invalid", path: "profileGeneration", message: "Profile generation must be a positive integer." });
+  for (const field of ["intentDigest", "profileDigest", "demandSetDigest", "providerCapacityDigest", "authorizationDigest", "reservationDigest", "preflightDigest"]) {
+    if (!receipt[field].trim()) diagnostics.push({ code: "digest_required", path: field, message: `${field} is required.` });
+  }
+  const expiry = Date.parse(receipt.expiresAt);
+  if (!Number.isFinite(expiry)) diagnostics.push({ code: "preflight_expiry_invalid", path: "expiresAt", message: "Preflight expiry must be a valid timestamp." });
+  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;
+}
+function validateWorkdayPreflightFreshness(receipt, observed) {
+  const diagnostics = [];
+  for (const field of ["profileGeneration", "profileDigest", "demandSetDigest", "providerCapacityDigest", "authorizationDigest", "reservationDigest"]) {
+    if (receipt[field] !== observed[field]) diagnostics.push({ code: "preflight_state_changed", path: field, message: `${field} changed after preflight; generate a fresh plan.` });
+  }
+  return diagnostics;
+}
+function validateWorkdaySettlement(settlement) {
+  const diagnostics = [];
+  if (settlement.schemaVersion !== "treeseed.workday-settlement/v1") diagnostics.push({ code: "schema_version_invalid", path: "schemaVersion", message: "Unsupported workday settlement schema." });
+  for (const [index, accounting] of settlement.classAccounting.entries()) {
+    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." });
+  return diagnostics;
+}
+export {
+  validateSelectedDemand,
+  validateWorkdayIntent,
+  validateWorkdayPreflight,
+  validateWorkdayPreflightFreshness,
+  validateWorkdaySettlement
+};

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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,106 @@
+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
+};

package/dist/projects/projects-core/project-workflow.d.ts

@@ -0,0 +1,179 @@
+export declare const PROJECT_JOB_STATUSES: readonly ["queued", "running", "waiting_for_approval", "failed", "completed", "rolled_back", "cancelled"];
+export declare const WORKSTREAM_STATES: readonly ["drafting", "active_local", "verifying", "saved_remote", "in_staging", "archived"];
+export declare const RELEASE_STATES: readonly ["drafting", "waiting_on_verification", "ready_to_publish", "published", "rolled_back"];
+export declare const SHARE_PACKAGE_STATES: readonly ["draft", "packaged", "ready_to_publish", "published", "archived", "failed"];
+export declare const AGENT_MESSAGE_KINDS: readonly ["informational", "warning", "action_requested", "release_readiness"];
+export type ProjectJobStatus = (typeof PROJECT_JOB_STATUSES)[number];
+export type WorkstreamState = (typeof WORKSTREAM_STATES)[number];
+export type ReleaseState = (typeof RELEASE_STATES)[number];
+export type SharePackageState = (typeof SHARE_PACKAGE_STATES)[number];
+export type AgentMessageKind = (typeof AGENT_MESSAGE_KINDS)[number];
+export interface LinkedProjectRecordRef {
+    model: 'objective' | 'question' | 'note' | 'proposal' | 'decision';
+    id: string;
+}
+export interface DirectBoardItemSummary {
+    model: 'objective' | 'question' | 'note' | 'proposal' | 'decision';
+    id: string;
+    title: string;
+    status: string | null;
+    updatedAt: string | null;
+    linkedWorkstreamIds: string[];
+    linkedReleaseIds: string[];
+}
+export interface WorkstreamEvent {
+    id: string;
+    workstreamId: string;
+    projectId: string;
+    kind: string;
+    summary: string | null;
+    data: Record<string, unknown>;
+    createdAt: string;
+}
+export interface WorkstreamSummary {
+    id: string;
+    projectId: string;
+    title: string;
+    summary: string | null;
+    state: WorkstreamState;
+    branchName: string | null;
+    branchRef: string | null;
+    owner: string | null;
+    linkedItems: LinkedProjectRecordRef[];
+    verificationStatus: 'completed' | 'failed' | 'waiting' | null;
+    verificationSummary: string | null;
+    lastSaveAt: string | null;
+    lastStageAt: string | null;
+    archivedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface WorkstreamDetail extends WorkstreamSummary {
+    events: WorkstreamEvent[];
+}
+export interface ReleaseSummary {
+    id: string;
+    projectId: string;
+    version: string;
+    title: string | null;
+    state: ReleaseState;
+    summary: string | null;
+    workstreamIds: string[];
+    releaseTag: string | null;
+    commitSha: string | null;
+    publishedAt: string | null;
+    rolledBackAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ReleaseDetail extends ReleaseSummary {
+    items: Array<{
+        id: string;
+        workstreamId: string | null;
+        model: string | null;
+        recordId: string | null;
+        summary: string | null;
+        metadata?: Record<string, unknown>;
+        createdAt: string;
+    }>;
+}
+export interface SharePackageStatus {
+    id: string;
+    projectId: string;
+    kind: 'export' | 'template' | 'knowledge_pack' | 'market_listing';
+    state: SharePackageState;
+    title: string;
+    summary: string | null;
+    version: string | null;
+    outputPath: string | null;
+    artifactKey: string | null;
+    manifestKey: string | null;
+    publishedItemId: string | null;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentStatusRecord {
+    agentSlug: string;
+    handler: string;
+    status: 'active' | 'idle' | 'failed' | 'waiting';
+    currentTask: string | null;
+    workstreamId: string | null;
+    lastMessage: string | null;
+    lastRunAt: string | null;
+}
+export interface AgentMessageRecord {
+    id: string;
+    agentSlug: string;
+    kind: AgentMessageKind;
+    type: string;
+    status: string;
+    summary: string;
+    workstreamId: string | null;
+    releaseId: string | null;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ProjectOverviewSummary {
+    projectId: string;
+    teamId: string;
+    health: {
+        state: string;
+        label: string;
+        reason: string;
+    };
+    counts: {
+        objectives: number;
+        questions: number;
+        notes: number;
+        proposals: number;
+        decisions: number;
+        activeWorkstreams: number;
+        agents: number;
+        releases: number;
+    };
+    nextBestAction: string;
+    recentActivity: Array<{
+        kind: string;
+        id: string;
+        title: string;
+        status: string | null;
+        timestamp: string | null;
+        summary: string | null;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+export interface TeamHomeSummary {
+    teamId: string;
+    projects: ProjectOverviewSummary[];
+    inboxCount: number;
+    productsCount: number;
+}
+export interface TeamMemberSummary {
+    id: string;
+    teamId: string;
+    userId: string;
+    status: string;
+    displayName: string | null;
+    email: string | null;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InboxItem {
+    id: string;
+    teamId: string;
+    projectId: string | null;
+    kind: string;
+    state: ProjectJobStatus | string;
+    title: string;
+    summary: string | null;
+    href: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function normalizeProjectJobStatus(status: string | null | undefined): ProjectJobStatus;

package/dist/projects/projects-core/project-workflow.js

@@ -0,0 +1,66 @@
+const PROJECT_JOB_STATUSES = [
+  "queued",
+  "running",
+  "waiting_for_approval",
+  "failed",
+  "completed",
+  "rolled_back",
+  "cancelled"
+];
+const WORKSTREAM_STATES = [
+  "drafting",
+  "active_local",
+  "verifying",
+  "saved_remote",
+  "in_staging",
+  "archived"
+];
+const RELEASE_STATES = [
+  "drafting",
+  "waiting_on_verification",
+  "ready_to_publish",
+  "published",
+  "rolled_back"
+];
+const SHARE_PACKAGE_STATES = [
+  "draft",
+  "packaged",
+  "ready_to_publish",
+  "published",
+  "archived",
+  "failed"
+];
+const AGENT_MESSAGE_KINDS = [
+  "informational",
+  "warning",
+  "action_requested",
+  "release_readiness"
+];
+function normalizeProjectJobStatus(status) {
+  switch (String(status ?? "").trim()) {
+    case "running":
+      return "running";
+    case "waiting_for_approval":
+      return "waiting_for_approval";
+    case "failed":
+      return "failed";
+    case "completed":
+      return "completed";
+    case "rolled_back":
+      return "rolled_back";
+    case "cancelled":
+      return "cancelled";
+    case "claimed":
+    case "pending":
+    default:
+      return "queued";
+  }
+}
+export {
+  AGENT_MESSAGE_KINDS,
+  PROJECT_JOB_STATUSES,
+  RELEASE_STATES,
+  SHARE_PACKAGE_STATES,
+  WORKSTREAM_STATES,
+  normalizeProjectJobStatus
+};