test(ipuaro): improve test coverage to 92% branches

- Raise branch coverage threshold from 90% to 92%
- Add 21 new edge-case tests across modules
- Watchdog: add tests for error handling, flushAll, polling mode
- OllamaClient: add tests for AbortError and model not found
- GetLinesTool: add tests for filesystem fallback, undefined params
- GetClassTool: add tests for undefined extends, error handling
- GetFunctionTool: add tests for error handling, undefined returnType

Coverage results:
- Lines: 97.83% (threshold 95%)
- Branches: 92.01% (threshold 92%)
- Functions: 99.16% (threshold 95%)
- Statements: 97.83% (threshold 95%)
- Total tests: 1441 (all passing)

packages/ipuaro/tests/unit/infrastructure/tools/read/GetFunctionTool.test.ts

@@ -301,5 +301,47 @@ describe("GetFunctionTool", () => {
             const data = result.data as GetFunctionResult
             expect(data.params).toEqual([])
         })
+
+        it("should handle error when reading lines fails", async () => {
+            const ast = createMockAST([createMockFunction({ name: "test", lineStart: 1, lineEnd: 1 })])
+            const storage: IStorage = {
+                getFile: vi.fn().mockResolvedValue(null),
+                getAST: vi.fn().mockResolvedValue(ast),
+                setFile: vi.fn(),
+                deleteFile: vi.fn(),
+                getAllFiles: vi.fn(),
+                setAST: vi.fn(),
+                getSymbolIndex: vi.fn(),
+                setSymbolIndex: vi.fn(),
+                getDepsGraph: vi.fn(),
+                setDepsGraph: vi.fn(),
+            }
+            const ctx = createMockContext(storage)
+
+            const result = await tool.execute({ path: "test.ts", name: "test" }, ctx)
+
+            expect(result.success).toBe(false)
+        })
+
+        it("should handle undefined returnType", async () => {
+            const lines = ["function implicitReturn() { return }"]
+            const func = createMockFunction({
+                name: "implicitReturn",
+                lineStart: 1,
+                lineEnd: 1,
+                returnType: undefined,
+                isAsync: false,
+            })
+            const ast = createMockAST([func])
+            const storage = createMockStorage({ lines }, ast)
+            const ctx = createMockContext(storage)
+
+            const result = await tool.execute({ path: "test.ts", name: "implicitReturn" }, ctx)
+
+            expect(result.success).toBe(true)
+            const data = result.data as GetFunctionResult
+            expect(data.returnType).toBeUndefined()
+            expect(data.isAsync).toBe(false)
+        })
     })
 })