🤖 fix: prevent compaction infinite loop and stale usage display

Two related bugs were causing compaction to loop forever:

1. **Message queue overwrote compaction metadata**: When a user typed
   a follow-up message while a compaction was queued, the queue would
   overwrite latestOptions, losing the muxMetadata that marks the
   message as a compaction-request. The compaction would then be sent
   as a normal message, never triggering actual history replacement.

   Fix: Follow-up messages added after a compaction request are now
   merged into the compaction's continueMessage field rather than
   overwriting options. This preserves compaction metadata and sends
   follow-ups after compaction completes.

2. **Usage display showed pre-compaction context**: After compaction,
   the summary message's usage field contained the pre-compaction
   context size (since that's what was sent to generate the summary).
   This inflated the context window display, making it appear usage
   was still high and triggering auto-compaction again.

   Fix: Skip compacted messages when computing lastContextUsage.
   The summary's usage reflects historical cost, not current context.

_Generated with `mux`_

Author: ammar-agent

src/browser/stores/WorkspaceStore.ts

@@ -476,10 +476,16 @@ export class WorkspaceStore {
 
       // Get last message's context usage for context window display
       // Uses contextUsage (last step) if available, falls back to usage for old messages
+      // Skips compacted messages - their usage reflects pre-compaction context, not current
       const lastContextUsage = (() => {
         for (let i = messages.length - 1; i >= 0; i--) {
           const msg = messages[i];
           if (msg.role === "assistant") {
+            // Skip compacted messages - their usage is from pre-compaction context
+            // and doesn't reflect current context window size
+            if (msg.metadata?.compacted) {
+              continue;
+            }
             const rawUsage = msg.metadata?.contextUsage ?? msg.metadata?.usage;
             const providerMeta =
               msg.metadata?.contextProviderMetadata ?? msg.metadata?.providerMetadata;

src/node/services/messageQueue.test.ts

@@ -35,7 +35,7 @@ describe("MessageQueue", () => {
       expect(queue.getDisplayText()).toBe("/compact -t 3000");
     });
 
-    it("should show actual messages when compaction is added after normal message", () => {
+    it("should throw when adding compaction after normal message", () => {
       queue.add("First message");
 
       const metadata: MuxFrontendMetadata = {
@@ -49,11 +49,11 @@ describe("MessageQueue", () => {
         muxMetadata: metadata,
       };
 
-      queue.add("Summarize this conversation...", options);
-
-      // When multiple messages are queued, compaction metadata is lost when sent,
-      // so display shows actual messages (not rawCommand) to match what will be sent
-      expect(queue.getDisplayText()).toBe("First message\nSummarize this conversation...");
+      // Compaction requests cannot be mixed with other messages to prevent
+      // silent failures where compaction metadata would be lost
+      expect(() => queue.add("Summarize this conversation...", options)).toThrow(
+        /Cannot queue compaction request/
+      );
     });
 
     it("should return joined messages when metadata type is not compaction-request", () => {
@@ -117,6 +117,48 @@ describe("MessageQueue", () => {
     });
   });
 
+  describe("hasCompactionRequest", () => {
+    it("should return false for empty queue", () => {
+      expect(queue.hasCompactionRequest()).toBe(false);
+    });
+
+    it("should return false for normal messages", () => {
+      queue.add("Regular message", { model: "gpt-4" });
+      expect(queue.hasCompactionRequest()).toBe(false);
+    });
+
+    it("should return true when compaction request is queued", () => {
+      const metadata: MuxFrontendMetadata = {
+        type: "compaction-request",
+        rawCommand: "/compact",
+        parsed: {},
+      };
+
+      queue.add("Summarize...", {
+        model: "claude-3-5-sonnet-20241022",
+        muxMetadata: metadata,
+      });
+
+      expect(queue.hasCompactionRequest()).toBe(true);
+    });
+
+    it("should return false after clearing", () => {
+      const metadata: MuxFrontendMetadata = {
+        type: "compaction-request",
+        rawCommand: "/compact",
+        parsed: {},
+      };
+
+      queue.add("Summarize...", {
+        model: "claude-3-5-sonnet-20241022",
+        muxMetadata: metadata,
+      });
+      queue.clear();
+
+      expect(queue.hasCompactionRequest()).toBe(false);
+    });
+  });
+
   describe("multi-message batching", () => {
     it("should batch multiple follow-up messages", () => {
       queue.add("First message");
@@ -127,7 +169,7 @@ describe("MessageQueue", () => {
       expect(queue.getDisplayText()).toBe("First message\nSecond message\nThird message");
     });
 
-    it("should batch follow-up message after compaction", () => {
+    it("should append follow-up to compaction's continueMessage", () => {
       const metadata: MuxFrontendMetadata = {
         type: "compaction-request",
         rawCommand: "/compact",
@@ -140,11 +182,44 @@ describe("MessageQueue", () => {
       });
       queue.add("And then do this follow-up task");
 
-      // When a follow-up is added, compaction metadata is lost (latestOptions overwritten),
-      // so display shows actual messages to match what will be sent
-      expect(queue.getDisplayText()).toBe("Summarize...\nAnd then do this follow-up task");
-      // Raw messages have the actual prompt
+      // Display shows compaction command plus follow-up
+      expect(queue.getDisplayText()).toBe("/compact\nAnd then do this follow-up task");
+
+      // getMessages includes both the compaction prompt and follow-up
       expect(queue.getMessages()).toEqual(["Summarize...", "And then do this follow-up task"]);
+
+      // produceMessage merges follow-up into continueMessage
+      const { message, options } = queue.produceMessage();
+      expect(message).toBe("Summarize..."); // Just the compaction prompt
+      const muxMeta = options?.muxMetadata as MuxFrontendMetadata;
+      expect(muxMeta.type).toBe("compaction-request");
+      if (muxMeta.type === "compaction-request") {
+        expect(muxMeta.parsed.continueMessage?.text).toBe("And then do this follow-up task");
+      }
+    });
+
+    it("should merge follow-up with existing continueMessage", () => {
+      const metadata: MuxFrontendMetadata = {
+        type: "compaction-request",
+        rawCommand: "/compact",
+        parsed: {
+          continueMessage: { text: "Original continue" },
+        },
+      };
+
+      queue.add("Summarize...", {
+        model: "claude-3-5-sonnet-20241022",
+        muxMetadata: metadata,
+      });
+      queue.add("Additional follow-up");
+
+      const { options } = queue.produceMessage();
+      const muxMeta = options?.muxMetadata as MuxFrontendMetadata;
+      if (muxMeta.type === "compaction-request") {
+        expect(muxMeta.parsed.continueMessage?.text).toBe(
+          "Original continue\nAdditional follow-up"
+        );
+      }
     });
 
     it("should produce combined message for API call", () => {

src/node/services/messageQueue.ts

@@ -1,9 +1,11 @@
 import type { ImagePart, SendMessageOptions } from "@/common/orpc/types";
+import type { CompactionRequestData, ContinueMessage } from "@/common/types/message";
 
-// Type guard for compaction request metadata (for display text)
+// Full compaction metadata structure for manipulation
 interface CompactionMetadata {
   type: "compaction-request";
   rawCommand: string;
+  parsed: CompactionRequestData;
 }
 
 function isCompactionMetadata(meta: unknown): meta is CompactionMetadata {
@@ -20,19 +22,42 @@ function isCompactionMetadata(meta: unknown): meta is CompactionMetadata {
  * - Latest options (model, thinking level, etc. - overwrites on each add)
  * - Image parts (accumulated across all messages)
  *
+ * Special handling for compaction requests:
+ * - Adding a compaction request to a non-empty queue throws an error
+ *   (must wait for current messages to send before compacting)
+ * - Adding a message AFTER a compaction request appends it to the
+ *   compaction's continueMessage (so it's sent after compaction completes)
+ *
  * Display logic:
- * - Single compaction request → shows rawCommand (/compact)
- * - Multiple messages → shows all actual message texts (since compaction metadata is lost anyway)
+ * - Compaction request alone → shows rawCommand (/compact)
+ * - Compaction with follow-ups → shows rawCommand + follow-up texts
+ * - Regular messages → shows all message texts
  */
 export class MessageQueue {
   private messages: string[] = [];
   private latestOptions?: SendMessageOptions;
   private accumulatedImages: ImagePart[] = [];
+  // Track follow-up messages added after a compaction request
+  // These get appended to the compaction's continueMessage
+  private compactionFollowUps: string[] = [];
+  private compactionFollowUpImages: ImagePart[] = [];
+
+  /**
+   * Check if the queue currently contains a compaction request.
+   */
+  hasCompactionRequest(): boolean {
+    return isCompactionMetadata(this.latestOptions?.muxMetadata);
+  }
 
   /**
    * Add a message to the queue.
    * Updates to latest options, accumulates image parts.
    * Allows image-only messages (empty text with images).
+   *
+   * Special case: Adding a message after a compaction request appends it
+   * to the compaction's continueMessage rather than overwriting options.
+   *
+   * @throws Error if trying to add a compaction request when queue already has messages
    */
   add(message: string, options?: SendMessageOptions & { imageParts?: ImagePart[] }): void {
     const trimmedMessage = message.trim();
@@ -43,7 +68,32 @@ export class MessageQueue {
       return;
     }
 
-    // Add text message if non-empty
+    const incomingIsCompaction = isCompactionMetadata(options?.muxMetadata);
+    const queueHasCompaction = this.hasCompactionRequest();
+    const queueHasMessages = !this.isEmpty();
+
+    // Cannot add compaction to a queue that already has messages
+    // (user should wait for those messages to send first)
+    if (incomingIsCompaction && queueHasMessages) {
+      throw new Error(
+        "Cannot queue compaction request: queue already has messages. " +
+          "Wait for current stream to complete before compacting."
+      );
+    }
+
+    // Special case: adding follow-up message after a pending compaction
+    // Append to the compaction's continueMessage instead of overwriting options
+    if (!incomingIsCompaction && queueHasCompaction) {
+      if (trimmedMessage.length > 0) {
+        this.compactionFollowUps.push(trimmedMessage);
+      }
+      if (hasImages && options?.imageParts) {
+        this.compactionFollowUpImages.push(...options.imageParts);
+      }
+      return;
+    }
+
+    // Normal case: add message to queue
     if (trimmedMessage.length > 0) {
       this.messages.push(trimmedMessage);
     }
@@ -60,21 +110,29 @@ export class MessageQueue {
 
   /**
    * Get all queued message texts (for editing/restoration).
+   * Includes follow-up messages if compaction is pending.
    */
   getMessages(): string[] {
+    if (this.compactionFollowUps.length > 0) {
+      return [...this.messages, ...this.compactionFollowUps];
+    }
     return [...this.messages];
   }
 
   /**
    * Get display text for queued messages.
-   * - Single compaction request shows rawCommand (/compact)
-   * - Multiple messages or non-compaction show actual message texts
+   * - Compaction alone → shows rawCommand (/compact)
+   * - Compaction with follow-ups → shows rawCommand + newline + follow-ups
+   * - Regular messages → shows all message texts
    */
   getDisplayText(): string {
-    // Only show rawCommand for single compaction request
-    // (compaction metadata is only preserved when no follow-up messages are added)
     const muxMetadata = this.latestOptions?.muxMetadata as unknown;
-    if (this.messages.length === 1 && isCompactionMetadata(muxMetadata)) {
+
+    if (isCompactionMetadata(muxMetadata)) {
+      // Show compaction command plus any follow-ups
+      if (this.compactionFollowUps.length > 0) {
+        return muxMetadata.rawCommand + "\n" + this.compactionFollowUps.join("\n");
+      }
       return muxMetadata.rawCommand;
     }
 
@@ -83,19 +141,71 @@ export class MessageQueue {
 
   /**
    * Get accumulated image parts for display.
+   * Includes follow-up images if compaction is pending.
    */
   getImageParts(): ImagePart[] {
+    if (this.compactionFollowUpImages.length > 0) {
+      return [...this.accumulatedImages, ...this.compactionFollowUpImages];
+    }
     return [...this.accumulatedImages];
   }
 
   /**
    * Get combined message and options for sending.
-   * Returns joined messages with latest options + accumulated images.
+   *
+   * For compaction requests with follow-ups:
+   * - Returns the compaction message unchanged
+   * - Merges follow-ups into the continueMessage field of the metadata
+   *
+   * For regular messages:
+   * - Returns joined messages with latest options + accumulated images
    */
   produceMessage(): {
     message: string;
     options?: SendMessageOptions & { imageParts?: ImagePart[] };
   } {
+    // Cast from z.any() schema type to unknown for safe type narrowing
+    const muxMetadata = this.latestOptions?.muxMetadata as unknown;
+
+    // Special handling for compaction with follow-ups
+    if (isCompactionMetadata(muxMetadata) && this.hasFollowUps()) {
+      const existingContinue = muxMetadata.parsed.continueMessage;
+      const existingText = existingContinue?.text ?? "";
+      const existingImages = existingContinue?.imageParts ?? [];
+
+      // Merge follow-ups with existing continueMessage
+      const mergedText = existingText
+        ? existingText + "\n" + this.compactionFollowUps.join("\n")
+        : this.compactionFollowUps.join("\n");
+      const mergedImages = [...existingImages, ...this.compactionFollowUpImages];
+
+      const newContinueMessage: ContinueMessage = {
+        text: mergedText,
+        imageParts: mergedImages.length > 0 ? mergedImages : undefined,
+        model: existingContinue?.model,
+      };
+
+      // Create updated metadata with merged continueMessage
+      const updatedMetadata: CompactionMetadata = {
+        type: "compaction-request",
+        rawCommand: muxMetadata.rawCommand,
+        parsed: {
+          ...muxMetadata.parsed,
+          continueMessage: newContinueMessage,
+        },
+      };
+
+      return {
+        message: this.messages.join("\n"),
+        options: {
+          ...this.latestOptions!,
+          muxMetadata: updatedMetadata,
+          imageParts: this.accumulatedImages.length > 0 ? this.accumulatedImages : undefined,
+        },
+      };
+    }
+
+    // Normal case
     const joinedMessages = this.messages.join("\n");
 
     const options = this.latestOptions
@@ -108,13 +218,22 @@ export class MessageQueue {
     return { message: joinedMessages, options };
   }
 
+  /**
+   * Check if there are follow-up messages pending after a compaction.
+   */
+  private hasFollowUps(): boolean {
+    return this.compactionFollowUps.length > 0 || this.compactionFollowUpImages.length > 0;
+  }
+
   /**
    * Clear all queued messages, options, and images.
    */
   clear(): void {
     this.messages = [];
     this.latestOptions = undefined;
     this.accumulatedImages = [];
+    this.compactionFollowUps = [];
+    this.compactionFollowUpImages = [];
   }
 
   /**