fix(tools): clear loading promise on loader rejection to prevent wedged tools

Move loading=null to finally block so transient loader failures don't
permanently brick the lazy wrapper. Adds recovery test.

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: codewithkenzo

src/tools/lazy-tool-wrapper.test.ts

@@ -184,4 +184,45 @@ describe("createLazyTool", () => {
     expect(loader).toHaveBeenCalledTimes(1)
     expect(onFirstLoad).toHaveBeenCalledTimes(1)
   })
+
+  it("recovers from loader rejection and allows retry", async () => {
+    // #given
+    let callCount = 0
+    const mockTool: ToolDefinition = {
+      description: "mock tool",
+      args: mockToolArgs,
+      execute: async () => "recovered result",
+    } as ToolDefinition
+    const loader = mock(async () => {
+      callCount++
+      if (callCount === 1) {
+        throw new Error("transient failure")
+      }
+      return mockTool
+    })
+    const tool = createLazyTool({
+      name: "lazy_mock",
+      description: "lazy description",
+      args: mockToolArgs,
+      loader,
+    })
+
+    // #when: first call fails
+    let error: Error | undefined
+    try {
+      await tool.execute(mockArgs, mockContext)
+    } catch (err) {
+      error = err as Error
+    }
+
+    // #then: error surfaced
+    expect(error?.message).toBe("transient failure")
+
+    // #when: retry succeeds because loading was cleared
+    const result = await tool.execute(mockArgs, mockContext)
+
+    // #then
+    expect(result).toBe("recovered result")
+    expect(loader).toHaveBeenCalledTimes(2)
+  })
 })

src/tools/lazy-tool-wrapper.ts

@@ -27,12 +27,15 @@ export function createLazyTool(opts: LazyToolOptions): ToolDefinition {
 
     loading = (async () => {
       const start = performance.now()
-      const tool = await opts.loader()
-      const elapsed = performance.now() - start
-      cached = tool
-      loading = null
-      opts.onFirstLoad?.(opts.name, elapsed)
-      return tool
+      try {
+        const tool = await opts.loader()
+        const elapsed = performance.now() - start
+        cached = tool
+        opts.onFirstLoad?.(opts.name, elapsed)
+        return tool
+      } finally {
+        loading = null
+      }
     })()
 
     return loading