@animalabs/agent-framework 0.22.1 → 0.22.3

package/dist/test/present-while-acting.test.js

@@ -1,706 +0,0 @@
-/**
- * "Present while acting": the two halves that keep an agent conversationally
- * alive during a long tool-using turn.
- *
- * SPEAK-while-acting — each round's prose is routed to the locus LIVE when
- * the round yields its tool calls. Explicit-send suppression lasts until new
- * external input begins another conversational round; the 'complete' case
- * routes only trailing prose.
- * Previously all segments were batched to the end of the turn.
- *
- * HEAR-while-acting — messages arriving mid-turn (deferred by addMessage
- * while tool_use blocks are pending) are flushed to the context window at
- * the tool-result boundary AND injected into the live stream via
- * provideToolResults(results, { injectedMessages }) (membrane ≥0.5.72), so
- * the next round of the SAME turn sees them instead of the agent staying
- * deaf until the turn ends.
- */
-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';
-// ---------------------------------------------------------------------------
-// Test module: tools that optionally emit a mid-turn external message
-// ---------------------------------------------------------------------------
-class RobotModule {
-    name = 'robot';
-    framework = null;
-    /** When set, the next `move` call pushes this text as an external message
-     *  BEFORE returning its result (simulating a chat reply arriving while the
-     *  tool executes). */
-    interjection = null;
-    /** Optional routing locus attached to the interjected message. */
-    interjectionChannelId = null;
-    /** Full metadata override for the interjected message (wins over
-     *  interjectionChannelId when set) — e.g. reaction tags. */
-    interjectionMetadata = null;
-    /** Delay tool completion so live routing deterministically precedes it. */
-    toolDelayMs = 0;
-    async start(_ctx) { }
-    async stop() { }
-    getTools() {
-        return [
-            {
-                name: 'move',
-                description: 'Move the robot',
-                inputSchema: { type: 'object', properties: { dir: { type: 'string' } } },
-            },
-            {
-                name: 'send_message',
-                description: 'Explicitly send a message',
-                inputSchema: { type: 'object', properties: { text: { type: 'string' } } },
-            },
-            // World-surface publication verbs (Eidoverse). Bare names matter: the
-            // framework strips the `robot--` prefix before consulting its sets.
-            {
-                name: 'say',
-                description: 'Say something aloud in the world',
-                inputSchema: { type: 'object', properties: { text: { type: 'string' } } },
-            },
-            {
-                name: 'whisper',
-                description: 'Whisper to someone in the world',
-                inputSchema: { type: 'object', properties: { to: { type: 'string' }, text: { type: 'string' } } },
-            },
-        ];
-    }
-    async handleToolCall(call) {
-        if (this.toolDelayMs > 0) {
-            await new Promise((r) => setTimeout(r, this.toolDelayMs));
-        }
-        if (this.interjection) {
-            const text = this.interjection;
-            this.interjection = null;
-            this.framework.pushEvent({
-                type: 'external-message',
-                source: 'test',
-                content: text,
-                metadata: this.interjectionMetadata
-                    ?? (this.interjectionChannelId
-                        ? { channelId: this.interjectionChannelId }
-                        : {}),
-            });
-            // Give the run loop a beat to process the queued message while this
-            // tool round is still pending (pendingAssistantBlocks non-empty), so
-            // it lands in deferredMessages before the tool-result event.
-            await new Promise((r) => setTimeout(r, 30));
-        }
-        return { success: true, data: { ok: true, tool: call.name } };
-    }
-    async onProcess(event, _state) {
-        if (event.type === 'external-message') {
-            const text = String(event.content);
-            const metadata = event.metadata;
-            return {
-                addMessages: [
-                    {
-                        participant: 'Antra',
-                        content: [{ type: 'text', text }],
-                        ...(metadata ? { metadata } : {}),
-                    },
-                ],
-                // Only the initial 'go' starts a turn. Mid-turn interjections must
-                // NOT request inference — we're testing mid-turn delivery, not wakes.
-                requestInference: text === 'go',
-            };
-        }
-        return {};
-    }
-}
-/** Minimal ChannelRegistry stub covering everything driveStream touches. */
-function stubChannelRegistry(framework) {
-    const routed = [];
-    let locusCalls = 0;
-    const explicit = {
-        resolveLocus: () => {
-            locusCalls++;
-            return `chan-live-${locusCalls}`;
-        },
-        routeSpeech: async (_agent, text, locus) => {
-            routed.push({ text, locus: locus ?? null });
-            // Mirror the real registry's outcome shape (delivery receipts read it).
-            return locus ? { delivered: true, channelId: locus } : null;
-        },
-        getDefaultPublishChannel: () => null,
-        isChannelOpen: () => true,
-        getDescriptor: () => undefined,
-        getChannelTools: () => [],
-    };
-    // Everything else driveStream/stop touches (startTyping, stopTyping,
-    // stopAll, ensureChannelRegistered, ...) becomes a no-op via Proxy so the
-    // stub doesn't chase the real registry's surface.
-    framework.channelRegistry = new Proxy(explicit, {
-        get: (target, prop) => (prop in target ? target[prop] : () => undefined),
-    });
-    return routed;
-}
-// ---------------------------------------------------------------------------
-describe('present while acting', () => {
-    let tempDir;
-    let membrane;
-    let module;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'pwa-test-'));
-        membrane = new MockMembrane();
-        module = new RobotModule();
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    async function createFramework() {
-        const framework = await AgentFramework.create({
-            storePath: join(tempDir, 'test.chronicle'),
-            membrane: membrane.asMembrane(),
-            agents: [
-                { name: 'assistant', model: 'test-model', systemPrompt: 'You are a robot pilot.' },
-            ],
-            modules: [module],
-        });
-        module.framework = framework;
-        return framework;
-    }
-    function trigger(framework) {
-        framework.pushEvent({
-            type: 'external-message',
-            source: 'test',
-            content: 'go',
-            metadata: {},
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Speak-while-acting
-    // -------------------------------------------------------------------------
-    it('routes each round\'s prose live and only trailing prose at complete', async () => {
-        // Round 1: narration + move; Round 2: more narration + move; final: postscript
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Heading to the door now!' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Door reached, opening it.' },
-            { type: 'tool_use', id: 'c2', name: 'robot--move', input: { dir: 'east' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Arrived.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        // Track live ordering: when the first segment routes, no tool results
-        // may have been provided yet (i.e. delivery happened DURING the round).
-        const resultsAtRouteTime = [];
-        const registry = framework.channelRegistry;
-        const origRoute = registry.routeSpeech;
-        registry.routeSpeech = async (a, t, l) => {
-            resultsAtRouteTime.push(membrane.lastStream.receivedToolResults.length);
-            return origRoute(a, t, l);
-        };
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed.map((r) => r.text), ['Heading to the door now!', 'Door reached, opening it.', 'Arrived.'], 'all three segments delivered, in order');
-        // Live: segment N routed before round N's tool results were provided
-        assert.equal(resultsAtRouteTime[0], 0, 'round-1 prose routed before round-1 results');
-        assert.equal(resultsAtRouteTime[1], 1, 'round-2 prose routed before round-2 results');
-        // Locus resolved ONCE and pinned for the whole turn (incl. trailing prose)
-        assert.deepEqual(routed.map((r) => r.locus), ['chan-live-1', 'chan-live-1', 'chan-live-1'], 'one locus resolution, pinned across the turn');
-        await framework.stop();
-    });
-    it('sticky silencing: a silencing round suppresses its own and all later prose', async () => {
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'sending it directly' },
-            { type: 'tool_use', id: 'c1', name: 'robot--send_message', input: { text: 'hi' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Narrating round two.' },
-            { type: 'tool_use', id: 'c2', name: 'robot--move', input: { dir: 'up' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed.map((r) => r.text), [], 'explicit send in round 1 silences the turn from that round onward');
-        await framework.stop();
-    });
-    it('sticky silencing is forward-only: earlier rounds\' prose still routes', async () => {
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Round one narration.' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'up' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'private planning' },
-            { type: 'tool_use', id: 'c2', name: 'robot--send_message', input: { text: 'hi' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'trailing postscript' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed.map((r) => r.text), ['Round one narration.'], 'round-1 prose delivered live; round-2 (silencing) and trailing suppressed');
-        await framework.stop();
-    });
-    it('new injected channel input resets send suppression but the turn locus stays frozen', async () => {
-        // While handling one channel, the agent explicitly sends that response; a
-        // message from another channel arrives during the send, and the terminal
-        // prose answers the new message. The suppression is cleared (the prose IS
-        // delivered) — but it lands in the TURN's frozen locus, not the injected
-        // message's channel: ambient input must never capture the agent's voice
-        // mid-turn (2026-07-21 Cairn lounge misroute). A cross-channel reply
-        // needs an explicit send.
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--send_message', input: { text: 'reply to room4' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Yes, I want to try the VR space.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.interjection = 'Want to try a VR space?';
-        module.interjectionChannelId = 'discord:guild:fable';
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'Yes, I want to try the VR space.', locus: 'chan-live-1' },
-        ]);
-        await framework.stop();
-    });
-    it('an ADDRESSED mid-turn injection re-pins the locus for subsequent prose', async () => {
-        // 2026-07-31 Mythos misroutes (n=6): someone explicitly addresses the
-        // agent from another channel mid-turn (mention / reply / DM); the
-        // agent's trailing prose answers THEM but the frozen pin delivered it
-        // to the stale locus (the hospital scene into antra's DM, and its
-        // mirror). Addressed conversational injections — the chat:addressed
-        // signal turn-START batching already prefers — now move the pin, with a
-        // one-line [routing] notice riding the same injection batch so window
-        // and wire agree. Ambient injections still cannot (previous test).
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Station four, proceeding.' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Answering the person who addressed me.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = 'hey, quick question over here?';
-        module.interjectionMetadata = { channelId: 'discord:dm:antra', tags: ['chat:addressed'] };
-        const notices = [];
-        framework.onTrace((event) => {
-            const e = event;
-            if (e.type === 'message:added' && e.source === 'routing-notice')
-                notices.push(e.source);
-        });
-        trigger(framework);
-        await framework.runUntilIdle();
-        // Round-1 prose predates the injection and belongs to the old pin;
-        // trailing prose follows the addressed speaker.
-        assert.deepEqual(routed, [
-            { text: 'Station four, proceeding.', locus: 'chan-live-1' },
-            { text: 'Answering the person who addressed me.', locus: 'discord:dm:antra' },
-        ]);
-        // Boot-baseline announcement + the mid-turn re-pin notice.
-        assert.equal(notices.length, 2, 'the re-pin produced exactly one routing notice');
-        // The notice rode the injection batch to the live stream (window == wire).
-        const injectedBatches = membrane.lastStream.receivedToolResultOptions
-            .map((o) => o?.injectedMessages ?? []);
-        const wired = injectedBatches.flat().map((m) => JSON.stringify(m.content));
-        assert.ok(wired.some((s) => s.includes('quick question')), 'the addressed message itself was injected');
-        assert.ok(wired.some((s) => s.includes('[routing] The conversation moved to discord:dm:antra')), 'the re-pin notice was injected alongside it');
-        await framework.stop();
-    });
-    it('a follow-up in a channel the agent explicitly engaged this turn re-pins', async () => {
-        // 2026-07-31 n=7 (q's #portables reply): the agent explicitly sent into
-        // a channel this turn; someone replies there WITHOUT a mention (ambient
-        // by tag, addressed by context). The engaged-channel leg moves the pin;
-        // trailing prose answering them follows.
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Good plan on both counts.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = 'I need to swap out this eye screen';
-        module.interjectionMetadata = {
-            channelId: 'discord:guild:portables',
-            tags: ['chat:ambient', 'chat:from-human'],
-        };
-        // Simulate an explicit send into #portables earlier in THIS turn (the
-        // production record happens on the MCPL send path; the harness module's
-        // tools are not MCPL, so seed the turn-scoped set mid-turn — after the
-        // turn-start clear, before the injection boundary).
-        const origHandle = module.handleToolCall.bind(module);
-        module.handleToolCall = async (call) => {
-            framework.turnEngagedChannels.set('assistant', new Set(['discord:guild:portables']));
-            return origHandle(call);
-        };
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'Good plan on both counts.', locus: 'discord:guild:portables' },
-        ], 'trailing prose followed the human reply into the engaged channel');
-        await framework.stop();
-    });
-    it('an agent-resident follow-up in an engaged channel re-pins too (no author-kind filter)', async () => {
-        // Fleet participants include agent-residents — "bot" by Discord flag,
-        // full conversational participants in fact. Their in-flow replies in a
-        // channel the agent just engaged move the pin exactly like anyone
-        // else's (antra, 2026-07-31: the author-kind distinction is fragile and
-        // wrong for this fleet).
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Continuing with the colleague.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = '*from the table* one receipt for the case, since I have a dated instance';
-        module.interjectionMetadata = {
-            channelId: 'discord:guild:hospital',
-            tags: ['chat:ambient', 'chat:from-bot'],
-        };
-        const origHandle = module.handleToolCall.bind(module);
-        module.handleToolCall = async (call) => {
-            framework.turnEngagedChannels.set('assistant', new Set(['discord:guild:hospital']));
-            return origHandle(call);
-        };
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'Continuing with the colleague.', locus: 'discord:guild:hospital' },
-        ], 'the agent-resident follow-up moved the pin like any participant');
-        await framework.stop();
-    });
-    it('ambient chatter in a channel the agent did NOT engage still cannot move the pin', async () => {
-        // The Cairn-protection boundary, restated for the engaged-channel era:
-        // no mention, no engagement this turn → the pin holds.
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Continuing my report.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = 'unrelated lounge chatter';
-        module.interjectionMetadata = {
-            channelId: 'discord:guild:lounge',
-            tags: ['chat:ambient', 'chat:from-human'],
-        };
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'Continuing my report.', locus: 'chan-live-1' },
-        ], 'un-engaged ambient left the pin alone');
-        await framework.stop();
-    });
-    it('an addressed injection from the CURRENT locus does not chatter a notice', async () => {
-        // Same-channel addressed input is the ordinary case (the person the
-        // agent is already talking to sends another message mid-turn): the pin
-        // is already right, so no re-pin and — critically for KV — no notice.
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Continuing right here.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = 'and one more thing';
-        module.interjectionMetadata = { channelId: 'chan-live-1', tags: ['chat:addressed'] };
-        const notices = [];
-        framework.onTrace((event) => {
-            const e = event;
-            if (e.type === 'message:added' && e.source === 'routing-notice')
-                notices.push(e.source);
-        });
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [{ text: 'Continuing right here.', locus: 'chan-live-1' }]);
-        assert.equal(notices.length, 1, 'only the boot-baseline announcement — no re-pin chatter');
-        await framework.stop();
-    });
-    it('a prose turn ends with a [delivered] receipt naming where the prose landed', async () => {
-        // Explicit sends receipt themselves via tool_result; auto-routed prose
-        // previously vanished with no in-window trace — the agent could never
-        // see where its own words went (2026-07-31 misroute series). One compact
-        // system message at logical turn end, channels deduped in delivery order.
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'A quiet reply with no tools.' },
-        ]));
-        const framework = await createFramework();
-        stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        const cm = framework.agents.get('assistant').getContextManager();
-        const texts = cm.getAllMessages()
-            .flatMap((m) => m.content)
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text ?? '');
-        const receipts = texts.filter((t) => t.startsWith('[delivered]'));
-        assert.deepEqual(receipts, ['[delivered] plain speech → chan-live-1']);
-        // The receipt is the LAST window message — after the assistant blocks.
-        assert.ok(texts[texts.length - 1].startsWith('[delivered]'), 'receipt sits at the settled tail');
-        await framework.stop();
-    });
-    it('a re-pinned turn\'s receipt names both channels in delivery order', async () => {
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Station four, proceeding.' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Answering the person who addressed me.' },
-        ]));
-        const framework = await createFramework();
-        stubChannelRegistry(framework);
-        module.toolDelayMs = 25;
-        module.interjection = 'quick question over here?';
-        module.interjectionMetadata = { channelId: 'discord:dm:antra', tags: ['chat:addressed'] };
-        trigger(framework);
-        await framework.runUntilIdle();
-        const cm = framework.agents.get('assistant').getContextManager();
-        const receipts = cm.getAllMessages()
-            .flatMap((m) => m.content)
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text ?? '')
-            .filter((t) => t.startsWith('[delivered]'));
-        assert.deepEqual(receipts, ['[delivered] plain speech → chan-live-1 · discord:dm:antra']);
-        await framework.stop();
-    });
-    it('suppressed prose is visible in the receipt (silencing is never a silent black hole)', async () => {
-        // n=8 (2026-07-31 ~22:46): one round multiplexing two threads — prose
-        // for the lane + an explicit send for another channel, textbook per the
-        // routing doc. Sticky silencing ate the prose reply and nothing told
-        // the author; their own record believed it delivered. The rule stands
-        // (antra: visibility is enough) — but the turn-end receipt now reports
-        // the suppression, so the segment's fate is visible one turn later.
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'the reply that silencing will eat' },
-            { type: 'tool_use', id: 'c1', name: 'robot--send_message', input: { text: 'explicit send to the other thread' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'trailing prose, also suppressed (sticky)' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [], 'silencing semantics unchanged: nothing auto-routed');
-        const cm = framework.agents.get('assistant').getContextManager();
-        const receipts = cm.getAllMessages()
-            .flatMap((m) => m.content)
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text ?? '')
-            .filter((t) => t.startsWith('[delivered]'));
-        assert.deepEqual(receipts, [
-            '[delivered] nothing — 2 plain-speech segment(s) suppressed (explicit send in the same round — resend with a send tool if it was meant to be heard)',
-        ]);
-        await framework.stop();
-    });
-    for (const verb of ['say', 'whisper']) {
-        it(`world \`${verb}\` silences adjacent auto-routed prose in locus mode (no double-publish)`, async () => {
-            // 2026-09-01 (Cairn, locus mode): a round of ordinary text + explicit
-            // world `say` published TWICE — seq 15146 was the say text, seq 15147
-            // the adjacent prose auto-routed to the same world locus, byte-for-byte.
-            // World publication verbs silenced only in hybrid mode; Discord sends
-            // silenced everywhere. An explicit world utterance is the resident's
-            // chosen speech for the round in every mode.
-            const input = verb === 'say'
-                ? { text: 'the intended utterance' }
-                : { to: 'sill', text: 'the intended utterance' };
-            membrane.pushResponse(createMockResponse([
-                { type: 'text', text: 'adjacent prose that must NOT auto-publish' },
-                { type: 'tool_use', id: 'c1', name: `robot--${verb}`, input },
-            ], 'tool_use'));
-            membrane.pushResponse(createMockResponse([
-                { type: 'text', text: 'trailing prose, also suppressed (sticky)' },
-            ]));
-            const framework = await createFramework();
-            const routed = stubChannelRegistry(framework);
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, [], `${verb}: nothing auto-routed beside the explicit world utterance`);
-            const cm = framework.agents.get('assistant').getContextManager();
-            const receipts = cm.getAllMessages()
-                .flatMap((m) => m.content)
-                .filter((b) => b.type === 'text')
-                .map((b) => b.text ?? '')
-                .filter((t) => t.startsWith('[delivered]'));
-            assert.deepEqual(receipts, [
-                '[delivered] nothing — 2 plain-speech segment(s) suppressed (explicit send in the same round — resend with a send tool if it was meant to be heard)',
-            ], `${verb}: suppression is visible in the receipt`);
-            await framework.stop();
-        });
-    }
-    it('a non-publishing world tool (move) does not silence — speak-while-acting unchanged', async () => {
-        // Negative control for the world-verb silencing: only publication verbs
-        // silence. Ordinary acting tools still narrate live to the locus.
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'walking over' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'there' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed.map((r) => r.text), ['walking over', 'there']);
-        await framework.stop();
-    });
-    it('channel_open moves the pin mid-turn and announces in its own tool result', async () => {
-        // The agent's own deliberate open is the strongest "my next words go
-        // here" signal — stronger than any injection. The original 2026-07-21
-        // Aria fix only set next-turn trigger state; the turn-frozen refactor
-        // silently regressed the reply-right-after-opening case. Now the pin
-        // moves immediately and the announcement rides the tool result itself
-        // (model-requested content: distance zero, safest role).
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'channel_open', input: { channelId: 'discord:guild:observatory' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Hello, observatory.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        const registry = framework.channelRegistry;
-        registry.handleChannelToolCall =
-            async () => ({ success: true, data: { channelId: 'discord:guild:observatory', opened: true } });
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'Hello, observatory.', locus: 'discord:guild:observatory' },
-        ], 'prose right after channel_open lands in the opened channel');
-        // The announcement rode the tool result the model saw.
-        const results = membrane.lastStream.receivedToolResults.flat();
-        assert.ok(JSON.stringify(results).includes('plain speech now lands in this channel'), 'routing note present in the channel_open tool result');
-        await framework.stop();
-    });
-    it('reactions and system markers injected mid-turn do not clear send suppression', async () => {
-        // A reaction (`chat:reaction` tag) or a `system: true` marker is not
-        // conversational input: prose following an explicit send stays suppressed,
-        // so a stray reaction can't make the agent double-post a "sent it"
-        // postscript — and (with the frozen locus) can't move routing either.
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--send_message', input: { text: 'reply to room4' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Sent it.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        module.interjection = '[reaction] @someone reacted 👍';
-        module.interjectionChannelId = null;
-        module.interjectionMetadata = { channelId: '999888777', tags: ['chat:reaction'] };
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [], 'post-send prose stayed suppressed after a reaction');
-        await framework.stop();
-    });
-    it('text-only turns route to the turn-frozen locus, not a live re-resolution', async () => {
-        // The text-only dispatch runs after the agent is idle; a live resolution
-        // there can read the NEXT turn's trigger state or a post-restart cleared
-        // one (2026-07-22 Sol DM misroute). The stub increments its locus per
-        // resolveLocus() call: the turn-start freeze consumes chan-live-1, so a
-        // live re-resolution at dispatch would return chan-live-2. The frozen
-        // path must deliver to chan-live-1.
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'A quiet reply with no tools.' },
-        ]));
-        const framework = await createFramework();
-        const routed = stubChannelRegistry(framework);
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.deepEqual(routed, [
-            { text: 'A quiet reply with no tools.', locus: 'chan-live-1' },
-        ]);
-        await framework.stop();
-    });
-    it('announces the outbound locus in the window only when it changes', async () => {
-        // Turn 1 (locus chan-live-1, e2e): one durable [routing] notice — the
-        // boot baseline. Then the announce-on-change logic directly (MockMembrane
-        // supports one turn per test): same locus → silence (steady state must
-        // not chatter — KV); new locus → exactly one more notice.
-        membrane.pushResponse(createMockResponse([{ type: 'text', text: 'one' }]));
-        const framework = await createFramework();
-        stubChannelRegistry(framework);
-        const notices = [];
-        framework.onTrace((event) => {
-            const e = event;
-            if (e.type === 'message:added' && e.source === 'routing-notice') {
-                notices.push(e.source);
-            }
-        });
-        trigger(framework);
-        await framework.runUntilIdle();
-        assert.equal(notices.length, 1, 'first turn announced the boot-baseline locus');
-        const announce = framework.announceLocusIfChanged.bind(framework);
-        announce('assistant', 'chan-live-1');
-        assert.equal(notices.length, 1, 'unchanged locus announced nothing');
-        announce('assistant', 'chan-B');
-        assert.equal(notices.length, 2, 'changed locus announced exactly once');
-        announce('assistant', 'chan-B');
-        assert.equal(notices.length, 2, 'steady state on the new locus stays silent');
-        announce('assistant', null);
-        assert.equal(notices.length, 3, 'losing the locus is announced too');
-        await framework.stop();
-    });
-    // -------------------------------------------------------------------------
-    // Hear-while-acting
-    // -------------------------------------------------------------------------
-    it('injects a mid-turn message into the resumed stream at the tool boundary', async () => {
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Moving.' },
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'Heard you!' },
-        ]));
-        const framework = await createFramework();
-        module.interjection = 'look left!';
-        trigger(framework);
-        await framework.runUntilIdle();
-        const stream = membrane.lastStream;
-        assert.equal(stream.receivedToolResults.length, 1);
-        const options = stream.receivedToolResultOptions[0];
-        assert.ok(options?.injectedMessages, 'tool-result resume carried injected messages');
-        assert.equal(options.injectedMessages.length, 1);
-        const injected = options.injectedMessages[0];
-        assert.equal(injected.participant, 'Antra');
-        const text = injected.content
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text)
-            .join('\n');
-        assert.equal(text, 'look left!');
-        await framework.stop();
-    });
-    it('passes no injection options when nothing arrived mid-turn', async () => {
-        membrane.pushResponse(createMockResponse([
-            { type: 'tool_use', id: 'c1', name: 'robot--move', input: { dir: 'north' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'done' },
-        ]));
-        const framework = await createFramework();
-        trigger(framework);
-        await framework.runUntilIdle();
-        const stream = membrane.lastStream;
-        assert.equal(stream.receivedToolResults.length, 1);
-        assert.equal(stream.receivedToolResultOptions[0], undefined);
-        await framework.stop();
-    });
-});
-//# sourceMappingURL=present-while-acting.test.js.map