🤖 Fix /compact multiline parsing bug (#268)

## Problem

Multiline content after the `/compact` command was being incorrectly
parsed as flags, causing rejection or unexpected behavior.

**Example of bug:**
```
/compact
-t should be treated as message content
```

This would error with: `-t requires a positive number, got should`
instead of treating the entire line as the continue message.

## Root Cause

The parser was tokenizing the entire input (including content after
newlines) and passing all tokens to minimist for flag parsing. This
meant any text after a newline that looked like a flag (e.g., `-t`,
`-c`, `--anything`) would be interpreted as a flag instead of message
content.

## Solution

Changed the `/compact` handler to:
1. Split `rawInput` at the first newline
2. Tokenize **only** the first line for flag parsing
3. Use remaining lines (after first newline) as multiline continue
message

This ensures content after newlines is never interpreted as flags.

## Testing

**New test cases added:**
- Multiline content starting with flag-like text (`-t`, `-c`)
- Combination of flags on first line + flag-like text in multiline
content

**All existing tests pass** (25/25 slash command tests, 537 total tests)

_Generated with `cmux`_

Author: ammar-agent

src/utils/slashCommands/compact.test.ts

@@ -214,4 +214,23 @@ describe("multiline continue messages", () => {
       continueMessage: undefined,
     });
   });
+
+  it("does not parse lines after newline as flags", () => {
+    // Bug: multiline content starting with -t or -c should not be parsed as flags
+    const result = parseCommand("/compact\n-t should be treated as message content");
+    expect(result).toEqual({
+      type: "compact",
+      maxOutputTokens: undefined,
+      continueMessage: "-t should be treated as message content",
+    });
+  });
+
+  it("does not parse lines after newline as flags with existing flag", () => {
+    const result = parseCommand("/compact -t 5000\n-c this is not a flag");
+    expect(result).toEqual({
+      type: "compact",
+      maxOutputTokens: 5000,
+      continueMessage: "-c this is not a flag",
+    });
+  });
 });

src/utils/slashCommands/registry.ts

@@ -173,16 +173,22 @@ const compactCommandDefinition: SlashCommandDefinition = {
   key: "compact",
   description:
     "Compact conversation history using AI summarization. Use -t <tokens> to set max output tokens. Add continue message on lines after the command.",
-  handler: ({ cleanRemainingTokens, rawInput }): ParsedCommand => {
+  handler: ({ rawInput }): ParsedCommand => {
     // Split rawInput into first line (for flags) and remaining lines (for multiline continue)
     // rawInput format: "-t 5000\nContinue here" or "\nContinue here" (starts with newline if no flags)
     const hasMultilineContent = rawInput.includes("\n");
     const lines = rawInput.split("\n");
-    // Note: firstLine could be empty string if rawInput starts with \n (which is fine)
+    const firstLine = lines[0]; // First line contains flags
     const remainingLines = lines.slice(1).join("\n").trim();
 
+    // Tokenize ONLY the first line to extract flags
+    // This prevents content after newlines from being parsed as flags
+    const firstLineTokens = (firstLine.match(/(?:[^\s"]+|"[^"]*")+/g) ?? []).map((token) =>
+      token.replace(/^"(.*)"$/, "$1")
+    );
+
     // Parse flags from first line using minimist
-    const parsed = minimist(cleanRemainingTokens, {
+    const parsed = minimist(firstLineTokens, {
       string: ["t", "c"],
       unknown: (arg: string) => {
         // Unknown flags starting with - are errors
@@ -193,8 +199,8 @@ const compactCommandDefinition: SlashCommandDefinition = {
       },
     });
 
-    // Check for unknown flags
-    const unknownFlags = cleanRemainingTokens.filter(
+    // Check for unknown flags (only from first line)
+    const unknownFlags = firstLineTokens.filter(
       (token) => token.startsWith("-") && token !== "-t" && token !== "-c"
     );
     if (unknownFlags.length > 0) {