pi-llama-cpp 0.14.0 → 0.16.0

package/tests/{settings.test.ts → settings/settings.test.ts}

@@ -6,12 +6,17 @@ import {
   POLLING_TIMEOUT,
   PROVIDER_PREFIX,
   SERVER_TIMEOUT,
-} from "../src/constants";
-import type { ModelOverride } from "../src/interfaces/settings";
-import { settings } from "../src/managers/settings";
-import { Server } from "../src/server";
+} from "../../src/constants";
+import type { ModelOverride } from "../../src/interfaces/settings";
+import {
+  createSettingsManager,
+  type LlamaSettingsManager,
+} from "../../src/managers/settings";
+import { Server } from "../../src/server";
+
+let manager: LlamaSettingsManager;
 
-// Hoisted mock instances — survives vi.resetModules()
+// Hoisted mock instances
 const mockReadStoredCredential = vi.hoisted(() => vi.fn());
 
 const mockSettingsManager = vi.hoisted(() => ({
@@ -43,314 +48,117 @@ vi.mock("node:fs/promises", () => ({
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { access } from "node:fs/promises";
 
-describe("URL resolution fallback chain", () => {
-  const mockGetAgentDir = vi.mocked(getAgentDir);
-  const mockGetProjectSettings = vi.mocked(
-    mockSettingsManager.getProjectSettings,
-  );
-  const mockGetGlobalSettings = vi.mocked(
-    mockSettingsManager.getGlobalSettings,
-  );
-
-  afterEach(() => {
-    delete process.env.LLAMA_SERVER_URL;
-    vi.resetModules();
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    // Default: no settings found
-    mockGetProjectSettings.mockReturnValue({});
-    mockGetGlobalSettings.mockReturnValue({});
-  });
-
-  it("should return default URL when no config is found", async () => {
-    // Ensure env var is not set (and not inherited from environment)
-    delete process.env.LLAMA_SERVER_URL;
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual([LLAMA_SERVER_URL]);
-  });
-
-  it("should prioritize env variable over project config", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://localhost:9999",
-    });
-    process.env.LLAMA_SERVER_URL = "http://env-url:8080";
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://env-url:8080"]);
-  });
-
-  it("should use env variable when no other config exists", async () => {
-    process.env.LLAMA_SERVER_URL = "http://env-url:8080";
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://env-url:8080"]);
-  });
-
-  it("should use legacy llamaServerUrl when env is not set", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://project:9999",
-    });
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://project:9999"]);
-  });
-
-  it("should use global settings when no project config or env exists", async () => {
-    mockGetGlobalSettings.mockReturnValue({
-      llamaServerUrl: "http://global:8080",
-    });
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://global:8080"]);
-  });
-
-  it("should strip trailing slashes from resolved URL", async () => {
-    process.env.LLAMA_SERVER_URL = "http://localhost:8080/";
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://localhost:8080"]);
-  });
-
-  it("should cache the resolved URL on subsequent calls", async () => {
-    process.env.LLAMA_SERVER_URL = "http://first:8080";
-
-    const result1 = await settings.resolveUrls();
-    const result2 = await settings.resolveUrls();
-
-    expect(result1).toEqual(["http://first:8080"]);
-    expect(result2).toEqual(["http://first:8080"]);
-  });
-
-  it("should handle multiple URLs separated by semicolons", async () => {
-    process.env.LLAMA_SERVER_URL = "http://first:8080;http://second:9090/";
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://first:8080", "http://second:9090"]);
-  });
-
-  it("should drop env URLs without an http(s) scheme, warn, and fall through", async () => {
-    process.env.LLAMA_SERVER_URL = "127.0.0.1:8080";
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual([LLAMA_SERVER_URL]);
-    expect(settings.takeWarnings()).toEqual([
-      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
-    ]);
-    expect(settings.takeWarnings()).toEqual([]); // drained
-  });
-
-  it("should drop server entries without an http(s) scheme and warn", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "127.0.0.1:8080" }, { url: "http://good:8080/" }],
-      },
-    });
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual(["http://good:8080"]);
-    expect(settings.takeWarnings()).toEqual([
-      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
-    ]);
-    expect(settings.takeWarnings()).toEqual([]); // drained
-  });
-});
-
-describe("llamaSettings.servers resolution", () => {
+describe("API key resolution", () => {
   const mockGetAgentDir = vi.mocked(getAgentDir);
-  const mockGetProjectSettings = vi.mocked(
-    mockSettingsManager.getProjectSettings,
-  );
-  const mockGetGlobalSettings = vi.mocked(
-    mockSettingsManager.getGlobalSettings,
-  );
 
-  afterEach(() => {
-    delete process.env.LLAMA_SERVER_URL;
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    mockGetProjectSettings.mockReturnValue({});
-    mockGetGlobalSettings.mockReturnValue({});
-  });
-
-  it("should resolve URLs from llamaSettings.servers in project config", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [
-          { url: "http://project-server:8080" },
-          { url: "http://project-server2:9090" },
-        ],
-      },
-    });
-
-    const result = await settings.resolveUrls();
-
-    expect(result).toEqual([
-      "http://project-server:8080",
-      "http://project-server2:9090",
-    ]);
+    mockReadStoredCredential.mockReturnValue(undefined);
+    manager = createSettingsManager();
   });
 
-  it("should prioritize project servers over global servers", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://project:8080" }],
-      },
-    });
-    mockGetGlobalSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://global:9090" }],
-      },
-    });
+  it("should return placeholder when credential is not found", () => {
+    mockReadStoredCredential.mockReturnValue(undefined);
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://project:8080"]);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
-  it("should use global servers when no project servers exist", async () => {
-    mockGetGlobalSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://global:8080" }],
-      },
-    });
+  it("should return placeholder when apiKey is missing from credential", () => {
+    mockReadStoredCredential.mockReturnValue({});
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://global:8080"]);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
-  it("should prioritize env variable over servers", async () => {
-    process.env.LLAMA_SERVER_URL = "http://env:8080";
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should return the key when present in credential", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "test-api-key" });
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://env:8080"]);
+    expect(result).toEqual("test-api-key");
   });
 
-  it("should use servers when env is not set", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should call readStoredCredential with the provider ID", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "test-key" });
 
-    const result = await settings.resolveUrls();
+    manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://server:9090"]);
+    expect(mockReadStoredCredential).toHaveBeenCalledWith(
+      "llama-server=http://127.0.0.1:8080",
+    );
   });
 
-  it("should prioritize servers over legacy llamaServerUrl", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://legacy:8080",
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should resolve $VAR env reference from process.env", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$MY_API_KEY" });
+    process.env.MY_API_KEY = "env-resolved-key";
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://server:9090"]);
+    expect(result).toBe("env-resolved-key");
+    delete process.env.MY_API_KEY;
   });
 
-  it("should use legacy llamaServerUrl when servers is empty", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://legacy:8080",
-      llamaSettings: {
-        servers: [],
-      },
-    });
+  it("should resolve ${VAR} braced env reference from process.env", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "${MY_API_KEY}" });
+    process.env.MY_API_KEY = "braced-resolved-key";
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://legacy:8080"]);
+    expect(result).toBe("braced-resolved-key");
+    delete process.env.MY_API_KEY;
   });
 
-  it("should strip trailing slashes from server URLs", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://localhost:8080/" }],
-      },
+  it("should prefer credential.env over process.env", () => {
+    mockReadStoredCredential.mockReturnValue({
+      key: "$MY_KEY",
+      env: { MY_KEY: "credential-env-value" },
     });
+    process.env.MY_KEY = "process-env-value";
 
-    const result = await settings.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://localhost:8080"]);
+    expect(result).toBe("credential-env-value");
+    delete process.env.MY_KEY;
   });
-});
 
-describe("API key resolution", () => {
-  const mockGetAgentDir = vi.mocked(getAgentDir);
+  it("should return placeholder when env var is not set", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$UNSET_VAR" });
+    delete process.env.UNSET_VAR;
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    mockReadStoredCredential.mockReturnValue(undefined);
+    expect(result).toBe(API_KEY_PLACEHOLDER);
   });
 
-  it("should return placeholder when credential is not found", () => {
-    mockReadStoredCredential.mockReturnValue(undefined);
+  // Shell command tests are covered by Pi core's resolve-config-value tests.
+  // The local implementation delegates to execSync which is tested there.
 
-    const result = settings.resolveApiKey("llama-server=http://127.0.0.1:8080");
+  it("should escape $$ as literal $", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$$LITERAL" });
 
-    expect(result).toEqual(API_KEY_PLACEHOLDER);
-  });
-
-  it("should return placeholder when apiKey is missing from credential", () => {
-    mockReadStoredCredential.mockReturnValue({});
-
-    const result = settings.resolveApiKey("llama-server=http://127.0.0.1:8080");
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(API_KEY_PLACEHOLDER);
+    expect(result).toBe("$LITERAL");
   });
 
-  it("should return the key when present in credential", () => {
-    mockReadStoredCredential.mockReturnValue({ key: "test-api-key" });
-
-    const result = settings.resolveApiKey("llama-server=http://127.0.0.1:8080");
-
-    expect(result).toEqual("test-api-key");
-  });
-
-  it("should call readStoredCredential with the provider ID", () => {
-    mockReadStoredCredential.mockReturnValue({ key: "test-key" });
+  it("should escape $! as literal !", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$!LITERAL" });
 
-    settings.resolveApiKey("llama-server=http://127.0.0.1:8080");
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(mockReadStoredCredential).toHaveBeenCalledWith(
-      "llama-server=http://127.0.0.1:8080",
-    );
+    expect(result).toBe("!LITERAL");
   });
 });
 
 describe("Server with custom id", () => {
   it("should use custom id as providerId when provided", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       customId: "my-custom-id",
     });
@@ -359,7 +167,9 @@ describe("Server with custom id", () => {
   });
 
   it("should fall back to URL-based providerId when no custom id", () => {
-    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
+    const server = new Server(manager, {
+      baseUrl: "http://127.0.0.1:8080",
+    });
 
     expect(server.providerId).toEqual(
       `${PROVIDER_PREFIX}=http://127.0.0.1:8080`,
@@ -367,7 +177,7 @@ describe("Server with custom id", () => {
   });
 
   it("should try custom id first in getApiKey(), then fall back to URL-based", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       customId: "my-custom-id",
     });
@@ -380,7 +190,7 @@ describe("Server with custom id", () => {
       .mockReturnValueOnce(API_KEY_PLACEHOLDER)
       .mockReturnValueOnce({ key: "fallback-key" });
 
-    const result = server.getApiKey();
+    const result = server.apiKey;
 
     expect(result).toEqual("fallback-key");
     expect(mockReadStoredCredential).toHaveBeenNthCalledWith(1, "my-custom-id");
@@ -393,12 +203,12 @@ describe("Server with custom id", () => {
   it("should return custom id key directly when found", () => {
     mockReadStoredCredential.mockReturnValue({ key: "custom-key" });
 
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       customId: "my-custom-id",
     });
 
-    const result = server.getApiKey();
+    const result = server.apiKey;
 
     expect(result).toEqual("custom-key");
     expect(mockReadStoredCredential).toHaveBeenCalledWith("my-custom-id");
@@ -407,7 +217,7 @@ describe("Server with custom id", () => {
 
 describe("Server with custom name", () => {
   it("should use custom name as suffix in providerName", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       customName: "Remote Server",
     });
@@ -416,13 +226,15 @@ describe("Server with custom name", () => {
   });
 
   it("should fall back to URL-based name when no custom name", () => {
-    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
+    const server = new Server(manager, {
+      baseUrl: "http://127.0.0.1:8080",
+    });
 
     expect(server.providerName).toEqual(`Llama.cpp (http://127.0.0.1:8080)`);
   });
 
   it("should use custom name even with custom id", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       customId: "my-custom-id",
       customName: "Remote Server",
@@ -434,30 +246,22 @@ describe("Server with custom name", () => {
 });
 
 describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   it("should return true when reactToModelSelect is not set", async () => {
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveReactToModelSelect();
+    const result = await manager.resolveReactToModelSelect();
 
     expect(result).toBe(true);
   });
 
   it("should return false when autoloadOnMessage is not set", async () => {
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveAutoloadOnMessage();
+    const result = await manager.resolveAutoloadOnMessage();
 
     expect(result).toBe(false);
   });
 
   it("should return 'asc' when sortBy is not set", async () => {
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveSortBy();
+    const result = await manager.resolveSortBy();
 
     expect(result).toBe("asc");
   });
@@ -470,10 +274,72 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
       },
     });
 
-    const { settings } = await import("../src/managers/settings");
+    const manager = createSettingsManager();
+
+    expect(await manager.resolveReactToModelSelect()).toBe(false);
+    expect(await manager.resolveAutoloadOnMessage()).toBe(true);
+  });
+});
+
+describe("resolveShowServerUrls", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
+
+  afterEach(() => {});
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+    manager = createSettingsManager();
+  });
+
+  it("should return true (default) when showServerUrls is not set", async () => {
+    const result = await manager.resolveShowServerUrls();
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false when explicitly set to false", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        showServerUrls: false,
+      },
+    });
+
+    const manager = createSettingsManager();
 
-    expect(await settings.resolveReactToModelSelect()).toBe(false);
-    expect(await settings.resolveAutoloadOnMessage()).toBe(true);
+    expect(await manager.resolveShowServerUrls()).toBe(false);
+  });
+
+  it("should return true when explicitly set to true", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        showServerUrls: true,
+      },
+    });
+
+    const manager = createSettingsManager();
+
+    expect(await manager.resolveShowServerUrls()).toBe(true);
+  });
+
+  it("should use global settings when no project config exists", async () => {
+    mockGetGlobalSettings.mockReturnValue({
+      llamaSettings: {
+        showServerUrls: false,
+      },
+    });
+
+    const manager = createSettingsManager();
+
+    expect(await manager.resolveShowServerUrls()).toBe(false);
   });
 });
 
@@ -488,7 +354,6 @@ describe("resolveServers", () => {
 
   afterEach(() => {
     delete process.env.LLAMA_SERVER_URL;
-    vi.resetModules();
   });
 
   beforeEach(() => {
@@ -496,6 +361,7 @@ describe("resolveServers", () => {
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
     mockGetProjectSettings.mockReturnValue({});
     mockGetGlobalSettings.mockReturnValue({});
+    manager = createSettingsManager();
   });
 
   it("should use llamaSettings.servers when configured", async () => {
@@ -507,7 +373,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://custom:8080");
@@ -517,14 +383,14 @@ describe("resolveServers", () => {
   it("should fall back to resolveUrls when servers is empty", async () => {
     process.env.LLAMA_SERVER_URL = "http://env-server:9090";
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://env-server:9090");
   });
 
   it("should fall back to default URL when no config exists", async () => {
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe(LLAMA_SERVER_URL);
@@ -539,7 +405,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://127.0.0.1:8080");
@@ -555,7 +421,7 @@ describe("resolveServers", () => {
     });
     process.env.LLAMA_SERVER_URL = "http://first:8080;http://second:9090";
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(2);
     expect(result[0].baseUrl).toBe("http://first:8080");
@@ -572,7 +438,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     // env variable takes precedence via resolveUrls
     expect(result).toHaveLength(1);
@@ -581,14 +447,10 @@ describe("resolveServers", () => {
 });
 
 describe("resolveTimeouts", () => {
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   it("should return default timeouts when not configured", async () => {
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveTimeouts();
+    const result = await manager.resolveTimeouts();
 
     expect(result).toEqual({
       pollingTimeout: POLLING_TIMEOUT,
@@ -603,9 +465,7 @@ describe("resolveTimeouts", () => {
       },
     });
 
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveTimeouts();
+    const result = await manager.resolveTimeouts();
 
     expect(result.pollingTimeout).toBe(120000);
     expect(result.serverTimeout).toBe(SERVER_TIMEOUT);
@@ -618,9 +478,7 @@ describe("resolveTimeouts", () => {
       },
     });
 
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveTimeouts();
+    const result = await manager.resolveTimeouts();
 
     expect(result.pollingTimeout).toBe(POLLING_TIMEOUT);
     expect(result.serverTimeout).toBe(3000);
@@ -634,9 +492,7 @@ describe("resolveTimeouts", () => {
       },
     });
 
-    const { settings } = await import("../src/managers/settings");
-
-    const result = await settings.resolveTimeouts();
+    const result = await manager.resolveTimeouts();
 
     expect(result).toEqual({
       pollingTimeout: 90000,
@@ -648,21 +504,20 @@ describe("resolveTimeouts", () => {
 describe("Thinking config resolution", () => {
   const mockGetAgentDir = vi.mocked(getAgentDir);
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
     mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
     mockSettingsManager.getThinkingBudgets.mockReturnValue({});
+    manager = createSettingsManager();
   });
 
   it("should return the default thinking level from SettingsManager", () => {
     mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("low");
 
-    const result = settings.resolveThinkingLevel();
+    const result = manager.resolveThinkingLevel();
 
     expect(result).toEqual("low");
   });
@@ -672,7 +527,7 @@ describe("Thinking config resolution", () => {
       low: 4096,
     });
 
-    const result = settings.resolveThinkingBudgets();
+    const result = manager.resolveThinkingBudgets();
 
     expect(result).toEqual(
       expect.objectContaining({
@@ -706,9 +561,7 @@ describe("setLlamaSetting", () => {
   const PROJECT_SETTINGS_PATH = "/fake/project/.pi/settings.json";
   const FAKE_CWD = "/fake/project";
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -720,14 +573,14 @@ describe("setLlamaSetting", () => {
     mockReadFile.mockResolvedValue("{}");
     mockWriteFile.mockResolvedValue(undefined);
     mockRename.mockResolvedValue(undefined);
+    manager = createSettingsManager();
   });
 
   it("should write to project settings when .pi/settings.json exists (auto scope)", async () => {
     mockAccess.mockResolvedValue(undefined);
     mockReadFile.mockResolvedValue("{}");
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc");
+    await manager.setLlamaSetting("sortBy", "desc");
 
     expect(mockWriteFile).toHaveBeenCalledWith(
       `${PROJECT_SETTINGS_PATH}.tmp`,
@@ -744,8 +597,7 @@ describe("setLlamaSetting", () => {
     mockAccess.mockRejectedValue(new Error("ENOENT"));
     mockReadFile.mockResolvedValue("{}");
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc");
+    await manager.setLlamaSetting("sortBy", "desc");
 
     expect(mockWriteFile).toHaveBeenCalledWith(
       `${GLOBAL_SETTINGS_PATH}.tmp`,
@@ -762,8 +614,7 @@ describe("setLlamaSetting", () => {
     mockAccess.mockResolvedValue(undefined); // project exists but we override
     mockReadFile.mockResolvedValue("{}");
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc", "global");
+    await manager.setLlamaSetting("sortBy", "desc", "global");
 
     expect(mockWriteFile).toHaveBeenCalledWith(
       `${GLOBAL_SETTINGS_PATH}.tmp`,
@@ -776,8 +627,7 @@ describe("setLlamaSetting", () => {
     mockAccess.mockRejectedValue(new Error("ENOENT")); // project doesn't exist but we override
     mockReadFile.mockResolvedValue("{}");
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc", "project");
+    await manager.setLlamaSetting("sortBy", "desc", "project");
 
     expect(mockWriteFile).toHaveBeenCalledWith(
       `${PROJECT_SETTINGS_PATH}.tmp`,
@@ -796,8 +646,7 @@ describe("setLlamaSetting", () => {
       ),
     );
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc");
+    await manager.setLlamaSetting("sortBy", "desc");
 
     expect(mockWriteFile).toHaveBeenCalledTimes(1);
     const [tmpPath, written, encoding] = mockWriteFile.mock.calls[0];
@@ -815,9 +664,7 @@ describe("setLlamaSetting", () => {
     expect(mockReload).toHaveBeenCalledTimes(1);
   });
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   it("should reflect the new value in resolvers immediately after the write", async () => {
     mockSettingsManager.reload.mockImplementation(async () => {
@@ -826,18 +673,16 @@ describe("setLlamaSetting", () => {
       });
     });
 
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("sortBy", "desc");
+    await manager.setLlamaSetting("sortBy", "desc");
 
-    expect(await settings.resolveSortBy()).toBe("desc");
+    expect(await manager.resolveSortBy()).toBe("desc");
   });
 
   it("should reject and skip reload when the write fails", async () => {
     mockAccess.mockRejectedValue(new Error("ENOENT"));
     mockWriteFile.mockRejectedValue(new Error("ENOSPC: simulated"));
 
-    const { settings } = await import("../src/managers/settings");
-    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+    await expect(manager.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
       "ENOSPC",
     );
     expect(mockReload).not.toHaveBeenCalled();
@@ -847,8 +692,7 @@ describe("setLlamaSetting", () => {
     mockAccess.mockRejectedValue(new Error("ENOENT"));
     mockReadFile.mockResolvedValue("{ broken");
 
-    const { settings } = await import("../src/managers/settings");
-    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+    await expect(manager.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
       /Cannot parse/,
     );
     expect(mockWriteFile).not.toHaveBeenCalled();
@@ -857,15 +701,15 @@ describe("setLlamaSetting", () => {
 
   it("should persist booleans and numbers with type fidelity", async () => {
     mockAccess.mockRejectedValue(new Error("ENOENT"));
-    const { settings } = await import("../src/managers/settings");
-    await settings.setLlamaSetting("reactToModelSelect", false);
+
+    await manager.setLlamaSetting("reactToModelSelect", false);
 
     const [, firstWrite] = mockWriteFile.mock.calls[0];
     expect(JSON.parse(firstWrite as string)).toEqual({
       llamaSettings: { reactToModelSelect: false },
     });
 
-    await settings.setLlamaSetting("pollingTimeout", 120000);
+    await manager.setLlamaSetting("pollingTimeout", 120000);
 
     const [, secondWrite] = mockWriteFile.mock.calls[1];
     expect(JSON.parse(secondWrite as string)).toEqual({
@@ -874,7 +718,8 @@ describe("setLlamaSetting", () => {
   });
 
   it("should still construct the manager without arguments", async () => {
-    const { LlamaSettingsManager } = await import("../src/managers/settings");
+    const { LlamaSettingsManager } =
+      await import("../../src/managers/settings");
 
     expect(() => new LlamaSettingsManager()).not.toThrow();
   });
@@ -889,15 +734,14 @@ describe("resolveServerOverrides", () => {
     mockSettingsManager.getGlobalSettings,
   );
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
     mockGetProjectSettings.mockReturnValue({});
     mockGetGlobalSettings.mockReturnValue({});
+    manager = createSettingsManager();
   });
 
   it("should return overrides for a server that has them configured", async () => {
@@ -922,7 +766,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -946,7 +790,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -960,7 +804,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -979,7 +823,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides("http://global:8080");
+    const result = await manager.resolveServerOverrides("http://global:8080");
 
     expect(result).toEqual({ "model-a": { cost: { input: 0.5 } } });
   });
@@ -1006,7 +850,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides("http://shared:8080");
+    const result = await manager.resolveServerOverrides("http://shared:8080");
 
     expect(result).toEqual({
       "model-b": { cost: { input: 0.1, output: 0.2 } },
@@ -1018,7 +862,7 @@ describe("resolveServerOverrides", () => {
       llamaSettings: { servers: [] },
     });
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -1028,7 +872,7 @@ describe("resolveServerOverrides", () => {
   it("should return empty object when llamaSettings is missing", async () => {
     mockGetProjectSettings.mockReturnValue({});
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -1047,7 +891,7 @@ describe("resolveServerOverrides", () => {
       },
     });
 
-    const result = await settings.resolveServerOverrides(
+    const result = await manager.resolveServerOverrides(
       "http://127.0.0.1:8080",
     );
 
@@ -1057,7 +901,7 @@ describe("resolveServerOverrides", () => {
 
 describe("Server with overrides", () => {
   it("should store and expose resolved overrides", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
       overrides: {
         "model-a": { cost: { input: 0.2, output: 0.6 } },
@@ -1074,7 +918,7 @@ describe("Server with overrides", () => {
   });
 
   it("should return undefined for findOverrideForModel when no overrides are provided", () => {
-    const server = new Server(settings, {
+    const server = new Server(manager, {
       baseUrl: "http://127.0.0.1:8080",
     });
 
@@ -1091,15 +935,14 @@ describe("resolveServers passes overrides", () => {
     mockSettingsManager.getGlobalSettings,
   );
 
-  afterEach(() => {
-    vi.resetModules();
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
     mockGetProjectSettings.mockReturnValue({});
     mockGetGlobalSettings.mockReturnValue({});
+    manager = createSettingsManager();
   });
 
   it("should pass resolved overrides to Server instances", async () => {
@@ -1117,7 +960,7 @@ describe("resolveServers passes overrides", () => {
       },
     });
 
-    const result = await settings.resolveServers();
+    const result = await manager.resolveServers();
 
     expect(result).toHaveLength(2);
     expect(result[0].findOverrideForModel("model-x")).toEqual({
@@ -1129,7 +972,7 @@ describe("resolveServers passes overrides", () => {
 
 describe("Server.findOverrideForModel", () => {
   function createServer(overrides: Record<string, ModelOverride>): Server {
-    return new Server(settings as any, {
+    return new Server(createSettingsManager() as any, {
       baseUrl: "http://127.0.0.1:8080",
       overrides,
     });