@agenthippo-ai/agenthippo 1.110.11 → 1.110.19

package/out/test/gateway-session-store.test.js

@@ -1,216 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-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 assert = __importStar(require("assert"));
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const gatewaySessionStore_js_1 = require("../gateway/gatewaySessionStore.js");
-suite('Gateway session store', () => {
-    let workspaceRoot;
-    setup(() => {
-        workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-session-store-'));
-    });
-    teardown(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test('normalizeInboundBindLabel collapses whitespace and case', () => {
-        assert.strictEqual((0, gatewaySessionStore_js_1.normalizeInboundBindLabel)('Fix Login Bug'), 'fix-login-bug');
-        assert.strictEqual((0, gatewaySessionStore_js_1.inboundBindLabelsMatch)('Fix Login Bug', 'fix-login-bug'), true);
-    });
-    test('write and read gateway-session.json', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-uuid-1',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-uuid-1',
-            published: {
-                mode: 'default',
-                bindLabel: 'fix-login-bug',
-                at: '2026-05-28T12:00:00.000Z',
-            },
-            gatewaySessionKeys: [],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const record = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, 'chat-uuid-1');
-        assert.ok(record);
-        assert.strictEqual(record?.published?.bindLabel, 'fix-login-bug');
-    });
-    test('findPublishedSessionIdByBindLabel scans session dirs', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-uuid-2',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-uuid-2',
-            published: {
-                mode: 'default',
-                bindLabel: 'refactor-api',
-                at: '2026-05-28T12:00:00.000Z',
-            },
-            gatewaySessionKeys: [],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const found = await (0, gatewaySessionStore_js_1.findPublishedSessionIdByBindLabel)(workspaceRoot, 'ide-myproj', 'Refactor API');
-        assert.strictEqual(found, 'chat-uuid-2');
-    });
-    test('shouldUpdateAgentDefaultOnGatewayPublish is false for peer-only publish', () => {
-        assert.strictEqual((0, gatewaySessionStore_js_1.shouldUpdateAgentDefaultOnGatewayPublish)('default'), true);
-        assert.strictEqual((0, gatewaySessionStore_js_1.shouldUpdateAgentDefaultOnGatewayPublish)('peer'), false);
-    });
-    test('mergeGatewaySessionKeyList unions existing and new keys', () => {
-        assert.deepStrictEqual((0, gatewaySessionStore_js_1.mergeGatewaySessionKeyList)(['agent:ide:slack:channel:c1'], 'agent:ide:slack:channel:c1', 'agent:ide:telegram:dm:9'), ['agent:ide:slack:channel:c1', 'agent:ide:telegram:dm:9']);
-    });
-    test('republish merges gatewaySessionKeys instead of replacing', async () => {
-        const keyA = 'agent:ide-myproj:slack:channel:c111';
-        const keyB = 'agent:ide-myproj:telegram:dm:99';
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-uuid-repub',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-uuid-repub',
-            gatewaySessionKeys: [keyA],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const merged = (0, gatewaySessionStore_js_1.mergeGatewaySessionKeyList)([keyA], keyB);
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-uuid-repub',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-uuid-repub',
-            gatewaySessionKeys: merged,
-            updatedAt: '2026-05-28T13:00:00.000Z',
-        });
-        const record = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, 'chat-uuid-repub');
-        assert.deepStrictEqual(record?.gatewaySessionKeys, [keyA, keyB]);
-    });
-    test('appendGatewaySessionKey is idempotent', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-uuid-3',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-uuid-3',
-            gatewaySessionKeys: [],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const key = 'agent:ide-myproj:slack:channel:c0123';
-        await (0, gatewaySessionStore_js_1.appendGatewaySessionKey)(workspaceRoot, 'chat-uuid-3', key);
-        await (0, gatewaySessionStore_js_1.appendGatewaySessionKey)(workspaceRoot, 'chat-uuid-3', key);
-        const record = await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, 'chat-uuid-3');
-        assert.deepStrictEqual(record?.gatewaySessionKeys, [key]);
-    });
-    test('detachGatewaySessionRoutes drops the reassigned keys and clears matching peer publish', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-y',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-y',
-            published: { mode: 'peer', peerRoute: 'dm:42', at: '2026-05-28T12:00:00.000Z' },
-            gatewaySessionKeys: ['telegram:dm:42', 'slack:channel:c9'],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const updated = await (0, gatewaySessionStore_js_1.detachGatewaySessionRoutes)(workspaceRoot, 'chat-y', ['telegram:dm:42', 'dm:42']);
-        // The reassigned key is removed; the unrelated route survives; peer publish is cleared.
-        assert.deepStrictEqual(updated?.gatewaySessionKeys, ['slack:channel:c9']);
-        assert.strictEqual(updated?.published, undefined);
-        assert.strictEqual((0, gatewaySessionStore_js_1.isGatewaySessionRecordOrphaned)(updated), false);
-    });
-    test('detachGatewaySessionRoutes leaves a record orphaned when nothing remains', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-y2',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-y2',
-            published: { mode: 'peer', peerRoute: 'dm:42', at: '2026-05-28T12:00:00.000Z' },
-            gatewaySessionKeys: ['telegram:dm:42'],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const updated = await (0, gatewaySessionStore_js_1.detachGatewaySessionRoutes)(workspaceRoot, 'chat-y2', ['telegram:dm:42', 'dm:42']);
-        assert.deepStrictEqual(updated?.gatewaySessionKeys, []);
-        assert.strictEqual(updated?.published, undefined);
-        assert.strictEqual((0, gatewaySessionStore_js_1.isGatewaySessionRecordOrphaned)(updated), true);
-    });
-    test('clearGatewaySessionPublishedDefault clears only a default publish', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-d',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-d',
-            published: { mode: 'default', at: '2026-05-28T12:00:00.000Z' },
-            gatewaySessionKeys: [],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const updated = await (0, gatewaySessionStore_js_1.clearGatewaySessionPublishedDefault)(workspaceRoot, 'chat-d');
-        assert.strictEqual(updated?.published, undefined);
-        assert.strictEqual((0, gatewaySessionStore_js_1.isGatewaySessionRecordOrphaned)(updated), true);
-        // A peer publish must be left intact by the default-only clear.
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-p',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-p',
-            published: { mode: 'peer', peerRoute: 'dm:7', at: '2026-05-28T12:00:00.000Z' },
-            gatewaySessionKeys: ['telegram:dm:7'],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        const peerUntouched = await (0, gatewaySessionStore_js_1.clearGatewaySessionPublishedDefault)(workspaceRoot, 'chat-p');
-        assert.strictEqual(peerUntouched?.published?.mode, 'peer');
-    });
-    test('deleteGatewaySessionRecord removes the binding file', async () => {
-        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
-            version: 1,
-            sessionId: 'chat-del',
-            agentId: 'ide-myproj',
-            packName: 'default',
-            vscodeSessionResource: 'vscode-chat://session/chat-del',
-            gatewaySessionKeys: [],
-            updatedAt: '2026-05-28T12:00:00.000Z',
-        });
-        assert.ok(await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, 'chat-del'));
-        await (0, gatewaySessionStore_js_1.deleteGatewaySessionRecord)(workspaceRoot, 'chat-del');
-        assert.strictEqual(await (0, gatewaySessionStore_js_1.readGatewaySessionRecord)(workspaceRoot, 'chat-del'), undefined);
-    });
-});

package/out/test/github.test.js

@@ -1,232 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------------------------
- *  Tests for GitHub integration (publish/install).
- *--------------------------------------------------------------------------------------------*/
-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 });
-require("mocha");
-const assert = __importStar(require("assert"));
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs/promises"));
-const os = __importStar(require("os"));
-const agentpack_1 = require("../agentpack");
-const publish_1 = require("../agentpack/publish");
-// -----------------------------------------------------------------------------
-// parseGitHubSource tests
-// -----------------------------------------------------------------------------
-suite('parseGitHubSource', () => {
-    test('parses owner/repo format', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('user/my-pack');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-        assert.strictEqual(result.version, undefined);
-    });
-    test('parses owner/repo@version format', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('user/my-pack@v1.0.0');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-        assert.strictEqual(result.version, 'v1.0.0');
-    });
-    test('parses github:// protocol', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('github://user/my-pack');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-        assert.strictEqual(result.version, undefined);
-    });
-    test('parses github:// protocol with version', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('github://user/my-pack@v2.1.0');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-        assert.strictEqual(result.version, 'v2.1.0');
-    });
-    test('parses https://github.com URL', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('https://github.com/user/my-pack');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-    });
-    test('parses https://github.com URL with .git suffix', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('https://github.com/user/my-pack.git');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-    });
-    test('throws on invalid format', () => {
-        assert.throws(() => (0, agentpack_1.parseGitHubSource)('invalid'), /Invalid GitHub source/);
-        assert.throws(() => (0, agentpack_1.parseGitHubSource)(''), /Invalid GitHub source/);
-    });
-    test('handles whitespace', () => {
-        const result = (0, agentpack_1.parseGitHubSource)('  user/my-pack  ');
-        assert.strictEqual(result.owner, 'user');
-        assert.strictEqual(result.repo, 'my-pack');
-    });
-});
-// -----------------------------------------------------------------------------
-// formatGitHubSource tests
-// -----------------------------------------------------------------------------
-suite('formatGitHubSource', () => {
-    test('formats without version', () => {
-        const result = (0, agentpack_1.formatGitHubSource)({
-            owner: 'user',
-            repo: 'my-pack',
-        });
-        assert.strictEqual(result, 'github://user/my-pack');
-    });
-    test('formats with version', () => {
-        const result = (0, agentpack_1.formatGitHubSource)({
-            owner: 'user',
-            repo: 'my-pack',
-            version: 'v1.0.0',
-        });
-        assert.strictEqual(result, 'github://user/my-pack@v1.0.0');
-    });
-});
-// -----------------------------------------------------------------------------
-// validateForPublish tests
-// -----------------------------------------------------------------------------
-suite('validateForPublish', () => {
-    let tempDir;
-    // Helper to get the correct agent directory path
-    function getAgentDir(agentId) {
-        return path.join(tempDir, agentpack_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, agentpack_1.AGENT_CONSTANTS.AGENTS_DIR, agentId);
-    }
-    setup(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agentide-test-'));
-    });
-    teardown(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    test('fails if agent directory does not exist', async () => {
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'nonexistent');
-        assert.strictEqual(result.valid, false);
-        assert.ok(result.errors.some(e => e.includes('Agent directory not found')));
-    });
-    test('fails if agent.yaml is missing', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'AGENTS.md'), '# Test');
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, false);
-        assert.ok(result.errors.some(e => e.includes('agent.yaml')));
-    });
-    test('fails if AGENTS.md is missing', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'agent.yaml'), [
-            'apiVersion: agentide.ai/v1',
-            'kind: AgentPack',
-            'metadata:',
-            '  name: test-pack',
-            '  version: 1.0.0',
-            'spec:',
-            '  engine: claude',
-        ].join('\n'));
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, false);
-        assert.ok(result.errors.some(e => e.includes('AGENTS.md')));
-    });
-    test('fails if version is missing', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'agent.yaml'), [
-            'apiVersion: agentide.ai/v1',
-            'kind: AgentPack',
-            'metadata:',
-            '  name: test-pack',
-            'spec:',
-            '  engine: claude',
-        ].join('\n'));
-        await fs.writeFile(path.join(agentDir, 'AGENTS.md'), '# Test');
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, false);
-        assert.ok(result.errors.some(e => e.includes('version')));
-    });
-    test('fails if version format is invalid', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'agent.yaml'), [
-            'apiVersion: agentide.ai/v1',
-            'kind: AgentPack',
-            'metadata:',
-            '  name: test-pack',
-            '  version: invalid',
-            'spec:',
-            '  engine: claude',
-        ].join('\n'));
-        await fs.writeFile(path.join(agentDir, 'AGENTS.md'), '# Test');
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, false);
-        assert.ok(result.errors.some(e => e.toLowerCase().includes('version')));
-    });
-    test('passes with valid pack', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'agent.yaml'), [
-            'apiVersion: agentide.ai/v1',
-            'kind: AgentPack',
-            'metadata:',
-            '  name: test-pack',
-            '  version: 1.0.0',
-            '  description: A test pack',
-            '  license: MIT',
-            '  author: testuser',
-            'spec:',
-            '  engine: claude',
-        ].join('\n'));
-        await fs.writeFile(path.join(agentDir, 'AGENTS.md'), '# Test Pack\n\nInstructions...');
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, true);
-        assert.strictEqual(result.errors.length, 0);
-    });
-    test('warns about missing optional fields', async () => {
-        const agentDir = getAgentDir('test-pack');
-        await fs.mkdir(agentDir, { recursive: true });
-        await fs.writeFile(path.join(agentDir, 'agent.yaml'), [
-            'apiVersion: agentide.ai/v1',
-            'kind: AgentPack',
-            'metadata:',
-            '  name: test-pack',
-            '  version: 1.0.0',
-            'spec:',
-            '  engine: claude',
-        ].join('\n'));
-        await fs.writeFile(path.join(agentDir, 'AGENTS.md'), '# Test');
-        const result = await (0, publish_1.validateForPublish)(tempDir, 'test-pack');
-        assert.strictEqual(result.valid, true);
-        assert.ok(result.warnings.some(w => w.includes('description')));
-        assert.ok(result.warnings.some(w => w.includes('author')));
-    });
-});

package/out/test/governor-hardening.test.js

@@ -1,222 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Governor hardening: kill that means kill (or says it does not), budgets that survive a kill,
- *  session stops that survive session_id rotation, and one constant for the poll interval.
- *--------------------------------------------------------------------------------------------*/
-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 });
-require("mocha");
-const assert = __importStar(require("assert"));
-const governor_1 = require("../pack/governor");
-const lease_1 = require("../pack/lease");
-function fakeSandboxes(initial = [], supportsInFlightTermination = true) {
-    const state = {
-        live: [...initial],
-        destroyed: [],
-        revoked: [],
-        supportsInFlightTermination,
-        // Session scope: one sandbox per session, so its key IS the session key.
-        sandboxes() {
-            return state.live.map((sessionKey) => ({
-                sandboxKey: sessionKey, sandboxId: `sandbox-${sessionKey}`, sessionKeys: [sessionKey],
-            }));
-        },
-        async destroySession(sessionKey) {
-            state.destroyed.push(sessionKey);
-            state.live = state.live.filter((s) => s !== sessionKey);
-        },
-        async revokeRoute(sessionKey, what) {
-            state.revoked.push({ sessionKey, what });
-        },
-    };
-    return state;
-}
-const liveLease = (over = {}) => ({
-    pack: 'joker1',
-    enabled: true,
-    expiresAt: Math.floor(Date.now() / 1000) + 3600,
-    ...over,
-});
-suite('kill never silently degrades to drain', () => {
-    test('without a sandbox driver, kill is REPORTED as the drain it actually is', async () => {
-        const lines = [];
-        const events = [];
-        const sandboxes = fakeSandboxes([], false);
-        const gov = (0, governor_1.createGovernor)({
-            caps: {}, sandboxes, pack: 'joker1',
-            getLease: async () => liveLease({ deny: [{ scope: 'session', match: 's1', mode: 'kill' }] }),
-            logger: { info: (m) => lines.push(m), warn: (m) => lines.push(m) },
-            audit: (event, fields) => events.push({ event, fields }),
-        });
-        await gov.refresh();
-        assert.ok(lines.some((l) => /DEGRADED TO DRAIN/.test(l)), 'the console must not claim kill when it means drain');
-        assert.ok(events.some((e) => e.event === 'deny_kill_degraded' && e.fields.effectiveMode === 'drain'));
-        // The substance still holds: the NEXT turn is refused.
-        assert.strictEqual((await gov.admitTurn('s1')).allowed, false);
-    });
-    test('the warning is once per rule, not once per poll', async () => {
-        const lines = [];
-        const sandboxes = fakeSandboxes([], false);
-        const gov = (0, governor_1.createGovernor)({
-            caps: {}, sandboxes, pack: 'joker1',
-            getLease: async () => liveLease({ deny: [{ scope: 'session', match: 's1', mode: 'kill' }] }),
-            logger: { info: (m) => lines.push(m), warn: (m) => lines.push(m) },
-        });
-        await gov.refresh();
-        await gov.refresh();
-        await gov.refresh();
-        assert.strictEqual(lines.filter((l) => /DEGRADED TO DRAIN/.test(l)).length, 1);
-    });
-    test('with a driver, kill still ends running work', async () => {
-        const sandboxes = fakeSandboxes(['s1'], true);
-        const gov = (0, governor_1.createGovernor)({
-            caps: {}, sandboxes, pack: 'joker1',
-            getLease: async () => liveLease({ deny: [{ scope: 'session', match: 's1', mode: 'kill' }] }),
-        });
-        await gov.refresh();
-        assert.deepStrictEqual(sandboxes.destroyed, ['s1']);
-    });
-    test('the kill switch itself says so when it can only refuse new work', async () => {
-        const lines = [];
-        const gov = (0, governor_1.createGovernor)({
-            caps: {}, sandboxes: fakeSandboxes([], false),
-            logger: { info: (m) => lines.push(m), warn: (m) => lines.push(m) },
-        });
-        await gov.killAll('drill');
-        assert.ok(lines.some((l) => /nothing running can be stopped/.test(l)));
-    });
-    test('effectiveDenyMode is the one place that decides', () => {
-        assert.strictEqual((0, governor_1.effectiveDenyMode)('kill', true), 'kill');
-        assert.strictEqual((0, governor_1.effectiveDenyMode)('kill', false), 'drain');
-        assert.strictEqual((0, governor_1.effectiveDenyMode)('drain', false), 'drain');
-        assert.strictEqual((0, governor_1.effectiveDenyMode)(undefined, false), undefined);
-    });
-});
-suite('a kill does not hand back budgets', () => {
-    /**
-     * `killAll` called `meter.forget` on every session it killed, so a kill-then-restore (a billing
-     * hold lifted, a drill, an operator toggling the switch) gave every session a brand-new turn and
-     * duration budget. The cheapest way past a cap was to trip the kill switch. The cap-breach path
-     * deliberately did NOT do this, and explains why.
-     */
-    test('a session over its turn cap is still over it after a kill and a restore', async () => {
-        const sandboxes = fakeSandboxes(['s1']);
-        let lease = liveLease({ caps: { maxTurnsPerSession: 2 } });
-        const gov = (0, governor_1.createGovernor)({ caps: {}, sandboxes, getLease: async () => lease });
-        await gov.refresh();
-        assert.ok((await gov.admitTurn('s1')).allowed);
-        gov.recordTurn('s1');
-        assert.ok((await gov.admitTurn('s1')).allowed);
-        gov.recordTurn('s1');
-        lease = liveLease({ enabled: false, caps: { maxTurnsPerSession: 2 } });
-        await gov.refresh();
-        lease = liveLease({ caps: { maxTurnsPerSession: 2 } });
-        await gov.refresh();
-        const after = await gov.admitTurn('s1');
-        assert.strictEqual(after.allowed, false, 'the kill must not renew the budget');
-        assert.match(after.reason ?? '', /turn cap reached/);
-    });
-    test('a deny(kill) does not renew the budget either', async () => {
-        const sandboxes = fakeSandboxes(['s1']);
-        let lease = liveLease({ caps: { maxTurnsPerSession: 1 } });
-        const gov = (0, governor_1.createGovernor)({ caps: {}, sandboxes, pack: 'joker1', getLease: async () => lease });
-        await gov.refresh();
-        assert.ok((await gov.admitTurn('s1')).allowed);
-        gov.recordTurn('s1');
-        lease = liveLease({ caps: { maxTurnsPerSession: 1 }, deny: [{ scope: 'session', match: 's1', mode: 'kill' }] });
-        await gov.refresh();
-        lease = liveLease({ caps: { maxTurnsPerSession: 1 } });
-        await gov.refresh();
-        const after = await gov.admitTurn('s1');
-        assert.strictEqual(after.allowed, false);
-        assert.match(after.reason ?? '', /turn cap reached/);
-    });
-});
-suite('session-scoped stops and the client-supplied session_id', () => {
-    test('a session rule bound to a user does not match another account replaying the id', () => {
-        const lease = liveLease({ deny: [{ scope: 'session', match: 'ticket-42', mode: 'kill', user: 'alice@x.com' }] });
-        assert.ok((0, lease_1.denyVerdict)(lease, { sessionKey: 'uH--ticket-42', pack: 'joker1', userId: 'alice@x.com' }).denied);
-        assert.ok(!(0, lease_1.denyVerdict)(lease, { sessionKey: 'uH--ticket-42', pack: 'joker1', userId: 'mallory@x.com' }).denied);
-    });
-    test('rotating session_id does not escape a session stop once the user is known', async () => {
-        const sandboxes = fakeSandboxes();
-        let lease = liveLease();
-        const gov = (0, governor_1.createGovernor)({ caps: {}, sandboxes, pack: 'joker1', getLease: async () => lease });
-        // The turn path teaches the governor which user 'ticket-42' belongs to.
-        await gov.admitTurn('uH--ticket-42', 'alice@x.com');
-        lease = liveLease({ deny: [{ scope: 'session', match: 'ticket-42', mode: 'kill', reason: 'runaway' }] });
-        await gov.refresh();
-        assert.strictEqual((await gov.admitTurn('uH--ticket-42', 'alice@x.com')).allowed, false, 'the named session');
-        const rotated = await gov.admitTurn('uH--brand-new-id', 'alice@x.com');
-        assert.strictEqual(rotated.allowed, false, 'a fresh session_id from the same user must not escape');
-        assert.strictEqual((await gov.admitTurn('uH--someone-else', 'bob@x.com')).allowed, true, 'and nobody else is caught');
-    });
-    test('followUser: false keeps a genuinely id-only stop', async () => {
-        const sandboxes = fakeSandboxes();
-        let lease = liveLease();
-        const gov = (0, governor_1.createGovernor)({ caps: {}, sandboxes, pack: 'joker1', getLease: async () => lease });
-        await gov.admitTurn('uH--ticket-42', 'alice@x.com');
-        lease = liveLease({ deny: [{ scope: 'session', match: 'ticket-42', mode: 'drain', followUser: false }] });
-        await gov.refresh();
-        assert.strictEqual((await gov.admitTurn('uH--ticket-42', 'alice@x.com')).allowed, false);
-        assert.strictEqual((await gov.admitTurn('uH--another', 'alice@x.com')).allowed, true);
-    });
-    test('with no verified identity the stop is id-only — the documented limitation', () => {
-        const lease = liveLease({ deny: [{ scope: 'session', match: 'anon-1', mode: 'kill' }] });
-        assert.ok((0, lease_1.denyVerdict)(lease, { sessionKey: 'anon-1', pack: 'joker1' }).denied);
-        assert.ok(!(0, lease_1.denyVerdict)(lease, { sessionKey: 'anon-2', pack: 'joker1' }).denied);
-    });
-    test('resolveFollowedUsers ignores spent rules and respects explicit user binding', () => {
-        const past = Math.floor(Date.now() / 1000) - 1;
-        const sessions = new Map([['uH--t42', 'alice@x.com']]);
-        assert.strictEqual((0, lease_1.resolveFollowedUsers)(liveLease({ deny: [{ scope: 'session', match: 't42', mode: 'kill', until: past }] }), sessions).size, 0);
-        assert.strictEqual((0, lease_1.resolveFollowedUsers)(liveLease({ deny: [{ scope: 'session', match: 't42', mode: 'kill', user: 'bob@x.com' }] }), sessions).size, 0, 'a rule bound to bob must not widen itself to alice');
-    });
-});
-suite('poll interval and the advertised kill latency', () => {
-    test('one constant drives poll and cache — they can no longer disagree', () => {
-        assert.strictEqual((0, lease_1.resolveLeasePollSeconds)(undefined), lease_1.DEFAULT_LEASE_POLL_SECONDS);
-        assert.strictEqual((0, lease_1.leaseCacheSecondsFor)((0, lease_1.resolveLeasePollSeconds)(undefined)), lease_1.DEFAULT_LEASE_POLL_SECONDS);
-    });
-    test('the printed kill latency is the TRUE worst case (poll + cache), not the poll alone', () => {
-        assert.strictEqual((0, lease_1.effectiveKillLatencySeconds)(30), 60);
-        assert.strictEqual((0, lease_1.effectiveKillLatencySeconds)(10), 20);
-    });
-    test('a nonsense or tiny poll is floored, not honoured', () => {
-        assert.strictEqual((0, lease_1.resolveLeasePollSeconds)(0), 5);
-        assert.strictEqual((0, lease_1.resolveLeasePollSeconds)(-1), 5);
-        assert.strictEqual((0, lease_1.resolveLeasePollSeconds)(NaN), lease_1.DEFAULT_LEASE_POLL_SECONDS);
-    });
-});