@vorionsys/shared-constants 1.0.0

package/dist/api-versions.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api-versions.ts
+var api_versions_exports = {};
+__export(api_versions_exports, {
+  API_VERSIONS: () => API_VERSIONS,
+  BASIS_CURRENT_VERSION: () => BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION: () => BASIS_SPEC_VERSION,
+  BASIS_VERSIONS: () => BASIS_VERSIONS,
+  CAR_SPEC_CURRENT_VERSION: () => CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS: () => CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION: () => COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION: () => COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_VERSIONS: () => COGNIGATE_VERSIONS,
+  LOGIC_API_VERSIONS: () => LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION: () => LOGIC_CURRENT_VERSION,
+  TRUST_API_VERSIONS: () => TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION: () => TRUST_CURRENT_VERSION,
+  VERSION_HEADERS: () => VERSION_HEADERS,
+  VersionStatus: () => VersionStatus,
+  buildApiUrl: () => buildApiUrl,
+  getCurrentVersion: () => getCurrentVersion,
+  getStableVersions: () => getStableVersions,
+  getVersionDefinition: () => getVersionDefinition,
+  isVersionDeprecated: () => isVersionDeprecated,
+  isVersionSupported: () => isVersionSupported
+});
+module.exports = __toCommonJS(api_versions_exports);
+var VersionStatus = /* @__PURE__ */ ((VersionStatus2) => {
+  VersionStatus2["DEVELOPMENT"] = "development";
+  VersionStatus2["PREVIEW"] = "preview";
+  VersionStatus2["STABLE"] = "stable";
+  VersionStatus2["DEPRECATED"] = "deprecated";
+  VersionStatus2["RETIRED"] = "retired";
+  return VersionStatus2;
+})(VersionStatus || {});
+var COGNIGATE_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://cognigate.dev/changelog/v1"
+  }
+};
+var COGNIGATE_CURRENT_VERSION = "v1";
+var COGNIGATE_DEFAULT_VERSION = "v1";
+var TRUST_API_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://trust.agentanchorai.com/changelog/v1"
+  }
+};
+var TRUST_CURRENT_VERSION = "v1";
+var LOGIC_API_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "preview" /* PREVIEW */,
+    changelogUrl: "https://logic.agentanchorai.com/changelog/v1"
+  }
+};
+var LOGIC_CURRENT_VERSION = "v1";
+var BASIS_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://basis.vorion.org/changelog"
+  }
+};
+var BASIS_CURRENT_VERSION = "v1";
+var BASIS_SPEC_VERSION = "1.0.0";
+var CAR_SPEC_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://carid.vorion.org/changelog"
+  }
+};
+var CAR_SPEC_CURRENT_VERSION = "v1";
+var API_VERSIONS = {
+  cognigate: COGNIGATE_VERSIONS,
+  trust: TRUST_API_VERSIONS,
+  logic: LOGIC_API_VERSIONS,
+  basis: BASIS_VERSIONS,
+  carSpec: CAR_SPEC_VERSIONS
+};
+function getCurrentVersion(service) {
+  switch (service) {
+    case "cognigate":
+      return COGNIGATE_CURRENT_VERSION;
+    case "trust":
+      return TRUST_CURRENT_VERSION;
+    case "logic":
+      return LOGIC_CURRENT_VERSION;
+    case "basis":
+      return BASIS_CURRENT_VERSION;
+    case "carSpec":
+      return CAR_SPEC_CURRENT_VERSION;
+  }
+}
+function getVersionDefinition(service, version) {
+  return API_VERSIONS[service][version];
+}
+function isVersionSupported(service, version) {
+  const def = getVersionDefinition(service, version);
+  if (!def) return false;
+  return def.status !== "retired" /* RETIRED */;
+}
+function isVersionDeprecated(service, version) {
+  const def = getVersionDefinition(service, version);
+  if (!def) return false;
+  return def.status === "deprecated" /* DEPRECATED */;
+}
+function getStableVersions(service) {
+  return Object.values(API_VERSIONS[service]).filter(
+    (v) => v.status === "stable" /* STABLE */
+  );
+}
+function buildApiUrl(baseUrl, version, path) {
+  const cleanBase = baseUrl.replace(/\/$/, "");
+  const cleanPath = path.replace(/^\//, "");
+  return `${cleanBase}/${version}/${cleanPath}`;
+}
+var VERSION_HEADERS = {
+  /** Header to request specific API version */
+  REQUEST_VERSION: "X-API-Version",
+  /** Header indicating actual API version used */
+  RESPONSE_VERSION: "X-API-Version",
+  /** Header warning about deprecation */
+  DEPRECATION_WARNING: "X-Deprecation-Warning",
+  /** Header with sunset date */
+  SUNSET: "Sunset"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_VERSIONS,
+  BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION,
+  BASIS_VERSIONS,
+  CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_VERSIONS,
+  LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION,
+  TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION,
+  VERSION_HEADERS,
+  VersionStatus,
+  buildApiUrl,
+  getCurrentVersion,
+  getStableVersions,
+  getVersionDefinition,
+  isVersionDeprecated,
+  isVersionSupported
+});

package/dist/api-versions.d.cts

@@ -0,0 +1,91 @@
+/**
+ * @vorionsys/shared-constants - API Versions
+ *
+ * Centralized API version management across all services
+ * Ensures consistent versioning strategy
+ *
+ * @see https://cognigate.dev/docs/versioning
+ */
+declare enum VersionStatus {
+    /** Currently in development, not available */
+    DEVELOPMENT = "development",
+    /** Available as preview/beta */
+    PREVIEW = "preview",
+    /** Stable and recommended */
+    STABLE = "stable",
+    /** Still supported but deprecated */
+    DEPRECATED = "deprecated",
+    /** No longer supported */
+    RETIRED = "retired"
+}
+interface ApiVersionDefinition {
+    /** Version identifier (e.g., "v1") */
+    version: string;
+    /** Full version number (e.g., "1.0.0") */
+    fullVersion: string;
+    /** Release date */
+    releaseDate: string;
+    /** End of support date (if deprecated/retired) */
+    endOfLife?: string;
+    /** Current status */
+    status: VersionStatus;
+    /** Changelog URL */
+    changelogUrl?: string;
+    /** Migration guide URL (if deprecated) */
+    migrationUrl?: string;
+}
+declare const COGNIGATE_VERSIONS: Record<string, ApiVersionDefinition>;
+declare const COGNIGATE_CURRENT_VERSION = "v1";
+declare const COGNIGATE_DEFAULT_VERSION = "v1";
+declare const TRUST_API_VERSIONS: Record<string, ApiVersionDefinition>;
+declare const TRUST_CURRENT_VERSION = "v1";
+declare const LOGIC_API_VERSIONS: Record<string, ApiVersionDefinition>;
+declare const LOGIC_CURRENT_VERSION = "v1";
+declare const BASIS_VERSIONS: Record<string, ApiVersionDefinition>;
+declare const BASIS_CURRENT_VERSION = "v1";
+declare const BASIS_SPEC_VERSION = "1.0.0";
+declare const CAR_SPEC_VERSIONS: Record<string, ApiVersionDefinition>;
+declare const CAR_SPEC_CURRENT_VERSION = "v1";
+declare const API_VERSIONS: {
+    readonly cognigate: Record<string, ApiVersionDefinition>;
+    readonly trust: Record<string, ApiVersionDefinition>;
+    readonly logic: Record<string, ApiVersionDefinition>;
+    readonly basis: Record<string, ApiVersionDefinition>;
+    readonly carSpec: Record<string, ApiVersionDefinition>;
+};
+/**
+ * Get the current stable version for a service
+ */
+declare function getCurrentVersion(service: 'cognigate' | 'trust' | 'logic' | 'basis' | 'carSpec'): string;
+/**
+ * Get version definition
+ */
+declare function getVersionDefinition(service: 'cognigate' | 'trust' | 'logic' | 'basis' | 'carSpec', version: string): ApiVersionDefinition | undefined;
+/**
+ * Check if a version is still supported
+ */
+declare function isVersionSupported(service: 'cognigate' | 'trust' | 'logic' | 'basis' | 'carSpec', version: string): boolean;
+/**
+ * Check if a version is deprecated
+ */
+declare function isVersionDeprecated(service: 'cognigate' | 'trust' | 'logic' | 'basis' | 'carSpec', version: string): boolean;
+/**
+ * Get all stable versions for a service
+ */
+declare function getStableVersions(service: 'cognigate' | 'trust' | 'logic' | 'basis' | 'carSpec'): ApiVersionDefinition[];
+/**
+ * Build versioned API URL
+ */
+declare function buildApiUrl(baseUrl: string, version: string, path: string): string;
+declare const VERSION_HEADERS: {
+    /** Header to request specific API version */
+    readonly REQUEST_VERSION: "X-API-Version";
+    /** Header indicating actual API version used */
+    readonly RESPONSE_VERSION: "X-API-Version";
+    /** Header warning about deprecation */
+    readonly DEPRECATION_WARNING: "X-Deprecation-Warning";
+    /** Header with sunset date */
+    readonly SUNSET: "Sunset";
+};
+
+export { API_VERSIONS, type ApiVersionDefinition, BASIS_CURRENT_VERSION, BASIS_SPEC_VERSION, BASIS_VERSIONS, CAR_SPEC_CURRENT_VERSION, CAR_SPEC_VERSIONS, COGNIGATE_CURRENT_VERSION, COGNIGATE_DEFAULT_VERSION, COGNIGATE_VERSIONS, LOGIC_API_VERSIONS, LOGIC_CURRENT_VERSION, TRUST_API_VERSIONS, TRUST_CURRENT_VERSION, VERSION_HEADERS, VersionStatus, buildApiUrl, getCurrentVersion, getStableVersions, getVersionDefinition, isVersionDeprecated, isVersionSupported };

package/dist/api-versions.js

@@ -0,0 +1,46 @@
+import {
+  API_VERSIONS,
+  BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION,
+  BASIS_VERSIONS,
+  CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_VERSIONS,
+  LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION,
+  TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION,
+  VERSION_HEADERS,
+  VersionStatus,
+  buildApiUrl,
+  getCurrentVersion,
+  getStableVersions,
+  getVersionDefinition,
+  isVersionDeprecated,
+  isVersionSupported
+} from "./chunk-UDCZKJSQ.js";
+export {
+  API_VERSIONS,
+  BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION,
+  BASIS_VERSIONS,
+  CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_VERSIONS,
+  LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION,
+  TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION,
+  VERSION_HEADERS,
+  VersionStatus,
+  buildApiUrl,
+  getCurrentVersion,
+  getStableVersions,
+  getVersionDefinition,
+  isVersionDeprecated,
+  isVersionSupported
+};

package/dist/capabilities.cjs

@@ -0,0 +1,246 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/capabilities.ts
+var capabilities_exports = {};
+__export(capabilities_exports, {
+  CAPABILITIES: () => CAPABILITIES,
+  CapabilityCategory: () => CapabilityCategory,
+  getAllCapabilityCodes: () => getAllCapabilityCodes,
+  getCapabilitiesByCategory: () => getCapabilitiesByCategory,
+  getCapabilitiesForTier: () => getCapabilitiesForTier,
+  getCapability: () => getCapability,
+  getCapabilityMinTier: () => getCapabilityMinTier,
+  isCapabilityAvailable: () => isCapabilityAvailable
+});
+module.exports = __toCommonJS(capabilities_exports);
+var CapabilityCategory = /* @__PURE__ */ ((CapabilityCategory2) => {
+  CapabilityCategory2["DATA_ACCESS"] = "data_access";
+  CapabilityCategory2["API_ACCESS"] = "api_access";
+  CapabilityCategory2["CODE_EXECUTION"] = "code_execution";
+  CapabilityCategory2["AGENT_INTERACTION"] = "agent_interaction";
+  CapabilityCategory2["RESOURCE_MANAGEMENT"] = "resource_management";
+  CapabilityCategory2["GOVERNANCE"] = "governance";
+  CapabilityCategory2["ADMIN"] = "admin";
+  return CapabilityCategory2;
+})(CapabilityCategory || {});
+var CAPABILITIES = [
+  // T0 - Sandbox
+  {
+    code: "CAP-READ-PUBLIC",
+    name: "Read Public Data",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Access publicly available data",
+    unlockTier: 0 /* T0_SANDBOX */
+  },
+  {
+    code: "CAP-GENERATE-TEXT",
+    name: "Generate Text",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Generate text responses",
+    unlockTier: 0 /* T0_SANDBOX */
+  },
+  // T1 - Observed
+  {
+    code: "CAP-READ-INTERNAL",
+    name: "Read Internal Data",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Access internal data within allowed scopes",
+    unlockTier: 1 /* T1_OBSERVED */,
+    constraints: ["Read-only", "Logged"]
+  },
+  {
+    code: "CAP-INTERNAL-API",
+    name: "Internal API Access",
+    category: "api_access" /* API_ACCESS */,
+    description: "Make read-only internal API calls",
+    unlockTier: 1 /* T1_OBSERVED */,
+    constraints: ["GET only", "Rate limited"]
+  },
+  // T2 - Provisional
+  {
+    code: "CAP-FILE-WRITE",
+    name: "Write Files",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Write to approved directories",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["Approved dirs only", "Size limited"]
+  },
+  {
+    code: "CAP-DB-READ",
+    name: "Database Read",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Read from approved database tables",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["Approved tables", "Query timeout"]
+  },
+  {
+    code: "CAP-EXTERNAL-API-READ",
+    name: "External API Read",
+    category: "api_access" /* API_ACCESS */,
+    description: "Make GET requests to approved external APIs",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["GET only", "Approved endpoints"]
+  },
+  // T3 - Monitored
+  {
+    code: "CAP-DB-WRITE",
+    name: "Database Write",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Write to approved database tables",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Approved tables", "Transaction limits"]
+  },
+  {
+    code: "CAP-EXTERNAL-API-FULL",
+    name: "External API Full Access",
+    category: "api_access" /* API_ACCESS */,
+    description: "Full REST operations on approved external APIs",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Approved endpoints", "Rate limited"]
+  },
+  {
+    code: "CAP-CODE-SANDBOX",
+    name: "Sandboxed Code Execution",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Execute code in isolated sandbox",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Sandboxed", "Time limited", "No network"]
+  },
+  // T4 - Standard
+  {
+    code: "CAP-AGENT-COMMUNICATE",
+    name: "Agent Communication",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Send and receive messages to/from other agents",
+    unlockTier: 4 /* T4_STANDARD */,
+    constraints: ["Approved agents", "Message limits"]
+  },
+  {
+    code: "CAP-WORKFLOW-MULTI",
+    name: "Multi-Step Workflow",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Orchestrate multi-step workflows",
+    unlockTier: 4 /* T4_STANDARD */,
+    constraints: ["Approved patterns", "Checkpoints required"]
+  },
+  {
+    code: "CAP-ESCALATE-HUMAN",
+    name: "Human Escalation",
+    category: "governance" /* GOVERNANCE */,
+    description: "Initiate escalation to human reviewers",
+    unlockTier: 4 /* T4_STANDARD */
+  },
+  // T5 - Trusted
+  {
+    code: "CAP-AGENT-DELEGATE",
+    name: "Task Delegation",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Delegate tasks to other agents",
+    unlockTier: 5 /* T5_TRUSTED */,
+    constraints: ["Trust verified agents"]
+  },
+  {
+    code: "CAP-RESOURCE-PROVISION",
+    name: "Resource Provisioning",
+    category: "resource_management" /* RESOURCE_MANAGEMENT */,
+    description: "Provision computational resources",
+    unlockTier: 5 /* T5_TRUSTED */,
+    constraints: ["Budget limits", "Approval required"]
+  },
+  // T6 - Certified
+  {
+    code: "CAP-AGENT-SPAWN",
+    name: "Spawn Agents",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Create new agent instances",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Template required", "Quota limited"]
+  },
+  {
+    code: "CAP-INFRA-MANAGE",
+    name: "Infrastructure Management",
+    category: "resource_management" /* RESOURCE_MANAGEMENT */,
+    description: "Manage infrastructure resources",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Approved resources"]
+  },
+  {
+    code: "CAP-POLICY-CREATE",
+    name: "Policy Creation",
+    category: "governance" /* GOVERNANCE */,
+    description: "Create governance policies",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Review required"]
+  },
+  // T7 - Autonomous
+  {
+    code: "CAP-FULL-ADMIN",
+    name: "Full Administration",
+    category: "admin" /* ADMIN */,
+    description: "Full administrative access",
+    unlockTier: 7 /* T7_AUTONOMOUS */
+  },
+  {
+    code: "CAP-SELF-MODIFY",
+    name: "Self-Modification",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Modify own configuration and behavior",
+    unlockTier: 7 /* T7_AUTONOMOUS */,
+    constraints: ["Ethical bounds", "Audit logged"]
+  },
+  {
+    code: "CAP-STRATEGIC-DECISION",
+    name: "Strategic Decisions",
+    category: "governance" /* GOVERNANCE */,
+    description: "Make strategic organizational decisions",
+    unlockTier: 7 /* T7_AUTONOMOUS */,
+    constraints: ["Human oversight available"]
+  }
+];
+function getCapabilitiesForTier(tier) {
+  return CAPABILITIES.filter((cap) => cap.unlockTier <= tier);
+}
+function getCapability(code) {
+  return CAPABILITIES.find((cap) => cap.code === code);
+}
+function isCapabilityAvailable(code, tier) {
+  const cap = getCapability(code);
+  return cap !== void 0 && cap.unlockTier <= tier;
+}
+function getCapabilityMinTier(code) {
+  return getCapability(code)?.unlockTier;
+}
+function getCapabilitiesByCategory(category) {
+  return CAPABILITIES.filter((cap) => cap.category === category);
+}
+function getAllCapabilityCodes() {
+  return CAPABILITIES.map((cap) => cap.code);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CAPABILITIES,
+  CapabilityCategory,
+  getAllCapabilityCodes,
+  getCapabilitiesByCategory,
+  getCapabilitiesForTier,
+  getCapability,
+  getCapabilityMinTier,
+  isCapabilityAvailable
+});

package/dist/capabilities.d.cts

@@ -0,0 +1,55 @@
+import { TrustTier } from './tiers.cjs';
+
+/**
+ * @vorionsys/shared-constants - Capability Definitions
+ *
+ * Single source of truth for capability codes and tier requirements
+ * Used across all Vorion ecosystem products
+ *
+ * @see https://basis.vorion.org/capabilities
+ */
+
+declare enum CapabilityCategory {
+    DATA_ACCESS = "data_access",
+    API_ACCESS = "api_access",
+    CODE_EXECUTION = "code_execution",
+    AGENT_INTERACTION = "agent_interaction",
+    RESOURCE_MANAGEMENT = "resource_management",
+    GOVERNANCE = "governance",
+    ADMIN = "admin"
+}
+interface CapabilityDefinition {
+    readonly code: string;
+    readonly name: string;
+    readonly category: CapabilityCategory;
+    readonly description: string;
+    readonly unlockTier: TrustTier;
+    readonly constraints?: readonly string[];
+}
+declare const CAPABILITIES: readonly CapabilityDefinition[];
+/**
+ * Get capabilities available at a specific tier
+ */
+declare function getCapabilitiesForTier(tier: TrustTier): CapabilityDefinition[];
+/**
+ * Get capability by code
+ */
+declare function getCapability(code: string): CapabilityDefinition | undefined;
+/**
+ * Check if a capability is available at a tier
+ */
+declare function isCapabilityAvailable(code: string, tier: TrustTier): boolean;
+/**
+ * Get minimum tier required for a capability
+ */
+declare function getCapabilityMinTier(code: string): TrustTier | undefined;
+/**
+ * Get capabilities by category
+ */
+declare function getCapabilitiesByCategory(category: CapabilityCategory): CapabilityDefinition[];
+/**
+ * Get all capability codes
+ */
+declare function getAllCapabilityCodes(): string[];
+
+export { CAPABILITIES, CapabilityCategory, type CapabilityDefinition, getAllCapabilityCodes, getCapabilitiesByCategory, getCapabilitiesForTier, getCapability, getCapabilityMinTier, isCapabilityAvailable };

package/dist/capabilities.js

@@ -0,0 +1,21 @@
+import {
+  CAPABILITIES,
+  CapabilityCategory,
+  getAllCapabilityCodes,
+  getCapabilitiesByCategory,
+  getCapabilitiesForTier,
+  getCapability,
+  getCapabilityMinTier,
+  isCapabilityAvailable
+} from "./chunk-JZJPDGG7.js";
+import "./chunk-PHL3CB53.js";
+export {
+  CAPABILITIES,
+  CapabilityCategory,
+  getAllCapabilityCodes,
+  getCapabilitiesByCategory,
+  getCapabilitiesForTier,
+  getCapability,
+  getCapabilityMinTier,
+  isCapabilityAvailable
+};