@vellumai/assistant 0.3.8 → 0.3.9

package/src/__tests__/call-state.test.ts

@@ -16,11 +16,11 @@ import {
   registerCallCompletionNotifier,
   unregisterCallCompletionNotifier,
   fireCallCompletionNotifier,
-  registerCallOrchestrator,
-  unregisterCallOrchestrator,
-  getCallOrchestrator,
+  registerCallController,
+  unregisterCallController,
+  getCallController,
 } from '../calls/call-state.js';
-import type { CallOrchestrator } from '../calls/call-orchestrator.js';
+import type { CallController } from '../calls/call-controller.js';
 
 describe('call-state', () => {
   // Clean up notifiers between tests
@@ -28,7 +28,7 @@ describe('call-state', () => {
     unregisterCallQuestionNotifier('test-conv');
     unregisterCallTranscriptNotifier('test-conv');
     unregisterCallCompletionNotifier('test-conv');
-    unregisterCallOrchestrator('test-session');
+    unregisterCallController('test-session');
   });
 
   // ── Question notifiers ────────────────────────────────────────────
@@ -135,40 +135,40 @@ describe('call-state', () => {
     fireCallCompletionNotifier('unregistered-conv', 'session-1');
   });
 
-  // ── Orchestrator registry ─────────────────────────────────────────
+  // ── Controller registry ─────────────────────────────────────────
 
-  test('registerCallOrchestrator + getCallOrchestrator: retrieves orchestrator', () => {
-    const fakeOrchestrator = { id: 'fake-orch' } as unknown as CallOrchestrator;
+  test('registerCallController + getCallController: retrieves controller', () => {
+    const fakeController = { id: 'fake-ctrl' } as unknown as CallController;
 
-    registerCallOrchestrator('test-session', fakeOrchestrator);
+    registerCallController('test-session', fakeController);
 
-    const retrieved = getCallOrchestrator('test-session');
-    expect(retrieved).toBe(fakeOrchestrator);
+    const retrieved = getCallController('test-session');
+    expect(retrieved).toBe(fakeController);
   });
 
-  test('unregisterCallOrchestrator: getCallOrchestrator returns undefined after unregister', () => {
-    const fakeOrchestrator = { id: 'fake-orch-2' } as unknown as CallOrchestrator;
+  test('unregisterCallController: getCallController returns undefined after unregister', () => {
+    const fakeController = { id: 'fake-ctrl-2' } as unknown as CallController;
 
-    registerCallOrchestrator('test-session', fakeOrchestrator);
-    unregisterCallOrchestrator('test-session');
+    registerCallController('test-session', fakeController);
+    unregisterCallController('test-session');
 
-    const retrieved = getCallOrchestrator('test-session');
+    const retrieved = getCallController('test-session');
     expect(retrieved).toBeUndefined();
   });
 
-  test('getCallOrchestrator returns undefined for unregistered session', () => {
-    const retrieved = getCallOrchestrator('nonexistent-session');
+  test('getCallController returns undefined for unregistered session', () => {
+    const retrieved = getCallController('nonexistent-session');
     expect(retrieved).toBeUndefined();
   });
 
-  test('registering a new orchestrator for same session overwrites the previous one', () => {
-    const first = { id: 'first' } as unknown as CallOrchestrator;
-    const second = { id: 'second' } as unknown as CallOrchestrator;
+  test('registering a new controller for same session overwrites the previous one', () => {
+    const first = { id: 'first' } as unknown as CallController;
+    const second = { id: 'second' } as unknown as CallController;
 
-    registerCallOrchestrator('test-session', first);
-    registerCallOrchestrator('test-session', second);
+    registerCallController('test-session', first);
+    registerCallController('test-session', second);
 
-    const retrieved = getCallOrchestrator('test-session');
+    const retrieved = getCallController('test-session');
     expect(retrieved).toBe(second);
   });
 });

package/src/__tests__/ipc-snapshot.test.ts

@@ -51,6 +51,11 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'session_switch',
     sessionId: 'sess-002',
   },
+  session_rename: {
+    type: 'session_rename',
+    sessionId: 'sess-002',
+    title: 'Renamed session',
+  },
   ping: {
     type: 'ping',
   },
@@ -1064,6 +1069,15 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     label: 'Call Sidd',
     message: 'Remember to call Sidd about the project',
   },
+  notification_intent: {
+    type: 'notification_intent',
+    sourceEventName: 'guardian.question',
+    title: '⚠️ Attention needed',
+    body: 'Your assistant needs your input.',
+    deepLinkMetadata: {
+      conversationId: 'conv-guardian-001',
+    },
+  },
   schedule_complete: {
     type: 'schedule_complete',
     scheduleId: 'sched-001',

package/src/__tests__/relay-server.test.ts

@@ -263,8 +263,8 @@ describe('relay-server', () => {
     const connectedEvents = events.filter(e => e.eventType === 'call_connected');
     expect(connectedEvents.length).toBe(1);
 
-    // Verify orchestrator was created
-    expect(relay.getOrchestrator()).not.toBeNull();
+    // Verify controller was created
+    expect(relay.getController()).not.toBeNull();
 
     relay.destroy();
   });
@@ -815,11 +815,11 @@ describe('relay-server', () => {
       to: '+15552222222',
     }));
 
-    expect(relay.getOrchestrator()).not.toBeNull();
+    expect(relay.getController()).not.toBeNull();
 
     relay.destroy();
 
-    expect(relay.getOrchestrator()).toBeNull();
+    expect(relay.getController()).toBeNull();
   });
 
   test('destroy: can be called multiple times without error', () => {
@@ -1145,7 +1145,7 @@ describe('relay-server', () => {
       to: '+15551111111',
     }));
 
-    const runtimeContext = (relay.getOrchestrator() as unknown as { guardianContext?: { sourceChannel?: string; actorRole?: string; guardianExternalUserId?: string } })?.guardianContext;
+    const runtimeContext = (relay.getController() as unknown as { guardianContext?: { sourceChannel?: string; actorRole?: string; guardianExternalUserId?: string } })?.guardianContext;
     expect(runtimeContext?.sourceChannel).toBe('voice');
     expect(runtimeContext?.actorRole).toBe('guardian');
     expect(runtimeContext?.guardianExternalUserId).toBe('+15550001111');
@@ -1181,7 +1181,7 @@ describe('relay-server', () => {
       to: '+15551111111',
     }));
 
-    const runtimeContext = (relay.getOrchestrator() as unknown as {
+    const runtimeContext = (relay.getController() as unknown as {
       guardianContext?: {
         sourceChannel?: string;
         actorRole?: string;
@@ -1197,7 +1197,7 @@ describe('relay-server', () => {
     relay.destroy();
   });
 
-  test('inbound guardian verification updates orchestrator context to guardian', async () => {
+  test('inbound guardian verification updates controller context to guardian', async () => {
     ensureConversation('conv-guardian-context-upgrade');
     const session = createCallSession({
       conversationId: 'conv-guardian-context-upgrade',
@@ -1219,7 +1219,7 @@ describe('relay-server', () => {
       to: session.toNumber,
     }));
 
-    const preVerify = (relay.getOrchestrator() as unknown as {
+    const preVerify = (relay.getController() as unknown as {
       guardianContext?: { actorRole?: string };
     })?.guardianContext;
     expect(preVerify?.actorRole).toBe('unverified_channel');
@@ -1233,7 +1233,7 @@ describe('relay-server', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    const postVerify = (relay.getOrchestrator() as unknown as {
+    const postVerify = (relay.getController() as unknown as {
       guardianContext?: { sourceChannel?: string; actorRole?: string; guardianExternalUserId?: string };
     })?.guardianContext;
     expect(postVerify?.sourceChannel).toBe('voice');

package/src/__tests__/run-orchestrator.test.ts

@@ -36,6 +36,7 @@ import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { createConversation } from '../memory/conversation-store.js';
 import { createRun, getRun, setRunConfirmation } from '../memory/runs-store.js';
 import { RunOrchestrator } from '../runtime/run-orchestrator.js';
+import type { VoiceRunEventSink } from '../runtime/run-orchestrator.js';
 import type { ChannelCapabilities } from '../daemon/session-runtime-assembly.js';
 
 initializeDb();
@@ -53,6 +54,7 @@ function makeSessionWithConfirmation(message: ServerMessage): Session {
     setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },
@@ -78,6 +80,7 @@ function makeSessionWithEvent(message: ServerMessage): Session {
     setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       onEvent(message);
@@ -110,7 +113,7 @@ describe('run failure detection', () => {
       deriveDefaultStrictSideEffects: () => false,
     });
 
-    const run = await orchestrator.startRun(conversation.id, 'Hello');
+    const { run } = await orchestrator.startRun(conversation.id, 'Hello');
 
     // The agent loop fires asynchronously; give it a tick to settle.
     await new Promise((r) => setTimeout(r, 50));
@@ -133,7 +136,7 @@ describe('run failure detection', () => {
       deriveDefaultStrictSideEffects: () => false,
     });
 
-    const run = await orchestrator.startRun(conversation.id, 'Hello');
+    const { run } = await orchestrator.startRun(conversation.id, 'Hello');
 
     await new Promise((r) => setTimeout(r, 50));
 
@@ -212,7 +215,7 @@ describe('run approval state executionTarget', () => {
       deriveDefaultStrictSideEffects: () => false,
     });
 
-    const run = await orchestrator.startRun(conversation.id, 'Run host command');
+    const { run } = await orchestrator.startRun(conversation.id, 'Run host command');
     const stored = orchestrator.getRun(run.id);
     expect(stored?.status).toBe('needs_confirmation');
     expect(stored?.pendingConfirmation?.executionTarget).toBe('host');
@@ -246,6 +249,7 @@ describe('startRun channel capability resolution', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -284,6 +288,7 @@ describe('startRun channel capability resolution', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -318,6 +323,7 @@ describe('startRun channel capability resolution', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -365,6 +371,7 @@ describe('strictSideEffects re-derivation across runs', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -403,6 +410,7 @@ describe('strictSideEffects re-derivation across runs', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -442,6 +450,7 @@ describe('strictSideEffects re-derivation across runs', () => {
       setGuardianContext: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
+    setVoiceCallControlPrompt: () => {},
       updateClient: () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -461,3 +470,390 @@ describe('strictSideEffects re-derivation across runs', () => {
     expect((session as unknown as { memoryPolicy: { strictSideEffects: boolean } }).memoryPolicy.strictSideEffects).toBe(false);
   });
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// VoiceRunEventSink forwarding
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('eventSink forwarding', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('eventSink receives assistant_text_delta events', async () => {
+    const conversation = createConversation('event sink delta test');
+    const deltaMsg: ServerMessage = {
+      type: 'assistant_text_delta',
+      text: 'Hello from agent',
+      sessionId: conversation.id,
+    };
+    const session = makeSessionWithEvent(deltaMsg);
+
+    const receivedDeltas: string[] = [];
+    const sink: VoiceRunEventSink = {
+      onTextDelta: (text) => receivedDeltas.push(text),
+      onMessageComplete: () => {},
+      onError: () => {},
+      onToolUse: () => {},
+    };
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello', undefined, {
+      eventSink: sink,
+    });
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(receivedDeltas).toEqual(['Hello from agent']);
+  });
+
+  test('eventSink receives error events', async () => {
+    const conversation = createConversation('event sink error test');
+    const errMsg: ServerMessage = {
+      type: 'error',
+      message: 'Something broke',
+    };
+    const session = makeSessionWithEvent(errMsg);
+
+    const receivedErrors: string[] = [];
+    const sink: VoiceRunEventSink = {
+      onTextDelta: () => {},
+      onMessageComplete: () => {},
+      onError: (msg) => receivedErrors.push(msg),
+      onToolUse: () => {},
+    };
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello', undefined, {
+      eventSink: sink,
+    });
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(receivedErrors).toEqual(['Something broke']);
+  });
+
+  test('eventSink receives tool_use_start events', async () => {
+    const conversation = createConversation('event sink tool test');
+    const toolMsg: ServerMessage = {
+      type: 'tool_use_start',
+      toolName: 'web_search',
+      input: { query: 'test' },
+      sessionId: conversation.id,
+    };
+    const session = makeSessionWithEvent(toolMsg);
+
+    const receivedTools: Array<{ name: string; input: Record<string, unknown> }> = [];
+    const sink: VoiceRunEventSink = {
+      onTextDelta: () => {},
+      onMessageComplete: () => {},
+      onError: () => {},
+      onToolUse: (name, input) => receivedTools.push({ name, input }),
+    };
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello', undefined, {
+      eventSink: sink,
+    });
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(receivedTools).toHaveLength(1);
+    expect(receivedTools[0].name).toBe('web_search');
+    expect(receivedTools[0].input).toEqual({ query: 'test' });
+  });
+
+  test('eventSink receives onMessageComplete on generation_cancelled', async () => {
+    const conversation = createConversation('event sink cancelled test');
+    const cancelledMsg: ServerMessage = {
+      type: 'generation_cancelled',
+      sessionId: conversation.id,
+    };
+    const session = makeSessionWithEvent(cancelledMsg);
+
+    let messageCompleteCount = 0;
+    const receivedErrors: string[] = [];
+    const sink: VoiceRunEventSink = {
+      onTextDelta: () => {},
+      onMessageComplete: () => { messageCompleteCount++; },
+      onError: (msg) => receivedErrors.push(msg),
+      onToolUse: () => {},
+    };
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello', undefined, {
+      eventSink: sink,
+    });
+    await new Promise((r) => setTimeout(r, 50));
+
+    // generation_cancelled should be forwarded as onMessageComplete
+    expect(messageCompleteCount).toBe(1);
+    // It should NOT trigger onError
+    expect(receivedErrors).toHaveLength(0);
+  });
+
+  test('eventSink receives onError when runAgentLoop throws', async () => {
+    const conversation = createConversation('event sink exception test');
+
+    // Build a session whose runAgentLoop throws an exception instead of
+    // emitting events — simulating an unhandled crash in the agent loop.
+    const session = {
+      isProcessing: () => false,
+      persistUserMessage: () => undefined as unknown as string,
+      memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setGuardianContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      runAgentLoop: async () => {
+        throw new Error('Unexpected agent crash');
+      },
+      handleConfirmationResponse: () => {},
+    } as unknown as Session;
+
+    const receivedErrors: string[] = [];
+    const sink: VoiceRunEventSink = {
+      onTextDelta: () => {},
+      onMessageComplete: () => {},
+      onError: (msg) => receivedErrors.push(msg),
+      onToolUse: () => {},
+    };
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello', undefined, {
+      eventSink: sink,
+    });
+    await new Promise((r) => setTimeout(r, 50));
+
+    // The exception message should be forwarded to the event sink
+    expect(receivedErrors).toEqual(['Unexpected agent crash']);
+  });
+
+  test('no events forwarded when eventSink is not provided', async () => {
+    const conversation = createConversation('no sink test');
+    const deltaMsg: ServerMessage = {
+      type: 'assistant_text_delta',
+      text: 'Hello',
+      sessionId: conversation.id,
+    };
+    const session = makeSessionWithEvent(deltaMsg);
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    // Should not throw when no eventSink is provided
+    const { run } = await orchestrator.startRun(conversation.id, 'Hello');
+    await new Promise((r) => setTimeout(r, 50));
+
+    const stored = orchestrator.getRun(run.id);
+    expect(stored?.status).toBe('completed');
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Run abort / cancellation
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('run abort', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('startRun returns an abort function', async () => {
+    const conversation = createConversation('abort handle test');
+    const session = {
+      isProcessing: () => false,
+      currentRequestId: undefined as string | undefined,
+      persistUserMessage: (_c: string, _a: unknown[], reqId: string) => {
+        session.currentRequestId = reqId;
+        return undefined as unknown as string;
+      },
+      memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setGuardianContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Session;
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    const handle = await orchestrator.startRun(conversation.id, 'Hello');
+    expect(typeof handle.abort).toBe('function');
+    expect(handle.run.id).toBeDefined();
+  });
+
+  test('aborting a run does not crash session state', async () => {
+    const conversation = createConversation('abort safety test');
+    let abortCalled = false;
+
+    const session = {
+      isProcessing: () => false,
+      currentRequestId: undefined as string | undefined,
+      persistUserMessage: (_c: string, _a: unknown[], reqId: string) => {
+        session.currentRequestId = reqId;
+        return undefined as unknown as string;
+      },
+      memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setGuardianContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      runAgentLoop: async () => {
+        // Simulate a long-running agent loop
+        await new Promise((r) => setTimeout(r, 200));
+      },
+      handleConfirmationResponse: () => {},
+      abort: () => { abortCalled = true; },
+    } as unknown as Session;
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    const handle = await orchestrator.startRun(conversation.id, 'Hello');
+
+    // Abort immediately — session still has same requestId
+    handle.abort();
+    expect(abortCalled).toBe(true);
+
+    // Wait for cleanup to settle
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Session state should not be corrupted — the run completes normally
+    // since the mock runAgentLoop resolves after 200ms regardless.
+    const stored = orchestrator.getRun(handle.run.id);
+    expect(stored).not.toBeNull();
+  });
+
+  test('stale abort handle is a no-op when session has moved to a new run', async () => {
+    const conversation = createConversation('stale abort test');
+    let abortCalled = false;
+
+    const session = {
+      isProcessing: () => false,
+      currentRequestId: undefined as string | undefined,
+      persistUserMessage: (_c: string, _a: unknown[], reqId: string) => {
+        session.currentRequestId = reqId;
+        return undefined as unknown as string;
+      },
+      memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setGuardianContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => { abortCalled = true; },
+    } as unknown as Session;
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    // Start first run and capture its handle
+    const handle1 = await orchestrator.startRun(conversation.id, 'First turn');
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Start second run — session's currentRequestId now belongs to run 2
+    const _handle2 = await orchestrator.startRun(conversation.id, 'Second turn');
+
+    // Attempt to abort using the stale handle from run 1.
+    // Since the session has moved to a new requestId, this should be a no-op.
+    handle1.abort();
+    expect(abortCalled).toBe(false);
+  });
+
+  test('abort works when session still has matching requestId', async () => {
+    const conversation = createConversation('matching abort test');
+    let abortCalled = false;
+
+    const session = {
+      isProcessing: () => false,
+      currentRequestId: undefined as string | undefined,
+      persistUserMessage: (_c: string, _a: unknown[], reqId: string) => {
+        session.currentRequestId = reqId;
+        return undefined as unknown as string;
+      },
+      memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setGuardianContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      runAgentLoop: async () => {
+        // Keep the agent loop running so the session stays on this requestId
+        await new Promise((r) => setTimeout(r, 500));
+      },
+      handleConfirmationResponse: () => {},
+      abort: () => { abortCalled = true; },
+    } as unknown as Session;
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+      deriveDefaultStrictSideEffects: () => false,
+    });
+
+    const handle = await orchestrator.startRun(conversation.id, 'Hello');
+
+    // Abort while the session is still processing this run
+    handle.abort();
+    expect(abortCalled).toBe(true);
+  });
+});