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

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

@@ -0,0 +1,833 @@
+"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;