@gotgenes/pi-permission-system 10.3.1 → 10.4.0

package/test/handlers/external-directory-session-dedup.test.ts

@@ -9,16 +9,15 @@
  * PermissionManager.
  */
 
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { describe, expect, it, vi } from "vitest";
 
 import { GateDecisionReporter } from "#src/decision-reporter";
 import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
+import type { GatePrompter } from "#src/gate-prompter";
 import { GateRunner } from "#src/handlers/gates/runner";
 import { SkillInputGatePipeline } from "#src/handlers/gates/skill-input-gate-pipeline";
 import { ToolCallGatePipeline } from "#src/handlers/gates/tool-call-gate-pipeline";
 import { PermissionGateHandler } from "#src/handlers/permission-gate-handler";
-import type { PromptPermissionDetails } from "#src/permission-prompter";
 import type { Rule } from "#src/rule";
 import type { SessionApproval } from "#src/session-approval";
 import { resolveToolPreviewLimits } from "#src/tool-preview-formatter";
@@ -154,15 +153,7 @@ function makeStatefulSession(
       vi
         .fn<MockGateHandlerSession["getToolPreviewLimits"]>()
         .mockReturnValue(resolveToolPreviewLimits(DEFAULT_EXTENSION_CONFIG)),
-    canPrompt:
-      overrides.canPrompt ??
-      vi.fn<MockGateHandlerSession["canPrompt"]>().mockReturnValue(true),
-    prompt:
-      overrides.prompt ??
-      vi
-        .fn<MockGateHandlerSession["prompt"]>()
-        .mockResolvedValue({ approved: true, state: "approved_for_session" }),
-    // Delegations — closures read `session` at call time so overrides win.
+    // Resolve delegation — closure reads `session` at call time so overrides win.
     resolve:
       overrides.resolve ??
       vi.fn<MockGateHandlerSession["resolve"]>((surface, input, agentName) =>
@@ -173,34 +164,31 @@ function makeStatefulSession(
           session.getSessionRuleset(),
         ),
       ),
-    canConfirm:
-      overrides.canConfirm ??
-      vi.fn<MockGateHandlerSession["canConfirm"]>(() =>
-        session.canPrompt(undefined as unknown as ExtensionContext),
-      ),
-    promptPermission:
-      overrides.promptPermission ??
-      vi.fn<MockGateHandlerSession["promptPermission"]>(
-        (details: PromptPermissionDetails) =>
-          session.prompt(undefined as unknown as ExtensionContext, details),
-      ),
   };
   return session;
 }
 
 function makeHandlerForSession(
   session: MockGateHandlerSession,
-): PermissionGateHandler {
+  prompter?: GatePrompter,
+): { handler: PermissionGateHandler; prompter: GatePrompter } {
   const events = makeEvents();
   const reporter = new GateDecisionReporter(session.logger, events);
-  const runner = new GateRunner(session, session, session, reporter);
-  return new PermissionGateHandler(
+  const resolvedPrompter: GatePrompter = prompter ?? {
+    canConfirm: vi.fn().mockReturnValue(true),
+    prompt: vi
+      .fn<GatePrompter["prompt"]>()
+      .mockResolvedValue({ approved: true, state: "approved_for_session" }),
+  };
+  const runner = new GateRunner(session, session, resolvedPrompter, reporter);
+  const handler = new PermissionGateHandler(
     session,
     makeToolRegistry(),
     new ToolCallGatePipeline(session),
     new SkillInputGatePipeline(session),
     runner,
   );
+  return { handler, prompter: resolvedPrompter };
 }
 
 function makeToolRegistry(): ToolRegistry {
@@ -223,7 +211,7 @@ describe("external-directory session dedup", () => {
   describe("path-bearing tools (read, write, edit)", () => {
     it("does not re-prompt for the same external path after session approval", async () => {
       const session = makeStatefulSession();
-      const handler = makeHandlerForSession(session);
+      const { handler, prompter } = makeHandlerForSession(session);
       const ctx = makeCtx();
       const externalPath = "/outside/project/data.txt";
 
@@ -236,7 +224,7 @@ describe("external-directory session dedup", () => {
       };
       const result1 = await handler.handleToolCall(event1, ctx);
       expect(result1).toEqual({});
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — same path, should hit session rule, no prompt
       const event2 = {
@@ -247,12 +235,12 @@ describe("external-directory session dedup", () => {
       };
       const result2 = await handler.handleToolCall(event2, ctx);
       expect(result2).toEqual({});
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
     });
 
     it("does not re-prompt for a different file in the same external directory", async () => {
       const session = makeStatefulSession();
-      const handler = makeHandlerForSession(session);
+      const { handler, prompter } = makeHandlerForSession(session);
       const ctx = makeCtx();
 
       // First call — prompt for /outside/project/a.txt
@@ -263,7 +251,7 @@ describe("external-directory session dedup", () => {
         input: { path: "/outside/project/a.txt" },
       };
       await handler.handleToolCall(event1, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — /outside/project/b.txt is in the same directory
       const event2 = {
@@ -273,12 +261,12 @@ describe("external-directory session dedup", () => {
         input: { path: "/outside/project/b.txt" },
       };
       await handler.handleToolCall(event2, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
     });
 
     it("does prompt for a file in a different external directory", async () => {
       const session = makeStatefulSession();
-      const handler = makeHandlerForSession(session);
+      const { handler, prompter } = makeHandlerForSession(session);
       const ctx = makeCtx();
 
       // First call — /outside/alpha/file.txt
@@ -289,7 +277,7 @@ describe("external-directory session dedup", () => {
         input: { path: "/outside/alpha/file.txt" },
       };
       await handler.handleToolCall(event1, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — /outside/beta/file.txt is a different directory
       const event2 = {
@@ -299,16 +287,18 @@ describe("external-directory session dedup", () => {
         input: { path: "/outside/beta/file.txt" },
       };
       await handler.handleToolCall(event2, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(2);
+      expect(prompter.prompt).toHaveBeenCalledTimes(2);
     });
 
     it("re-prompts when user approved once (not for session)", async () => {
-      const session = makeStatefulSession({
+      const session = makeStatefulSession();
+      const approveOnce: GatePrompter = {
+        canConfirm: vi.fn().mockReturnValue(true),
         prompt: vi
-          .fn()
+          .fn<GatePrompter["prompt"]>()
           .mockResolvedValue({ approved: true, state: "approved" }),
-      });
-      const handler = makeHandlerForSession(session);
+      };
+      const { handler, prompter } = makeHandlerForSession(session, approveOnce);
       const ctx = makeCtx();
       const externalPath = "/outside/project/data.txt";
 
@@ -320,7 +310,7 @@ describe("external-directory session dedup", () => {
         input: { path: externalPath },
       };
       await handler.handleToolCall(event1, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — no session rule recorded, should prompt again
       const event2 = {
@@ -330,14 +320,14 @@ describe("external-directory session dedup", () => {
         input: { path: externalPath },
       };
       await handler.handleToolCall(event2, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(2);
+      expect(prompter.prompt).toHaveBeenCalledTimes(2);
     });
   });
 
   describe("bash commands with external paths", () => {
     it("does not re-prompt for a bash command referencing the same external path after session approval", async () => {
       const session = makeStatefulSession();
-      const handler = makeHandlerForSession(session);
+      const { handler, prompter } = makeHandlerForSession(session);
       const ctx = makeCtx();
 
       // First call — bash referencing /tmp/out.txt
@@ -349,7 +339,7 @@ describe("external-directory session dedup", () => {
       };
       const result1 = await handler.handleToolCall(event1, ctx);
       expect(result1).toEqual({});
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — different bash command, same external path
       const event2 = {
@@ -360,12 +350,12 @@ describe("external-directory session dedup", () => {
       };
       const result2 = await handler.handleToolCall(event2, ctx);
       expect(result2).toEqual({});
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
     });
 
     it("does not re-prompt for read after bash already approved the same directory", async () => {
       const session = makeStatefulSession();
-      const handler = makeHandlerForSession(session);
+      const { handler, prompter } = makeHandlerForSession(session);
       const ctx = makeCtx();
 
       // First call — bash writes to /tmp/out.txt
@@ -376,7 +366,7 @@ describe("external-directory session dedup", () => {
         input: { command: "echo hello > /tmp/out.txt" },
       };
       await handler.handleToolCall(event1, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
 
       // Second call — read from /tmp/out.txt (same directory, different tool)
       const event2 = {
@@ -386,7 +376,7 @@ describe("external-directory session dedup", () => {
         input: { path: "/tmp/out.txt" },
       };
       await handler.handleToolCall(event2, ctx);
-      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(prompter.prompt).toHaveBeenCalledTimes(1);
     });
   });
 });

package/test/handlers/gates/runner.test.ts

@@ -81,9 +81,7 @@ describe("GateRunner — descriptor path", () => {
   it("returns allow and emits user_approved when ask + user approves", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
+      prompt: vi.fn().mockResolvedValue({ approved: true, state: "approved" }),
     });
     const result = await runner.run(makeDescriptor(), null, "tc-1");
     expect(result).toEqual({ action: "allow" });
@@ -98,7 +96,7 @@ describe("GateRunner — descriptor path", () => {
   it("returns allow, emits user_approved_for_session, and records session rule on approved_for_session", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
+      prompt: vi
         .fn()
         .mockResolvedValue({ approved: true, state: "approved_for_session" }),
     });
@@ -120,7 +118,7 @@ describe("GateRunner — descriptor path", () => {
   it("calls recordSessionApproval once with the full SessionApproval when sessionApproval has multiple patterns", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
+      prompt: vi
         .fn()
         .mockResolvedValue({ approved: true, state: "approved_for_session" }),
     });
@@ -138,9 +136,7 @@ describe("GateRunner — descriptor path", () => {
   it("returns block and emits user_denied when ask + user denies", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: false, state: "denied" }),
+      prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
     });
     const result = await runner.run(makeDescriptor(), null, "tc-1");
     expect(result).toMatchObject({ action: "block" });
@@ -170,7 +166,7 @@ describe("GateRunner — descriptor path", () => {
   it("emits auto_approved resolution when decision has autoApproved flag", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi.fn().mockResolvedValue({
+      prompt: vi.fn().mockResolvedValue({
         approved: true,
         state: "approved",
         autoApproved: true,
@@ -227,12 +223,12 @@ describe("GateRunner — descriptor path", () => {
     );
   });
 
-  it("passes requestId from toolCallId to promptPermission", async () => {
+  it("passes requestId from toolCallId to prompt", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
     });
     await runner.run(makeDescriptor(), null, "tc-42");
-    expect(deps.promptPermission).toHaveBeenCalledWith(
+    expect(deps.prompt).toHaveBeenCalledWith(
       expect.objectContaining({ requestId: "tc-42" }),
     );
   });
@@ -240,9 +236,7 @@ describe("GateRunner — descriptor path", () => {
   it("does not call recordSessionApproval when user approves once (no sessionApproval)", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
+      prompt: vi.fn().mockResolvedValue({ approved: true, state: "approved" }),
     });
     await runner.run(makeDescriptor(), null, "tc-1");
     expect(deps.recordSessionApproval).not.toHaveBeenCalled();
@@ -272,7 +266,7 @@ describe("GateRunner — descriptor path", () => {
   it("does not call recordSessionApproval when user approves for session but no sessionApproval on descriptor", async () => {
     const { runner, deps } = makeGateRunner({
       resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-      promptPermission: vi
+      prompt: vi
         .fn()
         .mockResolvedValue({ approved: true, state: "approved_for_session" }),
     });
@@ -323,7 +317,7 @@ describe("GateRunner — descriptor path", () => {
     it("uses denialContext to format userDeniedReason with extension tag", async () => {
       const { runner } = makeGateRunner({
         resolveResult: makeCheckResult({ state: "ask", matchedPattern: "*" }),
-        promptPermission: vi.fn().mockResolvedValue({
+        prompt: vi.fn().mockResolvedValue({
           approved: false,
           state: "denied",
           denialReason: "too risky",

package/test/handlers/input-events.test.ts

@@ -3,6 +3,7 @@
  */
 import { describe, expect, it, vi } from "vitest";
 
+import type { GatePrompter } from "#src/gate-prompter";
 import {
   getDecisionEvents,
   makeCheckResult,
@@ -70,8 +71,11 @@ describe("handleInput decision events — skill gate", () => {
     const { handler, events } = makeHandler({
       session: {
         checkPermission: makeSkillCheckPermission("ask"),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
         prompt: vi
-          .fn()
+          .fn<GatePrompter["prompt"]>()
           .mockResolvedValue({ approved: true, state: "approved" }),
       },
     });
@@ -91,7 +95,12 @@ describe("handleInput decision events — skill gate", () => {
     const { handler, events } = makeHandler({
       session: {
         checkPermission: makeSkillCheckPermission("ask"),
-        prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi
+          .fn<GatePrompter["prompt"]>()
+          .mockResolvedValue({ approved: false, state: "denied" }),
       },
     });
     await handler.handleInput({ text: "/skill:explorer" }, makeCtx());
@@ -110,7 +119,10 @@ describe("handleInput decision events — skill gate", () => {
     const { handler, events } = makeHandler({
       session: {
         checkPermission: makeSkillCheckPermission("ask"),
-        canPrompt: vi.fn().mockReturnValue(false),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(false),
+        prompt: vi.fn<GatePrompter["prompt"]>(),
       },
     });
     await handler.handleInput(
@@ -132,7 +144,10 @@ describe("handleInput decision events — skill gate", () => {
     const { handler, events } = makeHandler({
       session: {
         checkPermission: makeSkillCheckPermission("ask"),
-        prompt: vi.fn().mockResolvedValue({
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi.fn<GatePrompter["prompt"]>().mockResolvedValue({
           approved: true,
           state: "approved",
           autoApproved: true,

package/test/handlers/input.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-
+import type { GatePrompter } from "#src/gate-prompter";
 import { extractSkillNameFromInput } from "#src/handlers/permission-gate-handler";
 
 import { makeCtx, makeHandler } from "#test/helpers/handler-fixtures";
@@ -120,7 +120,10 @@ describe("handleInput", () => {
     const { handler } = makeHandler({
       session: {
         checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-        canPrompt: vi.fn().mockReturnValue(false),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(false),
+        prompt: vi.fn<GatePrompter["prompt"]>(),
       },
     });
     const result = await handler.handleInput(
@@ -131,12 +134,16 @@ describe("handleInput", () => {
   });
 
   it("prompts and returns continue when skill ask is approved", async () => {
-    const { handler, session } = makeHandler({
+    const approvePrompt = vi
+      .fn<GatePrompter["prompt"]>()
+      .mockResolvedValue({ approved: true, state: "approved" });
+    const { handler, prompter } = makeHandler({
       session: {
         checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-        prompt: vi
-          .fn()
-          .mockResolvedValue({ approved: true, state: "approved" }),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: approvePrompt,
       },
     });
     const result = await handler.handleInput(
@@ -144,14 +151,19 @@ describe("handleInput", () => {
       makeCtx(),
     );
     expect(result).toEqual({ action: "continue" });
-    expect(session.prompt).toHaveBeenCalledOnce();
+    expect(prompter.prompt).toHaveBeenCalledOnce();
   });
 
   it("returns handled when skill ask is denied by user", async () => {
     const { handler } = makeHandler({
       session: {
         checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-        prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi
+          .fn<GatePrompter["prompt"]>()
+          .mockResolvedValue({ approved: false, state: "denied" }),
       },
     });
     const result = await handler.handleInput(
@@ -162,17 +174,21 @@ describe("handleInput", () => {
   });
 
   it("passes agentName in the prompt permission request", async () => {
-    const { handler, session } = makeHandler({
+    const approvePrompt = vi
+      .fn<GatePrompter["prompt"]>()
+      .mockResolvedValue({ approved: true, state: "approved" });
+    const { handler, prompter } = makeHandler({
       session: {
         checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
         resolveAgentName: vi.fn().mockReturnValue("code-agent"),
-        prompt: vi
-          .fn()
-          .mockResolvedValue({ approved: true, state: "approved" }),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: approvePrompt,
       },
     });
     await handler.handleInput(makeInputEvent("/skill:librarian"), makeCtx());
-    expect(session.promptPermission).toHaveBeenCalledWith(
+    expect(prompter.prompt).toHaveBeenCalledWith(
       expect.objectContaining({
         agentName: "code-agent",
         skillName: "librarian",

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

@@ -4,6 +4,7 @@
  */
 import { describe, expect, it, vi } from "vitest";
 
+import type { GatePrompter } from "#src/gate-prompter";
 import {
   getDecisionEvents,
   makeCheckResult,
@@ -110,8 +111,11 @@ describe("handleToolCall decision events — user_approved", () => {
         checkPermission: vi
           .fn()
           .mockReturnValue(makeCheckResult({ state: "ask" })),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
         prompt: vi
-          .fn()
+          .fn<GatePrompter["prompt"]>()
           .mockResolvedValue({ approved: true, state: "approved" }),
       },
     });
@@ -132,7 +136,10 @@ describe("handleToolCall decision events — user_approved", () => {
         checkPermission: vi
           .fn()
           .mockReturnValue(makeCheckResult({ state: "ask" })),
-        prompt: vi.fn().mockResolvedValue({
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi.fn<GatePrompter["prompt"]>().mockResolvedValue({
           approved: true,
           state: "approved_for_session",
         }),
@@ -159,7 +166,12 @@ describe("handleToolCall decision events — user_denied", () => {
         checkPermission: vi
           .fn()
           .mockReturnValue(makeCheckResult({ state: "ask" })),
-        prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi
+          .fn<GatePrompter["prompt"]>()
+          .mockResolvedValue({ approved: false, state: "denied" }),
       },
     });
 
@@ -183,7 +195,10 @@ describe("handleToolCall decision events — confirmation_unavailable", () => {
         checkPermission: vi
           .fn()
           .mockReturnValue(makeCheckResult({ state: "ask" })),
-        canPrompt: vi.fn().mockReturnValue(false),
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(false),
+        prompt: vi.fn<GatePrompter["prompt"]>(),
       },
     });
 
@@ -239,7 +254,10 @@ describe("handleToolCall decision events — auto_approved", () => {
         checkPermission: vi
           .fn()
           .mockReturnValue(makeCheckResult({ state: "ask" })),
-        prompt: vi.fn().mockResolvedValue({
+      },
+      prompter: {
+        canConfirm: vi.fn().mockReturnValue(true),
+        prompt: vi.fn<GatePrompter["prompt"]>().mockResolvedValue({
           approved: true,
           state: "approved",
           autoApproved: true,

package/test/helpers/gate-fixtures.ts

@@ -94,7 +94,7 @@ export function makeGateRunner(
     resolve?: PermissionResolver["resolve"];
     recordSessionApproval?: SessionApprovalRecorder["recordSessionApproval"];
     canConfirm?: GatePrompter["canConfirm"];
-    promptPermission?: GatePrompter["promptPermission"];
+    prompt?: GatePrompter["prompt"];
     reporter?: Partial<DecisionReporter>;
   } = {},
 ) {
@@ -112,15 +112,15 @@ export function makeGateRunner(
   const canConfirm =
     overrides.canConfirm ??
     (vi.fn().mockReturnValue(true) as GatePrompter["canConfirm"]);
-  const promptPermission =
-    overrides.promptPermission ??
+  const prompt =
+    overrides.prompt ??
     vi
-      .fn<GatePrompter["promptPermission"]>()
+      .fn<GatePrompter["prompt"]>()
       .mockResolvedValue({ approved: true, state: "approved" });
   const runner = new GateRunner(
     { resolve },
     { recordSessionApproval },
-    { canConfirm, promptPermission },
+    { canConfirm, prompt },
     reporter,
   );
   return {
@@ -129,7 +129,7 @@ export function makeGateRunner(
       resolve,
       recordSessionApproval,
       canConfirm,
-      promptPermission,
+      prompt,
       reporter,
     },
   };