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

package/dist/bundled-agents/policy-engine-agents/dist/functions/agents/approval-routing/agent.js

@@ -1,833 +0,0 @@
-"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.ApprovalRoutingAgent = exports.DECISION_TYPE = exports.AGENT_VERSION = exports.AGENT_ID = void 0;
-/**
- * Approval Routing Agent
- *
- * CLASSIFICATION: APPROVAL GATING
- *
- * PURPOSE:
- * Determine required approval paths for policy-gated actions. Routes
- * approval requests to appropriate approvers based on configured rules.
- *
- * SCOPE:
- * - Evaluate approval rules against action context
- * - Determine required approvers
- * - Build approval chains for multi-step workflows
- * - Handle escalation paths
- * - Check auto-approval conditions
- *
- * DECISION_TYPE: "approval_routing_decision"
- *
- * NON-RESPONSIBILITIES (MUST NOT):
- * - Execute approval workflows
- * - Send notifications directly
- * - Store approval state
- * - Modify approval rules at runtime
- * - Access user management systems directly
- * - Connect directly to databases
- * - Execute SQL queries
- * - Track approval progress
- *
- * This agent follows the LLM-Policy-Engine Agent Infrastructure Constitution.
- */
-var crypto_1 = require("crypto");
-var uuid_1 = require("uuid");
-var ruvector_service_1 = require("../../integrations/ruvector-service");
-var observatory_1 = require("../../integrations/observatory");
-var logger_1 = __importDefault(require("../../utils/logger"));
-var config_1 = require("../../utils/config");
-/**
- * Agent metadata constants
- */
-exports.AGENT_ID = 'approval-routing-agent';
-exports.AGENT_VERSION = '1.0.0';
-exports.DECISION_TYPE = 'approval_routing_decision';
-/**
- * Default approval rules (loaded from configuration in production)
- */
-var DEFAULT_RULES = [
-    {
-        rule_id: 'high-value-model-access',
-        rule_name: 'High-Value Model Access',
-        description: 'Requires approval for access to premium LLM models',
-        condition: {
-            match: [
-                { field: 'resource_type', operator: 'equals', value: 'model' },
-                { field: 'details.tier', operator: 'equals', value: 'premium' },
-            ],
-            operator: 'all',
-        },
-        required_approvers: 1,
-        approver_pool: [],
-        timeout_seconds: 3600,
-        escalation_config: {
-            enabled: true,
-            levels: [],
-            max_escalations: 2,
-            final_action: 'deny',
-        },
-        priority: 100,
-        active: true,
-    },
-];
-/**
- * Approval Routing Agent
- *
- * Stateless agent that evaluates approval requirements and produces
- * ApprovalDecisionEvents.
- */
-var ApprovalRoutingAgent = /** @class */ (function () {
-    function ApprovalRoutingAgent(rules) {
-        if (rules === void 0) { rules = DEFAULT_RULES; }
-        this.rules = rules;
-        this.environment = config_1.config.environment || 'development';
-    }
-    /**
-     * Load approval rules
-     */
-    ApprovalRoutingAgent.prototype.loadRules = function (rules) {
-        this.rules = rules;
-    };
-    /**
-     * Add a single rule
-     */
-    ApprovalRoutingAgent.prototype.addRule = function (rule) {
-        this.rules.push(rule);
-    };
-    /**
-     * PRIMARY ENTRY POINT: Evaluate approval requirements
-     *
-     * This method:
-     * 1. Validates inputs
-     * 2. Evaluates approval rules
-     * 3. Determines required approvers
-     * 4. Builds approval chain
-     * 5. Calculates confidence
-     * 6. Emits exactly ONE ApprovalDecisionEvent to ruvector-service
-     * 7. Emits telemetry to Observatory
-     * 8. Returns deterministic, machine-readable output
-     */
-    ApprovalRoutingAgent.prototype.evaluate = function (input) {
-        return __awaiter(this, void 0, void 0, function () {
-            var startTime, eventId, traceId, matchedRules, output, confidence, inputsHash, decisionEvent, errorEvent;
-            return __generator(this, function (_a) {
-                startTime = performance.now();
-                eventId = (0, uuid_1.v4)();
-                traceId = (0, uuid_1.v4)();
-                logger_1.default.info({ eventId: eventId, requestId: input.request_id, traceId: traceId }, 'Approval Routing Agent: Starting evaluation');
-                try {
-                    matchedRules = this.findMatchingRules(input);
-                    output = this.buildRoutingOutput(input, matchedRules, startTime);
-                    confidence = this.calculateConfidence(matchedRules, output);
-                    inputsHash = this.hashInputs(input);
-                    decisionEvent = {
-                        event_id: eventId,
-                        agent_id: exports.AGENT_ID,
-                        agent_version: exports.AGENT_VERSION,
-                        decision_type: exports.DECISION_TYPE,
-                        inputs_hash: inputsHash,
-                        outputs: output,
-                        confidence: confidence,
-                        rules_applied: matchedRules,
-                        execution_ref: {
-                            request_id: input.request_id,
-                            trace_id: traceId,
-                            span_id: (0, uuid_1.v4)(),
-                            environment: this.environment,
-                        },
-                        timestamp: new Date().toISOString(),
-                        metadata: {
-                            cached: false,
-                            engine_version: exports.AGENT_VERSION,
-                            mode: input.dry_run ? 'dry-run' : 'real-time',
-                            source: 'approval-routing-agent',
-                            sla_tier: input.priority || 'normal',
-                        },
-                    };
-                    // Persist DecisionEvent to ruvector-service (async, non-blocking)
-                    this.persistDecisionEvent(decisionEvent).catch(function (error) {
-                        logger_1.default.error({ error: error, eventId: eventId }, 'Failed to persist ApprovalDecisionEvent');
-                    });
-                    // Emit telemetry to Observatory (async, non-blocking)
-                    this.emitTelemetry(decisionEvent, startTime).catch(function (error) {
-                        logger_1.default.error({ error: error, eventId: eventId }, 'Failed to emit telemetry');
-                    });
-                    logger_1.default.info({
-                        eventId: eventId,
-                        decision: output.decision,
-                        requiredApprovers: output.required_approvers.length,
-                        chainSteps: output.approval_chain.length,
-                        confidence: confidence,
-                        evaluationTimeMs: output.evaluation_time_ms,
-                    }, 'Approval Routing Agent: Evaluation completed');
-                    return [2 /*return*/, decisionEvent];
-                }
-                catch (error) {
-                    errorEvent = this.createErrorDecisionEvent(eventId, input, error, startTime);
-                    this.persistDecisionEvent(errorEvent).catch(function (persistError) {
-                        logger_1.default.error({ persistError: persistError, eventId: eventId }, 'Failed to persist error DecisionEvent');
-                    });
-                    throw error;
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * ROUTE: Determine approval routing for an action
-     */
-    ApprovalRoutingAgent.prototype.route = function (input) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.evaluate(input)];
-            });
-        });
-    };
-    /**
-     * RESOLVE: Resolve approval conflicts
-     */
-    ApprovalRoutingAgent.prototype.resolve = function (input) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // Resolution uses the same evaluation logic but may add trace info
-                return [2 /*return*/, this.evaluate(__assign(__assign({}, input), { trace: true }))];
-            });
-        });
-    };
-    /**
-     * Get approval status for a request
-     * @param requestId - The approval request ID to look up
-     */
-    ApprovalRoutingAgent.prototype.getStatus = function (requestId) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // In production, this would query ruvector-service
-                logger_1.default.info({ requestId: requestId }, 'Getting approval status');
-                return [2 /*return*/, null];
-            });
-        });
-    };
-    /**
-     * Find rules that match the input
-     */
-    ApprovalRoutingAgent.prototype.findMatchingRules = function (input) {
-        var matched = [];
-        for (var _i = 0, _a = this.rules; _i < _a.length; _i++) {
-            var rule = _a[_i];
-            if (!rule.active)
-                continue;
-            // Check if rule IDs filter is specified
-            if (input.approval_rules && !input.approval_rules.includes(rule.rule_id)) {
-                continue;
-            }
-            // Evaluate rule conditions
-            if (this.evaluateRuleConditions(rule, input)) {
-                matched.push(rule);
-            }
-        }
-        // Sort by priority (higher priority first)
-        return matched.sort(function (a, b) { return b.priority - a.priority; });
-    };
-    /**
-     * Evaluate rule conditions against input
-     */
-    ApprovalRoutingAgent.prototype.evaluateRuleConditions = function (rule, input) {
-        var _this = this;
-        var _a = rule.condition, match = _a.match, operator = _a.operator;
-        var results = match.map(function (condition) {
-            var value = _this.getFieldValue(input, condition.field);
-            return _this.evaluateCondition(value, condition.operator, condition.value);
-        });
-        if (operator === 'all') {
-            return results.every(function (r) { return r; });
-        }
-        else {
-            return results.some(function (r) { return r; });
-        }
-    };
-    /**
-     * Get field value from input using dot notation
-     */
-    ApprovalRoutingAgent.prototype.getFieldValue = function (input, field) {
-        var parts = field.split('.');
-        var value = input.action_context;
-        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
-            var part = parts_1[_i];
-            if (value && typeof value === 'object' && part in value) {
-                value = value[part];
-            }
-            else {
-                return undefined;
-            }
-        }
-        return value;
-    };
-    /**
-     * Evaluate a single condition
-     */
-    ApprovalRoutingAgent.prototype.evaluateCondition = function (value, operator, expected) {
-        switch (operator) {
-            case 'equals':
-                return value === expected;
-            case 'not_equals':
-                return value !== expected;
-            case 'contains':
-                if (typeof value === 'string' && typeof expected === 'string') {
-                    return value.includes(expected);
-                }
-                if (Array.isArray(value)) {
-                    return value.includes(expected);
-                }
-                return false;
-            case 'greater_than':
-                return typeof value === 'number' && typeof expected === 'number' && value > expected;
-            case 'less_than':
-                return typeof value === 'number' && typeof expected === 'number' && value < expected;
-            case 'in':
-                return Array.isArray(expected) && expected.includes(value);
-            case 'not_in':
-                return Array.isArray(expected) && !expected.includes(value);
-            case 'matches':
-                if (typeof value === 'string' && typeof expected === 'string') {
-                    try {
-                        return new RegExp(expected).test(value);
-                    }
-                    catch (_a) {
-                        return false;
-                    }
-                }
-                return false;
-            default:
-                return false;
-        }
-    };
-    /**
-     * Build the routing output from matched rules
-     */
-    ApprovalRoutingAgent.prototype.buildRoutingOutput = function (input, matchedRules, startTime) {
-        // Check for auto-approval first
-        var autoApproveResult = this.checkAutoApproval(input, matchedRules);
-        if (autoApproveResult) {
-            return {
-                decision: 'auto_approved',
-                required_approvers: [],
-                approval_chain: [],
-                timeout_seconds: 0,
-                escalation_path: [],
-                justification_required: false,
-                routing_metadata: {
-                    rules_evaluated: this.rules.map(function (r) { return r.rule_id; }),
-                    rules_matched: matchedRules.map(function (r) { return r.rule_id; }),
-                    auto_approve_reason: autoApproveResult,
-                },
-                evaluation_time_ms: performance.now() - startTime,
-            };
-        }
-        // If no rules matched, approve by default (bypass)
-        if (matchedRules.length === 0) {
-            return {
-                decision: 'approval_bypassed',
-                required_approvers: [],
-                approval_chain: [],
-                timeout_seconds: 0,
-                escalation_path: [],
-                justification_required: false,
-                routing_metadata: {
-                    rules_evaluated: this.rules.map(function (r) { return r.rule_id; }),
-                    rules_matched: [],
-                    bypass_reason: 'No matching approval rules',
-                },
-                evaluation_time_ms: performance.now() - startTime,
-            };
-        }
-        // Build approval chain from matched rules
-        var approvalChain = this.buildApprovalChain(matchedRules);
-        var requiredApprovers = this.collectRequiredApprovers(matchedRules);
-        var escalationPath = this.buildEscalationPath(matchedRules);
-        var totalTimeout = this.calculateTotalTimeout(matchedRules);
-        // Determine decision based on priority
-        var decision = this.isHighPriority(input)
-            ? 'escalation_required'
-            : 'approval_required';
-        return {
-            decision: decision,
-            required_approvers: requiredApprovers,
-            approval_chain: approvalChain,
-            timeout_seconds: totalTimeout,
-            escalation_path: escalationPath,
-            justification_required: this.requiresJustification(matchedRules),
-            routing_metadata: {
-                rules_evaluated: this.rules.map(function (r) { return r.rule_id; }),
-                rules_matched: matchedRules.map(function (r) { return r.rule_id; }),
-                risk_score: this.calculateRiskScore(input, matchedRules),
-                compliance_tags: this.getComplianceTags(matchedRules),
-            },
-            evaluation_time_ms: performance.now() - startTime,
-        };
-    };
-    /**
-     * Check if auto-approval conditions are met
-     */
-    ApprovalRoutingAgent.prototype.checkAutoApproval = function (input, matchedRules) {
-        var _loop_1 = function (rule) {
-            if (!rule.auto_approve_conditions)
-                return "continue";
-            var conditions = rule.auto_approve_conditions;
-            // Check allowed roles
-            if (conditions.allowed_roles && conditions.allowed_roles.length > 0) {
-                var hasAllowedRole = input.requester.roles.some(function (role) {
-                    return conditions.allowed_roles.includes(role);
-                });
-                if (hasAllowedRole) {
-                    return { value: "Requester has auto-approve role: ".concat(input.requester.roles.join(', ')) };
-                }
-            }
-            // Check allowed resource types
-            if (conditions.allowed_resource_types && conditions.allowed_resource_types.length > 0) {
-                if (conditions.allowed_resource_types.includes(input.action_context.resource_type)) {
-                    return { value: "Resource type ".concat(input.action_context.resource_type, " is auto-approved") };
-                }
-            }
-            // Check allowed operations
-            if (conditions.allowed_operations && conditions.allowed_operations.length > 0) {
-                if (conditions.allowed_operations.includes(input.action_context.operation)) {
-                    return { value: "Operation ".concat(input.action_context.operation, " is auto-approved") };
-                }
-            }
-            // Check max_value
-            if (conditions.max_value !== undefined) {
-                var value = this_1.getFieldValue(input, 'details.value');
-                if (typeof value === 'number' && value <= conditions.max_value) {
-                    return { value: "Value ".concat(value, " is within auto-approve threshold of ").concat(conditions.max_value) };
-                }
-            }
-            // Check time restrictions
-            if (conditions.time_restrictions) {
-                var now = new Date();
-                var hour = now.getHours();
-                var _a = conditions.time_restrictions, start_hour = _a.start_hour, end_hour = _a.end_hour, business_days_only = _a.business_days_only;
-                var isBusinessHours = hour >= start_hour && hour < end_hour;
-                var isBusinessDay = now.getDay() !== 0 && now.getDay() !== 6;
-                if (isBusinessHours && (!business_days_only || isBusinessDay)) {
-                    return { value: "Auto-approved during business hours" };
-                }
-            }
-        };
-        var this_1 = this;
-        for (var _i = 0, matchedRules_1 = matchedRules; _i < matchedRules_1.length; _i++) {
-            var rule = matchedRules_1[_i];
-            var state_1 = _loop_1(rule);
-            if (typeof state_1 === "object")
-                return state_1.value;
-        }
-        return null;
-    };
-    /**
-     * Build approval chain from rules
-     */
-    ApprovalRoutingAgent.prototype.buildApprovalChain = function (rules) {
-        var chain = [];
-        var stepOrder = 1;
-        for (var _i = 0, rules_1 = rules; _i < rules_1.length; _i++) {
-            var rule = rules_1[_i];
-            if (rule.approver_pool.length === 0)
-                continue;
-            chain.push({
-                step_id: (0, uuid_1.v4)(),
-                step_order: stepOrder++,
-                step_type: rule.required_approvers > 1 ? 'parallel' : 'any_of',
-                step_name: rule.rule_name,
-                approvers: rule.approver_pool.filter(function (a) { return a.available !== false; }),
-                required_approvals: rule.required_approvers,
-                timeout_seconds: rule.timeout_seconds,
-                escalation_on_timeout: rule.escalation_config.enabled,
-                source_rule_id: rule.rule_id,
-                instructions: rule.description,
-            });
-        }
-        return chain;
-    };
-    /**
-     * Collect all required approvers from rules
-     */
-    ApprovalRoutingAgent.prototype.collectRequiredApprovers = function (rules) {
-        var approvers = new Map();
-        for (var _i = 0, rules_2 = rules; _i < rules_2.length; _i++) {
-            var rule = rules_2[_i];
-            for (var _a = 0, _b = rule.approver_pool; _a < _b.length; _a++) {
-                var approver = _b[_a];
-                if (approver.available !== false && !approvers.has(approver.id)) {
-                    approvers.set(approver.id, approver);
-                }
-            }
-        }
-        return Array.from(approvers.values());
-    };
-    /**
-     * Build escalation path from rules
-     */
-    ApprovalRoutingAgent.prototype.buildEscalationPath = function (rules) {
-        var levels = new Map();
-        for (var _i = 0, rules_3 = rules; _i < rules_3.length; _i++) {
-            var rule = rules_3[_i];
-            if (!rule.escalation_config.enabled)
-                continue;
-            for (var _a = 0, _b = rule.escalation_config.levels; _a < _b.length; _a++) {
-                var level = _b[_a];
-                var existing = levels.get(level.level);
-                if (!existing) {
-                    levels.set(level.level, __assign({}, level));
-                }
-                else {
-                    // Merge approvers at the same level
-                    var existingIds = new Set(existing.approvers.map(function (a) { return a.id; }));
-                    for (var _c = 0, _d = level.approvers; _c < _d.length; _c++) {
-                        var approver = _d[_c];
-                        if (!existingIds.has(approver.id)) {
-                            existing.approvers.push(approver);
-                        }
-                    }
-                    // Use shorter timeout
-                    existing.timeout_seconds = Math.min(existing.timeout_seconds, level.timeout_seconds);
-                }
-            }
-        }
-        return Array.from(levels.values()).sort(function (a, b) { return a.level - b.level; });
-    };
-    /**
-     * Calculate total timeout from rules
-     */
-    ApprovalRoutingAgent.prototype.calculateTotalTimeout = function (rules) {
-        var total = 0;
-        for (var _i = 0, rules_4 = rules; _i < rules_4.length; _i++) {
-            var rule = rules_4[_i];
-            total += rule.timeout_seconds;
-            // Add escalation timeouts
-            if (rule.escalation_config.enabled) {
-                for (var _a = 0, _b = rule.escalation_config.levels; _a < _b.length; _a++) {
-                    var level = _b[_a];
-                    total += level.timeout_seconds;
-                }
-            }
-        }
-        return total;
-    };
-    /**
-     * Check if request is high priority
-     */
-    ApprovalRoutingAgent.prototype.isHighPriority = function (input) {
-        return input.priority === 'critical' || input.priority === 'high' || input.priority === 'emergency';
-    };
-    /**
-     * Check if justification is required
-     */
-    ApprovalRoutingAgent.prototype.requiresJustification = function (rules) {
-        // Require justification for high-priority rules (priority >= 80)
-        return rules.some(function (r) { return r.priority >= 80; });
-    };
-    /**
-     * Calculate risk score based on action and rules
-     */
-    ApprovalRoutingAgent.prototype.calculateRiskScore = function (input, rules) {
-        var score = 0;
-        // Base score from operation type
-        var operation = input.action_context.operation;
-        if (operation === 'delete')
-            score += 30;
-        else if (operation === 'update')
-            score += 20;
-        else if (operation === 'execute')
-            score += 25;
-        else if (operation === 'create')
-            score += 15;
-        // Add score based on matched rules
-        score += rules.length * 10;
-        // Add score based on rule priority
-        for (var _i = 0, rules_5 = rules; _i < rules_5.length; _i++) {
-            var rule = rules_5[_i];
-            score += Math.floor(rule.priority / 10);
-        }
-        // Cap at 100
-        return Math.min(100, score);
-    };
-    /**
-     * Get compliance tags from rules
-     */
-    ApprovalRoutingAgent.prototype.getComplianceTags = function (rules) {
-        var tags = new Set();
-        for (var _i = 0, rules_6 = rules; _i < rules_6.length; _i++) {
-            var rule = rules_6[_i];
-            if (rule.tags) {
-                for (var _a = 0, _b = rule.tags; _a < _b.length; _a++) {
-                    var tag = _b[_a];
-                    tags.add(tag);
-                }
-            }
-        }
-        return Array.from(tags);
-    };
-    /**
-     * Calculate confidence score
-     *
-     * Confidence is based on:
-     * - Number of rules evaluated
-     * - Clarity of decision (single rule vs. multiple)
-     * - Auto-approval certainty
-     */
-    ApprovalRoutingAgent.prototype.calculateConfidence = function (rules, output) {
-        var confidence = 1.0;
-        // Reduce confidence if no rules matched (default bypass)
-        if (rules.length === 0) {
-            confidence *= 0.85;
-        }
-        // Reduce confidence for multiple conflicting rules
-        if (rules.length > 3) {
-            confidence *= 0.95;
-        }
-        // Reduce confidence for escalation decisions
-        if (output.decision === 'escalation_required') {
-            confidence *= 0.9;
-        }
-        // Increase confidence for auto-approval with clear reason
-        if (output.decision === 'auto_approved' && output.routing_metadata.auto_approve_reason) {
-            confidence = Math.min(confidence * 1.05, 0.98);
-        }
-        // Reduce confidence if approvers are unavailable
-        var totalApprovers = rules.reduce(function (sum, r) { return sum + r.approver_pool.length; }, 0);
-        var availableApprovers = rules.reduce(function (sum, r) { return sum + r.approver_pool.filter(function (a) { return a.available !== false; }).length; }, 0);
-        if (totalApprovers > 0 && availableApprovers < totalApprovers) {
-            confidence *= availableApprovers / totalApprovers;
-        }
-        return Math.max(0, Math.min(1, confidence));
-    };
-    /**
-     * Create SHA256 hash of inputs for deduplication
-     */
-    ApprovalRoutingAgent.prototype.hashInputs = function (input) {
-        var serialized = JSON.stringify({
-            request_id: input.request_id,
-            action_context: input.action_context,
-            requester: input.requester,
-            approval_rules: input.approval_rules,
-        });
-        return (0, crypto_1.createHash)('sha256').update(serialized).digest('hex').substring(0, 16);
-    };
-    /**
-     * Persist DecisionEvent to ruvector-service
-     */
-    ApprovalRoutingAgent.prototype.persistDecisionEvent = function (event) {
-        return __awaiter(this, void 0, void 0, function () {
-            var baseEvent, ack;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        baseEvent = event;
-                        return [4 /*yield*/, ruvector_service_1.ruvectorServiceClient.persistDecisionEvent(baseEvent)];
-                    case 1:
-                        ack = _a.sent();
-                        if (!ack.accepted) {
-                            logger_1.default.warn({ event_id: event.event_id, error: ack.error }, 'ApprovalDecisionEvent persistence was not accepted');
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Emit telemetry to Observatory
-     */
-    ApprovalRoutingAgent.prototype.emitTelemetry = function (event, startTime) {
-        return __awaiter(this, void 0, void 0, function () {
-            var telemetryEvent;
-            var _a, _b, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        telemetryEvent = {
-                            eventId: event.event_id,
-                            timestamp: event.timestamp,
-                            traceId: event.execution_ref.trace_id,
-                            spanId: event.execution_ref.span_id,
-                            policyId: ((_a = event.rules_applied[0]) === null || _a === void 0 ? void 0 : _a.rule_id) || 'none',
-                            ruleId: (_b = event.rules_applied[0]) === null || _b === void 0 ? void 0 : _b.rule_id,
-                            decision: this.mapDecisionToTelemetry(event.outputs.decision),
-                            durationMs: performance.now() - startTime,
-                            cached: ((_c = event.metadata) === null || _c === void 0 ? void 0 : _c.cached) || false,
-                            context: {
-                                agent_id: event.agent_id,
-                                environment: event.execution_ref.environment,
-                            },
-                            labels: {
-                                agent_version: event.agent_version,
-                                decision_type: event.decision_type,
-                                priority: ((_d = event.metadata) === null || _d === void 0 ? void 0 : _d.sla_tier) || 'normal',
-                            },
-                        };
-                        return [4 /*yield*/, observatory_1.observatoryClient.emitEvaluationEvent(telemetryEvent)];
-                    case 1:
-                        _e.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Map ApprovalDecisionOutcome to Observatory DecisionOutcome
-     */
-    ApprovalRoutingAgent.prototype.mapDecisionToTelemetry = function (decision) {
-        switch (decision) {
-            case 'auto_approved':
-            case 'approval_bypassed':
-                return 'allow';
-            case 'approval_required':
-            case 'pending_approval':
-                return 'warn';
-            case 'escalation_required':
-                return 'modify';
-            default:
-                return 'warn';
-        }
-    };
-    /**
-     * Create error DecisionEvent for failure cases
-     */
-    ApprovalRoutingAgent.prototype.createErrorDecisionEvent = function (eventId, input, error, startTime) {
-        var errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            event_id: eventId,
-            agent_id: exports.AGENT_ID,
-            agent_version: exports.AGENT_VERSION,
-            decision_type: exports.DECISION_TYPE,
-            inputs_hash: this.hashInputs(input),
-            outputs: {
-                decision: 'pending_approval',
-                required_approvers: [],
-                approval_chain: [],
-                timeout_seconds: 3600,
-                escalation_path: [],
-                justification_required: false,
-                routing_metadata: {
-                    rules_evaluated: [],
-                    rules_matched: [],
-                    escalation_reason: "Evaluation error: ".concat(errorMessage),
-                },
-                evaluation_time_ms: performance.now() - startTime,
-            },
-            confidence: 0,
-            rules_applied: [],
-            execution_ref: {
-                request_id: input.request_id,
-                trace_id: (0, uuid_1.v4)(),
-                environment: this.environment,
-            },
-            timestamp: new Date().toISOString(),
-            metadata: {
-                cached: false,
-                engine_version: exports.AGENT_VERSION,
-                mode: input.dry_run ? 'dry-run' : 'real-time',
-                source: 'approval-routing-agent',
-            },
-        };
-    };
-    /**
-     * Get agent registration metadata
-     */
-    ApprovalRoutingAgent.getRegistration = function () {
-        return {
-            agent_id: exports.AGENT_ID,
-            agent_version: exports.AGENT_VERSION,
-            agent_type: 'approval_gating',
-            agent_name: 'Approval Routing Agent',
-            description: 'Determine required approval paths for policy-gated actions. Routes approval requests to appropriate approvers based on configured rules.',
-            input_schema: 'ApprovalRoutingInput',
-            output_schema: 'ApprovalDecisionEvent',
-            decision_types: [exports.DECISION_TYPE],
-            cli_contract: {
-                command: 'agent',
-                subcommands: ['evaluate', 'route', 'resolve'],
-                required_flags: ['--action-context', '--requester', '--request-id'],
-                optional_flags: ['--rules', '--priority', '--dry-run', '--trace', '--json'],
-            },
-            consumers: [
-                'llm-orchestrator',
-                'approval-workflow-service',
-                'notification-service',
-                'audit-service',
-                'governance-systems',
-            ],
-            non_responsibilities: [
-                'Execute approval workflows',
-                'Send notifications directly',
-                'Store approval state',
-                'Modify approval rules at runtime',
-                'Access user management systems directly',
-                'Track approval progress',
-                'Connect directly to databases',
-                'Execute SQL queries',
-            ],
-            failure_modes: [
-                'Rule evaluation timeout',
-                'Invalid action context format',
-                'Missing required fields',
-                'Rule parsing error',
-                'ruvector-service unavailable (graceful degradation)',
-                'Observatory unavailable (graceful degradation)',
-                'No approvers available',
-            ],
-            registered_at: new Date().toISOString(),
-        };
-    };
-    return ApprovalRoutingAgent;
-}());
-exports.ApprovalRoutingAgent = ApprovalRoutingAgent;