🤖 Add defensive checks for init-output and message processing (#413)

## Problem

After #228 merged, encountered two issues:

1. **Init-output crash**: `StreamingMessageAggregator.ts:516` throws
`Cannot read properties of undefined (reading 'trimEnd')` when
processing init-output events with missing `line` field
2. **Inconsistent message appearance**: User messages sometimes don't
appear immediately in chat view

## Solution

### 1. Init-output defensive check
Added null check for `data.line` before calling `trimEnd()`:
```typescript
if (!data.line) return; // Defensive: skip events with missing line data
```

Follows the defensive pattern from #228 - gracefully handle edge cases
during replay.

### 2. Message processing condition tightened  
Added `'role' in data` check to the caught-up branch:
```typescript
} else if (isCaughtUp && "role" in data) {
```

Makes the condition symmetric with the buffering branch and ensures only
valid CmuxMessages are processed.

## Testing

- ✅ `make typecheck` passes
- ✅ All 763 unit tests pass

_Generated with `cmux`_

Author: ammar-agent

src/stores/WorkspaceStore.ts

@@ -964,13 +964,24 @@ export class WorkspaceStore {
       const historicalMsgs = this.historicalMessages.get(workspaceId) ?? [];
       historicalMsgs.push(data);
       this.historicalMessages.set(workspaceId, historicalMsgs);
-    } else if (isCaughtUp) {
+    } else if (isCaughtUp && "role" in data) {
       // Process live events immediately (after history loaded)
+      // Check for role field to ensure this is a CmuxMessage
       aggregator.handleMessage(data);
       this.states.bump(workspaceId);
       this.checkAndBumpRecencyIfChanged();
+    } else if ("role" in data || "type" in data) {
+      // Unexpected: message with role/type field didn't match any condition
+      console.error("[WorkspaceStore] Message not processed - unexpected state", {
+        workspaceId,
+        isCaughtUp,
+        hasRole: "role" in data,
+        hasType: "type" in data,
+        type: "type" in data ? (data as { type: string }).type : undefined,
+        role: "role" in data ? (data as { role: string }).role : undefined,
+      });
     }
-    // Note: Init events and stream events are handled by isStreamEvent() buffering above
+    // Note: Messages without role/type are silently ignored (expected for some IPC events)
   }
 }
 

src/utils/messages/StreamingMessageAggregator.ts

@@ -511,15 +511,30 @@ export class StreamingMessageAggregator {
     }
 
     if (isInitOutput(data)) {
-      if (!this.initState) return; // Defensive: shouldn't happen but handle gracefully
+      if (!this.initState) {
+        console.error("Received init-output without init-start", { data });
+        return;
+      }
+      if (!data.line) {
+        console.error("Received init-output with missing line field", { data });
+        return;
+      }
       const line = data.isError ? `ERROR: ${data.line}` : data.line;
+      // Extra defensive check (should never hit due to check above, but prevents crash if data changes)
+      if (typeof line !== "string") {
+        console.error("Init-output line is not a string", { line, data });
+        return;
+      }
       this.initState.lines.push(line.trimEnd());
       this.invalidateCache();
       return;
     }
 
     if (isInitEnd(data)) {
-      if (!this.initState) return; // Defensive: shouldn't happen but handle gracefully
+      if (!this.initState) {
+        console.error("Received init-end without init-start", { data });
+        return;
+      }
       this.initState.exitCode = data.exitCode;
       this.initState.status = data.exitCode === 0 ? "success" : "error";
       this.invalidateCache();