🤖 Minimize initStateManager passing in tool configuration

Remove initStateManager from ToolConfiguration interface - it's only needed
by wrapWithInitWait, not by individual tools.

Changes:
- Remove workspaceId and initStateManager from ToolConfiguration
- Update wrapWithInitWait to accept these as separate parameters
- Update getToolsForModel signature to pass them separately
- Update all call sites in aiService.ts and ipcMain.ts
- Update test helpers to match new config interface

This makes the separation clearer:
- Tools only receive the config they need (cwd, runtime, secrets, etc.)
- Init state management is isolated to the wrapper layer
- Non-runtime tools never see init-related fields

All tests pass (806 unit, 7 integration).

Author: ammar-agent

src/services/aiService.ts

@@ -431,14 +431,17 @@ export class AIService extends EventEmitter {
 
       // Get tool names early for mode transition sentinel (stub config, no workspace context needed)
       const earlyRuntime = createRuntime({ type: "local", srcBaseDir: process.cwd() });
-      const earlyAllTools = await getToolsForModel(modelString, {
-        cwd: process.cwd(),
-        runtime: earlyRuntime,
-        runtimeTempDir: os.tmpdir(),
-        workspaceId: "", // Empty workspace ID for early stub config
-        initStateManager: this.initStateManager,
-        secrets: {},
-      });
+      const earlyAllTools = await getToolsForModel(
+        modelString,
+        {
+          cwd: process.cwd(),
+          runtime: earlyRuntime,
+          runtimeTempDir: os.tmpdir(),
+          secrets: {},
+        },
+        "", // Empty workspace ID for early stub config
+        this.initStateManager
+      );
       const earlyTools = applyToolPolicy(earlyAllTools, toolPolicy);
       const toolNamesForSentinel = Object.keys(earlyTools);
 
@@ -543,14 +546,17 @@ export class AIService extends EventEmitter {
       const runtimeTempDir = await this.streamManager.createTempDirForStream(streamToken, runtime);
 
       // Get model-specific tools with workspace path (correct for local or remote)
-      const allTools = await getToolsForModel(modelString, {
-        cwd: workspacePath,
-        runtime,
+      const allTools = await getToolsForModel(
+        modelString,
+        {
+          cwd: workspacePath,
+          runtime,
+          secrets: secretsToRecord(projectSecrets),
+          runtimeTempDir,
+        },
         workspaceId,
-        initStateManager: this.initStateManager,
-        secrets: secretsToRecord(projectSecrets),
-        runtimeTempDir,
-      });
+        this.initStateManager
+      );
 
       // Apply tool policy to filter tools (if policy provided)
       const tools = applyToolPolicy(allTools, toolPolicy);

src/services/ipcMain.ts

@@ -924,11 +924,10 @@ export class IpcMain {
 
           // Create bash tool with workspace's cwd and secrets
           // All IPC bash calls are from UI (background operations) - use truncate to avoid temp file spam
+          // No init wait needed - IPC calls are user-initiated, not AI tool use
           const bashTool = createBashTool({
             cwd: workspacePath, // Bash executes in the workspace directory
             runtime,
-            workspaceId,
-            initStateManager: this.initStateManager,
             secrets: secretsToRecord(projectSecrets),
             niceness: options?.niceness,
             runtimeTempDir: tempDir.path,

src/services/tools/testHelpers.ts

@@ -55,8 +55,6 @@ export function createTestToolConfig(
   return {
     cwd: tempDir,
     runtime: new LocalRuntime(tempDir),
-    workspaceId: "test-workspace",
-    initStateManager: getTestInitStateManager(),
     runtimeTempDir: tempDir,
     niceness: options?.niceness,
   };

src/services/tools/wrapWithInitWait.ts

@@ -1,5 +1,5 @@
 import type { Tool } from "ai";
-import type { ToolConfiguration } from "@/utils/tools/tools";
+import type { InitStateManager } from "@/services/initStateManager";
 
 /**
  * Wraps a tool to wait for workspace initialization before execution.
@@ -11,19 +11,21 @@ import type { ToolConfiguration } from "@/utils/tools/tools";
  * Non-runtime tools (propose_plan, todo, web_search) execute immediately.
  *
  * @param tool The tool to wrap (returned from a tool factory)
- * @param config Tool configuration containing initStateManager
+ * @param workspaceId Workspace ID for init state tracking
+ * @param initStateManager Init state manager for waiting
  * @returns Wrapped tool that waits for init before executing
  */
 export function wrapWithInitWait<TParameters, TResult>(
   tool: Tool<TParameters, TResult>,
-  config: ToolConfiguration
+  workspaceId: string,
+  initStateManager: InitStateManager
 ): Tool<TParameters, TResult> {
   return {
     ...tool,
     execute: async (args: TParameters, options) => {
       // Wait for workspace initialization to complete (no-op if not needed)
       // This never throws - tools proceed regardless of init outcome
-      await config.initStateManager.waitForInit(config.workspaceId);
+      await initStateManager.waitForInit(workspaceId);
 
       // Execute the actual tool with all arguments
       if (!tool.execute) {

src/utils/tools/tools.ts

@@ -20,10 +20,6 @@ export interface ToolConfiguration {
   cwd: string;
   /** Runtime environment for executing commands and file operations */
   runtime: Runtime;
-  /** Workspace ID - used to wait for initialization before executing tools */
-  workspaceId: string;
-  /** Init state manager - used by tools to wait for async initialization (SSH runtime) */
-  initStateManager: InitStateManager;
   /** Environment secrets to inject (optional) */
   secrets?: Record<string, string>;
   /** Process niceness level (optional, -20 to 19, lower = higher priority) */
@@ -47,25 +43,33 @@ export type ToolFactory = (config: ToolConfiguration) => Tool;
  *
  * @param modelString The model string in format "provider:model-id"
  * @param config Required configuration for tools
+ * @param workspaceId Workspace ID for init state tracking (required for runtime tools)
+ * @param initStateManager Init state manager for runtime tools to wait for initialization
  * @returns Promise resolving to record of tools available for the model
  */
 export async function getToolsForModel(
   modelString: string,
-  config: ToolConfiguration
+  config: ToolConfiguration,
+  workspaceId: string,
+  initStateManager: InitStateManager
 ): Promise<Record<string, Tool>> {
   const [provider, modelId] = modelString.split(":");
 
   // Runtime-dependent tools need to wait for workspace initialization
   // Wrap them to handle init waiting centrally instead of in each tool
   const runtimeTools: Record<string, Tool> = {
-    file_read: wrapWithInitWait(createFileReadTool(config), config),
-    file_edit_replace_string: wrapWithInitWait(createFileEditReplaceStringTool(config), config),
+    file_read: wrapWithInitWait(createFileReadTool(config), workspaceId, initStateManager),
+    file_edit_replace_string: wrapWithInitWait(
+      createFileEditReplaceStringTool(config),
+      workspaceId,
+      initStateManager
+    ),
     // DISABLED: file_edit_replace_lines - causes models (particularly GPT-5-Codex)
     // to leave repository in broken state due to issues with concurrent file modifications
     // and line number miscalculations. Use file_edit_replace_string or file_edit_insert instead.
-    // file_edit_replace_lines: wrapWithInitWait(createFileEditReplaceLinesTool(config), config),
-    file_edit_insert: wrapWithInitWait(createFileEditInsertTool(config), config),
-    bash: wrapWithInitWait(createBashTool(config), config),
+    // file_edit_replace_lines: wrapWithInitWait(createFileEditReplaceLinesTool(config), workspaceId, initStateManager),
+    file_edit_insert: wrapWithInitWait(createFileEditInsertTool(config), workspaceId, initStateManager),
+    bash: wrapWithInitWait(createBashTool(config), workspaceId, initStateManager),
   };
 
   // Non-runtime tools execute immediately (no init wait needed)