@animalabs/agent-framework 0.22.2 → 0.22.4

package/dist/test/trunk-channel-routing.test.js

@@ -1,652 +0,0 @@
-/**
- * Item-3 redux: single-TRUNK output routing.
- *
- * These tests cover the FRAMEWORK-side plumbing that feeds the ChannelRegistry's
- * `activeChannelResolver` (the routing DECISION itself is covered in
- * channel-registry-routing.test.ts):
- *   - derivePushEventChannel() reconstructs the MCPL composite channel for a
- *     push event (Discord DMs arrive this way), preferring an explicit
- *     origin.mcplChannelId.
- *   - a channel-incoming turn records its triggering channel per-agent.
- *   - a DM push-event turn records the reconstructed DM channel per-agent.
- *   - a batched wake picks the MOST-RECENT triggering channel.
- *
- * connectome-host runs every agent as a single trunk (it never sets
- * `conversations`), so no fork/home exists — the active triggering channel is
- * the only thing that keeps a reply in the channel it is answering.
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { tmpdir } from 'node:os';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { AgentFramework } from '../src/index.js';
-import { MockMembrane, createMockResponse } from './helpers/mock-membrane.js';
-import { MembraneError } from '@animalabs/membrane';
-/** Reach the private per-turn routing state (its triggering channel) + the pure channel-deriver. */
-function internals(framework) {
-    return framework;
-}
-function channelIncoming(channelId, text) {
-    return {
-        type: 'mcpl:channel-incoming',
-        serverId: 'discord',
-        channelId,
-        messageId: `m-${Math.random().toString(36).slice(2)}`,
-        author: { id: 'U1', name: 'antra' },
-        content: [{ type: 'text', text }],
-        timestamp: new Date().toISOString(),
-        metadata: {},
-        triggerInference: true,
-    };
-}
-/** A Discord DM as discord-mcpl forwards it: a push/event whose origin carries
- *  the raw channel (guildId null) — no channels/incoming, no open channel. */
-function dmPushEvent(rawChannelId, text) {
-    return {
-        type: 'mcpl:push-event',
-        serverId: 'discord',
-        featureSet: 'discord.messaging',
-        eventId: `discord_msg_${Math.random().toString(36).slice(2)}`,
-        content: [{ type: 'text', text }],
-        origin: {
-            source: 'discord',
-            channelId: rawChannelId,
-            guildId: null,
-            channelName: undefined,
-            isDM: true,
-        },
-        timestamp: new Date().toISOString(),
-        inferenceId: `inf-${Math.random().toString(36).slice(2)}`,
-        triggerInference: true,
-    };
-}
-describe('Trunk channel routing (item-3 redux)', () => {
-    let tempDir;
-    let membrane;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'trunk-routing-test-'));
-        membrane = new MockMembrane();
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    async function makeFramework() {
-        // NO `conversations` — this is connectome-host's single-trunk mode.
-        return AgentFramework.create({
-            storePath: join(tempDir, 'test.chronicle'),
-            membrane: membrane.asMembrane(),
-            agents: [{ name: 'scout', model: 'test-model', systemPrompt: 'You are scout.' }],
-            modules: [],
-        });
-    }
-    it('derivePushEventChannel prefers an explicit origin.mcplChannelId', async () => {
-        const framework = await makeFramework();
-        const got = internals(framework).derivePushEventChannel({
-            source: 'discord',
-            mcplChannelId: 'discord:dm:999',
-            channelName: 'DM with Antra',
-            channelId: '999',
-        });
-        assert.deepEqual(got, { channelId: 'discord:dm:999', label: 'DM with Antra' });
-        await framework.stop();
-    });
-    it('derivePushEventChannel reconstructs a Discord DM composite (guildId null -> dm)', async () => {
-        const framework = await makeFramework();
-        const got = internals(framework).derivePushEventChannel({
-            source: 'discord',
-            channelId: '42',
-            guildId: null,
-            isDM: true,
-        });
-        assert.deepEqual(got, { channelId: 'discord:dm:42' });
-        await framework.stop();
-    });
-    it('derivePushEventChannel reconstructs a non-open guild channel composite', async () => {
-        const framework = await makeFramework();
-        const got = internals(framework).derivePushEventChannel({
-            source: 'discord',
-            channelId: 'C7',
-            guildId: 'G1',
-        });
-        assert.deepEqual(got, { channelId: 'discord:G1:C7' });
-        await framework.stop();
-    });
-    it('derivePushEventChannel returns undefined for a channel-less push (heartbeat)', async () => {
-        const framework = await makeFramework();
-        const i = internals(framework);
-        assert.equal(i.derivePushEventChannel(undefined), undefined);
-        assert.equal(i.derivePushEventChannel({ source: 'heartbeat', kind: 'tick' }), undefined);
-        await framework.stop();
-    });
-    it('adds an actionable invitation when addressed in a closed channel', async () => {
-        const framework = await makeFramework();
-        const i = internals(framework);
-        i.channelRegistry = {
-            ensureChannelRegistered: () => { },
-            isChannelOpen: () => false,
-            getDescriptor: () => ({ capabilities: { history: { maxMessages: 80 } } }),
-            stopAll: () => { },
-        };
-        i.handleMcplPushEvent({
-            type: 'mcpl:push-event',
-            serverId: 'discord',
-            featureSet: 'discord.messaging',
-            eventId: 'discord_msg_m1',
-            content: [{ type: 'text', text: 'Antra: can you look at this?' }],
-            origin: {
-                source: 'discord',
-                messageId: 'm1',
-                mcplChannelId: 'discord:G1:C7',
-                channelName: 'portables',
-            },
-            tags: ['chat:mention', 'chat:addressed'],
-            timestamp: new Date().toISOString(),
-            inferenceId: 'i1',
-            triggerInference: false,
-        });
-        const messages = framework.getAgent('scout').getContextManager().queryMessages({}).messages;
-        const text = messages.at(-1)?.content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n') ?? '';
-        assert.match(text, /Channel invitation/);
-        assert.match(text, /channel_open/);
-        // 2026-07-21 rewrite: names resolved, numbered options, backscroll hint
-        // phrased as "a number up to N", explicit permission to do nothing.
-        assert.match(text, /#portables/);
-        assert.match(text, /backscroll \(a number up to 80\)/);
-        assert.match(text, /channel_decline/);
-        assert.match(text, /optionally set acknowledge/);
-        assert.match(text, /Doing nothing is also fine\./);
-        // 2026-08-05 accuracy pass: the delivery model must be stated correctly —
-        // direct addresses still arrive; un-@'d follow-ups to a reply do not.
-        assert.match(text, /address you directly/);
-        assert.match(text, /follow-ups to your reply will NOT reach you/);
-        // No surface-tracked tally on this event → no missed-count sentence.
-        assert.doesNotMatch(text, /passed there without you/);
-        await framework.stop();
-    });
-    it('surfaces the missed-ambient tally in the closed-channel invitation', async () => {
-        const framework = await makeFramework();
-        const i = internals(framework);
-        i.channelRegistry = {
-            ensureChannelRegistered: () => { },
-            isChannelOpen: () => false,
-            getDescriptor: () => ({ capabilities: { history: { maxMessages: 80 } } }),
-            stopAll: () => { },
-        };
-        i.handleMcplPushEvent({
-            type: 'mcpl:push-event',
-            serverId: 'discord',
-            featureSet: 'discord.messaging',
-            eventId: 'discord_msg_m2',
-            content: [{ type: 'text', text: 'Antra: still there?' }],
-            origin: {
-                source: 'discord',
-                messageId: 'm2',
-                mcplChannelId: 'discord:G1:C7',
-                channelName: 'portables',
-                // discord-mcpl attaches the missed-ambient tally for closed, tracked
-                // channels so the agent sees the cost of staying out at decision time.
-                missedMessages: 3,
-                missedCharacters: 2729,
-            },
-            tags: ['chat:mention', 'chat:addressed'],
-            timestamp: new Date().toISOString(),
-            inferenceId: 'i2',
-            triggerInference: false,
-        });
-        const messages = framework.getAgent('scout').getContextManager().queryMessages({}).messages;
-        const text = messages.at(-1)?.content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n') ?? '';
-        assert.match(text, /Channel invitation/);
-        assert.match(text, /While closed, 3 messages \(~2729 chars\) have passed there without you\./);
-        await framework.stop();
-    });
-    it('the invitation\'s reply prefix is a single resolvable token, not a label with spaces', async () => {
-        // Live bug (2026-10-02): a first DM arrived on a closed channel labelled "DM: _reim0n"; the
-        // invitation said to prefix ">>#DM: _reim0n", which parses as target "#DM:" + body "_reim0n …":
-        // the reply bounced, and the retained text later went out with a stray "_reim0n" line.
-        const textOf = (framework) => framework.getAgent('scout').getContextManager().queryMessages({}).messages.at(-1)?.content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n') ?? '';
-        const dmEvent = (id) => ({
-            type: 'mcpl:push-event',
-            serverId: 'discord',
-            featureSet: 'discord.messaging',
-            eventId: `discord_msg_${id}`,
-            content: [{ type: 'text', text: '_reim0n: hey, I have THE gossip' }],
-            origin: { source: 'discord', messageId: id, mcplChannelId: 'discord:dm:1555', channelName: 'DM: _reim0n' },
-            tags: ['chat:addressed'],
-            timestamp: new Date().toISOString(),
-            inferenceId: `i-${id}`,
-            triggerInference: false,
-        });
-        // The registry knows the channel: its round-trip target is used.
-        const framework = await makeFramework();
-        const i = internals(framework);
-        const asked = [];
-        i.channelRegistry = {
-            ensureChannelRegistered: () => { },
-            isChannelOpen: () => false,
-            getDescriptor: () => ({ label: 'DM: _reim0n', capabilities: { history: { maxMessages: 80 } } }),
-            proseTargetFor: (id, serverId) => { asked.push(`${serverId}/${id}`); return '@_reim0n'; },
-            stopAll: () => { },
-        };
-        i.handleMcplPushEvent(dmEvent('m3'));
-        const text = textOf(framework);
-        assert.deepEqual(asked, ['discord/discord:dm:1555'], 'asked for this channel on the server it came from');
-        assert.match(text, /prefixed with ">>@_reim0n"/);
-        assert.doesNotMatch(text, />>#DM:/);
-        assert.match(text, /#DM: _reim0n/, 'the readable label still names the place');
-        await framework.stop();
-        // The registry finds no safe token (shared id, whitespace): no prefix is offered at all.
-        const fw2 = await makeFramework();
-        const i2 = internals(fw2);
-        i2.channelRegistry = {
-            ensureChannelRegistered: () => { },
-            isChannelOpen: () => false,
-            getDescriptor: () => ({ label: 'DM: _reim0n', capabilities: { history: { maxMessages: 80 } } }),
-            proseTargetFor: () => undefined,
-            stopAll: () => { },
-        };
-        i2.handleMcplPushEvent(dmEvent('m4'));
-        const t2 = textOf(fw2);
-        assert.doesNotMatch(t2, /prefixed with ">>/);
-        assert.match(t2, /Reply without joining isn't available here/);
-        assert.match(t2, /channel_open with channelId "discord:dm:1555"/, 'joining stays available');
-        await fw2.stop();
-        // A registry stand-in without proseTargetFor: a whitespace-free guess, never the spaced label.
-        const fw3 = await makeFramework();
-        const i3 = internals(fw3);
-        i3.channelRegistry = {
-            ensureChannelRegistered: () => { },
-            isChannelOpen: () => false,
-            getDescriptor: () => undefined,
-            stopAll: () => { },
-        };
-        i3.handleMcplPushEvent(dmEvent('m5'));
-        assert.match(textOf(fw3), /prefixed with ">>discord:dm:1555"/);
-        await fw3.stop();
-    });
-    it('a channel-incoming trunk turn records its triggering channel', async () => {
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'the date is ...' }]));
-        const framework = await makeFramework();
-        framework.pushEvent(channelIncoming('discord:guild:chanA', 'A: sleep && date'));
-        await framework.runUntilIdle();
-        assert.equal(membrane.calls.length, 1, 'the trunk should have run one turn');
-        assert.equal(internals(framework).turnRouting.get('scout')?.triggerChannel, 'discord:guild:chanA', 'the turn must be routed to the channel that triggered it');
-        await framework.stop();
-    });
-    it('a DM push-event turn records the reconstructed DM channel (item-3 redux DM sub-case)', async () => {
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'hi in the DM' }]));
-        const framework = await makeFramework();
-        framework.pushEvent(dmPushEvent('42', 'hey scout, ping'));
-        await framework.runUntilIdle();
-        assert.equal(membrane.calls.length, 1, 'the trunk should wake for the DM');
-        assert.equal(internals(framework).turnRouting.get('scout')?.triggerChannel, 'discord:dm:42', 'the DM reply must route to the DM channel, not the global locus');
-        await framework.stop();
-    });
-    it('the triggering channel tracks the CURRENT turn, never a stale one', async () => {
-        const framework = await makeFramework();
-        const i = internals(framework);
-        // A channel-A turn sets the active channel... (push the response right before
-        // each turn: MockMembrane's stream consumes ALL queued responses at once.)
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ans A' }]));
-        framework.pushEvent(channelIncoming('discord:guild:chanA', 'A: hi'));
-        await framework.runUntilIdle();
-        assert.equal(i.turnRouting.get('scout')?.triggerChannel, 'discord:guild:chanA');
-        // ...then a DM turn OVERWRITES it — the next turn's reply must never inherit
-        // the previous turn's channel (the concurrency hazard this fix removes).
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ans DM' }]));
-        framework.pushEvent(dmPushEvent('42', 'now in a DM'));
-        await framework.runUntilIdle();
-        assert.equal(membrane.calls.length, 2, 'both turns should have run');
-        assert.equal(i.turnRouting.get('scout')?.triggerChannel, 'discord:dm:42', 'the routing state must reflect the CURRENT turn’s channel, not chanA');
-        await framework.stop();
-    });
-    it("the channel registry resolves and reports the current turn's trigger channel, then its locus", async () => {
-        const framework = await makeFramework();
-        const i = framework;
-        // The real registry, with no servers: its resolver reads the framework's turn state.
-        await i.initializeMcpl([]);
-        i.turnRouting.set('scout', { triggerChannel: 'discord:guild:chanA' });
-        assert.equal(i.channelRegistry.resolveLocus('scout'), 'discord:guild:chanA', 'the locus a turn freezes comes from its trigger channel');
-        assert.equal(i.channelRegistry.buildChannelContext('scout')?.defaultOutgoing?.channelId, 'discord:guild:chanA', 'and the agent is told the same channel');
-        // A re-pin moved the turn's locus: a later start of the turn tells the
-        // agent where its speech now lands.
-        i.turnRouting.set('scout', { triggerChannel: 'discord:guild:chanA', locus: 'discord:dm:42' });
-        assert.equal(i.channelRegistry.buildChannelContext('scout')?.defaultOutgoing?.channelId, 'discord:dm:42');
-        await framework.stop();
-    });
-    it("the compile a capacity hold defers a turn to keeps the turn's trigger channel", async () => {
-        // The first stream ends with an organization acceleration 429, which
-        // holds the turn; a message from another channel arrives during the hold.
-        membrane.pushResponse(createMockResponse([]));
-        const framework = await makeFramework();
-        const makeStream = membrane.streamYielding.bind(membrane);
-        let streams = 0;
-        membrane.streamYielding = (request, options) => {
-            const stream = makeStream(request, options);
-            const n = ++streams;
-            const iterate = stream[Symbol.asyncIterator].bind(stream);
-            stream[Symbol.asyncIterator] = async function* () {
-                for await (const event of { [Symbol.asyncIterator]: iterate }) {
-                    if (event.type === 'complete' && n === 1) {
-                        yield {
-                            type: 'error',
-                            error: new MembraneError({
-                                type: 'rate_limit', retryable: true, httpStatus: 429,
-                                message: "This request would exceed your organization's maximum usage increase rate for input tokens per minute",
-                                rawError: { status: 429 }, rawRequest: request,
-                            }),
-                        };
-                        return;
-                    }
-                    yield event;
-                }
-            };
-            return stream;
-        };
-        const held = framework;
-        const triggerAtStart = [];
-        framework.onTrace((event) => {
-            if (event.type !== 'inference:started')
-                return;
-            triggerAtStart.push(internals(framework).turnRouting.get('scout')?.triggerChannel);
-            if (triggerAtStart.length === 2)
-                membrane.pushResponse(createMockResponse([{ type: 'text', text: 'back' }]));
-        });
-        framework.pushEvent(channelIncoming('discord:guild:chanA', 'A: what time is it'));
-        await framework.runUntilIdle();
-        assert.ok(held.providerAccelerationCooldowns.has('scout'), 'the turn is held');
-        framework.pushEvent(channelIncoming('discord:guild:chanB', 'B: unrelated chatter'));
-        await framework.runUntilIdle();
-        const hold = held.providerAccelerationCooldowns.get('scout');
-        assert.ok(hold.heldRequests.some((r) => r.channelId === 'discord:guild:chanB'), "chanB's wake waits in the hold with the turn's");
-        // What the hold's timer does when it fires, at the hold's deadline.
-        hold.until = Date.now();
-        held.releaseProviderAccelerationCooldown('scout');
-        await framework.runUntilIdle();
-        assert.deepEqual(triggerAtStart, ['discord:guild:chanA', 'discord:guild:chanA'], "the deferred compile's batch names chanB, and the turn keeps chanA");
-        await framework.stop();
-    });
-    it('startAgentStream clears the triggering channel for a no-channel (heartbeat) turn', async () => {
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'tick' }]));
-        const framework = await makeFramework();
-        const i = internals(framework);
-        // Simulate a stale channel left by a prior turn, then run a heartbeat/timer
-        // turn (an InferenceRequest with no channelId). startAgentStream must clear
-        // the entry up front so routeSpeech falls back to the global locus rather
-        // than replaying the stale channel.
-        i.turnRouting.set('scout', { triggerChannel: 'discord:guild:stale' });
-        const scout = framework.getAgent('scout');
-        await framework.startAgentStream(scout, {
-            agentName: 'scout', reason: 'heartbeat', source: 'timer', timestamp: Date.now(),
-        });
-        await framework.runUntilIdle();
-        assert.equal(i.turnRouting.get('scout')?.triggerChannel, undefined, 'a no-trigger turn must clear any stale triggering channel');
-        await framework.stop();
-    });
-});
-// ---------------------------------------------------------------------------
-// Residents read one message slot
-// ---------------------------------------------------------------------------
-// Every ordinary resident reads the same message slot, and a tool boundary
-// weighs only the messages drained for its own agent. So each resident's open
-// turn weighs what lands in the slot by its own rule (an addressed message,
-// or a follow-up in a channel the turn engaged), whichever agent it was
-// stored for: by addMessage, by a boundary's drain, or by a start's own flush.
-/** A channel message as a channel server forwards it, waking only `target`. */
-function residentIncoming(channelId, text, target, addressed) {
-    return {
-        type: 'mcpl:channel-incoming',
-        serverId: 'discord',
-        channelId,
-        messageId: `m-${Math.random().toString(36).slice(2)}`,
-        author: { id: 'U1', name: 'antra' },
-        content: [{ type: 'text', text }],
-        timestamp: new Date().toISOString(),
-        metadata: addressed ? { mentioned: true } : {},
-        tags: addressed ? ['chat:addressed'] : ['chat:ambient', 'chat:from-human'],
-        triggerInference: true,
-        targetAgents: [target],
-    };
-}
-/** A module whose `pause` tool runs `during` before it returns, and whose
- *  context gathering runs `startHook` once, in the named agent's next start. */
-class PauseModule {
-    name = 'pause';
-    during = null;
-    startHook = null;
-    async start(_ctx) { }
-    async stop() { }
-    async gatherContext(agentName) {
-        const hook = this.startHook;
-        if (hook?.agent === agentName) {
-            this.startHook = null;
-            hook.run();
-        }
-        return [];
-    }
-    getTools() {
-        return [{ name: 'pause', description: 'Pause briefly', inputSchema: { type: 'object', properties: {} } }];
-    }
-    async handleToolCall(_call) {
-        const during = this.during;
-        this.during = null;
-        if (during)
-            await during();
-        return { success: true, data: { ok: true } };
-    }
-    async onProcess() {
-        return {};
-    }
-}
-describe('Residents read one message slot', () => {
-    let tempDir;
-    let membrane;
-    let pause;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'resident-slot-test-'));
-        membrane = new MockMembrane();
-        pause = new PauseModule();
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    /** Two residents, scout the primary and shade. A registry stand-in
-     *  resolves a fresh locus to the turn's trigger channel and records where
-     *  each agent's speech is routed. `held`'s first stream ends with an
-     *  organization acceleration 429, which holds its turn for a later
-     *  compile. `first` is that stream's rounds, and `responses[n]` feeds the
-     *  nth start (1-based) as it begins. */
-    async function residents(held, responses, first = [[]]) {
-        const framework = await AgentFramework.create({
-            storePath: join(tempDir, 'test.chronicle'),
-            membrane: membrane.asMembrane(),
-            agents: [
-                { name: 'scout', model: 'test-model', systemPrompt: 'You are scout.' },
-                { name: 'shade', model: 'test-model', systemPrompt: 'You are shade.' },
-            ],
-            modules: [pause],
-        });
-        const i = framework;
-        const routed = [];
-        const registry = {
-            resolveLocus: (name) => i.turnRouting.get(name)?.triggerChannel ?? 'chan-default',
-            routeSpeech: async (agent, text, locus) => {
-                routed.push({ agent, text, locus: locus ?? null });
-                return locus ? { delivered: true, channelId: locus } : null;
-            },
-            getDefaultPublishChannel: () => null,
-            isChannelOpen: () => true,
-            getDescriptor: () => undefined,
-            getChannelTools: () => [],
-        };
-        i.channelRegistry = new Proxy(registry, {
-            get: (target, prop) => (prop in target ? target[prop] : () => undefined),
-        });
-        first.forEach((blocks, n) => membrane.pushResponse(createMockResponse(blocks, n < first.length - 1 ? 'tool_use' : undefined)));
-        const makeStream = membrane.streamYielding.bind(membrane);
-        const firstStreamOf = new Set();
-        membrane.streamYielding = (request, options) => {
-            const stream = makeStream(request, options);
-            const system = JSON.stringify(request.system ?? '');
-            const agent = system.includes('You are shade.') ? 'shade' : 'scout';
-            const first = !firstStreamOf.has(agent);
-            firstStreamOf.add(agent);
-            const iterate = stream[Symbol.asyncIterator].bind(stream);
-            stream[Symbol.asyncIterator] = async function* () {
-                for await (const event of { [Symbol.asyncIterator]: iterate }) {
-                    if (event.type === 'complete' && first && agent === held) {
-                        yield {
-                            type: 'error',
-                            error: new MembraneError({
-                                type: 'rate_limit', retryable: true, httpStatus: 429,
-                                message: "This request would exceed your organization's maximum usage increase rate for input tokens per minute",
-                                rawError: { status: 429 }, rawRequest: request,
-                            }),
-                        };
-                        return;
-                    }
-                    yield event;
-                }
-            };
-            return stream;
-        };
-        let starts = 0;
-        framework.onTrace((event) => {
-            if (event.type !== 'inference:started')
-                return;
-            const feed = responses[++starts];
-            feed?.forEach((blocks, n) => membrane.pushResponse(createMockResponse(blocks, n < feed.length - 1 ? 'tool_use' : undefined)));
-        });
-        /** Bring `name`'s hold to its deadline and release it, as its timer does then. */
-        const release = async (name) => {
-            const hold = i.providerAccelerationCooldowns.get(name);
-            assert.ok(hold, `${name}'s turn is held`);
-            hold.until = Date.now();
-            i.releaseProviderAccelerationCooldown(name);
-            await framework.runUntilIdle();
-        };
-        return { framework, i, routed, release };
-    }
-    const hereIAm = [[{ type: 'text', text: 'Here I am.' }]];
-    // Each row is also what main does, by re-resolving the held turn's locus
-    // from its batch's addressed wake.
-    for (const [held, role] of [['scout', 'the primary'], ['shade', 'a second resident']]) {
-        it(`${role}, held by a capacity hold, moves its locus to an addressed message from another channel`, async () => {
-            const { framework, i, routed, release } = await residents(held, { 2: hereIAm });
-            framework.pushEvent(residentIncoming('discord:guild:chanA', `${held}, take a look`, held, false));
-            await framework.runUntilIdle();
-            assert.ok(i.providerAccelerationCooldowns.has(held), 'the turn is held');
-            framework.pushEvent(residentIncoming('discord:dm:antra', `${held}, over here please`, held, true));
-            await framework.runUntilIdle();
-            await release(held);
-            assert.deepEqual(routed, [{ agent: held, text: 'Here I am.', locus: 'discord:dm:antra' }]);
-            await framework.stop();
-        });
-    }
-    it('a second resident, held by a capacity hold, keeps its locus for ambient traffic in another channel', async () => {
-        const { framework, routed, release } = await residents('shade', { 2: hereIAm });
-        framework.pushEvent(residentIncoming('discord:guild:chanA', 'shade, take a look', 'shade', false));
-        await framework.runUntilIdle();
-        framework.pushEvent(residentIncoming('discord:guild:lounge', 'unrelated chatter', 'shade', false));
-        await framework.runUntilIdle();
-        assert.ok(framework.getAgent('shade').getContextManager().getAllMessages()
-            .some((m) => m.content.some((b) => b.type === 'text' && b.text === 'unrelated chatter')), 'shade reads the ambient message in the slot');
-        await release('shade');
-        assert.deepEqual(routed, [{ agent: 'shade', text: 'Here I am.', locus: 'discord:guild:chanA' }]);
-        await framework.stop();
-    });
-    it("a second resident's turn weighs a message stored while it runs, at the turn's next start", async () => {
-        const { framework, i, routed, release } = await residents('shade', { 2: hereIAm });
-        // While shade's start gathers its context, its turn is alive and no tool
-        // cycle is open, so an addressed message for the idle primary is stored
-        // at once. Shade's start has weighed its arrivals by then, and no
-        // boundary of shade's turn weighs it.
-        pause.startHook = {
-            agent: 'shade',
-            run: () => {
-                i.addMessage('Antra', [{ type: 'text', text: 'shade, over here please' }], { channelId: 'discord:dm:antra', tags: ['chat:addressed'] });
-            },
-        };
-        framework.pushEvent(residentIncoming('discord:guild:chanA', 'shade, take a look', 'shade', false));
-        await framework.runUntilIdle();
-        assert.equal(pause.startHook, null, "shade's start stored the message");
-        await release('shade');
-        assert.deepEqual(routed, [{ agent: 'shade', text: 'Here I am.', locus: 'discord:dm:antra' }]);
-        await framework.stop();
-    });
-    it("a second resident's held turn weighs a message the primary's own start stores", async () => {
-        const { framework, i, routed, release } = await residents('shade', {
-            2: [[{ type: 'text', text: 'scout here' }]],
-            3: hereIAm,
-        });
-        framework.pushEvent(residentIncoming('discord:guild:chanA', 'shade, take a look', 'shade', false));
-        await framework.runUntilIdle();
-        // While scout's turn is alive, a message for the primary waits in its
-        // queue, and scout's next start stores it.
-        i.activeTurnTokens.set('scout', 999);
-        framework.pushEvent(residentIncoming('discord:dm:antra', 'shade, over here please', 'shade', true));
-        await framework.runUntilIdle();
-        assert.equal(i.deferredMessages.length, 1, 'the message waits for scout');
-        i.activeTurnTokens.delete('scout');
-        framework.pushEvent(residentIncoming('discord:guild:chanC', 'scout, a word', 'scout', false));
-        await framework.runUntilIdle();
-        assert.equal(i.deferredMessages.length, 0, "scout's start stored it");
-        await release('shade');
-        assert.deepEqual(routed.filter((r) => r.agent === 'shade'), [{ agent: 'shade', text: 'Here I am.', locus: 'discord:dm:antra' }]);
-        await framework.stop();
-    });
-    it("a boundary that re-pins supersedes an arrival from another resident's store", async () => {
-        const { framework, i, routed, release } = await residents('scout', { 2: hereIAm }, [
-            [{ type: 'tool_use', id: 'p1', name: 'pause--pause', input: {} }],
-            [],
-        ]);
-        // While scout's tool runs, a message for shade is stored at once, an
-        // arrival for scout's turn. Then one for scout waits in its queue, and
-        // scout's boundary stores it after, re-pinning the turn there.
-        pause.during = async () => {
-            i.addMessage('Antra', [{ type: 'text', text: 'shade, a word' }], { channelId: 'discord:dm:xenia', tags: ['chat:addressed'] }, { forAgent: 'shade' });
-            i.addMessage('Antra', [{ type: 'text', text: 'scout, over here please' }], { channelId: 'discord:dm:antra', tags: ['chat:addressed'] });
-        };
-        framework.pushEvent(residentIncoming('discord:guild:chanA', 'scout, take a look', 'scout', false));
-        await framework.runUntilIdle();
-        assert.equal(pause.during, null, "scout's tool ran");
-        await release('scout');
-        assert.deepEqual(routed, [{ agent: 'scout', text: 'Here I am.', locus: 'discord:dm:antra' }], "the boundary's re-pin stands at the turn's next start");
-        await framework.stop();
-    });
-    it("a second resident's held turn weighs a message the primary's tool boundary drains", async () => {
-        const { framework, i, routed, release } = await residents('shade', {
-            2: [
-                [{ type: 'tool_use', id: 'p1', name: 'pause--pause', input: {} }],
-                [{ type: 'text', text: 'scout done' }],
-            ],
-            3: hereIAm,
-        });
-        framework.pushEvent(residentIncoming('discord:guild:chanA', 'shade, take a look', 'shade', false));
-        await framework.runUntilIdle();
-        // The message comes while scout's tool runs, so it waits in scout's queue
-        // until scout's boundary stores it.
-        let queued = -1;
-        pause.during = async () => {
-            i.addMessage('Antra', [{ type: 'text', text: 'shade, over here please' }], { channelId: 'discord:dm:antra', tags: ['chat:addressed'] });
-            queued = i.deferredMessages.length;
-        };
-        framework.pushEvent(residentIncoming('discord:guild:chanC', 'scout, a word', 'scout', false));
-        await framework.runUntilIdle();
-        assert.equal(queued, 1, "the message waited in scout's queue while its tool ran");
-        assert.equal(i.deferredMessages.length, 0, "scout's boundary stored it");
-        await release('shade');
-        assert.deepEqual(routed.filter((r) => r.agent === 'shade'), [{ agent: 'shade', text: 'Here I am.', locus: 'discord:dm:antra' }]);
-        await framework.stop();
-    });
-});
-//# sourceMappingURL=trunk-channel-routing.test.js.map