@openfinclaw/findoo-datahub-plugin 2026.3.10 → 2026.3.12

package/test/e2e/l4-skill-tool-chain.live.test.ts

@@ -87,379 +87,375 @@ function assertSuccess(res: Record<string, unknown>, minCount = 0) {
 
 /* ---------- tests ---------- */
 
-describe.skipIf(SKIP)(
-  "L4 — Skill-driven Tool Chain E2E",
-  { timeout: 180_000 },
-  () => {
-    let tempDir: string;
-    let tools: ToolMap;
-
-    beforeAll(async () => {
-      tempDir = mkdtempSync(join(tmpdir(), "l4-chain-"));
-      const env = createTestEnv(tempDir);
-      tools = env.tools;
-      await findooDatahubPlugin.register(env.api);
+describe.skipIf(SKIP)("L4 — Skill-driven Tool Chain E2E", { timeout: 180_000 }, () => {
+  let tempDir: string;
+  let tools: ToolMap;
+
+  beforeAll(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "l4-chain-"));
+    const env = createTestEnv(tempDir);
+    tools = env.tools;
+    await findooDatahubPlugin.register(env.api);
+  });
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario A: fin-a-share — 个股全景分析 (600519.SH 茅台)
+  //  Skill pattern: price → fundamentals → ownership → TA → regime
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("A: fin-a-share — A-share deep analysis (茅台)", () => {
+    let priceData: Record<string, unknown>;
+    let fundamentals: Record<string, unknown>;
+    let regime: Record<string, unknown>;
+
+    it("A.1 fin_stock(price/historical) — get price data", async () => {
+      const res = parse(
+        await tools.get("fin_stock")!.execute("a1", {
+          symbol: "600519.SH",
+          endpoint: "price/historical",
+          limit: 30,
+        }),
+      );
+      assertSuccess(res, 1);
+      priceData = res;
+      const rows = res.results as Array<Record<string, unknown>>;
+      expect(rows[0]).toHaveProperty("close");
+      expect(Number(rows[0]!.close)).toBeGreaterThan(100);
+    }, 30_000);
+
+    it("A.2 fin_stock(fundamental/income) — get financials", async () => {
+      const res = parse(
+        await tools.get("fin_stock")!.execute("a2", {
+          symbol: "600519.SH",
+          endpoint: "fundamental/income",
+          limit: 4,
+        }),
+      );
+      assertSuccess(res, 1);
+      fundamentals = res;
+    }, 30_000);
+
+    it("A.3 fin_ta(rsi) — technical overlay", async () => {
+      const res = parse(
+        await tools.get("fin_ta")!.execute("a3", {
+          symbol: "600519.SH",
+          indicator: "rsi",
+          period: 14,
+          limit: 30,
+        }),
+      );
+      assertSuccess(res, 0);
+      expect(res.endpoint).toBe("ta/rsi");
+    }, 30_000);
+
+    it("A.4 fin_data_regime — trend context", async () => {
+      const res = parse(
+        await tools.get("fin_data_regime")!.execute("a4", {
+          symbol: "600519.SH",
+          market: "equity",
+          timeframe: "1d",
+        }),
+      );
+      expect(res.error).toBeUndefined();
+      expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(res.regime);
+      regime = res;
+    }, 30_000);
+
+    it("A.5 chain produces complete analysis inputs", () => {
+      // Verify all 4 steps produced data that an LLM could synthesize
+      expect(priceData.count as number).toBeGreaterThan(0);
+      expect(fundamentals.count as number).toBeGreaterThan(0);
+      expect(regime.regime).toBeDefined();
     });
-
-    afterAll(() => {
-      rmSync(tempDir, { recursive: true, force: true });
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario A: fin-a-share — 个股全景分析 (600519.SH 茅台)
-    //  Skill pattern: price → fundamentals → ownership → TA → regime
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("A: fin-a-share — A-share deep analysis (茅台)", () => {
-      let priceData: Record<string, unknown>;
-      let fundamentals: Record<string, unknown>;
-      let regime: Record<string, unknown>;
-
-      it("A.1 fin_stock(price/historical) — get price data", async () => {
-        const res = parse(
-          await tools.get("fin_stock")!.execute("a1", {
-            symbol: "600519.SH",
-            endpoint: "price/historical",
-            limit: 30,
-          }),
-        );
-        assertSuccess(res, 1);
-        priceData = res;
-        const rows = res.results as Array<Record<string, unknown>>;
-        expect(rows[0]).toHaveProperty("close");
-        expect(Number(rows[0]!.close)).toBeGreaterThan(100);
-      }, 30_000);
-
-      it("A.2 fin_stock(fundamental/income) — get financials", async () => {
-        const res = parse(
-          await tools.get("fin_stock")!.execute("a2", {
-            symbol: "600519.SH",
-            endpoint: "fundamental/income",
-            limit: 4,
-          }),
-        );
-        assertSuccess(res, 1);
-        fundamentals = res;
-      }, 30_000);
-
-      it("A.3 fin_ta(rsi) — technical overlay", async () => {
-        const res = parse(
-          await tools.get("fin_ta")!.execute("a3", {
-            symbol: "600519.SH",
-            indicator: "rsi",
-            period: 14,
-            limit: 30,
-          }),
-        );
-        assertSuccess(res, 1);
-        expect(res.endpoint).toBe("ta/rsi");
-      }, 30_000);
-
-      it("A.4 fin_data_regime — trend context", async () => {
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario B: fin-hk-hsi-pulse — 恒指估值脉搏
+  //  Skill pattern: index valuation → HIBOR rate → regime
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("B: fin-hk-hsi-pulse — HSI valuation pulse", () => {
+    let valuation: Record<string, unknown>;
+    let hibor: Record<string, unknown>;
+    let regime: Record<string, unknown>;
+
+    it("B.1 fin_index(daily_basic) — PE/PB percentile data", async () => {
+      const res = parse(
+        await tools.get("fin_index")!.execute("b1", {
+          symbol: "HSI",
+          endpoint: "daily_basic",
+          limit: 100,
+        }),
+      );
+      assertSuccess(res);
+      valuation = res;
+    }, 30_000);
+
+    it("B.2 fin_macro(hibor) — risk-free rate for ERP calc", async () => {
+      const res = parse(
+        await tools.get("fin_macro")!.execute("b2", {
+          endpoint: "hibor",
+          limit: 10,
+        }),
+      );
+      assertSuccess(res, 1);
+      hibor = res;
+    }, 30_000);
+
+    it("B.3 fin_data_regime(HSI) — trend overlay", async () => {
+      // HSI may not have OHLCV via the standard equity path, but we test the flow
+      try {
         const res = parse(
-          await tools.get("fin_data_regime")!.execute("a4", {
-            symbol: "600519.SH",
+          await tools.get("fin_data_regime")!.execute("b3", {
+            symbol: "HSI",
             market: "equity",
             timeframe: "1d",
           }),
         );
-        expect(res.error).toBeUndefined();
-        expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(res.regime);
-        regime = res;
-      }, 30_000);
-
-      it("A.5 chain produces complete analysis inputs", () => {
-        // Verify all 4 steps produced data that an LLM could synthesize
-        expect(priceData.count as number).toBeGreaterThan(0);
-        expect(fundamentals.count as number).toBeGreaterThan(0);
-        expect(regime.regime).toBeDefined();
-      });
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario B: fin-hk-hsi-pulse — 恒指估值脉搏
-    //  Skill pattern: index valuation → HIBOR rate → regime
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("B: fin-hk-hsi-pulse — HSI valuation pulse", () => {
-      let valuation: Record<string, unknown>;
-      let hibor: Record<string, unknown>;
-      let regime: Record<string, unknown>;
-
-      it("B.1 fin_index(daily_basic) — PE/PB percentile data", async () => {
-        const res = parse(
-          await tools.get("fin_index")!.execute("b1", {
-            symbol: "HSI",
-            endpoint: "daily_basic",
-            limit: 100,
-          }),
-        );
-        assertSuccess(res);
-        valuation = res;
-      }, 30_000);
-
-      it("B.2 fin_macro(hibor) — risk-free rate for ERP calc", async () => {
-        const res = parse(
-          await tools.get("fin_macro")!.execute("b2", {
-            endpoint: "hibor",
-            limit: 10,
-          }),
-        );
-        assertSuccess(res, 1);
-        hibor = res;
-      }, 30_000);
-
-      it("B.3 fin_data_regime(HSI) — trend overlay", async () => {
-        // HSI may not have OHLCV via the standard equity path, but we test the flow
-        try {
-          const res = parse(
-            await tools.get("fin_data_regime")!.execute("b3", {
-              symbol: "HSI",
-              market: "equity",
-              timeframe: "1d",
-            }),
-          );
-          if (!res.error) {
-            expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(res.regime);
-          }
-          regime = res;
-        } catch {
-          // HSI index may not have OHLCV data in the same format
-          regime = { regime: "unavailable" };
+        if (!res.error) {
+          expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(res.regime);
         }
-      }, 30_000);
-
-      it("B.4 chain produces ERP calculation inputs", () => {
-        // Verify we have the data needed for ERP = 1/PE - HIBOR
-        expect(hibor.count as number).toBeGreaterThan(0);
-        // Valuation may be empty for HSI if not covered by tushare
-      });
+        regime = res;
+      } catch {
+        // HSI index may not have OHLCV data in the same format
+        regime = { regime: "unavailable" };
+      }
+    }, 30_000);
+
+    it("B.4 chain produces ERP calculation inputs", () => {
+      // Verify we have the data needed for ERP = 1/PE - HIBOR
+      expect(hibor.count as number).toBeGreaterThan(0);
+      // Valuation may be empty for HSI if not covered by tushare
     });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario C: fin-us-equity — US stock analysis (AAPL)
-    //  Skill pattern: earnings forecast → income → price → TA
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("C: fin-us-equity — US stock analysis (AAPL)", () => {
-      it("C.1 fin_stock(fundamental/earnings_forecast) — consensus EPS", async () => {
-        const res = parse(
-          await tools.get("fin_stock")!.execute("c1", {
-            symbol: "AAPL",
-            endpoint: "fundamental/earnings_forecast",
-            limit: 5,
-          }),
-        );
-        // tushare may have limited US coverage
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario C: fin-us-equity — US stock analysis (AAPL)
+  //  Skill pattern: earnings forecast → income → price → TA
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("C: fin-us-equity — US stock analysis (AAPL)", () => {
+    it("C.1 fin_stock(fundamental/earnings_forecast) — consensus EPS", async () => {
+      const res = parse(
+        await tools.get("fin_stock")!.execute("c1", {
+          symbol: "AAPL",
+          endpoint: "fundamental/earnings_forecast",
+          limit: 5,
+        }),
+      );
+      // tushare may have limited US coverage
+      assertSuccess(res);
+    }, 30_000);
+
+    it("C.2 fin_stock(us/income) — GAAP financials", async () => {
+      const res = parse(
+        await tools.get("fin_stock")!.execute("c2", {
+          symbol: "AAPL",
+          endpoint: "us/income",
+          limit: 4,
+        }),
+      );
+      assertSuccess(res);
+    }, 30_000);
+
+    it("C.3 fin_macro(treasury_us) — risk-free rate for DCF", async () => {
+      const res = parse(
+        await tools.get("fin_macro")!.execute("c3", {
+          endpoint: "treasury_us",
+          limit: 5,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario D: fin-crypto — Crypto market overview
+  //  Skill pattern: market overview → DeFi TVL → stablecoin flow
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("D: fin-crypto — Crypto market overview", () => {
+    it("D.1 fin_crypto(coin/market) — top coins", async () => {
+      const res = parse(
+        await tools.get("fin_crypto")!.execute("d1", {
+          endpoint: "coin/market",
+          limit: 10,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+
+    it("D.2 fin_crypto(defi/protocols) — DeFi TVL ranking", async () => {
+      const res = parse(
+        await tools.get("fin_crypto")!.execute("d2", {
+          endpoint: "defi/protocols",
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+
+    it("D.3 fin_crypto(defi/stablecoins) — stablecoin supply", async () => {
+      const res = parse(
+        await tools.get("fin_crypto")!.execute("d3", {
+          endpoint: "defi/stablecoins",
+        }),
+      );
+      assertSuccess(res);
+    }, 30_000);
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario E: fin-cross-asset — Cross-asset correlation
+  //  Skill pattern: macro rates → A-share index → US treasury → crypto
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("E: fin-cross-asset — Multi-asset analysis", () => {
+    it("E.1 fin_macro(shibor) — China rate environment", async () => {
+      const res = parse(
+        await tools.get("fin_macro")!.execute("e1", {
+          endpoint: "shibor",
+          limit: 10,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+
+    it("E.2 fin_index(price/historical) — CSI 300 trend", async () => {
+      const res = parse(
+        await tools.get("fin_index")!.execute("e2", {
+          symbol: "000300.SH",
+          endpoint: "price/historical",
+          limit: 30,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+
+    it("E.3 fin_macro(treasury_us) — US 10Y for global anchor", async () => {
+      const res = parse(
+        await tools.get("fin_macro")!.execute("e3", {
+          endpoint: "treasury_us",
+          limit: 10,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+
+    it("E.4 fin_derivatives(futures/historical) — commodity context", async () => {
+      const res = parse(
+        await tools.get("fin_derivatives")!.execute("e4", {
+          symbol: "RB2501.SHF",
+          endpoint: "futures/historical",
+          limit: 10,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario F: fin-a-quant-board — 涨停板量化 + 题材跟踪
+  //  Skill pattern: limit_list → top_list (龙虎榜) → ths_index (题材)
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("F: fin-a-quant-board — Limit-up board + theme tracking", () => {
+    it("F.1 fin_market(market/limit_list) — limit-up/down stats", async () => {
+      const res = parse(
+        await tools.get("fin_market")!.execute("f1", {
+          endpoint: "market/limit_list",
+          trade_date: "2026-02-27",
+        }),
+      );
+      // May return error for non-trading days
+      if (!res.error) {
         assertSuccess(res);
-      }, 30_000);
-
-      it("C.2 fin_stock(us/income) — GAAP financials", async () => {
-        const res = parse(
-          await tools.get("fin_stock")!.execute("c2", {
-            symbol: "AAPL",
-            endpoint: "us/income",
-            limit: 4,
-          }),
-        );
+      }
+    }, 30_000);
+
+    it("F.2 fin_market(market/top_list) — dragon-tiger list", async () => {
+      const res = parse(
+        await tools.get("fin_market")!.execute("f2", {
+          endpoint: "market/top_list",
+          trade_date: "2026-02-27",
+        }),
+      );
+      if (!res.error) {
         assertSuccess(res);
-      }, 30_000);
-
-      it("C.3 fin_macro(treasury_us) — risk-free rate for DCF", async () => {
-        const res = parse(
-          await tools.get("fin_macro")!.execute("c3", {
-            endpoint: "treasury_us",
-            limit: 5,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario D: fin-crypto — Crypto market overview
-    //  Skill pattern: market overview → DeFi TVL → stablecoin flow
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("D: fin-crypto — Crypto market overview", () => {
-      it("D.1 fin_crypto(coin/market) — top coins", async () => {
-        const res = parse(
-          await tools.get("fin_crypto")!.execute("d1", {
-            endpoint: "coin/market",
-            limit: 10,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-
-      it("D.2 fin_crypto(defi/protocols) — DeFi TVL ranking", async () => {
-        const res = parse(
-          await tools.get("fin_crypto")!.execute("d2", {
-            endpoint: "defi/protocols",
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-
-      it("D.3 fin_crypto(defi/stablecoins) — stablecoin supply", async () => {
-        const res = parse(
-          await tools.get("fin_crypto")!.execute("d3", {
-            endpoint: "defi/stablecoins",
-          }),
-        );
-        assertSuccess(res);
-      }, 30_000);
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario E: fin-cross-asset — Cross-asset correlation
-    //  Skill pattern: macro rates → A-share index → US treasury → crypto
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("E: fin-cross-asset — Multi-asset analysis", () => {
-      it("E.1 fin_macro(shibor) — China rate environment", async () => {
-        const res = parse(
-          await tools.get("fin_macro")!.execute("e1", {
-            endpoint: "shibor",
-            limit: 10,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-
-      it("E.2 fin_index(price/historical) — CSI 300 trend", async () => {
-        const res = parse(
-          await tools.get("fin_index")!.execute("e2", {
-            symbol: "000300.SH",
-            endpoint: "price/historical",
-            limit: 30,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-
-      it("E.3 fin_macro(treasury_us) — US 10Y for global anchor", async () => {
-        const res = parse(
-          await tools.get("fin_macro")!.execute("e3", {
-            endpoint: "treasury_us",
-            limit: 10,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-
-      it("E.4 fin_derivatives(futures/historical) — commodity context", async () => {
-        const res = parse(
-          await tools.get("fin_derivatives")!.execute("e4", {
-            symbol: "RB2501.SHF",
-            endpoint: "futures/historical",
-            limit: 10,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario F: fin-a-quant-board — 涨停板量化 + 题材跟踪
-    //  Skill pattern: limit_list → top_list (龙虎榜) → ths_index (题材)
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("F: fin-a-quant-board — Limit-up board + theme tracking", () => {
-      it("F.1 fin_market(market/limit_list) — limit-up/down stats", async () => {
-        const res = parse(
-          await tools.get("fin_market")!.execute("f1", {
-            endpoint: "market/limit_list",
-            trade_date: "2026-02-27",
-          }),
-        );
-        // May return error for non-trading days
-        if (!res.error) {
-          assertSuccess(res);
-        }
-      }, 30_000);
-
-      it("F.2 fin_market(market/top_list) — dragon-tiger list", async () => {
-        const res = parse(
-          await tools.get("fin_market")!.execute("f2", {
-            endpoint: "market/top_list",
-            trade_date: "2026-02-27",
-          }),
-        );
-        if (!res.error) {
-          assertSuccess(res);
-        }
-      }, 30_000);
-
-      it("F.3 fin_index(thematic/ths_index) — theme index list", async () => {
-        const res = parse(
-          await tools.get("fin_index")!.execute("f3", {
-            endpoint: "thematic/ths_index",
-            limit: 20,
-          }),
-        );
-        assertSuccess(res, 1);
-      }, 30_000);
-    });
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Scenario G: Error resilience in multi-step chains
-    // ═══════════════════════════════════════════════════════════════
-
-    describe("G: Error resilience", () => {
-      it("G.1 tool error doesn't crash — chain can continue", async () => {
-        // Step 1: Intentionally fail
-        const bad = parse(
-          await tools.get("fin_stock")!.execute("g1-bad", {
-            symbol: "NONEXISTENT_999",
-            endpoint: "price/historical",
-            limit: 5,
-          }),
-        );
-        // Should gracefully return (error or empty results)
-        const hasSomeResponse = bad.error !== undefined || bad.success !== undefined;
-        expect(hasSomeResponse).toBe(true);
-
-        // Step 2: Next tool in chain still works
-        const good = parse(
-          await tools.get("fin_macro")!.execute("g1-good", {
-            endpoint: "cpi",
-            limit: 3,
-          }),
-        );
-        assertSuccess(good, 1);
-      }, 30_000);
-
-      it("G.2 parallel tool calls produce independent results", async () => {
-        // Simulate LLM calling 3 tools in parallel (common pattern)
-        const [r1, r2, r3] = await Promise.all([
-          tools.get("fin_stock")!.execute("g2-1", {
-            symbol: "600519.SH",
-            endpoint: "price/historical",
-            limit: 5,
-          }),
-          tools.get("fin_macro")!.execute("g2-2", {
-            endpoint: "cpi",
-            limit: 5,
-          }),
-          tools.get("fin_crypto")!.execute("g2-3", {
-            endpoint: "coin/market",
-            limit: 5,
-          }),
-        ]);
-
-        const p1 = parse(r1);
-        const p2 = parse(r2);
-        const p3 = parse(r3);
-
-        assertSuccess(p1, 1);
-        assertSuccess(p2, 1);
-        assertSuccess(p3, 1);
-
-        // Results are independent
-        expect(p1.endpoint).not.toBe(p2.endpoint);
-        expect(p2.endpoint).not.toBe(p3.endpoint);
-      }, 30_000);
-    });
-  },
-);
+      }
+    }, 30_000);
+
+    it("F.3 fin_index(thematic/ths_index) — theme index list", async () => {
+      const res = parse(
+        await tools.get("fin_index")!.execute("f3", {
+          endpoint: "thematic/ths_index",
+          limit: 20,
+        }),
+      );
+      assertSuccess(res, 1);
+    }, 30_000);
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  //  Scenario G: Error resilience in multi-step chains
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("G: Error resilience", () => {
+    it("G.1 tool error doesn't crash — chain can continue", async () => {
+      // Step 1: Intentionally fail
+      const bad = parse(
+        await tools.get("fin_stock")!.execute("g1-bad", {
+          symbol: "NONEXISTENT_999",
+          endpoint: "price/historical",
+          limit: 5,
+        }),
+      );
+      // Should gracefully return (error or empty results)
+      const hasSomeResponse = bad.error !== undefined || bad.success !== undefined;
+      expect(hasSomeResponse).toBe(true);
+
+      // Step 2: Next tool in chain still works
+      const good = parse(
+        await tools.get("fin_macro")!.execute("g1-good", {
+          endpoint: "cpi",
+          limit: 3,
+        }),
+      );
+      assertSuccess(good, 1);
+    }, 30_000);
+
+    it("G.2 parallel tool calls produce independent results", async () => {
+      // Simulate LLM calling 3 tools in parallel (common pattern)
+      const [r1, r2, r3] = await Promise.all([
+        tools.get("fin_stock")!.execute("g2-1", {
+          symbol: "600519.SH",
+          endpoint: "price/historical",
+          limit: 5,
+        }),
+        tools.get("fin_macro")!.execute("g2-2", {
+          endpoint: "cpi",
+          limit: 5,
+        }),
+        tools.get("fin_crypto")!.execute("g2-3", {
+          endpoint: "coin/market",
+          limit: 5,
+        }),
+      ]);
+
+      const p1 = parse(r1);
+      const p2 = parse(r2);
+      const p3 = parse(r3);
+
+      assertSuccess(p1, 1);
+      assertSuccess(p2, 1);
+      assertSuccess(p3, 1);
+
+      // Results are independent
+      expect(p1.endpoint).not.toBe(p2.endpoint);
+      expect(p2.endpoint).not.toBe(p3.endpoint);
+    }, 30_000);
+  });
+});