@gotgenes/pi-permission-system 3.7.0 → 3.9.0

package/tests/handlers/lifecycle.test.ts

@@ -7,6 +7,7 @@ import {
 } from "../../src/handlers/lifecycle";
 import type { HandlerDeps } from "../../src/handlers/types";
 import type { PermissionManager } from "../../src/permission-manager";
+import type { ExtensionRuntime } from "../../src/runtime";
 import type { SessionApprovalCache } from "../../src/session-approval-cache";
 import type { SkillPromptEntry } from "../../src/skill-prompt-sanitizer";
 
@@ -67,22 +68,36 @@ function makeSessionApprovalCache(): SessionApprovalCache {
   } as unknown as SessionApprovalCache;
 }
 
-function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
-  const pm = makePermissionManager();
+function makeRuntime(
+  overrides: Partial<ExtensionRuntime> = {},
+): ExtensionRuntime {
   return {
-    getPermissionManager: vi.fn().mockReturnValue(pm),
-    setPermissionManager: vi.fn(),
-    getRuntimeContext: vi.fn().mockReturnValue(null),
-    setRuntimeContext: vi.fn(),
-    getActiveSkillEntries: vi.fn().mockReturnValue([] as SkillPromptEntry[]),
-    setActiveSkillEntries: vi.fn(),
-    getLastKnownActiveAgentName: vi.fn().mockReturnValue(null),
-    setLastKnownActiveAgentName: vi.fn(),
-    getLastActiveToolsCacheKey: vi.fn().mockReturnValue(null),
-    setLastActiveToolsCacheKey: vi.fn(),
-    getLastPromptStateCacheKey: vi.fn().mockReturnValue(null),
-    setLastPromptStateCacheKey: vi.fn(),
+    agentDir: "/test/agent",
+    sessionsDir: "/test/agent/sessions",
+    subagentSessionsDir: "/test/agent/subagent-sessions",
+    forwardingDir: "/test/agent/sessions/permission-forwarding",
+    globalLogsDir: "/test/agent/extensions/pi-permission-system/logs",
+    config: { debugLog: false, permissionReviewLog: true, yoloMode: false },
+    runtimeContext: null,
+    permissionManager: makePermissionManager() as unknown as PermissionManager,
+    activeSkillEntries: [] as SkillPromptEntry[],
+    lastKnownActiveAgentName: null,
+    lastActiveToolsCacheKey: null,
+    lastPromptStateCacheKey: null,
+    lastConfigWarning: null,
     sessionApprovalCache: makeSessionApprovalCache(),
+    permissionForwardingContext: null,
+    permissionForwardingTimer: null,
+    isProcessingForwardedRequests: false,
+    writeDebugLog: vi.fn(),
+    writeReviewLog: vi.fn(),
+    ...overrides,
+  } as ExtensionRuntime;
+}
+
+function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+  return {
+    runtime: makeRuntime(),
     createPermissionManagerForCwd: vi
       .fn()
       .mockReturnValue(makePermissionManager()),
@@ -97,8 +112,6 @@ function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
     createPermissionRequestId: vi.fn().mockReturnValue("test-id"),
     startForwardedPermissionPolling: vi.fn(),
     stopForwardedPermissionPolling: vi.fn(),
-    writeReviewLog: vi.fn(),
-    writeDebugLog: vi.fn(),
     getAllTools: vi.fn().mockReturnValue([]),
     setActiveTools: vi.fn(),
     ...overrides,
@@ -117,7 +130,7 @@ describe("handleSessionStart", () => {
     const ctx = makeCtx();
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.setRuntimeContext).toHaveBeenCalledWith(ctx);
+    expect(deps.runtime.runtimeContext).toBe(ctx);
   });
 
   it("refreshes extension config with ctx", async () => {
@@ -137,16 +150,16 @@ describe("handleSessionStart", () => {
     expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(
       "/my/project",
     );
-    expect(deps.setPermissionManager).toHaveBeenCalledWith(newPm);
+    expect(deps.runtime.permissionManager).toBe(newPm);
   });
 
   it("clears the before_agent_start cache", async () => {
     const ctx = makeCtx();
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
-    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
-    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.runtime.activeSkillEntries).toEqual([]);
+    expect(deps.runtime.lastActiveToolsCacheKey).toBeNull();
+    expect(deps.runtime.lastPromptStateCacheKey).toBeNull();
   });
 
   it("sets lastKnownActiveAgentName from getActiveAgentName", async () => {
@@ -154,7 +167,7 @@ describe("handleSessionStart", () => {
     const ctx = makeCtx();
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.setLastKnownActiveAgentName).toHaveBeenCalledWith("my-agent");
+    expect(deps.runtime.lastKnownActiveAgentName).toBe("my-agent");
   });
 
   it("sets lastKnownActiveAgentName to null when no agent is active", async () => {
@@ -162,7 +175,7 @@ describe("handleSessionStart", () => {
     const ctx = makeCtx();
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.setLastKnownActiveAgentName).toHaveBeenCalledWith(null);
+    expect(deps.runtime.lastKnownActiveAgentName).toBeNull();
   });
 
   it("starts forwarded permission polling", async () => {
@@ -182,7 +195,7 @@ describe("handleSessionStart", () => {
   it("notifies each policy issue", async () => {
     const pm = makePermissionManager(["issue A", "issue B"]);
     const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue(pm),
+      createPermissionManagerForCwd: vi.fn().mockReturnValue(pm),
     });
     await handleSessionStart(deps, { reason: "startup" }, makeCtx());
     expect(deps.notifyWarning).toHaveBeenCalledWith("issue A");
@@ -199,17 +212,20 @@ describe("handleSessionStart", () => {
     const ctx = makeCtx({ cwd: "/proj" });
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "reload" }, ctx);
-    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
-      triggeredBy: "session_start",
-      reason: "reload",
-      cwd: "/proj",
-    });
+    expect(deps.runtime.writeDebugLog).toHaveBeenCalledWith(
+      "lifecycle.reload",
+      {
+        triggeredBy: "session_start",
+        reason: "reload",
+        cwd: "/proj",
+      },
+    );
   });
 
   it("does not write lifecycle.reload debug log for non-reload reasons", async () => {
     const deps = makeDeps();
     await handleSessionStart(deps, { reason: "startup" }, makeCtx());
-    expect(deps.writeDebugLog).not.toHaveBeenCalled();
+    expect(deps.runtime.writeDebugLog).not.toHaveBeenCalled();
   });
 });
 
@@ -219,61 +235,63 @@ describe("handleResourcesDiscover", () => {
   it("does nothing when reason is not reload", async () => {
     const deps = makeDeps();
     await handleResourcesDiscover(deps, { reason: "startup" });
-    expect(deps.setPermissionManager).not.toHaveBeenCalled();
-    expect(deps.writeDebugLog).not.toHaveBeenCalled();
+    expect(deps.createPermissionManagerForCwd).not.toHaveBeenCalled();
+    expect(deps.runtime.writeDebugLog).not.toHaveBeenCalled();
   });
 
   it("creates and stores a new PM using runtimeContext.cwd on reload", async () => {
     const ctx = makeCtx({ cwd: "/runtime/cwd" });
     const newPm = makePermissionManager();
     const deps = makeDeps({
-      getRuntimeContext: vi.fn().mockReturnValue(ctx),
+      runtime: makeRuntime({ runtimeContext: ctx }),
       createPermissionManagerForCwd: vi.fn().mockReturnValue(newPm),
     });
     await handleResourcesDiscover(deps, { reason: "reload" });
     expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(
       "/runtime/cwd",
     );
-    expect(deps.setPermissionManager).toHaveBeenCalledWith(newPm);
+    expect(deps.runtime.permissionManager).toBe(newPm);
   });
 
   it("uses undefined cwd when runtimeContext is null on reload", async () => {
-    const deps = makeDeps({
-      getRuntimeContext: vi.fn().mockReturnValue(null),
-    });
+    const deps = makeDeps();
     await handleResourcesDiscover(deps, { reason: "reload" });
     expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(undefined);
   });
 
   it("clears the before_agent_start cache on reload", async () => {
-    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(null) });
+    const deps = makeDeps();
     await handleResourcesDiscover(deps, { reason: "reload" });
-    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
-    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
-    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.runtime.activeSkillEntries).toEqual([]);
+    expect(deps.runtime.lastActiveToolsCacheKey).toBeNull();
+    expect(deps.runtime.lastPromptStateCacheKey).toBeNull();
   });
 
   it("writes lifecycle.reload debug log on reload", async () => {
     const ctx = makeCtx({ cwd: "/proj" });
-    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(ctx) });
+    const deps = makeDeps({ runtime: makeRuntime({ runtimeContext: ctx }) });
     await handleResourcesDiscover(deps, { reason: "reload" });
-    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
-      triggeredBy: "resources_discover",
-      reason: "reload",
-      cwd: "/proj",
-    });
+    expect(deps.runtime.writeDebugLog).toHaveBeenCalledWith(
+      "lifecycle.reload",
+      {
+        triggeredBy: "resources_discover",
+        reason: "reload",
+        cwd: "/proj",
+      },
+    );
   });
 
   it("logs cwd as null when runtimeContext is null on reload", async () => {
-    const deps = makeDeps({
-      getRuntimeContext: vi.fn().mockReturnValue(null),
-    });
+    const deps = makeDeps();
     await handleResourcesDiscover(deps, { reason: "reload" });
-    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
-      triggeredBy: "resources_discover",
-      reason: "reload",
-      cwd: null,
-    });
+    expect(deps.runtime.writeDebugLog).toHaveBeenCalledWith(
+      "lifecycle.reload",
+      {
+        triggeredBy: "resources_discover",
+        reason: "reload",
+        cwd: null,
+      },
+    );
   });
 });
 
@@ -283,7 +301,7 @@ describe("handleSessionShutdown", () => {
   it("clears the UI status when a runtime context is present", async () => {
     const ctx = makeCtx();
     const deps = makeDeps({
-      getRuntimeContext: vi.fn().mockReturnValue(ctx),
+      runtime: makeRuntime({ runtimeContext: ctx }),
     });
     await handleSessionShutdown(deps);
     expect(ctx.ui.setStatus).toHaveBeenCalledWith(
@@ -293,28 +311,29 @@ describe("handleSessionShutdown", () => {
   });
 
   it("does not throw when runtime context is null", async () => {
-    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(null) });
+    const deps = makeDeps();
     await expect(handleSessionShutdown(deps)).resolves.not.toThrow();
   });
 
   it("sets runtime context to null", async () => {
-    const deps = makeDeps();
+    const ctx = makeCtx();
+    const deps = makeDeps({ runtime: makeRuntime({ runtimeContext: ctx }) });
     await handleSessionShutdown(deps);
-    expect(deps.setRuntimeContext).toHaveBeenCalledWith(null);
+    expect(deps.runtime.runtimeContext).toBeNull();
   });
 
   it("clears the before_agent_start cache", async () => {
     const deps = makeDeps();
     await handleSessionShutdown(deps);
-    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
-    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
-    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.runtime.activeSkillEntries).toEqual([]);
+    expect(deps.runtime.lastActiveToolsCacheKey).toBeNull();
+    expect(deps.runtime.lastPromptStateCacheKey).toBeNull();
   });
 
   it("clears the session approval cache", async () => {
     const deps = makeDeps();
     await handleSessionShutdown(deps);
-    expect(deps.sessionApprovalCache.clear).toHaveBeenCalledOnce();
+    expect(deps.runtime.sessionApprovalCache.clear).toHaveBeenCalledOnce();
   });
 
   it("stops forwarded permission polling", async () => {
@@ -324,8 +343,10 @@ describe("handleSessionShutdown", () => {
   });
 
   it("does not reset lastKnownActiveAgentName", async () => {
-    const deps = makeDeps();
+    const deps = makeDeps({
+      runtime: makeRuntime({ lastKnownActiveAgentName: "remembered" }),
+    });
     await handleSessionShutdown(deps);
-    expect(deps.setLastKnownActiveAgentName).not.toHaveBeenCalled();
+    expect(deps.runtime.lastKnownActiveAgentName).toBe("remembered");
   });
 });

package/tests/handlers/tool-call.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from "vitest";
 
 import { getEventInput, handleToolCall } from "../../src/handlers/tool-call";
 import type { HandlerDeps } from "../../src/handlers/types";
+import type { ExtensionRuntime } from "../../src/runtime";
 import type { PermissionCheckResult } from "../../src/types";
 
 // ── SDK stubs ──────────────────────────────────────────────────────────────
@@ -54,28 +55,43 @@ function makePermissionResult(
   return { state, toolName: "read", source: "tool" };
 }
 
-function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+function makeRuntime(
+  overrides: Partial<ExtensionRuntime> = {},
+): ExtensionRuntime {
   return {
-    getPermissionManager: vi.fn().mockReturnValue({
+    agentDir: "/test/agent",
+    sessionsDir: "/test/agent/sessions",
+    subagentSessionsDir: "/test/agent/subagent-sessions",
+    forwardingDir: "/test/agent/sessions/permission-forwarding",
+    globalLogsDir: "/test/agent/extensions/pi-permission-system/logs",
+    config: { debugLog: false, permissionReviewLog: true, yoloMode: false },
+    runtimeContext: null,
+    permissionManager: {
       checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
-    }),
-    setPermissionManager: vi.fn(),
-    getRuntimeContext: vi.fn().mockReturnValue(null),
-    setRuntimeContext: vi.fn(),
-    getActiveSkillEntries: vi.fn().mockReturnValue([]),
-    setActiveSkillEntries: vi.fn(),
-    getLastKnownActiveAgentName: vi.fn().mockReturnValue(null),
-    setLastKnownActiveAgentName: vi.fn(),
-    getLastActiveToolsCacheKey: vi.fn().mockReturnValue(null),
-    setLastActiveToolsCacheKey: vi.fn(),
-    getLastPromptStateCacheKey: vi.fn().mockReturnValue(null),
-    setLastPromptStateCacheKey: vi.fn(),
+    } as unknown as ExtensionRuntime["permissionManager"],
+    activeSkillEntries: [],
+    lastKnownActiveAgentName: null,
+    lastActiveToolsCacheKey: null,
+    lastPromptStateCacheKey: null,
+    lastConfigWarning: null,
     sessionApprovalCache: {
       approve: vi.fn(),
       has: vi.fn().mockReturnValue(false),
       findMatchingPrefix: vi.fn().mockReturnValue(null),
       clear: vi.fn(),
-    } as unknown as HandlerDeps["sessionApprovalCache"],
+    } as unknown as ExtensionRuntime["sessionApprovalCache"],
+    permissionForwardingContext: null,
+    permissionForwardingTimer: null,
+    isProcessingForwardedRequests: false,
+    writeDebugLog: vi.fn(),
+    writeReviewLog: vi.fn(),
+    ...overrides,
+  } as ExtensionRuntime;
+}
+
+function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+  return {
+    runtime: makeRuntime(),
     createPermissionManagerForCwd: vi.fn(),
     refreshExtensionConfig: vi.fn(),
     notifyWarning: vi.fn(),
@@ -88,8 +104,6 @@ function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
     createPermissionRequestId: vi.fn().mockReturnValue("req-id"),
     startForwardedPermissionPolling: vi.fn(),
     stopForwardedPermissionPolling: vi.fn(),
-    writeReviewLog: vi.fn(),
-    writeDebugLog: vi.fn(),
     getAllTools: vi.fn().mockReturnValue([{ name: "read" }, { name: "bash" }]),
     setActiveTools: vi.fn(),
     ...overrides,
@@ -129,7 +143,7 @@ describe("handleToolCall", () => {
     const ctx = makeCtx();
     const deps = makeDeps();
     await handleToolCall(deps, makeToolCallEvent("read"), ctx);
-    expect(deps.setRuntimeContext).toHaveBeenCalledWith(ctx);
+    expect(deps.runtime.runtimeContext).toBe(ctx);
   });
 
   it("starts forwarded permission polling", async () => {
@@ -162,11 +176,8 @@ describe("handleToolCall", () => {
   });
 
   it("returns empty object when tool is allowed", async () => {
-    const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
-      }),
-    });
+    // default makeRuntime() has checkPermission → "allow"
+    const deps = makeDeps();
     const result = await handleToolCall(
       deps,
       makeToolCallEvent("read"),
@@ -177,8 +188,12 @@ describe("handleToolCall", () => {
 
   it("blocks when tool is denied by policy", async () => {
     const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("deny")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi
+            .fn()
+            .mockReturnValue(makePermissionResult("deny")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
     });
     const result = await handleToolCall(
@@ -191,8 +206,10 @@ describe("handleToolCall", () => {
 
   it("blocks when tool ask has no UI available", async () => {
     const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
       canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
     });
@@ -206,8 +223,10 @@ describe("handleToolCall", () => {
 
   it("allows when user approves the ask prompt", async () => {
     const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
       canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
       promptPermission: vi
@@ -224,8 +243,10 @@ describe("handleToolCall", () => {
 
   it("blocks when user denies the ask prompt", async () => {
     const deps = makeDeps({
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
       canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
       promptPermission: vi
@@ -254,11 +275,8 @@ describe("handleToolCall — skill-read gate", () => {
       normalizedBaseDir: "/skills/librarian",
     };
     const deps = makeDeps({
-      getActiveSkillEntries: vi.fn().mockReturnValue([skillEntry]),
+      runtime: makeRuntime({ activeSkillEntries: [skillEntry] }),
       getAllTools: vi.fn().mockReturnValue([{ toolName: "read" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
-      }),
     });
     const event = {
       type: "tool_call",
@@ -280,11 +298,8 @@ describe("handleToolCall — skill-read gate", () => {
       normalizedBaseDir: "/skills/librarian",
     };
     const deps = makeDeps({
-      getActiveSkillEntries: vi.fn().mockReturnValue([skillEntry]),
+      runtime: makeRuntime({ activeSkillEntries: [skillEntry] }),
       getAllTools: vi.fn().mockReturnValue([{ toolName: "read" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
-      }),
     });
     const event = {
       type: "tool_call",
@@ -302,10 +317,14 @@ describe("handleToolCall — skill-read gate", () => {
 describe("handleToolCall — external-directory gate", () => {
   it("blocks a read of a path outside cwd when policy is deny", async () => {
     const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("deny")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi
+            .fn()
+            .mockReturnValue(makePermissionResult("deny")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
+      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
     });
     const event = {
       type: "tool_call",
@@ -319,16 +338,15 @@ describe("handleToolCall — external-directory gate", () => {
 
   it("allows when session has an existing approval for the external path", async () => {
     const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
+      runtime: makeRuntime({
+        sessionApprovalCache: {
+          approve: vi.fn(),
+          has: vi.fn().mockReturnValue(false),
+          findMatchingPrefix: vi.fn().mockReturnValue("/outside/project/"),
+          clear: vi.fn(),
+        } as unknown as ExtensionRuntime["sessionApprovalCache"],
       }),
-      sessionApprovalCache: {
-        approve: vi.fn(),
-        has: vi.fn().mockReturnValue(false),
-        findMatchingPrefix: vi.fn().mockReturnValue("/outside/project/"),
-        clear: vi.fn(),
-      } as unknown as HandlerDeps["sessionApprovalCache"],
+      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
     });
     const event = {
       type: "tool_call",
@@ -346,17 +364,19 @@ describe("handleToolCall — external-directory gate", () => {
       has: vi.fn().mockReturnValue(false),
       findMatchingPrefix: vi.fn().mockReturnValue(null),
       clear: vi.fn(),
-    } as unknown as HandlerDeps["sessionApprovalCache"];
+    } as unknown as ExtensionRuntime["sessionApprovalCache"];
     const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi.fn().mockReturnValue(makePermissionResult("ask")),
+        } as unknown as ExtensionRuntime["permissionManager"],
+        sessionApprovalCache: approveCache,
       }),
+      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
       canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
       promptPermission: vi
         .fn()
         .mockResolvedValue({ approved: true, state: "approved_for_session" }),
-      sessionApprovalCache: approveCache,
     });
     const event = {
       type: "tool_call",
@@ -377,10 +397,14 @@ describe("handleToolCall — external-directory gate", () => {
 describe("handleToolCall — bash external-directory gate", () => {
   it("blocks a bash command referencing an external path when policy is deny", async () => {
     const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "bash" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("deny")),
+      runtime: makeRuntime({
+        permissionManager: {
+          checkPermission: vi
+            .fn()
+            .mockReturnValue(makePermissionResult("deny")),
+        } as unknown as ExtensionRuntime["permissionManager"],
       }),
+      getAllTools: vi.fn().mockReturnValue([{ name: "bash" }]),
     });
     const event = {
       type: "tool_call",
@@ -394,17 +418,16 @@ describe("handleToolCall — bash external-directory gate", () => {
 
   it("skips bash external gate when all referenced paths are session-approved", async () => {
     const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "bash" }]),
-      getPermissionManager: vi.fn().mockReturnValue({
-        checkPermission: vi.fn().mockReturnValue(makePermissionResult("allow")),
+      runtime: makeRuntime({
+        sessionApprovalCache: {
+          approve: vi.fn(),
+          // All paths are covered
+          has: vi.fn().mockReturnValue(true),
+          findMatchingPrefix: vi.fn().mockReturnValue(null),
+          clear: vi.fn(),
+        } as unknown as ExtensionRuntime["sessionApprovalCache"],
       }),
-      sessionApprovalCache: {
-        approve: vi.fn(),
-        // All paths are covered
-        has: vi.fn().mockReturnValue(true),
-        findMatchingPrefix: vi.fn().mockReturnValue(null),
-        clear: vi.fn(),
-      } as unknown as HandlerDeps["sessionApprovalCache"],
+      getAllTools: vi.fn().mockReturnValue([{ name: "bash" }]),
     });
     const event = {
       type: "tool_call",