@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/test/analytics.test.js

@@ -1,756 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *  Licensed under the MIT License. See LICENSE.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-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 os = __importStar(require("os"));
-const fs_1 = require("fs");
-const base_1 = require("../engines/base");
-const sessionEvents_1 = require("../analytics/sessionEvents");
-const identity_1 = require("../analytics/identity");
-/**
- * Run `fn` with prompt/tool content capture opted in.
- *
- * Content capture is off by default now (PLAN/compliance-req.md §6), so the tests that assert on
- * previews have to say out loud that they are testing the opt-in path.
- */
-async function withContentCapture(fn) {
-    const previous = process.env[identity_1.CONTENT_CAPTURE_ENV];
-    process.env[identity_1.CONTENT_CAPTURE_ENV] = '1';
-    try {
-        return await fn();
-    }
-    finally {
-        if (previous === undefined) {
-            delete process.env[identity_1.CONTENT_CAPTURE_ENV];
-        }
-        else {
-            process.env[identity_1.CONTENT_CAPTURE_ENV] = previous;
-        }
-    }
-}
-async function createUniqueTempDir(prefix) {
-    return fs_1.promises.mkdtemp(path.join(os.tmpdir(), prefix));
-}
-async function removeDirWithRetries(dirPath) {
-    await fs_1.promises.rm(dirPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
-}
-// =============================================================================
-// generateRequestId Tests
-// =============================================================================
-suite('Analytics - generateRequestId', () => {
-    test('returns string starting with req- prefix', () => {
-        const id = (0, base_1.generateRequestId)();
-        assert.ok(id.startsWith('req-'), `Expected req- prefix, got: ${id}`);
-    });
-    test('returns correct format: req-<8 hex chars>', () => {
-        const id = (0, base_1.generateRequestId)();
-        assert.match(id, /^req-[0-9a-f]{1,8}$/, `Unexpected format: ${id}`);
-    });
-    test('generates unique IDs', () => {
-        const ids = new Set();
-        for (let i = 0; i < 100; i++) {
-            ids.add((0, base_1.generateRequestId)());
-        }
-        // With 8 hex chars, collisions in 100 attempts are extremely unlikely
-        assert.ok(ids.size > 95, `Expected near-unique IDs, got ${ids.size} unique out of 100`);
-    });
-    test('is distinguishable from session IDs (UUIDs)', () => {
-        const requestId = (0, base_1.generateRequestId)();
-        const sessionId = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890';
-        assert.ok(requestId.startsWith('req-'), 'Request ID should start with req-');
-        assert.ok(!sessionId.startsWith('req-'), 'Session ID should not start with req-');
-    });
-});
-// =============================================================================
-// buildLiteLLMMetadataHeaders Tests
-// =============================================================================
-suite('Analytics - buildLiteLLMMetadataHeaders', () => {
-    test('returns empty array when useLiteLLM is false', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(false, {
-            sessionId: 'session-1',
-            analyticsUserId: 'user-1',
-            agentId: 'my-agent',
-        });
-        assert.deepStrictEqual(headers, []);
-    });
-    test('returns empty array when metadata is empty', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {});
-        assert.deepStrictEqual(headers, []);
-    });
-    test('includes session_id header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { sessionId: 'sess-123' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-session-id: sess-123'), `Missing session_id header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes user_id header, hashed', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { analyticsUserId: 'user-42' });
-        assert.ok(headers.some(h => h === `x-litellm-metadata-user-id: ${(0, identity_1.hashIdentity)('user-42')}`), `Missing user_id header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('the raw user id never leaves the process on a header', () => {
-        // The proxy logs every request and may forward to a third-party observability backend, so
-        // a raw address here is a directory of who works at the customer.
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { analyticsUserId: 'priya@meridian.com' });
-        assert.ok(!headers.some(h => h.includes('priya@meridian.com')), JSON.stringify(headers));
-        assert.ok(headers.some(h => h.startsWith('x-litellm-metadata-user-id: anon_')));
-        assert.ok(headers.some(h => h.startsWith('langfuse_trace_user_id: anon_')));
-    });
-    test('includes project_id header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { analyticsProjectId: 'agentide-vscode' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-project-id: agentide-vscode'), `Missing project_id header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes agent_id header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { agentId: 'code-reviewer' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-agent-id: code-reviewer'), `Missing agent_id header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes agent_version header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { agentVersion: '1.2.0' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-agent-version: 1.2.0'), `Missing agent_version header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes source header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { source: 'langchain' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-source: langchain'), `Missing source header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes engine header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { engine: 'claude' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-engine: claude'), `Missing engine header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes request_id header', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { requestId: 'req-abcdef12' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-request-id: req-abcdef12'), `Missing request_id header. Headers: ${JSON.stringify(headers)}`);
-    });
-    test('includes langfuse passthrough headers for session_id and user_id', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {
-            sessionId: 'sess-1',
-            analyticsUserId: 'user-1',
-        });
-        assert.ok(headers.some(h => h === 'langfuse_session_id: sess-1'), 'Should include langfuse_session_id for Langfuse callback compatibility');
-        assert.ok(headers.some(h => h === `langfuse_trace_user_id: ${(0, identity_1.hashIdentity)('user-1')}`), 'Should include langfuse_trace_user_id for Langfuse callback compatibility');
-    });
-    // --- Use Case: AgentHippo pack (Mode A) — fully automatic ---
-    test('Mode A: AgentHippo pack produces all 10 headers (8 analytics + 2 langfuse)', () => {
-        const metadata = {
-            sessionId: 'vscode-chat-uuid-1234',
-            analyticsUserId: 'dev@example.com',
-            analyticsProjectId: 'agentide-vscode',
-            agentId: 'code-reviewer',
-            agentVersion: '1.2.0',
-            source: 'agenthippo',
-            engine: 'claude',
-            requestId: 'req-abcdef12',
-        };
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
-        // 8 x-litellm-metadata-* headers + langfuse_session_id + langfuse_trace_user_id
-        assert.strictEqual(headers.length, 10, `Expected 10 headers, got ${headers.length}: ${JSON.stringify(headers)}`);
-    });
-    // --- Use Case: AgentHippo default (Mode B) ---
-    test('Mode B: AgentHippo default agent produces all 10 headers', () => {
-        const metadata = {
-            sessionId: 'vscode-chat-uuid-5678',
-            analyticsUserId: 'dev@example.com',
-            analyticsProjectId: 'agentide-vscode',
-            agentId: 'default',
-            agentVersion: 'workspace',
-            source: 'agenthippo',
-            engine: 'codex',
-            requestId: 'req-11223344',
-        };
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
-        assert.strictEqual(headers.length, 10);
-        assert.ok(headers.some(h => h.includes('agent-id: default')));
-        assert.ok(headers.some(h => h.includes('agent-version: workspace')));
-    });
-    // --- Use Case: LangChain via LiteLLM proxy (Mode C) — developer sets minimum ---
-    test('Mode C: LangChain developer sets minimum viable metadata', () => {
-        const metadata = {
-            sessionId: 'langchain-run-001',
-            agentId: 'my-support-bot',
-        };
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
-        // session-id + agent-id + langfuse_session_id = 3
-        assert.strictEqual(headers.length, 3);
-        assert.ok(headers.some(h => h.includes('session-id: langchain-run-001')));
-        assert.ok(headers.some(h => h.includes('agent-id: my-support-bot')));
-    });
-    // --- Use Case: LangChain developer sets full metadata (Mode C) ---
-    test('Mode C: LangChain developer sets full metadata', () => {
-        const metadata = {
-            sessionId: 'langchain-run-001',
-            agentId: 'my-support-bot',
-            agentVersion: '0.3.1',
-            source: 'langchain',
-        };
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
-        // session-id + agent-id + agent-version + source + langfuse_session_id = 5
-        assert.strictEqual(headers.length, 5);
-        assert.ok(headers.some(h => h.includes('source: langchain')));
-    });
-    // --- Use Case: Direct SDK (Mode D) ---
-    test('Mode D: Anthropic SDK developer sets metadata', () => {
-        const metadata = {
-            sessionId: 'exp-42',
-            agentId: 'my-tool',
-            source: 'anthropic-sdk',
-        };
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
-        // session-id + agent-id + source + langfuse_session_id = 4
-        assert.strictEqual(headers.length, 4);
-        assert.ok(headers.some(h => h.includes('source: anthropic-sdk')));
-    });
-    test('trims whitespace from values', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { sessionId: '  sess-1  ' });
-        assert.ok(headers.some(h => h === 'x-litellm-metadata-session-id: sess-1'));
-    });
-    test('skips empty/whitespace-only values', () => {
-        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {
-            sessionId: '',
-            agentId: '   ',
-            source: 'agenthippo',
-        });
-        // Only source header (sessionId is empty so no langfuse passthrough either)
-        assert.strictEqual(headers.length, 1, `Only non-empty source should produce a header, got: ${JSON.stringify(headers)}`);
-    });
-});
-// =============================================================================
-// SessionEventWriter Tests
-// =============================================================================
-suite('Analytics - SessionEventWriter', () => {
-    let testDir;
-    let writer;
-    setup(async () => {
-        testDir = await createUniqueTempDir('agentide-analytics-test-');
-        writer = new sessionEvents_1.SessionEventWriter(testDir);
-    });
-    teardown(async () => {
-        try {
-            await removeDirWithRetries(testDir);
-        }
-        catch {
-            // ignore
-        }
-    });
-    test('creates sessions directory on first write', async () => {
-        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash' });
-        const stat = await fs_1.promises.stat(testDir);
-        assert.ok(stat.isDirectory());
-    });
-    test('writes JSONL file named by session ID', async () => {
-        await writer.append('sess-abc', 'req-1', 'tool_start', { toolName: 'Read' });
-        const filePath = path.join(testDir, 'sess-abc.jsonl');
-        const stat = await fs_1.promises.stat(filePath);
-        assert.ok(stat.isFile());
-    });
-    test('writes valid JSON per line', async () => {
-        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash' });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const lines = content.trim().split('\n');
-        assert.strictEqual(lines.length, 1);
-        const event = JSON.parse(lines[0]);
-        assert.strictEqual(event.session_id, 'sess-1');
-        assert.strictEqual(event.request_id, 'req-1');
-        assert.strictEqual(event.event_type, 'tool_start');
-        assert.strictEqual(event.payload.toolName, 'Bash');
-        assert.ok(typeof event.timestamp === 'number');
-    });
-    test('appends multiple events to same session file', async () => {
-        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash', callId: 'c1' });
-        await writer.append('sess-1', 'req-1', 'tool_end', { toolName: 'Bash', callId: 'c1', isError: false });
-        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Read', callId: 'c2' });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const lines = content.trim().split('\n');
-        assert.strictEqual(lines.length, 3);
-        const events = lines.map(l => JSON.parse(l));
-        assert.strictEqual(events[0].event_type, 'tool_start');
-        assert.strictEqual(events[0].payload.toolName, 'Bash');
-        assert.strictEqual(events[1].event_type, 'tool_end');
-        assert.strictEqual(events[2].event_type, 'tool_start');
-        assert.strictEqual(events[2].payload.toolName, 'Read');
-    });
-    test('different sessions write to different files', async () => {
-        await writer.append('sess-A', 'req-1', 'turn_start', {});
-        await writer.append('sess-B', 'req-2', 'turn_start', {});
-        const fileA = await fs_1.promises.stat(path.join(testDir, 'sess-A.jsonl'));
-        const fileB = await fs_1.promises.stat(path.join(testDir, 'sess-B.jsonl'));
-        assert.ok(fileA.isFile());
-        assert.ok(fileB.isFile());
-    });
-    test('request_id is preserved in events', async () => {
-        await writer.append('sess-1', 'req-abc', 'tool_start', { toolName: 'Test' });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.request_id, 'req-abc');
-    });
-    test('timestamps are monotonically increasing', async () => {
-        await writer.append('sess-1', 'req-1', 'turn_start', {});
-        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'A' });
-        await writer.append('sess-1', 'req-1', 'tool_end', { toolName: 'A' });
-        await writer.append('sess-1', 'req-1', 'turn_end', { success: true });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const events = content.trim().split('\n').map(l => JSON.parse(l));
-        for (let i = 1; i < events.length; i++) {
-            assert.ok(events[i].timestamp >= events[i - 1].timestamp, `Timestamps should be monotonic: ${events[i - 1].timestamp} -> ${events[i].timestamp}`);
-        }
-    });
-    test('getSessionsDir returns the base directory', () => {
-        assert.strictEqual(writer.getSessionsDir(), testDir);
-    });
-});
-// =============================================================================
-// ObservableStreamEmitter Tests
-// =============================================================================
-suite('Analytics - ObservableStreamEmitter', () => {
-    let testDir;
-    let writer;
-    let innerCalls;
-    let innerEmitter;
-    setup(async () => {
-        testDir = await createUniqueTempDir('agentide-emitter-test-');
-        writer = new sessionEvents_1.SessionEventWriter(testDir);
-        innerCalls = [];
-        // Mock inner emitter that records calls
-        innerEmitter = {
-            async thinking(delta) { innerCalls.push({ method: 'thinking', args: [delta] }); },
-            async text(delta) { innerCalls.push({ method: 'text', args: [delta] }); },
-            async toolStart(name, input, id, meta) {
-                innerCalls.push({ method: 'toolStart', args: [name, input, id, meta] });
-            },
-            async toolEnd(name, id, result, isError, meta) {
-                innerCalls.push({ method: 'toolEnd', args: [name, id, result, isError, meta] });
-            },
-            async progress(msg) { innerCalls.push({ method: 'progress', args: [msg] }); },
-            async question(payload) {
-                innerCalls.push({ method: 'question', args: [payload] });
-                return { selected: [], freeText: null };
-            },
-            async error(msg) { innerCalls.push({ method: 'error', args: [msg] }); },
-            async done() { innerCalls.push({ method: 'done', args: [] }); },
-        };
-    });
-    teardown(async () => {
-        try {
-            await removeDirWithRetries(testDir);
-        }
-        catch {
-            // ignore
-        }
-    });
-    test('passes through thinking() to inner emitter', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.thinking('hello');
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'thinking');
-        assert.deepStrictEqual(innerCalls[0].args, ['hello']);
-    });
-    test('passes through text() to inner emitter', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.text('world');
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'text');
-    });
-    test('passes through progress() to inner emitter', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.progress('Thinking...');
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'progress');
-    });
-    test('passes through done() to inner emitter', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.done();
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'done');
-    });
-    test('toolStart writes session event AND passes through', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.toolStart('Bash', 'ls -la', 'call-1');
-        // Inner emitter was called
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'toolStart');
-        // Session event was written
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.event_type, 'tool_start');
-        assert.strictEqual(event.payload.toolName, 'Bash');
-        assert.strictEqual(event.payload.callId, 'call-1');
-        assert.strictEqual(event.request_id, 'req-1');
-        // Tool arguments are content: digest by default, no preview.
-        assert.strictEqual(event.payload.inputPreview, undefined);
-        assert.strictEqual(event.payload.input_length, 6);
-        assert.strictEqual(typeof event.payload.input_sha256, 'string');
-    });
-    test('tool input preview appears only under the content-capture opt-in', async () => {
-        await withContentCapture(async () => {
-            const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-optin', 'req-1');
-            await emitter.toolStart('Bash', 'ls -la', 'call-1');
-        });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-optin.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.payload.inputPreview, 'ls -la');
-        // The digest is present in both modes, so a query written against it never breaks.
-        assert.strictEqual(typeof event.payload.input_sha256, 'string');
-    });
-    test('tool result content is a digest, not a preview, by default', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-nores', 'req-1');
-        await emitter.toolEnd('Read', 'call-1', 'CUSTOMER SECRET', false);
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-nores.jsonl'), 'utf8');
-        assert.ok(!content.includes('CUSTOMER SECRET'), 'raw tool output must not reach the JSONL');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.payload.resultPreview, undefined);
-        assert.strictEqual(event.payload.result_length, 15);
-    });
-    test('toolEnd writes session event AND passes through', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.toolEnd('Bash', 'call-1', 'file1.txt\nfile2.txt', false);
-        // Inner emitter was called
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'toolEnd');
-        // Session event was written
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.event_type, 'tool_end');
-        assert.strictEqual(event.payload.toolName, 'Bash');
-        assert.strictEqual(event.payload.isError, false);
-    });
-    test('toolEnd records errors', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.toolEnd('Bash', 'call-1', 'command not found', true);
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.payload.isError, true);
-    });
-    test('error() writes session event AND passes through', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.error('Something went wrong');
-        assert.strictEqual(innerCalls.length, 1);
-        assert.strictEqual(innerCalls[0].method, 'error');
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.event_type, 'error');
-        assert.strictEqual(event.payload.message, 'Something went wrong');
-    });
-    test('emitTurnStart writes turn_start event', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.emitTurnStart();
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.event_type, 'turn_start');
-        assert.strictEqual(event.session_id, 'sess-1');
-        assert.strictEqual(event.request_id, 'req-1');
-    });
-    test('emitTurnEnd writes turn_end event with success flag', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-        await emitter.emitTurnEnd(true);
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.event_type, 'turn_end');
-        assert.strictEqual(event.payload.success, true);
-    });
-    test('truncates long tool input to 500 chars (content-capture opt-in)', async () => {
-        await withContentCapture(async () => {
-            const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-            const longInput = 'x'.repeat(1000);
-            await emitter.toolStart('Read', longInput, 'call-1');
-        });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.payload.inputPreview.length, 500);
-        // The digest covers the WHOLE input, not the truncated preview.
-        assert.strictEqual(event.payload.input_length, 1000);
-    });
-    test('truncates long tool result to 500 chars (content-capture opt-in)', async () => {
-        await withContentCapture(async () => {
-            const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
-            const longResult = 'y'.repeat(1000);
-            await emitter.toolEnd('Read', 'call-1', longResult, false);
-        });
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
-        const event = JSON.parse(content.trim());
-        assert.strictEqual(event.payload.resultPreview.length, 500);
-        assert.strictEqual(event.payload.result_length, 1000);
-    });
-    // --- Use Case: Full agent request lifecycle ---
-    test('Use Case: full request lifecycle produces correct event sequence', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-debug', 'req-42');
-        // Simulate a full agent request lifecycle
-        await emitter.emitTurnStart();
-        await emitter.progress('Thinking...');
-        await emitter.thinking('Let me analyze this...');
-        await emitter.toolStart('Read', '/path/to/file.ts', 'tool-1');
-        await emitter.toolEnd('Read', 'tool-1', 'file contents here', false);
-        await emitter.toolStart('Bash', 'npm test', 'tool-2');
-        await emitter.toolEnd('Bash', 'tool-2', 'All tests passed', false);
-        await emitter.text('I analyzed the code and ran the tests.');
-        await emitter.done();
-        await emitter.emitTurnEnd(true);
-        // Verify inner emitter got all pass-through calls
-        const methods = innerCalls.map(c => c.method);
-        assert.deepStrictEqual(methods, [
-            'progress', 'thinking', 'toolStart', 'toolEnd',
-            'toolStart', 'toolEnd', 'text', 'done',
-        ]);
-        // Verify session events (only tool/turn events, not thinking/text/progress)
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-debug.jsonl'), 'utf8');
-        const events = content.trim().split('\n').map(l => JSON.parse(l));
-        const eventTypes = events.map((e) => e.event_type);
-        assert.deepStrictEqual(eventTypes, [
-            'turn_start', 'tool_start', 'tool_end', 'tool_start', 'tool_end', 'turn_end',
-        ]);
-        // All events have correct session_id and request_id
-        for (const event of events) {
-            assert.strictEqual(event.session_id, 'sess-debug');
-            assert.strictEqual(event.request_id, 'req-42');
-        }
-    });
-    // --- Use Case: Detect tool loop from events ---
-    test('Use Case: tool loop detection — 6 calls to same tool', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-loop', 'req-1');
-        await emitter.emitTurnStart();
-        // Simulate an agent calling read_file 6 times (possible loop)
-        for (let i = 0; i < 6; i++) {
-            await emitter.toolStart('read_file', `/path/file${i}.ts`, `call-${i}`);
-            await emitter.toolEnd('read_file', `call-${i}`, 'contents', false);
-        }
-        await emitter.emitTurnEnd(true);
-        // Read events and count tool_start for read_file
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-loop.jsonl'), 'utf8');
-        const events = content.trim().split('\n').map(l => JSON.parse(l));
-        const readFileStarts = events.filter((e) => e.event_type === 'tool_start' && e.payload.toolName === 'read_file');
-        assert.strictEqual(readFileStarts.length, 6, 'Should detect 6 read_file calls');
-        // This is what --tool-loops query would flag as "POSSIBLE LOOP" (>5 calls)
-    });
-    // --- Use Case: Multiple requests in same session ---
-    test('Use Case: multiple requests in same session have different request_ids', async () => {
-        const reqId1 = (0, base_1.generateRequestId)();
-        const reqId2 = (0, base_1.generateRequestId)();
-        const emitter1 = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-multi', reqId1);
-        await emitter1.emitTurnStart();
-        await emitter1.toolStart('Bash', 'echo hello', 'c1');
-        await emitter1.toolEnd('Bash', 'c1', 'hello', false);
-        await emitter1.emitTurnEnd(true);
-        const emitter2 = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-multi', reqId2);
-        await emitter2.emitTurnStart();
-        await emitter2.toolStart('Read', '/file.ts', 'c2');
-        await emitter2.toolEnd('Read', 'c2', 'contents', false);
-        await emitter2.emitTurnEnd(true);
-        // All events in same session file
-        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-multi.jsonl'), 'utf8');
-        const events = content.trim().split('\n').map(l => JSON.parse(l));
-        assert.strictEqual(events.length, 8); // 2 x (turn_start, tool_start, tool_end, turn_end)
-        // First 4 events have reqId1, last 4 have reqId2
-        const firstFour = events.slice(0, 4);
-        const lastFour = events.slice(4);
-        for (const e of firstFour) {
-            assert.strictEqual(e.request_id, reqId1);
-        }
-        for (const e of lastFour) {
-            assert.strictEqual(e.request_id, reqId2);
-        }
-        assert.notStrictEqual(reqId1, reqId2, 'Request IDs should be different');
-    });
-});
-// =============================================================================
-// ObservableStreamEmitter warrant audit trail (constructor-captured userId)
-// =============================================================================
-suite('Analytics - ObservableStreamEmitter records the acting user (the warrant)', () => {
-    let testDir;
-    let writer;
-    let innerEmitter;
-    setup(async () => {
-        testDir = await createUniqueTempDir('agentide-warrant-test-');
-        writer = new sessionEvents_1.SessionEventWriter(testDir);
-        innerEmitter = {
-            async thinking() { },
-            async text() { },
-            async toolStart() { },
-            async toolEnd() { },
-            async progress() { },
-            async question() { return { selected: [], freeText: null }; },
-            async error() { },
-            async done() { },
-        };
-    });
-    teardown(async () => {
-        try {
-            await removeDirWithRetries(testDir);
-        }
-        catch {
-            // ignore
-        }
-    });
-    async function readEvents(sessionId) {
-        const content = await fs_1.promises.readFile(path.join(testDir, `${sessionId}.jsonl`), 'utf8');
-        return content.trim().split('\n').map((l) => JSON.parse(l));
-    }
-    test('toolStart/toolEnd record the userId passed at wrap, as a salted hash', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-1', 'req-1', 'priya@meridian.com');
-        await emitter.toolStart('Bash', 'echo hi', 'c1');
-        await emitter.toolEnd('Bash', 'c1', 'hi', false);
-        const events = await readEvents('sess-warrant-1');
-        assert.strictEqual(events.length, 2);
-        const expected = (0, identity_1.hashIdentity)('priya@meridian.com');
-        assert.strictEqual(events[0].payload.userId, expected);
-        assert.strictEqual(events[1].payload.userId, expected);
-        // Attribution is preserved; the address itself is not.
-        assert.ok(String(expected).startsWith('anon_'));
-    });
-    test('the raw address never reaches the evidence file', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-raw', 'req-1', 'priya@meridian.com');
-        await emitter.emitTurnStart();
-        const raw = await fs_1.promises.readFile(path.join(testDir, 'sess-warrant-raw.jsonl'), 'utf8');
-        assert.ok(!raw.includes('priya@meridian.com'), 'raw user id must not be written to evidence');
-        assert.ok(!raw.includes('meridian.com'), 'not even the domain');
-    });
-    test('toolStart records no userId when wrap omitted it (IDE-local usage)', async () => {
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-2', 'req-1');
-        await emitter.toolStart('Bash', 'echo hi', 'c1');
-        const events = await readEvents('sess-warrant-2');
-        assert.strictEqual(events[0].payload.userId, undefined);
-    });
-    test('two emitters never attribute a tool call to the wrong user', async () => {
-        const alice = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-3', 'req-a', 'alice@acme.com');
-        const bob = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-3', 'req-b', 'bob@acme.com');
-        await Promise.all([
-            (async () => {
-                await new Promise((r) => setTimeout(r, 5));
-                await alice.toolStart('Bash', 'a', 'a1');
-            })(),
-            bob.toolStart('Bash', 'b', 'b1'),
-        ]);
-        const events = await readEvents('sess-warrant-3');
-        const byCallId = Object.fromEntries(events.map((e) => [e.payload.callId, e.payload.userId]));
-        assert.strictEqual(byCallId['a1'], (0, identity_1.hashIdentity)('alice@acme.com'));
-        assert.strictEqual(byCallId['b1'], (0, identity_1.hashIdentity)('bob@acme.com'));
-        assert.notStrictEqual(byCallId['a1'], byCallId['b1'], 'distinct users must stay distinguishable');
-    });
-    test('toolStart/toolEnd keep wrap-time userId even when called outside any credential scope', async () => {
-        // Simulates the custom-engine persistent-worker path: wrap captures identity on the
-        // request continuation, then tool events fire later on a detached IPC callback with
-        // no ambient runWithCredential (or a sticky wrong one). Attribution must not depend
-        // on ambient AsyncLocalStorage at emit time.
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-4', 'req-1', 'alice@acme.com');
-        await emitter.toolStart('Bash', 'echo hi', 'c1');
-        await emitter.toolEnd('Bash', 'c1', 'hi', false);
-        const events = await readEvents('sess-warrant-4');
-        assert.strictEqual(events[0].payload.userId, (0, identity_1.hashIdentity)('alice@acme.com'));
-        assert.strictEqual(events[1].payload.userId, (0, identity_1.hashIdentity)('alice@acme.com'));
-    });
-    test('error/turn_start/turn_end also carry the wrap-time userId, not just tool events', async () => {
-        // A turn that errors before any tool call (or has no tool calls at all) must still
-        // carry identity attribution — the mechanism was already on the instance, it just
-        // wasn't threaded into these three payloads.
-        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-warrant-5', 'req-1', 'bob@acme.com');
-        await emitter.emitTurnStart();
-        await emitter.error('boom');
-        await emitter.emitTurnEnd(false);
-        const events = await readEvents('sess-warrant-5');
-        assert.strictEqual(events.length, 3);
-        const bob = (0, identity_1.hashIdentity)('bob@acme.com');
-        assert.strictEqual(events[0].event_type, 'turn_start');
-        assert.strictEqual(events[0].payload.userId, bob);
-        assert.strictEqual(events[1].event_type, 'error');
-        assert.strictEqual(events[1].payload.userId, bob);
-        assert.strictEqual(events[2].event_type, 'turn_end');
-        assert.strictEqual(events[2].payload.userId, bob);
-    });
-});
-// =============================================================================
-// Evidence-write failures must be LOUD (compliance fix 2a)
-//
-// `append()` used to swallow every error in an empty catch block. A full disk, a read-only
-// volume, a bad mount — all of them produced a turn that ran with no record of it, and nothing
-// anywhere said so. An absent record is the failure mode that matters (SOC 2 CC7.2 / R-13), so
-// these tests exist to keep the silence from coming back.
-// =============================================================================
-suite('Analytics - evidence write failures are surfaced, never swallowed', () => {
-    let blockedDir;
-    let errors;
-    let originalError;
-    setup(async () => {
-        (0, sessionEvents_1.resetSessionEventWriterStatsForTest)();
-        // A FILE where the writer expects a directory: mkdir fails, so every append fails.
-        const root = await createUniqueTempDir('agentide-evidence-fail-');
-        blockedDir = path.join(root, 'not-a-dir');
-        await fs_1.promises.writeFile(blockedDir, 'this is a file, not a directory');
-        errors = [];
-        originalError = console.error;
-        console.error = (msg) => { errors.push(String(msg)); };
-    });
-    teardown(() => {
-        console.error = originalError;
-        delete process.env.AGENTHIPPO_EVIDENCE_REQUIRED;
-        (0, sessionEvents_1.resetSessionEventWriterStatsForTest)();
-    });
-    test('a failed append logs at error level and counts the loss', async () => {
-        const writer = new sessionEvents_1.SessionEventWriter(blockedDir);
-        await writer.append('sess-x', 'req-1', 'tool_start', { toolName: 'Bash' });
-        assert.strictEqual(writer.getStats().failed, 1, 'per-writer counter');
-        assert.strictEqual(writer.getStats().written, 0);
-        assert.strictEqual((0, sessionEvents_1.getSessionEventWriterStats)().failed, 1, 'process-wide counter for /health');
-        assert.ok(errors.some((e) => e.includes('LOST session event')), `no error logged: ${JSON.stringify(errors)}`);
-        assert.ok(errors.some((e) => e.includes('tool_start')), 'the lost event type is named');
-    });
-    test('the last failure is retained for /health output', async () => {
-        const writer = new sessionEvents_1.SessionEventWriter(blockedDir);
-        await writer.append('sess-x', 'req-1', 'turn_end', { success: true });
-        const stats = (0, sessionEvents_1.getSessionEventWriterStats)();
-        assert.strictEqual(stats.lastError?.eventType, 'turn_end');
-        assert.ok((stats.lastError?.at ?? 0) > 0);
-        assert.ok((stats.lastError?.message ?? '').length > 0);
-    });
-    test('AGENTHIPPO_EVIDENCE_REQUIRED makes the turn fail rather than run unrecorded', async () => {
-        process.env.AGENTHIPPO_EVIDENCE_REQUIRED = '1';
-        const writer = new sessionEvents_1.SessionEventWriter(blockedDir);
-        await assert.rejects(() => writer.append('sess-x', 'req-1', 'tool_start', {}), /evidence write failed for tool_start/);
-        assert.strictEqual((0, sessionEvents_1.getSessionEventWriterStats)().failed, 1);
-    });
-    test('without the flag the agent keeps running, but the loss is still counted', async () => {
-        const writer = new sessionEvents_1.SessionEventWriter(blockedDir);
-        await writer.append('sess-x', 'req-1', 'tool_start', {});
-        await writer.append('sess-x', 'req-1', 'tool_end', {});
-        assert.strictEqual((0, sessionEvents_1.getSessionEventWriterStats)().failed, 2);
-    });
-    test('successful writes are counted too, so /health can show a ratio', async () => {
-        const dir = await createUniqueTempDir('agentide-evidence-ok-');
-        const writer = new sessionEvents_1.SessionEventWriter(dir);
-        await writer.append('sess-ok', 'req-1', 'turn_start', {});
-        assert.strictEqual(writer.getStats().written, 1);
-        assert.strictEqual(writer.getStats().failed, 0);
-        assert.strictEqual((0, sessionEvents_1.getSessionEventWriterStats)().written, 1);
-        await removeDirWithRetries(dir);
-    });
-});