@gotgenes/pi-permission-system 10.3.1 → 10.5.0

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/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-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

@@ -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,10 +91,10 @@ export function makeReporter(
 export function makeGateRunner(
   overrides: {
     resolveResult?: PermissionCheckResult;
-    resolve?: PermissionResolver["resolve"];
+    resolve?: ScopedPermissionResolver["resolve"];
     recordSessionApproval?: SessionApprovalRecorder["recordSessionApproval"];
     canConfirm?: GatePrompter["canConfirm"];
-    promptPermission?: GatePrompter["promptPermission"];
+    prompt?: GatePrompter["prompt"];
     reporter?: Partial<DecisionReporter>;
   } = {},
 ) {
@@ -102,7 +102,7 @@ export function makeGateRunner(
   const resolve =
     overrides.resolve ??
     vi
-      .fn<PermissionResolver["resolve"]>()
+      .fn<ScopedPermissionResolver["resolve"]>()
       .mockReturnValue(
         overrides.resolveResult ?? makeCheckResult({ matchedPattern: "*" }),
       );
@@ -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,
     },
   };
@@ -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[]>(() => []),