Fix waitForInit to never throw and deduplicate test code

- waitForInit() now never throws - tools proceed regardless of init outcome
- If init fails or times out, tools will fail naturally with their own errors
- Simplified toolHelpers wrapper (no longer needs error handling)
- Updated all 4 tools to use simplified helper
- Added test helpers: collectInitEvents() and waitForInitEnd()
- Refactored all 6 tests in initWorkspace.test.ts to use helpers
- Reduced test duplication by ~100 lines
- Updated InitStateManager test to reflect new non-throwing behavior

Author: ammar-agent

src/services/initStateManager.test.ts

@@ -236,15 +236,15 @@ describe("InitStateManager", () => {
       // Get the init promise before clearing
       const initPromise = manager.waitForInit(workspaceId);
 
-      // Clear in-memory state (should reject pending promises)
+      // Clear in-memory state (rejects internal promise, but waitForInit catches it)
       manager.clearInMemoryState(workspaceId);
 
       // Verify state is cleared
       expect(manager.getInitState(workspaceId)).toBeUndefined();
 
-      // Verify the promise was rejected
-      // eslint-disable-next-line @typescript-eslint/await-thenable
-      await expect(initPromise).rejects.toThrow("Workspace test-workspace was deleted");
+      // waitForInit never throws - it resolves even when init is canceled
+      // This allows tools to proceed and fail naturally with their own errors
+      await expect(initPromise).resolves.toBeUndefined();
     });
   });
 

src/services/initStateManager.ts

@@ -300,16 +300,19 @@ export class InitStateManager extends EventEmitter {
    *
    * Behavior:
    * - No init state: Returns immediately (init not needed or backwards compat)
-   * - Init succeeded/failed: Returns immediately (let tool proceed/fail naturally)
-   * - Init running: Waits for completion promise (up to 5 minutes)
+   * - Init succeeded/failed: Returns immediately (tools proceed regardless of init outcome)
+   * - Init running: Waits for completion promise (up to 5 minutes, then proceeds anyway)
+   *
+   * This method NEVER throws - tools should always proceed. If init fails or times out,
+   * the tool will either succeed (if init wasn't critical) or fail with its own error
+   * (e.g., file not found). This provides better error messages than blocking on init.
    *
    * Promise-based approach eliminates race conditions:
    * - Multiple tools share the same promise (no duplicate listeners)
    * - No event cleanup needed (promise auto-resolves once)
    * - Timeout races handled by Promise.race()
    *
    * @param workspaceId Workspace ID to wait for
-   * @throws Error if init times out after 5 minutes
    */
   async waitForInit(workspaceId: string): Promise<void> {
     const state = this.getInitState(workspaceId);
@@ -320,6 +323,7 @@ export class InitStateManager extends EventEmitter {
     }
 
     // Init already completed (success or failure) - proceed immediately
+    // Tools should work regardless of init outcome
     if (state.status !== "running") {
       return;
     }
@@ -334,14 +338,24 @@ export class InitStateManager extends EventEmitter {
     }
 
     const INIT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-    const timeoutPromise = new Promise<void>((_, reject) => {
+    const timeoutPromise = new Promise<void>((resolve) => {
       setTimeout(() => {
-        reject(new Error("Workspace initialization timed out after 5 minutes"));
+        log.error(
+          `Init timeout for ${workspaceId} after 5 minutes - tools will proceed anyway. ` +
+            `Init will continue in background.`
+        );
+        resolve(); // Resolve, don't reject - tools should proceed
       }, INIT_TIMEOUT_MS);
     });
 
     // Race between completion and timeout
-    // If timeout wins, promise rejection propagates to caller
-    await Promise.race([promiseEntry.promise, timeoutPromise]);
+    // Both resolve (no rejection), so tools always proceed
+    try {
+      await Promise.race([promiseEntry.promise, timeoutPromise]);
+    } catch (error) {
+      // Init promise was rejected (e.g., workspace deleted)
+      // Log and proceed anyway - let the tool fail with its own error if needed
+      log.error(`Init wait interrupted for ${workspaceId}: ${error} - proceeding anyway`);
+    }
   }
 }

src/services/tools/bash.ts

@@ -40,15 +40,7 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
     inputSchema: TOOL_DEFINITIONS.bash.schema,
     execute: async ({ script, timeout_secs }, { abortSignal }): Promise<BashToolResult> => {
       // Wait for workspace initialization to complete (no-op if already complete or not needed)
-      const initError = await waitForWorkspaceInit(config, "execute bash");
-      if (initError) {
-        return {
-          success: false,
-          error: initError,
-          exitCode: -1,
-          wall_duration_ms: 0,
-        };
-      }
+      await waitForWorkspaceInit(config);
 
       // Validate script is not empty - likely indicates a malformed tool call
 

src/services/tools/file_edit_insert.ts

@@ -26,13 +26,7 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
       create,
     }): Promise<FileEditInsertToolResult> => {
       // Wait for workspace initialization to complete (no-op if already complete or not needed)
-      const initError = await waitForWorkspaceInit(config, "insert into file");
-      if (initError) {
-        return {
-          success: false,
-          error: `${WRITE_DENIED_PREFIX} ${initError}`,
-        };
-      }
+      await waitForWorkspaceInit(config);
 
       try {
         // Validate no redundant path prefix (must come first to catch absolute paths)

src/services/tools/file_edit_operation.ts

@@ -42,13 +42,7 @@ export async function executeFileEditOperation<TMetadata>({
   FileEditErrorResult | (FileEditDiffSuccessBase & TMetadata)
 > {
   // Wait for workspace initialization to complete (no-op if already complete or not needed)
-  const initError = await waitForWorkspaceInit(config, "edit file");
-  if (initError) {
-    return {
-      success: false,
-      error: `${WRITE_DENIED_PREFIX} ${initError}`,
-    };
-  }
+  await waitForWorkspaceInit(config);
 
   try {
     // Validate no redundant path prefix (must come first to catch absolute paths)

src/services/tools/file_read.ts

@@ -23,13 +23,7 @@ export const createFileReadTool: ToolFactory = (config: ToolConfiguration) => {
       // Note: abortSignal available but not used - file reads are fast and complete quickly
 
       // Wait for workspace initialization to complete (no-op if already complete or not needed)
-      const initError = await waitForWorkspaceInit(config, "read file");
-      if (initError) {
-        return {
-          success: false,
-          error: initError,
-        };
-      }
+      await waitForWorkspaceInit(config);
 
       try {
         // Validate no redundant path prefix (must come first to catch absolute paths)

src/services/tools/toolHelpers.ts

@@ -2,20 +2,11 @@ import type { ToolConfiguration } from "@/utils/tools/tools";
 
 /**
  * Wait for workspace initialization to complete before executing tool.
- * Wraps InitStateManager.waitForInit() with consistent error handling.
+ * Wraps InitStateManager.waitForInit() for tool consistency.
  *
- * Returns null on success, or an error message string on failure.
- * The returned error message is ready to use in tool error results.
+ * This is a no-op wrapper since waitForInit() never throws and always allows
+ * tools to proceed. Kept for consistency and future extensibility.
  */
-export async function waitForWorkspaceInit(
-  config: ToolConfiguration,
-  operationName: string
-): Promise<string | null> {
-  try {
-    await config.initStateManager.waitForInit(config.workspaceId);
-    return null;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    return `Cannot ${operationName}: ${errorMsg}`;
-  }
+export async function waitForWorkspaceInit(config: ToolConfiguration): Promise<void> {
+  await config.initStateManager.waitForInit(config.workspaceId);
 }

tests/ipcMain/helpers.ts

@@ -1,6 +1,11 @@
 import type { IpcRenderer } from "electron";
 import { IPC_CHANNELS, getChatChannel } from "../../src/constants/ipc-constants";
-import type { SendMessageOptions, WorkspaceChatMessage } from "../../src/types/ipc";
+import type {
+  SendMessageOptions,
+  WorkspaceChatMessage,
+  WorkspaceInitEvent,
+} from "../../src/types/ipc";
+import { isInitStart, isInitOutput, isInitEnd } from "../../src/types/ipc";
 import type { Result } from "../../src/types/result";
 import type { SendMessageError } from "../../src/types/errors";
 import type { WorkspaceMetadataWithPaths } from "../../src/types/workspace";
@@ -548,6 +553,57 @@ export async function waitForInitComplete(
   throw new Error(`Init did not complete within ${timeoutMs}ms - workspace may not be ready`);
 }
 
+/**
+ * Collect all init events for a workspace.
+ * Filters sentEvents for init-start, init-output, and init-end events.
+ * Returns the events in chronological order.
+ */
+export function collectInitEvents(
+  env: import("./setup").TestEnvironment,
+  workspaceId: string
+): WorkspaceInitEvent[] {
+  return env.sentEvents
+    .filter((e) => e.channel === getChatChannel(workspaceId))
+    .map((e) => e.data as WorkspaceChatMessage)
+    .filter((msg) => isInitStart(msg) || isInitOutput(msg) || isInitEnd(msg)) as WorkspaceInitEvent[];
+}
+
+/**
+ * Wait for init-end event without checking exit code.
+ * Use this when you want to test failure cases or inspect the exit code yourself.
+ * For success-only tests, use waitForInitComplete() which throws on failure.
+ */
+export async function waitForInitEnd(
+  env: import("./setup").TestEnvironment,
+  workspaceId: string,
+  timeoutMs = 5000
+): Promise<void> {
+  const startTime = Date.now();
+  let pollInterval = 50;
+
+  while (Date.now() - startTime < timeoutMs) {
+    // Check for init-end event in sentEvents
+    const initEndEvent = env.sentEvents.find(
+      (e) =>
+        e.channel === getChatChannel(workspaceId) &&
+        typeof e.data === "object" &&
+        e.data !== null &&
+        "type" in e.data &&
+        e.data.type === "init-end"
+    );
+
+    if (initEndEvent) {
+      return; // Found end event, regardless of exit code
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    pollInterval = Math.min(pollInterval * 1.5, 500);
+  }
+
+  // Throw error on timeout
+  throw new Error(`Init did not complete within ${timeoutMs}ms`);
+}
+
 /**
  * Wait for stream to complete successfully
  * Common pattern: create collector, wait for end, assert success