@llm-dev-ops/agentics-cli 1.4.26 → 1.4.29

package/dist/bundled-agents/policy-engine-agents/dist/functions/integrations/ruvector-service/client.js

@@ -0,0 +1,446 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruvectorServiceClient = exports.RuVectorServiceClient = void 0;
+/**
+ * RuVector Service Client
+ *
+ * Client for persisting DecisionEvents to ruvector-service.
+ *
+ * IMPORTANT: LLM-Policy-Engine NEVER connects directly to Google SQL.
+ * ALL persistence occurs via ruvector-service client calls only.
+ *
+ * This follows the LLM-Policy-Engine Agent Infrastructure Constitution:
+ * - No local persistence
+ * - No direct SQL access
+ * - Async, non-blocking writes
+ */
+var axios_1 = __importDefault(require("axios"));
+var config_1 = require("../../utils/config");
+var logger_1 = __importDefault(require("../../utils/logger"));
+/**
+ * RuVector Service Client
+ *
+ * Provides async, non-blocking access to ruvector-service for:
+ * - Persisting DecisionEvents
+ * - Registering agents
+ * - Querying historical decisions
+ */
+var RuVectorServiceClient = /** @class */ (function () {
+    function RuVectorServiceClient() {
+        var _a, _b;
+        this.enabled = !!((_a = config_1.config.integrations) === null || _a === void 0 ? void 0 : _a.ruvectorServiceUrl);
+        this.serviceName = 'llm-policy-engine';
+        this.client = axios_1.default.create({
+            baseURL: ((_b = config_1.config.integrations) === null || _b === void 0 ? void 0 : _b.ruvectorServiceUrl) || 'http://localhost:8080',
+            timeout: 5000,
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'LLM-Policy-Engine/1.0',
+                'X-Service-Name': this.serviceName,
+            },
+        });
+        // Add request interceptor for authentication
+        this.client.interceptors.request.use(function (requestConfig) {
+            // Add Agentics identity token if available
+            var token = process.env.AGENTICS_API_TOKEN;
+            if (token) {
+                requestConfig.headers.Authorization = "Bearer ".concat(token);
+            }
+            return requestConfig;
+        });
+    }
+    /**
+     * Persist a DecisionEvent to ruvector-service
+     *
+     * This is the PRIMARY method for recording agent decisions.
+     * It MUST be called exactly ONCE per agent invocation.
+     */
+    RuVectorServiceClient.prototype.persistDecisionEvent = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            logger_1.default.debug('RuVector service integration disabled');
+                            return [2 /*return*/, { accepted: true, event_id: event.event_id }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.post('/api/v1/decision-events', event)];
+                    case 2:
+                        response = _a.sent();
+                        logger_1.default.info({ event_id: event.event_id, agent_id: event.agent_id }, 'DecisionEvent persisted successfully');
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_1, 'persistDecisionEvent', {
+                                accepted: false,
+                                error: this.getErrorMessage(error_1),
+                            })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Persist multiple DecisionEvents in a batch
+     */
+    RuVectorServiceClient.prototype.persistDecisionEventsBatch = function (events) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            return [2 /*return*/, {
+                                    accepted_count: events.length,
+                                    rejected_count: 0,
+                                    rejected_ids: [],
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.post('/api/v1/decision-events/batch', { events: events })];
+                    case 2:
+                        response = _a.sent();
+                        logger_1.default.info({ count: events.length, accepted: response.data.accepted_count }, 'Batch DecisionEvents persisted');
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_2 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_2, 'persistDecisionEventsBatch', {
+                                accepted_count: 0,
+                                rejected_count: events.length,
+                                rejected_ids: events.map(function (e) { return e.event_id; }),
+                            })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register an agent with ruvector-service
+     */
+    RuVectorServiceClient.prototype.registerAgent = function (registration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            logger_1.default.debug('RuVector service integration disabled');
+                            return [2 /*return*/, { registered: true, agent_id: registration.agent_id }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.post('/api/v1/agents/register', registration)];
+                    case 2:
+                        response = _a.sent();
+                        logger_1.default.info({ agent_id: registration.agent_id, version: registration.agent_version }, 'Agent registered successfully');
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_3 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_3, 'registerAgent', {
+                                registered: false,
+                                error: this.getErrorMessage(error_3),
+                            })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Query historical DecisionEvents
+     */
+    RuVectorServiceClient.prototype.queryDecisionEvents = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            return [2 /*return*/, { total: 0, events: [], has_more: false }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.get('/api/v1/decision-events', { params: query })];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_4 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_4, 'queryDecisionEvents', {
+                                total: 0,
+                                events: [],
+                                has_more: false,
+                            })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get a specific DecisionEvent by ID
+     */
+    RuVectorServiceClient.prototype.getDecisionEvent = function (eventId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_5;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            return [2 /*return*/, null];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.get("/api/v1/decision-events/".concat(eventId))];
+                    case 2:
+                        response = _b.sent();
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_5 = _b.sent();
+                        if (axios_1.default.isAxiosError(error_5) && ((_a = error_5.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, this.handleError(error_5, 'getDecisionEvent', null)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get DecisionEvents by request ID
+     */
+    RuVectorServiceClient.prototype.getDecisionEventsByRequestId = function (requestId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            return [2 /*return*/, []];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.get('/api/v1/decision-events', { params: { request_id: requestId } })];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data.events];
+                    case 3:
+                        error_6 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_6, 'getDecisionEventsByRequestId', [])];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check ruvector-service health
+     */
+    RuVectorServiceClient.prototype.healthCheck = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, response, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        if (!this.enabled) {
+                            return [2 /*return*/, {
+                                    status: 'unhealthy',
+                                    database: false,
+                                    version: 'unknown',
+                                    latency_ms: Date.now() - startTime,
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.get('/health')];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, response.data), { latency_ms: Date.now() - startTime })];
+                    case 3:
+                        error_7 = _a.sent();
+                        logger_1.default.error({ error: error_7 }, 'RuVector service health check failed');
+                        return [2 /*return*/, {
+                                status: 'unhealthy',
+                                database: false,
+                                version: 'unknown',
+                                latency_ms: Date.now() - startTime,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Persist a governance signal to ruvector-service
+     * Phase 4 Layer 1 - Governance & FinOps
+     */
+    RuVectorServiceClient.prototype.persistGovernanceSignal = function (signal) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            logger_1.default.debug('RuVector service integration disabled');
+                            return [2 /*return*/, { accepted: true, signal_id: signal.signal_id }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.post('/api/v1/governance-signals', signal)];
+                    case 2:
+                        response = _a.sent();
+                        logger_1.default.info({
+                            signal_id: signal.signal_id,
+                            signal_type: signal.signal_type,
+                            severity: signal.severity,
+                            advisory_only: signal.advisory_only,
+                        }, 'Governance signal persisted successfully');
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_8 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_8, 'persistGovernanceSignal', {
+                                accepted: false,
+                                signal_id: signal.signal_id,
+                                error: this.getErrorMessage(error_8),
+                            })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Query governance signals
+     * Phase 4 Layer 1 - Governance & FinOps
+     */
+    RuVectorServiceClient.prototype.queryGovernanceSignals = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.enabled) {
+                            return [2 /*return*/, { signals: [], total: 0 }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.client.get('/api/v1/governance-signals', { params: query })];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        error_9 = _a.sent();
+                        return [2 /*return*/, this.handleError(error_9, 'queryGovernanceSignals', { signals: [], total: 0 })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if the client is enabled
+     */
+    RuVectorServiceClient.prototype.isEnabled = function () {
+        return this.enabled;
+    };
+    /**
+     * Handle errors with graceful degradation
+     * Decision event emission should not fail the main request
+     */
+    RuVectorServiceClient.prototype.handleError = function (error, operation, fallback) {
+        var _a, _b;
+        var errorMessage = this.getErrorMessage(error);
+        if (axios_1.default.isAxiosError(error)) {
+            if (error.code === 'ECONNREFUSED') {
+                logger_1.default.warn({ operation: operation }, 'RuVector service unavailable - continuing with graceful degradation');
+            }
+            else if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 503) {
+                logger_1.default.warn({ operation: operation }, 'RuVector service temporarily unavailable');
+            }
+            else {
+                logger_1.default.error({ operation: operation, error: errorMessage, status: (_b = error.response) === null || _b === void 0 ? void 0 : _b.status }, 'RuVector service error');
+            }
+        }
+        else {
+            logger_1.default.error({ operation: operation, error: errorMessage }, 'Unexpected error in RuVector client');
+        }
+        return fallback;
+    };
+    /**
+     * Extract error message from various error types
+     */
+    RuVectorServiceClient.prototype.getErrorMessage = function (error) {
+        var _a, _b;
+        if (axios_1.default.isAxiosError(error)) {
+            return ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message;
+        }
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    };
+    return RuVectorServiceClient;
+}());
+exports.RuVectorServiceClient = RuVectorServiceClient;
+// Export singleton instance
+exports.ruvectorServiceClient = new RuVectorServiceClient();

package/dist/bundled-agents/policy-engine-agents/dist/functions/integrations/ruvector-service/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * RuVector Service Integration
+ *
+ * Exports the RuVector service client for DecisionEvent persistence.
+ */
+__exportStar(require("./client"), exports);

package/dist/bundled-agents/policy-engine-agents/dist/functions/types/config.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Configuration Type Definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/bundled-agents/policy-engine-agents/dist/functions/types/policy.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Core Policy Type Definitions
+ * Following the SPARC specification for LLM-Policy-Engine
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionOperator = exports.DecisionType = exports.PolicyStatus = void 0;
+var PolicyStatus;
+(function (PolicyStatus) {
+    PolicyStatus["ACTIVE"] = "active";
+    PolicyStatus["DRAFT"] = "draft";
+    PolicyStatus["DEPRECATED"] = "deprecated";
+})(PolicyStatus || (exports.PolicyStatus = PolicyStatus = {}));
+var DecisionType;
+(function (DecisionType) {
+    DecisionType["ALLOW"] = "allow";
+    DecisionType["DENY"] = "deny";
+    DecisionType["WARN"] = "warn";
+    DecisionType["MODIFY"] = "modify";
+})(DecisionType || (exports.DecisionType = DecisionType = {}));
+var ConditionOperator;
+(function (ConditionOperator) {
+    ConditionOperator["EQUALS"] = "eq";
+    ConditionOperator["NOT_EQUALS"] = "ne";
+    ConditionOperator["GREATER_THAN"] = "gt";
+    ConditionOperator["GREATER_THAN_OR_EQUAL"] = "gte";
+    ConditionOperator["LESS_THAN"] = "lt";
+    ConditionOperator["LESS_THAN_OR_EQUAL"] = "lte";
+    ConditionOperator["IN"] = "in";
+    ConditionOperator["NOT_IN"] = "not_in";
+    ConditionOperator["CONTAINS"] = "contains";
+    ConditionOperator["NOT_CONTAINS"] = "not_contains";
+    ConditionOperator["MATCHES"] = "matches";
+    ConditionOperator["AND"] = "and";
+    ConditionOperator["OR"] = "or";
+    ConditionOperator["NOT"] = "not";
+})(ConditionOperator || (exports.ConditionOperator = ConditionOperator = {}));

package/dist/bundled-agents/policy-engine-agents/dist/functions/utils/config.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+/**
+ * Configuration loader
+ */
+var dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.config = {
+    nodeEnv: process.env.NODE_ENV || 'development',
+    database: {
+        url: process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:5432/llm_policy_engine',
+        poolMin: parseInt(process.env.DATABASE_POOL_MIN || '2', 10),
+        poolMax: parseInt(process.env.DATABASE_POOL_MAX || '10', 10),
+        ssl: process.env.DATABASE_SSL === 'true',
+    },
+    redis: {
+        url: process.env.REDIS_URL || 'redis://localhost:6379',
+        password: process.env.REDIS_PASSWORD,
+        db: parseInt(process.env.REDIS_DB || '0', 10),
+        keyPrefix: process.env.REDIS_KEY_PREFIX || 'llm-policy:',
+    },
+    cache: {
+        ttl: parseInt(process.env.CACHE_TTL || '300', 10),
+        maxSize: parseInt(process.env.CACHE_MAX_SIZE || '10000', 10),
+        enabled: process.env.CACHE_ENABLED !== 'false',
+    },
+    server: {
+        port: parseInt(process.env.PORT || '3000', 10),
+        grpcPort: parseInt(process.env.GRPC_PORT || '50051', 10),
+        host: process.env.HOST || '0.0.0.0',
+    },
+    security: {
+        jwtSecret: process.env.JWT_SECRET || 'your-secret-key-change-in-production',
+        jwtExpiresIn: process.env.JWT_EXPIRES_IN || '24h',
+        apiKeyHeader: process.env.API_KEY_HEADER || 'X-API-Key',
+    },
+    rateLimit: {
+        windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '60000', 10),
+        maxRequests: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100', 10),
+    },
+    observability: {
+        metricsPort: parseInt(process.env.METRICS_PORT || '9090', 10),
+        metricsPath: process.env.METRICS_PATH || '/metrics',
+        logLevel: (process.env.LOG_LEVEL || 'info'),
+        traceEnabled: process.env.TRACE_ENABLED === 'true',
+    },
+    integrations: {
+        llmShieldUrl: process.env.LLM_SHIELD_URL,
+        llmCostOpsUrl: process.env.LLM_COSTOPS_URL,
+        llmGovernanceUrl: process.env.LLM_GOVERNANCE_URL,
+        llmEdgeAgentUrl: process.env.LLM_EDGE_AGENT_URL,
+        // Phase 2B: Upstream consumption adapters
+        llmSchemaRegistryUrl: process.env.LLM_SCHEMA_REGISTRY_URL,
+        llmConfigManagerUrl: process.env.LLM_CONFIG_MANAGER_URL,
+        llmObservatoryUrl: process.env.LLM_OBSERVATORY_URL,
+        // RuVector Service for DecisionEvent persistence
+        ruvectorServiceUrl: process.env.RUVECTOR_SERVICE_URL,
+    },
+    environment: process.env.ENVIRONMENT || process.env.NODE_ENV || 'development',
+    performance: {
+        maxPolicySizeMB: parseInt(process.env.MAX_POLICY_SIZE_MB || '10', 10),
+        maxEvaluationTimeMs: parseInt(process.env.MAX_EVALUATION_TIME_MS || '100', 10),
+        enableParallelEvaluation: process.env.ENABLE_PARALLEL_EVALUATION !== 'false',
+    },
+};
+exports.default = exports.config;