@treeseed/sdk 0.12.62 → 0.13.0-rc.10

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

@@ -0,0 +1,115 @@
+function validateCapacityGrantV2(grant) {
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  for (const [path, value] of [["id", grant.id], ["membershipId", grant.membershipId], ["teamId", grant.teamId], ["providerId", grant.providerId], ["projectId", grant.projectId], ["environment", grant.environment]]) {
+    if (!value?.trim()) add("capacity_grant_field_required", path, `${path} is required.`);
+  }
+  if (grant.schemaVersion !== 2) add("capacity_grant_schema_invalid", "schemaVersion", "Grant schemaVersion must be 2.");
+  if (!Array.isArray(grant.allowedModes) || grant.allowedModes.length === 0 || grant.allowedModes.some((mode) => !["planning", "acting"].includes(mode))) add("capacity_grant_modes_invalid", "allowedModes", "Grant allowedModes must contain planning and/or acting.");
+  for (const [path, values] of [["executionProviderIds", grant.executionProviderIds], ["laneIds", grant.laneIds], ["capabilities", grant.capabilities]]) {
+    if (!Array.isArray(values) || values.some((value) => !value?.trim()) || new Set(values).size !== values.length) add("capacity_grant_list_invalid", path, `${path} must contain unique non-empty strings.`);
+  }
+  for (const [path, value] of [["dailyAgentSecondsLimit", grant.dailyAgentSecondsLimit], ["monthlyAgentSecondsLimit", grant.monthlyAgentSecondsLimit]]) {
+    if (value != null && (!Number.isFinite(value) || value < 0)) add("capacity_grant_limit_invalid", path, `${path} must be zero or greater when configured.`);
+  }
+  if (grant.maxConcurrentAssignments != null && (!Number.isInteger(grant.maxConcurrentAssignments) || grant.maxConcurrentAssignments < 0)) add("capacity_grant_concurrency_invalid", "maxConcurrentAssignments", "maxConcurrentAssignments must be a non-negative integer when configured.");
+  if (grant.budgetLimits?.tokens != null && (!Number.isFinite(grant.budgetLimits.tokens) || grant.budgetLimits.tokens < 0)) add("capacity_grant_token_limit_invalid", "budgetLimits.tokens", "Token limit must be finite and non-negative.");
+  if (grant.budgetLimits?.cost && (!Number.isFinite(grant.budgetLimits.cost.amount) || grant.budgetLimits.cost.amount < 0 || !grant.budgetLimits.cost.currency.trim())) add("capacity_grant_cost_limit_invalid", "budgetLimits.cost", "Cost limit requires a non-negative amount and currency.");
+  if (grant.budgetLimits?.native?.some((entry) => !entry.unit.trim() || !Number.isFinite(entry.amount) || entry.amount < 0)) add("capacity_grant_native_limit_invalid", "budgetLimits.native", "Native limits require a unit and non-negative amount.");
+  if (!Array.isArray(grant.executionProviderIds) || grant.executionProviderIds.length === 0) add("capacity_grant_execution_provider_required", "executionProviderIds", "At least one execution provider is required.");
+  if (!grant.unmetered && grant.dailyAgentSecondsLimit == null && grant.monthlyAgentSecondsLimit == null) add("capacity_grant_budget_required", "unmetered", "A metered grant requires a daily or monthly agent-time limit.");
+  if (grant.unmetered && (grant.dailyAgentSecondsLimit != null || grant.monthlyAgentSecondsLimit != null)) add("capacity_grant_budget_ambiguous", "unmetered", "An unmetered grant must not also declare agent-time limits.");
+  if (grant.expiresAt && timestamp(grant.expiresAt) === null) add("capacity_grant_expiry_invalid", "expiresAt", "expiresAt must be an ISO timestamp.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function finitePercent(value) {
+  return Number.isFinite(value) && value >= 0 && value <= 100;
+}
+function timestamp(value) {
+  const parsed = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function validateCapacityAllocationSetV2(set) {
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  if (set.schemaVersion !== 2) add("allocation_schema_invalid", "schemaVersion", "Allocation schemaVersion must be 2.");
+  if (!["draft", "validated", "active", "superseded", "archived"].includes(set.status)) add("allocation_status_invalid", "status", "Allocation status is invalid.");
+  if (!set.id?.trim()) add("allocation_id_required", "id", "Allocation id is required.");
+  if (!set.teamId?.trim()) add("allocation_team_required", "teamId", "Allocation teamId is required.");
+  if (!Number.isInteger(set.version) || set.version < 1) add("allocation_version_invalid", "version", "Allocation version must be a positive integer.");
+  if (timestamp(set.effectiveFrom) === null) add("allocation_effective_from_invalid", "effectiveFrom", "effectiveFrom must be an ISO timestamp.");
+  if (set.effectiveUntil && timestamp(set.effectiveUntil) === null) add("allocation_effective_until_invalid", "effectiveUntil", "effectiveUntil must be an ISO timestamp.");
+  if (set.effectiveUntil && timestamp(set.effectiveFrom) !== null && (timestamp(set.effectiveUntil) ?? 0) <= (timestamp(set.effectiveFrom) ?? 0)) add("allocation_effective_interval_invalid", "effectiveUntil", "effectiveUntil must be later than effectiveFrom.");
+  if (!finitePercent(set.reservePolicy?.percent)) add("allocation_reserve_invalid", "reservePolicy.percent", "Reserve percent must be between 0 and 100.");
+  if (!["deny", "approval-required", "borrow"].includes(set.reservePolicy?.overflow)) add("allocation_reserve_overflow_invalid", "reservePolicy.overflow", "Reserve overflow must be deny, approval-required, or borrow.");
+  const slices = Array.isArray(set.slices) ? set.slices : [];
+  const borrowingRules = Array.isArray(set.borrowingRules) ? set.borrowingRules : [];
+  if (slices.length === 0) add("allocation_slices_required", "slices", "At least one project allocation slice is required.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, slice] of slices.entries()) {
+    const path = `slices[${index}]`;
+    if (!slice || typeof slice !== "object") {
+      add("allocation_slice_invalid", path, "Allocation slice must be an object.");
+      continue;
+    }
+    if (!slice.id?.trim() || ids.has(slice.id)) add("allocation_slice_id_invalid", `${path}.id`, "Slice id must be non-empty and unique.");
+    ids.add(slice.id);
+    if (!["project", "agent-class", "mode"].includes(slice.scope)) add("allocation_slice_scope_invalid", `${path}.scope`, "Slice scope must be project, agent-class, or mode.");
+    if (!slice.targetId?.trim()) add("allocation_slice_target_required", `${path}.targetId`, "Slice targetId is required.");
+    if (!slice.policy || typeof slice.policy !== "object") {
+      add("allocation_slice_policy_invalid", `${path}.policy`, "Slice policy must be an object.");
+      continue;
+    }
+    const { minPercent, targetPercent, maxPercent, hardCapPercent } = slice.policy;
+    if (![minPercent, targetPercent, maxPercent, hardCapPercent].every(finitePercent) || !(minPercent <= targetPercent && targetPercent <= maxPercent && maxPercent <= hardCapPercent)) {
+      add("allocation_slice_bounds_invalid", `${path}.policy`, "Slice bounds must satisfy 0 <= min <= target <= max <= hardCap <= 100.");
+    }
+  }
+  for (const [index, slice] of slices.entries()) {
+    if (!slice || typeof slice !== "object") continue;
+    if (slice.parentSliceId && !ids.has(slice.parentSliceId)) add("allocation_parent_missing", `slices[${index}].parentSliceId`, "Parent slice must exist in the allocation set.");
+    const parent = slice.parentSliceId ? slices.find((candidate) => candidate && typeof candidate === "object" && candidate.id === slice.parentSliceId) : null;
+    if (!slice.parentSliceId && slice.scope !== "project") add("allocation_root_scope_invalid", `slices[${index}].scope`, "Only project slices may exist at the allocation root.");
+    if (parent && (slice.scope === "agent-class" && parent.scope !== "project" || slice.scope === "mode" && parent.scope !== "agent-class" || slice.scope === "project")) add("allocation_scope_hierarchy_invalid", `slices[${index}].scope`, "Allocation hierarchy must be project, then agent-class, then mode.");
+    const ancestors = /* @__PURE__ */ new Set();
+    let current = slice;
+    while (current.parentSliceId) {
+      if (ancestors.has(current.parentSliceId) || current.parentSliceId === slice.id) {
+        add("allocation_cycle_invalid", `slices[${index}].parentSliceId`, "Allocation slice hierarchy must not contain cycles.");
+        break;
+      }
+      ancestors.add(current.parentSliceId);
+      const next = slices.find((candidate) => candidate && typeof candidate === "object" && candidate.id === current.parentSliceId);
+      if (!next) break;
+      current = next;
+    }
+  }
+  const validSlices = slices.filter((slice) => slice && typeof slice === "object");
+  const parentKeys = new Set(validSlices.map((slice) => slice.parentSliceId ?? "root"));
+  for (const parentKey of parentKeys) {
+    const siblings = validSlices.filter((slice) => (slice.parentSliceId ?? "root") === parentKey);
+    const targetTotal = siblings.reduce((total, slice) => total + Number(slice.policy?.targetPercent ?? Number.NaN), 0);
+    const expected = parentKey === "root" ? 100 - set.reservePolicy.percent : 100;
+    if (Math.abs(targetTotal - expected) > 1e-6) add("allocation_target_total_invalid", `slices(parent=${parentKey})`, `Sibling target percentages must total ${expected}.`);
+  }
+  const ruleIds = /* @__PURE__ */ new Set();
+  for (const [index, rule] of borrowingRules.entries()) {
+    if (!rule || typeof rule !== "object") {
+      add("allocation_borrowing_rule_invalid", `borrowingRules[${index}]`, "Borrowing rule must be an object.");
+      continue;
+    }
+    if (!rule.id?.trim() || ruleIds.has(rule.id)) add("allocation_borrowing_id_invalid", `borrowingRules[${index}].id`, "Borrowing rule id must be non-empty and unique.");
+    ruleIds.add(rule.id);
+    if (!ids.has(rule.fromSliceId) || !ids.has(rule.toSliceId)) add("allocation_borrowing_slice_missing", `borrowingRules[${index}]`, "Borrowing rule slices must exist.");
+    if (rule.fromSliceId === rule.toSliceId) add("allocation_borrowing_self_invalid", `borrowingRules[${index}]`, "A slice cannot borrow from itself.");
+    const from = validSlices.find((slice) => slice.id === rule.fromSliceId);
+    const to = validSlices.find((slice) => slice.id === rule.toSliceId);
+    if (from && to && (from.scope !== to.scope || (from.parentSliceId ?? null) !== (to.parentSliceId ?? null))) add("allocation_borrowing_scope_invalid", `borrowingRules[${index}]`, "Borrowing is allowed only between sibling slices at the same scope.");
+    if (!finitePercent(rule.maxPercent) || rule.maxPercent === 0) add("allocation_borrowing_percent_invalid", `borrowingRules[${index}].maxPercent`, "Borrowing maxPercent must be greater than zero and no more than 100.");
+  }
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+export {
+  validateCapacityAllocationSetV2,
+  validateCapacityGrantV2
+};

package/dist/agent-capacity/validation/assignment-records.d.ts

@@ -0,0 +1,16 @@
+import type { AgentModeRun, ProviderAssignment } from '../contracts/capacity/assignments/assignment-records.js';
+export interface AssignmentRecordDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateProviderAssignment(value: unknown): {
+    ok: boolean;
+    diagnostics: AssignmentRecordDiagnostic[];
+};
+export declare function assertProviderAssignment(value: unknown): ProviderAssignment;
+export declare function validateAgentModeRun(value: unknown): {
+    ok: boolean;
+    diagnostics: AssignmentRecordDiagnostic[];
+};
+export declare function assertAgentModeRun(value: unknown): AgentModeRun;

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

@@ -0,0 +1,92 @@
+const ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["pending", "leased", "running", "completed", "failed", "returned", "expired", "cancelled"]);
+const LEASE_STATES = /* @__PURE__ */ new Set(["unleased", "leased", "released", "expired"]);
+const MODE_RUN_STATUSES = /* @__PURE__ */ new Set(["queued", "running", "succeeded", "failed", "cancelled"]);
+const SYNTHESIS_SOURCES = /* @__PURE__ */ new Set(["approved_decision", "planning_input_request", "capacity_plan", "workday_demand", "verification_failure", "fallback_queue"]);
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function present(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function timestamp(value) {
+  return present(value) && Number.isFinite(Date.parse(value));
+}
+function optionalTimestamp(value) {
+  return value == null || value === "" || timestamp(value);
+}
+function jsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function push(diagnostics, code, path, message) {
+  diagnostics.push({ code, path, message });
+}
+function validateCapacityEnvelope(value, path, diagnostics) {
+  const envelope = record(value);
+  if (!present(envelope.teamId)) push(diagnostics, "agent_capacity_envelope_field_invalid", `${path}.teamId`, "teamId is required.");
+  if (!present(envelope.projectId)) push(diagnostics, "agent_capacity_envelope_field_invalid", `${path}.projectId`, "projectId is required.");
+  if (envelope.mode !== "planning" && envelope.mode !== "acting") push(diagnostics, "agent_capacity_envelope_mode_invalid", `${path}.mode`, "mode must be planning or acting.");
+}
+function validateProviderAssignment(value) {
+  const assignment = record(value);
+  const diagnostics = [];
+  for (const field of ["id", "membershipId", "teamId", "projectId", "capacityProviderId", "projectAgentClassId", "createdAt", "updatedAt"]) {
+    if (!present(assignment[field])) push(diagnostics, "provider_assignment_field_invalid", field, `${field} is required.`);
+  }
+  if (!Number.isInteger(assignment.stateVersion) || Number(assignment.stateVersion) < 1) push(diagnostics, "provider_assignment_state_version_invalid", "stateVersion", "stateVersion must be a positive integer.");
+  if (assignment.mode !== "planning" && assignment.mode !== "acting") push(diagnostics, "provider_assignment_mode_invalid", "mode", "mode must be planning or acting.");
+  if (!ASSIGNMENT_STATUSES.has(String(assignment.status ?? ""))) push(diagnostics, "provider_assignment_status_invalid", "status", "status is invalid.");
+  if (!LEASE_STATES.has(String(assignment.leaseState ?? ""))) push(diagnostics, "provider_assignment_lease_state_invalid", "leaseState", "leaseState is invalid.");
+  if (!Number.isInteger(assignment.attemptCount) || Number(assignment.attemptCount) < 0) push(diagnostics, "provider_assignment_attempt_count_invalid", "attemptCount", "attemptCount must be a nonnegative integer.");
+  if (assignment.synthesizedFrom != null && !SYNTHESIS_SOURCES.has(String(assignment.synthesizedFrom))) push(diagnostics, "provider_assignment_synthesis_source_invalid", "synthesizedFrom", "synthesizedFrom is invalid.");
+  for (const field of ["leaseExpiresAt", "leaseRenewedAt", "assignedAt", "claimedAt", "completedAt", "returnedAt", "failedAt"]) {
+    if (!optionalTimestamp(assignment[field])) push(diagnostics, "provider_assignment_timestamp_invalid", field, `${field} must be an ISO timestamp when provided.`);
+  }
+  for (const field of ["capacityEnvelope", "decisionInput", "workspaceContext", "allowedOutputs", "explanation", "lifecycleOutput", "metadata"]) {
+    if (!jsonRecord(assignment[field])) push(diagnostics, "provider_assignment_json_invalid", field, `${field} must be an object.`);
+  }
+  validateCapacityEnvelope(assignment.capacityEnvelope, "capacityEnvelope", diagnostics);
+  const decisionInput = record(assignment.decisionInput);
+  for (const field of ["teamId", "projectId", "projectAgentClassId"]) {
+    if (!present(decisionInput[field])) push(diagnostics, "decision_execution_input_field_invalid", `decisionInput.${field}`, `${field} is required.`);
+  }
+  if (decisionInput.mode !== "planning" && decisionInput.mode !== "acting") push(diagnostics, "decision_execution_input_mode_invalid", "decisionInput.mode", "mode must be planning or acting.");
+  if (!jsonRecord(decisionInput.input)) push(diagnostics, "decision_execution_input_json_invalid", "decisionInput.input", "input must be an object.");
+  if (!timestamp(assignment.createdAt)) push(diagnostics, "provider_assignment_timestamp_invalid", "createdAt", "createdAt must be an ISO timestamp.");
+  if (!timestamp(assignment.updatedAt)) push(diagnostics, "provider_assignment_timestamp_invalid", "updatedAt", "updatedAt must be an ISO timestamp.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function assertProviderAssignment(value) {
+  const result = validateProviderAssignment(value);
+  if (!result.ok) throw new Error(`Invalid provider assignment: ${result.diagnostics.map((entry) => `${entry.code} at ${entry.path}`).join(", ")}`);
+  return value;
+}
+function validateAgentModeRun(value) {
+  const modeRun = record(value);
+  const diagnostics = [];
+  for (const field of ["id", "teamId", "projectId", "providerAssignmentId", "capacityProviderId", "projectAgentClassId", "createdAt", "updatedAt"]) {
+    if (!present(modeRun[field])) push(diagnostics, "agent_mode_run_field_invalid", field, `${field} is required.`);
+  }
+  if (modeRun.mode !== "planning" && modeRun.mode !== "acting") push(diagnostics, "agent_mode_run_mode_invalid", "mode", "mode must be planning or acting.");
+  if (!MODE_RUN_STATUSES.has(String(modeRun.status ?? ""))) push(diagnostics, "agent_mode_run_status_invalid", "status", "status is invalid.");
+  for (const field of ["selectedInput", "capacityEnvelope", "outputs", "traceRefs", "usageActual", "validation", "metadata"]) {
+    if (!jsonRecord(modeRun[field])) push(diagnostics, "agent_mode_run_json_invalid", field, `${field} must be an object.`);
+  }
+  validateCapacityEnvelope(modeRun.capacityEnvelope, "capacityEnvelope", diagnostics);
+  for (const field of ["startedAt", "completedAt", "failedAt"]) {
+    if (!optionalTimestamp(modeRun[field])) push(diagnostics, "agent_mode_run_timestamp_invalid", field, `${field} must be an ISO timestamp when provided.`);
+  }
+  if (!timestamp(modeRun.createdAt)) push(diagnostics, "agent_mode_run_timestamp_invalid", "createdAt", "createdAt must be an ISO timestamp.");
+  if (!timestamp(modeRun.updatedAt)) push(diagnostics, "agent_mode_run_timestamp_invalid", "updatedAt", "updatedAt must be an ISO timestamp.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function assertAgentModeRun(value) {
+  const result = validateAgentModeRun(value);
+  if (!result.ok) throw new Error(`Invalid agent mode run: ${result.diagnostics.map((entry) => `${entry.code} at ${entry.path}`).join(", ")}`);
+  return value;
+}
+export {
+  assertAgentModeRun,
+  assertProviderAssignment,
+  validateAgentModeRun,
+  validateProviderAssignment
+};

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

@@ -0,0 +1,14 @@
+import type { AgentActivityProfilesConfiguration } from '../../types/agents.js';
+import type { ProjectAgentClass } from '../contracts/projects/agents/project-agent-class.js';
+export interface CapacityConfigurationDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export interface CapacityConfigurationValidation {
+    ok: boolean;
+    diagnostics: CapacityConfigurationDiagnostic[];
+}
+export declare function validateProjectAgentClassConfiguration(value: unknown): CapacityConfigurationValidation;
+export type ProjectAgentClassConfiguration = Pick<ProjectAgentClass, 'id' | 'slug' | 'name' | 'status' | 'allowedModes' | 'requiredCapabilities' | 'kernelProfile' | 'kernelPolicy' | 'handlerRefs' | 'outputContracts' | 'metadata'>;
+export type PortableActivityProfilesConfiguration = AgentActivityProfilesConfiguration;

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

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

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

@@ -0,0 +1,11 @@
+export * from './activity-profile.js';
+export * from './agent-definition-schema.js';
+export * from './agent-lab-forensics-schema.js';
+export * from './agent-signal.js';
+export * from './proposal-type.js';
+export * from './assignment-records.js';
+export * from './configuration.js';
+export * from './research/citation.js';
+export * from './research/source-policy.js';
+export * from './research/workflow.js';
+export * from './workflow-promotion.js';

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

@@ -0,0 +1,11 @@
+export * from "./activity-profile.js";
+export * from "./agent-definition-schema.js";
+export * from "./agent-lab-forensics-schema.js";
+export * from "./agent-signal.js";
+export * from "./proposal-type.js";
+export * from "./assignment-records.js";
+export * from "./configuration.js";
+export * from "./research/citation.js";
+export * from "./research/source-policy.js";
+export * from "./research/workflow.js";
+export * from "./workflow-promotion.js";

package/dist/agent-capacity/validation/proposal-type.d.ts

@@ -0,0 +1,22 @@
+export declare const PROPOSAL_TYPE_SCHEMA: "treeseed.proposal-type/v1";
+export declare const PROPOSAL_TYPE_ID_PATTERN: RegExp;
+export interface ProposalTypeContract {
+    schemaVersion: typeof PROPOSAL_TYPE_SCHEMA;
+    id: string;
+    label: string;
+    description: string;
+    defaultPriority?: 'low' | 'normal' | 'high' | 'urgent';
+    subscriberSignals?: string[];
+    requiredReviewerClasses?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ProposalTypeValidation {
+    ok: boolean;
+    diagnostics: Array<{
+        code: string;
+        path: string;
+        message: string;
+    }>;
+    value?: ProposalTypeContract;
+}
+export declare function validateProposalTypeContract(value: unknown): ProposalTypeValidation;

package/dist/agent-capacity/validation/proposal-type.js

@@ -0,0 +1,21 @@
+const PROPOSAL_TYPE_SCHEMA = "treeseed.proposal-type/v1";
+const PROPOSAL_TYPE_ID_PATTERN = /^[a-z][a-z0-9-]*$/u;
+function record(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validateProposalTypeContract(value) {
+  const diagnostics = [];
+  if (!record(value)) return { ok: false, diagnostics: [{ code: "proposal_type_invalid", path: "", message: "Proposal type contract must be an object." }] };
+  if (value.schemaVersion !== PROPOSAL_TYPE_SCHEMA) diagnostics.push({ code: "proposal_type_schema_invalid", path: "schemaVersion", message: `schemaVersion must be ${PROPOSAL_TYPE_SCHEMA}.` });
+  for (const key of ["id", "label", "description"]) if (typeof value[key] !== "string" || !String(value[key]).trim()) diagnostics.push({ code: "proposal_type_text_required", path: key, message: `${key} must be a non-empty string.` });
+  if (typeof value.id === "string" && !PROPOSAL_TYPE_ID_PATTERN.test(value.id)) diagnostics.push({ code: "proposal_type_id_invalid", path: "id", message: "id must use lowercase kebab-case." });
+  if (value.defaultPriority !== void 0 && !["low", "normal", "high", "urgent"].includes(String(value.defaultPriority))) diagnostics.push({ code: "proposal_type_priority_invalid", path: "defaultPriority", message: "defaultPriority must be low, normal, high, or urgent." });
+  for (const key of ["subscriberSignals", "requiredReviewerClasses"]) if (value[key] !== void 0 && (!Array.isArray(value[key]) || !value[key].length || value[key].some((entry) => typeof entry !== "string" || !entry.trim()))) diagnostics.push({ code: "proposal_type_list_invalid", path: key, message: `${key} must contain non-empty strings.` });
+  if (value.metadata !== void 0 && !record(value.metadata)) diagnostics.push({ code: "proposal_type_metadata_invalid", path: "metadata", message: "metadata must be an object." });
+  return diagnostics.length ? { ok: false, diagnostics } : { ok: true, diagnostics, value };
+}
+export {
+  PROPOSAL_TYPE_ID_PATTERN,
+  PROPOSAL_TYPE_SCHEMA,
+  validateProposalTypeContract
+};

package/dist/agent-capacity/validation/research/citation.d.ts

@@ -0,0 +1,16 @@
+import type { ResearchCitation } from '../../contracts/support/research-citation.js';
+export declare const RESEARCH_CITATION_MAX_EXCERPT_CHARACTERS = 2000;
+export interface ResearchCitationDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateResearchCitation(value: unknown, path?: string): {
+    ok: boolean;
+    diagnostics: ResearchCitationDiagnostic[];
+};
+export declare function validateResearchCitations(citations: unknown, path?: string): {
+    ok: boolean;
+    diagnostics: ResearchCitationDiagnostic[];
+};
+export declare function assertResearchCitations(citations: unknown, path?: string): ResearchCitation[];

package/dist/agent-capacity/validation/research/citation.js

@@ -0,0 +1,47 @@
+const RESEARCH_CITATION_MAX_EXCERPT_CHARACTERS = 2e3;
+function present(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function timestamp(value) {
+  return present(value) && Number.isFinite(Date.parse(value));
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function validateResearchCitation(value, path = "citation") {
+  const citation = record(value);
+  const diagnostics = [];
+  const add = (code, field, message) => diagnostics.push({ code, path: `${path}.${field}`, message });
+  try {
+    const url = new URL(String(citation.sourceUrl ?? ""));
+    if (url.protocol !== "https:" && url.protocol !== "http:") add("research_citation_url_protocol_invalid", "sourceUrl", "sourceUrl must use HTTP or HTTPS.");
+  } catch {
+    add("research_citation_url_invalid", "sourceUrl", "sourceUrl must be an absolute URL.");
+  }
+  if (!present(citation.title)) add("research_citation_title_required", "title", "title is required.");
+  if (!timestamp(citation.retrievedAt)) add("research_citation_retrieved_at_invalid", "retrievedAt", "retrievedAt must be an ISO timestamp.");
+  if (citation.publishedAt !== void 0 && !timestamp(citation.publishedAt)) add("research_citation_published_at_invalid", "publishedAt", "publishedAt must be an ISO timestamp when provided.");
+  if (!present(citation.contentHash)) add("research_citation_content_hash_required", "contentHash", "contentHash is required.");
+  if (!Array.isArray(citation.claimIds) || citation.claimIds.length === 0 || citation.claimIds.some((id) => !present(id))) add("research_citation_claim_ids_invalid", "claimIds", "claimIds must contain at least one non-empty claim identifier.");
+  if (!["low", "medium", "high"].includes(String(citation.confidence ?? ""))) add("research_citation_confidence_invalid", "confidence", "confidence must be low, medium, or high.");
+  if (citation.excerpt !== void 0 && (!present(citation.excerpt) || String(citation.excerpt).length > RESEARCH_CITATION_MAX_EXCERPT_CHARACTERS)) add("research_citation_excerpt_invalid", "excerpt", `excerpt must be a non-empty string of at most ${RESEARCH_CITATION_MAX_EXCERPT_CHARACTERS} characters.`);
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function validateResearchCitations(citations, path = "citations") {
+  const diagnostics = Array.isArray(citations) ? citations.flatMap((citation, index) => validateResearchCitation(citation, `${path}[${index}]`).diagnostics) : [{ code: "research_citations_array_required", path, message: "citations must be an array." }];
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function assertResearchCitations(citations, path = "citations") {
+  const result = validateResearchCitations(citations, path);
+  if (!result.ok) {
+    const details = result.diagnostics.map((diagnostic) => `${diagnostic.code} at ${diagnostic.path}`).join(", ");
+    throw new Error(`Invalid research citations: ${details}`);
+  }
+  return citations;
+}
+export {
+  RESEARCH_CITATION_MAX_EXCERPT_CHARACTERS,
+  assertResearchCitations,
+  validateResearchCitation,
+  validateResearchCitations
+};

package/dist/agent-capacity/validation/research/source-policy.d.ts

@@ -0,0 +1,11 @@
+import type { ResearchSourcePolicy } from '../../contracts/support/research-source-policy.js';
+export interface ResearchSourcePolicyDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateResearchSourcePolicy(value: unknown): {
+    ok: boolean;
+    diagnostics: ResearchSourcePolicyDiagnostic[];
+};
+export declare function assertResearchSourcePolicy(value: unknown): ResearchSourcePolicy;

package/dist/agent-capacity/validation/research/source-policy.js

@@ -0,0 +1,26 @@
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function validateResearchSourcePolicy(value) {
+  const policy = record(value);
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  if (policy.schemaVersion !== 1) add("research_source_policy_version_invalid", "schemaVersion", "schemaVersion must be 1.");
+  if (!Array.isArray(policy.allowedDomains) || policy.allowedDomains.length === 0 || policy.allowedDomains.some((domain) => typeof domain !== "string" || !domain.trim() || domain.includes("/") || domain.includes(":"))) {
+    add("research_source_policy_domains_invalid", "allowedDomains", "allowedDomains must contain hostnames without schemes, ports, or paths.");
+  }
+  if (!Number.isInteger(policy.requestTimeoutMs) || Number(policy.requestTimeoutMs) < 100 || Number(policy.requestTimeoutMs) > 6e4) add("research_source_policy_timeout_invalid", "requestTimeoutMs", "requestTimeoutMs must be an integer from 100 through 60000.");
+  if (!Number.isInteger(policy.maxResponseBytes) || Number(policy.maxResponseBytes) < 1024 || Number(policy.maxResponseBytes) > 1e6) add("research_source_policy_size_invalid", "maxResponseBytes", "maxResponseBytes must be an integer from 1024 through 1000000.");
+  if (!Number.isInteger(policy.maxRedirects) || Number(policy.maxRedirects) < 0 || Number(policy.maxRedirects) > 10) add("research_source_policy_redirects_invalid", "maxRedirects", "maxRedirects must be an integer from zero through ten.");
+  if (!Array.isArray(policy.allowedContentTypes) || policy.allowedContentTypes.length === 0 || policy.allowedContentTypes.some((type) => typeof type !== "string" || !type.trim())) add("research_source_policy_content_types_invalid", "allowedContentTypes", "allowedContentTypes must be a non-empty string array.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function assertResearchSourcePolicy(value) {
+  const result = validateResearchSourcePolicy(value);
+  if (!result.ok) throw new Error(`Invalid research source policy: ${result.diagnostics.map((item) => `${item.code} at ${item.path}`).join(", ")}`);
+  return value;
+}
+export {
+  assertResearchSourcePolicy,
+  validateResearchSourcePolicy
+};

package/dist/agent-capacity/validation/research/workflow.d.ts

@@ -0,0 +1,10 @@
+import { type ResearchWorkflowRecord } from '../../contracts/operations/research-workflow.js';
+export interface ResearchWorkflowDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateResearchWorkflow(value: ResearchWorkflowRecord): {
+    ok: boolean;
+    diagnostics: ResearchWorkflowDiagnostic[];
+};

package/dist/agent-capacity/validation/research/workflow.js

@@ -0,0 +1,31 @@
+import { RESEARCH_WORKFLOW_STAGES } from "../../contracts/operations/research-workflow.js";
+import { validateResearchCitations } from "./citation.js";
+function validateResearchWorkflow(value) {
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  if (value.schemaVersion !== 1) add("research_workflow_schema_invalid", "schemaVersion", "schemaVersion must be 1.");
+  for (const key of ["id", "teamId", "projectId", "objectiveRef", "questionRef"]) if (!value[key]?.trim()) add("research_workflow_field_required", key, `${key} is required.`);
+  if (!Number.isInteger(value.stateVersion) || value.stateVersion < 1) add("research_workflow_state_version_invalid", "stateVersion", "stateVersion must be a positive integer.");
+  if (!Number.isInteger(value.minimumIndependentSources) || value.minimumIndependentSources < 2) add("research_workflow_source_minimum_invalid", "minimumIndependentSources", "At least two independent sources are required.");
+  if (!Number.isInteger(value.maxRevisionCycles) || value.maxRevisionCycles < 1 || value.maxRevisionCycles > 10) add("research_workflow_revision_limit_invalid", "maxRevisionCycles", "maxRevisionCycles must be an integer from 1 through 10.");
+  if (value.nodes.length !== RESEARCH_WORKFLOW_STAGES.length || value.nodes.some((node, index) => node.stage !== RESEARCH_WORKFLOW_STAGES[index])) add("research_workflow_stage_order_invalid", "nodes", "The canonical eleven research stages must occur exactly once in order.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, node] of value.nodes.entries()) {
+    if (!node.id || ids.has(node.id)) add("research_workflow_node_id_invalid", `nodes[${index}].id`, "Node ids must be non-empty and unique.");
+    ids.add(node.id);
+    if (index === 0 ? node.dependsOn.length !== 0 : node.dependsOn.length !== 1 || node.dependsOn[0] !== value.nodes[index - 1]?.id) add("research_workflow_dependency_invalid", `nodes[${index}].dependsOn`, "Each stage must depend only on its immediate predecessor.");
+  }
+  for (const diagnostic of validateResearchCitations(value.citations).diagnostics) add(diagnostic.code, `citations.${diagnostic.path}`, diagnostic.message);
+  const claimIds = /* @__PURE__ */ new Set();
+  for (const [index, claim] of value.claims.entries()) {
+    if (!claim.id || claimIds.has(claim.id)) add("research_claim_id_invalid", `claims[${index}].id`, "Claim ids must be non-empty and unique.");
+    claimIds.add(claim.id);
+    if (!claim.text?.trim()) add("research_claim_text_required", `claims[${index}].text`, "Claim text is required.");
+    if (claim.status !== "unsupported" && claim.citationIds.length === 0) add("research_claim_citation_required", `claims[${index}].citationIds`, "Supported and contradicted claims require citations.");
+  }
+  if (value.status === "completed" && (!value.reviewerApprovedRevision || !value.publicationRef || !value.reportRef || value.claims.some((claim) => claim.material && claim.status === "unsupported"))) add("research_workflow_completion_invalid", "status", "Completed research requires independent Reviewer approval, publication, report, and no unsupported material claim.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+export {
+  validateResearchWorkflow
+};

package/dist/agent-capacity/validation/workflow-promotion.d.ts

@@ -0,0 +1,2 @@
+import type { EngineeringWorkflowPromotionValidation } from '../contracts/operations/workflow-promotion.js';
+export declare function validateEngineeringWorkflowPromotionConfig(value: unknown): EngineeringWorkflowPromotionValidation;

package/dist/agent-capacity/validation/workflow-promotion.js

@@ -0,0 +1,34 @@
+const REQUIRED_ROLES = ["tester", "engineer", "reviewer", "technicalWriter", "releaser"];
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function validateEngineeringWorkflowPromotionConfig(value) {
+  const diagnostics = [];
+  const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  if (input.schemaVersion !== 1) diagnostics.push({ code: "schema_version_invalid", path: "schemaVersion", message: "schemaVersion must be 1." });
+  for (const field of ["id", "projectId", "decisionId", "objectiveId", "exactBaseRef"]) {
+    if (!text(input[field])) diagnostics.push({ code: "field_required", path: field, message: `${field} is required.` });
+  }
+  if (text(input.exactBaseRef) && !/^[0-9a-f]{7,64}$/iu.test(input.exactBaseRef)) {
+    diagnostics.push({ code: "exact_base_ref_invalid", path: "exactBaseRef", message: "exactBaseRef must be an immutable hexadecimal commit id." });
+  }
+  const roles = input.roles && typeof input.roles === "object" ? input.roles : {};
+  for (const role of REQUIRED_ROLES) {
+    if (!text(roles[role])) diagnostics.push({ code: "role_required", path: `roles.${role}`, message: `${role} role is required.` });
+  }
+  for (const optional of ["operations", "researcher", "architect"]) {
+    if (roles[optional] != null && !text(roles[optional])) diagnostics.push({ code: "role_invalid", path: `roles.${optional}`, message: `${optional} must be a non-empty string when supplied.` });
+  }
+  if (input.includeResearch === true && !text(roles.researcher)) diagnostics.push({ code: "researcher_role_required", path: "roles.researcher", message: "includeResearch requires a researcher role." });
+  if (input.includeArchitecture === true && !text(roles.architect)) diagnostics.push({ code: "architect_role_required", path: "roles.architect", message: "includeArchitecture requires an architect role." });
+  if (input.requireRevisionCycle != null && typeof input.requireRevisionCycle !== "boolean") {
+    diagnostics.push({ code: "revision_cycle_invalid", path: "requireRevisionCycle", message: "requireRevisionCycle must be boolean when supplied." });
+  }
+  for (const [stage, amount] of Object.entries(input.seconds ?? {})) {
+    if (!Number.isFinite(amount) || Number(amount) <= 0) diagnostics.push({ code: "time_invalid", path: `seconds.${stage}`, message: "Stage agent time must be positive finite seconds." });
+  }
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+export {
+  validateEngineeringWorkflowPromotionConfig
+};

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

@@ -0,0 +1,52 @@
+export interface WorkdayPlanningAgent {
+    slug: string;
+    activityType?: string | null;
+    planningAllocationPercent?: number | null;
+    projectAgentClassSlug?: string | null;
+    projectAgentClassId?: string | null;
+}
+export interface WorkdayAgentSelection {
+    classIds: string[];
+    classSlugs: string[];
+    agentSlugs: string[];
+    activityTypes: string[];
+    mode: 'intersection' | 'union';
+}
+export declare function normalizeWorkdayAgentSelection(value: unknown): WorkdayAgentSelection;
+export declare function workdayAgentSelectionActive(selection: WorkdayAgentSelection): boolean;
+export declare function selectWorkdayAgents<T extends WorkdayPlanningAgent>(agents: T[], value: unknown): T[];
+export interface WorkdayExistingAssignment {
+    projectId?: string | null;
+    project_id?: string | null;
+    agentId?: string | null;
+    agent_id?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function selectFairPlanningAgentCycles<T extends WorkdayPlanningAgent>(projectId: string, agents: T[], existingAssignments: WorkdayExistingAssignment[], limit: number): {
+    agent: T;
+    cycle: number;
+}[];
+export declare function evaluateWorkdayContinuation(input: {
+    status: string;
+    now: string;
+    deadlineAt?: string | null;
+    totalSeconds: number;
+    committedSeconds: number;
+    usefulEligibleWork: boolean;
+}): {
+    continue: boolean;
+    reason: "workday_not_active";
+} | {
+    continue: boolean;
+    reason: "duration_bound_reached";
+} | {
+    continue: boolean;
+    reason: "budget_bound_reached";
+} | {
+    continue: boolean;
+    reason: "no_useful_eligible_work";
+} | {
+    continue: boolean;
+    reason: "within_duration_and_budget";
+};