refactor: Unify init hooks with chat stream

Simplifies init hook architecture by reusing existing chat stream
infrastructure instead of creating parallel IPC system.

Changes:
- Add WorkspaceInitEvent union to WorkspaceChatMessage (3 event types)
- Backend emits init events via AgentSession.emitChatEvent()
- Frontend handles init events from chat subscription
- Tests filter init events from chat channel
- Remove metaEventBuffer, onMeta(), and WORKSPACE_STREAM_META

Benefits:
- ~80 net LoC reduction (removed ~150, added ~70)
- 1 subscription per workspace instead of 2
- Automatic replay via existing history mechanism
- Cleaner types (no redundant workspaceId field)
- Single buffer for all workspace events

Init events are ephemeral (not persisted) and flow through the same
stream as caught-up, stream-error, and delete messages.

Author: ammar-agent

bun.lock

@@ -13,7 +13,6 @@
         "crc-32": "^1.2.2",
         "diff": "^8.0.2",
         "disposablestack": "^1.1.7",
-        "electron": "^38.2.1",
         "electron-updater": "^6.6.2",
         "express": "^5.1.0",
         "jsonc-parser": "^3.3.1",
@@ -61,6 +60,7 @@
         "cmdk": "^1.0.0",
         "concurrently": "^8.2.0",
         "dotenv": "^17.2.3",
+        "electron": "^38.2.1",
         "electron-builder": "^24.6.0",
         "electron-devtools-installer": "^4.0.0",
         "electron-mock-ipc": "^0.3.12",

src/browser/api.ts

@@ -249,11 +249,6 @@ const webApi: IPCApi = {
     onMetadata: (callback) => {
       return wsManager.on(IPC_CHANNELS.WORKSPACE_METADATA, callback as (data: unknown) => void);
     },
-
-    onMeta: (workspaceId, callback) => {
-      return wsManager.on(IPC_CHANNELS.WORKSPACE_STREAM_META, callback as (data: unknown) => void, workspaceId);
-    },
-
   },
   window: {
     setTitle: (title) => {

src/components/AIView.tsx

@@ -29,7 +29,8 @@ import { useGitStatus } from "@/stores/GitStatusStore";
 import { TooltipWrapper, Tooltip } from "./Tooltip";
 import type { DisplayedMessage } from "@/types/message";
 import { useAIViewKeybinds } from "@/hooks/useAIViewKeybinds";
-import type { WorkspaceMetaEvent } from "@/types/workspace";
+import type { WorkspaceChatMessage } from "@/types/ipc";
+import { isInitStart, isInitOutput, isInitEnd } from "@/types/ipc";
 
 const ViewContainer = styled.div`
   flex: 1;
@@ -275,46 +276,32 @@ const AIViewInner: React.FC<AIViewProps> = ({
   const [initExitCode, setInitExitCode] = useState<number | null>(null);
   const [showInit, setShowInit] = useState<boolean>(false);
 
+  // Subscribe to init hook events from chat stream
   useEffect(() => {
-    setInitLines([]);
-    setInitExitCode(null);
-    setShowInit(false);
-    const unsubscribe = window.api.workspace.onMeta(workspaceId, (data: WorkspaceMetaEvent) => {
-      if (data.workspaceId !== workspaceId) return;
-      switch (data.type) {
-        case "workspace-init-start":
+    const handleMessage = (msg: WorkspaceChatMessage) => {
+      if (isInitStart(msg)) {
+        setShowInit(true);
+        setInitLines([]);
+        setInitExitCode(null);
+      } else if (isInitOutput(msg)) {
+        setShowInit(true);
+        const line = msg.isError ? `ERROR: ${msg.line}` : msg.line;
+        setInitLines((prev) => [...prev, line.trimEnd()]);
+      } else if (isInitEnd(msg)) {
+        const code = msg.exitCode;
+        setInitExitCode(code);
+        if (code === 0) {
+          setTimeout(() => setShowInit(false), 800);
+        } else {
           setShowInit(true);
-          break;
-        case "workspace-init-output":
-          setShowInit(true);
-          setInitLines((prev) => [...prev, data.line.trimEnd()]);
-          break;
-        case "workspace-init-error":
-          setShowInit(true);
-          // Prefer line when present, else error
-          {
-            const line = data.line ?? (data.error ? `ERROR: ${data.error}` : null);
-            if (line) {
-              setInitLines((prev) => [...prev, line]);
-            }
-          }
-          setInitExitCode((c) => c ?? -1);
-          break;
-        case "workspace-init-end":
-          {
-            const code = data.exitCode;
-            setInitExitCode(code);
-            if (code === 0) {
-              setTimeout(() => setShowInit(false), 800);
-            } else {
-              setShowInit(true);
-            }
-          }
-          break;
+        }
       }
-    });
-    return () => unsubscribe?.();
+    };
+
+    const unsubscribe = window.api.workspace.onChat(workspaceId, handleMessage);
+    return unsubscribe;
   }, [workspaceId]);
+
   const [editingMessage, setEditingMessage] = useState<{ id: string; content: string } | undefined>(
     undefined
   );

src/constants/ipc-constants.ts

@@ -34,9 +34,6 @@ export const IPC_CHANNELS = {
   WORKSPACE_GET_INFO: "workspace:getInfo",
   WORKSPACE_EXECUTE_BASH: "workspace:executeBash",
   WORKSPACE_OPEN_TERMINAL: "workspace:openTerminal",
-  // Meta stream for non-chat workspace events (e.g., init hook output)
-  // Renderer should subscribe and display for the active workspace context
-  WORKSPACE_STREAM_META: "workspace:streamMeta",
 
   // Window channels
   WINDOW_SET_TITLE: "window:setTitle",

src/preload.ts

@@ -20,7 +20,7 @@
 
 import { contextBridge, ipcRenderer } from "electron";
 import type { IPCApi, WorkspaceChatMessage, UpdateStatus } from "./types/ipc";
-import type { FrontendWorkspaceMetadata, WorkspaceMetaEvent } from "./types/workspace";
+import type { FrontendWorkspaceMetadata } from "./types/workspace";
 import type { ProjectConfig } from "./types/project";
 import { IPC_CHANNELS, getChatChannel } from "./constants/ipc-constants";
 
@@ -110,18 +110,6 @@ const api: IPCApi = {
         ipcRenderer.send(`workspace:metadata:unsubscribe`);
       };
     },
-    onMeta: (workspaceId: string, callback: (data: WorkspaceMetaEvent) => void) => {
-      const handler = (_event: unknown, data: WorkspaceMetaEvent) => {
-        // Forward to consumer - consumer is responsible for filtering by workspaceId
-        callback(data);
-      };
-      ipcRenderer.on(IPC_CHANNELS.WORKSPACE_STREAM_META, handler);
-      ipcRenderer.send(`workspace:meta:subscribe`, workspaceId);
-      return () => {
-        ipcRenderer.removeListener(IPC_CHANNELS.WORKSPACE_STREAM_META, handler);
-        ipcRenderer.send(`workspace:meta:unsubscribe`, workspaceId);
-      };
-    },
   },
   window: {
     setTitle: (title: string) => ipcRenderer.invoke(IPC_CHANNELS.WINDOW_SET_TITLE, title),

src/services/agentSession.ts

@@ -391,7 +391,8 @@ export class AgentSession {
     this.aiService.on("error", errorHandler as never);
   }
 
-  private emitChatEvent(message: WorkspaceChatMessage): void {
+  // Public method to emit chat events (used by init hooks and other workspace events)
+  emitChatEvent(message: WorkspaceChatMessage): void {
     this.assertNotDisposed("emitChatEvent");
     this.emitter.emit("chat-event", {
       workspaceId: this.workspaceId,

src/services/ipcMain.ts

@@ -28,7 +28,6 @@ import { createBashTool } from "@/services/tools/bash";
 import type { BashToolResult } from "@/types/tools";
 import { secretsToRecord } from "@/types/secrets";
 import { DisposableTempDir } from "@/services/tempDir";
-import type { WorkspaceMetaEvent } from "@/types/workspace";
 
 /**
  * IpcMain - Manages all IPC handlers and service coordination
@@ -54,28 +53,14 @@ export class IpcMain {
     { chat: () => void; metadata: () => void }
   >();
   private mainWindow: BrowserWindow | null = null;
-  // Buffer of streaming meta events keyed by workspaceId. Used to replay to late subscribers.
-  private readonly metaEventBuffer: Map<string, WorkspaceMetaEvent[]> = new Map<
-    string,
-    WorkspaceMetaEvent[]
-  >();
-
-  // Helper to emit a workspace meta event to the renderer and buffer it for replay
-  private emitWorkspaceMeta(event: WorkspaceMetaEvent): void {
-    if (!event?.workspaceId) return;
-    const arr = this.metaEventBuffer.get(event.workspaceId) ?? [];
-    arr.push(event);
-    this.metaEventBuffer.set(event.workspaceId, arr);
-    this.mainWindow?.webContents.send(IPC_CHANNELS.WORKSPACE_STREAM_META, event);
-  }
 
   // Run optional .cmux/init hook for a newly created workspace and stream its output
   private async runWorkspaceInitHook(params: {
     projectPath: string;
     worktreePath: string;
     workspaceId: string;
   }): Promise<void> {
-    // Non-blocking fire-and-forget; errors are reported via meta stream
+    // Non-blocking fire-and-forget; errors are reported via chat stream
     try {
       const hookPath = path.join(params.projectPath, ".cmux", "init");
       // Check if hook exists
@@ -87,12 +72,13 @@ export class IpcMain {
         return; // Nothing to do
       }
 
-      // Emit start event
-      this.emitWorkspaceMeta({
-        type: "workspace-init-start",
-        workspaceId: params.workspaceId,
-        timestamp: Date.now(),
+      const session = this.getOrCreateSession(params.workspaceId);
+
+      // Emit start event via chat stream
+      session.emitChatEvent({
+        type: "init-start",
         hookPath,
+        timestamp: Date.now(),
       });
 
       // Spawn bash to run the hook in the new worktree directory
@@ -119,11 +105,11 @@ export class IpcMain {
         const partial = lines.pop() ?? "";
         for (const line of lines) {
           if (line.length === 0) continue;
-          this.emitWorkspaceMeta({
-            type: isErr ? "workspace-init-error" : "workspace-init-output",
-            workspaceId: params.workspaceId,
-            timestamp: Date.now(),
+          session.emitChatEvent({
+            type: "init-output",
             line,
+            isError: isErr,
+            timestamp: Date.now(),
           });
         }
         return partial;
@@ -142,56 +128,55 @@ export class IpcMain {
       child.on("close", (code: number | null) => {
         // Flush any remaining partials as lines
         if (outBuf.trim().length > 0) {
-          this.emitWorkspaceMeta({
-            type: "workspace-init-output",
-            workspaceId: params.workspaceId,
-            timestamp: Date.now(),
+          session.emitChatEvent({
+            type: "init-output",
             line: outBuf,
+            isError: false,
+            timestamp: Date.now(),
           });
         }
         if (errBuf.trim().length > 0) {
-          this.emitWorkspaceMeta({
-            type: "workspace-init-error",
-            workspaceId: params.workspaceId,
-            timestamp: Date.now(),
+          session.emitChatEvent({
+            type: "init-output",
             line: errBuf,
+            isError: true,
+            timestamp: Date.now(),
           });
         }
 
-        this.emitWorkspaceMeta({
-          type: "workspace-init-end",
-          workspaceId: params.workspaceId,
-          timestamp: Date.now(),
+        session.emitChatEvent({
+          type: "init-end",
           exitCode: typeof code === "number" ? code : -1,
+          timestamp: Date.now(),
         });
       });
 
       child.on("error", (error: unknown) => {
-        this.emitWorkspaceMeta({
-          type: "workspace-init-error",
-          workspaceId: params.workspaceId,
+        session.emitChatEvent({
+          type: "init-output",
+          line: error instanceof Error ? error.message : String(error),
+          isError: true,
           timestamp: Date.now(),
-          error: error instanceof Error ? error.message : String(error),
         });
-        this.emitWorkspaceMeta({
-          type: "workspace-init-end",
-          workspaceId: params.workspaceId,
-          timestamp: Date.now(),
+        // Also emit end with error code
+        session.emitChatEvent({
+          type: "init-end",
           exitCode: -1,
+          timestamp: Date.now(),
         });
       });
     } catch (error) {
-      this.emitWorkspaceMeta({
-        type: "workspace-init-error",
-        workspaceId: params.workspaceId,
+      const session = this.getOrCreateSession(params.workspaceId);
+      session.emitChatEvent({
+        type: "init-output",
+        line: error instanceof Error ? error.message : String(error),
+        isError: true,
         timestamp: Date.now(),
-        error: error instanceof Error ? error.message : String(error),
       });
-      this.emitWorkspaceMeta({
-        type: "workspace-init-end",
-        workspaceId: params.workspaceId,
-        timestamp: Date.now(),
+      session.emitChatEvent({
+        type: "init-end",
         exitCode: -1,
+        timestamp: Date.now(),
       });
     }
   }
@@ -1332,18 +1317,7 @@ export class IpcMain {
       })();
     });
 
-    // Handle subscription events for workspace meta stream (init hook output)
-    ipcMain.on(`workspace:meta:subscribe`, (_event, workspaceId: string) => {
-      if (!workspaceId || typeof workspaceId !== "string") return;
-      const buffered = this.metaEventBuffer.get(workspaceId) ?? [];
-      for (const ev of buffered) {
-        this.mainWindow?.webContents.send(IPC_CHANNELS.WORKSPACE_STREAM_META, ev);
-      }
-    });
 
-    ipcMain.on(`workspace:meta:unsubscribe`, (_event, _workspaceId: string) => {
-      // No-op: we keep buffer for the session; it will be disposed with the session
-    });
 
     // Handle subscription events for metadata
     ipcMain.on(IPC_CHANNELS.WORKSPACE_METADATA_SUBSCRIBE, () => {