@vorionsys/shared-constants 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,129 @@
+# @vorionsys/shared-constants
+
+Single source of truth for the Vorion ecosystem - trust tiers, domains, capabilities, rate limits, error codes, and more.
+
+## Installation
+
+```bash
+npm install @vorionsys/shared-constants
+```
+
+## Quick Start
+
+```typescript
+import {
+  TrustTier,
+  TIER_THRESHOLDS,
+  scoreToTier,
+  API_ENDPOINTS,
+  CAPABILITIES,
+} from '@vorionsys/shared-constants';
+
+// Convert score to tier
+const tier = scoreToTier(750); // TrustTier.T4_STANDARD
+
+// Get tier info
+const info = TIER_THRESHOLDS[TrustTier.T4_STANDARD];
+console.log(info.name);        // "Standard"
+console.log(info.min, info.max); // 650, 799
+
+// Check capabilities
+const caps = getCapabilitiesForTier(TrustTier.T4_STANDARD);
+```
+
+## Features
+
+- **Trust Tiers (T0-T7)**: Complete 8-tier trust model with thresholds, names, colors, and helper functions
+- **Domains & URLs**: All Vorion, AgentAnchor, and Cognigate domains and API endpoints
+- **Capabilities**: Tier-gated capability definitions with category filtering
+- **Products**: Product catalog with status and category metadata
+- **Rate Limits**: Per-tier rate limiting and quota configurations
+- **Error Codes**: Standardized error codes with categories and retry information
+- **API Versions**: Version management for Cognigate, Trust, Logic, BASIS, and CAR APIs
+- **Themes**: UI theme tokens with CSS variable generation
+
+## Trust Tiers
+
+The BASIS 8-tier trust model (score range 0-1000):
+
+| Tier | Score | Name | Description |
+|------|-------|------|-------------|
+| T0 | 0-199 | Sandbox | Isolated, no external access |
+| T1 | 200-349 | Observed | Read-only, monitored |
+| T2 | 350-499 | Provisional | Basic operations, heavy supervision |
+| T3 | 500-649 | Monitored | Standard operations with monitoring |
+| T4 | 650-799 | Standard | External API access, policy-governed |
+| T5 | 800-875 | Trusted | Cross-agent communication |
+| T6 | 876-950 | Certified | Admin tasks, minimal oversight |
+| T7 | 951-1000 | Autonomous | Full autonomy, self-governance |
+
+## Subpath Imports
+
+```typescript
+// Import only what you need
+import { TrustTier, scoreToTier } from '@vorionsys/shared-constants/tiers';
+import { VORION_DOMAINS, API_ENDPOINTS } from '@vorionsys/shared-constants/domains';
+import { CAPABILITIES, getCapabilitiesForTier } from '@vorionsys/shared-constants/capabilities';
+import { VORION_PRODUCTS } from '@vorionsys/shared-constants/products';
+import { RATE_LIMITS, getRateLimits } from '@vorionsys/shared-constants/rate-limits';
+import { ERROR_CODES, getErrorByCode } from '@vorionsys/shared-constants/error-codes';
+import { API_VERSIONS, getCurrentVersion } from '@vorionsys/shared-constants/api-versions';
+```
+
+## API Reference
+
+### Tiers
+
+```typescript
+scoreToTier(750)                          // TrustTier.T4_STANDARD
+getTierName(TrustTier.T5_TRUSTED)         // "Trusted"
+getTierColor(TrustTier.T3_MONITORED)      // "#eab308"
+getTierMinScore(TrustTier.T4_STANDARD)    // 650
+meetsTierRequirement(750, TrustTier.T3_MONITORED) // true
+parseTier('T3')                           // TrustTier.T3_MONITORED
+parseTier('TRUSTED')                      // TrustTier.T5_TRUSTED
+```
+
+### Rate Limits
+
+```typescript
+const limits = getRateLimits(TrustTier.T4_STANDARD);
+// { requestsPerMinute: ..., requestsPerHour: ..., ... }
+
+wouldExceedLimit(currentCount, TrustTier.T4_STANDARD, 'requestsPerMinute');
+formatRateLimit(limits); // Human-readable string
+```
+
+### Error Codes
+
+```typescript
+const error = getErrorByCode('AUTH_001');
+// { code, message, category, httpStatus, retryable }
+
+const retryable = getRetryableErrors();
+const response = createErrorResponse('AUTH_001', { detail: 'Token expired' });
+```
+
+## TypeScript
+
+All types are fully exported:
+
+```typescript
+import type {
+  TrustTier,
+  TierThreshold,
+  TrustTierName,
+  TrustTierCode,
+  CapabilityDefinition,
+  ProductDefinition,
+  RateLimitConfig,
+  ErrorDefinition,
+  ErrorCode,
+  ApiVersionDefinition,
+  ThemeTokens,
+} from '@vorionsys/shared-constants';
+```
+
+## License
+
+MIT

package/dist/capabilities.js

@@ -8,7 +8,7 @@ import {
   getCapabilityMinTier,
   isCapabilityAvailable
 } from "./chunk-JZJPDGG7.js";
-import "./chunk-PHL3CB53.js";
+import "./chunk-X5XDDJ3Z.js";
 export {
   CAPABILITIES,
   CapabilityCategory,

package/dist/chunk-X5XDDJ3Z.js

@@ -0,0 +1,159 @@
+// src/tiers.ts
+var TrustTier = /* @__PURE__ */ ((TrustTier2) => {
+  TrustTier2[TrustTier2["T0_SANDBOX"] = 0] = "T0_SANDBOX";
+  TrustTier2[TrustTier2["T1_OBSERVED"] = 1] = "T1_OBSERVED";
+  TrustTier2[TrustTier2["T2_PROVISIONAL"] = 2] = "T2_PROVISIONAL";
+  TrustTier2[TrustTier2["T3_MONITORED"] = 3] = "T3_MONITORED";
+  TrustTier2[TrustTier2["T4_STANDARD"] = 4] = "T4_STANDARD";
+  TrustTier2[TrustTier2["T5_TRUSTED"] = 5] = "T5_TRUSTED";
+  TrustTier2[TrustTier2["T6_CERTIFIED"] = 6] = "T6_CERTIFIED";
+  TrustTier2[TrustTier2["T7_AUTONOMOUS"] = 7] = "T7_AUTONOMOUS";
+  return TrustTier2;
+})(TrustTier || {});
+var TIER_THRESHOLDS = {
+  [0 /* T0_SANDBOX */]: {
+    min: 0,
+    max: 199,
+    name: "Sandbox",
+    description: "Isolated, no external access, observation only",
+    color: "#78716c",
+    textColor: "#ffffff"
+  },
+  [1 /* T1_OBSERVED */]: {
+    min: 200,
+    max: 349,
+    name: "Observed",
+    description: "Read-only, sandboxed execution, monitored",
+    color: "#ef4444",
+    textColor: "#ffffff"
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    min: 350,
+    max: 499,
+    name: "Provisional",
+    description: "Basic operations, heavy supervision",
+    color: "#f97316",
+    textColor: "#ffffff"
+  },
+  [3 /* T3_MONITORED */]: {
+    min: 500,
+    max: 649,
+    name: "Monitored",
+    description: "Standard operations with continuous monitoring",
+    color: "#eab308",
+    textColor: "#000000"
+  },
+  [4 /* T4_STANDARD */]: {
+    min: 650,
+    max: 799,
+    name: "Standard",
+    description: "External API access, policy-governed",
+    color: "#22c55e",
+    textColor: "#ffffff"
+  },
+  [5 /* T5_TRUSTED */]: {
+    min: 800,
+    max: 875,
+    name: "Trusted",
+    description: "Cross-agent communication, delegated tasks",
+    color: "#3b82f6",
+    textColor: "#ffffff"
+  },
+  [6 /* T6_CERTIFIED */]: {
+    min: 876,
+    max: 950,
+    name: "Certified",
+    description: "Admin tasks, agent spawning, minimal oversight",
+    color: "#8b5cf6",
+    textColor: "#ffffff"
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    min: 951,
+    max: 1e3,
+    name: "Autonomous",
+    description: "Full autonomy, self-governance, strategic only",
+    color: "#06b6d4",
+    textColor: "#ffffff"
+  }
+};
+function scoreToTier(score) {
+  if (score < 0 || score > 1e3) {
+    throw new Error(`Trust score must be between 0 and 1000, got ${score}`);
+  }
+  if (score >= 951) return 7 /* T7_AUTONOMOUS */;
+  if (score >= 876) return 6 /* T6_CERTIFIED */;
+  if (score >= 800) return 5 /* T5_TRUSTED */;
+  if (score >= 650) return 4 /* T4_STANDARD */;
+  if (score >= 500) return 3 /* T3_MONITORED */;
+  if (score >= 350) return 2 /* T2_PROVISIONAL */;
+  if (score >= 200) return 1 /* T1_OBSERVED */;
+  return 0 /* T0_SANDBOX */;
+}
+function getTierThreshold(tier) {
+  return TIER_THRESHOLDS[tier];
+}
+function getTierName(tier) {
+  return TIER_THRESHOLDS[tier].name;
+}
+function getTierColor(tier) {
+  return TIER_THRESHOLDS[tier].color;
+}
+function getTierMinScore(tier) {
+  return TIER_THRESHOLDS[tier].min;
+}
+function getTierMaxScore(tier) {
+  return TIER_THRESHOLDS[tier].max;
+}
+function meetsTierRequirement(score, minTier) {
+  const actualTier = scoreToTier(score);
+  return actualTier >= minTier;
+}
+function getTierCode(tier) {
+  return `T${tier}`;
+}
+function parseTier(input) {
+  const normalized = input.toUpperCase().trim();
+  const tMatch = normalized.match(/^T?(\d)$/);
+  if (tMatch) {
+    const num = parseInt(tMatch[1], 10);
+    if (num >= 0 && num <= 7) {
+      return num;
+    }
+  }
+  const nameMap = {
+    SANDBOX: 0 /* T0_SANDBOX */,
+    OBSERVED: 1 /* T1_OBSERVED */,
+    PROVISIONAL: 2 /* T2_PROVISIONAL */,
+    MONITORED: 3 /* T3_MONITORED */,
+    STANDARD: 4 /* T4_STANDARD */,
+    TRUSTED: 5 /* T5_TRUSTED */,
+    CERTIFIED: 6 /* T6_CERTIFIED */,
+    AUTONOMOUS: 7 /* T7_AUTONOMOUS */
+  };
+  return nameMap[normalized] ?? null;
+}
+var ALL_TIERS = [
+  0 /* T0_SANDBOX */,
+  1 /* T1_OBSERVED */,
+  2 /* T2_PROVISIONAL */,
+  3 /* T3_MONITORED */,
+  4 /* T4_STANDARD */,
+  5 /* T5_TRUSTED */,
+  6 /* T6_CERTIFIED */,
+  7 /* T7_AUTONOMOUS */
+];
+
+export {
+  TrustTier,
+  TIER_THRESHOLDS,
+  scoreToTier,
+  getTierThreshold,
+  getTierName,
+  getTierColor,
+  getTierMinScore,
+  getTierMaxScore,
+  meetsTierRequirement,
+  getTierCode,
+  parseTier,
+  ALL_TIERS
+};

package/dist/chunk-ZSBKDWWS.js

@@ -0,0 +1,253 @@
+import {
+  TrustTier
+} from "./chunk-X5XDDJ3Z.js";
+
+// src/rate-limits.ts
+var RATE_LIMITS = {
+  [0 /* T0_SANDBOX */]: {
+    requestsPerSecond: 1,
+    requestsPerMinute: 10,
+    requestsPerHour: 100,
+    requestsPerDay: 500,
+    burstLimit: 2,
+    maxPayloadBytes: 1024 * 10,
+    // 10 KB
+    maxResponseBytes: 1024 * 100,
+    // 100 KB
+    connectionTimeoutMs: 5e3,
+    requestTimeoutMs: 1e4
+  },
+  [1 /* T1_OBSERVED */]: {
+    requestsPerSecond: 2,
+    requestsPerMinute: 30,
+    requestsPerHour: 500,
+    requestsPerDay: 2e3,
+    burstLimit: 5,
+    maxPayloadBytes: 1024 * 50,
+    // 50 KB
+    maxResponseBytes: 1024 * 500,
+    // 500 KB
+    connectionTimeoutMs: 5e3,
+    requestTimeoutMs: 15e3
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    requestsPerSecond: 5,
+    requestsPerMinute: 100,
+    requestsPerHour: 2e3,
+    requestsPerDay: 1e4,
+    burstLimit: 10,
+    maxPayloadBytes: 1024 * 100,
+    // 100 KB
+    maxResponseBytes: 1024 * 1024,
+    // 1 MB
+    connectionTimeoutMs: 1e4,
+    requestTimeoutMs: 3e4
+  },
+  [3 /* T3_MONITORED */]: {
+    requestsPerSecond: 10,
+    requestsPerMinute: 300,
+    requestsPerHour: 5e3,
+    requestsPerDay: 5e4,
+    burstLimit: 20,
+    maxPayloadBytes: 1024 * 500,
+    // 500 KB
+    maxResponseBytes: 1024 * 1024 * 5,
+    // 5 MB
+    connectionTimeoutMs: 1e4,
+    requestTimeoutMs: 6e4
+  },
+  [4 /* T4_STANDARD */]: {
+    requestsPerSecond: 20,
+    requestsPerMinute: 600,
+    requestsPerHour: 1e4,
+    requestsPerDay: 1e5,
+    burstLimit: 50,
+    maxPayloadBytes: 1024 * 1024,
+    // 1 MB
+    maxResponseBytes: 1024 * 1024 * 10,
+    // 10 MB
+    connectionTimeoutMs: 15e3,
+    requestTimeoutMs: 12e4
+  },
+  [5 /* T5_TRUSTED */]: {
+    requestsPerSecond: 50,
+    requestsPerMinute: 1500,
+    requestsPerHour: 3e4,
+    requestsPerDay: 3e5,
+    burstLimit: 100,
+    maxPayloadBytes: 1024 * 1024 * 5,
+    // 5 MB
+    maxResponseBytes: 1024 * 1024 * 50,
+    // 50 MB
+    connectionTimeoutMs: 3e4,
+    requestTimeoutMs: 3e5
+  },
+  [6 /* T6_CERTIFIED */]: {
+    requestsPerSecond: 100,
+    requestsPerMinute: 3e3,
+    requestsPerHour: 1e5,
+    requestsPerDay: 1e6,
+    burstLimit: 200,
+    maxPayloadBytes: 1024 * 1024 * 10,
+    // 10 MB
+    maxResponseBytes: 1024 * 1024 * 100,
+    // 100 MB
+    connectionTimeoutMs: 6e4,
+    requestTimeoutMs: 6e5
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    requestsPerSecond: 500,
+    requestsPerMinute: 1e4,
+    requestsPerHour: 5e5,
+    requestsPerDay: 5e6,
+    burstLimit: 500,
+    maxPayloadBytes: 1024 * 1024 * 50,
+    // 50 MB
+    maxResponseBytes: 1024 * 1024 * 500,
+    // 500 MB
+    connectionTimeoutMs: 12e4,
+    requestTimeoutMs: 12e5
+  }
+};
+function getRateLimits(tier) {
+  return RATE_LIMITS[tier];
+}
+function getMinTierForLimits(config) {
+  const tiers = Object.values(TrustTier).filter((t) => typeof t === "number");
+  for (const tier of tiers) {
+    const limits = RATE_LIMITS[tier];
+    if ((config.requestsPerSecond === void 0 || limits.requestsPerSecond >= config.requestsPerSecond) && (config.requestsPerMinute === void 0 || limits.requestsPerMinute >= config.requestsPerMinute) && (config.requestsPerHour === void 0 || limits.requestsPerHour >= config.requestsPerHour) && (config.requestsPerDay === void 0 || limits.requestsPerDay >= config.requestsPerDay)) {
+      return tier;
+    }
+  }
+  return 7 /* T7_AUTONOMOUS */;
+}
+function wouldExceedLimit(tier, window, currentCount) {
+  const limits = RATE_LIMITS[tier];
+  switch (window) {
+    case "second":
+      return currentCount >= limits.requestsPerSecond;
+    case "minute":
+      return currentCount >= limits.requestsPerMinute;
+    case "hour":
+      return currentCount >= limits.requestsPerHour;
+    case "day":
+      return currentCount >= limits.requestsPerDay;
+  }
+}
+function formatRateLimit(tier) {
+  const limits = RATE_LIMITS[tier];
+  return `${limits.requestsPerSecond}/s, ${limits.requestsPerMinute}/min, ${limits.requestsPerHour}/hr`;
+}
+var TIER_QUOTAS = {
+  [0 /* T0_SANDBOX */]: {
+    monthlyApiCalls: 1e3,
+    monthlyComputeUnits: 100,
+    monthlyStorageBytes: 1024 * 1024 * 10,
+    // 10 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 100,
+    // 100 MB
+    maxAgents: 1,
+    maxWebhooks: 1,
+    maxTeamMembers: 1
+  },
+  [1 /* T1_OBSERVED */]: {
+    monthlyApiCalls: 1e4,
+    monthlyComputeUnits: 1e3,
+    monthlyStorageBytes: 1024 * 1024 * 100,
+    // 100 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024,
+    // 1 GB
+    maxAgents: 5,
+    maxWebhooks: 5,
+    maxTeamMembers: 3
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    monthlyApiCalls: 5e4,
+    monthlyComputeUnits: 5e3,
+    monthlyStorageBytes: 1024 * 1024 * 500,
+    // 500 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 5,
+    // 5 GB
+    maxAgents: 10,
+    maxWebhooks: 10,
+    maxTeamMembers: 5
+  },
+  [3 /* T3_MONITORED */]: {
+    monthlyApiCalls: 25e4,
+    monthlyComputeUnits: 25e3,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 2,
+    // 2 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 25,
+    // 25 GB
+    maxAgents: 50,
+    maxWebhooks: 25,
+    maxTeamMembers: 10
+  },
+  [4 /* T4_STANDARD */]: {
+    monthlyApiCalls: 1e6,
+    monthlyComputeUnits: 1e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 10,
+    // 10 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 100,
+    // 100 GB
+    maxAgents: 200,
+    maxWebhooks: 50,
+    maxTeamMembers: 25
+  },
+  [5 /* T5_TRUSTED */]: {
+    monthlyApiCalls: 5e6,
+    monthlyComputeUnits: 5e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 50,
+    // 50 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 500,
+    // 500 GB
+    maxAgents: 1e3,
+    maxWebhooks: 100,
+    maxTeamMembers: 50
+  },
+  [6 /* T6_CERTIFIED */]: {
+    monthlyApiCalls: 25e6,
+    monthlyComputeUnits: 25e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 250,
+    // 250 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 2500,
+    // 2.5 TB
+    maxAgents: 5e3,
+    maxWebhooks: 250,
+    maxTeamMembers: 100
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    monthlyApiCalls: -1,
+    // Unlimited
+    monthlyComputeUnits: -1,
+    // Unlimited
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 1024,
+    // 1 TB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 1e4,
+    // 10 TB
+    maxAgents: -1,
+    // Unlimited
+    maxWebhooks: -1,
+    // Unlimited
+    maxTeamMembers: -1
+    // Unlimited
+  }
+};
+function getQuota(tier) {
+  return TIER_QUOTAS[tier];
+}
+function isUnlimited(value) {
+  return value === -1;
+}
+
+export {
+  RATE_LIMITS,
+  getRateLimits,
+  getMinTierForLimits,
+  wouldExceedLimit,
+  formatRateLimit,
+  TIER_QUOTAS,
+  getQuota,
+  isUnlimited
+};

package/dist/index.cjs

@@ -143,14 +143,14 @@ var TIER_THRESHOLDS = {
   },
   [2 /* T2_PROVISIONAL */]: {
     min: 350,
-    max: 500,
+    max: 499,
     name: "Provisional",
     description: "Basic operations, heavy supervision",
     color: "#f97316",
     textColor: "#ffffff"
   },
   [3 /* T3_MONITORED */]: {
-    min: 501,
+    min: 500,
     max: 649,
     name: "Monitored",
     description: "Standard operations with continuous monitoring",
@@ -198,7 +198,7 @@ function scoreToTier(score) {
   if (score >= 876) return 6 /* T6_CERTIFIED */;
   if (score >= 800) return 5 /* T5_TRUSTED */;
   if (score >= 650) return 4 /* T4_STANDARD */;
-  if (score >= 501) return 3 /* T3_MONITORED */;
+  if (score >= 500) return 3 /* T3_MONITORED */;
   if (score >= 350) return 2 /* T2_PROVISIONAL */;
   if (score >= 200) return 1 /* T1_OBSERVED */;
   return 0 /* T0_SANDBOX */;

package/dist/index.js

@@ -79,7 +79,7 @@ import {
   getRateLimits,
   isUnlimited,
   wouldExceedLimit
-} from "./chunk-F2R6HBF5.js";
+} from "./chunk-ZSBKDWWS.js";
 import {
   ALL_TIERS,
   TIER_THRESHOLDS,
@@ -93,7 +93,7 @@ import {
   meetsTierRequirement,
   parseTier,
   scoreToTier
-} from "./chunk-PHL3CB53.js";
+} from "./chunk-X5XDDJ3Z.js";
 import {
   ACTIVE_THEME,
   THEMES,

package/dist/rate-limits.js

@@ -7,8 +7,8 @@ import {
   getRateLimits,
   isUnlimited,
   wouldExceedLimit
-} from "./chunk-F2R6HBF5.js";
-import "./chunk-PHL3CB53.js";
+} from "./chunk-ZSBKDWWS.js";
+import "./chunk-X5XDDJ3Z.js";
 export {
   RATE_LIMITS,
   TIER_QUOTAS,

package/dist/tiers.cjs

@@ -64,14 +64,14 @@ var TIER_THRESHOLDS = {
   },
   [2 /* T2_PROVISIONAL */]: {
     min: 350,
-    max: 500,
+    max: 499,
     name: "Provisional",
     description: "Basic operations, heavy supervision",
     color: "#f97316",
     textColor: "#ffffff"
   },
   [3 /* T3_MONITORED */]: {
-    min: 501,
+    min: 500,
     max: 649,
     name: "Monitored",
     description: "Standard operations with continuous monitoring",
@@ -119,7 +119,7 @@ function scoreToTier(score) {
   if (score >= 876) return 6 /* T6_CERTIFIED */;
   if (score >= 800) return 5 /* T5_TRUSTED */;
   if (score >= 650) return 4 /* T4_STANDARD */;
-  if (score >= 501) return 3 /* T3_MONITORED */;
+  if (score >= 500) return 3 /* T3_MONITORED */;
   if (score >= 350) return 2 /* T2_PROVISIONAL */;
   if (score >= 200) return 1 /* T1_OBSERVED */;
   return 0 /* T0_SANDBOX */;

package/dist/tiers.js

@@ -11,7 +11,7 @@ import {
   meetsTierRequirement,
   parseTier,
   scoreToTier
-} from "./chunk-PHL3CB53.js";
+} from "./chunk-X5XDDJ3Z.js";
 export {
   ALL_TIERS,
   TIER_THRESHOLDS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorionsys/shared-constants",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Shared constants for Vorion ecosystem - single source of truth for tiers, domains, and configuration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -67,5 +67,8 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/tiers.ts

@@ -58,14 +58,14 @@ export const TIER_THRESHOLDS: Readonly<Record<TrustTier, TierThreshold>> = {
   },
   [TrustTier.T2_PROVISIONAL]: {
     min: 350,
-    max: 500,
+    max: 499,
     name: 'Provisional',
     description: 'Basic operations, heavy supervision',
     color: '#f97316',
     textColor: '#ffffff',
   },
   [TrustTier.T3_MONITORED]: {
-    min: 501,
+    min: 500,
     max: 649,
     name: 'Monitored',
     description: 'Standard operations with continuous monitoring',
@@ -122,7 +122,7 @@ export function scoreToTier(score: number): TrustTier {
   if (score >= 876) return TrustTier.T6_CERTIFIED;
   if (score >= 800) return TrustTier.T5_TRUSTED;
   if (score >= 650) return TrustTier.T4_STANDARD;
-  if (score >= 501) return TrustTier.T3_MONITORED;
+  if (score >= 500) return TrustTier.T3_MONITORED;
   if (score >= 350) return TrustTier.T2_PROVISIONAL;
   if (score >= 200) return TrustTier.T1_OBSERVED;
   return TrustTier.T0_SANDBOX;