@gotgenes/pi-permission-system 8.3.1 → 9.0.0

package/test/permission-system.test.ts

@@ -8,6 +8,7 @@ import {
 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { expect, test } from "vitest";
 import {
   createActiveToolsCacheKey,
@@ -46,23 +47,16 @@ import {
   canResolveAskPermissionRequest,
   shouldAutoApprovePermissionState,
 } from "#src/yolo-mode";
+import { type FakePi, makeFakePi } from "#test/helpers/make-fake-pi";
 import {
   type CreateManagerOptions,
   createManager,
 } from "#test/helpers/manager-harness";
 
-type MockHandler = (
-  event: Record<string, unknown>,
-  ctx: Record<string, unknown>,
-) =>
-  | Promise<Record<string, unknown> | undefined>
-  | Record<string, unknown>
-  | undefined;
-
 type ExtensionHarness = {
   baseDir: string;
   cwd: string;
-  handlers: Record<string, MockHandler>;
+  pi: FakePi;
   prompts: string[];
   cleanup: () => Promise<void>;
 };
@@ -112,7 +106,6 @@ function createToolCallHarness(
   const baseDir = mkdtempSync(join(tmpdir(), "pi-permission-system-runtime-"));
   const cwd = options.cwd ?? baseDir;
   const prompts: string[] = [];
-  const handlers: Record<string, MockHandler> = {};
   const originalAgentDir = process.env.PI_CODING_AGENT_DIR;
   const globalConfigPath = getGlobalConfigPath(baseDir);
   mkdirSync(join(baseDir, "agents"), { recursive: true });
@@ -124,22 +117,10 @@ function createToolCallHarness(
     "utf8",
   );
 
+  const pi = makeFakePi({ toolNames });
   process.env.PI_CODING_AGENT_DIR = baseDir;
   try {
-    piPermissionSystemExtension({
-      on: (name: string, handler: MockHandler): void => {
-        handlers[name] = handler;
-      },
-      registerCommand: (): void => {},
-      getAllTools: (): Array<{ name: string }> =>
-        toolNames.map((name) => ({ name })),
-      setActiveTools: (): void => {},
-      registerProvider: (): void => {},
-      events: {
-        emit: (): void => {},
-        on: (): (() => void) => () => undefined,
-      },
-    } as never);
+    piPermissionSystemExtension(pi as unknown as ExtensionAPI);
   } finally {
     if (originalAgentDir === undefined) {
       delete process.env.PI_CODING_AGENT_DIR;
@@ -151,11 +132,13 @@ function createToolCallHarness(
   return {
     baseDir,
     cwd,
-    handlers,
+    pi,
     prompts,
     cleanup: async (): Promise<void> => {
-      await Promise.resolve(
-        handlers.session_shutdown({}, createMockContext(cwd, prompts, options)),
+      await pi.fire(
+        "session_shutdown",
+        {},
+        createMockContext(cwd, prompts, options),
       );
       rmSync(baseDir, { recursive: true, force: true });
     },
@@ -192,15 +175,14 @@ async function runToolCall(
   event: Record<string, unknown>,
   options: ExtensionHarnessOptions = {},
 ): Promise<Record<string, unknown>> {
-  const handler = harness.handlers.tool_call;
-  expect(handler).toBeTypeOf("function");
-
   const result = await withIsolatedSubagentEnv(async () =>
-    Promise.resolve(
-      handler(event, createMockContext(harness.cwd, harness.prompts, options)),
+    harness.pi.fire(
+      "tool_call",
+      event,
+      createMockContext(harness.cwd, harness.prompts, options),
     ),
   );
-  return result ?? {};
+  return (result as Record<string, unknown> | undefined) ?? {};
 }
 
 test("Yolo mode only auto-approves ask-state permissions", () => {
@@ -2335,7 +2317,7 @@ test("session approval: session_shutdown clears session approvals", async () =>
       hasUI: true,
       selectResponse: "Yes",
     });
-    await Promise.resolve(harness.handlers.session_shutdown({}, shutdownCtx));
+    await harness.pi.fire("session_shutdown", {}, shutdownCtx);
 
     // Access same path again — should prompt because cache was cleared
     const result = await runToolCall(

package/test/service.test.ts

@@ -26,7 +26,10 @@ function makeService(
 
 describe("globalThis accessor", () => {
   afterEach(() => {
-    unpublishPermissionsService();
+    const current = getPermissionsService();
+    if (current) {
+      unpublishPermissionsService(current);
+    }
   });
 
   it("returns undefined when nothing has been published", () => {
@@ -47,15 +50,25 @@ describe("globalThis accessor", () => {
     expect(getPermissionsService()).toBe(second);
   });
 
-  it("returns undefined after unpublish", () => {
+  it("removes the slot when it still holds the given service", () => {
     const service = makeService();
     publishPermissionsService(service);
-    unpublishPermissionsService();
+    unpublishPermissionsService(service);
     expect(getPermissionsService()).toBeUndefined();
   });
 
+  it("does not remove the slot when a different service occupies it", () => {
+    const parent = makeService();
+    const child = makeService();
+    publishPermissionsService(parent);
+    // A child instance never published `parent`; unpublishing its own service
+    // must be a no-op that leaves the parent's slot intact.
+    unpublishPermissionsService(child);
+    expect(getPermissionsService()).toBe(parent);
+  });
+
   it("unpublish is safe to call when nothing was published", () => {
-    expect(() => unpublishPermissionsService()).not.toThrow();
+    expect(() => unpublishPermissionsService(makeService())).not.toThrow();
     expect(getPermissionsService()).toBeUndefined();
   });
 });
@@ -64,7 +77,10 @@ describe("globalThis accessor", () => {
 
 describe("service adapter delegation", () => {
   afterEach(() => {
-    unpublishPermissionsService();
+    const current = getPermissionsService();
+    if (current) {
+      unpublishPermissionsService(current);
+    }
   });
 
   const fakeResult: PermissionCheckResult = {
@@ -191,7 +207,10 @@ describe("service adapter delegation", () => {
 
 describe("registerToolInputFormatter delegation", () => {
   afterEach(() => {
-    unpublishPermissionsService();
+    const current = getPermissionsService();
+    if (current) {
+      unpublishPermissionsService(current);
+    }
   });
 
   it("delegates to the registry and returns its disposer", () => {

package/test/subagent-context.test.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { SUBAGENT_ENV_HINT_KEYS } from "#src/permission-forwarding";
 import {
+  isRegisteredSubagentChild,
   isSubagentExecutionContext,
   normalizeFilesystemPath,
 } from "#src/subagent-context";
@@ -12,14 +13,57 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
-function makeCtx(sessionDir: string | null): ExtensionContext {
+function makeCtx(
+  sessionDir: string | null,
+  sessionId: string = "",
+): ExtensionContext {
   return {
     sessionManager: {
       getSessionDir: vi.fn(() => sessionDir),
+      getSessionId: vi.fn(() => sessionId),
     },
   } as unknown as ExtensionContext;
 }
 
+describe("isRegisteredSubagentChild", () => {
+  const childSessionId = "child-session-abc";
+
+  test("returns true when the session id is registered", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register(childSessionId, {});
+    expect(
+      isRegisteredSubagentChild(makeCtx(null, childSessionId), registry),
+    ).toBe(true);
+  });
+
+  test("returns false when the session id is not registered", () => {
+    const registry = new SubagentSessionRegistry();
+    expect(
+      isRegisteredSubagentChild(makeCtx(null, childSessionId), registry),
+    ).toBe(false);
+  });
+
+  test("returns false when the session id is empty", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register("", {});
+    expect(isRegisteredSubagentChild(makeCtx(null, ""), registry)).toBe(false);
+  });
+
+  test("returns false when getSessionId throws", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register(childSessionId, {});
+    const ctx = {
+      sessionManager: {
+        getSessionDir: vi.fn(() => null),
+        getSessionId: vi.fn(() => {
+          throw new Error("session id unavailable");
+        }),
+      },
+    } as unknown as ExtensionContext;
+    expect(isRegisteredSubagentChild(ctx, registry)).toBe(false);
+  });
+});
+
 describe("normalizeFilesystemPath", () => {
   test("normalizes a simple absolute path", () => {
     expect(normalizeFilesystemPath("/projects/my-app")).toBe(
@@ -203,57 +247,75 @@ describe("isSubagentExecutionContext — registry detection", () => {
   const subagentRoot = "/home/user/.pi/agent/sessions/subagents";
   const outsideDir =
     "/home/user/projects/my-app/.pi/agent/sessions/parent/tasks";
+  const childSessionId = "child-session-abc";
 
-  test("returns true when session dir is registered (no env vars, outside filesystem root)", () => {
+  test("returns true when session id is registered (no env vars, dir outside filesystem root)", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register(outsideDir, { agentName: "Explore" });
+    registry.register(childSessionId, {});
     expect(
-      isSubagentExecutionContext(makeCtx(outsideDir), subagentRoot, registry),
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
     ).toBe(true);
   });
 
   test("returns true when registered session has a parentSessionId", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register(outsideDir, {
-      agentName: "Plan",
-      parentSessionId: "parent-123",
-    });
+    registry.register(childSessionId, { parentSessionId: "parent-123" });
     expect(
-      isSubagentExecutionContext(makeCtx(outsideDir), subagentRoot, registry),
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
     ).toBe(true);
   });
 
-  test("returns false when registry is provided but session dir is not registered", () => {
+  test("returns false when registry is provided but session id is not registered", () => {
     const registry = new SubagentSessionRegistry();
     expect(
-      isSubagentExecutionContext(makeCtx(outsideDir), subagentRoot, registry),
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
     ).toBe(false);
   });
 
-  test("returns false when session dir is null and registry has no matching entry", () => {
+  test("returns false when session id is empty and registry has no matching entry", () => {
     const registry = new SubagentSessionRegistry();
     expect(
-      isSubagentExecutionContext(makeCtx(null), subagentRoot, registry),
+      isSubagentExecutionContext(makeCtx(null, ""), subagentRoot, registry),
     ).toBe(false);
   });
 
   test("registry check takes priority over env var detection", () => {
     // Registry says registered; env var not set — should still return true.
     const registry = new SubagentSessionRegistry();
-    registry.register(outsideDir, { agentName: "Explore" });
+    registry.register(childSessionId, {});
     // Confirm no env var is set
     expect(process.env.PI_IS_SUBAGENT).toBeUndefined();
     expect(
-      isSubagentExecutionContext(makeCtx(outsideDir), subagentRoot, registry),
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
     ).toBe(true);
   });
 
   test("unregistered session falls through to env var detection", () => {
     vi.stubEnv("PI_IS_SUBAGENT", "true");
-    const registry = new SubagentSessionRegistry(); // empty — outsideDir not registered
+    const registry = new SubagentSessionRegistry(); // empty — childSessionId not registered
     // Env var present → still true even without registry entry
     expect(
-      isSubagentExecutionContext(makeCtx(outsideDir), subagentRoot, registry),
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
     ).toBe(true);
   });
 

package/test/subagent-lifecycle-events.test.ts

@@ -19,13 +19,11 @@ describe("subscribeSubagentLifecycle", () => {
     subscribeSubagentLifecycle(bus, registry);
 
     bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
-      sessionDir: "/sessions/child-abc",
-      agentName: "Explore",
+      sessionId: "child-session-abc",
       parentSessionId: "parent-42",
     });
 
-    expect(registry.get("/sessions/child-abc")).toEqual({
-      agentName: "Explore",
+    expect(registry.get("child-session-abc")).toEqual({
       parentSessionId: "parent-42",
     });
   });
@@ -40,12 +38,11 @@ describe("subscribeSubagentLifecycle", () => {
     subscribeSubagentLifecycle(bus, registry);
 
     bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
-      sessionDir: "/sessions/child-sync",
-      agentName: "Explore",
+      sessionId: "child-session-sync",
     });
 
     // No await between emit and this assertion.
-    expect(registry.has("/sessions/child-sync")).toBe(true);
+    expect(registry.has("child-session-sync")).toBe(true);
   });
 
   it("omits parentSessionId when the event does not carry one", () => {
@@ -53,12 +50,10 @@ describe("subscribeSubagentLifecycle", () => {
     subscribeSubagentLifecycle(bus, registry);
 
     bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
-      sessionDir: "/sessions/child-xyz",
-      agentName: "general-purpose",
+      sessionId: "child-session-xyz",
     });
 
-    expect(registry.get("/sessions/child-xyz")).toEqual({
-      agentName: "general-purpose",
+    expect(registry.get("child-session-xyz")).toEqual({
       parentSessionId: undefined,
     });
   });
@@ -66,11 +61,11 @@ describe("subscribeSubagentLifecycle", () => {
   it("unregisters a child session on disposed", () => {
     const bus = createEventBus();
     subscribeSubagentLifecycle(bus, registry);
-    registry.register("/sessions/child-abc", { agentName: "Explore" });
+    registry.register("child-session-abc", { parentSessionId: "parent-42" });
 
-    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionDir: "/sessions/child-abc" });
+    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: "child-session-abc" });
 
-    expect(registry.has("/sessions/child-abc")).toBe(false);
+    expect(registry.has("child-session-abc")).toBe(false);
   });
 
   it("detaches both handlers when the returned unsubscribe is called", () => {
@@ -80,12 +75,11 @@ describe("subscribeSubagentLifecycle", () => {
     unsubscribe();
 
     bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
-      sessionDir: "/sessions/child-abc",
-      agentName: "Explore",
+      sessionId: "child-session-abc",
     });
-    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionDir: "/sessions/child-abc" });
+    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: "child-session-abc" });
 
-    expect(registry.has("/sessions/child-abc")).toBe(false);
+    expect(registry.has("child-session-abc")).toBe(false);
   });
 
   it("subscribes to a fake bus on the exact channel names", () => {
@@ -110,4 +104,29 @@ describe("subscribeSubagentLifecycle", () => {
     );
     expect(SUBAGENT_CHILD_DISPOSED).toBe("subagents:child:disposed");
   });
+
+  // ── #298 regression: concurrent siblings must be independent ──────────────
+
+  it("disposing one sibling does not evict the other (collision regression)", () => {
+    const bus = createEventBus();
+    subscribeSubagentLifecycle(bus, registry);
+
+    // Two concurrent children of the same parent register under distinct ids.
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-A",
+      parentSessionId: "parent-P",
+    });
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-B",
+      parentSessionId: "parent-P",
+    });
+
+    // Sibling A finishes first.
+    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: "child-A" });
+
+    // B must still be detected as a registered subagent.
+    expect(registry.has("child-A")).toBe(false);
+    expect(registry.has("child-B")).toBe(true);
+    expect(registry.get("child-B")?.parentSessionId).toBe("parent-P");
+  });
 });

package/test/subagent-registry.test.ts

@@ -12,89 +12,99 @@ const REGISTRY_KEY = Symbol.for(
 function makeInfo(
   overrides: Partial<SubagentSessionInfo> = {},
 ): SubagentSessionInfo {
-  return {
-    agentName: "Explore",
-    ...overrides,
-  };
+  return { ...overrides };
 }
 
 describe("SubagentSessionRegistry", () => {
   test("has() returns false for an unregistered key", () => {
     const registry = new SubagentSessionRegistry();
-    expect(registry.has("/sessions/task-abc")).toBe(false);
+    expect(registry.has("session-abc")).toBe(false);
   });
 
   test("get() returns undefined for an unregistered key", () => {
     const registry = new SubagentSessionRegistry();
-    expect(registry.get("/sessions/task-abc")).toBeUndefined();
+    expect(registry.get("session-abc")).toBeUndefined();
   });
 
   test("has() returns true after register()", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register("/sessions/task-abc", makeInfo());
-    expect(registry.has("/sessions/task-abc")).toBe(true);
+    registry.register("session-abc", makeInfo());
+    expect(registry.has("session-abc")).toBe(true);
   });
 
   test("get() returns the registered info after register()", () => {
     const registry = new SubagentSessionRegistry();
     const info = makeInfo({ parentSessionId: "parent-123" });
-    registry.register("/sessions/task-abc", info);
-    expect(registry.get("/sessions/task-abc")).toEqual(info);
+    registry.register("session-abc", info);
+    expect(registry.get("session-abc")).toEqual(info);
   });
 
-  test("register() stores agentName without parentSessionId", () => {
+  test("register() stores entry without parentSessionId", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register("/sessions/task-abc", makeInfo());
-    expect(registry.get("/sessions/task-abc")).toEqual({
-      agentName: "Explore",
-    });
+    registry.register("session-abc", makeInfo());
+    expect(registry.get("session-abc")).toEqual({});
   });
 
   test("has() returns false after unregister()", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register("/sessions/task-abc", makeInfo());
-    registry.unregister("/sessions/task-abc");
-    expect(registry.has("/sessions/task-abc")).toBe(false);
+    registry.register("session-abc", makeInfo());
+    registry.unregister("session-abc");
+    expect(registry.has("session-abc")).toBe(false);
   });
 
   test("get() returns undefined after unregister()", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register("/sessions/task-abc", makeInfo());
-    registry.unregister("/sessions/task-abc");
-    expect(registry.get("/sessions/task-abc")).toBeUndefined();
+    registry.register("session-abc", makeInfo());
+    registry.unregister("session-abc");
+    expect(registry.get("session-abc")).toBeUndefined();
   });
 
   test("unregister() is a no-op for an unknown key", () => {
     const registry = new SubagentSessionRegistry();
-    expect(() => registry.unregister("/sessions/nonexistent")).not.toThrow();
+    expect(() => registry.unregister("session-nonexistent")).not.toThrow();
   });
 
   test("register() overwrites a previous entry for the same key", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register("session-abc", makeInfo({ parentSessionId: "parent-1" }));
+    registry.register("session-abc", makeInfo({ parentSessionId: "parent-2" }));
+    expect(registry.get("session-abc")?.parentSessionId).toBe("parent-2");
+  });
+
+  // ── #298 regression: concurrent siblings must be independent ──────────────
+
+  test("two sibling session ids are registered independently", () => {
     const registry = new SubagentSessionRegistry();
     registry.register(
-      "/sessions/task-abc",
-      makeInfo({ parentSessionId: "parent-1" }),
+      "child-session-A",
+      makeInfo({ parentSessionId: "parent-P" }),
     );
     registry.register(
-      "/sessions/task-abc",
-      makeInfo({ parentSessionId: "parent-2" }),
-    );
-    expect(registry.get("/sessions/task-abc")?.parentSessionId).toBe(
-      "parent-2",
+      "child-session-B",
+      makeInfo({ parentSessionId: "parent-P" }),
     );
+
+    expect(registry.has("child-session-A")).toBe(true);
+    expect(registry.has("child-session-B")).toBe(true);
   });
 
-  test("multiple keys are independent", () => {
+  test("disposing one sibling does not evict the other (collision regression)", () => {
     const registry = new SubagentSessionRegistry();
-    registry.register("/sessions/task-1", makeInfo({ agentName: "Explore" }));
-    registry.register("/sessions/task-2", makeInfo({ agentName: "Plan" }));
+    registry.register(
+      "child-session-A",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
+    registry.register(
+      "child-session-B",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
 
-    expect(registry.get("/sessions/task-1")?.agentName).toBe("Explore");
-    expect(registry.get("/sessions/task-2")?.agentName).toBe("Plan");
+    // Sibling A finishes — should not affect B.
+    registry.unregister("child-session-A");
 
-    registry.unregister("/sessions/task-1");
-    expect(registry.has("/sessions/task-1")).toBe(false);
-    expect(registry.has("/sessions/task-2")).toBe(true);
+    expect(registry.has("child-session-A")).toBe(false);
+    expect(registry.has("child-session-B")).toBe(true);
+    expect(registry.get("child-session-B")?.parentSessionId).toBe("parent-P");
   });
 });
 
@@ -119,20 +129,17 @@ describe("getSubagentSessionRegistry (process-global accessor)", () => {
 
   test("state registered through one call is visible through another call", () => {
     const writer = getSubagentSessionRegistry();
-    writer.register("/sessions/child-tasks", {
-      agentName: "Explore",
+    writer.register("child-session-xyz", {
       parentSessionId: "parent-abc",
     });
 
     const reader = getSubagentSessionRegistry();
-    expect(reader.has("/sessions/child-tasks")).toBe(true);
-    expect(reader.get("/sessions/child-tasks")?.parentSessionId).toBe(
-      "parent-abc",
-    );
+    expect(reader.has("child-session-xyz")).toBe(true);
+    expect(reader.get("child-session-xyz")?.parentSessionId).toBe("parent-abc");
   });
 
   test("starts empty on first call", () => {
     const registry = getSubagentSessionRegistry();
-    expect(registry.has("/sessions/any-key")).toBe(false);
+    expect(registry.has("any-session-id")).toBe(false);
   });
 });