fix(cursor): preserve pending messages when isolating slash commands

pushIsolateAndClear() wipes the entire queue, so a normal prompt queued
before /summarize or /clear would be silently dropped. Add pushIsolated()
- isolation without clearing - and route Cursor slash commands through
it instead. Adds queue tests covering the preserve-then-isolate path.

Addresses PR tiann#747 review.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: heavygee

cli/src/cursor/cursorUserMessageQueue.test.ts

@@ -32,4 +32,22 @@ describe('enqueueCursorUserMessage', () => {
         const second = await queue.waitForMessagesAndGetAsString();
         expect(second?.message).toBe('next task');
     });
+
+    it('preserves a normal prompt queued before a slash command', async () => {
+        const queue = new MessageQueue2<EnhancedMode>((m) => m.permissionMode);
+        enqueueCursorUserMessage(queue, 'first work', mode, 'a');
+        enqueueCursorUserMessage(queue, '/summarize', mode, 'b');
+        enqueueCursorUserMessage(queue, 'after summarize', mode, 'c');
+
+        const first = await queue.waitForMessagesAndGetAsString();
+        expect(first?.message).toBe('first work');
+        expect(first?.isolate).toBe(false);
+
+        const second = await queue.waitForMessagesAndGetAsString();
+        expect(second?.message).toBe('/summarize');
+        expect(second?.isolate).toBe(true);
+
+        const third = await queue.waitForMessagesAndGetAsString();
+        expect(third?.message).toBe('after summarize');
+    });
 });

cli/src/cursor/cursorUserMessageQueue.ts

@@ -14,7 +14,7 @@ export function enqueueCursorUserMessage(
 ): void {
     const specialCommand = parseCursorSpecialCommand(formattedText);
     if (specialCommand.type !== null) {
-        messageQueue.pushIsolateAndClear(formattedText.trim(), enhancedMode, localId);
+        messageQueue.pushIsolated(formattedText.trim(), enhancedMode, localId);
         return;
     }
     messageQueue.push(formattedText, enhancedMode, localId);

cli/src/utils/MessageQueue2.test.ts

@@ -367,6 +367,28 @@ describe('MessageQueue2', () => {
         expect(batch1?.mode.type).toBe('A');
     });
 
+    it('should preserve pending messages when pushIsolated is used', async () => {
+        const queue = new MessageQueue2<{ type: string }>((mode) => mode.type);
+
+        queue.push('message1', { type: 'A' });
+        queue.push('message2', { type: 'A' });
+
+        queue.pushIsolated('isolated', { type: 'A' });
+
+        queue.push('message3', { type: 'A' });
+
+        const batch1 = await queue.waitForMessagesAndGetAsString();
+        expect(batch1?.message).toBe('message1\nmessage2');
+        expect(batch1?.isolate).toBe(false);
+
+        const batch2 = await queue.waitForMessagesAndGetAsString();
+        expect(batch2?.message).toBe('isolated');
+        expect(batch2?.isolate).toBe(true);
+
+        const batch3 = await queue.waitForMessagesAndGetAsString();
+        expect(batch3?.message).toBe('message3');
+    });
+
     it('should isolate messages pushed with pushIsolateAndClear', async () => {
         const queue = new MessageQueue2<{ type: string }>((mode) => mode.type);
 

cli/src/utils/MessageQueue2.ts

@@ -107,6 +107,43 @@ export class MessageQueue2<T> {
         logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
     }
 
+    /**
+     * Push a message that must be processed in isolation, preserving any
+     * messages already queued ahead of it. The new message is never batched
+     * with siblings (neither the ones before it, nor any that arrive after).
+     * Use this when a slash command must run alone but earlier prompts must
+     * still be delivered in order.
+     */
+    pushIsolated(message: string, mode: T, localId?: string): void {
+        if (this.closed) {
+            throw new Error('Cannot push to closed queue');
+        }
+
+        const modeHash = this.modeHasher(mode);
+        logger.debug(`[MessageQueue2] pushIsolated() called with mode hash: ${modeHash} - preserving ${this.queue.length} pending messages`);
+
+        this.queue.push({
+            message,
+            mode,
+            modeHash,
+            localId,
+            isolate: true
+        });
+
+        if (this.onMessageHandler) {
+            this.onMessageHandler(message, mode);
+        }
+
+        if (this.waiter) {
+            logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+            const waiter = this.waiter;
+            this.waiter = null;
+            waiter(true);
+        }
+
+        logger.debug(`[MessageQueue2] pushIsolated() completed. Queue size: ${this.queue.length}`);
+    }
+
     /**
      * Push a message that must be processed in complete isolation.
      * Clears any pending messages and ensures this message is never batched with others.