@gotgenes/pi-permission-system 10.0.0 → 10.2.0

package/src/service-lifecycle.ts

@@ -0,0 +1,49 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { emitReadyEvent, type PermissionEventBus } from "./permission-events";
+import {
+  type PermissionsService,
+  publishPermissionsService,
+  unpublishPermissionsService,
+} from "./service";
+import { isRegisteredSubagentChild } from "./subagent-context";
+import type { SubagentSessionRegistry } from "./subagent-registry";
+
+/** The session-scoped service lifecycle that the lifecycle handler drives. */
+export interface ServiceLifecycle {
+  activate(ctx: ExtensionContext): void;
+  teardown(): void;
+}
+
+/**
+ * Owns the process-global service publication lifecycle for one extension
+ * instance.
+ *
+ * - `activate` publishes the service (skipped for registered subagent children
+ *   so they never clobber the parent's slot — see #302), then emits the ready
+ *   event.
+ * - `teardown` runs all session-scoped subscription cleanups in order, then
+ *   unpublishes the service.
+ */
+export class PermissionServiceLifecycle implements ServiceLifecycle {
+  constructor(
+    private readonly service: PermissionsService,
+    private readonly registry: SubagentSessionRegistry,
+    private readonly events: PermissionEventBus,
+    private readonly subscriptions: readonly (() => void)[],
+  ) {}
+
+  activate(ctx: ExtensionContext): void {
+    if (!isRegisteredSubagentChild(ctx, this.registry)) {
+      publishPermissionsService(this.service);
+    }
+    emitReadyEvent(this.events);
+  }
+
+  teardown(): void {
+    for (const unsubscribe of this.subscriptions) {
+      unsubscribe();
+    }
+    unpublishPermissionsService(this.service);
+  }
+}

package/src/session-approval-recorder.ts

@@ -0,0 +1,6 @@
+import type { SessionApproval } from "./session-approval";
+
+/** Records a granted session-scoped approval into the session ruleset. */
+export interface SessionApprovalRecorder {
+  recordSessionApproval(approval: SessionApproval): void;
+}

package/src/session-lifecycle-session.ts

@@ -0,0 +1,24 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { SessionLogger } from "./session-logger";
+
+/**
+ * The session surface `SessionLifecycleHandler` invokes across
+ * `session_start`, `resources_discover`, and `session_shutdown`: refresh and
+ * report config, reset / reload / shut down session state, resolve the agent
+ * name, surface config issues, read the runtime context, and log.
+ *
+ * `activate` is intentionally absent — the lifecycle handler never calls it
+ * directly (ISP: do not depend on methods you do not use).
+ */
+export interface SessionLifecycleSession {
+  refreshConfig(ctx?: ExtensionContext): void;
+  resetForNewSession(ctx: ExtensionContext): void;
+  logResolvedConfigPaths(): void;
+  resolveAgentName(ctx: ExtensionContext, systemPrompt?: string): string | null;
+  getConfigIssues(agentName?: string): string[];
+  reload(): void;
+  getRuntimeContext(): ExtensionContext | null;
+  shutdown(): void;
+  readonly logger: SessionLogger;
+}

package/src/tool-input-preview.ts

@@ -1,4 +1,3 @@
-import { getNonEmptyString, toRecord } from "./common";
 import { safeJsonStringify } from "./logging";
 
 export const TOOL_INPUT_PREVIEW_MAX_LENGTH = 200;
@@ -25,67 +24,6 @@ export function formatCount(
   return `${value} ${value === 1 ? singular : plural}`;
 }
 
-export function getPromptPath(input: Record<string, unknown>): string | null {
-  return getNonEmptyString(input.path) ?? getNonEmptyString(input.file_path);
-}
-
-export function formatEditInputForPrompt(
-  input: Record<string, unknown>,
-): string {
-  const path = getPromptPath(input);
-  const rawEdits = Array.isArray(input.edits)
-    ? input.edits
-    : typeof input.oldText === "string" && typeof input.newText === "string"
-      ? [{ oldText: input.oldText, newText: input.newText }]
-      : [];
-
-  const edits = rawEdits
-    .map((edit) => toRecord(edit))
-    .filter(
-      (edit) =>
-        typeof edit.oldText === "string" && typeof edit.newText === "string",
-    );
-
-  const pathPart = path ? `for '${path}'` : "";
-  if (edits.length === 0) {
-    return pathPart ? `${pathPart} with edit input` : "with edit input";
-  }
-
-  const firstEdit = edits[0];
-  const oldText = String(firstEdit.oldText);
-  const newText = String(firstEdit.newText);
-  const firstEditSummary = `edit #1 replaces ${formatCount(countTextLines(oldText), "line", "lines")} with ${formatCount(countTextLines(newText), "line", "lines")}`;
-  const extraEdits =
-    edits.length > 1
-      ? `, plus ${formatCount(edits.length - 1, "additional edit", "additional edits")}`
-      : "";
-  const summary = `(${formatCount(edits.length, "replacement", "replacements")}: ${firstEditSummary}${extraEdits})`;
-  return pathPart ? `${pathPart} ${summary}` : summary;
-}
-
-export function formatWriteInputForPrompt(
-  input: Record<string, unknown>,
-): string {
-  const path = getPromptPath(input);
-  const content = typeof input.content === "string" ? input.content : "";
-  const summary = `(${formatCount(countTextLines(content), "line", "lines")}, ${formatCount(content.length, "character", "characters")})`;
-  return path ? `for '${path}' ${summary}` : summary;
-}
-
-export function formatReadInputForPrompt(
-  input: Record<string, unknown>,
-): string {
-  const path = getPromptPath(input);
-  const parts = path ? [`path '${path}'`] : [];
-  if (typeof input.offset === "number") {
-    parts.push(`offset ${input.offset}`);
-  }
-  if (typeof input.limit === "number") {
-    parts.push(`limit ${input.limit}`);
-  }
-  return parts.length > 0 ? `for ${parts.join(", ")}` : "";
-}
-
 export function serializeToolInputPreview(input: unknown): string {
   const serialized = safeJsonStringify(input);
   if (!serialized || serialized === "{}" || serialized === "null") {

package/src/tool-input-prompt-formatters.ts

@@ -0,0 +1,63 @@
+import { getNonEmptyString, toRecord } from "./common";
+import { countTextLines, formatCount } from "./tool-input-preview";
+
+export function getPromptPath(input: Record<string, unknown>): string | null {
+  return getNonEmptyString(input.path) ?? getNonEmptyString(input.file_path);
+}
+
+export function formatEditInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const rawEdits = Array.isArray(input.edits)
+    ? input.edits
+    : typeof input.oldText === "string" && typeof input.newText === "string"
+      ? [{ oldText: input.oldText, newText: input.newText }]
+      : [];
+
+  const edits = rawEdits
+    .map((edit) => toRecord(edit))
+    .filter(
+      (edit) =>
+        typeof edit.oldText === "string" && typeof edit.newText === "string",
+    );
+
+  const pathPart = path ? `for '${path}'` : "";
+  if (edits.length === 0) {
+    return pathPart ? `${pathPart} with edit input` : "with edit input";
+  }
+
+  const firstEdit = edits[0];
+  const oldText = String(firstEdit.oldText);
+  const newText = String(firstEdit.newText);
+  const firstEditSummary = `edit #1 replaces ${formatCount(countTextLines(oldText), "line", "lines")} with ${formatCount(countTextLines(newText), "line", "lines")}`;
+  const extraEdits =
+    edits.length > 1
+      ? `, plus ${formatCount(edits.length - 1, "additional edit", "additional edits")}`
+      : "";
+  const summary = `(${formatCount(edits.length, "replacement", "replacements")}: ${firstEditSummary}${extraEdits})`;
+  return pathPart ? `${pathPart} ${summary}` : summary;
+}
+
+export function formatWriteInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const content = typeof input.content === "string" ? input.content : "";
+  const summary = `(${formatCount(countTextLines(content), "line", "lines")}, ${formatCount(content.length, "character", "characters")})`;
+  return path ? `for '${path}' ${summary}` : summary;
+}
+
+export function formatReadInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const parts = path ? [`path '${path}'`] : [];
+  if (typeof input.offset === "number") {
+    parts.push(`offset ${input.offset}`);
+  }
+  if (typeof input.limit === "number") {
+    parts.push(`limit ${input.limit}`);
+  }
+  return parts.length > 0 ? `for ${parts.join(", ")}` : "";
+}

package/src/tool-preview-formatter.ts

@@ -2,16 +2,18 @@ import { getNonEmptyString, toRecord } from "./common";
 import type { PermissionSystemExtensionConfig } from "./extension-config";
 import type { ToolInputFormatterLookup } from "./tool-input-formatter-registry";
 import {
-  formatEditInputForPrompt,
-  formatReadInputForPrompt,
-  formatWriteInputForPrompt,
-  getPromptPath,
   serializeToolInputPreview,
   TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
   TOOL_INPUT_PREVIEW_MAX_LENGTH,
   TOOL_TEXT_SUMMARY_MAX_LENGTH,
   truncateInlineText,
 } from "./tool-input-preview";
+import {
+  formatEditInputForPrompt,
+  formatReadInputForPrompt,
+  formatWriteInputForPrompt,
+  getPromptPath,
+} from "./tool-input-prompt-formatters";
 import type { PermissionCheckResult } from "./types";
 
 export interface ToolPreviewFormatterOptions {

package/test/decision-reporter.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  type DecisionReporter,
+  GateDecisionReporter,
+} from "#src/decision-reporter";
+import {
+  PERMISSIONS_DECISION_CHANNEL,
+  type PermissionDecisionEvent,
+} from "#src/permission-events";
+import type { SessionLogger } from "#src/session-logger";
+
+// ── fixtures ───────────────────────────────────────────────────────────────
+
+function makeLogger(): SessionLogger {
+  return {
+    debug: vi.fn(),
+    review: vi.fn(),
+    warn: vi.fn(),
+  };
+}
+
+function makeEvents() {
+  return {
+    emit: vi.fn(),
+    on: vi.fn().mockReturnValue(() => undefined),
+  };
+}
+
+function makeDecisionEvent(
+  overrides: Partial<PermissionDecisionEvent> = {},
+): PermissionDecisionEvent {
+  return {
+    surface: "read",
+    value: "read",
+    result: "allow",
+    resolution: "policy_allow",
+    origin: "global",
+    agentName: null,
+    matchedPattern: null,
+    ...overrides,
+  };
+}
+
+// ── tests ──────────────────────────────────────────────────────────────────
+
+describe("GateDecisionReporter", () => {
+  it("satisfies the DecisionReporter interface", () => {
+    const reporter: DecisionReporter = new GateDecisionReporter(
+      makeLogger(),
+      makeEvents(),
+    );
+    expect(reporter).toBeDefined();
+  });
+
+  describe("writeReviewLog", () => {
+    it("delegates to logger.review with event and details", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.writeReviewLog("permission_request.blocked", { tool: "bash" });
+      expect(logger.review).toHaveBeenCalledWith("permission_request.blocked", {
+        tool: "bash",
+      });
+    });
+
+    it("delegates with an empty details object", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.writeReviewLog("permission_request.session_approved", {});
+      expect(logger.review).toHaveBeenCalledWith(
+        "permission_request.session_approved",
+        {},
+      );
+    });
+
+    it("does not call emitDecision", () => {
+      const events = makeEvents();
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      reporter.writeReviewLog("some.event", { key: "val" });
+      expect(events.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("emitDecision", () => {
+    it("emits on the PERMISSIONS_DECISION_CHANNEL with the event", () => {
+      const events = makeEvents();
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      const event = makeDecisionEvent();
+      reporter.emitDecision(event);
+      expect(events.emit).toHaveBeenCalledWith(
+        PERMISSIONS_DECISION_CHANNEL,
+        event,
+      );
+    });
+
+    it("does not call writeReviewLog", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.emitDecision(makeDecisionEvent());
+      expect(logger.review).not.toHaveBeenCalled();
+    });
+
+    it("does not propagate a throwing listener", () => {
+      const events = makeEvents();
+      events.emit.mockImplementation(() => {
+        throw new Error("listener boom");
+      });
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      expect(() => reporter.emitDecision(makeDecisionEvent())).not.toThrow();
+    });
+  });
+});

package/test/denial-messages.test.ts

@@ -265,6 +265,31 @@ describe("formatDenyReason", () => {
       );
     });
   });
+
+  describe("skill_input context", () => {
+    test("without agent", () => {
+      expect(
+        formatDenyReason({
+          kind: "skill_input",
+          skillName: "librarian",
+        }),
+      ).toBe(
+        "[pi-permission-system] Current agent is not permitted to access skill 'librarian'.",
+      );
+    });
+
+    test("with agent", () => {
+      expect(
+        formatDenyReason({
+          kind: "skill_input",
+          skillName: "librarian",
+          agentName: "my-agent",
+        }),
+      ).toBe(
+        "[pi-permission-system] Agent 'my-agent' is not permitted to access skill 'librarian'.",
+      );
+    });
+  });
 });
 
 // ── formatUnavailableReason ────────────────────────────────────────────────
@@ -353,6 +378,17 @@ describe("formatUnavailableReason", () => {
       "[pi-permission-system] Accessing skill 'librarian' requires approval, but no interactive UI is available.",
     );
   });
+
+  test("skill_input", () => {
+    expect(
+      formatUnavailableReason({
+        kind: "skill_input",
+        skillName: "librarian",
+      }),
+    ).toBe(
+      "[pi-permission-system] Accessing skill 'librarian' requires approval, but no interactive UI is available.",
+    );
+  });
 });
 
 // ── formatUserDeniedReason ─────────────────────────────────────────────────
@@ -530,4 +566,30 @@ describe("formatUserDeniedReason", () => {
       );
     });
   });
+
+  describe("skill_input context", () => {
+    test("without agent and without reason", () => {
+      expect(
+        formatUserDeniedReason({
+          kind: "skill_input",
+          skillName: "librarian",
+        }),
+      ).toBe("[pi-permission-system] User denied access to skill 'librarian'.");
+    });
+
+    test("with agent and with reason", () => {
+      expect(
+        formatUserDeniedReason(
+          {
+            kind: "skill_input",
+            skillName: "librarian",
+            agentName: "code-agent",
+          },
+          "not permitted",
+        ),
+      ).toBe(
+        "[pi-permission-system] User denied access to skill 'librarian'. Reason: not permitted.",
+      );
+    });
+  });
 });

package/test/forwarding-manager.test.ts

@@ -4,13 +4,11 @@ import { ForwardingManager } from "#src/forwarding-manager";
 
 // ── Mocks ─────────────────────────────────────────────────────────────────
 
-const mockProcessForwardedPermissionRequests = vi.hoisted(() => vi.fn());
+const mockProcessInbox = vi.hoisted(() =>
+  vi.fn((): Promise<void> => Promise.resolve()),
+);
 const mockIsSubagentExecutionContext = vi.hoisted(() => vi.fn());
 
-vi.mock("../src/forwarded-permissions/polling", () => ({
-  processForwardedPermissionRequests: mockProcessForwardedPermissionRequests,
-}));
-
 vi.mock("../src/subagent-context", () => ({
   isSubagentExecutionContext: mockIsSubagentExecutionContext,
 }));
@@ -27,22 +25,12 @@ function makeCtx(overrides: { hasUI?: boolean; sessionId?: string } = {}) {
   } as unknown as import("@earendil-works/pi-coding-agent").ExtensionContext;
 }
 
-function makeForwardingDeps() {
-  return {
-    forwardingDir: "/agent/sessions/permission-forwarding",
-    subagentSessionsDir: "/agent/subagent-sessions",
-    logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-    writeReviewLog: vi.fn(),
-    requestPermissionDecisionFromUi: vi.fn(),
-    shouldAutoApprove: vi.fn().mockReturnValue(false),
-  } as unknown as import("../src/forwarded-permissions/polling").PermissionForwardingDeps;
+function makeForwarder() {
+  return { processInbox: mockProcessInbox };
 }
 
 function makeManager() {
-  return new ForwardingManager(
-    "/agent/subagent-sessions",
-    makeForwardingDeps(),
-  );
+  return new ForwardingManager("/agent/subagent-sessions", makeForwarder());
 }
 
 // ── Tests ─────────────────────────────────────────────────────────────────
@@ -52,8 +40,8 @@ describe("ForwardingManager", () => {
     vi.useFakeTimers();
     mockIsSubagentExecutionContext.mockReset();
     mockIsSubagentExecutionContext.mockReturnValue(false);
-    mockProcessForwardedPermissionRequests.mockReset();
-    mockProcessForwardedPermissionRequests.mockResolvedValue(undefined);
+    mockProcessInbox.mockReset();
+    mockProcessInbox.mockResolvedValue(undefined);
   });
 
   afterEach(() => {
@@ -73,9 +61,9 @@ describe("ForwardingManager", () => {
       manager.stop();
 
       // After stop, the timer fires no more callbacks.
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
   });
 
@@ -86,7 +74,7 @@ describe("ForwardingManager", () => {
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("stops any existing poll and does not start a new one when hasUI is false", async () => {
@@ -98,9 +86,9 @@ describe("ForwardingManager", () => {
       // Now stop the polling by calling start() with no-UI ctx.
       manager.start(noUiCtx);
 
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("does not start polling when isSubagentExecutionContext returns true", async () => {
@@ -110,7 +98,7 @@ describe("ForwardingManager", () => {
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("stops any existing poll when called with a subagent context", async () => {
@@ -124,21 +112,18 @@ describe("ForwardingManager", () => {
       const ctx2 = makeCtx();
       manager.start(ctx2);
 
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
-    it("starts polling and calls processForwardedPermissionRequests on tick", async () => {
+    it("starts polling and calls processInbox on tick", async () => {
       const manager = makeManager();
       const ctx = makeCtx();
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
-        ctx,
-        expect.anything(),
-      );
+      expect(mockProcessInbox).toHaveBeenCalledWith(ctx);
     });
 
     it("is idempotent — calling start() twice does not create a second timer", async () => {
@@ -149,7 +134,7 @@ describe("ForwardingManager", () => {
 
       await vi.advanceTimersByTimeAsync(250);
       // Only one tick should fire per interval, not two.
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
     });
 
     it("updates the context when called again while already running", async () => {
@@ -161,16 +146,13 @@ describe("ForwardingManager", () => {
 
       await vi.advanceTimersByTimeAsync(250);
       // The process call should use the newer context.
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
-        ctx2,
-        expect.anything(),
-      );
+      expect(mockProcessInbox).toHaveBeenCalledWith(ctx2);
     });
 
     it("skips a tick while processing is in progress", async () => {
-      // Make processForwardedPermissionRequests hang so processing=true persists.
+      // Make processInbox hang so processing=true persists.
       let resolveProcess: () => void;
-      mockProcessForwardedPermissionRequests.mockReturnValue(
+      mockProcessInbox.mockReturnValue(
         new Promise<void>((resolve) => {
           resolveProcess = resolve;
         }),
@@ -182,22 +164,22 @@ describe("ForwardingManager", () => {
 
       // First tick starts processing.
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
 
       // Second tick is skipped because processing flag is still true.
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
 
       // Resolve and a third tick should fire.
       resolveProcess!();
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(2);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(2);
     });
 
     it("passes subagentSessionsDir from the constructor to isSubagentExecutionContext", () => {
       const manager = new ForwardingManager(
         "/custom/subagent-dir",
-        makeForwardingDeps(),
+        makeForwarder(),
       );
       const ctx = makeCtx();
       manager.start(ctx);