@gotgenes/pi-permission-system 5.8.0 → 5.10.0

package/tests/permission-session.test.ts

@@ -0,0 +1,546 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── Module mocks (hoisted) ─────────────────────────────────────────────────
+
+const {
+  mockGetActiveAgentName,
+  mockGetActiveAgentNameFromSystemPrompt,
+  mockCreatePermissionManagerForCwd,
+} = vi.hoisted(() => ({
+  mockGetActiveAgentName: vi.fn<(ctx: ExtensionContext) => string | null>(),
+  mockGetActiveAgentNameFromSystemPrompt:
+    vi.fn<(systemPrompt?: string) => string | null>(),
+  mockCreatePermissionManagerForCwd: vi.fn(),
+}));
+
+vi.mock("../src/active-agent", () => ({
+  getActiveAgentName: mockGetActiveAgentName,
+  getActiveAgentNameFromSystemPrompt: mockGetActiveAgentNameFromSystemPrompt,
+}));
+
+vi.mock("../src/runtime", async (importOriginal) => {
+  const original = await importOriginal<typeof import("../src/runtime")>();
+  return {
+    ...original,
+    createPermissionManagerForCwd: mockCreatePermissionManagerForCwd,
+  };
+});
+
+// ── Test helpers ───────────────────────────────────────────────────────────
+
+import type { ExtensionPaths } from "../src/extension-paths";
+import type { ForwardingController } from "../src/forwarding-manager";
+import type { PermissionManager } from "../src/permission-manager";
+import {
+  PermissionSession,
+  type PermissionSessionRuntimeDeps,
+} from "../src/permission-session";
+import type { SessionLogger } from "../src/session-logger";
+import type { SkillPromptEntry } from "../src/skill-prompt-sanitizer";
+import type { PermissionCheckResult } from "../src/types";
+
+function makeSkillEntry(
+  name: string,
+  overrides: Partial<SkillPromptEntry> = {},
+): SkillPromptEntry {
+  return {
+    name,
+    description: `${name} skill`,
+    location: `/${name}/SKILL.md`,
+    state: "allow",
+    normalizedLocation: `/${name}/SKILL.md`,
+    normalizedBaseDir: `/${name}`,
+    ...overrides,
+  };
+}
+
+function makePaths(overrides: Partial<ExtensionPaths> = {}): ExtensionPaths {
+  return {
+    agentDir: "/test/agent",
+    sessionsDir: "/test/agent/sessions",
+    subagentSessionsDir: "/test/agent/subagent-sessions",
+    forwardingDir: "/test/agent/sessions/permission-forwarding",
+    globalLogsDir: "/test/agent/logs",
+    piInfrastructureDirs: ["/test/agent", "/test/agent/git"],
+    ...overrides,
+  };
+}
+
+function makeLogger(): SessionLogger {
+  return {
+    debug: vi.fn(),
+    review: vi.fn(),
+    warn: vi.fn(),
+  };
+}
+
+function makeRuntimeDeps(): PermissionSessionRuntimeDeps {
+  return {
+    refreshExtensionConfig: vi.fn(),
+    logResolvedConfigPaths: vi.fn(),
+    getConfig: vi.fn().mockReturnValue({}),
+  };
+}
+
+function makeForwarding(): ForwardingController {
+  return {
+    start: vi.fn(),
+    stop: vi.fn(),
+  };
+}
+
+function makeCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+  return {
+    cwd: "/test/project",
+    hasUI: true,
+    ui: {
+      setStatus: vi.fn(),
+      notify: vi.fn(),
+      select: vi.fn(),
+      input: vi.fn(),
+    },
+    sessionManager: {
+      getEntries: vi.fn().mockReturnValue([]),
+      getSessionDir: vi.fn().mockReturnValue("/sessions/test"),
+      addEntry: vi.fn(),
+    },
+    ...overrides,
+  } as unknown as ExtensionContext;
+}
+
+function makePermissionManager(
+  overrides: Partial<PermissionManager> = {},
+): PermissionManager {
+  return {
+    checkPermission: vi.fn().mockReturnValue({
+      state: "allow",
+      toolName: "read",
+      source: "tool",
+      origin: "builtin",
+    } as PermissionCheckResult),
+    getToolPermission: vi.fn().mockReturnValue("allow"),
+    getConfigIssues: vi.fn().mockReturnValue([]),
+    getPolicyCacheStamp: vi.fn().mockReturnValue("stamp-1"),
+    getComposedConfigRules: vi.fn().mockReturnValue([]),
+    getResolvedPolicyPaths: vi.fn().mockReturnValue({}),
+    ...overrides,
+  } as unknown as PermissionManager;
+}
+
+function createSession(overrides?: {
+  paths?: Partial<ExtensionPaths>;
+  logger?: SessionLogger;
+  forwarding?: ForwardingController;
+  runtimeDeps?: PermissionSessionRuntimeDeps;
+}): {
+  session: PermissionSession;
+  paths: ExtensionPaths;
+  logger: SessionLogger;
+  forwarding: ForwardingController;
+  runtimeDeps: PermissionSessionRuntimeDeps;
+} {
+  const paths = makePaths(overrides?.paths);
+  const logger = overrides?.logger ?? makeLogger();
+  const forwarding = overrides?.forwarding ?? makeForwarding();
+  const runtimeDeps = overrides?.runtimeDeps ?? makeRuntimeDeps();
+  const session = new PermissionSession(paths, logger, forwarding, runtimeDeps);
+  return { session, paths, logger, forwarding, runtimeDeps };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mockGetActiveAgentName.mockReset();
+  mockGetActiveAgentNameFromSystemPrompt.mockReset();
+  mockCreatePermissionManagerForCwd.mockReset();
+
+  // Default: createPermissionManagerForCwd returns a fresh mock PM
+  mockCreatePermissionManagerForCwd.mockReturnValue(makePermissionManager());
+  mockGetActiveAgentName.mockReturnValue(null);
+  mockGetActiveAgentNameFromSystemPrompt.mockReturnValue(null);
+});
+
+describe("PermissionSession", () => {
+  describe("constructor and delegation", () => {
+    it("delegates checkPermission to internal PermissionManager", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      const result = session.checkPermission("bash", { command: "ls" });
+
+      expect(pm.checkPermission).toHaveBeenCalledWith(
+        "bash",
+        { command: "ls" },
+        undefined,
+        undefined,
+      );
+      expect(result.state).toBe("allow");
+    });
+
+    it("delegates getToolPermission to internal PermissionManager", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      const result = session.getToolPermission("read");
+
+      expect(pm.getToolPermission).toHaveBeenCalledWith("read", undefined);
+      expect(result).toBe("allow");
+    });
+
+    it("delegates getConfigIssues to internal PermissionManager", () => {
+      const pm = makePermissionManager({
+        getConfigIssues: vi.fn().mockReturnValue(["issue1"]),
+      });
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      expect(session.getConfigIssues("agent1")).toEqual(["issue1"]);
+      expect(pm.getConfigIssues).toHaveBeenCalledWith("agent1");
+    });
+
+    it("delegates getPolicyCacheStamp to internal PermissionManager", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      expect(session.getPolicyCacheStamp("agent1")).toBe("stamp-1");
+      expect(pm.getPolicyCacheStamp).toHaveBeenCalledWith("agent1");
+    });
+
+    it("delegates getSessionRuleset to internal SessionRules", () => {
+      const { session } = createSession();
+      const rules = session.getSessionRuleset();
+      expect(rules).toEqual([]);
+    });
+
+    it("delegates approveSessionRule to internal SessionRules", () => {
+      const { session } = createSession();
+      session.approveSessionRule("bash", "/usr/bin/*");
+      const rules = session.getSessionRuleset();
+      expect(rules).toHaveLength(1);
+      expect(rules[0]).toMatchObject({
+        surface: "bash",
+        pattern: "/usr/bin/*",
+        action: "allow",
+      });
+    });
+  });
+
+  describe("activate and deactivate", () => {
+    it("stores the context on activate", () => {
+      const { session, forwarding } = createSession();
+      const ctx = makeCtx();
+
+      session.activate(ctx);
+
+      expect(forwarding.start).toHaveBeenCalledWith(ctx);
+    });
+
+    it("clears context on deactivate", () => {
+      const { session, forwarding } = createSession();
+      session.activate(makeCtx());
+      session.deactivate();
+
+      expect(forwarding.stop).toHaveBeenCalled();
+    });
+  });
+
+  describe("resetForNewSession", () => {
+    it("creates a new PermissionManager for the context cwd", () => {
+      const pm2 = makePermissionManager({
+        checkPermission: vi.fn().mockReturnValue({
+          state: "deny",
+          toolName: "bash",
+          source: "bash",
+          origin: "global",
+        } as PermissionCheckResult),
+      });
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm2);
+      const { session } = createSession();
+      const ctx = makeCtx({ cwd: "/new/project" });
+
+      session.resetForNewSession(ctx);
+
+      expect(mockCreatePermissionManagerForCwd).toHaveBeenCalledWith(
+        "/test/agent",
+        "/new/project",
+      );
+      // Verify the new PM is used for subsequent calls
+      const result = session.checkPermission("bash", { command: "rm" });
+      expect(result.state).toBe("deny");
+    });
+
+    it("clears cache keys", () => {
+      const { session } = createSession();
+      session.commitActiveToolsCacheKey("key-1");
+      session.commitPromptStateCacheKey("key-2");
+      expect(session.shouldUpdateActiveTools("key-1")).toBe(false);
+      expect(session.shouldUpdatePromptState("key-2")).toBe(false);
+
+      session.resetForNewSession(makeCtx());
+
+      // After reset, same keys should be treated as new
+      expect(session.shouldUpdateActiveTools("key-1")).toBe(true);
+      expect(session.shouldUpdatePromptState("key-2")).toBe(true);
+    });
+
+    it("clears skill entries", () => {
+      const { session } = createSession();
+      session.setActiveSkillEntries([makeSkillEntry("test")]);
+      expect(session.getActiveSkillEntries()).toHaveLength(1);
+
+      session.resetForNewSession(makeCtx());
+
+      expect(session.getActiveSkillEntries()).toEqual([]);
+    });
+
+    it("starts forwarding with the new context", () => {
+      const { session, forwarding } = createSession();
+      const ctx = makeCtx();
+
+      session.resetForNewSession(ctx);
+
+      expect(forwarding.start).toHaveBeenCalledWith(ctx);
+    });
+
+    it("activates the new context", () => {
+      const { session } = createSession();
+      const ctx = makeCtx();
+
+      session.resetForNewSession(ctx);
+
+      // Verify context is stored by calling resolveAgentName which needs it
+      mockGetActiveAgentName.mockReturnValue("test-agent");
+      const name = session.resolveAgentName(ctx);
+      expect(name).toBe("test-agent");
+    });
+  });
+
+  describe("shutdown", () => {
+    it("clears session rules", () => {
+      const { session } = createSession();
+      session.approveSessionRule("bash", "*");
+      expect(session.getSessionRuleset()).toHaveLength(1);
+
+      session.shutdown();
+
+      expect(session.getSessionRuleset()).toEqual([]);
+    });
+
+    it("clears cache keys", () => {
+      const { session } = createSession();
+      session.commitActiveToolsCacheKey("k1");
+      session.commitPromptStateCacheKey("k2");
+
+      session.shutdown();
+
+      expect(session.shouldUpdateActiveTools("k1")).toBe(true);
+      expect(session.shouldUpdatePromptState("k2")).toBe(true);
+    });
+
+    it("clears skill entries", () => {
+      const { session } = createSession();
+      session.setActiveSkillEntries([makeSkillEntry("s")]);
+
+      session.shutdown();
+
+      expect(session.getActiveSkillEntries()).toEqual([]);
+    });
+
+    it("stops forwarding and deactivates context", () => {
+      const { session, forwarding } = createSession();
+      session.activate(makeCtx());
+
+      session.shutdown();
+
+      expect(forwarding.stop).toHaveBeenCalled();
+    });
+  });
+
+  describe("cache key methods", () => {
+    it("shouldUpdateActiveTools returns true for new key", () => {
+      const { session } = createSession();
+      expect(session.shouldUpdateActiveTools("key-1")).toBe(true);
+    });
+
+    it("shouldUpdateActiveTools returns false for committed key", () => {
+      const { session } = createSession();
+      session.commitActiveToolsCacheKey("key-1");
+      expect(session.shouldUpdateActiveTools("key-1")).toBe(false);
+    });
+
+    it("shouldUpdateActiveTools returns true for different key", () => {
+      const { session } = createSession();
+      session.commitActiveToolsCacheKey("key-1");
+      expect(session.shouldUpdateActiveTools("key-2")).toBe(true);
+    });
+
+    it("shouldUpdatePromptState returns true for new key", () => {
+      const { session } = createSession();
+      expect(session.shouldUpdatePromptState("key-1")).toBe(true);
+    });
+
+    it("shouldUpdatePromptState returns false for committed key", () => {
+      const { session } = createSession();
+      session.commitPromptStateCacheKey("key-1");
+      expect(session.shouldUpdatePromptState("key-1")).toBe(false);
+    });
+  });
+
+  describe("skill entries", () => {
+    it("get/set skill entries", () => {
+      const { session } = createSession();
+      const entries = [makeSkillEntry("a"), makeSkillEntry("b")];
+      session.setActiveSkillEntries(entries);
+      expect(session.getActiveSkillEntries()).toEqual(entries);
+    });
+  });
+
+  describe("resolveAgentName", () => {
+    it("returns name from session context", () => {
+      mockGetActiveAgentName.mockReturnValue("ctx-agent");
+      const { session } = createSession();
+      const ctx = makeCtx();
+
+      expect(session.resolveAgentName(ctx)).toBe("ctx-agent");
+    });
+
+    it("falls back to system prompt", () => {
+      mockGetActiveAgentName.mockReturnValue(null);
+      mockGetActiveAgentNameFromSystemPrompt.mockReturnValue("prompt-agent");
+      const { session } = createSession();
+      const ctx = makeCtx();
+
+      expect(session.resolveAgentName(ctx, "system prompt")).toBe(
+        "prompt-agent",
+      );
+    });
+
+    it("falls back to last known name", () => {
+      const { session } = createSession();
+      const ctx = makeCtx();
+
+      // First call sets name
+      mockGetActiveAgentName.mockReturnValue("first-agent");
+      session.resolveAgentName(ctx);
+
+      // Second call with no name resolves to last known
+      mockGetActiveAgentName.mockReturnValue(null);
+      mockGetActiveAgentNameFromSystemPrompt.mockReturnValue(null);
+      expect(session.resolveAgentName(ctx)).toBe("first-agent");
+    });
+
+    it("exposes lastKnownActiveAgentName", () => {
+      const { session } = createSession();
+      expect(session.lastKnownActiveAgentName).toBeNull();
+
+      mockGetActiveAgentName.mockReturnValue("named");
+      session.resolveAgentName(makeCtx());
+      expect(session.lastKnownActiveAgentName).toBe("named");
+    });
+  });
+
+  describe("infrastructure paths", () => {
+    it("getInfrastructureDirs returns paths from ExtensionPaths", () => {
+      const { session } = createSession();
+      expect(session.getInfrastructureDirs()).toEqual([
+        "/test/agent",
+        "/test/agent/git",
+      ]);
+    });
+
+    it("getInfrastructureReadPaths returns config paths", () => {
+      const runtimeDeps = makeRuntimeDeps();
+      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue({
+        piInfrastructureReadPaths: ["/extra/path"],
+      });
+      const { session } = createSession({ runtimeDeps });
+      expect(session.getInfrastructureReadPaths()).toEqual(["/extra/path"]);
+    });
+
+    it("getInfrastructureReadPaths returns empty when config omits the field", () => {
+      const { session } = createSession();
+      expect(session.getInfrastructureReadPaths()).toEqual([]);
+    });
+  });
+
+  describe("config delegation", () => {
+    it("refreshConfig delegates to runtimeDeps", () => {
+      const { session, runtimeDeps } = createSession();
+      const ctx = makeCtx();
+      session.refreshConfig(ctx);
+      expect(runtimeDeps.refreshExtensionConfig).toHaveBeenCalledWith(ctx);
+    });
+
+    it("logResolvedConfigPaths delegates to runtimeDeps", () => {
+      const { session, runtimeDeps } = createSession();
+      session.logResolvedConfigPaths();
+      expect(runtimeDeps.logResolvedConfigPaths).toHaveBeenCalled();
+    });
+
+    it("config getter delegates to runtimeDeps.getConfig", () => {
+      const runtimeDeps = makeRuntimeDeps();
+      const fakeConfig = { debugLog: true };
+      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue(
+        fakeConfig,
+      );
+      const { session } = createSession({ runtimeDeps });
+      expect(session.config).toBe(fakeConfig);
+    });
+  });
+
+  describe("reload", () => {
+    it("recreates PermissionManager for current context cwd", () => {
+      const { session } = createSession();
+      const ctx = makeCtx({ cwd: "/project" });
+      session.activate(ctx);
+
+      const pm2 = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm2);
+
+      session.reload();
+
+      expect(mockCreatePermissionManagerForCwd).toHaveBeenCalledWith(
+        "/test/agent",
+        "/project",
+      );
+    });
+
+    it("clears caches and skill entries", () => {
+      const { session } = createSession();
+      session.commitActiveToolsCacheKey("k1");
+      session.commitPromptStateCacheKey("k2");
+      session.setActiveSkillEntries([makeSkillEntry("s")]);
+
+      session.reload();
+
+      expect(session.shouldUpdateActiveTools("k1")).toBe(true);
+      expect(session.shouldUpdatePromptState("k2")).toBe(true);
+      expect(session.getActiveSkillEntries()).toEqual([]);
+    });
+  });
+
+  describe("getRuntimeContext", () => {
+    it("returns null before activation", () => {
+      const { session } = createSession();
+      expect(session.getRuntimeContext()).toBeNull();
+    });
+
+    it("returns context after activation", () => {
+      const { session } = createSession();
+      const ctx = makeCtx();
+      session.activate(ctx);
+      expect(session.getRuntimeContext()).toBe(ctx);
+    });
+
+    it("returns null after deactivation", () => {
+      const { session } = createSession();
+      session.activate(makeCtx());
+      session.deactivate();
+      expect(session.getRuntimeContext()).toBeNull();
+    });
+  });
+});

package/tests/runtime.test.ts

@@ -8,8 +8,6 @@ const {
   mockCreateLogger,
   mockLoadAndMergeConfigs,
   mockSyncPermissionSystemStatus,
-  mockGetActiveAgentName,
-  mockGetActiveAgentNameFromSystemPrompt,
   mockBuildResolvedConfigLogEntry,
   mockDiscoverGlobalNodeModulesRoot,
 } = vi.hoisted(() => ({
@@ -24,9 +22,6 @@ const {
   mockCreateLogger: vi.fn(),
   mockLoadAndMergeConfigs: vi.fn(),
   mockSyncPermissionSystemStatus: vi.fn(),
-  mockGetActiveAgentName: vi.fn<() => string | null>(),
-  mockGetActiveAgentNameFromSystemPrompt:
-    vi.fn<(prompt?: string) => string | null>(),
   mockBuildResolvedConfigLogEntry: vi.fn(),
   mockDiscoverGlobalNodeModulesRoot: vi.fn<() => string | null>(),
 }));
@@ -50,11 +45,6 @@ vi.mock("../src/status", () => ({
   getPermissionSystemStatus: vi.fn(),
 }));
 
-vi.mock("../src/active-agent", () => ({
-  getActiveAgentName: mockGetActiveAgentName,
-  getActiveAgentNameFromSystemPrompt: mockGetActiveAgentNameFromSystemPrompt,
-}));
-
 vi.mock("../src/config-reporter", () => ({
   buildResolvedConfigLogEntry: mockBuildResolvedConfigLogEntry,
 }));
@@ -89,7 +79,6 @@ import {
   createPermissionManagerForCwd,
   derivePiProjectPaths,
   refreshExtensionConfig,
-  resolveAgentName,
 } from "../src/runtime";
 
 // ── test suite ─────────────────────────────────────────────────────────────
@@ -212,21 +201,6 @@ describe("createExtensionRuntime", () => {
     expect(runtime.lastConfigWarning).toBeNull();
   });
 
-  it("initializes permissionForwardingContext to null", () => {
-    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
-    expect(runtime.permissionForwardingContext).toBeNull();
-  });
-
-  it("initializes permissionForwardingTimer to null", () => {
-    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
-    expect(runtime.permissionForwardingTimer).toBeNull();
-  });
-
-  it("initializes isProcessingForwardedRequests to false", () => {
-    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
-    expect(runtime.isProcessingForwardedRequests).toBe(false);
-  });
-
   it("creates a sessionRules instance", () => {
     const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
     expect(runtime.sessionRules).toBeDefined();
@@ -593,69 +567,5 @@ describe("refreshExtensionConfig", () => {
   });
 });
 
-// ── resolveAgentName ──────────────────────────────────────────────────────
-
-describe("resolveAgentName", () => {
-  function makeRuntime() {
-    mockCreateLogger.mockReturnValue({
-      debug: mockLoggerDebug,
-      review: mockLoggerReview,
-    });
-    return createExtensionRuntime({ agentDir: "/test/agent" });
-  }
-
-  function makeCtx(): ExtensionContext {
-    return {
-      cwd: "/test/project",
-      hasUI: false,
-      ui: {},
-      sessionManager: { getEntries: vi.fn(), addEntry: vi.fn() },
-    } as unknown as ExtensionContext;
-  }
-
-  beforeEach(() => {
-    mockLoggerDebug.mockReset().mockReturnValue(undefined);
-    mockGetActiveAgentName.mockReset().mockReturnValue(null);
-    mockGetActiveAgentNameFromSystemPrompt.mockReset().mockReturnValue(null);
-  });
-
-  it("returns and stores name from getActiveAgentName when available", () => {
-    const runtime = makeRuntime();
-    mockGetActiveAgentName.mockReturnValue("session-agent");
-    const result = resolveAgentName(runtime, makeCtx());
-    expect(result).toBe("session-agent");
-    expect(runtime.lastKnownActiveAgentName).toBe("session-agent");
-  });
-
-  it("falls back to getActiveAgentNameFromSystemPrompt when session name is null", () => {
-    const runtime = makeRuntime();
-    mockGetActiveAgentName.mockReturnValue(null);
-    mockGetActiveAgentNameFromSystemPrompt.mockReturnValue("prompt-agent");
-    const result = resolveAgentName(runtime, makeCtx(), "system prompt text");
-    expect(result).toBe("prompt-agent");
-    expect(runtime.lastKnownActiveAgentName).toBe("prompt-agent");
-  });
-
-  it("falls back to lastKnownActiveAgentName when both sources return null", () => {
-    const runtime = makeRuntime();
-    runtime.lastKnownActiveAgentName = "remembered-agent";
-    mockGetActiveAgentName.mockReturnValue(null);
-    mockGetActiveAgentNameFromSystemPrompt.mockReturnValue(null);
-    const result = resolveAgentName(runtime, makeCtx());
-    expect(result).toBe("remembered-agent");
-  });
-
-  it("returns null when all sources are null and no prior name", () => {
-    const runtime = makeRuntime();
-    const result = resolveAgentName(runtime, makeCtx());
-    expect(result).toBeNull();
-  });
-
-  it("does not update lastKnownActiveAgentName when falling back to stored value", () => {
-    const runtime = makeRuntime();
-    runtime.lastKnownActiveAgentName = "remembered-agent";
-    resolveAgentName(runtime, makeCtx());
-    // Value unchanged — not overwritten with null
-    expect(runtime.lastKnownActiveAgentName).toBe("remembered-agent");
-  });
-});
+// resolveAgentName was moved to PermissionSession (#129)
+// Tests live in tests/permission-session.test.ts