🤖 fix: avoid restore-to-input clobbering edit mode

Author: ammar-agent

src/browser/components/ChatInput/index.tsx

@@ -654,6 +654,9 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
       const { text, mode = "append", imageParts } = customEvent.detail;
 
       if (mode === "replace") {
+        if (editingMessage) {
+          return;
+        }
         restoreText(text);
       } else {
         appendText(text);
@@ -666,7 +669,7 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
     window.addEventListener(CUSTOM_EVENTS.INSERT_TO_CHAT_INPUT, handler as EventListener);
     return () =>
       window.removeEventListener(CUSTOM_EVENTS.INSERT_TO_CHAT_INPUT, handler as EventListener);
-  }, [appendText, restoreText, restoreImages]);
+  }, [appendText, restoreText, restoreImages, editingMessage]);
 
   // Allow external components to open the Model Selector
   useEffect(() => {

src/browser/utils/compaction/handler.test.ts

@@ -3,8 +3,13 @@ import type { APIClient } from "@/browser/contexts/API";
 import { cancelCompaction } from "./handler";
 
 describe("cancelCompaction", () => {
-  test("interrupts without restore-to-input and enters edit mode with full text", async () => {
-    const interruptStream = mock(() => Promise.resolve({ success: true }));
+  test("enters edit mode with full text before interrupting", async () => {
+    const calls: string[] = [];
+
+    const interruptStream = mock(() => {
+      calls.push("interrupt");
+      return Promise.resolve({ success: true });
+    });
 
     const client = {
       workspace: {
@@ -28,15 +33,19 @@ describe("cancelCompaction", () => {
       ],
     } as unknown as Parameters<typeof cancelCompaction>[2];
 
-    const startEditingMessage = mock(() => undefined);
+    const startEditingMessage = mock(() => {
+      calls.push("edit");
+      return undefined;
+    });
 
     const result = await cancelCompaction(client, "ws-1", aggregator, startEditingMessage);
 
     expect(result).toBe(true);
+    expect(startEditingMessage).toHaveBeenCalledWith("user-1", "/compact -t 100\nDo the thing");
     expect(interruptStream).toHaveBeenCalledWith({
       workspaceId: "ws-1",
-      options: { abandonPartial: true, restoreQueuedToInput: false },
+      options: { abandonPartial: true },
     });
-    expect(startEditingMessage).toHaveBeenCalledWith("user-1", "/compact -t 100\nDo the thing");
+    expect(calls).toEqual(["edit", "interrupt"]);
   });
 });

src/browser/utils/compaction/handler.ts

@@ -77,16 +77,16 @@ export async function cancelCompaction(
     return false;
   }
 
+  // Enter edit mode first so any subsequent restore-to-input event from the interrupt can't
+  // clobber the edit buffer.
+  startEditingMessage(compactionRequestMsg.id, command);
+
   // Interrupt stream with abandonPartial flag
   // Backend detects this and skips compaction (Ctrl+C flow)
   await client.workspace.interruptStream({
     workspaceId,
-    options: { abandonPartial: true, restoreQueuedToInput: false },
+    options: { abandonPartial: true },
   });
 
-  // Enter edit mode on the compaction-request message with original command
-  // This lets user immediately edit the message or delete it
-  startEditingMessage(compactionRequestMsg.id, command);
-
   return true;
 }

src/browser/utils/messages/compactionOptions.test.ts

@@ -74,7 +74,7 @@ describe("applyCompactionOverrides", () => {
     const result = applyCompactionOverrides(baseWithTools, compactData);
 
     expect(result.mode).toBe("compact");
-    expect(result.toolPolicy).toEqual([{ regex_match: ".*", action: "disable" }]);
+    expect(result.toolPolicy).toEqual([{ regex_match: ".*", action: "disable" }]); // Tools always disabled for compaction
   });
 
   it("applies all overrides together", () => {

src/common/orpc/schemas/api.ts

@@ -306,7 +306,6 @@ export const workspace = {
           soft: z.boolean().optional(),
           abandonPartial: z.boolean().optional(),
           sendQueuedImmediately: z.boolean().optional(),
-          restoreQueuedToInput: z.boolean().optional(),
         })
         .optional(),
     }),

src/common/types/message.ts

@@ -85,7 +85,7 @@ export type MuxFrontendMetadata = MuxFrontendMetadataBase &
   (
     | {
         type: "compaction-request";
-        rawCommand: string; // The /compact command line for display (excludes multiline continue payload)
+        rawCommand: string; // The original /compact command as typed by user (for display)
         parsed: CompactionRequestData;
         /** Source of compaction request: user-initiated (undefined) or idle-compaction (auto) */
         source?: "idle-compaction";

src/node/services/serverService.test.ts

@@ -77,18 +77,22 @@ describe("ServerService.startServer", () => {
   }
 
   test("cleans up server when lockfile acquisition fails", async () => {
+    // Skip on Windows where chmod doesn't work the same way
+    if (process.platform === "win32") {
+      return;
+    }
+
     const service = new ServerService();
 
-    // Make muxHome a file (not a directory) so lockfile.acquire fails deterministically.
-    const muxHomeFile = path.join(tempDir, "not-a-dir");
-    await fs.writeFile(muxHomeFile, "not a directory");
+    // Make muxHome read-only so lockfile.acquire() will fail
+    await fs.chmod(tempDir, 0o444);
 
     let thrownError: Error | null = null;
 
     try {
       // Start server - this should fail when trying to write lockfile
       await service.startServer({
-        muxHome: muxHomeFile,
+        muxHome: tempDir,
         context: stubContext as ORPCContext,
         authToken: "test-token",
         port: 0, // random port
@@ -99,7 +103,7 @@ describe("ServerService.startServer", () => {
 
     // Verify that an error was thrown
     expect(thrownError).not.toBeNull();
-    expect(thrownError!.message).toMatch(/ENOTDIR|not a directory/i);
+    expect(thrownError!.message).toMatch(/EACCES|permission denied/i);
 
     // Verify the server is NOT left running
     expect(service.isServerRunning()).toBe(false);

src/node/services/workspaceService.ts

@@ -1449,12 +1449,7 @@ export class WorkspaceService extends EventEmitter {
 
   async interruptStream(
     workspaceId: string,
-    options?: {
-      soft?: boolean;
-      abandonPartial?: boolean;
-      sendQueuedImmediately?: boolean;
-      restoreQueuedToInput?: boolean;
-    }
+    options?: { soft?: boolean; abandonPartial?: boolean; sendQueuedImmediately?: boolean }
   ): Promise<Result<void>> {
     try {
       const session = this.getOrCreateSession(workspaceId);
@@ -1475,9 +1470,6 @@ export class WorkspaceService extends EventEmitter {
       if (options?.sendQueuedImmediately) {
         // Send queued messages immediately instead of restoring to input
         session.sendQueuedMessages();
-      } else if (options?.restoreQueuedToInput === false) {
-        // Explicitly drop queued messages (used by cancel-compaction so we don't clobber edit mode)
-        session.clearQueue();
       } else {
         // Restore queued messages to input box for user-initiated interrupts
         session.restoreQueueToInput();