@komarspn/pi-permission-system 16.0.2

package/test/subagent-context.test.ts

@@ -0,0 +1,326 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { SUBAGENT_ENV_HINT_KEYS } from "#src/permission-forwarding";
+import {
+  isRegisteredSubagentChild,
+  isSubagentExecutionContext,
+  normalizeFilesystemPath,
+  type SubagentDetectionContext,
+} from "#src/subagent-context";
+import { SubagentSessionRegistry } from "#src/subagent-registry";
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+
+function makeCtx(
+  sessionDir: string | null,
+  sessionId: string = "",
+): SubagentDetectionContext {
+  return {
+    sessionManager: {
+      getSessionDir: vi.fn(() => sessionDir ?? ""),
+      getSessionId: vi.fn(() => sessionId),
+    },
+  };
+}
+
+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: SubagentDetectionContext = {
+      sessionManager: {
+        getSessionDir: vi.fn(() => ""),
+        getSessionId: vi.fn(() => {
+          throw new Error("session id unavailable");
+        }),
+      },
+    };
+    expect(isRegisteredSubagentChild(ctx, registry)).toBe(false);
+  });
+});
+
+describe("normalizeFilesystemPath", () => {
+  test("normalizes a simple absolute path", () => {
+    expect(normalizeFilesystemPath("/projects/my-app")).toBe(
+      "/projects/my-app",
+    );
+  });
+
+  test("collapses redundant separators", () => {
+    expect(normalizeFilesystemPath("/projects//my-app")).toBe(
+      "/projects/my-app",
+    );
+  });
+
+  test("resolves . and .. segments", () => {
+    expect(normalizeFilesystemPath("/projects/my-app/../other")).toBe(
+      "/projects/other",
+    );
+  });
+});
+
+describe("isSubagentExecutionContext — env hint detection", () => {
+  test("returns true when PI_IS_SUBAGENT is set", () => {
+    vi.stubEnv("PI_IS_SUBAGENT", "true");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_SESSION_ID is set", () => {
+    vi.stubEnv("PI_SUBAGENT_SESSION_ID", "abc123");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_AGENT_ROUTER_SUBAGENT is set", () => {
+    vi.stubEnv("PI_AGENT_ROUTER_SUBAGENT", "1");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  // nicobailon/pi-subagents keys
+  test("returns true when PI_SUBAGENT_CHILD is set", () => {
+    vi.stubEnv("PI_SUBAGENT_CHILD", "1");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_RUN_ID is set", () => {
+    vi.stubEnv("PI_SUBAGENT_RUN_ID", "run-abc");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_CHILD_AGENT is set", () => {
+    vi.stubEnv("PI_SUBAGENT_CHILD_AGENT", "worker");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_DEPTH is set", () => {
+    vi.stubEnv("PI_SUBAGENT_DEPTH", "1");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_DEPTH is zero (depth-0 is still a subagent context)", () => {
+    vi.stubEnv("PI_SUBAGENT_DEPTH", "0");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  // HazAT/pi-interactive-subagents keys
+  test("returns true when PI_SUBAGENT_NAME is set", () => {
+    vi.stubEnv("PI_SUBAGENT_NAME", "my-agent");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_ID is set", () => {
+    vi.stubEnv("PI_SUBAGENT_ID", "id-xyz");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_SESSION is set", () => {
+    vi.stubEnv("PI_SUBAGENT_SESSION", "session-xyz");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("returns true when PI_SUBAGENT_ACTIVITY_FILE is set", () => {
+    vi.stubEnv("PI_SUBAGENT_ACTIVITY_FILE", "/tmp/activity.json");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(true);
+  });
+
+  test("covers all declared SUBAGENT_ENV_HINT_KEYS", () => {
+    // Verify the keys we test match what the module declares.
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_IS_SUBAGENT");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_SESSION_ID");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_AGENT_ROUTER_SUBAGENT");
+    // nicobailon/pi-subagents
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_CHILD");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_RUN_ID");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_CHILD_AGENT");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_DEPTH");
+    // HazAT/pi-interactive-subagents
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_NAME");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_ID");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_SESSION");
+    expect(SUBAGENT_ENV_HINT_KEYS).toContain("PI_SUBAGENT_ACTIVITY_FILE");
+  });
+
+  test("returns false when env hint value is empty string", () => {
+    vi.stubEnv("PI_IS_SUBAGENT", "");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(false);
+  });
+
+  test("returns false when env hint value is whitespace only", () => {
+    vi.stubEnv("PI_IS_SUBAGENT", "   ");
+    expect(
+      isSubagentExecutionContext(makeCtx(null), "/sessions/subagents"),
+    ).toBe(false);
+  });
+});
+
+describe("isSubagentExecutionContext — session dir detection", () => {
+  const subagentRoot = "/home/user/.pi/agent/sessions/subagents";
+
+  test("returns true when session dir is within subagent root", () => {
+    const sessionDir = `${subagentRoot}/session-abc`;
+    expect(isSubagentExecutionContext(makeCtx(sessionDir), subagentRoot)).toBe(
+      true,
+    );
+  });
+
+  test("returns true when session dir equals subagent root", () => {
+    expect(
+      isSubagentExecutionContext(makeCtx(subagentRoot), subagentRoot),
+    ).toBe(true);
+  });
+
+  test("returns false when session dir is outside subagent root", () => {
+    const sessionDir = "/home/user/.pi/agent/sessions/main-session";
+    expect(isSubagentExecutionContext(makeCtx(sessionDir), subagentRoot)).toBe(
+      false,
+    );
+  });
+
+  test("returns false when session dir is a sibling with shared prefix", () => {
+    // "/sessions/subagents-extra" should not match root "/sessions/subagents"
+    const sessionDir = `${subagentRoot}-extra/session-abc`;
+    expect(isSubagentExecutionContext(makeCtx(sessionDir), subagentRoot)).toBe(
+      false,
+    );
+  });
+
+  test("returns false when getSessionDir returns null", () => {
+    expect(isSubagentExecutionContext(makeCtx(null), subagentRoot)).toBe(false);
+  });
+
+  test("returns false when getSessionDir returns empty string", () => {
+    expect(isSubagentExecutionContext(makeCtx(""), subagentRoot)).toBe(false);
+  });
+});
+
+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 id is registered (no env vars, dir outside filesystem root)", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register(childSessionId, {});
+    expect(
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
+    ).toBe(true);
+  });
+
+  test("returns true when registered session has a parentSessionId", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register(childSessionId, { parentSessionId: "parent-123" });
+    expect(
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
+    ).toBe(true);
+  });
+
+  test("returns false when registry is provided but session id is not registered", () => {
+    const registry = new SubagentSessionRegistry();
+    expect(
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
+    ).toBe(false);
+  });
+
+  test("returns false when session id is empty and registry has no matching entry", () => {
+    const registry = new SubagentSessionRegistry();
+    expect(
+      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(childSessionId, {});
+    // Confirm no env var is set
+    expect(process.env.PI_IS_SUBAGENT).toBeUndefined();
+    expect(
+      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 — childSessionId not registered
+    // Env var present → still true even without registry entry
+    expect(
+      isSubagentExecutionContext(
+        makeCtx(outsideDir, childSessionId),
+        subagentRoot,
+        registry,
+      ),
+    ).toBe(true);
+  });
+
+  test("no registry passed — existing behaviour unchanged", () => {
+    // Ensure the parameter is truly optional (no registry arg)
+    expect(isSubagentExecutionContext(makeCtx(null), subagentRoot)).toBe(false);
+  });
+});

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

@@ -0,0 +1,132 @@
+import { createEventBus } from "@earendil-works/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  SUBAGENT_CHILD_DISPOSED,
+  SUBAGENT_CHILD_SESSION_CREATED,
+  subscribeSubagentLifecycle,
+} from "#src/subagent-lifecycle-events";
+import { SubagentSessionRegistry } from "#src/subagent-registry";
+
+describe("subscribeSubagentLifecycle", () => {
+  let registry: SubagentSessionRegistry;
+
+  beforeEach(() => {
+    registry = new SubagentSessionRegistry();
+  });
+
+  it("registers a child session on session-created", () => {
+    const bus = createEventBus();
+    subscribeSubagentLifecycle(bus, registry);
+
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-session-abc",
+      parentSessionId: "parent-42",
+    });
+
+    expect(registry.get("child-session-abc")).toEqual({
+      parentSessionId: "parent-42",
+    });
+  });
+
+  it("populates the registry synchronously — before emit() returns", () => {
+    // Guards the pre-bindExtensions ordering: the core emits session-created
+    // on the same synchronous call stack right before bindExtensions(), so the
+    // handler must complete before emit() returns. A real EventEmitter-backed
+    // bus dispatches synchronously; this fails loudly if the handler ever
+    // becomes async (awaiting before registry.register).
+    const bus = createEventBus();
+    subscribeSubagentLifecycle(bus, registry);
+
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-session-sync",
+    });
+
+    // No await between emit and this assertion.
+    expect(registry.has("child-session-sync")).toBe(true);
+  });
+
+  it("omits parentSessionId when the event does not carry one", () => {
+    const bus = createEventBus();
+    subscribeSubagentLifecycle(bus, registry);
+
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-session-xyz",
+    });
+
+    expect(registry.get("child-session-xyz")).toEqual({
+      parentSessionId: undefined,
+    });
+  });
+
+  it("unregisters a child session on disposed", () => {
+    const bus = createEventBus();
+    subscribeSubagentLifecycle(bus, registry);
+    registry.register("child-session-abc", { parentSessionId: "parent-42" });
+
+    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: "child-session-abc" });
+
+    expect(registry.has("child-session-abc")).toBe(false);
+  });
+
+  it("detaches both handlers when the returned unsubscribe is called", () => {
+    const bus = createEventBus();
+    const unsubscribe = subscribeSubagentLifecycle(bus, registry);
+
+    unsubscribe();
+
+    bus.emit(SUBAGENT_CHILD_SESSION_CREATED, {
+      sessionId: "child-session-abc",
+    });
+    bus.emit(SUBAGENT_CHILD_DISPOSED, { sessionId: "child-session-abc" });
+
+    expect(registry.has("child-session-abc")).toBe(false);
+  });
+
+  it("subscribes to a fake bus on the exact channel names", () => {
+    const handlers = new Map<string, (data: unknown) => void>();
+    const bus = {
+      on: vi.fn((channel: string, handler: (data: unknown) => void) => {
+        handlers.set(channel, handler);
+        return () => handlers.delete(channel);
+      }),
+    };
+
+    subscribeSubagentLifecycle(bus, registry);
+
+    expect(bus.on).toHaveBeenCalledTimes(2);
+    expect(handlers.has("subagents:child:session-created")).toBe(true);
+    expect(handlers.has("subagents:child:disposed")).toBe(true);
+  });
+
+  it("exposes the canonical channel-name strings", () => {
+    expect(SUBAGENT_CHILD_SESSION_CREATED).toBe(
+      "subagents:child:session-created",
+    );
+    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

@@ -0,0 +1,145 @@
+import { afterEach, describe, expect, test } from "vitest";
+import {
+  getSubagentSessionRegistry,
+  type SubagentSessionInfo,
+  SubagentSessionRegistry,
+} from "#src/subagent-registry";
+
+const REGISTRY_KEY = Symbol.for(
+  "@gotgenes/pi-permission-system:subagent-registry",
+);
+
+function makeInfo(
+  overrides: Partial<SubagentSessionInfo> = {},
+): SubagentSessionInfo {
+  return { ...overrides };
+}
+
+describe("SubagentSessionRegistry", () => {
+  test("has() returns false for an unregistered key", () => {
+    const registry = new SubagentSessionRegistry();
+    expect(registry.has("session-abc")).toBe(false);
+  });
+
+  test("get() returns undefined for an unregistered key", () => {
+    const registry = new SubagentSessionRegistry();
+    expect(registry.get("session-abc")).toBeUndefined();
+  });
+
+  test("has() returns true after register()", () => {
+    const registry = new SubagentSessionRegistry();
+    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("session-abc", info);
+    expect(registry.get("session-abc")).toEqual(info);
+  });
+
+  test("register() stores entry without parentSessionId", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register("session-abc", makeInfo());
+    expect(registry.get("session-abc")).toEqual({});
+  });
+
+  test("has() returns false after unregister()", () => {
+    const registry = new SubagentSessionRegistry();
+    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("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("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(
+      "child-session-A",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
+    registry.register(
+      "child-session-B",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
+
+    expect(registry.has("child-session-A")).toBe(true);
+    expect(registry.has("child-session-B")).toBe(true);
+  });
+
+  test("disposing one sibling does not evict the other (collision regression)", () => {
+    const registry = new SubagentSessionRegistry();
+    registry.register(
+      "child-session-A",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
+    registry.register(
+      "child-session-B",
+      makeInfo({ parentSessionId: "parent-P" }),
+    );
+
+    // Sibling A finishes — should not affect B.
+    registry.unregister("child-session-A");
+
+    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");
+  });
+});
+
+// ── process-global accessor ────────────────────────────────────────────────
+
+describe("getSubagentSessionRegistry (process-global accessor)", () => {
+  afterEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Symbol-keyed global property; Map.delete() is not applicable
+    delete (globalThis as Record<symbol, unknown>)[REGISTRY_KEY];
+  });
+
+  test("returns a SubagentSessionRegistry instance", () => {
+    const registry = getSubagentSessionRegistry();
+    expect(registry).toBeInstanceOf(SubagentSessionRegistry);
+  });
+
+  test("returns the same instance on repeated calls", () => {
+    const first = getSubagentSessionRegistry();
+    const second = getSubagentSessionRegistry();
+    expect(first).toBe(second);
+  });
+
+  test("state registered through one call is visible through another call", () => {
+    const writer = getSubagentSessionRegistry();
+    writer.register("child-session-xyz", {
+      parentSessionId: "parent-abc",
+    });
+
+    const reader = getSubagentSessionRegistry();
+    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("any-session-id")).toBe(false);
+  });
+});