@vorionsys/atsf-core 0.2.2 → 0.2.3

package/dist/api/server.js

@@ -5,19 +5,19 @@
  *
  * @packageDocumentation
  */
-import Fastify from 'fastify';
-import cors from '@fastify/cors';
-import helmet from '@fastify/helmet';
-import rateLimit from '@fastify/rate-limit';
-import { createLogger } from '../common/logger.js';
-import { getConfig } from '../common/config.js';
-import { createIntentService } from '../intent/index.js';
-import { createProofService } from '../proof/index.js';
-import { createTrustEngine } from '../trust-engine/index.js';
-import { createEvaluator } from '../basis/evaluator.js';
-import { createGovernanceEngine } from '../governance/index.js';
-import { GovernanceProofBridge } from '../governance/proof-bridge.js';
-const apiLogger = createLogger({ component: 'api' });
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import helmet from "@fastify/helmet";
+import rateLimit from "@fastify/rate-limit";
+import { createLogger } from "../common/logger.js";
+import { getConfig } from "../common/config.js";
+import { PersistentIntentService } from "../intent/persistent-intent-service.js";
+import { createProofService } from "../proof/index.js";
+import { createTrustEngine } from "../trust-engine/index.js";
+import { createEvaluator } from "../basis/evaluator.js";
+import { createGovernanceEngine } from "../governance/index.js";
+import { GovernanceProofBridge } from "../governance/proof-bridge.js";
+const apiLogger = createLogger({ component: "api" });
 // ============================================================
 // Health Check Implementation
 // ============================================================
@@ -43,15 +43,15 @@ function checkSystemHealth(startTime) {
     const metrics = getSystemMetrics(startTime);
     // Warning threshold: 80% memory usage
     // Error threshold: 95% memory usage
-    let status = 'ok';
-    let message = 'System healthy';
+    let status = "ok";
+    let message = "System healthy";
     if (metrics.memoryUsagePercent > 95) {
-        status = 'error';
-        message = 'Critical memory pressure';
+        status = "error";
+        message = "Critical memory pressure";
     }
     else if (metrics.memoryUsagePercent > 80) {
-        status = 'degraded';
-        message = 'High memory usage';
+        status = "degraded";
+        message = "High memory usage";
     }
     return {
         status,
@@ -71,27 +71,27 @@ async function checkService(name, checkFn) {
     try {
         await checkFn();
         return {
-            status: 'ok',
+            status: "ok",
             latencyMs: Date.now() - start,
             message: `${name} operational`,
         };
     }
     catch (error) {
         return {
-            status: 'error',
+            status: "error",
             latencyMs: Date.now() - start,
-            message: `${name} error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            message: `${name} error: ${error instanceof Error ? error.message : "Unknown error"}`,
         };
     }
 }
 /**
  * Create and configure the API server
  */
-export async function createServer() {
+export async function createServer(deps) {
     const config = getConfig();
     const startTime = new Date();
     // Initialize services
-    const intentService = createIntentService();
+    const intentService = deps?.intentService ?? new PersistentIntentService();
     const proofService = createProofService();
     const trustEngine = createTrustEngine();
     const evaluator = createEvaluator();
@@ -101,41 +101,45 @@ export async function createServer() {
             const proof = await proofService.create(req);
             return { id: proof.id };
         },
-        tenantId: '__system__',
+        tenantId: "__system__",
     });
     // Use pino logger config for Fastify 5
-    const isTest = process.env['NODE_ENV'] === 'test' || process.env['VITEST'];
+    const isTest = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
     const server = Fastify({
-        logger: isTest ? false : {
-            level: config.env === 'production' ? 'info' : 'debug',
-            transport: config.env !== 'production' ? {
-                target: 'pino-pretty',
-                options: { colorize: true },
-            } : undefined,
-        },
-        requestIdHeader: 'x-request-id',
-        requestIdLogLabel: 'requestId',
+        logger: isTest
+            ? false
+            : {
+                level: config.env === "production" ? "info" : "debug",
+                transport: config.env !== "production"
+                    ? {
+                        target: "pino-pretty",
+                        options: { colorize: true },
+                    }
+                    : undefined,
+            },
+        requestIdHeader: "x-request-id",
+        requestIdLogLabel: "requestId",
     });
     // Register plugins
     await server.register(cors, {
-        origin: config.env === 'production' ? false : true,
+        origin: config.env === "production" ? false : true,
         credentials: true,
     });
     await server.register(helmet, {
-        contentSecurityPolicy: config.env === 'production',
+        contentSecurityPolicy: config.env === "production",
     });
     await server.register(rateLimit, {
         max: config.api.rateLimit,
-        timeWindow: '1 minute',
+        timeWindow: "1 minute",
     });
     // API Key authentication for protected routes
-    const API_KEY = process.env['VORION_API_KEY'] || config.api.apiKey;
+    const API_KEY = process.env["VORION_API_KEY"] || config.api.apiKey;
     const requiresAuth = (url) => {
         // Public endpoints that don't require auth
-        const publicPaths = ['/health', '/ready', '/live', '/api/v1/health'];
-        return !publicPaths.some(path => url === path || url.startsWith(path + '?'));
+        const publicPaths = ["/health", "/ready", "/live", "/api/v1/health"];
+        return !publicPaths.some((path) => url === path || url.startsWith(path + "?"));
     };
-    server.addHook('onRequest', async (request, reply) => {
+    server.addHook("onRequest", async (request, reply) => {
         // Skip auth in test mode or for public endpoints
         if (isTest || !requiresAuth(request.url)) {
             return;
@@ -144,107 +148,113 @@ export async function createServer() {
         if (!API_KEY) {
             return;
         }
-        const authHeader = request.headers['authorization'];
+        const authHeader = request.headers["authorization"];
         if (!authHeader) {
             return reply.status(401).send({
-                error: { code: 'UNAUTHORIZED', message: 'Missing Authorization header' },
+                error: {
+                    code: "UNAUTHORIZED",
+                    message: "Missing Authorization header",
+                },
             });
         }
-        const [scheme, token] = authHeader.split(' ');
-        if (scheme?.toLowerCase() !== 'bearer' || token !== API_KEY) {
+        const [scheme, token] = authHeader.split(" ");
+        if (scheme?.toLowerCase() !== "bearer" || token !== API_KEY) {
             return reply.status(401).send({
-                error: { code: 'UNAUTHORIZED', message: 'Invalid API key' },
+                error: { code: "UNAUTHORIZED", message: "Invalid API key" },
             });
         }
     });
     // Health check endpoint - performs actual checks on all services
-    server.get('/health', async () => {
+    server.get("/health", async () => {
         const checks = {};
         // Check trust engine
-        checks.trustEngine = await checkService('Trust engine', async () => {
-            await trustEngine.getScore('__health_check__');
+        checks.trustEngine = await checkService("Trust engine", async () => {
+            await trustEngine.getScore("__health_check__");
         });
         // Check proof service
-        checks.proofService = await checkService('Proof service', async () => {
-            await proofService.get('__health_check_proof__');
+        checks.proofService = await checkService("Proof service", async () => {
+            await proofService.get("__health_check_proof__");
         });
         // Check intent service
-        checks.intentService = await checkService('Intent service', async () => {
-            await intentService.get('__health_check_intent__', '__system__');
+        checks.intentService = await checkService("Intent service", async () => {
+            await intentService.get("__health_check_intent__", "__system__");
         });
         // Check system health
         checks.system = checkSystemHealth(startTime);
         // Determine overall status
         const statuses = Object.values(checks).map((c) => c.status);
         let status;
-        if (statuses.every((s) => s === 'ok')) {
-            status = 'healthy';
+        if (statuses.every((s) => s === "ok")) {
+            status = "healthy";
         }
-        else if (statuses.some((s) => s === 'error')) {
-            status = 'unhealthy';
+        else if (statuses.some((s) => s === "error")) {
+            status = "unhealthy";
         }
         else {
-            status = 'degraded';
+            status = "degraded";
         }
         return {
             status,
             timestamp: new Date().toISOString(),
-            version: process.env['npm_package_version'],
+            version: process.env["npm_package_version"],
             environment: config.env,
             checks,
             metrics: getSystemMetrics(startTime),
         };
     });
     // Ready check endpoint - verifies all critical services are ready
-    server.get('/ready', async (_request, reply) => {
+    server.get("/ready", async (_request, reply) => {
         const checks = {};
         // Check trust engine (critical)
-        checks.trustEngine = await checkService('Trust engine', async () => {
-            await trustEngine.getScore('__health_check__');
+        checks.trustEngine = await checkService("Trust engine", async () => {
+            await trustEngine.getScore("__health_check__");
         });
         // Check proof service (critical)
-        checks.proofService = await checkService('Proof service', async () => {
-            await proofService.get('__health_check_proof__');
+        checks.proofService = await checkService("Proof service", async () => {
+            await proofService.get("__health_check_proof__");
         });
         // Check intent service (critical)
-        checks.intentService = await checkService('Intent service', async () => {
-            await intentService.get('__health_check_intent__', '__system__');
+        checks.intentService = await checkService("Intent service", async () => {
+            await intentService.get("__health_check_intent__", "__system__");
         });
-        const allPassed = Object.values(checks).every((c) => c.status === 'ok' || c.status === 'degraded');
+        const allPassed = Object.values(checks).every((c) => c.status === "ok" || c.status === "degraded");
         // Return 503 if not ready (for Kubernetes probes)
         if (!allPassed) {
             reply.status(503);
         }
         return {
-            status: allPassed ? 'ready' : 'not_ready',
+            status: allPassed ? "ready" : "not_ready",
             timestamp: new Date().toISOString(),
             checks,
             allPassed,
         };
     });
     // Liveness probe endpoint - simple alive check (no deep checks)
-    server.get('/live', async () => ({
-        status: 'alive',
+    server.get("/live", async () => ({
+        status: "alive",
         timestamp: new Date().toISOString(),
     }));
     // API routes
     server.register(async (api) => {
         // SDK: Health check endpoint
-        api.get('/health', async () => ({
-            status: 'healthy',
-            version: process.env['npm_package_version'] ?? '0.1.0',
+        api.get("/health", async () => ({
+            status: "healthy",
+            version: process.env["npm_package_version"] ?? "0.1.0",
         }));
         // Intent routes - unified handler for both legacy and SDK formats
-        api.post('/intents', async (request, reply) => {
+        api.post("/intents", async (request, reply) => {
             const body = request.body;
             // Detect format: SDK format has 'agentId' and 'action', legacy has 'entityId' and 'goal'
-            if ('agentId' in body && 'action' in body) {
+            if ("agentId" in body && "action" in body) {
                 // SDK format
                 const startTime = Date.now();
-                const { agentId, capabilities = [], action } = body;
+                const { agentId, capabilities = [], action, } = body;
                 if (!agentId || !action?.type || !action?.resource) {
                     return reply.status(400).send({
-                        error: { code: 'INVALID_REQUEST', message: 'Missing required fields: agentId, action.type, action.resource' },
+                        error: {
+                            code: "INVALID_REQUEST",
+                            message: "Missing required fields: agentId, action.type, action.resource",
+                        },
                     });
                 }
                 // Get or create agent trust record
@@ -254,10 +264,10 @@ export async function createServer() {
                     trustRecord = await trustEngine.getScore(agentId);
                 }
                 // Check capability
-                const hasCapability = capabilities.some(cap => cap === '*' ||
+                const hasCapability = capabilities.some((cap) => cap === "*" ||
                     cap === action.type ||
                     cap === `${action.type}:*` ||
-                    cap === `${action.type}:${action.resource.split('/')[0]}`);
+                    cap === `${action.type}:${action.resource.split("/")[0]}`);
                 // Determine decision
                 const trustLevel = trustRecord?.level ?? 3;
                 const trustScore = trustRecord?.score ?? 500;
@@ -265,13 +275,13 @@ export async function createServer() {
                 // Decision tier based on trust level
                 let tier;
                 if (!allowed) {
-                    tier = 'RED';
+                    tier = "RED";
                 }
                 else if (trustLevel >= 5) {
-                    tier = 'GREEN';
+                    tier = "GREEN";
                 }
                 else {
-                    tier = 'YELLOW';
+                    tier = "YELLOW";
                 }
                 // Create proof record
                 const proofId = `proof-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
@@ -279,20 +289,20 @@ export async function createServer() {
                 // Determine constraints based on tier
                 const constraints = [];
                 if (trustLevel <= 1) {
-                    constraints.push('rate_limit:10/min', 'audit:full', 'sandbox:true');
+                    constraints.push("rate_limit:10/min", "audit:full", "sandbox:true");
                 }
                 else if (trustLevel <= 3) {
-                    constraints.push('rate_limit:100/min', 'audit:standard');
+                    constraints.push("rate_limit:100/min", "audit:standard");
                 }
                 else if (trustLevel <= 5) {
-                    constraints.push('rate_limit:1000/min', 'audit:light');
+                    constraints.push("rate_limit:1000/min", "audit:light");
                 }
                 const reason = allowed
-                    ? 'Action permitted based on capabilities and trust level'
+                    ? "Action permitted based on capabilities and trust level"
                     : hasCapability
                         ? `Trust score ${trustScore} below minimum threshold (200)`
-                        : `Missing capability for ${action.type}:${action.resource.split('/')[0]}`;
-                apiLogger.info({ intentId, agentId, action: action.type, allowed, tier }, 'Intent processed');
+                        : `Missing capability for ${action.type}:${action.resource.split("/")[0]}`;
+                apiLogger.info({ intentId, agentId, action: action.type, allowed, tier }, "Intent processed");
                 return {
                     intentId,
                     allowed,
@@ -308,7 +318,10 @@ export async function createServer() {
                 const { entityId, goal, context, metadata } = body;
                 if (!entityId || !goal) {
                     return reply.status(400).send({
-                        error: { code: 'INVALID_REQUEST', message: 'Missing required fields: entityId, goal' },
+                        error: {
+                            code: "INVALID_REQUEST",
+                            message: "Missing required fields: entityId, goal",
+                        },
                     });
                 }
                 const intent = await intentService.submit({
@@ -316,26 +329,29 @@ export async function createServer() {
                     goal,
                     context: context ?? {},
                     metadata,
-                }, { tenantId: '__system__' });
-                apiLogger.info({ intentId: intent.id, entityId }, 'Intent submitted');
+                }, { tenantId: "__system__" });
+                apiLogger.info({ intentId: intent.id, entityId }, "Intent submitted");
                 return reply.status(201).send({ intent });
             }
         });
-        api.get('/intents/:id', async (request, reply) => {
-            const intent = await intentService.get(request.params.id, '__system__');
+        api.get("/intents/:id", async (request, reply) => {
+            const intent = await intentService.get(request.params.id, "__system__");
             if (!intent) {
                 return reply.status(404).send({
-                    error: { code: 'NOT_FOUND', message: 'Intent not found' },
+                    error: { code: "NOT_FOUND", message: "Intent not found" },
                 });
             }
             return { intent };
         });
         // SDK: Check intent (pre-flight, no side effects)
-        api.post('/intents/check', async (request, reply) => {
+        api.post("/intents/check", async (request, reply) => {
             const { agentId, capabilities = [], action } = request.body;
             if (!agentId || !action?.type || !action?.resource) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required fields",
+                    },
                 });
             }
             // Get agent trust record
@@ -343,49 +359,49 @@ export async function createServer() {
             const trustScore = trustRecord?.score ?? 0;
             const trustLevel = trustRecord?.level ?? 0;
             // Check capability
-            const hasCapability = capabilities.some(cap => cap === '*' ||
+            const hasCapability = capabilities.some((cap) => cap === "*" ||
                 cap === action.type ||
                 cap === `${action.type}:*` ||
-                cap === `${action.type}:${action.resource.split('/')[0]}`);
+                cap === `${action.type}:${action.resource.split("/")[0]}`);
             const wouldAllow = hasCapability && trustScore >= 200;
             let tier;
             if (!wouldAllow) {
-                tier = 'RED';
+                tier = "RED";
             }
             else if (trustLevel >= 5) {
-                tier = 'GREEN';
+                tier = "GREEN";
             }
             else {
-                tier = 'YELLOW';
+                tier = "YELLOW";
             }
             const reason = wouldAllow
-                ? 'Action would be permitted'
+                ? "Action would be permitted"
                 : hasCapability
                     ? `Trust score ${trustScore} below minimum threshold`
                     : `Missing capability for ${action.type}`;
             return { wouldAllow, tier, reason };
         });
         // Proof routes
-        api.get('/proofs/:id', async (request, reply) => {
+        api.get("/proofs/:id", async (request, reply) => {
             const proof = await proofService.get(request.params.id);
             if (!proof) {
                 return reply.status(404).send({
-                    error: { code: 'NOT_FOUND', message: 'Proof not found' },
+                    error: { code: "NOT_FOUND", message: "Proof not found" },
                 });
             }
             return { proof };
         });
-        api.post('/proofs/:id/verify', async (request, reply) => {
+        api.post("/proofs/:id/verify", async (request, reply) => {
             const result = await proofService.verify(request.params.id);
             if (result.chainPosition === -1) {
                 return reply.status(404).send({
-                    error: { code: 'NOT_FOUND', message: 'Proof not found' },
+                    error: { code: "NOT_FOUND", message: "Proof not found" },
                 });
             }
             return { verification: result };
         });
         // Trust routes
-        api.get('/trust/:entityId', async (request) => {
+        api.get("/trust/:entityId", async (request) => {
             const record = await trustEngine.getScore(request.params.entityId);
             if (!record) {
                 // Return null values for non-existent agents (SDK compatible)
@@ -394,7 +410,7 @@ export async function createServer() {
                     score: null,
                     tier: null,
                     tierName: null,
-                    message: 'Agent not found',
+                    message: "Agent not found",
                 };
             }
             return {
@@ -406,11 +422,14 @@ export async function createServer() {
             };
         });
         // SDK: Admit agent endpoint
-        api.post('/trust/admit', async (request, reply) => {
+        api.post("/trust/admit", async (request, reply) => {
             const { agentId, name, capabilities, observationTier } = request.body;
             if (!agentId || !name) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields: agentId, name' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required fields: agentId, name",
+                    },
                 });
             }
             // Initialize agent in trust engine at T3 (Monitored)
@@ -418,31 +437,35 @@ export async function createServer() {
             await trustEngine.initializeEntity(agentId, initialLevel);
             const record = await trustEngine.getScore(agentId);
             const expiresAt = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(); // 1 year
-            apiLogger.info({ agentId, name, initialLevel }, 'Agent admitted');
+            apiLogger.info({ agentId, name, initialLevel }, "Agent admitted");
             return reply.status(201).send({
                 admitted: true,
                 initialTier: record?.level ?? initialLevel,
                 initialScore: record?.score ?? 500,
-                observationCeiling: observationTier === 'WHITE_BOX' ? 7 : observationTier === 'GRAY_BOX' ? 5 : 3,
+                observationCeiling: observationTier === "WHITE_BOX"
+                    ? 7
+                    : observationTier === "GRAY_BOX"
+                        ? 5
+                        : 3,
                 capabilities: capabilities ?? [],
                 expiresAt,
             });
         });
         // SDK: Record trust signal
-        api.post('/trust/:agentId/signal', async (request, reply) => {
+        api.post("/trust/:agentId/signal", async (request, reply) => {
             const { agentId } = request.params;
             const { type, source, weight = 0.1, context } = request.body;
             const recordBefore = await trustEngine.getScore(agentId);
             if (!recordBefore) {
                 return reply.status(404).send({
-                    error: { code: 'NOT_FOUND', message: 'Agent not found' },
+                    error: { code: "NOT_FOUND", message: "Agent not found" },
                 });
             }
             const scoreBefore = recordBefore.score;
             // Map signal type to trust value
             const valueMap = {
-                success: 0.8 + (weight * 0.2),
-                failure: 0.2 - (weight * 0.1),
+                success: 0.8 + weight * 0.2,
+                failure: 0.2 - weight * 0.1,
                 violation: 0.0,
                 neutral: 0.5,
             };
@@ -464,18 +487,23 @@ export async function createServer() {
                 scoreAfter,
                 change: scoreAfter - scoreBefore,
                 newTier: recordAfter?.level ?? null,
-                newTierName: recordAfter ? trustEngine.getLevelName(recordAfter.level) : null,
+                newTierName: recordAfter
+                    ? trustEngine.getLevelName(recordAfter.level)
+                    : null,
             };
         });
         // ================================================================
         // Governance routes
         // ================================================================
         // Evaluate governance request (with proof chain)
-        api.post('/governance/evaluate', async (request, reply) => {
+        api.post("/governance/evaluate", async (request, reply) => {
             const body = request.body;
             if (!body.requestId || !body.entityId || !body.action) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields: requestId, entityId, action' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required fields: requestId, entityId, action",
+                    },
                 });
             }
             const startTime = Date.now();
@@ -485,7 +513,7 @@ export async function createServer() {
                 entityId: body.entityId,
                 decision: result.decision,
                 proofId,
-            }, 'Governance evaluation completed');
+            }, "Governance evaluation completed");
             return {
                 result,
                 proofId,
@@ -493,85 +521,96 @@ export async function createServer() {
             };
         });
         // Query governance rules
-        api.get('/governance/rules', async (request) => {
+        api.get("/governance/rules", async (request) => {
             const rules = await governanceEngine.queryRules(request.query);
             return { rules, count: rules.length };
         });
         // Register governance rule
-        api.post('/governance/rules', async (request, reply) => {
+        api.post("/governance/rules", async (request, reply) => {
             const rule = request.body;
             if (!rule.ruleId || !rule.name || !rule.condition || !rule.effect) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required rule fields' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required rule fields",
+                    },
                 });
             }
             governanceEngine.registerRule(rule);
-            apiLogger.info({ ruleId: rule.ruleId, name: rule.name }, 'Governance rule registered');
-            return reply.status(201).send({ registered: true, ruleId: rule.ruleId });
+            apiLogger.info({ ruleId: rule.ruleId, name: rule.name }, "Governance rule registered");
+            return reply
+                .status(201)
+                .send({ registered: true, ruleId: rule.ruleId });
         });
         // ================================================================
         // Boot Camp routes
         // ================================================================
         // Run boot camp for an agent
-        api.post('/agents/:agentId/bootcamp', async (request, reply) => {
+        api.post("/agents/:agentId/bootcamp", async (request, reply) => {
             const { agentId } = request.params;
             const { tenantId } = request.body;
             if (!tenantId) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required field: tenantId' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required field: tenantId",
+                    },
                 });
             }
             // The agent must implement handleChallenge — for API usage,
             // this is a placeholder that indicates the boot camp needs
             // to be driven by the calling service with a real agent adapter.
             // For now, return the service configuration info.
-            apiLogger.info({ agentId, tenantId }, 'Boot camp requested');
+            apiLogger.info({ agentId, tenantId }, "Boot camp requested");
             return reply.status(501).send({
                 error: {
-                    code: 'NOT_IMPLEMENTED',
-                    message: 'Boot camp must be run programmatically via PromotionService. ' +
-                        'Use the @vorionsys/atsf-core SDK to run boot camp with a BootCampAgent implementation.',
+                    code: "NOT_IMPLEMENTED",
+                    message: "Boot camp must be run programmatically via PromotionService. " +
+                        "Use the @vorionsys/atsf-core SDK to run boot camp with a BootCampAgent implementation.",
                 },
                 hint: {
-                    sdk: '@vorionsys/atsf-core',
-                    import: 'PromotionService',
-                    usage: 'new PromotionService(trustEngine).runAndEvaluate(agent)',
+                    sdk: "@vorionsys/atsf-core",
+                    import: "PromotionService",
+                    usage: "new PromotionService(trustEngine).runAndEvaluate(agent)",
                 },
             });
         });
         // Constraint routes
-        api.post('/constraints/validate', async (request, reply) => {
+        api.post("/constraints/validate", async (request, reply) => {
             const { entityId, intentType, context } = request.body;
             if (!entityId || !intentType) {
                 return reply.status(400).send({
-                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields' },
+                    error: {
+                        code: "INVALID_REQUEST",
+                        message: "Missing required fields",
+                    },
                 });
             }
             // Get entity trust record
             const trustRecord = await trustEngine.getScore(entityId);
             if (!trustRecord) {
                 return reply.status(404).send({
-                    error: { code: 'NOT_FOUND', message: 'Entity not found' },
+                    error: { code: "NOT_FOUND", message: "Entity not found" },
                 });
             }
             // Create evaluation context
             const evalContext = {
                 intent: {
-                    id: 'validation-check',
+                    id: "validation-check",
                     type: intentType,
-                    goal: 'constraint-validation',
+                    goal: "constraint-validation",
                     context: context ?? {},
                 },
                 entity: {
                     id: entityId,
-                    type: 'agent',
+                    type: "agent",
                     trustScore: trustRecord.score,
                     trustLevel: trustRecord.level,
                     attributes: {},
                 },
                 environment: {
                     timestamp: new Date().toISOString(),
-                    timezone: 'UTC',
+                    timezone: "UTC",
                     requestId: request.id,
                 },
                 custom: {},
@@ -597,13 +636,11 @@ export async function createServer() {
             error: error.message,
             stack: error.stack,
             requestId: request.id,
-        }, 'Request error');
+        }, "Request error");
         reply.status(error.statusCode ?? 500).send({
             error: {
-                code: error.code ?? 'INTERNAL_ERROR',
-                message: config.env === 'production'
-                    ? 'An error occurred'
-                    : error.message,
+                code: error.code ?? "INTERNAL_ERROR",
+                message: config.env === "production" ? "An error occurred" : error.message,
             },
         });
     });
@@ -624,10 +661,10 @@ export async function startServer() {
             port: config.api.port,
             host: config.api.host,
             environment: config.env,
-        }, 'Server started');
+        }, "Server started");
     }
     catch (error) {
-        apiLogger.error({ error }, 'Failed to start server');
+        apiLogger.error({ error }, "Failed to start server");
         process.exit(1);
     }
 }