@qduc/term2 0.7.3 → 0.9.0

package/dist/services/session/conversation-session.characterization.test.js

@@ -0,0 +1,1266 @@
+import { it, expect } from 'vitest';
+import { createConversationSession, createConversationSessionComposition } from './session-composition.js';
+import { createMockSettingsService } from '../settings/settings-service.mock.js';
+import { MockStream } from '../test-helpers/mock-stream.js';
+import { TurnItemAccumulator } from './turn-item-accumulator.js';
+// ── Shared mocks ───────────────────────────────────────────────────────────
+const mockLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+    security: () => { },
+    setCorrelationId: () => { },
+    getCorrelationId: () => undefined,
+    clearCorrelationId: () => { },
+};
+const createSessionContextService = () => {
+    let capturedContext = null;
+    return {
+        runWithContext: (context, fn) => {
+            capturedContext = context;
+            return fn();
+        },
+        getContext: () => capturedContext,
+    };
+};
+// ── Helper: ApprovalState-like object for mock streams ────────────────────
+const createApprovalState = () => ({
+    approveCalls: [],
+    rejectCalls: [],
+    approve(interruption) {
+        this.approveCalls.push(interruption);
+    },
+    reject(interruption) {
+        this.rejectCalls.push(interruption);
+    },
+});
+const createShellInterruption = ({ callId, command }) => ({
+    name: 'shell',
+    agent: { name: 'CLI Agent' },
+    arguments: JSON.stringify({ command }),
+    ...(callId ? { callId } : {}),
+});
+// ── Helper: typed mock agent client ──────────────────────────────────────
+const createMockAgentClient = (overrides = {}) => ({
+    startStream: async () => new MockStream([]),
+    continueRunStream: async () => new MockStream([]),
+    abort: () => { },
+    setModel: () => { },
+    addToolInterceptor: () => () => { },
+    chat: async () => '',
+    ...overrides,
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 1. sendMessage wraps events with log dispatch and clears
+//    setSubagentEventSink in finally
+// ══════════════════════════════════════════════════════════════════════════
+it('sendMessage installs setSubagentEventSink with a function then clears it to null', async () => {
+    const sinkCalls = [];
+    const stream = new MockStream([]);
+    stream.finalOutput = 'Hello';
+    stream.lastResponseId = 'resp-sink-test';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'sink-test',
+        agentClient: mockClient,
+        subagentEventSinkHost: {
+            setSubagentEventSink(sink) {
+                sinkCalls.push(typeof sink === 'function' ? 'function' : sink);
+            },
+        },
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    await terminalAdapter.sendMessage('hello');
+    // First call: a function (the wrapped onEvent)
+    expect(sinkCalls[0], 'First setSubagentEventSink call should install a function callback').toBe('function');
+    // After the finally block: null
+    expect(sinkCalls[sinkCalls.length - 1], 'Last setSubagentEventSink call should clear to null').toBe(null);
+    // Exactly 2 calls: install then clear
+    expect(sinkCalls.length, 'setSubagentEventSink should be called exactly twice (install + clear)').toBe(2);
+});
+it('sendMessage dispatches events through conversationLogger before onEvent callback', async () => {
+    const eventLog = [];
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Hello' }]);
+    stream.finalOutput = 'Hello';
+    stream.lastResponseId = 'resp-log-dispatch';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'log-dispatch',
+        agentClient: mockClient,
+        subagentEventSinkHost: {
+            setSubagentEventSink() { },
+        },
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('hi', {
+        onEvent: (event) => {
+            eventLog.push({ phase: 'onEvent', type: event.type });
+        },
+    });
+    expect(result.type).toBe('response');
+    // The onEvent callback was called at least for final event
+    expect(eventLog.length > 0).toBe(true);
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 2. handleApprovalDecision returns null when no approval is pending
+// ══════════════════════════════════════════════════════════════════════════
+it('handleApprovalDecision returns null when no approval is pending', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-no-pending';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'no-pending',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    // No approval pending
+    const result = await terminalAdapter.handleApprovalDecision('y');
+    expect(result).toBe(null);
+});
+it('handleApprovalDecision returns null for rejection when no approval is pending', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-reject-no-pending';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'reject-no-pending',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.handleApprovalDecision('n', 'User rejected');
+    expect(result).toBe(null);
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 3. handleApprovalDecision sets ask-user answer by call ID for
+//    accepted approvals
+// ══════════════════════════════════════════════════════════════════════════
+it('handleApprovalDecision forwards approvalAnswer to agentClient.setAskUserAnswer', async () => {
+    const askUserCalls = [];
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [createShellInterruption({ callId: 'call-ask-user-test', command: 'echo test' })];
+    interruptedStream.state = createApprovalState();
+    const finalStream = new MockStream([]);
+    finalStream.finalOutput = 'Answer forwarded.';
+    finalStream.lastResponseId = 'resp-ask-user';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return interruptedStream;
+        },
+        async continueRunStream() {
+            return finalStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'ask-user-test',
+        agentClient: mockClient,
+        askUserAnswerSink: {
+            setAskUserAnswer(callId, answer) {
+                askUserCalls.push({ callId, answer });
+            },
+        },
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const approvalResult = await terminalAdapter.sendMessage('ask the user');
+    expect(approvalResult.type).toBe('approval_required');
+    const finalResult = await terminalAdapter.handleApprovalDecision('y', undefined, {
+        approvalAnswer: 'Use option B',
+    });
+    expect(finalResult?.type).toBe('response');
+    expect(finalResult.finalText).toBe('Answer forwarded.');
+    expect(askUserCalls).toEqual([{ callId: 'call-ask-user-test', answer: 'Use option B' }]);
+});
+it('handleApprovalDecision does not call setAskUserAnswer when answer is not y', async () => {
+    const askUserCalls = [];
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [createShellInterruption({ callId: 'call-reject', command: 'echo reject' })];
+    interruptedStream.state = createApprovalState();
+    const rejectionFinal = new MockStream([]);
+    rejectionFinal.finalOutput = 'Rejected.';
+    rejectionFinal.lastResponseId = 'resp-rejected';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return interruptedStream;
+        },
+        async continueRunStream() {
+            return rejectionFinal;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'reject-no-ask',
+        agentClient: mockClient,
+        askUserAnswerSink: {
+            setAskUserAnswer(callId, answer) {
+                askUserCalls.push({ callId, answer });
+            },
+        },
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const approvalResult = await terminalAdapter.sendMessage('run command');
+    expect(approvalResult.type).toBe('approval_required');
+    const rejectionResult = await terminalAdapter.handleApprovalDecision('n', 'User rejected', {
+        approvalAnswer: 'Use option B',
+    });
+    // Rejection returns a response from the continuation runner
+    expect(rejectionResult?.type).toBe('response');
+    expect(askUserCalls.length > 0).toBe(false);
+});
+it('handleApprovalDecision does not call setAskUserAnswer when approvalAnswer is not provided', async () => {
+    const askUserCalls = [];
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [createShellInterruption({ callId: 'call-no-answer', command: 'echo no answer' })];
+    interruptedStream.state = createApprovalState();
+    const noAnswerFinal = new MockStream([]);
+    noAnswerFinal.finalOutput = 'Done.';
+    noAnswerFinal.lastResponseId = 'resp-no-answer';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return interruptedStream;
+        },
+        async continueRunStream() {
+            return noAnswerFinal;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'no-answer-test',
+        agentClient: mockClient,
+        askUserAnswerSink: {
+            setAskUserAnswer(callId, answer) {
+                askUserCalls.push({ callId, answer });
+            },
+        },
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const approvalResult = await terminalAdapter.sendMessage('run command');
+    expect(approvalResult.type).toBe('approval_required');
+    // No approvalAnswer provided; handleApprovalDecision still calls continueAfterApproval
+    const result = await terminalAdapter.handleApprovalDecision('y');
+    expect(result?.type).toBe('response');
+    expect(askUserCalls.length > 0).toBe(false);
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 4. abort records aborted approval tool ledger entry only when an
+//    approval was pending
+// ══════════════════════════════════════════════════════════════════════════
+it('abort with no pending approval does not throw and produces no change in snapshot toolLedger', async () => {
+    const mockClient = createMockAgentClient({
+        abort() { },
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-abort-empty';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'abort-empty',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { turnCoordinator, stateFacade } = bundle;
+    // No approval pending; abort should be a no-op
+    turnCoordinator.abort();
+    // The tool ledger should still be empty
+    const snapshot = stateFacade.getCurrentSnapshot();
+    expect(snapshot.toolLedger, 'Tool ledger should be empty when no approval was pending at abort').toEqual([]);
+});
+it('abort with pending approval records aborted entry in tool ledger', async () => {
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [createShellInterruption({ callId: 'call-abort-1', command: 'echo abort me' })];
+    interruptedStream.state = createApprovalState();
+    const mockClient = createMockAgentClient({
+        abort() { },
+        async startStream() {
+            return interruptedStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'abort-pending',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { turnCoordinator, terminalAdapter, stateFacade } = bundle;
+    await terminalAdapter.sendMessage('run command');
+    // Now abort
+    turnCoordinator.abort();
+    // Verify the tool ledger has an aborted entry
+    const snapshot = stateFacade.getCurrentSnapshot();
+    const abortedEntries = snapshot.toolLedger.filter((entry) => entry.status === 'aborted');
+    expect(abortedEntries.length > 0).toBe(true);
+    expect(abortedEntries[0].callId).toBe('call-abort-1');
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 5. getCurrentSnapshot reconciles history with tool ledger and
+//    includes provider/model
+// ══════════════════════════════════════════════════════════════════════════
+it('getCurrentSnapshot returns expected shape with history, previousResponseId, and toolLedger', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-snapshot';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'snapshot-test',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { stateFacade } = bundle;
+    const snapshot = stateFacade.getCurrentSnapshot();
+    expect(Array.isArray(snapshot.history)).toBe(true);
+    expect(snapshot.previousResponseId === null || typeof snapshot.previousResponseId === 'string').toBe(true);
+    expect(Array.isArray(snapshot.toolLedger)).toBe(true);
+});
+it('getCurrentSnapshot includes provider from agentClient.getProvider when available', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-provider';
+            return stream;
+        },
+        getProvider() {
+            return 'test-provider';
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'provider-test',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { stateFacade } = bundle;
+    const snapshot = stateFacade.getCurrentSnapshot();
+    expect(snapshot.provider).toBe('test-provider');
+});
+it('getCurrentSnapshot includes model from settingsService when available', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-model';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'model-test',
+        agentClient: mockClient,
+        deps: {
+            logger: mockLogger,
+            settingsService: createMockSettingsService({ 'agent.model': 'gpt-4o-test' }),
+            sessionContextService: createSessionContextService(),
+        },
+    });
+    const { stateFacade } = bundle;
+    const snapshot = stateFacade.getCurrentSnapshot();
+    expect(snapshot.model).toBe('gpt-4o-test');
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 6. Provider/model/temperature/reasoning changes call
+//    afterProviderChanged before mutating agent client
+// ══════════════════════════════════════════════════════════════════════════
+it('setModel calls afterProviderChanged then agentClient.setModel', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-set-model';
+            return stream;
+        },
+        setModel(model) {
+            calls.push({ method: 'setModel', model });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'set-model',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.setModel('gpt-4');
+    expect(calls.length).toBe(1);
+    expect(calls[0].method).toBe('setModel');
+    expect(calls[0].model).toBe('gpt-4');
+});
+it('setProvider calls afterProviderChanged then agentClient.setProvider', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-set-provider';
+            return stream;
+        },
+        setProvider(provider) {
+            calls.push({ method: 'setProvider', provider });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'set-provider',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.setProvider('anthropic');
+    expect(calls.length).toBe(1);
+    expect(calls[0].method).toBe('setProvider');
+    expect(calls[0].provider).toBe('anthropic');
+});
+it('setProvider is idempotent via switchProvider alias', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-switch';
+            return stream;
+        },
+        setProvider(provider) {
+            calls.push({ method: 'setProvider', provider });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'switch-provider',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.switchProvider('openai');
+    expect(calls.length).toBe(1);
+    expect(calls[0].provider).toBe('openai');
+});
+it('setTemperature calls afterProviderChanged then agentClient.setTemperature', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-set-temp';
+            return stream;
+        },
+        setTemperature(temp) {
+            calls.push({ method: 'setTemperature', temp });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'set-temp',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.setTemperature(0.7);
+    expect(calls.length).toBe(1);
+    expect(calls[0].method).toBe('setTemperature');
+    expect(calls[0].temp).toBe(0.7);
+});
+it('setTemperature with undefined is passed through to agentClient', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-set-temp-undefined';
+            return stream;
+        },
+        setTemperature(temp) {
+            calls.push({ method: 'setTemperature', temp });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'set-temp-undef',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.setTemperature(undefined);
+    expect(calls.length).toBe(1);
+    expect(calls[0].temp).toBe(undefined);
+});
+it('setReasoningEffort calls afterProviderChanged then agentClient.setReasoningEffort', async () => {
+    const calls = [];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-set-reasoning';
+            return stream;
+        },
+        setReasoningEffort(effort) {
+            calls.push({ method: 'setReasoningEffort', effort });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'set-reasoning',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    runtimeController.setReasoningEffort('high');
+    expect(calls.length).toBe(1);
+    expect(calls[0].method).toBe('setReasoningEffort');
+    expect(calls[0].effort).toBe('high');
+});
+it('setReasoningEffort is a no-op when agentClient lacks setReasoningEffort', async () => {
+    // An agentClient without the optional setReasoningEffort method
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            const stream = new MockStream([]);
+            stream.finalOutput = 'Done.';
+            stream.lastResponseId = 'resp-no-reasoning';
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'no-reasoning',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { runtimeController } = bundle;
+    // Should not throw
+    runtimeController.setReasoningEffort('low');
+    expect(true).toBe(true);
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 7. Auto-approved tool continuations preserve cumulative usage and
+//    command messages (#buildAndResolve)
+// ══════════════════════════════════════════════════════════════════════════
+it('auto-approve: cumulative usage from continuation supersedes first-turn usage', async () => {
+    const firstInterruption = createShellInterruption({ callId: 'call-usage-1', command: 'ls source' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [firstInterruption];
+    initialStream.state = {
+        ...createApprovalState(),
+        usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+    };
+    const finalStream = new MockStream([]);
+    finalStream.finalOutput = 'Files listed.';
+    finalStream.lastResponseId = 'resp-usage-final';
+    finalStream.state = {
+        usage: { inputTokens: 300, outputTokens: 50, totalTokens: 350 },
+    };
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return finalStream;
+        },
+        async chat() {
+            return JSON.stringify({
+                results: [{ id: 'call-usage-1', reasoning: 'Listing files is read-only and safe.', approved: true }],
+            });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'auto-usage-test',
+        agentClient: mockClient,
+        deps: {
+            logger: mockLogger,
+            settingsService: createMockSettingsService({
+                'shell.autoApproveMode': 'auto',
+                'agent.autoApproveModel': 'test-model',
+                'agent.autoApproveProvider': 'test-provider',
+            }),
+            sessionContextService: createSessionContextService(),
+        },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('list the source files');
+    expect(result.type).toBe('response');
+    if (result.type !== 'response')
+        return;
+    // The continuation usage (300/50) supersedes the first-turn usage (100/20)
+    expect(result.usage?.prompt_tokens).toBe(300);
+    expect(result.usage?.completion_tokens).toBe(50);
+    expect(result.usage?.total_tokens).toBe(350);
+});
+it('auto-approve: finalText comes from auto-approved continuation', async () => {
+    const firstInterruption = createShellInterruption({ callId: 'call-text-1', command: 'echo hello' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [firstInterruption];
+    initialStream.state = createApprovalState();
+    const finalStream = new MockStream([]);
+    finalStream.finalOutput = 'Hello from continuation.';
+    finalStream.lastResponseId = 'resp-text-final';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return finalStream;
+        },
+        async chat() {
+            return JSON.stringify({
+                results: [{ id: 'call-text-1', reasoning: 'Safe command.', approved: true }],
+            });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'auto-text-test',
+        agentClient: mockClient,
+        deps: {
+            logger: mockLogger,
+            settingsService: createMockSettingsService({
+                'shell.autoApproveMode': 'auto',
+                'agent.autoApproveModel': 'test-model',
+                'agent.autoApproveProvider': 'test-provider',
+            }),
+            sessionContextService: createSessionContextService(),
+        },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('echo hello');
+    expect(result.type).toBe('response');
+    if (result.type !== 'response')
+        return;
+    expect(result.finalText).toBe('Hello from continuation.');
+});
+it('auto-approve: command messages from continuation are preserved in final result', async () => {
+    const firstInterruption = createShellInterruption({ callId: 'call-cmd-1', command: 'ls' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [firstInterruption];
+    initialStream.state = createApprovalState();
+    // This stream's state provides command message data through the continuation runner
+    const finalStream = new MockStream([]);
+    finalStream.finalOutput = 'Done.';
+    finalStream.lastResponseId = 'resp-cmd-final';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return finalStream;
+        },
+        async chat() {
+            return JSON.stringify({
+                results: [{ id: 'call-cmd-1', reasoning: 'Safe.', approved: true }],
+            });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'auto-cmd-test',
+        agentClient: mockClient,
+        deps: {
+            logger: mockLogger,
+            settingsService: createMockSettingsService({
+                'shell.autoApproveMode': 'auto',
+                'agent.autoApproveModel': 'test-model',
+                'agent.autoApproveProvider': 'test-provider',
+            }),
+            sessionContextService: createSessionContextService(),
+        },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('list files');
+    expect(result.type).toBe('response');
+    if (result.type !== 'response')
+        return;
+    expect(Array.isArray(result.commandMessages)).toBe(true);
+    expect(result.finalText).toBe('Done.');
+});
+it('auto-approve: two auto-approved commands continue until approval_required or final', async () => {
+    const first = createShellInterruption({ callId: 'call-batch-a', command: 'ls' });
+    const second = createShellInterruption({ callId: 'call-batch-b', command: 'pwd' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [first, second];
+    initialStream.state = createApprovalState();
+    const continuationStream = new MockStream([]);
+    continuationStream.interruptions = [second];
+    continuationStream.state = createApprovalState();
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+        async chat() {
+            return JSON.stringify({
+                results: [
+                    { id: 'call-batch-a', reasoning: 'Listing is safe.', approved: true },
+                    { id: 'call-batch-b', reasoning: 'PWD is safe but needs user approval.', approved: false },
+                ],
+            });
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'auto-batch-test',
+        agentClient: mockClient,
+        deps: {
+            logger: mockLogger,
+            settingsService: createMockSettingsService({
+                'shell.autoApproveMode': 'auto',
+                'agent.autoApproveModel': 'test-model',
+                'agent.autoApproveProvider': 'test-provider',
+            }),
+            sessionContextService: createSessionContextService(),
+        },
+    });
+    const { terminalAdapter } = bundle;
+    // First command is auto-approved; continuation hits the second which is
+    // rejected by the LLM, so we should get an approval_required event
+    const result = await terminalAdapter.sendMessage('list files and print working directory');
+    expect(result.type).toBe('approval_required');
+    if (result.type !== 'approval_required')
+        return;
+    // The second command is the one that triggered the prompt
+    expect(result.approval.toolName).toBe('shell');
+    expect(result.approval.llmAdvisory).toBeTruthy();
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 8. Traffic context includes session context fields
+// ══════════════════════════════════════════════════════════════════════════
+it('sendMessage runs inside sessionContextService.runWithContext with session context fields', async () => {
+    const contextLog = [];
+    const sessionContextService = {
+        runWithContext(context, fn) {
+            contextLog.push(context);
+            return fn();
+        },
+        getContext: () => null,
+    };
+    const loggerWithTrace = {
+        ...mockLogger,
+        getCorrelationId: () => 'trace-abc-123',
+    };
+    const stream = new MockStream([]);
+    stream.finalOutput = 'Traced.';
+    stream.lastResponseId = 'resp-traffic';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'traffic-test',
+        agentClient: mockClient,
+        deps: { logger: loggerWithTrace, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    await terminalAdapter.sendMessage('my first question');
+    expect(contextLog.length).toBe(1);
+    const ctx = contextLog[0];
+    expect(ctx.sessionId).toBe('traffic-test');
+    expect(ctx.sessionStartedAt, 'sessionStartedAt should be a non-empty string').toBeTruthy();
+    expect(ctx.firstUserMessagePreview).toBe('my first question');
+    expect(ctx.mode).toBe('standard'); // was: t.is(ctx.mode, 'standard', 'Default mode (no settingsService) should be standard')
+    expect(ctx.traceId).toBe('trace-abc-123');
+});
+it('sendMessage sets firstUserMessagePreview to first turn text even on subsequent messages', async () => {
+    const contextLog = [];
+    const sessionContextService = {
+        runWithContext(context, fn) {
+            contextLog.push(context);
+            return fn();
+        },
+        getContext: () => null,
+    };
+    const loggerWithTrace = {
+        ...mockLogger,
+        getCorrelationId: () => 'trace-second',
+    };
+    const makeStream = (text) => {
+        const s = new MockStream([]);
+        s.finalOutput = `Reply: ${text}`;
+        s.lastResponseId = `resp-${text}`;
+        return s;
+    };
+    let callCount = 0;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            callCount++;
+            return makeStream(`call-${callCount}`);
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'traffic-preview',
+        agentClient: mockClient,
+        deps: { logger: loggerWithTrace, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    // First message becomes the "first user message"
+    await terminalAdapter.sendMessage('first turn');
+    // Second message should still show "first turn" as the firstUserMessagePreview
+    await terminalAdapter.sendMessage('second turn');
+    expect(contextLog.length).toBe(2);
+    // Both traffic contexts should reference the first message as the preview
+    expect(contextLog[0].firstUserMessagePreview).toBe('first turn');
+    expect(contextLog[1].firstUserMessagePreview).toBe('first turn'); // was: t.is(contextLog[1].firstUserMessagePreview, 'first turn', 'Second turn should keep first turn as preview')
+});
+// ══════════════════════════════════════════════════════════════════════════
+// 9. TurnCoordinator observable event sequences
+// ══════════════════════════════════════════════════════════════════════════
+it('approval then approval emits each terminal boundary in order', async () => {
+    const first = createShellInterruption({ callId: 'call-first', command: 'echo first' });
+    const second = createShellInterruption({ callId: 'call-second', command: 'echo second' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [first];
+    initialStream.state = createApprovalState();
+    const continuationStream = new MockStream([]);
+    continuationStream.interruptions = [second];
+    continuationStream.state = createApprovalState();
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+    });
+    const { turnCoordinator: session } = createConversationSession({
+        sessionId: 'approval-then-approval',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const events = [];
+    for await (const event of session.start('run both commands')) {
+        events.push(event);
+    }
+    for await (const event of session.continueAfterApproval({ answer: 'y' })) {
+        events.push(event);
+    }
+    expect(events.map((event) => event.type === 'approval_required'
+        ? { type: event.type, callId: event.approval.callId }
+        : event.type === 'tool_started'
+            ? { type: event.type, callId: event.toolCallId }
+            : { type: event.type })).toEqual([
+        { type: 'approval_required', callId: 'call-first' },
+        { type: 'tool_started', callId: 'call-first' },
+        { type: 'approval_required', callId: 'call-second' },
+    ]);
+});
+it('approval then rejection emits no tool_started event for the rejected tool', async () => {
+    const interruption = createShellInterruption({ callId: 'call-rejected', command: 'echo rejected' });
+    const approvalState = createApprovalState();
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    initialStream.state = approvalState;
+    const rejectedStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Rejected.' }]);
+    rejectedStream.finalOutput = 'Rejected.';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return rejectedStream;
+        },
+    });
+    const { turnCoordinator: session } = createConversationSession({
+        sessionId: 'approval-then-rejection',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const events = [];
+    for await (const event of session.start('run a command')) {
+        events.push(event);
+    }
+    for await (const event of session.continueAfterApproval({
+        answer: 'n',
+        rejectionReason: 'Not needed',
+    })) {
+        events.push(event);
+    }
+    expect(events.map((event) => event.type === 'approval_required'
+        ? { type: event.type, callId: event.approval.callId }
+        : event.type === 'text_delta' || event.type === 'final'
+            ? { type: event.type, text: event.type === 'text_delta' ? event.delta : event.finalText }
+            : { type: event.type })).toEqual([
+        { type: 'approval_required', callId: 'call-rejected' },
+        { type: 'text_delta', text: 'Rejected.' },
+        { type: 'final', text: 'Rejected.' },
+    ]);
+    expect(approvalState.approveCalls).toEqual([]);
+    expect(approvalState.rejectCalls).toEqual([interruption]);
+});
+it('multiple sequential interruptions preserve approval and tool-start ordering', async () => {
+    const interruptions = [
+        createShellInterruption({ callId: 'call-one', command: 'echo one' }),
+        createShellInterruption({ callId: 'call-two', command: 'echo two' }),
+        createShellInterruption({ callId: 'call-three', command: 'echo three' }),
+    ];
+    const streams = interruptions.map((interruption) => {
+        const stream = new MockStream([]);
+        stream.interruptions = [interruption];
+        stream.state = createApprovalState();
+        return stream;
+    });
+    const finalStream = new MockStream([{ type: 'response.output_text.delta', delta: 'All done.' }]);
+    finalStream.finalOutput = 'All done.';
+    let continuationIndex = 0;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return streams[0];
+        },
+        async continueRunStream() {
+            continuationIndex++;
+            return continuationIndex < streams.length ? streams[continuationIndex] : finalStream;
+        },
+    });
+    const { turnCoordinator: session } = createConversationSession({
+        sessionId: 'sequential-interruptions',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const events = [];
+    for await (const event of session.start('run three commands')) {
+        events.push(event);
+    }
+    for (let index = 0; index < 3; index++) {
+        for await (const event of session.continueAfterApproval({ answer: 'y' })) {
+            events.push(event);
+        }
+    }
+    expect(events.map((event) => {
+        if (event.type === 'approval_required') {
+            return `${event.type}:${event.approval.callId}`;
+        }
+        if (event.type === 'tool_started') {
+            return `${event.type}:${event.toolCallId}`;
+        }
+        return event.type;
+    })).toEqual([
+        'approval_required:call-one',
+        'tool_started:call-one',
+        'approval_required:call-two',
+        'tool_started:call-two',
+        'approval_required:call-three',
+        'tool_started:call-three',
+        'text_delta',
+        'final',
+    ]);
+});
+it('aborted approval resolved by new user input emits the abort marker before resumed output', async () => {
+    const interruption = createShellInterruption({ callId: 'call-aborted', command: 'echo pending' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    initialStream.state = createApprovalState();
+    const resolvedStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Changed course.' }]);
+    resolvedStream.finalOutput = 'Changed course.';
+    const mockClient = createMockAgentClient({
+        abort() { },
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return resolvedStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'aborted-approval-resolution',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const events = [];
+    for await (const event of bundle.turnCoordinator.start('run pending command')) {
+        events.push(event);
+    }
+    bundle.turnCoordinator.abort();
+    for await (const event of bundle.turnCoordinator.start('do something else')) {
+        events.push(event);
+    }
+    expect(events.map((event) => event.type)).toEqual([
+        'approval_required',
+        'user_message_consumed_for_abort',
+        'text_delta',
+        'final',
+    ]);
+    expect(bundle.stateFacade.listUserTurns().map(({ text, imageCount }) => ({ text, imageCount }))).toEqual([
+        { text: 'run pending command', imageCount: 0 },
+    ]);
+});
+// ══════════════════════════════════════════════════════════════════════════
+// Refactoring characterization tests
+// ══════════════════════════════════════════════════════════════════════════
+it('characterization - undo while an approval is pending invalidates pending approval and prevents continuation', async () => {
+    const interruption = createShellInterruption({ callId: 'call-pending-tool', command: 'rm -rf /' });
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [interruption];
+    interruptedStream.state = createApprovalState();
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return interruptedStream;
+        },
+    });
+    const composition = createConversationSessionComposition({
+        sessionId: 'undo-pending-test',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+        turnAccumulator: new TurnItemAccumulator(),
+    });
+    const emitted = [];
+    for await (const event of composition.turnCoordinator.start('trigger tool call')) {
+        emitted.push(event);
+    }
+    // We should have received approval_required
+    expect(emitted.length).toBe(1);
+    expect(emitted[0].type).toBe('approval_required');
+    // Verify there is a pending approval in approvalState
+    expect(composition.approvalState.getPending()).toBeTruthy();
+    // Trigger undo
+    composition.stateFacade.undoLastUserTurn();
+    // Verify that pending approval is invalidated/cleared
+    expect(composition.approvalState.getPending()).toBe(null);
+    // Verify continuation is not allowed (throws error)
+    await expect(async () => {
+        for await (const _ of composition.turnCoordinator.continueAfterApproval({ answer: 'y' })) {
+        }
+    }).rejects.toThrow('No pending approval to continue.');
+});
+it('characterization - reset while an approval is pending invalidates pending approval and resets status machine', async () => {
+    const interruption = createShellInterruption({ callId: 'call-pending-tool-reset', command: 'rm -rf /' });
+    const interruptedStream = new MockStream([]);
+    interruptedStream.interruptions = [interruption];
+    interruptedStream.state = createApprovalState();
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return interruptedStream;
+        },
+    });
+    const composition = createConversationSessionComposition({
+        sessionId: 'reset-pending-test',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+        turnAccumulator: new TurnItemAccumulator(),
+    });
+    const emitted = [];
+    for await (const event of composition.turnCoordinator.start('trigger tool call')) {
+        emitted.push(event);
+    }
+    expect(emitted[0].type).toBe('approval_required');
+    expect(composition.approvalState.getPending()).toBeTruthy();
+    // Trigger reset
+    composition.stateFacade.reset();
+    // Verify pending approval is cleared
+    expect(composition.approvalState.getPending()).toBe(null);
+    // Verify continuation throws 'No pending approval to continue.' because status machine is reset to idle
+    await expect(async () => {
+        for await (const _ of composition.turnCoordinator.continueAfterApproval({ answer: 'y' })) {
+        }
+    }).rejects.toThrow('No pending approval to continue.');
+});
+// ══════════════════════════════════════════════════════════════════════════
+// Service-boundary characterization: critical gap coverage
+// ══════════════════════════════════════════════════════════════════════════
+it('characterization - fresh start execution recovers from transient error with successful re-drive', async () => {
+    const interruption = createShellInterruption({ callId: 'call-fresh-start', command: 'echo recover' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    initialStream.state = createApprovalState();
+    const freshStream = new MockStream([]);
+    freshStream.finalOutput = 'Recovered from transient error.';
+    freshStream.lastResponseId = 'resp-fresh-start';
+    let startCallCount = 0;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            startCallCount++;
+            if (startCallCount === 1) {
+                return initialStream;
+            }
+            // Second call is the fresh-start re-drive
+            return freshStream;
+        },
+        async continueRunStream() {
+            const error = new Error('Connection refused');
+            error.code = 'ECONNREFUSED';
+            throw error;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'fresh-start-exec',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    // First sendMessage -> approval_required
+    const result1 = await terminalAdapter.sendMessage('run command');
+    expect(result1.type).toBe('approval_required');
+    // handleApprovalDecision -> continuation throws -> fresh start re-drive -> response
+    const result2 = await terminalAdapter.handleApprovalDecision('y');
+    expect(result2?.type).toBe('response');
+    if (result2?.type === 'response') {
+        expect(result2.finalText).toBe('Recovered from transient error.');
+    }
+    expect(startCallCount).toBe(2); // was: t.is(startCallCount, 2, 'startStream should be called twice (initial + fresh start re-drive)')
+    const result3 = await terminalAdapter.sendMessage('next message');
+    expect(result3.type).toBe('response');
+    expect(startCallCount).toBe(3); // was: t.is(startCallCount, 3, 'a new turn should start after fresh-start recovery completes')
+});
+it('characterization - approve-approve-response through handleApprovalDecision API', async () => {
+    const first = createShellInterruption({ callId: 'call-aa1', command: 'echo first' });
+    const second = createShellInterruption({ callId: 'call-aa2', command: 'echo second' });
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [first];
+    initialStream.state = createApprovalState();
+    const continuationStream = new MockStream([]);
+    continuationStream.interruptions = [second];
+    continuationStream.state = createApprovalState();
+    const finalStream = new MockStream([]);
+    finalStream.finalOutput = 'All done.';
+    finalStream.lastResponseId = 'resp-aa2';
+    let continueCalls = 0;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            continueCalls++;
+            if (continueCalls === 1) {
+                return continuationStream;
+            }
+            return finalStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'appr-appr-resp',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    const events = [];
+    // First sendMessage -> approval_required (tool 1)
+    const r1 = await terminalAdapter.sendMessage('run commands', {
+        onEvent: (e) => events.push(e),
+    });
+    expect(r1.type).toBe('approval_required');
+    expect(r1.approval.callId).toBe('call-aa1');
+    // First handleApprovalDecision -> approval_required (tool 2)
+    const r2 = await terminalAdapter.handleApprovalDecision('y', undefined, {
+        onEvent: (e) => events.push(e),
+    });
+    expect(r2?.type).toBe('approval_required');
+    expect(r2?.approval.callId).toBe('call-aa2');
+    // Second handleApprovalDecision -> response
+    const r3 = await terminalAdapter.handleApprovalDecision('y', undefined, {
+        onEvent: (e) => events.push(e),
+    });
+    expect(r3?.type).toBe('response');
+    if (r3?.type === 'response') {
+        expect(r3.finalText).toBe('All done.');
+    }
+    // Verify tool_started events for both tools
+    const toolStarted = events.filter((e) => e.type === 'tool_started');
+    expect(toolStarted.length).toBe(2); // was: t.is(toolStarted.length, 2, 'Should have exactly 2 tool_started events')
+    expect(toolStarted[0].toolCallId).toBe('call-aa1');
+    expect(toolStarted[1].toolCallId).toBe('call-aa2');
+});
+it('characterization - reject then approve sequence through handleApprovalDecision API', async () => {
+    const firstTool = createShellInterruption({ callId: 'call-rej1', command: 'echo rejectable' });
+    const secondTool = createShellInterruption({ callId: 'call-appr1', command: 'echo approvable' });
+    const approvalState = createApprovalState();
+    const firstStream = new MockStream([]);
+    firstStream.interruptions = [firstTool];
+    firstStream.state = approvalState;
+    const rejectionResponse = new MockStream([{ type: 'response.output_text.delta', delta: 'Rejected.' }]);
+    rejectionResponse.finalOutput = 'Rejected.';
+    const secondStream = new MockStream([]);
+    secondStream.interruptions = [secondTool];
+    secondStream.state = createApprovalState();
+    const approvalResponse = new MockStream([{ type: 'response.output_text.delta', delta: 'Approved.' }]);
+    approvalResponse.finalOutput = 'Approved.';
+    let startCallCount = 0;
+    let continueCallCount = 0;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            startCallCount++;
+            if (startCallCount === 1)
+                return firstStream;
+            return secondStream;
+        },
+        async continueRunStream() {
+            continueCallCount++;
+            if (continueCallCount === 1)
+                return rejectionResponse;
+            return approvalResponse;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 'reject-approve',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+    });
+    const { terminalAdapter } = bundle;
+    // Turn 1: sendMessage -> approval_required
+    const r1 = await terminalAdapter.sendMessage('run command 1');
+    expect(r1.type).toBe('approval_required');
+    // Turn 1: reject -> response
+    const r2 = await terminalAdapter.handleApprovalDecision('n', 'Not needed');
+    expect(r2?.type).toBe('response');
+    expect(r2?.finalText).toBeTruthy();
+    // Verify rejection was recorded in the approval state
+    expect(approvalState.approveCalls.length).toBe(0); // was: t.is(approvalState.approveCalls.length, 0, 'No approvals should have been recorded')
+    expect(approvalState.rejectCalls.length).toBe(1); // was: t.is(approvalState.rejectCalls.length, 1, 'One rejection should be recorded')
+    expect(approvalState.rejectCalls[0].callId).toBe('call-rej1'); // was: t.is((approvalState.rejectCalls[0] as { callId: string }).callId, 'call-rej1', 'Rejected call should match')
+    // Turn 2: new sendMessage -> approval_required (subsequent tool needs approval after rejection)
+    const r3 = await terminalAdapter.sendMessage('run command 2');
+    expect(r3.type).toBe('approval_required');
+    // Turn 2: approve -> response (subsequent approval works correctly after rejection)
+    const r4 = await terminalAdapter.handleApprovalDecision('y');
+    expect(r4?.type).toBe('response');
+    if (r4?.type === 'response') {
+        expect(r4.finalText).toBe('Approved.');
+    }
+});
+it('characterization - abort during pending approval clears state and prevents continuation', async () => {
+    const interruption = createShellInterruption({ callId: 'call-abort-chain', command: 'echo pending' });
+    const approvalState = createApprovalState();
+    const stream = new MockStream([]);
+    stream.interruptions = [interruption];
+    stream.state = approvalState;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+        abort() { },
+    });
+    const composition = createConversationSessionComposition({
+        sessionId: 'abort-chain-test',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService: createSessionContextService() },
+        turnAccumulator: new TurnItemAccumulator(),
+    });
+    const emitted = [];
+    for await (const event of composition.turnCoordinator.start('run command')) {
+        emitted.push(event);
+    }
+    expect(emitted.length).toBe(1);
+    expect(emitted[0].type).toBe('approval_required');
+    expect(composition.approvalState.getPending(), 'Should have pending approval before abort').toBeTruthy();
+    // Abort while approval is pending
+    composition.turnCoordinator.abort();
+    // Status should return to idle
+    expect(composition.appState.statusMachine.current).toBe('idle'); // was: t.is(composition.appState.statusMachine.current, 'idle', 'Status machine should be idle after abort')
+    // No pending approval after abort
+    expect(composition.approvalState.getPending()).toBe(null); // was: t.is(composition.approvalState.getPending(), null, 'No pending approval after abort')
+    // Tool ledger should have aborted entry
+    const ledger = composition.toolTracker.ledger.export();
+    const abortedEntries = ledger.filter((entry) => entry.status === 'aborted');
+    expect(abortedEntries.length >= 1, 'Tool ledger should have at least one aborted entry').toBe(true);
+    expect(abortedEntries[0].callId).toBe('call-abort-chain'); // was: t.is(abortedEntries[0].callId, 'call-abort-chain', 'Aborted entry should match the interrupted call')
+});
+//# sourceMappingURL=conversation-session.characterization.test.js.map