@gotgenes/pi-permission-system 10.4.0 → 10.5.1

package/test/handlers/gates/tool-call-gate-pipeline.test.ts

@@ -40,9 +40,10 @@ describe("ToolCallGatePipeline", () => {
 
   describe("evaluate — non-bash tool", () => {
     it("returns allow when all gates pass", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       const result = await pipeline.evaluate(
         makeTcc({ toolName: "read", input: {} }),
@@ -53,12 +54,12 @@ describe("ToolCallGatePipeline", () => {
     });
 
     it("returns block when the tool gate denies", async () => {
-      const { resolve } = makeResolver(
+      const resolver = makeResolver(
         makeCheckResult({ state: "deny", matchedPattern: "*" }),
       );
-      const inputs = makeGateInputs({ resolve });
-      const { runner } = makeGateRunner({ resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const inputs = makeGateInputs();
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       const result = await pipeline.evaluate(
         makeTcc({ toolName: "read", input: {} }),
@@ -69,13 +70,14 @@ describe("ToolCallGatePipeline", () => {
     });
 
     it("short-circuits after the first blocking gate without evaluating later ones", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
       const { runner } = makeGateRunner();
       const runSpy = vi
         .spyOn(runner, "run")
         .mockResolvedValue({ action: "block", reason: "first gate blocked" });
 
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
       const result = await pipeline.evaluate(
         makeTcc({ toolName: "read", input: {} }),
         runner,
@@ -92,9 +94,10 @@ describe("ToolCallGatePipeline", () => {
         toolTextSummaryMaxLength: 100,
         toolInputLogPreviewMaxLength: 200,
       }));
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs({ getToolPreviewLimits });
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
 
@@ -103,9 +106,10 @@ describe("ToolCallGatePipeline", () => {
 
     it("calls getInfrastructureReadDirs() during evaluate", async () => {
       const getInfrastructureReadDirs = vi.fn<() => string[]>(() => []);
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs({ getInfrastructureReadDirs });
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
 
@@ -114,9 +118,10 @@ describe("ToolCallGatePipeline", () => {
 
     it("calls getActiveSkillEntries() during evaluate", async () => {
       const getActiveSkillEntries = vi.fn<() => []>(() => []);
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs({ getActiveSkillEntries });
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
 
@@ -124,9 +129,10 @@ describe("ToolCallGatePipeline", () => {
     });
 
     it("does not call BashProgram.parse for non-bash tools", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
 
@@ -138,9 +144,10 @@ describe("ToolCallGatePipeline", () => {
 
   describe("evaluate — bash tool", () => {
     it("returns allow when the bash command is permitted", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       const result = await pipeline.evaluate(
         makeTcc({ toolName: "bash", input: { command: "echo hello" } }),
@@ -151,9 +158,10 @@ describe("ToolCallGatePipeline", () => {
     });
 
     it("parses BashProgram exactly once per evaluate for bash tools with a command", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(
         makeTcc({ toolName: "bash", input: { command: "echo hello" } }),
@@ -165,9 +173,10 @@ describe("ToolCallGatePipeline", () => {
     });
 
     it("does not parse BashProgram when the bash command is empty", async () => {
+      const resolver = makeResolver(makeCheckResult());
       const inputs = makeGateInputs();
-      const { runner } = makeGateRunner({ resolve: inputs.resolve });
-      const pipeline = new ToolCallGatePipeline(inputs);
+      const { runner } = makeGateRunner();
+      const pipeline = new ToolCallGatePipeline(resolver, inputs);
 
       await pipeline.evaluate(
         makeTcc({ toolName: "bash", input: { command: "" } }),

package/test/handlers/input.test.ts

@@ -49,9 +49,10 @@ describe("extractSkillNameFromInput", () => {
 describe("handleInput", () => {
   it("activates session with ctx", async () => {
     const ctx = makeCtx();
-    const { handler, session } = makeHandler();
+    const { handler, forwarding } = makeHandler();
     await handler.handleInput(makeInputEvent("hello"), ctx);
-    expect(session.activate).toHaveBeenCalledWith(ctx);
+    // session.activate(ctx) calls forwarding.start(ctx) on the real session
+    expect(forwarding.start).toHaveBeenCalledWith(ctx);
   });
 
   it("returns continue for non-skill input", async () => {
@@ -64,9 +65,9 @@ describe("handleInput", () => {
   });
 
   it("does not check permissions for non-skill input", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, permissionManager } = makeHandler();
     await handler.handleInput(makeInputEvent("just a message"), makeCtx());
-    expect(session.checkPermission).not.toHaveBeenCalled();
+    expect(permissionManager.checkPermission).not.toHaveBeenCalled();
   });
 
   it("returns continue when skill is allowed", async () => {

package/test/handlers/lifecycle.test.ts

@@ -2,9 +2,12 @@ import { describe, expect, it, vi } from "vitest";
 
 import { SessionLifecycleHandler } from "#src/handlers/lifecycle";
 import type { ServiceLifecycle } from "#src/service-lifecycle";
-import type { SessionLifecycleSession } from "#src/session-lifecycle-session";
 
 import { makeCtx } from "#test/helpers/handler-fixtures";
+import {
+  makeRealResolver,
+  makeRealSession,
+} from "#test/helpers/session-fixtures";
 
 // ── status stub ────────────────────────────────────────────────────────────
 vi.mock("../../src/status", () => ({
@@ -15,55 +18,40 @@ vi.mock("../../src/status", () => ({
 
 // ── helpers ────────────────────────────────────────────────────────────────
 
-function makeSession(
-  overrides: Partial<SessionLifecycleSession> = {},
-): SessionLifecycleSession {
-  return {
-    logger: overrides.logger ?? {
-      debug: vi.fn<SessionLifecycleSession["logger"]["debug"]>(),
-      review: vi.fn<SessionLifecycleSession["logger"]["review"]>(),
-      warn: vi.fn<SessionLifecycleSession["logger"]["warn"]>(),
-    },
-    refreshConfig:
-      overrides.refreshConfig ??
-      vi.fn<SessionLifecycleSession["refreshConfig"]>(),
-    resetForNewSession:
-      overrides.resetForNewSession ??
-      vi.fn<SessionLifecycleSession["resetForNewSession"]>(),
-    logResolvedConfigPaths:
-      overrides.logResolvedConfigPaths ??
-      vi.fn<SessionLifecycleSession["logResolvedConfigPaths"]>(),
-    resolveAgentName:
-      overrides.resolveAgentName ??
-      vi
-        .fn<SessionLifecycleSession["resolveAgentName"]>()
-        .mockReturnValue(null),
-    getConfigIssues:
-      overrides.getConfigIssues ??
-      vi.fn<SessionLifecycleSession["getConfigIssues"]>().mockReturnValue([]),
-    reload: overrides.reload ?? vi.fn<SessionLifecycleSession["reload"]>(),
-    getRuntimeContext:
-      overrides.getRuntimeContext ??
-      vi
-        .fn<SessionLifecycleSession["getRuntimeContext"]>()
-        .mockReturnValue(null),
-    shutdown:
-      overrides.shutdown ?? vi.fn<SessionLifecycleSession["shutdown"]>(),
-  };
-}
-
-function makeHandler(overrides?: Partial<SessionLifecycleSession>): {
-  handler: SessionLifecycleHandler;
-  session: SessionLifecycleSession;
-  serviceLifecycle: ServiceLifecycle;
-} {
-  const session = makeSession(overrides);
+function makeSetup(opts?: { configIssues?: string[] }) {
+  const {
+    session,
+    permissionManager,
+    sessionRules,
+    logger,
+    forwarding,
+    configStore,
+  } = makeRealSession();
+  const { resolver } = makeRealResolver(permissionManager, sessionRules);
+  if (opts?.configIssues) {
+    vi.mocked(permissionManager.getConfigIssues).mockReturnValue(
+      opts.configIssues,
+    );
+  }
   const serviceLifecycle: ServiceLifecycle = {
     activate: vi.fn<ServiceLifecycle["activate"]>(),
     teardown: vi.fn<ServiceLifecycle["teardown"]>(),
   };
-  const handler = new SessionLifecycleHandler(session, serviceLifecycle);
-  return { handler, session, serviceLifecycle };
+  const handler = new SessionLifecycleHandler(
+    session,
+    resolver,
+    serviceLifecycle,
+  );
+  return {
+    handler,
+    session,
+    resolver,
+    permissionManager,
+    logger,
+    forwarding,
+    configStore,
+    serviceLifecycle,
+  };
 }
 
 // ── handleSessionStart ─────────────────────────────────────────────────────
@@ -71,51 +59,53 @@ function makeHandler(overrides?: Partial<SessionLifecycleSession>): {
 describe("handleSessionStart", () => {
   it("refreshes config with ctx", async () => {
     const ctx = makeCtx();
-    const { handler, session } = makeHandler();
+    const { handler, configStore } = makeSetup();
     await handler.handleSessionStart({ reason: "startup" }, ctx);
-    expect(session.refreshConfig).toHaveBeenCalledWith(ctx);
+    expect(configStore.refresh).toHaveBeenCalledWith(ctx);
   });
 
   it("calls resetForNewSession with ctx", async () => {
     const ctx = makeCtx();
-    const { handler, session } = makeHandler();
+    const { handler, session } = makeSetup();
+    const spy = vi.spyOn(session, "resetForNewSession");
     await handler.handleSessionStart({ reason: "startup" }, ctx);
-    expect(session.resetForNewSession).toHaveBeenCalledWith(ctx);
+    expect(spy).toHaveBeenCalledWith(ctx);
   });
 
   it("logs resolved config paths", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, configStore } = makeSetup();
     await handler.handleSessionStart({ reason: "startup" }, makeCtx());
-    expect(session.logResolvedConfigPaths).toHaveBeenCalledOnce();
+    expect(configStore.logResolvedPaths).toHaveBeenCalledOnce();
   });
 
   it("resolves agent name from ctx", async () => {
     const ctx = makeCtx();
-    const { handler, session } = makeHandler();
+    const { handler, session } = makeSetup();
+    const spy = vi.spyOn(session, "resolveAgentName");
     await handler.handleSessionStart({ reason: "startup" }, ctx);
-    expect(session.resolveAgentName).toHaveBeenCalledWith(ctx);
+    expect(spy).toHaveBeenCalledWith(ctx);
   });
 
   it("notifies each policy issue", async () => {
-    const { handler, session } = makeHandler({
-      getConfigIssues: vi.fn().mockReturnValue(["issue A", "issue B"]),
+    const { handler, logger } = makeSetup({
+      configIssues: ["issue A", "issue B"],
     });
     await handler.handleSessionStart({ reason: "startup" }, makeCtx());
-    expect(session.logger.warn).toHaveBeenCalledWith("issue A");
-    expect(session.logger.warn).toHaveBeenCalledWith("issue B");
+    expect(logger.warn).toHaveBeenCalledWith("issue A");
+    expect(logger.warn).toHaveBeenCalledWith("issue B");
   });
 
   it("does not warn when there are no policy issues", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, logger } = makeSetup();
     await handler.handleSessionStart({ reason: "startup" }, makeCtx());
-    expect(session.logger.warn).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
   });
 
   it("writes lifecycle.reload debug log when reason is reload", async () => {
     const ctx = makeCtx({ cwd: "/proj" });
-    const { handler, session } = makeHandler();
+    const { handler, logger } = makeSetup();
     await handler.handleSessionStart({ reason: "reload" }, ctx);
-    expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
+    expect(logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "session_start",
       reason: "reload",
       cwd: "/proj",
@@ -123,23 +113,26 @@ describe("handleSessionStart", () => {
   });
 
   it("does not write lifecycle.reload debug log for non-reload reasons", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, logger } = makeSetup();
     await handler.handleSessionStart({ reason: "startup" }, makeCtx());
-    expect(session.logger.debug).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
   });
 
   it("activates the service for the session with ctx", async () => {
     const ctx = makeCtx();
-    const { handler, serviceLifecycle } = makeHandler();
+    const { handler, serviceLifecycle } = makeSetup();
     await handler.handleSessionStart({ reason: "startup" }, ctx);
     expect(serviceLifecycle.activate).toHaveBeenCalledWith(ctx);
   });
 
   it("calls refreshConfig before resetForNewSession", async () => {
     const callOrder: string[] = [];
-    const { handler } = makeHandler({
-      refreshConfig: vi.fn(() => callOrder.push("refreshConfig")),
-      resetForNewSession: vi.fn(() => callOrder.push("resetForNewSession")),
+    const { handler, session, configStore } = makeSetup();
+    vi.spyOn(configStore, "refresh").mockImplementation(() => {
+      callOrder.push("refreshConfig");
+    });
+    vi.spyOn(session, "resetForNewSession").mockImplementation(() => {
+      callOrder.push("resetForNewSession");
     });
     await handler.handleSessionStart({ reason: "startup" }, makeCtx());
     expect(callOrder).toEqual(["refreshConfig", "resetForNewSession"]);
@@ -150,24 +143,25 @@ describe("handleSessionStart", () => {
 
 describe("handleResourcesDiscover", () => {
   it("does nothing when reason is not reload", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, session } = makeSetup();
+    const spy = vi.spyOn(session, "reload");
     await handler.handleResourcesDiscover({ reason: "startup" });
-    expect(session.reload).not.toHaveBeenCalled();
+    expect(spy).not.toHaveBeenCalled();
   });
 
   it("calls reload on the session on reload", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, session } = makeSetup();
+    const spy = vi.spyOn(session, "reload");
     await handler.handleResourcesDiscover({ reason: "reload" });
-    expect(session.reload).toHaveBeenCalledOnce();
+    expect(spy).toHaveBeenCalledOnce();
   });
 
   it("writes lifecycle.reload debug log on reload", async () => {
     const ctx = makeCtx({ cwd: "/proj" });
-    const { handler, session } = makeHandler({
-      getRuntimeContext: vi.fn().mockReturnValue(ctx),
-    });
+    const { handler, session, logger } = makeSetup();
+    session.activate(ctx);
     await handler.handleResourcesDiscover({ reason: "reload" });
-    expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
+    expect(logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "resources_discover",
       reason: "reload",
       cwd: "/proj",
@@ -175,9 +169,9 @@ describe("handleResourcesDiscover", () => {
   });
 
   it("logs cwd as null when runtimeContext is null on reload", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, logger } = makeSetup();
     await handler.handleResourcesDiscover({ reason: "reload" });
-    expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
+    expect(logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "resources_discover",
       reason: "reload",
       cwd: null,
@@ -190,9 +184,8 @@ describe("handleResourcesDiscover", () => {
 describe("handleSessionShutdown", () => {
   it("clears UI status when runtime context is present", async () => {
     const ctx = makeCtx();
-    const { handler } = makeHandler({
-      getRuntimeContext: vi.fn().mockReturnValue(ctx),
-    });
+    const { handler, session } = makeSetup();
+    session.activate(ctx);
     await handler.handleSessionShutdown();
     expect(ctx.ui.setStatus).toHaveBeenCalledWith(
       "permission-system",
@@ -201,18 +194,19 @@ describe("handleSessionShutdown", () => {
   });
 
   it("does not throw when runtime context is null", async () => {
-    const { handler } = makeHandler();
+    const { handler } = makeSetup();
     await expect(handler.handleSessionShutdown()).resolves.not.toThrow();
   });
 
   it("calls shutdown on the session", async () => {
-    const { handler, session } = makeHandler();
+    const { handler, session } = makeSetup();
+    const spy = vi.spyOn(session, "shutdown");
     await handler.handleSessionShutdown();
-    expect(session.shutdown).toHaveBeenCalledOnce();
+    expect(spy).toHaveBeenCalledOnce();
   });
 
   it("calls serviceLifecycle.teardown", async () => {
-    const { handler, serviceLifecycle } = makeHandler();
+    const { handler, serviceLifecycle } = makeSetup();
     await handler.handleSessionShutdown();
     expect(serviceLifecycle.teardown).toHaveBeenCalledOnce();
   });

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

@@ -49,9 +49,10 @@ describe("getEventInput", () => {
 describe("handleToolCall", () => {
   it("activates session with ctx", async () => {
     const ctx = makeCtx();
-    const { handler, session } = makeHandler();
+    const { handler, forwarding } = makeHandler();
     await handler.handleToolCall(makeToolCallEvent("read"), ctx);
-    expect(session.activate).toHaveBeenCalledWith(ctx);
+    // session.activate(ctx) calls forwarding.start(ctx) on the real session
+    expect(forwarding.start).toHaveBeenCalledWith(ctx);
   });
 
   it("blocks when tool name cannot be resolved", async () => {

package/test/helpers/gate-fixtures.ts

@@ -10,7 +10,7 @@ import { GateRunner } from "#src/handlers/gates/runner";
 import type { SkillInputGateInputs } from "#src/handlers/gates/skill-input-gate-pipeline";
 import type { ToolCallGateInputs } from "#src/handlers/gates/tool-call-gate-pipeline";
 import type { ToolCallContext } from "#src/handlers/gates/types";
-import type { PermissionResolver } from "#src/permission-resolver";
+import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import type { SessionApprovalRecorder } from "#src/session-approval-recorder";
 import type { SkillPromptEntry } from "#src/skill-prompt-sanitizer";
 import type { ToolPreviewFormatterOptions } from "#src/tool-preview-formatter";
@@ -25,7 +25,7 @@ import { makeCheckResult } from "#test/helpers/handler-fixtures";
  * mock access (`mockReturnValue`, `mockImplementation`, `mock.calls`).
  */
 export function makeResolver(defaultCheck?: PermissionCheckResult) {
-  const resolve = vi.fn<PermissionResolver["resolve"]>();
+  const resolve = vi.fn<ScopedPermissionResolver["resolve"]>();
   if (defaultCheck) {
     resolve.mockReturnValue(defaultCheck);
   }
@@ -91,7 +91,7 @@ export function makeReporter(
 export function makeGateRunner(
   overrides: {
     resolveResult?: PermissionCheckResult;
-    resolve?: PermissionResolver["resolve"];
+    resolve?: ScopedPermissionResolver["resolve"];
     recordSessionApproval?: SessionApprovalRecorder["recordSessionApproval"];
     canConfirm?: GatePrompter["canConfirm"];
     prompt?: GatePrompter["prompt"];
@@ -102,7 +102,7 @@ export function makeGateRunner(
   const resolve =
     overrides.resolve ??
     vi
-      .fn<PermissionResolver["resolve"]>()
+      .fn<ScopedPermissionResolver["resolve"]>()
       .mockReturnValue(
         overrides.resolveResult ?? makeCheckResult({ matchedPattern: "*" }),
       );
@@ -204,7 +204,7 @@ export function makePathDispatchResolver(
   byPath: Record<string, PermissionCheckResult>,
   defaultResult: PermissionCheckResult,
 ) {
-  const resolve = vi.fn<PermissionResolver["resolve"]>();
+  const resolve = vi.fn<ScopedPermissionResolver["resolve"]>();
   resolve.mockImplementation((_surface, input) => {
     const path = (input as Record<string, unknown>).path;
     if (typeof path === "string" && path in byPath) {
@@ -243,16 +243,12 @@ export function makeGateCheckResult(
  */
 export function makeGateInputs(
   overrides: {
-    resolve?: PermissionResolver["resolve"];
     getActiveSkillEntries?: () => SkillPromptEntry[];
     getInfrastructureReadDirs?: () => string[];
     getToolPreviewLimits?: () => ToolPreviewFormatterOptions;
   } = {},
 ): ToolCallGateInputs {
   return {
-    resolve:
-      overrides.resolve ??
-      vi.fn<PermissionResolver["resolve"]>().mockReturnValue(makeCheckResult()),
     getActiveSkillEntries:
       overrides.getActiveSkillEntries ??
       vi.fn<() => SkillPromptEntry[]>(() => []),