@gotgenes/pi-permission-system 10.2.0 → 10.3.0

package/test/config-store.test.ts

@@ -0,0 +1,452 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── Module mocks (hoisted) ─────────────────────────────────────────────────
+
+const {
+  mockLoadAndMergeConfigs,
+  mockLoadUnifiedConfig,
+  mockSyncPermissionSystemStatus,
+  mockBuildResolvedConfigLogEntry,
+  mockExistsSync,
+  mockMkdirSync,
+  mockWriteFileSync,
+  mockRenameSync,
+  mockUnlinkSync,
+} = vi.hoisted(() => ({
+  mockLoadAndMergeConfigs: vi.fn(),
+  mockLoadUnifiedConfig: vi.fn(),
+  mockSyncPermissionSystemStatus: vi.fn(),
+  mockBuildResolvedConfigLogEntry: vi.fn(),
+  mockExistsSync: vi.fn<(path: string) => boolean>(),
+  mockMkdirSync: vi.fn(),
+  mockWriteFileSync: vi.fn(),
+  mockRenameSync: vi.fn(),
+  mockUnlinkSync: vi.fn(),
+}));
+
+vi.mock("../src/config-loader", () => ({
+  loadAndMergeConfigs: mockLoadAndMergeConfigs,
+  loadUnifiedConfig: mockLoadUnifiedConfig,
+}));
+
+vi.mock("../src/status", () => ({
+  syncPermissionSystemStatus: mockSyncPermissionSystemStatus,
+}));
+
+vi.mock("../src/config-reporter", () => ({
+  buildResolvedConfigLogEntry: mockBuildResolvedConfigLogEntry,
+}));
+
+vi.mock("node:fs", () => ({
+  existsSync: mockExistsSync,
+  mkdirSync: mockMkdirSync,
+  writeFileSync: mockWriteFileSync,
+  renameSync: mockRenameSync,
+  unlinkSync: mockUnlinkSync,
+  default: {
+    existsSync: mockExistsSync,
+    mkdirSync: mockMkdirSync,
+    writeFileSync: mockWriteFileSync,
+    renameSync: mockRenameSync,
+    unlinkSync: mockUnlinkSync,
+  },
+}));
+
+// ── Imports ────────────────────────────────────────────────────────────────
+
+import type {
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  ConfigStore,
+  type ConfigStoreDeps,
+  type ResolvedPolicyPathProvider,
+  type RuntimeContextRef,
+} from "#src/config-store";
+import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
+import type { ResolvedPolicyPaths } from "#src/policy-loader";
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function makeContextRef(
+  initialCtx: ExtensionContext | null = null,
+): RuntimeContextRef & { _ctx: ExtensionContext | null } {
+  const ref = {
+    _ctx: initialCtx,
+    get: () => ref._ctx,
+    set: (ctx: ExtensionContext) => {
+      ref._ctx = ctx;
+    },
+  };
+  return ref;
+}
+
+function makePolicyPathProvider(
+  paths?: Partial<ResolvedPolicyPaths>,
+): ResolvedPolicyPathProvider {
+  return {
+    getResolvedPolicyPaths: vi.fn(
+      (): ResolvedPolicyPaths => ({
+        globalConfigPath: "/agent/config.json",
+        globalConfigExists: false,
+        projectConfigPath: null,
+        projectConfigExists: false,
+        agentsDir: "/agent/agents",
+        agentsDirExists: false,
+        projectAgentsDir: null,
+        projectAgentsDirExists: false,
+        ...paths,
+      }),
+    ),
+  };
+}
+
+function makeLogger() {
+  return {
+    writeDebugLog:
+      vi.fn<(event: string, details?: Record<string, unknown>) => void>(),
+    writeReviewLog:
+      vi.fn<(event: string, details?: Record<string, unknown>) => void>(),
+  };
+}
+
+function makeCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+  return {
+    cwd: "/test/project",
+    hasUI: false,
+    ui: { notify: vi.fn(), setStatus: vi.fn() },
+    sessionManager: { getEntries: vi.fn(), addEntry: vi.fn() },
+    ...overrides,
+  } as unknown as ExtensionContext;
+}
+
+function makeCommandCtx(
+  overrides: Partial<ExtensionCommandContext> = {},
+): ExtensionCommandContext {
+  return {
+    cwd: "/test/project",
+    ui: { notify: vi.fn(), setStatus: vi.fn() },
+    ...overrides,
+  } as unknown as ExtensionCommandContext;
+}
+
+function makeStore(overrides: Partial<ConfigStoreDeps> = {}): {
+  store: ConfigStore;
+  contextRef: RuntimeContextRef & { _ctx: ExtensionContext | null };
+  logger: ReturnType<typeof makeLogger>;
+} {
+  const contextRef = makeContextRef();
+  const logger = makeLogger();
+  const deps: ConfigStoreDeps = {
+    agentDir: "/test/agent",
+    context: contextRef,
+    policyPaths: makePolicyPathProvider(),
+    logger,
+    ...overrides,
+  };
+  return { store: new ConfigStore(deps), contextRef, logger };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+describe("ConfigStore", () => {
+  beforeEach(() => {
+    mockLoadAndMergeConfigs.mockReset().mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: [],
+    });
+    mockLoadUnifiedConfig.mockReset().mockReturnValue({ config: {} });
+    mockSyncPermissionSystemStatus.mockReset();
+    mockBuildResolvedConfigLogEntry
+      .mockReset()
+      .mockReturnValue({ resolved: true });
+    mockExistsSync.mockReset().mockReturnValue(false);
+    mockMkdirSync.mockReset();
+    mockWriteFileSync.mockReset();
+    mockRenameSync.mockReset();
+    mockUnlinkSync.mockReset();
+  });
+
+  // ── current() ─────────────────────────────────────────────────────────
+
+  describe("current()", () => {
+    it("returns DEFAULT_EXTENSION_CONFIG before any refresh", () => {
+      const { store } = makeStore();
+      expect(store.current()).toEqual(DEFAULT_EXTENSION_CONFIG);
+    });
+  });
+
+  // ── refresh() ─────────────────────────────────────────────────────────
+
+  describe("refresh()", () => {
+    it("calls loadAndMergeConfigs with agentDir and cwd from context", () => {
+      const { store, contextRef } = makeStore();
+      contextRef._ctx = makeCtx({ cwd: "/my/project" });
+      store.refresh();
+      expect(mockLoadAndMergeConfigs).toHaveBeenCalledWith(
+        "/test/agent",
+        "/my/project",
+        expect.any(String),
+      );
+    });
+
+    it("updates context via context.set when ctx is provided", () => {
+      const { store, contextRef } = makeStore();
+      const ctx = makeCtx({ cwd: "/new/project" });
+      store.refresh(ctx);
+      expect(contextRef._ctx).toBe(ctx);
+    });
+
+    it("does not overwrite context when ctx is omitted", () => {
+      const { store, contextRef } = makeStore();
+      const existing = makeCtx();
+      contextRef._ctx = existing;
+      store.refresh();
+      expect(contextRef._ctx).toBe(existing);
+    });
+
+    it("updates current() with normalized merged result", () => {
+      const { store } = makeStore();
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { debugLog: true, permissionReviewLog: false, yoloMode: false },
+        issues: [],
+      });
+      store.refresh();
+      expect(store.current().debugLog).toBe(true);
+      expect(store.current().permissionReviewLog).toBe(false);
+    });
+
+    it("writes config.loaded debug log", () => {
+      const { store, logger } = makeStore();
+      store.refresh();
+      expect(logger.writeDebugLog).toHaveBeenCalledWith(
+        "config.loaded",
+        expect.objectContaining({ debugLog: false }),
+      );
+    });
+
+    it("sets warning when issues are present", () => {
+      const { store } = makeStore();
+      const ctx = makeCtx({ hasUI: false });
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["legacy config detected"],
+      });
+      store.refresh(ctx);
+      // Verify the warning is tracked (next identical call should not re-notify)
+      const mockNotify = vi.fn();
+      const ctx2 = makeCtx({
+        hasUI: true,
+        ui: { notify: mockNotify } as never,
+      });
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["legacy config detected"],
+      });
+      store.refresh(ctx2);
+      // Same warning — should not re-notify
+      expect(mockNotify).not.toHaveBeenCalled();
+    });
+
+    it("notifies UI when a new warning appears and hasUI is true", () => {
+      const mockNotify = vi.fn();
+      const { store } = makeStore();
+      const ctx = makeCtx({ hasUI: true, ui: { notify: mockNotify } as never });
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["new warning"],
+      });
+      store.refresh(ctx);
+      expect(mockNotify).toHaveBeenCalledWith("new warning", "warning");
+    });
+
+    it("does not re-notify the same warning on subsequent calls", () => {
+      const mockNotify = vi.fn();
+      const { store } = makeStore();
+      const ctx = makeCtx({ hasUI: true, ui: { notify: mockNotify } as never });
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["persistent warning"],
+      });
+      store.refresh(ctx);
+      store.refresh(ctx);
+      expect(mockNotify).toHaveBeenCalledTimes(1);
+    });
+
+    it("clears warning when no issues on next refresh", () => {
+      const mockNotify = vi.fn();
+      const { store } = makeStore();
+      // First call: set a warning
+      const ctxWithUI = makeCtx({
+        hasUI: true,
+        ui: { notify: mockNotify } as never,
+      });
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["warning"],
+      });
+      store.refresh(ctxWithUI);
+      // Second call: no issues — warning should clear
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: [],
+      });
+      store.refresh();
+      // Third call: same warning reappears — should notify again (dedup cleared)
+      mockLoadAndMergeConfigs.mockReturnValue({
+        merged: { ...DEFAULT_EXTENSION_CONFIG },
+        issues: ["warning"],
+      });
+      store.refresh(ctxWithUI);
+      expect(mockNotify).toHaveBeenCalledTimes(2);
+    });
+
+    it("calls syncPermissionSystemStatus when hasUI is true", () => {
+      const { store } = makeStore();
+      const ctx = makeCtx({ hasUI: true });
+      store.refresh(ctx);
+      expect(mockSyncPermissionSystemStatus).toHaveBeenCalledWith(
+        ctx,
+        expect.any(Object),
+      );
+    });
+
+    it("does not call syncPermissionSystemStatus when hasUI is false", () => {
+      const { store } = makeStore();
+      const ctx = makeCtx({ hasUI: false });
+      store.refresh(ctx);
+      expect(mockSyncPermissionSystemStatus).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── save() ─────────────────────────────────────────────────────────────
+
+  describe("save()", () => {
+    it("writes merged config to the global path", () => {
+      const { store } = makeStore();
+      mockLoadUnifiedConfig.mockReturnValue({
+        config: { permission: { "*": "ask" } },
+      });
+      const next = { ...DEFAULT_EXTENSION_CONFIG, debugLog: true };
+      const ctx = makeCommandCtx();
+      store.save(next, ctx);
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        expect.stringContaining(".tmp"),
+        expect.stringContaining('"debugLog": true'),
+        "utf-8",
+      );
+      expect(mockRenameSync).toHaveBeenCalled();
+    });
+
+    it("updates current() after a successful save", () => {
+      const { store } = makeStore();
+      const next = { ...DEFAULT_EXTENSION_CONFIG, debugLog: true };
+      store.save(next, makeCommandCtx());
+      expect(store.current().debugLog).toBe(true);
+    });
+
+    it("calls syncPermissionSystemStatus after a successful save", () => {
+      const { store } = makeStore();
+      const ctx = makeCommandCtx();
+      store.save({ ...DEFAULT_EXTENSION_CONFIG }, ctx);
+      expect(mockSyncPermissionSystemStatus).toHaveBeenCalledWith(
+        ctx,
+        expect.any(Object),
+      );
+    });
+
+    it("writes config.saved debug log after a successful save", () => {
+      const { store, logger } = makeStore();
+      store.save({ ...DEFAULT_EXTENSION_CONFIG }, makeCommandCtx());
+      expect(logger.writeDebugLog).toHaveBeenCalledWith(
+        "config.saved",
+        expect.objectContaining({ debugLog: false }),
+      );
+    });
+
+    it("notifies with error and returns early when write fails", () => {
+      const mockNotify = vi.fn();
+      const ctx = makeCommandCtx({ ui: { notify: mockNotify } as never });
+      const { store, logger } = makeStore();
+      mockMkdirSync.mockImplementation(() => {
+        throw new Error("disk full");
+      });
+      store.save({ ...DEFAULT_EXTENSION_CONFIG }, ctx);
+      expect(mockNotify).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to save"),
+        "error",
+      );
+      // current() is not updated on failure
+      expect(store.current()).toEqual(DEFAULT_EXTENSION_CONFIG);
+      // no debug log on failure
+      expect(logger.writeDebugLog).not.toHaveBeenCalledWith(
+        "config.saved",
+        expect.anything(),
+      );
+    });
+
+    it("attempts cleanup of tmp file when write fails and tmp exists", () => {
+      const ctx = makeCommandCtx();
+      const { store } = makeStore();
+      mockMkdirSync.mockImplementation(() => {
+        throw new Error("disk full");
+      });
+      mockExistsSync.mockReturnValue(true);
+      store.save({ ...DEFAULT_EXTENSION_CONFIG }, ctx);
+      expect(mockUnlinkSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── logResolvedPaths() ─────────────────────────────────────────────────
+
+  describe("logResolvedPaths()", () => {
+    it("writes config.resolved to both review and debug logs", () => {
+      const { store, logger } = makeStore();
+      store.logResolvedPaths();
+      expect(logger.writeReviewLog).toHaveBeenCalledWith(
+        "config.resolved",
+        expect.any(Object),
+      );
+      expect(logger.writeDebugLog).toHaveBeenCalledWith(
+        "config.resolved",
+        expect.any(Object),
+      );
+    });
+
+    it("calls getResolvedPolicyPaths from the provider", () => {
+      const mockProvider = makePolicyPathProvider();
+      const { store } = makeStore({ policyPaths: mockProvider });
+      store.logResolvedPaths();
+      expect(mockProvider.getResolvedPolicyPaths).toHaveBeenCalled();
+    });
+
+    it("passes legacy detection results to buildResolvedConfigLogEntry", () => {
+      const { store, contextRef } = makeStore();
+      contextRef._ctx = makeCtx({ cwd: "/some/project" });
+      // Make one legacy path exist
+      mockExistsSync.mockImplementation((p: string) =>
+        p.includes("policies.json"),
+      );
+      store.logResolvedPaths();
+      expect(mockBuildResolvedConfigLogEntry).toHaveBeenCalledWith(
+        expect.objectContaining({
+          legacyGlobalPolicyDetected: expect.any(Boolean),
+          legacyProjectPolicyDetected: expect.any(Boolean),
+          legacyExtensionConfigDetected: expect.any(Boolean),
+        }),
+      );
+    });
+
+    it("does not check project legacy path when context has no cwd", () => {
+      const { store } = makeStore(); // contextRef._ctx = null
+      store.logResolvedPaths();
+      // existsSync called for global and ext-config legacy paths only (not project)
+      const calls = mockExistsSync.mock.calls.map(([p]: [string]) => p);
+      const projectCalls = calls.filter(
+        (p) => p.includes("/null/") || p.includes("null"),
+      );
+      expect(projectCalls).toHaveLength(0);
+    });
+  });
+});

package/test/permission-prompter.test.ts

@@ -7,6 +7,7 @@ const mockRequestApproval = vi.fn();
 // ── Imports ─────────────────────────────────────────────────────────────────
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ConfigReader } from "#src/config-store";
 import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
 import type { PermissionPromptDecision } from "#src/permission-dialog";
 import type { PromptPermissionDetails } from "#src/permission-prompter";
@@ -38,11 +39,17 @@ function makeDetails(
   };
 }
 
+function makeConfigReader(
+  config: Partial<typeof DEFAULT_EXTENSION_CONFIG> = {},
+): ConfigReader {
+  return { current: () => ({ ...DEFAULT_EXTENSION_CONFIG, ...config }) };
+}
+
 function makeDeps(
   overrides?: Partial<PermissionPrompterDeps>,
 ): PermissionPrompterDeps {
   return {
-    getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: false }),
+    config: makeConfigReader(),
     writeReviewLog: vi.fn(),
     events: { emit: vi.fn(), on: vi.fn().mockReturnValue(() => undefined) },
     forwarder: { requestApproval: mockRequestApproval },
@@ -70,7 +77,7 @@ describe("PermissionPrompter", () => {
         on: vi.fn().mockReturnValue(() => undefined),
       };
       const deps = makeDeps({
-        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        config: makeConfigReader({ yoloMode: true }),
         events,
       });
       const prompter = new PermissionPrompter(deps);
@@ -92,7 +99,7 @@ describe("PermissionPrompter", () => {
     it("logs permission_request.auto_approved in yolo mode", async () => {
       const writeReviewLog = vi.fn();
       const deps = makeDeps({
-        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        config: makeConfigReader({ yoloMode: true }),
         writeReviewLog,
       });
       const prompter = new PermissionPrompter(deps);
@@ -108,7 +115,7 @@ describe("PermissionPrompter", () => {
     it("does not log permission_request.waiting in yolo mode", async () => {
       const writeReviewLog = vi.fn();
       const deps = makeDeps({
-        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        config: makeConfigReader({ yoloMode: true }),
         writeReviewLog,
       });
       const prompter = new PermissionPrompter(deps);
@@ -123,7 +130,7 @@ describe("PermissionPrompter", () => {
 
     it("does not call confirmPermission with yoloMode even when ctx has UI", async () => {
       const deps = makeDeps({
-        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        config: makeConfigReader({ yoloMode: true }),
       });
       const prompter = new PermissionPrompter(deps);
 

package/test/permission-session.test.ts

@@ -17,6 +17,8 @@ vi.mock("../src/active-agent", () => ({
 
 // ── Test helpers ───────────────────────────────────────────────────────────
 
+import type { SessionConfigStore } from "#src/config-store";
+import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
 import type { ExtensionPaths } from "#src/extension-paths";
 import type { ForwardingController } from "#src/forwarding-manager";
 import type { ScopedPermissionManager } from "#src/permission-manager";
@@ -66,11 +68,22 @@ function makeLogger(): SessionLogger {
   };
 }
 
+function makeConfigStore(
+  overrides: Partial<SessionConfigStore> = {},
+): SessionConfigStore {
+  return {
+    current:
+      overrides.current ??
+      vi
+        .fn<() => typeof DEFAULT_EXTENSION_CONFIG>()
+        .mockReturnValue({ ...DEFAULT_EXTENSION_CONFIG }),
+    refresh: overrides.refresh ?? vi.fn<(ctx?: ExtensionContext) => void>(),
+    logResolvedPaths: overrides.logResolvedPaths ?? vi.fn<() => void>(),
+  };
+}
+
 function makeRuntimeDeps(): PermissionSessionRuntimeDeps {
   return {
-    refreshExtensionConfig: vi.fn(),
-    logResolvedConfigPaths: vi.fn(),
-    getConfig: vi.fn().mockReturnValue({}),
     canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
     promptPermission: vi
       .fn()
@@ -116,12 +129,14 @@ function createSession(overrides?: {
   logger?: SessionLogger;
   forwarding?: ForwardingController;
   permissionManager?: ScopedPermissionManager;
+  configStore?: SessionConfigStore;
   runtimeDeps?: PermissionSessionRuntimeDeps;
 }): {
   session: PermissionSession;
   paths: ExtensionPaths;
   logger: SessionLogger;
   forwarding: ForwardingController;
+  configStore: SessionConfigStore;
   runtimeDeps: PermissionSessionRuntimeDeps;
 } {
   const paths = makePaths(overrides?.paths);
@@ -129,15 +144,17 @@ function createSession(overrides?: {
   const forwarding = overrides?.forwarding ?? makeForwarding();
   const permissionManager =
     overrides?.permissionManager ?? makePermissionManager();
+  const configStore = overrides?.configStore ?? makeConfigStore();
   const runtimeDeps = overrides?.runtimeDeps ?? makeRuntimeDeps();
   const session = new PermissionSession(
     paths,
     logger,
     forwarding,
     permissionManager,
+    configStore,
     runtimeDeps,
   );
-  return { session, paths, logger, forwarding, runtimeDeps };
+  return { session, paths, logger, forwarding, configStore, runtimeDeps };
 }
 
 // ── Tests ──────────────────────────────────────────────────────────────────
@@ -484,11 +501,12 @@ describe("PermissionSession", () => {
 
   describe("infrastructure paths", () => {
     it("getInfrastructureReadDirs combines piInfrastructureDirs and piInfrastructureReadPaths", () => {
-      const runtimeDeps = makeRuntimeDeps();
-      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue({
-        piInfrastructureReadPaths: ["/extra/path"],
+      const configStore = makeConfigStore({
+        current: vi.fn().mockReturnValue({
+          piInfrastructureReadPaths: ["/extra/path"],
+        }),
       });
-      const { session } = createSession({ runtimeDeps });
+      const { session } = createSession({ configStore });
       expect(session.getInfrastructureReadDirs()).toEqual([
         "/test/agent",
         "/test/agent/git",
@@ -506,36 +524,36 @@ describe("PermissionSession", () => {
   });
 
   describe("config delegation", () => {
-    it("refreshConfig delegates to runtimeDeps", () => {
-      const { session, runtimeDeps } = createSession();
+    it("refreshConfig delegates to configStore.refresh", () => {
+      const { session, configStore } = createSession();
       const ctx = makeCtx();
       session.refreshConfig(ctx);
-      expect(runtimeDeps.refreshExtensionConfig).toHaveBeenCalledWith(ctx);
+      expect(configStore.refresh).toHaveBeenCalledWith(ctx);
     });
 
-    it("logResolvedConfigPaths delegates to runtimeDeps", () => {
-      const { session, runtimeDeps } = createSession();
+    it("logResolvedConfigPaths delegates to configStore.logResolvedPaths", () => {
+      const { session, configStore } = createSession();
       session.logResolvedConfigPaths();
-      expect(runtimeDeps.logResolvedConfigPaths).toHaveBeenCalled();
+      expect(configStore.logResolvedPaths).toHaveBeenCalled();
     });
 
-    it("config getter delegates to runtimeDeps.getConfig", () => {
-      const runtimeDeps = makeRuntimeDeps();
-      const fakeConfig = { debugLog: true };
-      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue(
-        fakeConfig,
-      );
-      const { session } = createSession({ runtimeDeps });
+    it("config getter delegates to configStore.current()", () => {
+      const fakeConfig = { debugLog: true } as typeof DEFAULT_EXTENSION_CONFIG;
+      const configStore = makeConfigStore({
+        current: vi.fn().mockReturnValue(fakeConfig),
+      });
+      const { session } = createSession({ configStore });
       expect(session.config).toBe(fakeConfig);
     });
 
     it("getToolPreviewLimits returns resolved preview limits from config", () => {
-      const runtimeDeps = makeRuntimeDeps();
-      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue({
-        toolInputPreviewMaxLength: 400,
-        toolTextSummaryMaxLength: 120,
+      const configStore = makeConfigStore({
+        current: vi.fn().mockReturnValue({
+          toolInputPreviewMaxLength: 400,
+          toolTextSummaryMaxLength: 120,
+        }),
       });
-      const { session } = createSession({ runtimeDeps });
+      const { session } = createSession({ configStore });
       const limits = session.getToolPreviewLimits();
       expect(limits.toolInputPreviewMaxLength).toBe(400);
       expect(limits.toolTextSummaryMaxLength).toBe(120);