@tyvm/knowhow 0.0.108 → 0.0.109-dev.86123ed

package/tests/unit/clients/withRetry.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Unit tests for withRetry — retry, timeout, and AbortSignal behaviour.
+ *
+ * These tests are isolated from AIClient: they exercise the withRetry helper
+ * directly using a mock async function.
+ */
+import { withRetry } from "../../../src/clients/withRetry";
+
+describe("withRetry", () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  // ─── Success path ────────────────────────────────────────────────────────
+
+  describe("success path", () => {
+    it("returns the result immediately when fn succeeds on the first attempt", async () => {
+      const fn = jest.fn().mockResolvedValue({ answer: 42 });
+      const result = await withRetry(fn, { maxRetries: 2 });
+      expect(result).toEqual({ answer: 42 });
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it("passes undefined signal to fn when no timeout or external signal is provided", async () => {
+      let receivedSignal: AbortSignal | undefined = "not-called" as any;
+      const fn = jest.fn().mockImplementation((signal: any) => {
+        receivedSignal = signal;
+        return Promise.resolve("ok");
+      });
+      await withRetry(fn, {});
+      expect(receivedSignal).toBeUndefined();
+    });
+
+    it("passes a signal to fn when a timeout is provided", async () => {
+      let receivedSignal: AbortSignal | undefined;
+      const fn = jest.fn().mockImplementation((signal: any) => {
+        receivedSignal = signal;
+        return Promise.resolve("ok");
+      });
+      await withRetry(fn, { timeout: 5000 });
+      expect(receivedSignal).toBeInstanceOf(AbortSignal);
+      expect(receivedSignal!.aborted).toBe(false);
+    });
+  });
+
+  // ─── Retry path ──────────────────────────────────────────────────────────
+
+  describe("retry on retriable errors", () => {
+    it("retries on a 429 rate-limit error and eventually succeeds", async () => {
+      jest.useFakeTimers();
+      const fn = jest
+        .fn()
+        .mockRejectedValueOnce(new Error("429 Too Many Requests"))
+        .mockResolvedValueOnce({ answer: "retried" });
+
+      const promise = withRetry(fn, { maxRetries: 2, backoffMs: 100 });
+      await jest.runAllTimersAsync();
+      const result = await promise;
+
+      expect(result).toEqual({ answer: "retried" });
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it("retries on a 500 server error and eventually succeeds", async () => {
+      jest.useFakeTimers();
+      const fn = jest
+        .fn()
+        .mockRejectedValueOnce(new Error("500 Internal Server Error"))
+        .mockResolvedValueOnce({
+          choices: [{ message: { role: "assistant", content: "hi" } }],
+        });
+
+      const promise = withRetry(fn, { maxRetries: 2, backoffMs: 100 });
+      await jest.runAllTimersAsync();
+      const result = await promise;
+
+      expect(result).toMatchObject({
+        choices: [{ message: { content: "hi" } }],
+      });
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it("retries on ECONNRESET and succeeds", async () => {
+      jest.useFakeTimers();
+      const fn = jest
+        .fn()
+        .mockRejectedValueOnce(new Error("ECONNRESET"))
+        .mockResolvedValueOnce("success");
+
+      const promise = withRetry(fn, { maxRetries: 2, backoffMs: 100 });
+      await jest.runAllTimersAsync();
+      const result = await promise;
+
+      expect(result).toBe("success");
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it("retries up to maxRetries times then throws", async () => {
+      jest.useFakeTimers();
+      const fn = jest.fn().mockImplementation(() =>
+        Promise.reject(new Error("500 Server Error"))
+      );
+
+      const resultPromise = withRetry(fn, { maxRetries: 2, backoffMs: 10 });
+      // Suppress unhandled rejection warning while timers run
+      resultPromise.catch(() => {});
+      await jest.runAllTimersAsync();
+      await expect(resultPromise).rejects.toThrow("500 Server Error");
+      // 1 initial attempt + 2 retries = 3 total calls
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+
+    it("does NOT retry on a non-retriable error (e.g. 400 Bad Request)", async () => {
+      const fn = jest
+        .fn()
+        .mockRejectedValue(new Error("400 Bad Request"));
+      await expect(withRetry(fn, { maxRetries: 2 })).rejects.toThrow(
+        "400 Bad Request"
+      );
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it("does NOT retry when maxRetries is 0", async () => {
+      const fn = jest
+        .fn()
+        .mockRejectedValue(new Error("500 Server Error"));
+      await expect(withRetry(fn, { maxRetries: 0 })).rejects.toThrow(
+        "500 Server Error"
+      );
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it("uses exponential backoff between retries", async () => {
+      jest.useFakeTimers();
+
+      const error = new Error("500 err");
+      const fn = jest
+        .fn()
+        .mockRejectedValueOnce(error)
+        .mockRejectedValueOnce(error)
+        .mockResolvedValueOnce("done");
+
+      // Spy on setTimeout to capture backoff delay values
+      const observedDelays: number[] = [];
+      const origSetTimeout = global.setTimeout;
+      const spy = jest
+        .spyOn(global, "setTimeout")
+        .mockImplementation((cb: any, delay?: number, ...args: any[]) => {
+          if (delay === 100 || delay === 200) {
+            observedDelays.push(delay!);
+          }
+          // Always run immediately so the test doesn't stall
+          return origSetTimeout(cb, 0, ...args);
+        });
+
+      const promise = withRetry(fn, { maxRetries: 2, backoffMs: 100 });
+      await jest.runAllTimersAsync();
+      await promise;
+
+      spy.mockRestore();
+
+      // Attempt 0 backoff = 100 * 2^0 = 100ms; attempt 1 backoff = 100 * 2^1 = 200ms
+      expect(observedDelays).toContain(100);
+      expect(observedDelays).toContain(200);
+    });
+  });
+
+  // ─── Timeout path ────────────────────────────────────────────────────────
+
+  describe("per-attempt timeout", () => {
+    it("aborts fn via signal when timeout fires and retries on the next attempt", async () => {
+      jest.useFakeTimers();
+
+      // First call: honours the signal abort (simulates slow network)
+      // Second call: resolves immediately
+      const fn = jest
+        .fn()
+        .mockImplementationOnce((signal: AbortSignal) => {
+          return new Promise<string>((_, reject) => {
+            signal.addEventListener("abort", () => reject(signal.reason));
+          });
+        })
+        .mockResolvedValueOnce("completed after timeout retry");
+
+      const promise = withRetry(fn, {
+        timeout: 1000,
+        maxRetries: 2,
+        backoffMs: 10,
+      });
+
+      // Advance timers: fires the timeout on the first attempt, then the backoff
+      await jest.runAllTimersAsync();
+
+      const result = await promise;
+      expect(result).toBe("completed after timeout retry");
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it("throws after all retries are exhausted by timeouts", async () => {
+      jest.useFakeTimers();
+
+      // Every call hangs waiting for the abort signal
+      const fn = jest.fn().mockImplementation((signal: AbortSignal) => {
+        return new Promise<string>((_, reject) => {
+          signal.addEventListener("abort", () => reject(signal.reason));
+        });
+      });
+
+      const promise = withRetry(fn, {
+        timeout: 500,
+        maxRetries: 1,
+        backoffMs: 10,
+      });
+      // Suppress unhandled rejection while timers run
+      promise.catch(() => {});
+      await jest.runAllTimersAsync();
+
+      await expect(promise).rejects.toMatchObject({ name: "TimeoutError" });
+      // 1 initial + 1 retry, both timed out
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  // ─── AbortSignal (external cancel) ───────────────────────────────────────
+
+  describe("external AbortSignal", () => {
+    it("does not call fn when signal is already aborted before invocation", async () => {
+      const controller = new AbortController();
+      controller.abort();
+
+      const fn = jest.fn().mockResolvedValue("should not reach");
+      await expect(
+        withRetry(fn, { signal: controller.signal, maxRetries: 2 })
+      ).rejects.toMatchObject({ name: "AbortError" });
+
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it("cancels an in-flight request when signal is aborted externally", async () => {
+      const controller = new AbortController();
+
+      const fn = jest.fn().mockImplementation((signal: AbortSignal) => {
+        return new Promise<string>((_, reject) => {
+          signal.addEventListener("abort", () => reject(signal.reason));
+        });
+      });
+
+      const promise = withRetry(fn, {
+        signal: controller.signal,
+        maxRetries: 2,
+      });
+
+      // Abort from outside while in-flight
+      setImmediate(() =>
+        controller.abort(new DOMException("User cancelled", "AbortError"))
+      );
+
+      await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+      // Must NOT retry after external abort
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not retry after external abort even if error string looks retriable", async () => {
+      const controller = new AbortController();
+      controller.abort(new DOMException("Aborted", "AbortError"));
+
+      const fn = jest.fn().mockResolvedValue("ok");
+      await expect(
+        withRetry(fn, { signal: controller.signal, maxRetries: 3 })
+      ).rejects.toMatchObject({ name: "AbortError" });
+
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it("forwards the combined signal to fn and it is not aborted on success", async () => {
+      const controller = new AbortController();
+      let receivedSignal: AbortSignal | undefined;
+
+      const fn = jest.fn().mockImplementation((signal: AbortSignal) => {
+        receivedSignal = signal;
+        return Promise.resolve("ok");
+      });
+
+      await withRetry(fn, { signal: controller.signal, timeout: 5000 });
+
+      expect(receivedSignal).toBeInstanceOf(AbortSignal);
+      expect(receivedSignal!.aborted).toBe(false);
+    });
+  });
+
+  // ─── Combined timeout + external signal ──────────────────────────────────
+
+  describe("timeout + external signal combined", () => {
+    it("abort via external signal takes priority over pending timeout", async () => {
+      const controller = new AbortController();
+
+      const fn = jest.fn().mockImplementation((signal: AbortSignal) => {
+        return new Promise<string>((_, reject) => {
+          signal.addEventListener("abort", () => reject(signal.reason));
+        });
+      });
+
+      const promise = withRetry(fn, {
+        signal: controller.signal,
+        timeout: 10_000, // long timeout — won't fire before external abort
+        maxRetries: 2,
+      });
+
+      // Abort externally right away
+      setImmediate(() =>
+        controller.abort(new DOMException("User cancelled", "AbortError"))
+      );
+
+      await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+      // No retry after external abort
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/tests/unit/commands/github-credentials.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Unit tests for the github-credentials command.
+ *
+ * Key invariant: running `github-credentials` must NEVER write anything other than
+ * the credential lines to stdout. Module loading logs, warnings, etc. must be
+ * silenced so the git credential helper protocol is not corrupted.
+ */
+
+// Mock config before any imports that depend on it
+jest.mock("../../../src/config", () => ({
+  getConfig: jest.fn().mockResolvedValue({ modules: [] }),
+  getGlobalConfig: jest.fn().mockResolvedValue({ modules: [] }),
+  getConfigSync: jest.fn().mockReturnValue({}),
+  migrateConfig: jest.fn().mockResolvedValue(undefined),
+}));
+
+// Mock clients to avoid openai.ts side-effects
+jest.mock("../../../src/clients", () => ({
+  AIClient: jest.fn(),
+  Clients: { registerClient: jest.fn(), registerModels: jest.fn() },
+}));
+
+// Mock KnowhowSimpleClient so we control what getGitCredential returns
+// without needing a real JWT or network connection
+jest.mock("../../../src/services/KnowhowClient", () => ({
+  KnowhowSimpleClient: jest.fn().mockImplementation(() => ({
+    getGitCredential: jest.fn().mockResolvedValue({
+      protocol: "https",
+      host: "github.com",
+      username: "x-access-token",
+      password: "ghu_TESTTOKEN123",
+    }),
+  })),
+}));
+
+// Mock readline so the 'get' action doesn't hang waiting for stdin
+jest.mock("readline", () => ({
+  createInterface: jest.fn().mockReturnValue({
+    on: jest.fn().mockImplementation(function (event: string, cb: Function) {
+      // Immediately fire 'close' so the readline promise resolves
+      if (event === "close") {
+        setImmediate(() => cb());
+      }
+      return this;
+    }),
+  }),
+}));
+
+import { Command } from "commander";
+import { addGithubCredentialsCommand } from "../../../src/commands/misc";
+import { logger } from "../../../src/logger";
+
+describe("github-credentials command", () => {
+  /**
+   * This test verifies the EARLY silencing logic in cli.ts main().
+   * The problem: modules load BEFORE parseAsync, so any module that emits
+   * warnings (e.g. Terminal module: no TunnelHandler) does so before the
+   * action's logger.silence() call can stop it.
+   *
+   * The fix: cli.ts checks process.argv before module loading and silences early.
+   * This test simulates that logic directly.
+   */
+  describe("early silencing (pre-module-load)", () => {
+    beforeEach(() => {
+      logger.unsilence();
+      logger.installConsoleOverload();
+    });
+
+    afterEach(() => {
+      logger.unsilence();
+      logger.uninstallConsoleOverload();
+    });
+
+    it("silences before module loading when github-credentials is in argv", () => {
+      const originalArgv = process.argv;
+      process.argv = ["node", "knowhow", "github-credentials", "get"];
+
+      // Simulate the exact early-detection logic from cli.ts main()
+      const rawArgs = process.argv.slice(2);
+      const SILENT_COMMANDS = ["github-credentials"];
+      if (rawArgs.some((a) => SILENT_COMMANDS.includes(a))) {
+        logger.silence();
+      }
+
+      // Now any module-load-time console.log/warn should be suppressed
+      const consoleSpy = jest.spyOn(process.stdout, "write");
+      console.log("some module loading noise that should be suppressed");
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+      consoleSpy.mockRestore();
+      process.argv = originalArgv;
+    });
+
+    it("does NOT silence for other commands", () => {
+      const originalArgv = process.argv;
+      process.argv = ["node", "knowhow", "chat"];
+
+      const rawArgs = process.argv.slice(2);
+      const SILENT_COMMANDS = ["github-credentials"];
+      if (rawArgs.some((a) => SILENT_COMMANDS.includes(a))) {
+        logger.silence();
+      }
+
+      expect(logger.isSilenced()).toBe(false);
+      process.argv = originalArgv;
+    });
+  });
+
+  let program: Command;
+  let stdoutSpy: jest.SpyInstance;
+  let writtenToStdout: string[];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Reset logger silence state between tests
+    logger.unsilence();
+
+    // Capture process.stdout.write — this is what the credential helper uses
+    writtenToStdout = [];
+    stdoutSpy = jest
+      .spyOn(process.stdout, "write")
+      .mockImplementation((chunk: any) => {
+        writtenToStdout.push(typeof chunk === "string" ? chunk : chunk.toString());
+        return true;
+      });
+
+    program = new Command();
+    program.exitOverride(); // prevent process.exit during tests
+    addGithubCredentialsCommand(program);
+  });
+
+  afterEach(() => {
+    stdoutSpy.mockRestore();
+    logger.unsilence();
+  });
+
+  it("outputs only credential lines to stdout for 'get' action", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    expect(writtenToStdout).toHaveLength(1);
+    expect(writtenToStdout[0]).toBe(
+      "protocol=https\nhost=github.com\nusername=x-access-token\npassword=ghu_TESTTOKEN123\n"
+    );
+  });
+
+  it("silences the logger immediately so module logs don't pollute stdout", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    // The action must have called logger.silence() — state persists after action
+    expect(logger.isSilenced()).toBe(true);
+  });
+
+  it("produces exactly 4 credential field lines and nothing else", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    const allOutput = writtenToStdout.join("");
+    const lines = allOutput.trim().split("\n");
+
+    expect(lines).toHaveLength(4);
+    expect(lines[0]).toMatch(/^protocol=/);
+    expect(lines[1]).toMatch(/^host=/);
+    expect(lines[2]).toMatch(/^username=/);
+    expect(lines[3]).toMatch(/^password=/);
+  });
+
+  it("exits cleanly for 'store' action without writing credentials", async () => {
+    let exitCode: number | undefined;
+    // Throw to stop execution after exit() is called — otherwise the mock
+    // just sets a flag and the action continues to fetch credentials.
+    const exitSpy = jest
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        exitCode = code ?? 0;
+        throw new Error(`process.exit(${exitCode})`);
+      }) as any);
+
+    await expect(
+      program.parseAsync(["node", "knowhow", "github-credentials", "store"])
+    ).rejects.toThrow("process.exit(0)");
+
+    expect(exitCode).toBe(0);
+    expect(writtenToStdout).toHaveLength(0);
+    exitSpy.mockRestore();
+  });
+
+  it("exits cleanly for 'erase' action without writing credentials", async () => {
+    let exitCode: number | undefined;
+    const exitSpy = jest
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        exitCode = code ?? 0;
+        throw new Error(`process.exit(${exitCode})`);
+      }) as any);
+
+    await expect(
+      program.parseAsync(["node", "knowhow", "github-credentials", "erase"])
+    ).rejects.toThrow("process.exit(0)");
+
+    expect(exitCode).toBe(0);
+    expect(writtenToStdout).toHaveLength(0);
+    exitSpy.mockRestore();
+  });
+});

package/tests/unit/modules/moduleLoading.test.ts

@@ -24,20 +24,27 @@ jest.mock("../../../src/services", () => ({
 }));
 
 import { ModulesService } from "../../../src/services/modules";
-import { ModuleContext, KnowhowModule } from "../../../src/services/modules/types";
+import {
+  ModuleContext,
+  KnowhowModule,
+} from "../../../src/services/modules/types";
 import { getConfig, getGlobalConfig } from "../../../src/config";
 
 const mockGetConfig = getConfig as jest.MockedFunction<typeof getConfig>;
-const mockGetGlobalConfig = getGlobalConfig as jest.MockedFunction<typeof getGlobalConfig>;
+const mockGetGlobalConfig = getGlobalConfig as jest.MockedFunction<
+  typeof getGlobalConfig
+>;
 
 function makeContext(overrides?: Partial<ModuleContext>): ModuleContext {
   return {
+    Events: {
+      log: jest.fn(),
+    } as any,
     Agents: {
       registerAgent: jest.fn(),
     } as any,
     Plugins: {
       registerPlugin: jest.fn(),
-      loadPluginsFromConfig: jest.fn().mockResolvedValue(undefined),
     } as any,
     Clients: {
       registerClient: jest.fn(),
@@ -87,7 +94,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const context = makeContext();
 
     // Mock require used inside loadModulesFromConfig
-    const requireSpy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const requireSpy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
@@ -113,26 +121,35 @@ describe("ModulesService.loadModulesFromConfig", () => {
     };
     const mockToolHandler = jest.fn();
     const mockModule = makeModule({
-      tools: [{ name: "myTool", handler: mockToolHandler, definition: mockToolDef }],
+      tools: [
+        { name: "myTool", handler: mockToolHandler, definition: mockToolDef },
+      ],
     });
 
     const service = new ModulesService();
     const context = makeContext();
 
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
         for (const tool of mockModule.tools) {
           resolvedCtx.Tools.addTool(tool.definition);
-          resolvedCtx.Tools.setFunction(tool.definition.function.name, tool.handler);
+          resolvedCtx.Tools.setFunction(
+            tool.definition.function.name,
+            tool.handler
+          );
         }
       });
 
     await service.loadModulesFromConfig(context);
 
     expect(context.Tools.addTool).toHaveBeenCalledWith(mockToolDef);
-    expect(context.Tools.setFunction).toHaveBeenCalledWith("myTool", mockToolHandler);
+    expect(context.Tools.setFunction).toHaveBeenCalledWith(
+      "myTool",
+      mockToolHandler
+    );
     spy.mockRestore();
   });
 
@@ -147,7 +164,9 @@ describe("ModulesService.loadModulesFromConfig", () => {
       embed: () => Promise.resolve([]),
     };
     // ModulePlugin expects a constructor (class), not an instance
-    const MockPluginClass = jest.fn().mockImplementation(() => mockPluginInstance);
+    const MockPluginClass = jest
+      .fn()
+      .mockImplementation(() => mockPluginInstance);
     const mockModule = makeModule({
       plugins: [{ name: "test-plugin", plugin: MockPluginClass as any }],
     });
@@ -155,7 +174,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const service = new ModulesService();
     const context = makeContext();
 
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
@@ -167,36 +187,17 @@ describe("ModulesService.loadModulesFromConfig", () => {
 
     await service.loadModulesFromConfig(context);
 
-    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith("test-plugin", mockPluginInstance);
+    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith(
+      "test-plugin",
+      mockPluginInstance
+    );
     spy.mockRestore();
   });
 
-  it("should call loadPluginsFromConfig with both global and local configs", async () => {
-    const localConfig = {
-      modules: [],
-      pluginPackages: { asana: "@knowhow/plugin-asana" },
-    } as unknown as Config;
-    const globalConfig = {
-      modules: [],
-      pluginPackages: { linear: "@knowhow/plugin-linear" },
-    } as unknown as Config;
-
-    mockGetConfig.mockResolvedValue(localConfig);
-    mockGetGlobalConfig.mockResolvedValue(globalConfig);
-
-    const service = new ModulesService();
-    const context = makeContext();
-
-    await service.loadModulesFromConfig(context);
-
-    // pluginService.loadPluginsFromConfig should be called twice: once for local, once for global
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledTimes(2);
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledWith(localConfig);
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledWith(globalConfig);
-  });
-
   it("should load modules from both global and local config paths", async () => {
-    const globalModule = makeModule({ agents: [{ name: "GlobalAgent" } as any] });
+    const globalModule = makeModule({
+      agents: [{ name: "GlobalAgent" } as any],
+    });
     const localModule = makeModule({ agents: [{ name: "LocalAgent" } as any] });
 
     mockGetConfig.mockResolvedValue({
@@ -210,7 +211,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const context = makeContext();
 
     const loadedPaths: string[] = [];
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         for (const [path, mod] of [