palaryn 0.1.0

package/dist/tests/unit/opa-engine.test.js

@@ -0,0 +1,1813 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const opa_engine_1 = require("../../src/policy/opa-engine");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Build a minimal valid ToolCall for testing. */
+function buildToolCall(overrides = {}) {
+    return {
+        tool_call_id: 'tc-opa-001',
+        task_id: 'task-opa-001',
+        workspace_id: 'ws-default',
+        actor: {
+            type: 'agent',
+            id: 'agent-1',
+            ...(overrides.actor || {}),
+        },
+        source: {
+            platform: 'langgraph',
+            ...(overrides.source || {}),
+        },
+        tool: {
+            name: 'http.request',
+            capability: 'read',
+            ...(overrides.tool || {}),
+        },
+        args: {
+            method: 'GET',
+            url: 'https://api.github.com/repos',
+            ...(overrides.args || {}),
+        },
+        context: overrides.context,
+        constraints: overrides.constraints,
+        timestamp: overrides.timestamp,
+    };
+}
+// ---------------------------------------------------------------------------
+// Remote OPA evaluation (mock HTTP server)
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Remote evaluation', () => {
+    let opaServer;
+    let opaPort;
+    let serverResponse;
+    let lastRequestBody;
+    let serverShouldTimeout;
+    let serverShouldError;
+    let serverShouldReturnInvalidJson;
+    beforeAll((done) => {
+        opaServer = http.createServer((req, res) => {
+            if (serverShouldTimeout) {
+                // Do nothing; let the client timeout
+                return;
+            }
+            if (serverShouldError) {
+                res.destroy();
+                return;
+            }
+            if (serverShouldReturnInvalidJson) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end('not valid json{{{');
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => body += chunk);
+            req.on('end', () => {
+                lastRequestBody = JSON.parse(body);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(serverResponse));
+            });
+        });
+        opaServer.listen(0, '127.0.0.1', () => {
+            opaPort = opaServer.address().port;
+            done();
+        });
+    });
+    afterAll((done) => {
+        opaServer.close(done);
+    });
+    beforeEach(() => {
+        serverResponse = { result: { decision: 'allow' } };
+        lastRequestBody = null;
+        serverShouldTimeout = false;
+        serverShouldError = false;
+        serverShouldReturnInvalidJson = false;
+    });
+    test('should evaluate allow decision from OPA server', async () => {
+        serverResponse = {
+            result: {
+                decision: 'allow',
+                rule_id: 'opa_allow_reads',
+                rule_name: 'Allow read operations',
+                reasons: ['Read operations are permitted'],
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+        expect(result.rule_id).toBe('opa_allow_reads');
+        expect(result.rule_name).toBe('Allow read operations');
+        expect(result.reasons).toEqual(['Read operations are permitted']);
+    });
+    test('should evaluate deny decision from OPA server', async () => {
+        serverResponse = {
+            result: {
+                decision: 'deny',
+                rule_id: 'opa_deny_writes',
+                rule_name: 'Deny write operations',
+                reasons: ['Write operations are blocked in this environment'],
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const tc = buildToolCall({ tool: { name: 'http.request', capability: 'write' } });
+        const result = await engine.evaluate(tc);
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_deny_writes');
+        expect(result.reasons).toContain('Write operations are blocked in this environment');
+    });
+    test('should evaluate transform decision with transformations', async () => {
+        serverResponse = {
+            result: {
+                decision: 'transform',
+                rule_id: 'opa_strip_auth',
+                rule_name: 'Strip auth headers',
+                reasons: ['Auth headers must be stripped for external calls'],
+                transformations: [
+                    { type: 'strip_header', target: 'Authorization' },
+                ],
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('transform');
+        expect(result.transformations).toHaveLength(1);
+        expect(result.transformations[0]).toEqual({ type: 'strip_header', target: 'Authorization' });
+    });
+    test('should evaluate require_approval decision with approval info', async () => {
+        serverResponse = {
+            result: {
+                decision: 'require_approval',
+                rule_id: 'opa_admin_approval',
+                rule_name: 'Admin operations need approval',
+                reasons: ['Admin capability requires human approval'],
+                approval: { scope: 'security', ttl_seconds: 7200, reason: 'Admin operation detected' },
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const tc = buildToolCall({ tool: { name: 'http.request', capability: 'admin' } });
+        const result = await engine.evaluate(tc);
+        expect(result.decision).toBe('require_approval');
+        expect(result.approval).toEqual({ scope: 'security', ttl_seconds: 7200, reason: 'Admin operation detected' });
+    });
+    test('should send correct input format to OPA server', async () => {
+        serverResponse = { result: { decision: 'allow' } };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const tc = buildToolCall({
+            tool: { name: 'http.get', capability: 'read', version: '2.0' },
+            context: { purpose: 'test', labels: ['ci'] },
+        });
+        await engine.evaluate(tc);
+        expect(lastRequestBody).toBeDefined();
+        expect(lastRequestBody.input).toBeDefined();
+        expect(lastRequestBody.input.tool_call_id).toBe('tc-opa-001');
+        expect(lastRequestBody.input.task_id).toBe('task-opa-001');
+        expect(lastRequestBody.input.tool.name).toBe('http.get');
+        expect(lastRequestBody.input.tool.capability).toBe('read');
+        expect(lastRequestBody.input.context.labels).toEqual(['ci']);
+    });
+    test('should use custom policy_path', async () => {
+        serverResponse = { result: { decision: 'allow' } };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            policy_path: 'v1/data/custom/path',
+        });
+        await engine.evaluate(buildToolCall());
+        // If the server received the request successfully, it means the correct path was used
+        expect(lastRequestBody).toBeDefined();
+    });
+    test('should fall back when OPA server times out', async () => {
+        serverShouldTimeout = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            timeout_ms: 200,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toContain('OPA server error');
+    });
+    test('should fall back when OPA server returns error', async () => {
+        serverShouldError = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toContain('OPA server error');
+    });
+    test('should fall back when OPA returns invalid JSON', async () => {
+        serverShouldReturnInvalidJson = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toContain('OPA server error');
+    });
+    test('should fall back when OPA returns empty result', async () => {
+        serverResponse = {};
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toBe('OPA returned empty result');
+    });
+    test('should fall back when OPA returns result without decision', async () => {
+        serverResponse = { result: { rule_id: 'some_rule' } };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        // normalizeDecision handles undefined → fallback
+        expect(result.decision).toBe('deny');
+    });
+    test('should use allow as fallback decision when configured', async () => {
+        serverShouldError = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'allow',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+        expect(result.rule_id).toBe('opa_fallback');
+    });
+    test('should return OPA server unreachable fallback for invalid URL', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: 'http://127.0.0.1:1', // Port 1 is unlikely to have anything listening
+            timeout_ms: 500,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+    });
+    test('should use default values for reasons when OPA provides a string', async () => {
+        serverResponse = {
+            result: {
+                decision: 'deny',
+                reasons: 'single reason string',
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.reasons).toEqual(['single reason string']);
+    });
+    test('should provide default reasons when OPA returns none', async () => {
+        serverResponse = {
+            result: {
+                decision: 'allow',
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.reasons).toEqual(['OPA decision: allow']);
+    });
+    test('should provide default rule_id and rule_name when OPA returns none', async () => {
+        serverResponse = {
+            result: {
+                decision: 'allow',
+            },
+        };
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.rule_id).toBe('opa_policy');
+        expect(result.rule_name).toBe('OPA policy evaluation');
+    });
+});
+// ---------------------------------------------------------------------------
+// Local Rego evaluation
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Local Rego evaluation', () => {
+    test('should deny by default with basic deny policy', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_local');
+    });
+    test('should allow by default with basic allow policy', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "allow"
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+    });
+    test('should evaluate allow rule with capability condition', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.tool.capability == "read"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        // Read capability should be allowed
+        const readResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'read' } }));
+        expect(readResult.decision).toBe('allow');
+        // Write capability should be denied
+        const writeResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'write' } }));
+        expect(writeResult.decision).toBe('deny');
+    });
+    test('should evaluate deny rule for specific tool name', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "allow"
+      decision = "deny" {
+        input.tool.name == "dangerous"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        // Normal tool should be allowed
+        const normalResult = await engine.evaluate(buildToolCall());
+        expect(normalResult.decision).toBe('allow');
+        // Dangerous tool should be denied
+        const dangerousResult = await engine.evaluate(buildToolCall({ tool: { name: 'dangerous', capability: 'read' } }));
+        expect(dangerousResult.decision).toBe('deny');
+    });
+    test('should handle multiple rules (last match wins)', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.tool.capability == "read"
+      }
+      decision = "deny" {
+        input.tool.name == "http.dangerous"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        // A read tool that isn't dangerous should be allowed
+        const readResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'read' } }));
+        expect(readResult.decision).toBe('allow');
+        // A dangerous tool with read capability -- both rules match, last wins (deny)
+        const dangerousRead = await engine.evaluate(buildToolCall({ tool: { name: 'http.dangerous', capability: 'read' } }));
+        expect(dangerousRead.decision).toBe('deny');
+    });
+    test('should collect reasons from reasons rules', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "deny" {
+        input.tool.capability == "admin"
+      }
+      reasons[reason] {
+        input.tool.capability == "admin"
+        reason := "Admin capability requires approval"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'admin' } }));
+        expect(result.decision).toBe('deny');
+        expect(result.reasons).toContain('Admin capability requires approval');
+    });
+    test('should handle inequality conditions', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.tool.capability != "admin"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const readResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'read' } }));
+        expect(readResult.decision).toBe('allow');
+        const adminResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'admin' } }));
+        expect(adminResult.decision).toBe('deny');
+    });
+    test('should handle AND logic (multiple conditions in a rule)', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.tool.capability == "read"
+        input.source.platform == "langgraph"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        // Both conditions met
+        const result1 = await engine.evaluate(buildToolCall({
+            tool: { name: 'http.request', capability: 'read' },
+            source: { platform: 'langgraph' },
+        }));
+        expect(result1.decision).toBe('allow');
+        // Only one condition met
+        const result2 = await engine.evaluate(buildToolCall({
+            tool: { name: 'http.request', capability: 'read' },
+            source: { platform: 'n8n' },
+        }));
+        expect(result2.decision).toBe('deny');
+    });
+    test('should handle actor type conditions', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.actor.type == "user"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const agentResult = await engine.evaluate(buildToolCall({ actor: { type: 'agent', id: 'a1' } }));
+        expect(agentResult.decision).toBe('deny');
+        const userResult = await engine.evaluate(buildToolCall({ actor: { type: 'user', id: 'u1' } }));
+        expect(userResult.decision).toBe('allow');
+    });
+    test('should handle workspace_id conditions', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.workspace_id == "ws-allowed"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const tc1 = {
+            ...buildToolCall(),
+            workspace_id: 'ws-allowed',
+        };
+        const result1 = await engine.evaluate(tc1);
+        expect(result1.decision).toBe('allow');
+        const tc2 = {
+            ...buildToolCall(),
+            workspace_id: 'ws-blocked',
+        };
+        const result2 = await engine.evaluate(tc2);
+        expect(result2.decision).toBe('deny');
+    });
+    test('should handle startswith function', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        startswith(input.tool.name, "http.")
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const httpResult = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'read' } }));
+        expect(httpResult.decision).toBe('allow');
+        const slackResult = await engine.evaluate(buildToolCall({ tool: { name: 'slack.post', capability: 'write' } }));
+        expect(slackResult.decision).toBe('deny');
+    });
+    test('should handle endswith function', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        endswith(input.args.url, "/repos")
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const matchResult = await engine.evaluate(buildToolCall({ args: { url: 'https://api.github.com/repos' } }));
+        expect(matchResult.decision).toBe('allow');
+        const noMatchResult = await engine.evaluate(buildToolCall({ args: { url: 'https://api.github.com/users' } }));
+        expect(noMatchResult.decision).toBe('deny');
+    });
+    test('should handle contains function', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        contains(input.args.url, "github.com")
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const githubResult = await engine.evaluate(buildToolCall({ args: { url: 'https://api.github.com/repos' } }));
+        expect(githubResult.decision).toBe('allow');
+        const otherResult = await engine.evaluate(buildToolCall({ args: { url: 'https://api.gitlab.com/repos' } }));
+        expect(otherResult.decision).toBe('deny');
+    });
+    test('should handle truthy check condition', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.context.purpose
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const withPurpose = await engine.evaluate(buildToolCall({ context: { purpose: 'testing' } }));
+        expect(withPurpose.decision).toBe('allow');
+        const withoutPurpose = await engine.evaluate(buildToolCall());
+        expect(withoutPurpose.decision).toBe('deny');
+    });
+    test('should handle not condition', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        not input.constraints.max_cost_usd
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const noConstraints = await engine.evaluate(buildToolCall());
+        expect(noConstraints.decision).toBe('allow');
+        const withConstraints = await engine.evaluate(buildToolCall({ constraints: { max_cost_usd: 5 } }));
+        expect(withConstraints.decision).toBe('deny');
+    });
+    test('should handle custom default rule_id and rule_name', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "allow"
+      default rule_id = "custom_opa"
+      default rule_name = "Custom OPA Policy"
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+        expect(result.rule_id).toBe('custom_opa');
+        expect(result.rule_name).toBe('Custom OPA Policy');
+    });
+    test('should provide default reason when no reasons rules match', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "allow"
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.reasons).toEqual(['OPA local decision: allow']);
+    });
+    test('should handle require_approval decision locally', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "require_approval" {
+        input.tool.capability == "delete"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'delete' } }));
+        expect(result.decision).toBe('require_approval');
+    });
+    test('should handle transform decision locally', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "transform" {
+        input.tool.capability == "write"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall({ tool: { name: 'http.request', capability: 'write' } }));
+        expect(result.decision).toBe('transform');
+    });
+    test('should skip comment lines in Rego policy', async () => {
+        const policy = `
+      package palaryn.policy
+      # This is a comment
+      default decision = "allow"
+      # Another comment
+      decision = "deny" {
+        input.tool.name == "blocked"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+    });
+    test('should fall back on Rego evaluation error', async () => {
+        // Test with empty rego_policy (edge case)
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: '',
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        // Empty policy = no defaults, so fallback to normalizeDecision(undefined) = 'deny'
+        expect(result.decision).toBe('deny');
+    });
+    test('should handle boolean comparison in conditions', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.tool.capability == "read"
+      }
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall({ tool: { name: 'test', capability: 'read' } }));
+        expect(result.decision).toBe('allow');
+    });
+});
+// ---------------------------------------------------------------------------
+// Decision normalization
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Decision normalization', () => {
+    let engine;
+    beforeEach(() => {
+        engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            fallback_decision: 'deny',
+        });
+    });
+    test('should pass through valid decisions', () => {
+        expect(engine.normalizeDecision('allow')).toBe('allow');
+        expect(engine.normalizeDecision('deny')).toBe('deny');
+        expect(engine.normalizeDecision('transform')).toBe('transform');
+        expect(engine.normalizeDecision('require_approval')).toBe('require_approval');
+    });
+    test('should handle case-insensitive decisions', () => {
+        expect(engine.normalizeDecision('ALLOW')).toBe('allow');
+        expect(engine.normalizeDecision('DENY')).toBe('deny');
+        expect(engine.normalizeDecision('Transform')).toBe('transform');
+        expect(engine.normalizeDecision('REQUIRE_APPROVAL')).toBe('require_approval');
+    });
+    test('should map common OPA boolean patterns', () => {
+        expect(engine.normalizeDecision('true')).toBe('allow');
+        expect(engine.normalizeDecision('allowed')).toBe('allow');
+        expect(engine.normalizeDecision('false')).toBe('deny');
+        expect(engine.normalizeDecision('denied')).toBe('deny');
+    });
+    test('should return fallback for undefined decision', () => {
+        expect(engine.normalizeDecision(undefined)).toBe('deny');
+    });
+    test('should return fallback for unknown decision strings', () => {
+        expect(engine.normalizeDecision('maybe')).toBe('deny');
+        expect(engine.normalizeDecision('pending')).toBe('deny');
+        expect(engine.normalizeDecision('')).toBe('deny');
+    });
+    test('should use custom fallback decision', () => {
+        const customEngine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            fallback_decision: 'allow',
+        });
+        expect(customEngine.normalizeDecision(undefined)).toBe('allow');
+        expect(customEngine.normalizeDecision('unknown')).toBe('allow');
+    });
+});
+// ---------------------------------------------------------------------------
+// parseOPAResponse
+// ---------------------------------------------------------------------------
+describe('OPAEngine - parseOPAResponse', () => {
+    let engine;
+    const tc = buildToolCall();
+    beforeEach(() => {
+        engine = new opa_engine_1.OPAEngine({ enabled: true, fallback_decision: 'deny' });
+    });
+    test('should parse complete OPA response', () => {
+        const response = {
+            result: {
+                decision: 'allow',
+                rule_id: 'rule_1',
+                rule_name: 'Rule One',
+                reasons: ['Allowed by policy'],
+                transformations: [{ type: 'strip_header', target: 'Authorization' }],
+                approval: { scope: 'admin', ttl_seconds: 3600 },
+            },
+        };
+        const result = engine.parseOPAResponse(response, tc);
+        expect(result.decision).toBe('allow');
+        expect(result.rule_id).toBe('rule_1');
+        expect(result.rule_name).toBe('Rule One');
+        expect(result.reasons).toEqual(['Allowed by policy']);
+        expect(result.transformations).toHaveLength(1);
+        expect(result.approval).toEqual({ scope: 'admin', ttl_seconds: 3600 });
+    });
+    test('should handle null response', () => {
+        const result = engine.parseOPAResponse(null, tc);
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+    });
+    test('should handle response with no result', () => {
+        const result = engine.parseOPAResponse({}, tc);
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+    });
+    test('should handle response with partial result', () => {
+        const response = {
+            result: {
+                decision: 'deny',
+            },
+        };
+        const result = engine.parseOPAResponse(response, tc);
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_policy');
+        expect(result.rule_name).toBe('OPA policy evaluation');
+        expect(result.reasons).toEqual(['OPA decision: deny']);
+        expect(result.transformations).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// buildInput
+// ---------------------------------------------------------------------------
+describe('OPAEngine - buildInput', () => {
+    test('should convert ToolCall to OPA input format', () => {
+        const engine = new opa_engine_1.OPAEngine({ enabled: true });
+        const tc = buildToolCall({
+            tool: { name: 'http.get', capability: 'read', version: '1.0' },
+            context: { purpose: 'testing', labels: ['ci', 'automated'] },
+            constraints: { max_cost_usd: 1.0, timeout_ms: 5000 },
+        });
+        tc.timestamp = '2025-01-01T00:00:00Z';
+        const input = engine.buildInput(tc);
+        expect(input.tool_call_id).toBe('tc-opa-001');
+        expect(input.task_id).toBe('task-opa-001');
+        expect(input.workspace_id).toBe('ws-default');
+        expect(input.actor.type).toBe('agent');
+        expect(input.tool.name).toBe('http.get');
+        expect(input.tool.capability).toBe('read');
+        expect(input.context.purpose).toBe('testing');
+        expect(input.constraints.max_cost_usd).toBe(1.0);
+        expect(input.timestamp).toBe('2025-01-01T00:00:00Z');
+    });
+    test('should handle ToolCall with minimal fields', () => {
+        const engine = new opa_engine_1.OPAEngine({ enabled: true });
+        const tc = buildToolCall();
+        const input = engine.buildInput(tc);
+        expect(input.constraints).toBeUndefined();
+        expect(input.context).toBeUndefined();
+        expect(input.timestamp).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// No configuration (fallback)
+// ---------------------------------------------------------------------------
+describe('OPAEngine - No configuration', () => {
+    test('should return fallback when neither server_url nor rego_policy is configured', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toBe('OPA not configured: no server_url or rego_policy provided');
+    });
+    test('should return allow fallback when configured', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            fallback_decision: 'allow',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('allow');
+    });
+});
+// ---------------------------------------------------------------------------
+// isAvailable
+// ---------------------------------------------------------------------------
+describe('OPAEngine - isAvailable', () => {
+    test('should return true when rego_policy is configured', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: 'package palaryn.policy\ndefault decision = "allow"',
+        });
+        const available = await engine.isAvailable();
+        expect(available).toBe(true);
+    });
+    test('should return false when nothing is configured', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+        });
+        const available = await engine.isAvailable();
+        expect(available).toBe(false);
+    });
+    test('should return false when server_url is unreachable', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: 'http://127.0.0.1:1', // unlikely to be listening
+        });
+        const available = await engine.isAvailable();
+        expect(available).toBe(false);
+    });
+    test('should return true when server_url is reachable', async () => {
+        // Create a quick mock OPA server
+        const server = http.createServer((req, res) => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ result: {} }));
+        });
+        await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+        const port = server.address().port;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${port}`,
+        });
+        const available = await engine.isAvailable();
+        expect(available).toBe(true);
+        await new Promise((resolve) => server.close(() => resolve()));
+    });
+});
+// ---------------------------------------------------------------------------
+// Circuit breaker (S15)
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Circuit breaker', () => {
+    let opaServer;
+    let opaPort;
+    let requestCount;
+    let serverShouldFail;
+    beforeAll((done) => {
+        opaServer = http.createServer((req, res) => {
+            requestCount++;
+            if (serverShouldFail) {
+                res.destroy();
+                return;
+            }
+            let body = '';
+            req.on('data', (chunk) => body += chunk);
+            req.on('end', () => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ result: { decision: 'allow' } }));
+            });
+        });
+        opaServer.listen(0, '127.0.0.1', () => {
+            opaPort = opaServer.address().port;
+            done();
+        });
+    });
+    afterAll((done) => {
+        opaServer.close(done);
+    });
+    beforeEach(() => {
+        requestCount = 0;
+        serverShouldFail = false;
+    });
+    test('should open circuit after consecutive failures', async () => {
+        serverShouldFail = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        // 3 consecutive failures should open the circuit
+        for (let i = 0; i < 3; i++) {
+            await engine.evaluate(buildToolCall());
+        }
+        expect(engine.getCircuitState().state).toBe('open');
+        expect(engine.getCircuitState().failures).toBe(3);
+    });
+    test('should skip HTTP call when circuit is open', async () => {
+        serverShouldFail = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        // Trip the circuit
+        for (let i = 0; i < 3; i++) {
+            await engine.evaluate(buildToolCall());
+        }
+        const beforeCount = requestCount;
+        // Next call should NOT make an HTTP request (circuit open)
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.reasons[0]).toContain('circuit breaker open');
+        expect(requestCount).toBe(beforeCount); // no new HTTP calls
+    });
+    test('should return fallback with circuit breaker reason when open', async () => {
+        serverShouldFail = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        // Trip the circuit
+        for (let i = 0; i < 3; i++) {
+            await engine.evaluate(buildToolCall());
+        }
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.decision).toBe('deny');
+        expect(result.rule_id).toBe('opa_fallback');
+        expect(result.reasons[0]).toContain('circuit breaker');
+    });
+    test('should reset circuit on successful call', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        // Cause some failures (but not enough to trip)
+        serverShouldFail = true;
+        await engine.evaluate(buildToolCall());
+        await engine.evaluate(buildToolCall());
+        expect(engine.getCircuitState().failures).toBe(2);
+        // Now succeed
+        serverShouldFail = false;
+        await engine.evaluate(buildToolCall());
+        expect(engine.getCircuitState().state).toBe('closed');
+        expect(engine.getCircuitState().failures).toBe(0);
+    });
+    test('should expose circuit state via getCircuitState()', () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+        });
+        const state = engine.getCircuitState();
+        expect(state.state).toBe('closed');
+        expect(state.failures).toBe(0);
+        expect(state.lastFailure).toBe(0);
+    });
+    test('should allow resetCircuit() to force close the circuit', async () => {
+        serverShouldFail = true;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: `http://127.0.0.1:${opaPort}`,
+            fallback_decision: 'deny',
+        });
+        // Trip the circuit
+        for (let i = 0; i < 3; i++) {
+            await engine.evaluate(buildToolCall());
+        }
+        expect(engine.getCircuitState().state).toBe('open');
+        // Admin reset
+        engine.resetCircuit();
+        expect(engine.getCircuitState().state).toBe('closed');
+        expect(engine.getCircuitState().failures).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// getConfig
+// ---------------------------------------------------------------------------
+describe('OPAEngine - getConfig', () => {
+    test('should return the engine configuration with defaults applied', () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: 'http://localhost:8181',
+        });
+        const config = engine.getConfig();
+        expect(config.enabled).toBe(true);
+        expect(config.server_url).toBe('http://localhost:8181');
+        expect(config.policy_path).toBe('v1/data/palaryn/policy');
+        expect(config.timeout_ms).toBe(5000);
+        expect(config.fallback_decision).toBe('deny');
+        expect(config.package_name).toBe('palaryn.policy');
+    });
+    test('should return custom configuration values', () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            server_url: 'http://opa.internal:8181',
+            policy_path: 'v1/data/custom/policy',
+            timeout_ms: 10000,
+            fallback_decision: 'allow',
+            package_name: 'custom.policy',
+        });
+        const config = engine.getConfig();
+        expect(config.policy_path).toBe('v1/data/custom/policy');
+        expect(config.timeout_ms).toBe(10000);
+        expect(config.fallback_decision).toBe('allow');
+        expect(config.package_name).toBe('custom.policy');
+    });
+});
+// ---------------------------------------------------------------------------
+// Gateway integration behavior
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Gateway integration', () => {
+    test('OPA disabled: existing YAML behavior unchanged', () => {
+        // When OPA is not enabled, the config.policy.opa is undefined,
+        // so the Gateway constructor won't create an OPAEngine.
+        // This test verifies that building a config without OPA still works.
+        const config = {
+            enabled: false,
+        };
+        // The Gateway should not initialize OPA when enabled=false
+        expect(config.enabled).toBe(false);
+    });
+    test('OPA fallback result has rule_id opa_fallback', async () => {
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            fallback_decision: 'deny',
+        });
+        const result = await engine.evaluate(buildToolCall());
+        // When OPA is not configured and returns a fallback, gateway.ts checks
+        // for rule_id === 'opa_fallback' to decide whether to fall back to YAML
+        expect(result.rule_id).toBe('opa_fallback');
+    });
+    test('OPA successful result does not have opa_fallback rule_id', async () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "allow"
+    `;
+        const engine = new opa_engine_1.OPAEngine({
+            enabled: true,
+            rego_policy: policy,
+        });
+        const result = await engine.evaluate(buildToolCall());
+        expect(result.rule_id).not.toBe('opa_fallback');
+        expect(result.rule_id).toBe('opa_local');
+    });
+});
+// ---------------------------------------------------------------------------
+// evaluateRegoSubset (direct method testing)
+// ---------------------------------------------------------------------------
+describe('OPAEngine - evaluateRegoSubset', () => {
+    let engine;
+    beforeEach(() => {
+        engine = new opa_engine_1.OPAEngine({ enabled: true, rego_policy: '' });
+    });
+    test('should handle empty policy', () => {
+        const result = engine.evaluateRegoSubset('', { tool: { name: 'test', capability: 'read' } });
+        // No defaults, no rules -- normalizeDecision(undefined) = fallback = 'deny'
+        expect(result.decision).toBe('deny');
+    });
+    test('should handle policy with only package declaration', () => {
+        const result = engine.evaluateRegoSubset('package palaryn.policy', { tool: { name: 'test' } });
+        expect(result.decision).toBe('deny');
+    });
+    test('should handle deeply nested input paths', () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.args.headers.Authorization == "Bearer token"
+      }
+    `;
+        const input = {
+            args: {
+                headers: { Authorization: 'Bearer token' },
+            },
+        };
+        const result = engine.evaluateRegoSubset(policy, input);
+        expect(result.decision).toBe('allow');
+    });
+    test('should handle missing nested paths gracefully', () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.nonexistent.deep.path == "value"
+      }
+    `;
+        const result = engine.evaluateRegoSubset(policy, { tool: { name: 'test' } });
+        expect(result.decision).toBe('deny');
+    });
+    test('should handle multiple reasons rules', () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "deny" {
+        input.tool.capability == "admin"
+      }
+      reasons[reason] {
+        input.tool.capability == "admin"
+        reason := "Admin access is restricted"
+      }
+      reasons[reason] {
+        input.tool.name == "dangerous"
+        reason := "Dangerous tool detected"
+      }
+    `;
+        const input = { tool: { capability: 'admin', name: 'dangerous' } };
+        const result = engine.evaluateRegoSubset(policy, input);
+        expect(result.decision).toBe('deny');
+        expect(result.reasons).toContain('Admin access is restricted');
+        expect(result.reasons).toContain('Dangerous tool detected');
+    });
+    test('should handle numeric comparison', () => {
+        const policy = `
+      package palaryn.policy
+      default decision = "deny"
+      decision = "allow" {
+        input.constraints.max_cost_usd == 5
+      }
+    `;
+        const input = { constraints: { max_cost_usd: 5 } };
+        const result = engine.evaluateRegoSubset(policy, input);
+        expect(result.decision).toBe('allow');
+    });
+});
+// ---------------------------------------------------------------------------
+// Extended Rego patterns: some, count, numeric comparisons, regex.match,
+// type checks, in keyword
+// ---------------------------------------------------------------------------
+describe('OPAEngine - Extended Rego patterns', () => {
+    let engine;
+    beforeEach(() => {
+        engine = new opa_engine_1.OPAEngine({ enabled: true, rego_policy: '' });
+    });
+    // -------------------------------------------------------------------------
+    // `some` keyword for iteration
+    // -------------------------------------------------------------------------
+    describe('some keyword for iteration', () => {
+        test('should match when array contains matching element (semicolon syntax)', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.labels; x == "sensitive"
+        }
+      `;
+            const input = { context: { labels: ['public', 'sensitive', 'data'] } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('allow');
+        });
+        test('should not match when array does not contain matching element', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.labels; x == "sensitive"
+        }
+      `;
+            const input = { context: { labels: ['public', 'data'] } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('deny');
+        });
+        test('should match with multi-line some block', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.labels
+          x == "admin"
+        }
+      `;
+            const input = { context: { labels: ['user', 'admin', 'editor'] } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('allow');
+        });
+        test('should not match when collection is not an array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.purpose
+          x == "test"
+        }
+      `;
+            const input = { context: { purpose: 'testing' } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('deny');
+        });
+        test('should handle some with empty array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.labels
+          x == "admin"
+        }
+      `;
+            const input = { context: { labels: [] } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('deny');
+        });
+        test('should handle some with additional normal conditions', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.tool.capability == "read"
+          some x in input.context.labels
+          x == "approved"
+        }
+      `;
+            // Both conditions met
+            const input1 = { tool: { capability: 'read' }, context: { labels: ['approved'] } };
+            const result1 = engine.evaluateRegoSubset(policy, input1);
+            expect(result1.decision).toBe('allow');
+            // Normal condition fails
+            const input2 = { tool: { capability: 'write' }, context: { labels: ['approved'] } };
+            const result2 = engine.evaluateRegoSubset(policy, input2);
+            expect(result2.decision).toBe('deny');
+            // Some condition fails
+            const input3 = { tool: { capability: 'read' }, context: { labels: ['pending'] } };
+            const result3 = engine.evaluateRegoSubset(policy, input3);
+            expect(result3.decision).toBe('deny');
+        });
+        test('should handle some with inequality sub-condition', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          some x in input.context.labels; x != "blocked"
+        }
+      `;
+            // Has at least one element that is not "blocked"
+            const input1 = { context: { labels: ['blocked', 'ok'] } };
+            const result1 = engine.evaluateRegoSubset(policy, input1);
+            expect(result1.decision).toBe('allow');
+            // All elements are "blocked" -- no x satisfies x != "blocked"
+            const input2 = { context: { labels: ['blocked'] } };
+            const result2 = engine.evaluateRegoSubset(policy, input2);
+            expect(result2.decision).toBe('deny');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // count() built-in
+    // -------------------------------------------------------------------------
+    describe('count() built-in', () => {
+        test('should count array elements with > comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) > 3
+        }
+      `;
+            const input1 = { context: { labels: ['a', 'b', 'c', 'd'] } };
+            const result1 = engine.evaluateRegoSubset(policy, input1);
+            expect(result1.decision).toBe('allow');
+            const input2 = { context: { labels: ['a', 'b', 'c'] } };
+            const result2 = engine.evaluateRegoSubset(policy, input2);
+            expect(result2.decision).toBe('deny');
+        });
+        test('should count array elements with == comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) == 2
+        }
+      `;
+            const input = { context: { labels: ['a', 'b'] } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('allow');
+        });
+        test('should count array elements with < comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) < 3
+        }
+      `;
+            const input1 = { context: { labels: ['a', 'b'] } };
+            const result1 = engine.evaluateRegoSubset(policy, input1);
+            expect(result1.decision).toBe('allow');
+            const input2 = { context: { labels: ['a', 'b', 'c'] } };
+            const result2 = engine.evaluateRegoSubset(policy, input2);
+            expect(result2.decision).toBe('deny');
+        });
+        test('should count array elements with >= comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) >= 2
+        }
+      `;
+            const input1 = { context: { labels: ['a', 'b'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: ['a'] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should count array elements with <= comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) <= 2
+        }
+      `;
+            const input1 = { context: { labels: ['a', 'b'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: ['a', 'b', 'c'] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should count array elements with != comparison', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) != 0
+        }
+      `;
+            const input1 = { context: { labels: ['a'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: [] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should count object keys', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.args) > 1
+        }
+      `;
+            const input = { args: { method: 'GET', url: 'https://example.com' } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('allow');
+        });
+        test('should count string length', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.tool.name) > 5
+        }
+      `;
+            const input = { tool: { name: 'http.request' } };
+            const result = engine.evaluateRegoSubset(policy, input);
+            expect(result.decision).toBe('allow');
+        });
+        test('should return 0 for undefined value', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.nonexistent) == 0
+        }
+      `;
+            const result = engine.evaluateRegoSubset(policy, { tool: { name: 'test' } });
+            expect(result.decision).toBe('allow');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Numeric comparisons (>, <, >=, <=)
+    // -------------------------------------------------------------------------
+    describe('numeric comparisons', () => {
+        test('should evaluate greater than', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.constraints.max_cost_usd > 10
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 15 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 10 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+            const input3 = { constraints: { max_cost_usd: 5 } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+        test('should evaluate less than', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.constraints.max_cost_usd < 10
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 5 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 10 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should evaluate greater than or equal', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.constraints.max_cost_usd >= 10
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 10 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 15 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('allow');
+            const input3 = { constraints: { max_cost_usd: 9 } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+        test('should evaluate less than or equal', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.constraints.max_cost_usd <= 10
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 10 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 5 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('allow');
+            const input3 = { constraints: { max_cost_usd: 11 } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+        test('should return false for non-numeric comparisons', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.tool.name > 5
+        }
+      `;
+            const input = { tool: { name: 'http.request' } };
+            expect(engine.evaluateRegoSubset(policy, input).decision).toBe('deny');
+        });
+        test('should handle decimal numbers', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.constraints.max_cost_usd <= 0.5
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 0.3 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 0.7 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // regex.match() built-in
+    // -------------------------------------------------------------------------
+    describe('regex.match() built-in', () => {
+        test('should match URL pattern', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          regex.match("^https://.*\\.example\\.com", input.args.url)
+        }
+      `;
+            const input1 = { args: { url: 'https://api.example.com/data' } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { args: { url: 'http://api.example.com/data' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+            const input3 = { args: { url: 'https://malicious.com/data' } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+        test('should match simple patterns', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          regex.match("^http\\.", input.tool.name)
+        }
+      `;
+            const input1 = { tool: { name: 'http.request' } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { tool: { name: 'slack.post' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should return false for non-string values', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          regex.match("^test", input.constraints.max_cost_usd)
+        }
+      `;
+            const input = { constraints: { max_cost_usd: 5 } };
+            expect(engine.evaluateRegoSubset(policy, input).decision).toBe('deny');
+        });
+        test('should handle invalid regex gracefully', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          regex.match("[invalid(", input.tool.name)
+        }
+      `;
+            const input = { tool: { name: 'test' } };
+            expect(engine.evaluateRegoSubset(policy, input).decision).toBe('deny');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Type checks: is_string, is_number, is_boolean, is_array
+    // -------------------------------------------------------------------------
+    describe('type checks', () => {
+        test('should check is_string', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_string(input.args.url)
+        }
+      `;
+            const input1 = { args: { url: 'https://example.com' } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { args: { url: 123 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should check is_number', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_number(input.constraints.max_cost_usd)
+        }
+      `;
+            const input1 = { constraints: { max_cost_usd: 5.0 } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { constraints: { max_cost_usd: 'five' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should check is_boolean', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_boolean(input.args.dry_run)
+        }
+      `;
+            const input1 = { args: { dry_run: true } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { args: { dry_run: 'true' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should check is_array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_array(input.context.labels)
+        }
+      `;
+            const input1 = { context: { labels: ['a', 'b'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: 'not-an-array' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should return false for undefined values', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_string(input.nonexistent.path)
+        }
+      `;
+            const result = engine.evaluateRegoSubset(policy, { tool: { name: 'test' } });
+            expect(result.decision).toBe('deny');
+        });
+        test('should combine type checks with other conditions', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_string(input.args.url)
+          startswith(input.args.url, "https://")
+        }
+      `;
+            const input1 = { args: { url: 'https://example.com' } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { args: { url: 'http://example.com' } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Array membership with `in` keyword
+    // -------------------------------------------------------------------------
+    describe('in keyword for array membership', () => {
+        test('should check string membership in array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          "admin" in input.context.labels
+        }
+      `;
+            const input1 = { context: { labels: ['user', 'admin', 'editor'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: ['user', 'editor'] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should check numeric membership in array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          42 in input.context.labels
+        }
+      `;
+            const input1 = { context: { labels: [1, 42, 100] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: [1, 2, 3] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should return false when target is not an array', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          "admin" in input.tool.name
+        }
+      `;
+            const input = { tool: { name: 'http.request' } };
+            expect(engine.evaluateRegoSubset(policy, input).decision).toBe('deny');
+        });
+        test('should handle boolean membership', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          true in input.context.labels
+        }
+      `;
+            const input1 = { context: { labels: [true, false] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { context: { labels: ['true', false] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should combine in keyword with other conditions', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          input.tool.capability == "write"
+          "approved" in input.context.labels
+        }
+      `;
+            const input1 = { tool: { capability: 'write' }, context: { labels: ['approved'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { tool: { capability: 'write' }, context: { labels: ['pending'] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+            const input3 = { tool: { capability: 'read' }, context: { labels: ['approved'] } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Integration: combining multiple new patterns
+    // -------------------------------------------------------------------------
+    describe('combined patterns', () => {
+        test('should combine count, in, and numeric comparisons', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) >= 2
+          "approved" in input.context.labels
+          input.constraints.max_cost_usd <= 100
+        }
+      `;
+            const input1 = {
+                context: { labels: ['approved', 'reviewed'] },
+                constraints: { max_cost_usd: 50 },
+            };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            // count fails
+            const input2 = {
+                context: { labels: ['approved'] },
+                constraints: { max_cost_usd: 50 },
+            };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+            // in fails
+            const input3 = {
+                context: { labels: ['pending', 'reviewed'] },
+                constraints: { max_cost_usd: 50 },
+            };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+            // numeric comparison fails
+            const input4 = {
+                context: { labels: ['approved', 'reviewed'] },
+                constraints: { max_cost_usd: 150 },
+            };
+            expect(engine.evaluateRegoSubset(policy, input4).decision).toBe('deny');
+        });
+        test('should combine regex.match with type checks', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          is_string(input.args.url)
+          regex.match("^https://.*\\.example\\.com", input.args.url)
+        }
+      `;
+            const input1 = { args: { url: 'https://api.example.com/v1' } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            const input2 = { args: { url: 123 } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+        });
+        test('should combine some with count', () => {
+            const policy = `
+        package palaryn.policy
+        default decision = "deny"
+        decision = "allow" {
+          count(input.context.labels) > 1
+          some x in input.context.labels
+          x == "critical"
+        }
+      `;
+            const input1 = { context: { labels: ['info', 'critical'] } };
+            expect(engine.evaluateRegoSubset(policy, input1).decision).toBe('allow');
+            // count satisfied but some fails
+            const input2 = { context: { labels: ['info', 'warning'] } };
+            expect(engine.evaluateRegoSubset(policy, input2).decision).toBe('deny');
+            // some satisfied but count fails
+            const input3 = { context: { labels: ['critical'] } };
+            expect(engine.evaluateRegoSubset(policy, input3).decision).toBe('deny');
+        });
+    });
+});
+//# sourceMappingURL=opa-engine.test.js.map