@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/test/deps-auto-install.test.js

@@ -1,81 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Deps auto-install flag (serve-v3 A2 — self-contained image)
- *
- *  Verifies AGENTHIPPO_NO_AUTO_INSTALL is actually honored (the runtime-install bug).
- *--------------------------------------------------------------------------------------------*/
-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 deps_1 = require("../cli/deps");
-suite('deps: isAutoInstallDisabled', () => {
-    const KEYS = ['AGENTHIPPO_NO_AUTO_INSTALL', 'AGENTIDE_NO_AUTO_INSTALL'];
-    let saved;
-    setup(() => {
-        saved = {};
-        for (const k of KEYS) {
-            saved[k] = process.env[k];
-            delete process.env[k];
-        }
-    });
-    teardown(() => {
-        for (const k of KEYS) {
-            if (saved[k] === undefined)
-                delete process.env[k];
-            else
-                process.env[k] = saved[k];
-        }
-    });
-    test('unset → auto-install enabled (false)', () => {
-        assert.strictEqual((0, deps_1.isAutoInstallDisabled)(), false);
-    });
-    test('truthy values disable install', () => {
-        for (const v of ['1', 'true', 'TRUE', 'yes', 'on', '  1  ']) {
-            process.env.AGENTHIPPO_NO_AUTO_INSTALL = v;
-            assert.strictEqual((0, deps_1.isAutoInstallDisabled)(), true, `value ${JSON.stringify(v)}`);
-        }
-    });
-    test('falsey / empty values keep install enabled', () => {
-        for (const v of ['', '0', 'false', 'no']) {
-            process.env.AGENTHIPPO_NO_AUTO_INSTALL = v;
-            assert.strictEqual((0, deps_1.isAutoInstallDisabled)(), false, `value ${JSON.stringify(v)}`);
-        }
-    });
-    test('legacy AGENTIDE_NO_AUTO_INSTALL is honored', () => {
-        process.env.AGENTIDE_NO_AUTO_INSTALL = '1';
-        assert.strictEqual((0, deps_1.isAutoInstallDisabled)(), true);
-    });
-});

package/out/test/egress-broker.test.js

@@ -1,172 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Egress broker tests (secure-obo-design §7.6)
- *
- *  Boots the real broker (loopback HTTP + shared TurnRegistry) against a temp workspace whose
- *  gateway-outbound handle store is seeded like the bridge would seed it, then drives it exactly
- *  as the agent-facing `gateway send` broker mode does: bearer nonce, `{message, to?}` body.
- *
- *  The `send` function is a spy — no live OpenClaw gateway — so we assert on WHAT the broker
- *  resolved and WHETHER it delivered, not on the platform call itself.
- *--------------------------------------------------------------------------------------------*/
-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 fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const data_plane_1 = require("../cli/data-plane");
-const outboundPaths_1 = require("../gateway/outboundPaths");
-const AGENT_ID = 'demo-agent';
-/** Seed a handle store the way the bridge's upsertGatewayOutboundHandle would. */
-function seedStore(workspaceRoot, storeKey, handle) {
-    const p = (0, outboundPaths_1.getGatewayOutboundFilePath)(workspaceRoot, (0, outboundPaths_1.safeGatewaySessionDirId)(storeKey));
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, JSON.stringify({
-        version: 1,
-        lastByAgent: { [AGENT_ID]: handle },
-        targetsByAgent: { [AGENT_ID]: { [handle.target]: handle } },
-    }), 'utf8');
-}
-function handle(target, overrides = {}) {
-    return {
-        agentId: AGENT_ID, channel: 'telegram', target,
-        firstSeenAt: 1, lastSeenAt: 2, inboundCount: 1, ...overrides,
-    };
-}
-async function post(url, nonce, body) {
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...(nonce !== undefined ? { Authorization: `Bearer ${nonce}` } : {}) },
-        body: JSON.stringify(body),
-    });
-    return { status: res.status, json: await res.json().catch(() => ({})) };
-}
-suite('egress broker: server-side resolution + fail-closed (§7.6)', function () {
-    this.timeout(15_000);
-    let workspaceRoot;
-    let registry;
-    let broker;
-    let sends;
-    suiteSetup(async () => {
-        workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'egress-ws-'));
-        registry = new data_plane_1.TurnRegistry();
-        sends = [];
-        broker = await (0, data_plane_1.startEgressBroker)({
-            registry,
-            workspaceRoot,
-            agentId: AGENT_ID,
-            send: async (h, message, media) => {
-                sends.push({ handle: h, message, media });
-                return { ok: true, via: 'spy' };
-            },
-        });
-    });
-    suiteTeardown(async () => {
-        await broker?.close();
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test('binds loopback only', () => {
-        assert.ok(broker.url.startsWith('http://127.0.0.1:'), broker.url);
-    });
-    test('reply-to-sender: a live nonce delivers to the session\'s bound handle', async () => {
-        seedStore(workspaceRoot, 'chat-1', handle('telegram:dm:100'));
-        const turn = registry.register({ userId: 'u@corp.com', sessionKey: 's', egressStoreKey: 'chat-1' });
-        try {
-            const { status, json } = await post(broker.url, turn.nonce, { message: 'hello' });
-            assert.strictEqual(status, 200);
-            assert.strictEqual(json.ok, true);
-            assert.strictEqual(sends.at(-1)?.handle.target, 'telegram:dm:100');
-            assert.strictEqual(sends.at(-1)?.message, 'hello');
-        }
-        finally {
-            turn.release();
-        }
-    });
-    test('`to` may only SELECT among bound handles — a new destination is refused, no send', async () => {
-        seedStore(workspaceRoot, 'chat-2', handle('telegram:dm:200'));
-        const turn = registry.register({ userId: 'u@corp.com', sessionKey: 's', egressStoreKey: 'chat-2' });
-        const before = sends.length;
-        try {
-            const { status, json } = await post(broker.url, turn.nonce, { message: 'exfil', to: 'telegram:dm:ATTACKER' });
-            assert.strictEqual(status, 404, 'a target not bound to this session must not resolve');
-            assert.strictEqual(json.ok, false);
-            assert.strictEqual(sends.length, before, 'nothing may be delivered when resolution fails');
-        }
-        finally {
-            turn.release();
-        }
-    });
-    test('off-turn / released nonce → 401, fail closed, no send', async () => {
-        seedStore(workspaceRoot, 'chat-3', handle('telegram:dm:300'));
-        const turn = registry.register({ userId: 'u@corp.com', sessionKey: 's', egressStoreKey: 'chat-3' });
-        const nonce = turn.nonce;
-        turn.release();
-        const before = sends.length;
-        const { status, json } = await post(broker.url, nonce, { message: 'stale' });
-        assert.strictEqual(status, 401);
-        assert.strictEqual(json.ok, false);
-        assert.strictEqual(sends.length, before);
-    });
-    test('unknown / missing nonce → 401', async () => {
-        assert.strictEqual((await post(broker.url, 'never-issued-nonce', { message: 'x' })).status, 401);
-        assert.strictEqual((await post(broker.url, undefined, { message: 'x' })).status, 401);
-    });
-    test('a turn with no egress store key (bare HTTP data turn) cannot send → 403', async () => {
-        const turn = registry.register({ userId: 'u@corp.com', sessionKey: 's' }); // no egressStoreKey
-        try {
-            const { status } = await post(broker.url, turn.nonce, { message: 'x' });
-            assert.strictEqual(status, 403);
-        }
-        finally {
-            turn.release();
-        }
-    });
-    test('one user cannot address another session\'s bound handle (server-side scoping)', async () => {
-        // Alice's session is bound to her peer; Bob's turn (his own store key) must not reach it.
-        seedStore(workspaceRoot, 'alice-chat', handle('telegram:dm:ALICE'));
-        const bob = registry.register({ userId: 'bob@corp.com', sessionKey: 'sb', egressStoreKey: 'bob-chat' }); // no store seeded
-        const before = sends.length;
-        try {
-            const { status } = await post(broker.url, bob.nonce, { message: 'to alice?', to: 'telegram:dm:ALICE' });
-            assert.strictEqual(status, 404, 'Bob\'s turn resolves only against Bob\'s own session store');
-            assert.strictEqual(sends.length, before);
-        }
-        finally {
-            bob.release();
-        }
-    });
-});

package/out/test/engine-integration.test.js

@@ -1,297 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Engine Integration Tests
- *
- * These tests actually run the engines with real API calls.
- * They verify that agent-scoped config directories are used correctly.
- *
- * Requirements:
- *   - AGENTHIPPO_INTEGRATION_TEST=1 to enable (legacy: AGENTIDE_INTEGRATION_TEST)
- *   - ANTHROPIC_API_KEY or CLAUDE_API_KEY for Claude tests
- *   - OPENAI_API_KEY for Codex tests
- *
- * Run with:
- *   cd extensions/agentide && npm run compile && \
- *   AGENTHIPPO_INTEGRATION_TEST=1 ANTHROPIC_API_KEY=sk-... \
- *     node ../../node_modules/mocha/bin/mocha ./out/test/engine-integration.test.js --timeout 120000
- */
-require("mocha");
-const branding_1 = require("../branding");
-const INTEGRATION_ENABLED = process.env.AGENTHIPPO_INTEGRATION_TEST === '1' ||
-    process.env.AGENTIDE_INTEGRATION_TEST === '1';
-// Only register tests when integration testing is enabled
-// This avoids "pending" noise in normal test runs
-if (INTEGRATION_ENABLED) {
-    const assert = require('assert');
-    const fs = require('fs');
-    const path = require('path');
-    const os = require('os');
-    // Shim vscode for engine modules that import it
-    const Module = require('module');
-    const originalRequire = Module.prototype.require;
-    const fakeVscode = {
-        window: {
-            showInformationMessage: () => undefined,
-            showErrorMessage: () => undefined,
-        },
-        workspace: {
-            getConfiguration: () => ({
-                get: (_key, defaultValue) => defaultValue,
-                inspect: (_key) => undefined,
-            }),
-        },
-        commands: {
-            executeCommand: async () => undefined,
-        },
-    };
-    Module.prototype.require = function (request) {
-        if (request === 'vscode') {
-            return fakeVscode;
-        }
-        return originalRequire.apply(this, arguments);
-    };
-    // Dynamic imports after stubbing vscode
-    const { ClaudeEngine } = require('../engines/claude');
-    const { CodexEngine } = require('../engines/codex');
-    const { resolveAgentRuntimePaths } = require('../agentpack/paths');
-    const { createTestAgentYaml } = require('./helpers/manifest-fixtures');
-    const CLAUDE_API_KEY = process.env.ANTHROPIC_API_KEY ||
-        process.env.CLAUDE_API_KEY ||
-        process.env.AGENTHIPPO_LITELLM_API_KEY ||
-        process.env.AGENTIDE_LITELLM_API_KEY;
-    const OPENAI_API_KEY = process.env.OPENAI_API_KEY ||
-        process.env.AGENTHIPPO_LITELLM_API_KEY ||
-        process.env.AGENTIDE_LITELLM_API_KEY;
-    const LITELLM_BASE_URL = process.env.AGENTHIPPO_LITELLM_BASE_URL ||
-        process.env.AGENTIDE_LITELLM_BASE_URL ||
-        'https://localhost:4443';
-    // -------------------------------------------------------------------------
-    // Helper Functions
-    // -------------------------------------------------------------------------
-    function makeTempWorkspace() {
-        return fs.mkdtempSync(path.join(os.tmpdir(), `${branding_1.AGENTIDE_CLI_NAME}-integration-`));
-    }
-    function makeAgent(workspaceRoot, agentId, engine, modelId) {
-        const runtimePaths = resolveAgentRuntimePaths(workspaceRoot, workspaceRoot, agentId);
-        const agentRoot = runtimePaths.agentRoot;
-        fs.mkdirSync(agentRoot, { recursive: true });
-        fs.writeFileSync(path.join(agentRoot, 'AGENTS.md'), `# ${agentId} Agent\n\nA test agent for integration testing.\n`, 'utf8');
-        const agentYaml = createTestAgentYaml({
-            name: agentId,
-            version: '0.1.0',
-            engine,
-            model: modelId,
-            includeSkills: true,
-            fileAccess: 'workspace-write',
-            visibility: 'internal',
-        });
-        fs.writeFileSync(path.join(agentRoot, 'agent.yaml'), agentYaml, 'utf8');
-        return {
-            agentRoot,
-            claudeConfigDir: runtimePaths.claudeConfigDir,
-            codexHome: runtimePaths.codexHome,
-        };
-    }
-    function createOutputChannel() {
-        const lines = [];
-        return {
-            lines,
-            appendLine: (msg) => {
-                lines.push(msg);
-                if (process.env.DEBUG_INTEGRATION) {
-                    console.log(msg);
-                }
-            },
-            show: () => { },
-        };
-    }
-    function createRuntimeContext(output) {
-        return {
-            logger: {
-                debug: (msg) => output.appendLine(msg),
-                info: (msg) => output.appendLine(msg),
-                warn: (msg) => output.appendLine(`Warning: ${msg}`),
-                error: (msg, err) => output.appendLine(`Error: ${msg}${err ? `: ${err.message}` : ''}`),
-            },
-            editTracker: undefined,
-            configProvider: undefined,
-        };
-    }
-    function createStreamEmitter() {
-        const chunks = [];
-        const emitter = {
-            progress: async (msg) => { chunks.push({ type: 'progress', content: msg }); },
-            thinking: async (msg) => { chunks.push({ type: 'thinking', content: msg }); },
-            message: async (msg) => { chunks.push({ type: 'message', content: msg }); },
-            error: async (msg) => { chunks.push({ type: 'error', content: msg }); },
-            done: async () => { chunks.push({ type: 'done', content: '' }); },
-            text: async (msg) => { chunks.push({ type: 'text', content: msg }); },
-            markdown: async (msg) => { chunks.push({ type: 'markdown', content: msg }); },
-            toolStart: async (name, input, id) => {
-                chunks.push({ type: 'toolStart', content: `${name}:${input || ''}:${id || ''}` });
-            },
-        };
-        return { emitter, chunks };
-    }
-    // -------------------------------------------------------------------------
-    // Claude Engine Integration Tests
-    // -------------------------------------------------------------------------
-    suite('Claude Engine Integration', function () {
-        this.timeout(120000);
-        if (!CLAUDE_API_KEY) {
-            console.log('[Claude tests] Skipped: no ANTHROPIC_API_KEY or CLAUDE_API_KEY');
-            return;
-        }
-        test('sends prompt and uses agent-scoped CLAUDE_CONFIG_DIR', async () => {
-            const workspaceRoot = makeTempWorkspace();
-            const agentId = 'integration-test-claude';
-            const { claudeConfigDir } = makeAgent(workspaceRoot, agentId, 'claude', 'claude-sonnet-4-5-20250929');
-            const workspaceClaude = path.join(workspaceRoot, '.claude');
-            if (fs.existsSync(workspaceClaude)) {
-                fs.rmSync(workspaceClaude, { recursive: true, force: true });
-            }
-            const output = createOutputChannel();
-            const { emitter, chunks } = createStreamEmitter();
-            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
-            const opts = {
-                agentPackId: agentId,
-                workspaceRoot,
-                additionalDirectories: [],
-                modelId: 'claude-sonnet-4-5-20250929',
-                sessionId: `integration-${Date.now()}`,
-                apiKey: CLAUDE_API_KEY,
-                useLiteLLM: true,
-            };
-            await engine.stream('Reply with exactly: INTEGRATION_TEST_OK', opts, emitter, createRuntimeContext(output), new AbortController().signal);
-            assert.ok(fs.existsSync(claudeConfigDir), `Agent CLAUDE_CONFIG_DIR should exist: ${claudeConfigDir}`);
-            const hasAgentDirLog = output.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes(agentId));
-            assert.ok(hasAgentDirLog, 'Output should log agent-scoped CLAUDE_CONFIG_DIR');
-            const textChunks = chunks.filter((c) => c.type === 'text');
-            assert.ok(textChunks.length > 0, 'Should receive text response from Claude');
-            const fullResponse = textChunks.map((c) => c.content).join('');
-            assert.ok(fullResponse.includes('INTEGRATION_TEST_OK'), `Response should contain INTEGRATION_TEST_OK, got: ${fullResponse.slice(0, 200)}`);
-            // Cleanup: dispose engine to close SDK sessions
-            engine.dispose();
-            try {
-                fs.rmSync(workspaceRoot, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
-        });
-        test('default agent uses default-scoped directory', async () => {
-            const workspaceRoot = makeTempWorkspace();
-            const defaultPaths = resolveAgentRuntimePaths(workspaceRoot, workspaceRoot, 'default');
-            const output = createOutputChannel();
-            const { emitter, chunks } = createStreamEmitter();
-            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
-            const opts = {
-                workspaceRoot,
-                additionalDirectories: [],
-                modelId: 'claude-sonnet-4-5-20250929',
-                sessionId: `integration-default-${Date.now()}`,
-                apiKey: CLAUDE_API_KEY,
-                useLiteLLM: true,
-            };
-            await engine.stream('Reply with exactly: DEFAULT_MODE_OK', opts, emitter, createRuntimeContext(output), new AbortController().signal);
-            assert.ok(fs.existsSync(defaultPaths.claudeConfigDir), `Default CLAUDE_CONFIG_DIR should exist: ${defaultPaths.claudeConfigDir}`);
-            const textChunks = chunks.filter((c) => c.type === 'text');
-            const fullResponse = textChunks.map((c) => c.content).join('');
-            assert.ok(fullResponse.includes('DEFAULT_MODE_OK'), `Response should contain DEFAULT_MODE_OK, got: ${fullResponse.slice(0, 200)}`);
-            // Cleanup: dispose engine to close SDK sessions
-            engine.dispose();
-            try {
-                fs.rmSync(workspaceRoot, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Codex Engine Integration Tests
-    // -------------------------------------------------------------------------
-    suite('Codex Engine Integration', function () {
-        this.timeout(120000);
-        if (!OPENAI_API_KEY) {
-            console.log('[Codex tests] Skipped: no OPENAI_API_KEY');
-            return;
-        }
-        test('writes config into agent-scoped CODEX_HOME', async () => {
-            const workspaceRoot = makeTempWorkspace();
-            const agentId = 'integration-test-codex';
-            const { codexHome } = makeAgent(workspaceRoot, agentId, 'codex', 'gpt-4o');
-            const workspaceCodex = path.join(workspaceRoot, '.codex');
-            if (fs.existsSync(workspaceCodex)) {
-                fs.rmSync(workspaceCodex, { recursive: true, force: true });
-            }
-            const output = createOutputChannel();
-            const engine = new CodexEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, () => undefined, () => undefined);
-            await engine.ensureCodexConfig(false, undefined, 'gpt-4o', workspaceRoot, [], output, codexHome, agentId);
-            const configPath = path.join(codexHome, 'config.toml');
-            assert.ok(fs.existsSync(configPath), `config.toml should exist in agent CODEX_HOME: ${codexHome}`);
-            const configContent = fs.readFileSync(configPath, 'utf8');
-            const instructionsMatch = configContent.match(/model_instructions_file\s*=\s*"([^"]+)"/);
-            assert.ok(instructionsMatch, `config.toml should include model_instructions_file, got:\n${configContent}`);
-            const instructionsPath = instructionsMatch?.[1];
-            assert.ok(instructionsPath && fs.existsSync(instructionsPath), `model_instructions_file should exist: ${instructionsPath ?? 'missing'}`);
-            const instructionsContent = fs.readFileSync(instructionsPath, 'utf8');
-            assert.ok(instructionsContent.includes(`# ${agentId} Agent`), 'Instructions file should include AGENTS.md content');
-            try {
-                fs.rmSync(workspaceRoot, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
-        });
-    });
-    // -------------------------------------------------------------------------
-    // Multi-Agent Isolation Tests
-    // -------------------------------------------------------------------------
-    suite('Multi-Agent Isolation', function () {
-        this.timeout(180000);
-        if (!CLAUDE_API_KEY) {
-            console.log('[Multi-Agent tests] Skipped: no ANTHROPIC_API_KEY or CLAUDE_API_KEY');
-            return;
-        }
-        test('different agents use isolated config directories', async () => {
-            const workspaceRoot = makeTempWorkspace();
-            const agentA = makeAgent(workspaceRoot, 'agent-alpha', 'claude', 'claude-sonnet-4-5-20250929');
-            const agentB = makeAgent(workspaceRoot, 'agent-beta', 'claude', 'claude-sonnet-4-5-20250929');
-            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
-            const outputA = createOutputChannel();
-            const { emitter: emitterA } = createStreamEmitter();
-            await engine.stream('Reply: AGENT_ALPHA', {
-                agentPackId: 'agent-alpha',
-                workspaceRoot,
-                additionalDirectories: [],
-                modelId: 'claude-sonnet-4-5-20250929',
-                sessionId: `agent-alpha-${Date.now()}`,
-                apiKey: CLAUDE_API_KEY,
-                useLiteLLM: true,
-            }, emitterA, createRuntimeContext(outputA), new AbortController().signal);
-            const outputB = createOutputChannel();
-            const { emitter: emitterB } = createStreamEmitter();
-            await engine.stream('Reply: AGENT_BETA', {
-                agentPackId: 'agent-beta',
-                workspaceRoot,
-                additionalDirectories: [],
-                modelId: 'claude-sonnet-4-5-20250929',
-                sessionId: `agent-beta-${Date.now()}`,
-                apiKey: CLAUDE_API_KEY,
-                useLiteLLM: true,
-            }, emitterB, createRuntimeContext(outputB), new AbortController().signal);
-            assert.ok(fs.existsSync(agentA.claudeConfigDir), `Agent alpha CLAUDE_CONFIG_DIR should exist`);
-            assert.ok(fs.existsSync(agentB.claudeConfigDir), `Agent beta CLAUDE_CONFIG_DIR should exist`);
-            assert.notStrictEqual(agentA.claudeConfigDir, agentB.claudeConfigDir, 'Agent config dirs should be different');
-            const hasAgentALog = outputA.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes('agent-alpha'));
-            const hasAgentBLog = outputB.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes('agent-beta'));
-            assert.ok(hasAgentALog, 'Agent alpha output should log its config dir');
-            assert.ok(hasAgentBLog, 'Agent beta output should log its config dir');
-            // Cleanup: dispose engine to close SDK sessions
-            engine.dispose();
-            try {
-                fs.rmSync(workspaceRoot, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
-        });
-    });
-} // end if (INTEGRATION_ENABLED)