@gotgenes/pi-permission-system 3.7.0 → 3.8.0

package/tests/runtime.test.ts

@@ -0,0 +1,618 @@
+import { join } from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── logger stub ────────────────────────────────────────────────────────────
+const {
+  mockLoggerDebug,
+  mockLoggerReview,
+  mockCreateLogger,
+  mockLoadAndMergeConfigs,
+  mockSyncPermissionSystemStatus,
+  mockGetActiveAgentName,
+  mockGetActiveAgentNameFromSystemPrompt,
+  mockBuildResolvedConfigLogEntry,
+} = vi.hoisted(() => ({
+  mockLoggerDebug:
+    vi.fn<
+      (event: string, details?: Record<string, unknown>) => string | undefined
+    >(),
+  mockLoggerReview:
+    vi.fn<
+      (event: string, details?: Record<string, unknown>) => string | undefined
+    >(),
+  mockCreateLogger: vi.fn(),
+  mockLoadAndMergeConfigs: vi.fn(),
+  mockSyncPermissionSystemStatus: vi.fn(),
+  mockGetActiveAgentName: vi.fn<() => string | null>(),
+  mockGetActiveAgentNameFromSystemPrompt:
+    vi.fn<(prompt?: string) => string | null>(),
+  mockBuildResolvedConfigLogEntry: vi.fn(),
+}));
+
+vi.mock("../src/logging", () => ({
+  createPermissionSystemLogger: mockCreateLogger,
+}));
+
+vi.mock("../src/permission-manager", () => ({
+  PermissionManager: vi.fn(),
+}));
+
+vi.mock("../src/config-loader", () => ({
+  loadAndMergeConfigs: mockLoadAndMergeConfigs,
+  loadUnifiedConfig: vi.fn().mockReturnValue({ config: {} }),
+}));
+
+vi.mock("../src/status", () => ({
+  PERMISSION_SYSTEM_STATUS_KEY: "permission-system",
+  syncPermissionSystemStatus: mockSyncPermissionSystemStatus,
+  getPermissionSystemStatus: vi.fn(),
+}));
+
+vi.mock("../src/active-agent", () => ({
+  getActiveAgentName: mockGetActiveAgentName,
+  getActiveAgentNameFromSystemPrompt: mockGetActiveAgentNameFromSystemPrompt,
+}));
+
+vi.mock("../src/config-reporter", () => ({
+  buildResolvedConfigLogEntry: mockBuildResolvedConfigLogEntry,
+}));
+
+vi.mock("../src/forwarded-permissions/polling", () => ({
+  processForwardedPermissionRequests: vi.fn().mockResolvedValue(undefined),
+  confirmPermission: vi
+    .fn()
+    .mockResolvedValue({ approved: true, state: "approved" }),
+}));
+
+vi.mock("../src/subagent-context", () => ({
+  isSubagentExecutionContext: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock("../src/session-approval-cache", () => ({
+  SessionApprovalCache: vi.fn(),
+}));
+
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  getGlobalConfigPath,
+  getGlobalLogsDir,
+  getProjectConfigPath,
+} from "../src/config-paths";
+import { DEFAULT_EXTENSION_CONFIG } from "../src/extension-config";
+import { PermissionManager } from "../src/permission-manager";
+import {
+  createExtensionRuntime,
+  createPermissionManagerForCwd,
+  derivePiProjectPaths,
+  refreshExtensionConfig,
+  resolveAgentName,
+} from "../src/runtime";
+
+// ── test suite ─────────────────────────────────────────────────────────────
+
+describe("createExtensionRuntime", () => {
+  beforeEach(() => {
+    mockLoggerDebug.mockReset();
+    mockLoggerDebug.mockReturnValue(undefined);
+    mockLoggerReview.mockReset();
+    mockLoggerReview.mockReturnValue(undefined);
+    mockCreateLogger.mockReset();
+    mockCreateLogger.mockReturnValue({
+      debug: mockLoggerDebug,
+      review: mockLoggerReview,
+    });
+  });
+
+  // ── Path derivation ──────────────────────────────────────────────────────
+
+  it("sets agentDir from provided option", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.agentDir).toBe("/test/agent");
+  });
+
+  it("derives sessionsDir from agentDir", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.sessionsDir).toBe("/test/agent/sessions");
+  });
+
+  it("derives subagentSessionsDir from agentDir", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.subagentSessionsDir).toBe("/test/agent/subagent-sessions");
+  });
+
+  it("derives forwardingDir as sessions/permission-forwarding", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.forwardingDir).toBe(
+      "/test/agent/sessions/permission-forwarding",
+    );
+  });
+
+  it("derives globalLogsDir via getGlobalLogsDir", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.globalLogsDir).toBe(getGlobalLogsDir("/test/agent"));
+  });
+
+  // ── Default mutable state ────────────────────────────────────────────────
+
+  it("initializes config to DEFAULT_EXTENSION_CONFIG", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.config).toEqual(DEFAULT_EXTENSION_CONFIG);
+  });
+
+  it("initializes runtimeContext to null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.runtimeContext).toBeNull();
+  });
+
+  it("initializes activeSkillEntries to empty array", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.activeSkillEntries).toEqual([]);
+  });
+
+  it("initializes lastKnownActiveAgentName to null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.lastKnownActiveAgentName).toBeNull();
+  });
+
+  it("initializes lastActiveToolsCacheKey to null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.lastActiveToolsCacheKey).toBeNull();
+  });
+
+  it("initializes lastPromptStateCacheKey to null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.lastPromptStateCacheKey).toBeNull();
+  });
+
+  it("initializes lastConfigWarning to null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    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 sessionApprovalCache instance", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    expect(runtime.sessionApprovalCache).toBeDefined();
+  });
+
+  // ── Mutable state is writable ──────────────────────────────────────────
+
+  it("allows config to be updated", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const newConfig = {
+      debugLog: true,
+      permissionReviewLog: false,
+      yoloMode: false,
+    };
+    runtime.config = newConfig;
+    expect(runtime.config).toEqual(newConfig);
+  });
+
+  it("allows runtimeContext to be updated", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const mockCtx = { hasUI: false } as never;
+    runtime.runtimeContext = mockCtx;
+    expect(runtime.runtimeContext).toBe(mockCtx);
+  });
+
+  // ── Logger is created with runtime-derived paths ─────────────────────────
+
+  it("creates the logger with derived debugLogPath and reviewLogPath", () => {
+    const agentDir = "/test/agent";
+    const expectedLogsDir = getGlobalLogsDir(agentDir);
+    createExtensionRuntime({ agentDir });
+    expect(mockCreateLogger).toHaveBeenCalledOnce();
+    const opts = mockCreateLogger.mock.calls[0][0] as {
+      debugLogPath: string;
+      reviewLogPath: string;
+    };
+    expect(opts.debugLogPath).toContain(expectedLogsDir);
+    expect(opts.reviewLogPath).toContain(expectedLogsDir);
+  });
+
+  it("passes getConfig that reads current runtime.config", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const opts = mockCreateLogger.mock.calls[0][0] as {
+      getConfig: () => typeof DEFAULT_EXTENSION_CONFIG;
+    };
+    const updatedConfig = {
+      debugLog: true,
+      permissionReviewLog: false,
+      yoloMode: false,
+    };
+    runtime.config = updatedConfig;
+    // getConfig() should reflect the updated value
+    expect(opts.getConfig()).toEqual(updatedConfig);
+  });
+
+  // ── writeDebugLog delegates to logger.debug ──────────────────────────────
+
+  it("writeDebugLog calls logger.debug with event and details", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    runtime.writeDebugLog("test.event", { key: "value" });
+    expect(mockLoggerDebug).toHaveBeenCalledWith("test.event", {
+      key: "value",
+    });
+  });
+
+  it("writeDebugLog uses empty object as default details", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    runtime.writeDebugLog("test.event");
+    expect(mockLoggerDebug).toHaveBeenCalledWith("test.event", {});
+  });
+
+  // ── writeReviewLog delegates to logger.review ────────────────────────────
+
+  it("writeReviewLog calls logger.review with event and details", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    runtime.writeReviewLog("test.event", { key: "value" });
+    expect(mockLoggerReview).toHaveBeenCalledWith("test.event", {
+      key: "value",
+    });
+  });
+
+  it("writeReviewLog uses empty object as default details", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    runtime.writeReviewLog("test.event");
+    expect(mockLoggerReview).toHaveBeenCalledWith("test.event", {});
+  });
+
+  // ── Logging warning reporter ──────────────────────────────────────────────
+
+  it("notifies runtimeContext.ui when logger returns a warning", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const mockNotify = vi.fn();
+    runtime.runtimeContext = {
+      hasUI: true,
+      ui: { notify: mockNotify },
+    } as never;
+    mockLoggerDebug.mockReturnValueOnce("log dir not writable");
+    runtime.writeDebugLog("some.event");
+    expect(mockNotify).toHaveBeenCalledWith("log dir not writable", "warning");
+  });
+
+  it("does not notify when runtimeContext is null", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    mockLoggerDebug.mockReturnValueOnce("a warning");
+    // runtimeContext is null, should not throw
+    expect(() => runtime.writeDebugLog("some.event")).not.toThrow();
+  });
+
+  it("deduplicates logging warnings (same warning not reported twice)", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const mockNotify = vi.fn();
+    runtime.runtimeContext = {
+      hasUI: true,
+      ui: { notify: mockNotify },
+    } as never;
+    mockLoggerDebug
+      .mockReturnValueOnce("duplicate warning")
+      .mockReturnValueOnce("duplicate warning");
+    runtime.writeDebugLog("event.one");
+    runtime.writeDebugLog("event.two");
+    // The same warning should only be notified once
+    expect(mockNotify).toHaveBeenCalledTimes(1);
+    expect(mockNotify).toHaveBeenCalledWith("duplicate warning", "warning");
+  });
+
+  it("reports a different warning even after a duplicate has been suppressed", () => {
+    const runtime = createExtensionRuntime({ agentDir: "/test/agent" });
+    const mockNotify = vi.fn();
+    runtime.runtimeContext = {
+      hasUI: true,
+      ui: { notify: mockNotify },
+    } as never;
+    mockLoggerDebug
+      .mockReturnValueOnce("warning A")
+      .mockReturnValueOnce("warning A")
+      .mockReturnValueOnce("warning B");
+    runtime.writeDebugLog("event.one");
+    runtime.writeDebugLog("event.two");
+    runtime.writeDebugLog("event.three");
+    expect(mockNotify).toHaveBeenCalledTimes(2);
+    expect(mockNotify).toHaveBeenNthCalledWith(1, "warning A", "warning");
+    expect(mockNotify).toHaveBeenNthCalledWith(2, "warning B", "warning");
+  });
+
+  // ── Multiple independent runtimes ─────────────────────────────────────────
+
+  it("two runtimes have independent state", () => {
+    const rt1 = createExtensionRuntime({ agentDir: "/agent/a" });
+    const rt2 = createExtensionRuntime({ agentDir: "/agent/b" });
+    rt1.lastKnownActiveAgentName = "agent-a";
+    expect(rt2.lastKnownActiveAgentName).toBeNull();
+  });
+});
+
+// ── derivePiProjectPaths ───────────────────────────────────────────────────
+
+describe("derivePiProjectPaths", () => {
+  it("returns null for null cwd", () => {
+    expect(derivePiProjectPaths(null)).toBeNull();
+  });
+
+  it("returns null for undefined cwd", () => {
+    expect(derivePiProjectPaths(undefined)).toBeNull();
+  });
+
+  it("returns null for empty string cwd", () => {
+    expect(derivePiProjectPaths("")).toBeNull();
+  });
+
+  it("returns projectGlobalConfigPath via getProjectConfigPath", () => {
+    const result = derivePiProjectPaths("/my/project");
+    expect(result?.projectGlobalConfigPath).toBe(
+      getProjectConfigPath("/my/project"),
+    );
+  });
+
+  it("returns projectAgentsDir as .pi/agent/agents under cwd", () => {
+    const result = derivePiProjectPaths("/my/project");
+    expect(result?.projectAgentsDir).toBe(
+      join("/my/project", ".pi", "agent", "agents"),
+    );
+  });
+});
+
+// ── createPermissionManagerForCwd ─────────────────────────────────────────
+
+describe("createPermissionManagerForCwd", () => {
+  beforeEach(() => {
+    // PermissionManager is already mocked as vi.fn() at module scope.
+  });
+
+  it("creates a PermissionManager with globalConfigPath from agentDir", () => {
+    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
+    MockPM.mockClear();
+    createPermissionManagerForCwd("/test/agent", null);
+    expect(MockPM).toHaveBeenCalledWith(
+      expect.objectContaining({
+        globalConfigPath: getGlobalConfigPath("/test/agent"),
+      }),
+    );
+  });
+
+  it("includes projectGlobalConfigPath when cwd is provided", () => {
+    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
+    MockPM.mockClear();
+    createPermissionManagerForCwd("/test/agent", "/my/project");
+    expect(MockPM).toHaveBeenCalledWith(
+      expect.objectContaining({
+        globalConfigPath: getGlobalConfigPath("/test/agent"),
+        projectGlobalConfigPath: getProjectConfigPath("/my/project"),
+      }),
+    );
+  });
+
+  it("excludes projectGlobalConfigPath when cwd is null", () => {
+    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
+    MockPM.mockClear();
+    createPermissionManagerForCwd("/test/agent", null);
+    const callArg = MockPM.mock.calls[0][0] as Record<string, unknown>;
+    expect(callArg.projectGlobalConfigPath).toBeUndefined();
+  });
+});
+
+// ── refreshExtensionConfig ────────────────────────────────────────────────
+
+describe("refreshExtensionConfig", () => {
+  function makeRuntime() {
+    mockCreateLogger.mockReturnValue({
+      debug: mockLoggerDebug,
+      review: mockLoggerReview,
+    });
+    return createExtensionRuntime({ agentDir: "/test/agent" });
+  }
+
+  function makeCtx(
+    overrides: Partial<ExtensionContext> = {},
+  ): ExtensionContext {
+    return {
+      cwd: "/test/project",
+      hasUI: false,
+      ui: { notify: vi.fn(), setStatus: vi.fn() },
+      sessionManager: { getEntries: vi.fn(), addEntry: vi.fn() },
+      ...overrides,
+    } as unknown as ExtensionContext;
+  }
+
+  beforeEach(() => {
+    mockLoggerDebug.mockReset().mockReturnValue(undefined);
+    mockLoggerReview.mockReset().mockReturnValue(undefined);
+    mockLoadAndMergeConfigs.mockReset().mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: [],
+    });
+    mockSyncPermissionSystemStatus.mockReset();
+  });
+
+  it("updates runtime.runtimeContext when ctx is provided", () => {
+    const runtime = makeRuntime();
+    const ctx = makeCtx();
+    refreshExtensionConfig(runtime, ctx);
+    expect(runtime.runtimeContext).toBe(ctx);
+  });
+
+  it("does not override runtimeContext when ctx is omitted", () => {
+    const runtime = makeRuntime();
+    const existing = makeCtx();
+    runtime.runtimeContext = existing;
+    refreshExtensionConfig(runtime);
+    expect(runtime.runtimeContext).toBe(existing);
+  });
+
+  it("updates runtime.config with normalized merged result", () => {
+    const runtime = makeRuntime();
+    mockLoadAndMergeConfigs.mockReturnValue({
+      merged: { debugLog: true, permissionReviewLog: false, yoloMode: false },
+      issues: [],
+    });
+    refreshExtensionConfig(runtime);
+    expect(runtime.config.debugLog).toBe(true);
+    expect(runtime.config.permissionReviewLog).toBe(false);
+  });
+
+  it("calls loadAndMergeConfigs with runtime.agentDir and cwd", () => {
+    const runtime = makeRuntime();
+    const ctx = makeCtx({ cwd: "/my/project" });
+    refreshExtensionConfig(runtime, ctx);
+    expect(mockLoadAndMergeConfigs).toHaveBeenCalledWith(
+      "/test/agent",
+      "/my/project",
+      expect.any(String), // EXTENSION_ROOT
+    );
+  });
+
+  it("writes config.loaded debug log", () => {
+    const runtime = makeRuntime();
+    refreshExtensionConfig(runtime);
+    expect(mockLoggerDebug).toHaveBeenCalledWith(
+      "config.loaded",
+      expect.objectContaining({ debugLog: false }),
+    );
+  });
+
+  it("sets lastConfigWarning when issues are present", () => {
+    const runtime = makeRuntime();
+    mockLoadAndMergeConfigs.mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: ["legacy config detected"],
+    });
+    refreshExtensionConfig(runtime);
+    expect(runtime.lastConfigWarning).toBe("legacy config detected");
+  });
+
+  it("clears lastConfigWarning when no issues", () => {
+    const runtime = makeRuntime();
+    runtime.lastConfigWarning = "old warning";
+    mockLoadAndMergeConfigs.mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: [],
+    });
+    refreshExtensionConfig(runtime);
+    expect(runtime.lastConfigWarning).toBeNull();
+  });
+
+  it("notifies UI when a new warning appears and hasUI is true", () => {
+    const runtime = makeRuntime();
+    const mockNotify = vi.fn();
+    const ctx = makeCtx({ hasUI: true, ui: { notify: mockNotify } as never });
+    mockLoadAndMergeConfigs.mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: ["new warning"],
+    });
+    refreshExtensionConfig(runtime, ctx);
+    expect(mockNotify).toHaveBeenCalledWith("new warning", "warning");
+  });
+
+  it("does not re-notify the same warning on subsequent calls", () => {
+    const runtime = makeRuntime();
+    const mockNotify = vi.fn();
+    const ctx = makeCtx({ hasUI: true, ui: { notify: mockNotify } as never });
+    mockLoadAndMergeConfigs.mockReturnValue({
+      merged: { ...DEFAULT_EXTENSION_CONFIG },
+      issues: ["persistent warning"],
+    });
+    refreshExtensionConfig(runtime, ctx);
+    refreshExtensionConfig(runtime, ctx);
+    expect(mockNotify).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls syncPermissionSystemStatus when hasUI is true", () => {
+    const runtime = makeRuntime();
+    const ctx = makeCtx({ hasUI: true });
+    refreshExtensionConfig(runtime, ctx);
+    expect(mockSyncPermissionSystemStatus).toHaveBeenCalledWith(
+      ctx,
+      expect.any(Object),
+    );
+  });
+
+  it("does not call syncPermissionSystemStatus when hasUI is false", () => {
+    const runtime = makeRuntime();
+    const ctx = makeCtx({ hasUI: false });
+    refreshExtensionConfig(runtime, ctx);
+    expect(mockSyncPermissionSystemStatus).not.toHaveBeenCalled();
+  });
+});
+
+// ── 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");
+  });
+});