@animalabs/agent-framework 0.6.6 → 0.6.8

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

@@ -0,0 +1,853 @@
+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