@animalabs/agent-framework 0.22.2 → 0.22.4

package/dist/test/same-round-think-policy.test.js

@@ -1,853 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { AgentFramework } from '../src/index.js';
-import { MockMembrane, MockYieldingStream, createMockResponse } from './helpers/mock-membrane.js';
-const TILDE_PREFACE_80 = 'P'.repeat(80);
-const TILDE_THINK_4416 = 'T'.repeat(4416);
-class TestToolsModule {
-    name = 'tools';
-    async start(_ctx) { }
-    async stop() { }
-    getTools() {
-        return [
-            {
-                name: 'read',
-                description: 'Read from the workspace.',
-                inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
-            },
-            {
-                name: 'ping',
-                description: 'A non-silencing tool.',
-                inputSchema: { type: 'object', properties: {} },
-            },
-            {
-                name: 'think',
-                description: 'A namespaced tool that happens to be called think.',
-                inputSchema: { type: 'object', properties: { content: { type: 'string' } } },
-            },
-            {
-                name: 'send_message',
-                description: 'Explicitly send a message.',
-                inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
-            },
-        ];
-    }
-    async handleToolCall(call) {
-        return { success: true, data: { ok: true, tool: call.name, input: call.input } };
-    }
-    async onProcess(event, _state) {
-        if (event.type !== 'external-message')
-            return {};
-        const text = String(event.content ?? '');
-        return {
-            addMessages: [{ participant: 'Antra', content: [{ type: 'text', text }] }],
-            requestInference: text === 'go',
-        };
-    }
-}
-function makeToolRound(preface) {
-    return [
-        { type: 'text', text: preface },
-        { type: 'tool_use', id: 'think-1', name: 'think', input: { content: TILDE_THINK_4416 } },
-        { type: 'tool_use', id: 'read-1', name: 'tools--read', input: { path: 'project/secret.txt' } },
-    ];
-}
-function makeChannelRegistry(framework) {
-    const routed = [];
-    const explicit = {
-        getChannelTools: () => [
-            {
-                name: 'think',
-                description: 'private reasoning',
-                inputSchema: {
-                    type: 'object',
-                    properties: { content: { type: 'string' } },
-                    required: [],
-                },
-            },
-            {
-                name: 'skip_reply',
-                description: 'stay silent',
-                inputSchema: {
-                    type: 'object',
-                    properties: { reason: { type: 'string' } },
-                    required: [],
-                },
-            },
-        ],
-        handleChannelToolCall: async (toolName) => {
-            if (toolName === 'think') {
-                return {
-                    success: true,
-                    data: {
-                        noted: true,
-                        note: 'Thought recorded (private — not sent anywhere). Same-round text routing depends on your current same_round_think_text_policy; use agent_settings get to inspect it, or call skip_reply to end the turn without replying.',
-                    },
-                };
-            }
-            if (toolName === 'skip_reply') {
-                return {
-                    success: true,
-                    endTurn: true,
-                    data: { skipped: true, note: 'Turn ended; nothing sent.' },
-                };
-            }
-            return { success: false, error: `Unknown channel tool: ${toolName}`, isError: true };
-        },
-        resolveLocus: () => 'chan-test',
-        routeSpeech: async (_agent, text) => {
-            routed.push(text);
-        },
-        getDefaultPublishChannel: () => null,
-        isChannelOpen: () => true,
-        getDescriptor: () => undefined,
-    };
-    framework.channelRegistry = new Proxy(explicit, {
-        get: (target, prop) => (prop in target ? target[prop] : () => undefined),
-    });
-    return routed;
-}
-async function createFramework(opts) {
-    const dir = mkdtempSync(join(tmpdir(), 'same-round-think-'));
-    const membrane = opts?.membrane ?? new MockMembrane();
-    const agents = opts?.agents ?? [{
-            name: 'agent',
-            ...(opts?.policy !== undefined ? { sameRoundThinkTextPolicy: opts.policy } : {}),
-        }];
-    const framework = await AgentFramework.create({
-        storePath: join(dir, 'store'),
-        membrane: (membrane.asMembrane?.() ?? membrane),
-        agents: agents.map((agent) => ({
-            name: agent.name,
-            model: 'test-model',
-            systemPrompt: 'test',
-            ...(agent.sameRoundThinkTextPolicy !== undefined
-                ? { sameRoundThinkTextPolicy: agent.sameRoundThinkTextPolicy }
-                : {}),
-        })),
-        modules: [new TestToolsModule()],
-    });
-    const routed = makeChannelRegistry(framework);
-    return { dir, framework, membrane, routed };
-}
-function trigger(framework) {
-    framework.pushEvent({
-        type: 'external-message',
-        source: 'test',
-        content: 'go',
-        metadata: {},
-    });
-}
-async function waitFor(predicate, timeoutMs = 1000) {
-    const deadline = Date.now() + timeoutMs;
-    while (!predicate()) {
-        if (Date.now() >= deadline)
-            throw new Error('timed out waiting for condition');
-        await new Promise(resolve => setTimeout(resolve, 5));
-    }
-}
-class LegacyNoRoundContentStream {
-    pendingResolve = null;
-    deliveredComplete = false;
-    provideToolResults(_results) {
-        const resolve = this.pendingResolve;
-        this.pendingResolve = null;
-        resolve?.();
-    }
-    cancel() {
-        this.deliveredComplete = true;
-        const resolve = this.pendingResolve;
-        this.pendingResolve = null;
-        resolve?.();
-    }
-    async *[Symbol.asyncIterator]() {
-        yield {
-            type: 'tool-calls',
-            calls: [
-                { id: 'think-legacy', name: 'think', input: { content: TILDE_THINK_4416 } },
-                { id: 'read-legacy', name: 'tools--read', input: { path: 'project/secret.txt' } },
-            ],
-            context: {
-                rawText: '',
-                preamble: TILDE_PREFACE_80,
-                depth: 0,
-                previousResults: [],
-                accumulated: '',
-            },
-        };
-        await new Promise((resolve) => { this.pendingResolve = resolve; });
-        if (this.deliveredComplete)
-            return;
-        yield {
-            type: 'complete',
-            response: createMockResponse(makeToolRound(TILDE_PREFACE_80)),
-        };
-    }
-}
-class LegacyNoRoundContentMembrane {
-    calls = [];
-    streamYielding(request) {
-        this.calls.push(request);
-        return new LegacyNoRoundContentStream();
-    }
-}
-class PausedAfterFirstToolRoundStream {
-    responses;
-    events = [];
-    done = false;
-    _isWaitingForTools = false;
-    _pendingToolCallIds = [];
-    _toolDepth = 0;
-    pendingResolve = null;
-    paused = false;
-    receivedToolResults = [];
-    receivedToolResultOptions = [];
-    constructor(responses) {
-        this.responses = responses;
-        this.processResponse(0);
-    }
-    processResponse(index) {
-        const response = this.responses[index];
-        if (!response) {
-            this.done = true;
-            return;
-        }
-        if (response.rawAssistantText) {
-            this.events.push({
-                type: 'block',
-                event: { event: 'block_start', index: 0, block: { type: 'text' } },
-            });
-            this.events.push({
-                type: 'tokens',
-                content: response.rawAssistantText,
-                meta: { type: 'text', visible: true, blockIndex: 0 },
-            });
-            this.events.push({
-                type: 'block',
-                event: { event: 'block_complete', index: 0, block: { type: 'text', content: response.rawAssistantText } },
-            });
-        }
-        if (response.usage) {
-            this.events.push({ type: 'usage', usage: response.usage });
-        }
-        if (response.toolCalls.length > 0) {
-            this._isWaitingForTools = true;
-            this._pendingToolCallIds = response.toolCalls.map((tc) => tc.id);
-            this.events.push({
-                type: 'tool-calls',
-                calls: response.toolCalls.map((tc) => ({
-                    id: tc.id,
-                    name: tc.name,
-                    input: tc.input,
-                })),
-                context: {
-                    rawText: '',
-                    preamble: '',
-                    depth: this._toolDepth,
-                    previousResults: [],
-                    accumulated: '',
-                    roundContent: response.content,
-                },
-            });
-            return;
-        }
-        this.events.push({ type: 'complete', response });
-        this.done = true;
-    }
-    provideToolResults(results, options) {
-        if (!this._isWaitingForTools)
-            throw new Error('Not waiting for tools');
-        this.receivedToolResults.push(results);
-        this.receivedToolResultOptions.push(options);
-        this._isWaitingForTools = false;
-        this._pendingToolCallIds = [];
-        this._toolDepth++;
-        if (this._toolDepth === 1) {
-            this.paused = true;
-            return;
-        }
-        this.processResponse(this._toolDepth);
-        this.pendingResolve?.();
-        this.pendingResolve = null;
-    }
-    release() {
-        if (!this.paused)
-            return;
-        this.paused = false;
-        this.processResponse(this._toolDepth);
-        this.pendingResolve?.();
-        this.pendingResolve = null;
-    }
-    cancel() {
-        this.done = true;
-        this._pendingToolCallIds = [];
-        this.pendingResolve?.();
-        this.pendingResolve = null;
-    }
-    get isWaitingForTools() {
-        return this._isWaitingForTools;
-    }
-    get pendingToolCallIds() {
-        return [...this._pendingToolCallIds];
-    }
-    get toolDepth() {
-        return this._toolDepth;
-    }
-    async *[Symbol.asyncIterator]() {
-        while (true) {
-            while (this.events.length > 0) {
-                const event = this.events.shift();
-                yield event;
-                if (event.type === 'complete' || event.type === 'error' || event.type === 'aborted') {
-                    return;
-                }
-            }
-            if (this.done)
-                return;
-            await new Promise((resolve) => { this.pendingResolve = resolve; });
-        }
-    }
-}
-class ScenarioMembrane {
-    calls = [];
-    lastStream = null;
-    scenarios = [];
-    queueScenario(responses, opts) {
-        this.scenarios.push({ responses, pauseAfterFirstToolRound: opts?.pauseAfterFirstToolRound });
-    }
-    streamYielding(request) {
-        this.calls.push(request);
-        const next = this.scenarios.shift();
-        if (!next)
-            throw new Error('No queued stream scenario');
-        const stream = next.pauseAfterFirstToolRound
-            ? new PausedAfterFirstToolRoundStream(next.responses)
-            : new MockYieldingStream(next.responses);
-        this.lastStream = stream;
-        return stream;
-    }
-    asMembrane() {
-        return this;
-    }
-}
-function thinkDescription(request) {
-    const thinkTool = (request.tools ?? []).find((tool) => tool.name === 'think');
-    assert.ok(thinkTool, 'think tool should be present');
-    return thinkTool.description;
-}
-async function expectInFlightResetRestoresNextInferencePolicy(opts) {
-    const membrane = new ScenarioMembrane();
-    membrane.queueScenario([
-        createMockResponse([
-            { type: 'text', text: 'private request before reset' },
-            { type: 'tool_use', id: 'think-1', name: 'think', input: { content: TILDE_THINK_4416 } },
-            {
-                type: 'tool_use',
-                id: 'settings-1',
-                name: 'agent_settings',
-                input: opts.resetInput,
-            },
-            { type: 'tool_use', id: 'read-1', name: 'tools--read', input: { path: 'project/secret.txt' } },
-        ], 'tool_use'),
-        createMockResponse([
-            { type: 'text', text: 'still private in the continuation' },
-            { type: 'tool_use', id: 'think-2', name: 'think', input: { content: TILDE_THINK_4416 } },
-            { type: 'tool_use', id: 'ping-1', name: 'tools--ping', input: {} },
-        ], 'tool_use'),
-        createMockResponse([]),
-    ], { pauseAfterFirstToolRound: true });
-    membrane.queueScenario([
-        createMockResponse(makeToolRound('public on the next inference'), 'tool_use'),
-        createMockResponse([]),
-    ]);
-    const { dir, framework, routed } = await createFramework({
-        ...(opts.basePolicy !== undefined ? { policy: opts.basePolicy } : {}),
-        membrane,
-    });
-    try {
-        framework.updateAgentRuntimeSettings('agent', { sameRoundThinkTextPolicy: 'private' });
-        assert.equal(framework.getAgentRuntimeSettings('agent').sameRoundThinkTextPolicy, 'private');
-        framework.start();
-        trigger(framework);
-        await waitFor(() => membrane.calls.length === 1);
-        await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-        const firstRoundResults = membrane.lastStream.receivedToolResults[0];
-        const settingsResult = firstRoundResults.find((result) => result.toolUseId === 'settings-1');
-        assert.ok(settingsResult, 'agent_settings reset result should be present');
-        assert.match(settingsResult.content, /sameRoundThinkTextPolicyUpdateNote/);
-        assert.match(settingsResult.content, /next inference/);
-        assert.match(thinkDescription(membrane.calls[0]), /withheld from channel routing/);
-        assert.deepEqual(routed, []);
-        assert.equal(framework.getAgentRuntimeSettings('agent').sameRoundThinkTextPolicy, 'public');
-        assert.match(thinkDescription(await framework.previewActivation('agent')), /may still be routed publicly as your speech/);
-        membrane.lastStream.release();
-        await waitFor(() => framework.activeStreams.size === 0);
-        assert.deepEqual(routed, []);
-        trigger(framework);
-        await waitFor(() => membrane.calls.length === 2);
-        await waitFor(() => routed.length === 1);
-        assert.match(thinkDescription(membrane.calls[1]), /may still be routed publicly as your speech/);
-        assert.deepEqual(routed, ['public on the next inference']);
-    }
-    finally {
-        await framework.stop();
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-describe('same-round think text policy', () => {
-    it('compatibility default/public routes the exact Tilde-shaped same-round preface', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse(makeToolRound(TILDE_PREFACE_80), 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const { dir, framework, routed } = await createFramework({ membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, [TILDE_PREFACE_80]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('recipe private routes zero same-round prose for the exact Tilde shape', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse(makeToolRound(TILDE_PREFACE_80), 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, []);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('private is non-sticky: later non-think rounds and trailing prose route normally', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse(makeToolRound(TILDE_PREFACE_80), 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'visible same turn after a non-think tool round' },
-            { type: 'tool_use', id: 'ping-1', name: 'tools--ping', input: {} },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'visible trailing prose after tool results' },
-        ]));
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, [
-                'visible same turn after a non-think tool round',
-                'visible trailing prose after tool results',
-            ]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('public remains non-silencing across later rounds and trailing prose', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse(makeToolRound(TILDE_PREFACE_80), 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'still public in the next tool round' },
-            { type: 'tool_use', id: 'ping-2', name: 'tools--ping', input: {} },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'still public in trailing prose' },
-        ]));
-        const { dir, framework, routed } = await createFramework({ policy: 'public', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, [
-                TILDE_PREFACE_80,
-                'still public in the next tool round',
-                'still public in trailing prose',
-            ]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('think plus skip_reply remains silent under both policies', async () => {
-        for (const policy of ['public', 'private']) {
-            const membrane = new MockMembrane();
-            membrane.pushResponse(createMockResponse([
-                { type: 'text', text: TILDE_PREFACE_80 },
-                { type: 'tool_use', id: `think-${policy}`, name: 'think', input: { content: TILDE_THINK_4416 } },
-                { type: 'tool_use', id: `skip-${policy}`, name: 'skip_reply', input: { reason: 'no reply' } },
-            ], 'tool_use'));
-            membrane.pushResponse(createMockResponse([]));
-            const { dir, framework, routed } = await createFramework({ policy, membrane });
-            try {
-                trigger(framework);
-                await framework.runUntilIdle();
-                assert.deepEqual(routed, [], `${policy} should stay silent`);
-            }
-            finally {
-                await framework.stop();
-                rmSync(dir, { recursive: true, force: true });
-            }
-        }
-    });
-    it('explicit-send behavior is unchanged', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'sending directly' },
-            { type: 'tool_use', id: 'send-1', name: 'tools--send_message', input: { text: 'hi' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'this later tool round should still stay silent' },
-            { type: 'tool_use', id: 'ping-3', name: 'tools--ping', input: {} },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'and trailing prose should stay silent too' },
-        ]));
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, []);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('private keeps the preface in Chronicle while withholding it from channel routing', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse(makeToolRound(TILDE_PREFACE_80), 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, []);
-            const compiled = await framework.getAgent('agent').getContextManager().compile();
-            assert.ok(compiled.messages.some((message) => JSON.stringify(message.content).includes(TILDE_PREFACE_80)), 'the same-round preface should remain in Chronicle/context');
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('builds different provider-bound think descriptions per agent, and preview matches activation', async () => {
-        const { dir, framework } = await createFramework({
-            agents: [
-                { name: 'public-agent', sameRoundThinkTextPolicy: 'public' },
-                { name: 'private-agent', sameRoundThinkTextPolicy: 'private' },
-            ],
-        });
-        try {
-            const previewPublic = await framework.previewActivation('public-agent');
-            const previewPrivate = await framework.previewActivation('private-agent');
-            const publicThink = previewPublic.tools?.find((tool) => tool.name === 'think');
-            const privateThink = previewPrivate.tools?.find((tool) => tool.name === 'think');
-            const staticThinkBefore = framework.getAllTools().find((tool) => tool.name === 'think');
-            assert.ok(publicThink);
-            assert.ok(privateThink);
-            assert.ok(staticThinkBefore);
-            assert.match(publicThink.description, /may still be routed publicly as your speech/);
-            assert.match(privateThink.description, /withheld from channel routing/);
-            assert.equal(staticThinkBefore.description, 'private reasoning');
-            const publicActivationTools = framework.getToolsForAgent('public-agent');
-            const privateActivationTools = framework.getToolsForAgent('private-agent');
-            assert.equal(publicActivationTools.find((tool) => tool.name === 'think')?.description, publicThink?.description);
-            assert.equal(privateActivationTools.find((tool) => tool.name === 'think')?.description, privateThink?.description);
-            assert.equal(framework.getAllTools().find((tool) => tool.name === 'think')?.description, 'private reasoning');
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('a host update from public to private does not retroactively change an in-flight request snapshot', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse([
-                { type: 'text', text: 'public snapshot round one' },
-                { type: 'tool_use', id: 'think-1', name: 'think', input: { content: TILDE_THINK_4416 } },
-                { type: 'tool_use', id: 'read-1', name: 'tools--read', input: { path: 'project/secret.txt' } },
-            ], 'tool_use'),
-            createMockResponse([
-                { type: 'text', text: 'public snapshot round two' },
-                { type: 'tool_use', id: 'think-2', name: 'think', input: { content: TILDE_THINK_4416 } },
-                { type: 'tool_use', id: 'ping-1', name: 'tools--ping', input: {} },
-            ], 'tool_use'),
-            createMockResponse([]),
-        ], { pauseAfterFirstToolRound: true });
-        membrane.queueScenario([
-            createMockResponse(makeToolRound('next inference should now be private'), 'tool_use'),
-            createMockResponse([]),
-        ]);
-        const { dir, framework, routed } = await createFramework({ policy: 'public', membrane });
-        try {
-            framework.start();
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 1);
-            await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-            assert.match(thinkDescription(membrane.calls[0]), /may still be routed publicly as your speech/);
-            assert.deepEqual(routed, ['public snapshot round one']);
-            framework.updateAgentRuntimeSettings('agent', { sameRoundThinkTextPolicy: 'private' });
-            const preview = await framework.previewActivation('agent');
-            assert.match(thinkDescription(preview), /withheld from channel routing/);
-            membrane.lastStream.release();
-            await waitFor(() => routed.length === 2);
-            assert.deepEqual(routed, [
-                'public snapshot round one',
-                'public snapshot round two',
-            ]);
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 2);
-            await waitFor(() => framework.activeStreams.size === 0);
-            assert.match(thinkDescription(membrane.calls[1]), /withheld from channel routing/);
-            assert.deepEqual(routed, [
-                'public snapshot round one',
-                'public snapshot round two',
-            ]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('a host update from private to public does not retroactively change an in-flight request snapshot', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse(makeToolRound('private snapshot round one'), 'tool_use'),
-            createMockResponse([
-                { type: 'text', text: 'private snapshot round two' },
-                { type: 'tool_use', id: 'think-2', name: 'think', input: { content: TILDE_THINK_4416 } },
-                { type: 'tool_use', id: 'ping-1', name: 'tools--ping', input: {} },
-            ], 'tool_use'),
-            createMockResponse([]),
-        ], { pauseAfterFirstToolRound: true });
-        membrane.queueScenario([
-            createMockResponse(makeToolRound('next inference should now be public'), 'tool_use'),
-            createMockResponse([]),
-        ]);
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            framework.start();
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 1);
-            await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-            assert.match(thinkDescription(membrane.calls[0]), /withheld from channel routing/);
-            assert.deepEqual(routed, []);
-            framework.updateAgentRuntimeSettings('agent', { sameRoundThinkTextPolicy: 'public' });
-            membrane.lastStream.release();
-            await waitFor(() => framework.activeStreams.size === 0);
-            assert.deepEqual(routed, []);
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 2);
-            await waitFor(() => routed.length === 1);
-            assert.match(thinkDescription(membrane.calls[1]), /may still be routed publicly as your speech/);
-            assert.deepEqual(routed, ['next inference should now be public']);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('same-round agent_settings updates apply immediately to preview and next request, but not to the current request snapshot', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse([
-                { type: 'text', text: 'public request before update' },
-                { type: 'tool_use', id: 'think-1', name: 'think', input: { content: TILDE_THINK_4416 } },
-                {
-                    type: 'tool_use',
-                    id: 'settings-1',
-                    name: 'agent_settings',
-                    input: { action: 'update', same_round_think_text_policy: 'private' },
-                },
-                { type: 'tool_use', id: 'read-1', name: 'tools--read', input: { path: 'project/secret.txt' } },
-            ], 'tool_use'),
-            createMockResponse([
-                { type: 'text', text: 'still public in the continuation' },
-                { type: 'tool_use', id: 'think-2', name: 'think', input: { content: TILDE_THINK_4416 } },
-                { type: 'tool_use', id: 'ping-1', name: 'tools--ping', input: {} },
-            ], 'tool_use'),
-            createMockResponse([]),
-        ], { pauseAfterFirstToolRound: true });
-        membrane.queueScenario([
-            createMockResponse(makeToolRound('private on the next inference'), 'tool_use'),
-            createMockResponse([]),
-        ]);
-        const { dir, framework, routed } = await createFramework({ policy: 'public', membrane });
-        try {
-            framework.start();
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 1);
-            await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-            const firstRoundResults = membrane.lastStream.receivedToolResults[0];
-            assert.ok(firstRoundResults.some((result) => result.toolUseId === 'settings-1' &&
-                result.content.includes('sameRoundThinkTextPolicyUpdateNote')));
-            assert.deepEqual(routed, ['public request before update']);
-            assert.equal(framework.getAgentRuntimeSettings('agent').sameRoundThinkTextPolicy, 'private');
-            assert.match(thinkDescription(await framework.previewActivation('agent')), /withheld from channel routing/);
-            membrane.lastStream.release();
-            await waitFor(() => routed.length === 2);
-            assert.deepEqual(routed, [
-                'public request before update',
-                'still public in the continuation',
-            ]);
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 2);
-            await waitFor(() => framework.activeStreams.size === 0);
-            assert.match(thinkDescription(membrane.calls[1]), /withheld from channel routing/);
-            assert.deepEqual(routed, [
-                'public request before update',
-                'still public in the continuation',
-            ]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('same-round agent_settings explicit reset restores the compatibility policy only on the next inference', async () => {
-        await expectInFlightResetRestoresNextInferencePolicy({
-            resetInput: { action: 'reset', settings: ['same_round_think_text_policy'] },
-        });
-    });
-    it('same-round agent_settings reset-all restores the recipe policy only on the next inference', async () => {
-        await expectInFlightResetRestoresNextInferencePolicy({
-            basePolicy: 'public',
-            resetInput: { action: 'reset' },
-        });
-    });
-    it('agent_settings reset without same_round_think_text_policy omits the next-inference note', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse([
-                { type: 'tool_use', id: 'settings-1', name: 'agent_settings', input: { action: 'reset', settings: ['tail_tokens'] } },
-            ], 'tool_use'),
-            createMockResponse([]),
-        ], { pauseAfterFirstToolRound: true });
-        const { dir, framework } = await createFramework({ membrane });
-        try {
-            framework.start();
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 1);
-            await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-            const firstRoundResults = membrane.lastStream.receivedToolResults[0];
-            const settingsResult = firstRoundResults.find((result) => result.toolUseId === 'settings-1');
-            assert.ok(settingsResult, 'agent_settings reset result should be present');
-            assert.doesNotMatch(settingsResult.content, /sameRoundThinkTextPolicyUpdateNote/);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('preview reflects a hot policy update while an already-started activation keeps its original description snapshot', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse(makeToolRound('request snapshot stays public'), 'tool_use'),
-            createMockResponse([]),
-        ], { pauseAfterFirstToolRound: true });
-        const { dir, framework } = await createFramework({ policy: 'public', membrane });
-        try {
-            framework.start();
-            trigger(framework);
-            await waitFor(() => membrane.calls.length === 1);
-            await waitFor(() => membrane.lastStream?.receivedToolResults.length === 1);
-            assert.match(thinkDescription(membrane.calls[0]), /may still be routed publicly as your speech/);
-            framework.updateAgentRuntimeSettings('agent', { sameRoundThinkTextPolicy: 'private' });
-            assert.match(thinkDescription(await framework.previewActivation('agent')), /withheld from channel routing/);
-            assert.match(thinkDescription(membrane.calls[0]), /may still be routed publicly as your speech/);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('private policy suppresses only the synthesized think tool, not namespaced tools named think', async () => {
-        const membrane = new MockMembrane();
-        membrane.pushResponse(createMockResponse([
-            { type: 'text', text: 'namespaced think should still route' },
-            { type: 'tool_use', id: 'module-think-1', name: 'tools--think', input: { content: 'module thought' } },
-        ], 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, ['namespaced think should still route']);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('suppression logs do not include the withheld prose text', async () => {
-        const membrane = new MockMembrane();
-        const withheld = 'withheld private prose should not appear in logs';
-        membrane.pushResponse(createMockResponse(makeToolRound(withheld), 'tool_use'));
-        membrane.pushResponse(createMockResponse([]));
-        const { dir, framework } = await createFramework({ policy: 'private', membrane });
-        const originalError = console.error;
-        const errors = [];
-        console.error = (...args) => { errors.push(args.join(' ')); };
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.ok(errors.some((line) => line.includes('same_round_think_text_policy=private')));
-            assert.ok(errors.every((line) => !line.includes(withheld)));
-        }
-        finally {
-            console.error = originalError;
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('an ephemeral request gets its own effective think description snapshot', async () => {
-        const membrane = new ScenarioMembrane();
-        membrane.queueScenario([
-            createMockResponse([{ type: 'text', text: 'ephemeral done' }]),
-        ]);
-        const { dir, framework } = await createFramework({ membrane });
-        try {
-            const created = await framework.createEphemeralAgent({
-                name: 'ephemeral-worker',
-                model: 'test-model',
-                systemPrompt: 'test',
-                allowedTools: 'all',
-                sameRoundThinkTextPolicy: 'private',
-            });
-            created.contextManager.addMessage('user', [{ type: 'text', text: 'go' }]);
-            const run = framework.runEphemeralToCompletion(created.agent, created.contextManager);
-            framework.start();
-            const result = await run;
-            assert.equal(result.speech, 'ephemeral done');
-            assert.match(thinkDescription(membrane.calls[0]), /withheld from channel routing/);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('legacy/no-roundContent behavior remains unchanged', async () => {
-        const membrane = new LegacyNoRoundContentMembrane();
-        const { dir, framework, routed } = await createFramework({ policy: 'private', membrane });
-        try {
-            trigger(framework);
-            await framework.runUntilIdle();
-            assert.deepEqual(routed, [TILDE_PREFACE_80]);
-        }
-        finally {
-            await framework.stop();
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});
-//# sourceMappingURL=same-round-think-policy.test.js.map