@animalabs/agent-framework 0.22.1 → 0.22.3

package/dist/test/event-gate.test.js

@@ -1,919 +0,0 @@
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { EventGate } from '../src/gate/event-gate.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const TMP_DIR = join(import.meta.dirname, '../.test-tmp-gate');
-function tmpPath(name) {
-    return join(TMP_DIR, name);
-}
-function writeConfig(name, config) {
-    const path = tmpPath(name);
-    mkdirSync(TMP_DIR, { recursive: true });
-    writeFileSync(path, JSON.stringify(config, null, 2));
-    return path;
-}
-function makeGate(configPath, opts) {
-    const traces = [];
-    const messages = [];
-    const inferenceRequests = [];
-    const gate = new EventGate({
-        configPath,
-        initialConfig: opts?.initialConfig,
-        ...(opts?.resolveRouteChannel ? { resolveRouteChannel: opts.resolveRouteChannel } : {}),
-        emitTrace: (e) => traces.push(e),
-        addMessage: (p, c, m) => { messages.push({ participant: p, content: c, metadata: m }); return ''; },
-        requestInference: (a, r, s, p) => inferenceRequests.push({ agentName: a, reason: r, source: s, ...(p ?? {}) }),
-        getAgentNames: () => ['agent'],
-    });
-    return { gate, traces, messages, inferenceRequests };
-}
-function event(overrides) {
-    return {
-        content: 'test message',
-        eventType: 'mcpl:push-event',
-        serverId: '',
-        channelId: '',
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// Setup / Teardown
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    mkdirSync(TMP_DIR, { recursive: true });
-});
-afterEach(() => {
-    if (existsSync(TMP_DIR)) {
-        rmSync(TMP_DIR, { recursive: true, force: true });
-    }
-});
-// ---------------------------------------------------------------------------
-// Default behavior (no config file)
-// ---------------------------------------------------------------------------
-describe('default behavior', () => {
-    it('no config file + no initial config → all-pass', () => {
-        const { gate } = makeGate(tmpPath('nonexistent.json'));
-        const decision = gate.evaluate(event());
-        assert.strictEqual(decision.trigger, true);
-        assert.strictEqual(decision.policyName, null);
-    });
-    it('default: skip → all skipped', () => {
-        const path = writeConfig('skip-default.json', {
-            policies: [],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        const decision = gate.evaluate(event());
-        assert.strictEqual(decision.trigger, false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Policy matching
-// ---------------------------------------------------------------------------
-describe('policy matching', () => {
-    it('scope match — matching event type', () => {
-        const path = writeConfig('scope.json', {
-            policies: [
-                { name: 'channels', match: { scope: ['mcpl:channel-incoming'] }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'mcpl:channel-incoming' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'mcpl:push-event' })).trigger, false);
-    });
-    it('source match — exact serverId', () => {
-        const path = writeConfig('source.json', {
-            policies: [
-                { name: 'zulip', match: { source: 'zulip' }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'zulip' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'discord' })).trigger, false);
-    });
-    it('source match — glob pattern', () => {
-        const path = writeConfig('source-glob.json', {
-            policies: [
-                { name: 'any-zulip', match: { source: 'zulip-*' }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'zulip-prod' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'zulip-staging' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'discord' })).trigger, false);
-    });
-    it('channel match — glob pattern', () => {
-        const path = writeConfig('channel-glob.json', {
-            policies: [
-                { name: 'dev-channels', match: { channel: 'dev-*' }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ channelId: 'dev-backend' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ channelId: 'prod-alerts' })).trigger, false);
-    });
-    it('mount match — exact name', () => {
-        const path = writeConfig('mount-exact.json', {
-            policies: [
-                {
-                    name: 'tickets',
-                    match: { scope: ['workspace:created'], mount: 'knowledge-requests' },
-                    behavior: 'always',
-                },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:created', mount: 'knowledge-requests', paths: ['knowledge-requests/t1.md'] })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:created', mount: 'library-mined', paths: ['library-mined/r1.md'] })).trigger, false);
-        // Event without a mount must not match a mount-scoped policy.
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:created' })).trigger, false);
-    });
-    it('pathGlob match — any path matches', () => {
-        const path = writeConfig('path-glob.json', {
-            policies: [
-                {
-                    name: 'md-only',
-                    match: { scope: ['workspace:modified'], pathGlob: '*.md' },
-                    behavior: 'always',
-                },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:modified', paths: ['tickets/a.md'] })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:modified', paths: ['logs/a.txt'] })).trigger, false);
-        // ANY-match: one matching path is enough.
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:modified', paths: ['logs/a.txt', 'tickets/b.md'] })).trigger, true);
-        // Empty paths can't match a pathGlob policy.
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:modified', paths: [] })).trigger, false);
-    });
-    it('content filter — text match (case insensitive)', () => {
-        const path = writeConfig('filter-text.json', {
-            policies: [
-                { name: 'errors', match: { filter: { type: 'text', pattern: 'ERROR' } }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ content: 'Something error happened' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ content: 'All good' })).trigger, false);
-    });
-    it('content filter — regex match', () => {
-        const path = writeConfig('filter-regex.json', {
-            policies: [
-                { name: 'deploys', match: { filter: { type: 'regex', pattern: 'deploy|rollback' } }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ content: 'Starting deploy v2.3' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ content: 'rollback initiated' })).trigger, true);
-        assert.strictEqual(gate.evaluate(event({ content: 'Rolling back' })).trigger, false);
-    });
-    it('combined match — scope + source + filter (AND logic)', () => {
-        const path = writeConfig('combined.json', {
-            policies: [
-                {
-                    name: 'zulip-errors',
-                    match: {
-                        scope: ['mcpl:channel-incoming'],
-                        source: 'zulip',
-                        filter: { type: 'text', pattern: 'error' },
-                    },
-                    behavior: 'always',
-                },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        // All conditions met
-        assert.strictEqual(gate.evaluate(event({
-            content: 'An error occurred',
-            eventType: 'mcpl:channel-incoming',
-            serverId: 'zulip',
-        })).trigger, true);
-        // Wrong scope
-        assert.strictEqual(gate.evaluate(event({
-            content: 'An error occurred',
-            eventType: 'mcpl:push-event',
-            serverId: 'zulip',
-        })).trigger, false);
-        // Wrong source
-        assert.strictEqual(gate.evaluate(event({
-            content: 'An error occurred',
-            eventType: 'mcpl:channel-incoming',
-            serverId: 'discord',
-        })).trigger, false);
-        // No error keyword
-        assert.strictEqual(gate.evaluate(event({
-            content: 'All good',
-            eventType: 'mcpl:channel-incoming',
-            serverId: 'zulip',
-        })).trigger, false);
-    });
-    it('first match wins — order matters', () => {
-        const path = writeConfig('order.json', {
-            policies: [
-                { name: 'suppress-noise', match: { filter: { type: 'text', pattern: 'heartbeat' } }, behavior: 'skip' },
-                { name: 'catch-all', match: {}, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ content: 'heartbeat ping' })).trigger, false);
-        assert.strictEqual(gate.evaluate(event({ content: 'real message' })).trigger, true);
-    });
-    it('empty match object matches everything', () => {
-        const path = writeConfig('empty-match.json', {
-            policies: [
-                { name: 'catch-all', match: {}, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event({ serverId: 'any', channelId: 'any' })).trigger, true);
-    });
-});
-// ---------------------------------------------------------------------------
-// Behaviors
-// ---------------------------------------------------------------------------
-describe('behaviors', () => {
-    it('always → trigger: true', () => {
-        const path = writeConfig('always.json', {
-            policies: [{ name: 'all', match: {}, behavior: 'always' }],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        const d = gate.evaluate(event());
-        assert.strictEqual(d.trigger, true);
-        assert.strictEqual(d.behavior, 'always');
-    });
-    it('skip → trigger: false', () => {
-        const path = writeConfig('skip.json', {
-            policies: [{ name: 'quiet', match: {}, behavior: 'skip' }],
-            default: 'always',
-        });
-        const { gate } = makeGate(path);
-        const d = gate.evaluate(event());
-        assert.strictEqual(d.trigger, false);
-        assert.strictEqual(d.behavior, 'skip');
-        assert.strictEqual(d.policyName, 'quiet');
-    });
-});
-// ---------------------------------------------------------------------------
-// Debounce
-// ---------------------------------------------------------------------------
-describe('debounce', () => {
-    it('returns false immediately', () => {
-        const path = writeConfig('debounce.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        const d = gate.evaluate(event());
-        assert.strictEqual(d.trigger, false);
-        assert.deepStrictEqual(d.behavior, { debounce: 100 });
-    });
-    it('batches events and fires after delay', async () => {
-        const path = writeConfig('debounce-fire.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 150 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ content: 'edit 1' }));
-        gate.evaluate(event({ content: 'edit 2' }));
-        gate.evaluate(event({ content: 'edit 3' }));
-        // Should not have delivered yet
-        assert.strictEqual(messages.length, 0);
-        // Wait for debounce to fire
-        await new Promise(r => setTimeout(r, 200));
-        assert.strictEqual(messages.length, 1);
-        const text = messages[0].content[0].text;
-        assert.ok(text.includes('3 event'));
-        // MCPL events (push-event / channel-incoming) are stored in the context
-        // window AT ARRIVAL by the framework, so the batched wake references them
-        // instead of re-quoting — a re-quote minutes later reads as fresh, stale
-        // duplicate input (observed live: Sol's "step was a bit too small" echo).
-        assert.ok(text.includes('already shown above'));
-        assert.ok(!text.includes('edit 1'), 'must not re-quote in-context event content');
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].agentName, 'agent');
-    });
-    it('a batched wake carries the newest channel event\'s channel AND author together (provenance)', async () => {
-        const path = writeConfig('debounce-provenance.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:alice-room', content: 'a',
-            metadata: { author: { id: '111', name: 'alice' } } }));
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:bob-room', content: 'b',
-            metadata: { authorId: '222' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].reason, 'gate:debounce');
-        assert.strictEqual(inferenceRequests[0].channelId, 'discord:g:bob-room', 'newest channel event wins when none is addressed');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'discord:user:222', 'author comes from the SAME event as the channel');
-        assert.strictEqual(inferenceRequests[0].addressed, undefined);
-    });
-    it('an older ADDRESSED event outranks newer ambient chatter — channel, author and addressed stay together', async () => {
-        const path = writeConfig('debounce-addressed.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:alice-room', content: 'hey agent',
-            tags: ['chat:addressed'], metadata: { author: { id: '111' } } }));
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:bob-room', content: 'ambient',
-            metadata: { authorId: '222' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].channelId, 'discord:g:alice-room');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'discord:user:111');
-        assert.strictEqual(inferenceRequests[0].addressed, true);
-    });
-    it('the counterparty is namespaced by the event\'s server id, not the channel id\'s first segment', async () => {
-        const path = writeConfig('debounce-namespace.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'beta', channelId: 'shared', content: 'x',
-            metadata: { authorId: '42' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests[0].channelId, 'shared');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'beta:user:42');
-        assert.ok(typeof inferenceRequests[0].at === 'number', 'provenance carries the chosen event\'s timestamp');
-    });
-    it('a push-event wake (raw adapter channel id) names its author but reports no channel', async () => {
-        const path = writeConfig('debounce-push-raw.json', {
-            policies: [
-                { name: 'all', match: { scope: ['mcpl:push-event', 'mcpl:channel-incoming'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        // exactly what PushHandler builds for a discord-mcpl DM push event
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'discord', channelId: '123456789012345678', content: 'hi',
-            tags: ['chat:dm', 'chat:addressed', 'chat:private'], metadata: { authorId: '42', channelId: '123456789012345678' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].channelId, undefined, 'a raw snowflake is not a composite channel id — not reported');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'discord:user:42');
-        assert.strictEqual(inferenceRequests[0].addressed, true);
-    });
-    it('an addressed batch names its registered route channel; ambient-only batches name none', async () => {
-        const path = writeConfig('debounce-route.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming', 'mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        // The host maps a push origin to its registered composite id.
-        const resolveRouteChannel = (info) => info.eventType === 'mcpl:push-event' ? `discord:dm:${String(info.metadata?.channelId)}` : info.channelId;
-        const { gate, inferenceRequests, messages } = makeGate(path, { resolveRouteChannel });
-        // DM (addressed, raw id) then newer ambient chatter elsewhere.
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'discord', channelId: '1548', content: 'dm',
-            tags: ['chat:dm', 'chat:addressed'], metadata: { authorId: '42', channelId: '1548' } }));
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:general', content: 'chatter',
-            metadata: { authorId: '7' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].routeChannelId, 'discord:dm:1548', 'the addressed event names the route');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'discord:user:42', 'route and author come from the same event');
-        assert.strictEqual(inferenceRequests[0].channelId, undefined, 'telemetry channel unchanged for push events');
-        // The batched-wake line names the registered id, not the raw snowflake.
-        const text = JSON.stringify(messages.at(-1)?.content);
-        assert.ok(text.includes('discord:dm:1548'), 'gate line shows the registered channel id');
-        // Ambient-only batch: telemetry provenance, no route.
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:room', content: 'x',
-            metadata: { authorId: '8' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 2);
-        assert.strictEqual(inferenceRequests[1].channelId, 'discord:g:room');
-        assert.strictEqual(inferenceRequests[1].routeChannelId, undefined, 'ambient chatter never sets a route');
-    });
-    it('the default resolver routes an addressed channel-incoming event; a push event needs the host resolver', async () => {
-        const path = writeConfig('debounce-route-default.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming', 'mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:room', content: '@agent hi',
-            tags: ['chat:addressed'], metadata: { authorId: '1' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests[0].routeChannelId, 'discord:g:room');
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'discord', channelId: '1548', content: 'dm',
-            tags: ['chat:dm', 'chat:addressed'], metadata: { authorId: '42', channelId: '1548' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests[1].routeChannelId, undefined, 'a raw id is never used as a route');
-    });
-    it('the newest addressed event decides the route even when it has none (no guessing an older one)', async () => {
-        const path = writeConfig('debounce-route-newest.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming', 'mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path); // default resolver: push → no route
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:room', content: '@agent first',
-            tags: ['chat:addressed'], metadata: { authorId: '1' } }));
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'discord', channelId: '1548', content: 'dm later',
-            tags: ['chat:dm', 'chat:addressed'], metadata: { authorId: '42', channelId: '1548' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests[0].counterparty, 'discord:user:42');
-        assert.strictEqual(inferenceRequests[0].routeChannelId, undefined, 'the DM is the newest addressed event; replying to the older mention would answer the wrong person');
-    });
-    it('an addressed push that names only its registered channel (no raw id, no author) still routes', async () => {
-        const path = writeConfig('debounce-route-only.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming', 'mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const resolveRouteChannel = (info) => typeof info.metadata?.mcplChannelId === 'string' ? info.metadata.mcplChannelId : undefined;
-        const { gate, inferenceRequests } = makeGate(path, { resolveRouteChannel });
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'surface', channelId: 'surface:room:general',
-            content: 'chatter', metadata: { authorId: '7' } }));
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'surface', content: 'dm',
-            tags: ['chat:dm', 'chat:addressed'], metadata: { mcplChannelId: 'surface:dm:42' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].routeChannelId, 'surface:dm:42');
-        assert.strictEqual(inferenceRequests[0].addressed, true);
-        assert.strictEqual(inferenceRequests[0].counterparty, undefined, 'no author on the chosen event, none borrowed from the chatter');
-    });
-    it('a newer AMBIENT route-only push does not hide an earlier event\'s channel and author', async () => {
-        const path = writeConfig('debounce-route-only-ambient.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming', 'mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const resolveRouteChannel = (info) => typeof info.metadata?.mcplChannelId === 'string' ? info.metadata.mcplChannelId : info.channelId || undefined;
-        const { gate, inferenceRequests } = makeGate(path, { resolveRouteChannel });
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'surface', channelId: 'surface:room:general',
-            content: 'chatter', metadata: { authorId: '7' } }));
-        gate.evaluate(event({ eventType: 'mcpl:push-event', serverId: 'surface', content: 'status ping',
-            metadata: { mcplChannelId: 'surface:room:feed' } }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].channelId, 'surface:room:general', 'telemetry keeps the attributable event');
-        assert.strictEqual(inferenceRequests[0].counterparty, 'surface:user:7');
-        assert.strictEqual(inferenceRequests[0].routeChannelId, undefined, 'ambient batches never route');
-    });
-    it('a throwing route resolver never breaks gating', async () => {
-        const path = writeConfig('debounce-route-throw.json', {
-            policies: [
-                { name: 'chat', match: { scope: ['mcpl:channel-incoming'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path, { resolveRouteChannel: () => { throw new Error('boom'); } });
-        const decision = gate.evaluate(event({ eventType: 'mcpl:channel-incoming', serverId: 'discord', channelId: 'discord:g:room',
-            content: '@agent hi', tags: ['chat:addressed'] }));
-        assert.strictEqual(decision.policyName, 'chat');
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].routeChannelId, undefined);
-    });
-    it('a batched wake with no channel-bearing event carries no provenance', async () => {
-        const path = writeConfig('debounce-noprov.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, inferenceRequests } = makeGate(path);
-        gate.evaluate(event({ content: 'edit' }));
-        await new Promise(r => setTimeout(r, 150));
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(inferenceRequests[0].channelId, undefined);
-        assert.strictEqual(inferenceRequests[0].counterparty, undefined);
-    });
-    it('quotes content for non-MCPL events (no context entry of their own)', async () => {
-        const path = writeConfig('debounce-quote.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['module:custom'] }, behavior: { debounce: 150 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.evaluate(event({ content: 'compile finished', eventType: 'module:custom' }));
-        await new Promise(r => setTimeout(r, 200));
-        assert.strictEqual(messages.length, 1);
-        const text = messages[0].content[0].text;
-        assert.ok(text.includes('[editor]'));
-        assert.ok(text.includes('compile finished'), 'non-MCPL events carry their content');
-    });
-    it('resets timer on new events', async () => {
-        const path = writeConfig('debounce-reset.json', {
-            policies: [
-                { name: 'editor', match: {}, behavior: { debounce: 150 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.evaluate(event({ content: 'edit 1' }));
-        await new Promise(r => setTimeout(r, 80));
-        // Timer hasn't fired yet, send another
-        gate.evaluate(event({ content: 'edit 2' }));
-        await new Promise(r => setTimeout(r, 80));
-        // Still within debounce window of second event
-        assert.strictEqual(messages.length, 0);
-        await new Promise(r => setTimeout(r, 100));
-        // Now it should have fired
-        assert.strictEqual(messages.length, 1);
-    });
-});
-// ---------------------------------------------------------------------------
-// Debounce bounds validation
-// ---------------------------------------------------------------------------
-describe('debounce bounds', () => {
-    it('rejects debounce < 100ms', () => {
-        const path = tmpPath('low-debounce.json');
-        mkdirSync(TMP_DIR, { recursive: true });
-        writeFileSync(path, JSON.stringify({
-            policies: [{ name: 'fast', match: {}, behavior: { debounce: 50 } }],
-            default: 'always',
-        }));
-        const { gate, traces } = makeGate(path);
-        // Should fall back to default config, emit error trace
-        assert.strictEqual(gate.evaluate(event()).trigger, true);
-        assert.ok(traces.some(t => t.type === 'gate:config-error'));
-    });
-    it('rejects debounce > 300000ms', () => {
-        const path = tmpPath('high-debounce.json');
-        mkdirSync(TMP_DIR, { recursive: true });
-        writeFileSync(path, JSON.stringify({
-            policies: [{ name: 'slow', match: {}, behavior: { debounce: 500000 } }],
-            default: 'always',
-        }));
-        const { gate, traces } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event()).trigger, true);
-        assert.ok(traces.some(t => t.type === 'gate:config-error'));
-    });
-});
-// ---------------------------------------------------------------------------
-// Inference buffering
-// ---------------------------------------------------------------------------
-describe('inference buffering', () => {
-    it('inference buffer is capped at MAX_INFERENCE_BUFFER', async () => {
-        const path = writeConfig('infer-cap.json', {
-            policies: [
-                { name: 'chat', match: {}, behavior: { debounce: 100 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.onInferenceStarted('agent');
-        // Fire many debounce batches — each with 20 events, 6 batches = 120 events
-        for (let batch = 0; batch < 6; batch++) {
-            for (let i = 0; i < 20; i++) {
-                gate.evaluate(event({ content: `batch${batch}-msg${i}` }));
-            }
-            // Let debounce fire (into inference buffer since inferring)
-            await new Promise(r => setTimeout(r, 150));
-        }
-        // Buffer should be capped at 100 (oldest dropped)
-        const bufferLen = gate.inferenceBuffer.length;
-        assert.ok(bufferLen <= 100, `Expected buffer <= 100, got ${bufferLen}`);
-        assert.ok(bufferLen > 0, 'Expected buffer to have events');
-        // First event should NOT be from batch 0 (those were dropped)
-        const firstEvent = gate.inferenceBuffer[0];
-        assert.ok(!firstEvent.content.startsWith('batch0'), `Expected oldest events dropped, but first is ${firstEvent.content}`);
-        // End inference → flush
-        gate.onInferenceEnded('agent');
-        await new Promise(r => setTimeout(r, 10));
-        assert.strictEqual(messages.length, 1);
-        gate.dispose();
-    });
-    it('debounce during inference → buffer → flush on end', async () => {
-        const path = writeConfig('infer-debounce.json', {
-            policies: [
-                { name: 'chat', match: {}, behavior: { debounce: 150 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.evaluate(event({ content: 'msg 1' }));
-        gate.evaluate(event({ content: 'msg 2' }));
-        // Simulate inference started before debounce fires
-        gate.onInferenceStarted('agent');
-        // Wait for debounce timer to fire
-        await new Promise(r => setTimeout(r, 200));
-        // Should be buffered, not delivered (inference is active)
-        assert.strictEqual(messages.length, 0);
-        // End inference → flush
-        gate.onInferenceEnded('agent');
-        // queueMicrotask defers delivery
-        await new Promise(r => setTimeout(r, 10));
-        assert.strictEqual(messages.length, 1);
-    });
-});
-// ---------------------------------------------------------------------------
-// Config hot-reload
-// ---------------------------------------------------------------------------
-describe('config hot-reload', () => {
-    it('reloads config when file changes', async () => {
-        const path = writeConfig('reload.json', {
-            policies: [{ name: 'all', match: {}, behavior: 'always' }],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event()).trigger, true);
-        // Force throttle to expire
-        gate.lastReloadCheck = 0;
-        // Wait for mtime to differ
-        await new Promise(r => setTimeout(r, 50));
-        // Rewrite config — now skip everything
-        writeFileSync(path, JSON.stringify({ policies: [], default: 'skip' }));
-        assert.strictEqual(gate.evaluate(event()).trigger, false);
-    });
-    it('config error keeps previous valid config', async () => {
-        const path = writeConfig('error-reload.json', {
-            policies: [{ name: 'all', match: {}, behavior: 'always' }],
-            default: 'skip',
-        });
-        const { gate, traces } = makeGate(path);
-        assert.strictEqual(gate.evaluate(event()).trigger, true);
-        // Force throttle to expire
-        gate.lastReloadCheck = 0;
-        await new Promise(r => setTimeout(r, 50));
-        // Write invalid JSON
-        writeFileSync(path, 'not valid json{{{');
-        // Should still use previous config
-        assert.strictEqual(gate.evaluate(event()).trigger, true);
-        assert.ok(traces.some(t => t.type === 'gate:config-error'));
-    });
-});
-// ---------------------------------------------------------------------------
-// Config seeding
-// ---------------------------------------------------------------------------
-describe('config seeding', () => {
-    it('seeds config file from initialConfig when file does not exist', () => {
-        const path = tmpPath('seeded.json');
-        const config = {
-            policies: [{ name: 'test', match: {}, behavior: 'always' }],
-            default: 'skip',
-        };
-        makeGate(path, { initialConfig: config });
-        assert.ok(existsSync(path));
-        const written = JSON.parse(readFileSync(path, 'utf-8'));
-        assert.strictEqual(written.policies[0].name, 'test');
-    });
-    it('does not overwrite existing file', () => {
-        const path = writeConfig('existing.json', {
-            policies: [{ name: 'original', match: {}, behavior: 'always' }],
-            default: 'always',
-        });
-        makeGate(path, {
-            initialConfig: {
-                policies: [{ name: 'new', match: {}, behavior: 'skip' }],
-                default: 'skip',
-            },
-        });
-        const written = JSON.parse(readFileSync(path, 'utf-8'));
-        assert.strictEqual(written.policies[0].name, 'original');
-    });
-});
-// ---------------------------------------------------------------------------
-// gate:status tool
-// ---------------------------------------------------------------------------
-describe('gate:status tool', () => {
-    it('returns correct status structure', async () => {
-        const path = writeConfig('status.json', {
-            policies: [
-                { name: 'always-policy', match: {}, behavior: 'always' },
-                { name: 'debounce-policy', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 1000 } },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        // Trigger some matches
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming' }));
-        gate.evaluate(event({ eventType: 'mcpl:channel-incoming' }));
-        const result = await gate.handleToolCall();
-        assert.strictEqual(result.success, true);
-        const status = result.data;
-        assert.strictEqual(status.configPath, path);
-        assert.strictEqual(status.configSource, 'file');
-        assert.strictEqual(status.default, 'skip');
-        assert.strictEqual(status.policies.length, 2);
-        assert.strictEqual(status.policies[0].name, 'always-policy');
-        assert.strictEqual(status.policies[0].matchCount, 2);
-        assert.strictEqual(status.errors.length, 0);
-    });
-});
-// ---------------------------------------------------------------------------
-// asShouldTriggerCallback
-// ---------------------------------------------------------------------------
-describe('asShouldTriggerCallback', () => {
-    it('returns a function with the shouldTriggerInference signature', () => {
-        const path = writeConfig('callback.json', {
-            policies: [
-                { name: 'allow-zulip', match: { source: 'zulip' }, behavior: 'always' },
-            ],
-            default: 'skip',
-        });
-        const { gate } = makeGate(path);
-        const cb = gate.asShouldTriggerCallback();
-        assert.strictEqual(typeof cb, 'function');
-        assert.strictEqual(cb('hello', { eventType: 'mcpl:push-event', serverId: 'zulip' }), true);
-        assert.strictEqual(cb('hello', { eventType: 'mcpl:push-event', serverId: 'discord' }), false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Trace events
-// ---------------------------------------------------------------------------
-describe('trace events', () => {
-    it('emits gate:policy-matched on match', () => {
-        const path = writeConfig('trace-match.json', {
-            policies: [{ name: 'test', match: {}, behavior: 'always' }],
-            default: 'skip',
-        });
-        const { gate, traces } = makeGate(path);
-        gate.evaluate(event());
-        const matchTraces = traces.filter(t => t.type === 'gate:policy-matched');
-        assert.strictEqual(matchTraces.length, 1);
-        assert.strictEqual(matchTraces[0].policyName, 'test');
-    });
-    it('emits gate:config-reloaded on successful reload', async () => {
-        const path = writeConfig('trace-reload.json', {
-            policies: [],
-            default: 'always',
-        });
-        const { gate, traces } = makeGate(path);
-        gate.evaluate(event()); // initial eval
-        gate.lastReloadCheck = 0;
-        await new Promise(r => setTimeout(r, 50));
-        writeFileSync(path, JSON.stringify({ policies: [{ name: 'new', match: {}, behavior: 'skip' }], default: 'always' }));
-        gate.evaluate(event());
-        assert.ok(traces.some(t => t.type === 'gate:config-reloaded'));
-    });
-});
-// ---------------------------------------------------------------------------
-// Cleanup
-// ---------------------------------------------------------------------------
-describe('dispose', () => {
-    it('clears debounce timers without delivering', () => {
-        const path = writeConfig('dispose.json', {
-            policies: [{ name: 'debounced', match: {}, behavior: { debounce: 10000 } }],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.evaluate(event());
-        gate.dispose();
-        // No delivery should happen
-        assert.strictEqual(messages.length, 0);
-    });
-});
-// ---------------------------------------------------------------------------
-// Policy reconciliation on restart (postmortem: clerk stuck on old policies)
-// ---------------------------------------------------------------------------
-describe('policy reconciliation', () => {
-    it('appends missing-by-name policies from initialConfig when gate.json already exists', () => {
-        // Simulate a prior session that seeded gate.json with 2 policies
-        const path = writeConfig('reconcile-add.json', {
-            default: 'skip',
-            policies: [
-                { name: 'user-input', match: { scope: ['external-message'] }, behavior: 'always' },
-                { name: 'subagent-completions', match: { scope: ['inference-request'] }, behavior: 'always' },
-            ],
-        });
-        // New session starts with a recipe that added a third policy
-        const { gate, traces } = makeGate(path, {
-            initialConfig: {
-                default: 'skip',
-                policies: [
-                    { name: 'user-input', match: { scope: ['external-message'] }, behavior: 'always' },
-                    { name: 'subagent-completions', match: { scope: ['inference-request'] }, behavior: 'always' },
-                    { name: 'reviewed-responses', match: { scope: ['workspace:created'] }, behavior: 'always' },
-                ],
-            },
-        });
-        // gate.json on disk should now contain all three policies
-        const onDisk = JSON.parse(readFileSync(path, 'utf-8'));
-        assert.strictEqual(onDisk.policies.length, 3);
-        assert.ok(onDisk.policies.some((p) => p.name === 'reviewed-responses'));
-        // Reconciliation trace emitted
-        assert.ok(traces.some(t => t.type === 'gate:config-reconciled'));
-        // Live gate honors the new policy
-        assert.strictEqual(gate.evaluate(event({ eventType: 'workspace:created' })).trigger, true);
-    });
-    it("leaves existing policies alone — user's workspace--edit survives recipe changes", () => {
-        const path = writeConfig('reconcile-preserve.json', {
-            default: 'skip',
-            policies: [
-                {
-                    name: 'user-input',
-                    // User edited this policy to also filter on content
-                    match: { scope: ['external-message'], filter: { type: 'text', pattern: 'urgent' } },
-                    behavior: 'always',
-                },
-            ],
-        });
-        makeGate(path, {
-            initialConfig: {
-                default: 'skip',
-                policies: [
-                    // Recipe declares it without the filter
-                    { name: 'user-input', match: { scope: ['external-message'] }, behavior: 'always' },
-                ],
-            },
-        });
-        const onDisk = JSON.parse(readFileSync(path, 'utf-8'));
-        assert.strictEqual(onDisk.policies.length, 1);
-        assert.deepStrictEqual(onDisk.policies[0].match.filter, { type: 'text', pattern: 'urgent' });
-    });
-});
-// ---------------------------------------------------------------------------
-// Observability: defaultDecisions counts help diagnose silent drops
-// ---------------------------------------------------------------------------
-describe('defaultDecisions counters', () => {
-    it('counts events that fell through to default (by eventType)', () => {
-        const path = writeConfig('default-counts.json', {
-            default: 'skip',
-            policies: [
-                { name: 'user-input', match: { scope: ['external-message'] }, behavior: 'always' },
-            ],
-        });
-        const { gate } = makeGate(path);
-        gate.evaluate(event({ eventType: 'external-message' })); // matches
-        gate.evaluate(event({ eventType: 'workspace:created' })); // default skip
-        gate.evaluate(event({ eventType: 'workspace:created' })); // default skip
-        gate.evaluate(event({ eventType: 'other' })); // default skip
-        const status = gate.getStatus();
-        assert.strictEqual(status.totalEvaluations, 4);
-        assert.strictEqual(status.defaultDecisions.skipped, 3);
-        assert.strictEqual(status.defaultDecisions.triggered, 0);
-        assert.strictEqual(status.defaultDecisions.byEventType['workspace:created'].skipped, 2);
-        assert.strictEqual(status.defaultDecisions.byEventType['other'].skipped, 1);
-    });
-});
-// ---------------------------------------------------------------------------
-// Host quiesce suppression (issue #122)
-// ---------------------------------------------------------------------------
-describe('quiesce suppression', () => {
-    it('buffers debounce firings while quiesced and flushes on setQuiesced(false)', async () => {
-        const path = writeConfig('quiesce-debounce.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 120 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages, inferenceRequests } = makeGate(path);
-        gate.setQuiesced(true);
-        gate.evaluate(event({ content: 'edit 1' }));
-        gate.evaluate(event({ content: 'edit 2' }));
-        // Debounce fires while quiesced → buffered, no context write, no wake.
-        await new Promise(r => setTimeout(r, 250));
-        assert.strictEqual(messages.length, 0, 'no gate message mid-surgery');
-        assert.strictEqual(inferenceRequests.length, 0);
-        assert.strictEqual(gate.inferenceDiagnostics().bufferedEvents, 2);
-        gate.setQuiesced(false);
-        await new Promise(r => setTimeout(r, 20)); // flush is deferred a microtask
-        assert.strictEqual(messages.length, 1, 'buffered events compose one delivery');
-        assert.strictEqual(inferenceRequests.length, 1);
-        assert.strictEqual(gate.inferenceDiagnostics().bufferedEvents, 0);
-    });
-    it('a turn ending while quiesced does not flush the buffer', async () => {
-        const path = writeConfig('quiesce-turn-end.json', {
-            policies: [
-                { name: 'editor', match: { scope: ['mcpl:push-event'] }, behavior: { debounce: 120 } },
-            ],
-            default: 'skip',
-        });
-        const { gate, messages } = makeGate(path);
-        gate.setQuiesced(true);
-        gate.onInferenceStarted('agent');
-        gate.evaluate(event({ content: 'during drain' }));
-        await new Promise(r => setTimeout(r, 250));
-        gate.onInferenceEnded('agent'); // drain completes mid-quiesce
-        await new Promise(r => setTimeout(r, 20));
-        assert.strictEqual(messages.length, 0, 'buffer holds until resume, not turn end');
-        assert.strictEqual(gate.inferenceDiagnostics().bufferedEvents, 1);
-    });
-});
-//# sourceMappingURL=event-gate.test.js.map