@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-tool-display/tests/reload-behavior.test.ts

@@ -1,1241 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import test from "node:test";
-import {
-  UserMessageComponent,
-  type ExtensionAPI,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import toolDisplayExtension from "../src/index.ts";
-import { registerToolDisplayOverrides } from "../src/tool-overrides.ts";
-import { renderBashCall } from "../src/bash-display.ts";
-import { registerThinkingLabeling } from "../src/thinking-label.ts";
-import registerNativeUserMessageBox from "../src/user-message-box-native.ts";
-import { createToolDisplayDebugLogger } from "../src/debug-logger.ts";
-import { loadToolDisplayConfig, saveToolDisplayConfig } from "../src/config-store.ts";
-import { DEFAULT_TOOL_DISPLAY_CONFIG, type ToolDisplayConfig } from "../src/types.ts";
-import type { PatchableUserMessagePrototype } from "../src/user-message-box-patch.ts";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-interface CapturedHandler {
-  event: string;
-  handler: (...args: unknown[]) => unknown;
-}
-
-interface CapturedCommand {
-  name: string;
-  description?: string;
-  handler?: (...args: unknown[]) => unknown;
-}
-
-interface ToolLike {
-  name: string;
-  renderCall?: unknown;
-  renderResult?: unknown;
-  [key: string]: unknown;
-}
-
-/**
- * Create a minimal ExtensionAPI stub that captures registrations for later
- * inspection. Mirrors the pattern from index-integration.test.ts.
- */
-function createApiStub(
-  overrides: Partial<{
-    registerTool: (tool: unknown) => void;
-    registerCommand: (name: string, cmd: unknown) => void;
-    on: (event: string, handler: (...args: unknown[]) => unknown) => void;
-    getAllTools: () => unknown[];
-    getCommands: () => Array<{ name: string }>;
-  }> = {},
-): {
-  api: ExtensionAPI;
-  capturedTools: ToolLike[];
-  capturedCommands: CapturedCommand[];
-  capturedHandlers: CapturedHandler[];
-} {
-  const capturedTools: ToolLike[] = [];
-  const capturedCommands: CapturedCommand[] = [];
-  const capturedHandlers: CapturedHandler[] = [];
-
-  const api = {
-    registerTool(tool: unknown): void {
-      capturedTools.push(tool as ToolLike);
-      overrides.registerTool?.(tool);
-    },
-    registerCommand(name: string, cmd: unknown): void {
-      capturedCommands.push({ name, ...(cmd as object) } as CapturedCommand);
-      overrides.registerCommand?.(name, cmd);
-    },
-    on(event: string, handler: (...args: unknown[]) => unknown): void {
-      capturedHandlers.push({ event, handler });
-      overrides.on?.(event, handler);
-    },
-    getAllTools(): unknown[] {
-      return overrides.getAllTools?.() ?? [];
-    },
-    getCommands(): Array<{ name: string }> {
-      return overrides.getCommands?.() ?? [];
-    },
-  } as unknown as ExtensionAPI;
-
-  return { api, capturedTools, capturedCommands, capturedHandlers };
-}
-
-/**
- * Create a stub for registerToolDisplayOverrides tests that need event-driven
- * deferred registration (read/edit/grep deferral).
- */
-function createExtensionApiStub(allTools: unknown[] = []): {
-  api: ExtensionAPI;
-  registeredTools: ToolLike[];
-  eventHandlers: Record<string, () => Promise<void> | void>;
-} {
-  const registeredTools: ToolLike[] = [];
-  const eventHandlers: Record<string, () => Promise<void> | void> = {};
-  const api = {
-    registerTool(tool: ToolLike): void {
-      registeredTools.push(tool);
-    },
-    on(event: string, handler: () => Promise<void> | void): void {
-      eventHandlers[event] = handler;
-    },
-    getAllTools(): unknown[] {
-      return allTools;
-    },
-  } as unknown as ExtensionAPI;
-
-  return { api, registeredTools, eventHandlers };
-}
-
-/** Minimal theme stub for render calls. */
-const stubTheme = {
-  fg: (_color: string, text: string) => text,
-  bold: (text: string) => text,
-};
-
-// ---------------------------------------------------------------------------
-// 1. Basic reload detection
-// ---------------------------------------------------------------------------
-
-test("1: calling toolDisplayExtension twice (reload) does not throw", () => {
-  const { api } = createApiStub();
-  toolDisplayExtension(api);
-  assert.doesNotThrow(() => toolDisplayExtension(api));
-});
-
-test("1: after reload, new lifecycle handlers are registered", () => {
-  const { api, capturedHandlers } = createApiStub();
-  const beforeCount = capturedHandlers.length;
-
-  toolDisplayExtension(api);
-  const afterFirstCount = capturedHandlers.length;
-  assert.ok(afterFirstCount > beforeCount, "handlers registered on first call");
-
-  // Simulate reload
-  toolDisplayExtension(api);
-  const afterSecondCount = capturedHandlers.length;
-  assert.ok(afterSecondCount > afterFirstCount, "handlers accumulate on reload");
-});
-
-// ---------------------------------------------------------------------------
-// 2. Tool override restoration
-// ---------------------------------------------------------------------------
-
-test("2: built-in tool overrides are re-registered on reload", () => {
-  const { api, capturedTools } = createApiStub();
-
-  // First call
-  toolDisplayExtension(api);
-  const firstTools = capturedTools.map((t) => t.name);
-  assert.ok(firstTools.includes("find"), "find registered on first call");
-
-  // Simulate reload
-  const countBeforeReload = capturedTools.length;
-  toolDisplayExtension(api);
-  const countAfterReload = capturedTools.length;
-
-  // Each call to registerToolDisplayOverrides registers the same built-in
-  // tools again (find, ls, write immediately; read/grep/edit/bash deferred).
-  assert.ok(
-    countAfterReload >= countBeforeReload + 3,
-    "at least 3 tools re-registered on reload",
-  );
-
-  // Verify tool names appear multiple times, meaning they were re-registered
-  const toolNameCounts = new Map<string, number>();
-  for (const tool of capturedTools) {
-    toolNameCounts.set(tool.name, (toolNameCounts.get(tool.name) ?? 0) + 1);
-  }
-  assert.ok(
-    (toolNameCounts.get("find") ?? 0) >= 2,
-    "find is registered at least twice (two calls)",
-  );
-  assert.ok(
-    (toolNameCounts.get("ls") ?? 0) >= 2,
-    "ls is registered at least twice (two calls)",
-  );
-  assert.ok(
-    (toolNameCounts.get("write") ?? 0) >= 2,
-    "write is registered at least twice (two calls)",
-  );
-});
-
-test("2: re-registered tools have renderCall and renderResult functions after reload", () => {
-  const { api, capturedTools } = createApiStub();
-
-  toolDisplayExtension(api);
-  toolDisplayExtension(api);
-
-  // Collect tools registered in the SECOND call only
-  const allTools = capturedTools;
-  const midPoint = Math.floor(allTools.length / 2);
-  const secondCallTools = allTools.slice(midPoint);
-
-  if (secondCallTools.length > 0) {
-    for (const tool of secondCallTools) {
-      if (tool.name === "read" || tool.name === "edit" || tool.name === "grep") {
-        continue; // Deferred - not registered immediately
-      }
-      assert.ok(
-        typeof tool.renderCall === "function",
-        `${tool.name} from reload has renderCall`,
-      );
-      assert.ok(
-        typeof tool.renderResult === "function",
-        `${tool.name} from reload has renderResult`,
-      );
-    }
-  }
-});
-
-test("2: built-in tool overrides register before lifecycle events and re-register on reload", async () => {
-  const { api, registeredTools, eventHandlers } = createExtensionApiStub();
-
-  registerToolDisplayOverrides(api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  const firstImmediate = registeredTools.map((t) => t.name);
-
-  for (const toolName of ["read", "edit", "grep", "bash"] as const) {
-    assert.ok(firstImmediate.includes(toolName), `${toolName} registered before lifecycle events`);
-  }
-
-  const countBeforeLifecycle = registeredTools.length;
-  await eventHandlers.before_agent_start?.();
-  assert.equal(
-    registeredTools.length,
-    countBeforeLifecycle,
-    "before_agent_start does not duplicate already registered built-ins",
-  );
-
-  registerToolDisplayOverrides(api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  const countAfterReload = registeredTools.length;
-
-  assert.ok(
-    countAfterReload >= countBeforeLifecycle + 7,
-    "built-in display overrides re-register during reload initialization",
-  );
-});
-
-// ---------------------------------------------------------------------------
-// 3. Bash override cleanup (spinner timer)
-// ---------------------------------------------------------------------------
-
-test("3: bash spinner interval is created during partial execution and cleared on completion", () => {
-  const originalSetInterval = globalThis.setInterval;
-  const originalClearInterval = globalThis.clearInterval;
-
-  const createdIntervals: ReturnType<typeof setInterval>[] = [];
-  const clearedIntervals: ReturnType<typeof setInterval>[] = [];
-
-  // Mock setInterval to track creations
-  globalThis.setInterval = ((fn: (...args: unknown[]) => unknown, ms?: number, ..._args: unknown[]) => {
-    const id = originalSetInterval(fn as (...args: unknown[]) => unknown, ms ?? 0);
-    createdIntervals.push(id);
-    return id;
-  }) as typeof globalThis.setInterval;
-
-  // Mock clearInterval to track clearings
-  globalThis.clearInterval = ((id: ReturnType<typeof setInterval>) => {
-    clearedIntervals.push(id);
-    originalClearInterval(id);
-  }) as typeof globalThis.clearInterval;
-
-  try {
-    // Render context that triggers spinner
-    const textComponent = new Text("", 0, 0);
-    const context: Record<string, unknown> = {
-      executionStarted: true,
-      isPartial: true,
-      invalidate: () => {},
-      lastComponent: textComponent,
-      state: {},
-    };
-
-    // Create spinner
-    const result1 = renderBashCall(
-      { command: "sleep 5" },
-      stubTheme,
-      context as unknown as Parameters<typeof renderBashCall>[2],
-    );
-    assert.ok(result1 instanceof Text, "renderBashCall returns a Text");
-    assert.ok(
-      createdIntervals.length > 0,
-      "spinner interval was created during partial execution",
-    );
-
-    // Simulate execution completing (reload-like: context becomes non-partial)
-    context.isPartial = false;
-    const result2 = renderBashCall(
-      { command: "sleep 5" },
-      stubTheme,
-      context as unknown as Parameters<typeof renderBashCall>[2],
-    );
-    assert.ok(result2 instanceof Text, "renderBashCall still returns Text");
-    assert.ok(
-      clearedIntervals.length > 0,
-      "spinner interval was cleared on execution completion",
-    );
-
-    // Verify the created interval was also cleared
-    const allCreatedCleared = createdIntervals.every((id) =>
-      clearedIntervals.includes(id),
-    );
-    assert.ok(allCreatedCleared, "all created spinner intervals were cleared");
-  } finally {
-    globalThis.setInterval = originalSetInterval;
-    globalThis.clearInterval = originalClearInterval;
-    // Clean up any remaining intervals
-    for (const id of createdIntervals) {
-      if (!clearedIntervals.includes(id)) {
-        originalClearInterval(id);
-      }
-    }
-  }
-});
-
-test("3: multiple consecutive bash render calls do not create duplicate timers", () => {
-  const originalSetInterval = globalThis.setInterval;
-  const originalClearInterval = globalThis.clearInterval;
-
-  const createdIntervals: ReturnType<typeof setInterval>[] = [];
-
-  globalThis.setInterval = ((fn: (...args: unknown[]) => unknown, ms?: number, ..._args: unknown[]) => {
-    const id = originalSetInterval(fn, ms ?? 0);
-    createdIntervals.push(id);
-    return id;
-  }) as typeof globalThis.setInterval;
-
-  globalThis.clearInterval = ((id: ReturnType<typeof setInterval>) => {
-    originalClearInterval(id);
-  }) as typeof globalThis.clearInterval;
-
-  try {
-    const textComponent = new Text("", 0, 0);
-    const context: Record<string, unknown> = {
-      executionStarted: true,
-      isPartial: true,
-      invalidate: () => {},
-      lastComponent: textComponent,
-      state: {},
-    };
-
-    // Call renderBashCall multiple times - should only create ONE timer
-    renderBashCall({ command: "test" }, stubTheme, context as unknown as Parameters<typeof renderBashCall>[2]);
-    const afterFirst = createdIntervals.length;
-
-    renderBashCall({ command: "test" }, stubTheme, context as unknown as Parameters<typeof renderBashCall>[2]);
-    const afterSecond = createdIntervals.length;
-
-    // The timer should only be created once (guarded by spinnerState.timer check)
-    assert.equal(
-      afterSecond,
-      afterFirst,
-      "duplicate renderBashCall does not create another timer",
-    );
-
-    // Complete execution
-    context.isPartial = false;
-    renderBashCall({ command: "test" }, stubTheme, context as unknown as Parameters<typeof renderBashCall>[2]);
-  } finally {
-    globalThis.setInterval = originalSetInterval;
-    globalThis.clearInterval = originalClearInterval;
-  }
-});
-
-// ---------------------------------------------------------------------------
-// 4. MCP override cleanup
-// ---------------------------------------------------------------------------
-
-test("4: MCP tools are decorated on first registration (via session_start event)", () => {
-  // isMcpToolCandidate checks for name==="mcp" or description matching \bmcp\b
-  const mcpTool: Record<string, unknown> = {
-    name: "weather",
-    description: "MCP weather tool for forecasts",
-    parameters: { type: "object", properties: {} },
-    execute: () => "sunny",
-  };
-
-  const { api, eventHandlers } = createExtensionApiStub([mcpTool]);
-
-  assert.equal(
-    typeof mcpTool.renderCall,
-    "undefined",
-    "MCP tool has no renderCall before registration",
-  );
-
-  // registerToolDisplayOverrides registers session_start handler;
-  // MCP tool decoration happens inside that handler
-  registerToolDisplayOverrides(api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-
-  // MCP tools not decorated yet (deferred to session_start)
-  assert.equal(
-    typeof mcpTool.renderCall,
-    "undefined",
-    "MCP tool not decorated until session_start fires",
-  );
-
-  // Trigger the session_start event
-  if (eventHandlers.session_start) {
-    eventHandlers.session_start();
-  }
-
-  assert.ok(
-    typeof mcpTool.renderCall === "function",
-    "MCP tool receives renderCall after session_start",
-  );
-  assert.ok(
-    typeof mcpTool.renderResult === "function",
-    "MCP tool receives renderResult after session_start",
-  );
-});
-
-test("4: MCP tools get re-decorated on reload (new wrappedMcpToolNames set)", () => {
-  // isMcpToolCandidate checks for name==="mcp" or description matching \bmcp\b
-  const mcpTool: Record<string, unknown> = {
-    name: "weather",
-    description: "MCP weather tool for forecasts",
-    parameters: { type: "object", properties: {} },
-    execute: () => "sunny",
-  };
-
-  // First call: create a stub and trigger session_start
-  const { api: api1, eventHandlers: handlers1 } = createExtensionApiStub([mcpTool]);
-  registerToolDisplayOverrides(api1, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  handlers1.session_start?.();
-
-  assert.ok(
-    typeof mcpTool.renderCall === "function",
-    "MCP tool receives renderCall after first registration + session_start",
-  );
-  const firstRenderCall = mcpTool.renderCall;
-
-  // Reload: create a NEW stub (new getAllTools result) and trigger session_start
-  const { api: api2, eventHandlers: handlers2 } = createExtensionApiStub([mcpTool]);
-  registerToolDisplayOverrides(api2, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  handlers2.session_start?.();
-
-  const secondRenderCall = mcpTool.renderCall;
-
-  assert.ok(
-    typeof secondRenderCall === "function",
-    "MCP tool has renderCall after reload",
-  );
-});
-
-// ---------------------------------------------------------------------------
-// 5. User message box cleanup
-// ---------------------------------------------------------------------------
-
-test("5: UserMessageComponent prototype is patched on first call and safe on reload", () => {
-  const { api } = createApiStub();
-
-  const proto = UserMessageComponent.prototype as PatchableUserMessagePrototype;
-
-  // Before any patching
-  const originalRenderBefore = proto.__piUserMessageOriginalRender;
-
-  // First call patches it
-  toolDisplayExtension(api);
-  assert.ok(
-    proto.__piUserMessageNativePatched,
-    "prototype is marked as patched after first call",
-  );
-  assert.ok(
-    proto.__piUserMessageOriginalRender,
-    "original render is saved",
-  );
-
-  const firstOriginalRender = proto.__piUserMessageOriginalRender;
-
-  // Reload (second call) should be safe
-  assert.doesNotThrow(() => toolDisplayExtension(api));
-
-  assert.ok(
-    proto.__piUserMessageNativePatched,
-    "prototype remains patched after reload",
-  );
-  assert.equal(
-    proto.__piUserMessageOriginalRender,
-    firstOriginalRender,
-    "original render reference is preserved across reloads",
-  );
-});
-
-test("5: patchNativeUserMessagePrototype can be called multiple times safely", () => {
-  const proto = UserMessageComponent.prototype as PatchableUserMessagePrototype;
-
-  // Track the original render before any patching (tests share process state,
-  // so this might already be patched; we record what's there.)
-  const renderBefore = proto.render;
-  const wasAlreadyPatched = !!proto.__piUserMessageNativePatched;
-
-  // Patch via full extension (uses a fresh api stub each time)
-  assert.doesNotThrow(() => toolDisplayExtension(createApiStub().api));
-
-  // After calling, the prototype should be patched
-  assert.ok(
-    proto.__piUserMessageNativePatched,
-    "prototype is patched after first call",
-  );
-
-  // The original render reference should have been saved
-  assert.ok(
-    proto.__piUserMessageOriginalRender,
-    "original render is preserved after patch",
-  );
-
-  // If it wasn't already patched, the render function should have changed
-  if (!wasAlreadyPatched) {
-    assert.notEqual(
-      proto.render,
-      renderBefore,
-      "patched render function differs from original",
-    );
-  }
-
-  // The __piUserMessageOriginalRender function should be callable
-  assert.equal(
-    typeof proto.__piUserMessageOriginalRender,
-    "function",
-    "original render is a function",
-  );
-
-  // Re-patching via another extension call is safe (no throw)
-  assert.doesNotThrow(() => {
-    toolDisplayExtension(createApiStub().api);
-  });
-
-  // The patched flag and original render ref remain stable
-  assert.ok(
-    proto.__piUserMessageNativePatched,
-    "prototype still patched after second call",
-  );
-  assert.ok(
-    proto.__piUserMessageOriginalRender,
-    "original render still preserved after second call",
-  );
-});
-
-// ---------------------------------------------------------------------------
-// 6. Command unregistration / re-registration
-// ---------------------------------------------------------------------------
-
-test("6: /tool-display command is registered on first call and re-registered on reload", () => {
-  const { api, capturedCommands } = createApiStub();
-
-  toolDisplayExtension(api);
-  const firstToolDisplayCmds = capturedCommands.filter(
-    (c) => c.name === "tool-display",
-  );
-  assert.equal(firstToolDisplayCmds.length, 1, "tool-display command registered");
-
-  // Reload
-  toolDisplayExtension(api);
-  const secondToolDisplayCmds = capturedCommands.filter(
-    (c) => c.name === "tool-display",
-  );
-  assert.ok(
-    secondToolDisplayCmds.length >= 1,
-    "tool-display command registered after reload",
-  );
-});
-
-// ---------------------------------------------------------------------------
-// 7. Thinking label cleanup
-// ---------------------------------------------------------------------------
-
-test("7: thinking label event handlers are registered on each extension call", () => {
-  const { api, capturedHandlers } = createApiStub();
-
-  // First call registers thinking label handlers
-  registerThinkingLabeling(api);
-  const handlerEvents = capturedHandlers.map((h) => h.event);
-
-  assert.ok(handlerEvents.includes("message_update"), "message_update registered");
-  assert.ok(handlerEvents.includes("message_end"), "message_end registered");
-  assert.ok(handlerEvents.includes("context"), "context registered");
-
-  // Count handlers per event
-  const messageUpdateCount = capturedHandlers.filter(
-    (h) => h.event === "message_update",
-  ).length;
-  const messageEndCount = capturedHandlers.filter(
-    (h) => h.event === "message_end",
-  ).length;
-  const contextCount = capturedHandlers.filter(
-    (h) => h.event === "context",
-  ).length;
-
-  assert.equal(messageUpdateCount, 1, "one message_update handler after first call");
-  assert.equal(messageEndCount, 1, "one message_end handler after first call");
-  assert.equal(contextCount, 1, "one context handler after first call");
-
-  // Second call with same API — duplicate prevention skips re-registration
-  registerThinkingLabeling(api);
-  const messageUpdateAfterSecond = capturedHandlers.filter(
-    (h) => h.event === "message_update",
-  ).length;
-
-  assert.equal(
-    messageUpdateAfterSecond,
-    1,
-    "duplicate prevention: no new handlers on second call",
-  );
-
-  // Simulate reload by finding and invoking the session_shutdown handler
-  const shutdownHandler = capturedHandlers.find(
-    (h) => h.event === "session_shutdown",
-  )?.handler;
-  assert.ok(shutdownHandler, "session_shutdown handler registered");
-
-  // Invoke session_shutdown with reason "reload" — this resets the guard
-  if (shutdownHandler) {
-    shutdownHandler({ reason: "reload" });
-  }
-
-  // Third call — guard was reset by reload, so handlers register again
-  registerThinkingLabeling(api);
-  const messageUpdateAfterReload = capturedHandlers.filter(
-    (h) => h.event === "message_update",
-  ).length;
-
-  assert.equal(
-    messageUpdateAfterReload,
-    2,
-    "handlers re-register after reload resets the guard",
-  );
-});
-
-test("7: thinking label handlers do not throw when invoked after reload", async () => {
-  const { api } = createApiStub();
-
-  // First registration
-  toolDisplayExtension(api);
-
-  // Reload
-  toolDisplayExtension(api);
-
-  // Should be able to invoke all thinking handlers without error
-  // (We can't easily extract individual handlers from the stub, but the
-  // extension function itself being callable twice proves basic safety.)
-  assert.ok(true, "extension can be initialized twice with thinking label handlers");
-});
-
-// ---------------------------------------------------------------------------
-// 8. Lifecycle event cleanup
-// ---------------------------------------------------------------------------
-
-test("8: session_start and before_agent_start handlers registered on each call", () => {
-  const { api, capturedHandlers } = createApiStub();
-
-  toolDisplayExtension(api);
-  const eventsAfterFirst = capturedHandlers.filter(
-    (h) => h.event === "session_start" || h.event === "before_agent_start",
-  );
-
-  assert.ok(
-    eventsAfterFirst.some((h) => h.event === "session_start"),
-    "session_start handler registered",
-  );
-  assert.ok(
-    eventsAfterFirst.some((h) => h.event === "before_agent_start"),
-    "before_agent_start handler registered",
-  );
-
-  // Reload
-  toolDisplayExtension(api);
-  const eventsAfterReload = capturedHandlers.filter(
-    (h) => h.event === "session_start" || h.event === "before_agent_start",
-  );
-
-  assert.ok(
-    eventsAfterReload.length > eventsAfterFirst.length,
-    "lifecycle handlers re-registered on reload",
-  );
-});
-
-test("8: session_start handler can be invoked after reload without errors", async () => {
-  const { api, capturedHandlers } = createApiStub();
-
-  toolDisplayExtension(api);
-
-  // Find the first session_start handler
-  let sessionHandler = capturedHandlers.find(
-    (h) => h.event === "session_start",
-  )?.handler;
-  assert.ok(sessionHandler, "session_start handler found");
-
-  // Invoke it once
-  await assert.doesNotReject(async () =>
-    sessionHandler!({}, { ui: { theme: {}, notify: () => {} } }),
-  );
-
-  // Reload
-  toolDisplayExtension(api);
-
-  // Now there are multiple session_start handlers; the first one should
-  // still be invocable
-  const firstSessionHandler = capturedHandlers.find(
-    (h) => h.event === "session_start",
-  )?.handler;
-  assert.ok(firstSessionHandler, "session_start handler exists after reload");
-  await assert.doesNotReject(async () =>
-    firstSessionHandler!({}, { ui: { theme: {}, notify: () => {} } }),
-  );
-});
-
-// ---------------------------------------------------------------------------
-// 9. Double reload safety
-// ---------------------------------------------------------------------------
-
-test("9: calling toolDisplayExtension three times (double reload) is safe", () => {
-  const { api, capturedTools, capturedCommands } = createApiStub();
-
-  // First call
-  toolDisplayExtension(api);
-  const afterFirst = { tools: capturedTools.length, cmds: capturedCommands.length };
-
-  // First reload
-  toolDisplayExtension(api);
-  const afterSecond = { tools: capturedTools.length, cmds: capturedCommands.length };
-
-  // Second reload (double reload)
-  assert.doesNotThrow(() => toolDisplayExtension(api));
-  const afterThird = { tools: capturedTools.length, cmds: capturedCommands.length };
-
-  // Each call adds more registrations (no deduplication in the stub)
-  assert.ok(afterThird.tools > afterSecond.tools, "tools registered on third call");
-  assert.ok(afterThird.cmds > afterSecond.cmds, "commands registered on third call");
-
-  // Verify all tool registrations have renderCall/renderResult
-  for (const tool of capturedTools) {
-    if (tool.name === "read" || tool.name === "edit" || tool.name === "grep") {
-      continue; // Deferred tools
-    }
-    if (tool.renderCall !== undefined) {
-      assert.equal(
-        typeof tool.renderCall,
-        "function",
-        `${tool.name} renderCall is a function`,
-      );
-    }
-    if (tool.renderResult !== undefined) {
-      assert.equal(
-        typeof tool.renderResult,
-        "function",
-        `${tool.name} renderResult is a function`,
-      );
-    }
-  }
-});
-
-test("9: no duplicate setInterval across rapid reload-like scenarios", () => {
-  const originalSetInterval = globalThis.setInterval;
-  const originalClearInterval = globalThis.clearInterval;
-
-  const createdIntervals: ReturnType<typeof setInterval>[] = [];
-
-  globalThis.setInterval = ((fn: (...args: unknown[]) => unknown, ms?: number, ..._args: unknown[]) => {
-    const id = originalSetInterval(fn, ms ?? 0);
-    createdIntervals.push(id);
-    return id;
-  }) as typeof globalThis.setInterval;
-
-  globalThis.clearInterval = ((id: ReturnType<typeof setInterval>) => {
-    originalClearInterval(id);
-  }) as typeof globalThis.clearInterval;
-
-  try {
-    // Create two independent contexts (simulating two rapid calls)
-    const ctx1: Record<string, unknown> = {
-      executionStarted: true,
-      isPartial: true,
-      invalidate: () => {},
-      lastComponent: new Text("", 0, 0),
-      state: {},
-    };
-
-    const ctx2: Record<string, unknown> = {
-      executionStarted: true,
-      isPartial: true,
-      invalidate: () => {},
-      lastComponent: new Text("", 0, 0),
-      state: {},
-    };
-
-    // Simulate two rapid render calls (like double reload)
-    renderBashCall({ command: "test" }, stubTheme, ctx1 as unknown as Parameters<typeof renderBashCall>[2]);
-    renderBashCall({ command: "test" }, stubTheme, ctx2 as unknown as Parameters<typeof renderBashCall>[2]);
-
-    // Each context should get its own timer
-    assert.equal(createdIntervals.length, 2, "two contexts = two timers");
-
-    // Clean up both
-    ctx1.isPartial = false;
-    ctx2.isPartial = false;
-    renderBashCall({ command: "test" }, stubTheme, ctx1 as unknown as Parameters<typeof renderBashCall>[2]);
-    renderBashCall({ command: "test" }, stubTheme, ctx2 as unknown as Parameters<typeof renderBashCall>[2]);
-  } finally {
-    globalThis.setInterval = originalSetInterval;
-    globalThis.clearInterval = originalClearInterval;
-    for (const id of createdIntervals) {
-      originalClearInterval(id);
-    }
-  }
-});
-
-// ---------------------------------------------------------------------------
-// 10. Partial reload (active bash spinner mid-animation)
-// ---------------------------------------------------------------------------
-
-test("10: active bash spinner timer is cleaned up when execution transitions from partial to complete", () => {
-  const originalSetInterval = globalThis.setInterval;
-  const originalClearInterval = globalThis.clearInterval;
-
-  const createdIntervals: ReturnType<typeof setInterval>[] = [];
-  const clearedIntervals: ReturnType<typeof setInterval>[] = [];
-
-  globalThis.setInterval = ((fn: (...args: unknown[]) => unknown, ms?: number, ..._args: unknown[]) => {
-    const id = originalSetInterval(fn, ms ?? 0);
-    createdIntervals.push(id);
-    return id;
-  }) as typeof globalThis.setInterval;
-
-  globalThis.clearInterval = ((id: ReturnType<typeof setInterval>) => {
-    clearedIntervals.push(id);
-    originalClearInterval(id);
-  }) as typeof globalThis.clearInterval;
-
-  try {
-    const textComponent = new Text("", 0, 0);
-    const context: Record<string, unknown> = {
-      executionStarted: true,
-      isPartial: true,
-      invalidate: () => {},
-      lastComponent: textComponent,
-      state: {},
-    };
-
-    // Start spinner (mid-animation)
-    renderBashCall({ command: "long-running-task" }, stubTheme, context as unknown as Parameters<typeof renderBashCall>[2]);
-    assert.equal(createdIntervals.length, 1, "one timer created for spinner");
-
-    // Simulate partial reload: execution not started yet in new context
-    // (e.g., reload happens while bash is still running)
-    const newContext: Record<string, unknown> = {
-      executionStarted: false,
-      isPartial: false,
-      invalidate: () => {},
-      lastComponent: new Text("", 0, 0),
-      state: {},
-    };
-
-    // New render call with fresh context - no timer should be created since
-    // execution hasn't started
-    renderBashCall({ command: "long-running-task" }, stubTheme, newContext as unknown as Parameters<typeof renderBashCall>[2]);
-    assert.equal(
-      createdIntervals.length,
-      1,
-      "no new timer for non-executing context",
-    );
-
-    // Complete the original execution
-    context.isPartial = false;
-    renderBashCall({ command: "long-running-task" }, stubTheme, context as unknown as Parameters<typeof renderBashCall>[2]);
-
-    // Original timer should have been cleared
-    assert.ok(
-      clearedIntervals.length > 0,
-      "original spinner timer cleared on completion",
-    );
-  } finally {
-    globalThis.setInterval = originalSetInterval;
-    globalThis.clearInterval = originalClearInterval;
-    for (const id of createdIntervals) {
-      if (!clearedIntervals.includes(id)) {
-        originalClearInterval(id);
-      }
-    }
-  }
-});
-
-// ---------------------------------------------------------------------------
-// 11. State isolation between reloads
-// ---------------------------------------------------------------------------
-
-test("11: registerToolDisplayOverrides creates fresh state on each call", () => {
-  // Each call to registerToolDisplayOverrides creates new:
-  // - builtInToolCache (cleared)
-  // - registeredBuiltInToolOverrides Set
-  // - deferredBuiltInToolOverrides Map
-  // - wrappedMcpToolNames Set
-  // - ToolDisplayApi on globalThis
-
-  const mcpTool: Record<string, unknown> = {
-    name: "server-tool",
-    description: "An MCP tool",
-    parameters: {},
-    execute: () => "result",
-  };
-
-  // First call with MCP tool
-  const stub1 = createExtensionApiStub([mcpTool]);
-  registerToolDisplayOverrides(stub1.api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  // Trigger session_start to invoke registerMcpToolOverrides
-  stub1.eventHandlers.session_start?.();
-
-  assert.ok(
-    typeof mcpTool.renderCall === "function",
-    "MCP tool decorated in first registration",
-  );
-
-  const firstDeco = mcpTool.renderCall;
-
-  // Second call - fresh wrappedMcpToolNames set means re-decoration
-  const stub2 = createExtensionApiStub([mcpTool]);
-  registerToolDisplayOverrides(stub2.api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  stub2.eventHandlers.session_start?.();
-
-  // The MCP tool is the same object, so it should have been re-decorated
-  // Even though the first call already decorated it, the second call's new
-  // wrappedMcpToolNames set doesn't know about it.
-  // The decoration may produce the same function or a new one; either is fine
-  // as long as renderCall is still a function.
-  assert.ok(
-    typeof mcpTool.renderCall === "function",
-    "MCP tool still has renderCall after second registration",
-  );
-});
-
-test("11: each tool override call clones parameters independently", () => {
-  const { api, registeredTools, eventHandlers } = createExtensionApiStub();
-
-  // First call
-  registerToolDisplayOverrides(api, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  const firstParamRefs = new Map(
-    registeredTools.map((t) => [t.name, t.parameters]),
-  );
-
-  // Trigger deferred registration
-  eventHandlers.before_agent_start?.();
-
-  const firstAllParamRefs = new Map(
-    registeredTools.map((t) => [t.name, t.parameters]),
-  );
-
-  // Second call
-  const { api: api2, registeredTools: tools2, eventHandlers: handlers2 } = createExtensionApiStub();
-  registerToolDisplayOverrides(api2, () => DEFAULT_TOOL_DISPLAY_CONFIG);
-  handlers2.before_agent_start?.();
-
-  const secondParamRefs = new Map(
-    tools2.map((t) => [t.name, t.parameters]),
-  );
-
-  // Parameters from first and second calls should be different objects
-  for (const [name, firstParams] of firstAllParamRefs) {
-    const secondParams = secondParamRefs.get(name);
-    if (secondParams) {
-      assert.notEqual(
-        firstParams,
-        secondParams,
-        `${name} parameters are different objects across calls`,
-      );
-      assert.deepEqual(
-        firstParams,
-        secondParams,
-        `${name} parameters are structurally equal`,
-      );
-    }
-  }
-});
-
-// ---------------------------------------------------------------------------
-// 12. Config persistence across reloads
-// ---------------------------------------------------------------------------
-
-test("12: config-store reloads config on fingerprint change between calls", () => {
-  const configUrl = new URL("../config.json", import.meta.url);
-  // The package config is gitignored and absent on a fresh checkout; use defaults
-  // as a stand-in so the save/reload round-trip still has a real fixture.
-  let originalConfigJson: string;
-  let hadConfig = true;
-  try {
-    originalConfigJson = readFileSync(configUrl, "utf8");
-  } catch {
-    hadConfig = false;
-    originalConfigJson = JSON.stringify(DEFAULT_TOOL_DISPLAY_CONFIG, null, 2);
-  }
-
-  try {
-    const initialResult = loadToolDisplayConfig(configUrl.pathname);
-
-    // Config is cached, but if we change the file, fingerprint changes.
-    // Since local extension config can intentionally differ from defaults,
-    // verify loading returns a valid config and save/reload preserves it.
-    assert.ok(initialResult.config, "config loaded successfully");
-    assert.equal(typeof initialResult.config.readOutputMode, "string");
-    assert.equal(typeof initialResult.config.searchOutputMode, "string");
-
-    // saveToolDisplayConfig clears the cache, forcing a re-read
-    const saveResult = saveToolDisplayConfig(initialResult.config, configUrl.pathname);
-    assert.ok(saveResult.success, "config saved successfully (cache cleared)");
-
-    // After save, cache is cleared. Next load re-reads from disk.
-    const afterSaveResult = loadToolDisplayConfig(configUrl.pathname);
-    assert.ok(afterSaveResult.config, "config re-loaded after cache clear");
-    assert.equal(
-      afterSaveResult.config.readOutputMode,
-      initialResult.config.readOutputMode,
-      "re-loaded read output mode matches saved config",
-    );
-    assert.equal(
-      afterSaveResult.config.searchOutputMode,
-      initialResult.config.searchOutputMode,
-      "re-loaded search output mode matches saved config",
-    );
-  } finally {
-    if (hadConfig) {
-      writeFileSync(configUrl, originalConfigJson, "utf8");
-    } else {
-      unlinkSync(configUrl);
-    }
-  }
-});
-
-test("12: extension loads config fresh on each call (no stale cache)", () => {
-  // The extension's toolDisplayExtension function calls loadToolDisplayConfig()
-  // which uses a fingerprint cache. On a new process (or after cache expiry),
-  // it re-reads. Since each test gets a fresh module instance, the cache is
-  // fresh. We verify the loading mechanism works.
-  const { api: api1 } = createApiStub();
-  assert.doesNotThrow(() => toolDisplayExtension(api1));
-
-  const { api: api2 } = createApiStub();
-  assert.doesNotThrow(() => toolDisplayExtension(api2));
-});
-
-// ---------------------------------------------------------------------------
-// 13. Debug logger cleanup
-// ---------------------------------------------------------------------------
-
-test("13: debug logger flush completes without errors", async () => {
-  const logger = createToolDisplayDebugLogger({
-    configFile: "/dev/null/non-existent-config.json",
-    debugDir: "/tmp/non-existent-debug",
-    debugLogFile: "/tmp/non-existent-debug/debug.log",
-    now: () => 0,
-    createDate: () => new Date(0),
-  });
-
-  // Log a message (should be a no-op since debug is not enabled)
-  logger.log("test message");
-
-  // Flush should resolve without errors
-  await assert.doesNotReject(() => logger.flush());
-});
-
-test("13: debug logger can be created multiple times (simulating reload)", () => {
-  // Each extension call creates its own internal debug logger via
-  // logToolDisplayDebug which uses the module-level default. On reload,
-  // the module-level default is reused (not re-created). Test that
-  // creating fresh instances is safe.
-
-  const logger1 = createToolDisplayDebugLogger({
-    configFile: "/dev/null/non-existent.json",
-  });
-  logger1.log("from instance 1");
-
-  const logger2 = createToolDisplayDebugLogger({
-    configFile: "/dev/null/non-existent.json",
-  });
-  logger2.log("from instance 2");
-
-  // Both should be independently usable
-  assert.doesNotThrow(() => logger1.log("test"));
-  assert.doesNotThrow(() => logger2.log("test"));
-  assert.doesNotReject(() => logger1.flush());
-  assert.doesNotReject(() => logger2.flush());
-});
-
-// ---------------------------------------------------------------------------
-// 14. Modal cleanup
-// ---------------------------------------------------------------------------
-
-test("14: modal with dispose() method can be cleaned up on reload", async () => {
-  // ZellijModal.dispose() calls content.invalidate()
-  // The settings modal in config-modal.ts is created inside a closure
-  // that can be closed via the onClose callback.
-  // This test verifies the dispose pattern exists and works.
-
-  // We can't directly test the modal from config-modal.ts since it's
-  // created inside a closure, but we verify that:
-  // 1. The ZellijModal class has a dispose() method
-  // 2. Calling dispose() doesn't throw
-
-  const dummyContent = {
-    render: (_width: number) => ["test"],
-    invalidate: () => {},
-  };
-
-  // Dynamic import for ESM compatibility
-  const { ZellijModal } = await import("../src/zellij-modal.ts") as {
-    ZellijModal: new (
-      content: { render: (w: number) => string[]; invalidate: () => void },
-      config?: Record<string, unknown>,
-      theme?: unknown,
-    ) => { dispose: () => void; invalidate: () => void };
-  };
-
-  const modal = new ZellijModal(dummyContent, {
-    title: "Test",
-    borderStyle: "square",
-  });
-
-  assert.doesNotThrow(() => modal.dispose(), "modal.dispose() is safe");
-  assert.doesNotThrow(
-    () => modal.invalidate(),
-    "modal.invalidate() is safe after dispose",
-  );
-});
-
-test("14: open settings modal onClose callback can be invoked multiple times", () => {
-  // The settings modal in config-modal.ts has an onClose callback
-  // that calls done() to dismiss the modal. Multiple close calls
-  // should be safe.
-
-  let closeCount = 0;
-  const onClose = () => {
-    closeCount++;
-  };
-
-  onClose();
-  assert.equal(closeCount, 1, "first close invoked");
-
-  onClose();
-  assert.equal(closeCount, 2, "second close (reload) invoked");
-
-  // No errors from double close
-  assert.ok(true, "onClose can be called multiple times safely");
-});
-
-test("14: extension re-initialization does not leave stale modal references", () => {
-  // When the extension is re-loaded, the old controller and modal closures
-  // are replaced. The new extension function creates fresh closures.
-  // This test verifies the old references don't interfere.
-
-  const { api: api1, capturedCommands: cmds1 } = createApiStub();
-  toolDisplayExtension(api1);
-
-  const firstCommandHandler = cmds1.find((c) => c.name === "tool-display")?.handler;
-
-  // Reload
-  const { api: api2, capturedCommands: cmds2 } = createApiStub();
-  toolDisplayExtension(api2);
-
-  const secondCommandHandler = cmds2.find((c) => c.name === "tool-display")?.handler;
-
-  // Each extension call creates its own handler closure with fresh state
-  assert.ok(firstCommandHandler, "first handler exists");
-  assert.ok(secondCommandHandler, "second handler exists");
-
-  // First handler should still be callable without affecting second
-  if (firstCommandHandler) {
-    assert.doesNotThrow(() =>
-      firstCommandHandler("show", {
-        ui: { notify: () => {}, theme: {} },
-        hasUI: false,
-      }),
-    );
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Comprehensive: session lifecycle across reload
-// ---------------------------------------------------------------------------
-
-test("lifecycle: full session lifecycle (init→reload→invoke handlers) does not throw", async () => {
-  const { api, capturedHandlers } = createApiStub();
-
-  // First init
-  toolDisplayExtension(api);
-
-  // Invoke all registered lifecycle handlers
-  for (const { event, handler } of capturedHandlers) {
-    if (event === "message_update" || event === "message_end" || event === "context") {
-      continue; // These need specific event shapes; tested separately
-    }
-    const result = handler({}, { ui: { theme: {}, notify: () => {} } });
-    if (result instanceof Promise) {
-      await assert.doesNotReject(
-        () => result,
-        `handler for ${event} does not throw`,
-      );
-    }
-  }
-
-  // Reload
-  toolDisplayExtension(api);
-
-  // Invoke handlers again after reload
-  for (const { event, handler } of capturedHandlers) {
-    if (event === "message_update" || event === "message_end" || event === "context") {
-      continue;
-    }
-    const result = handler({}, { ui: { theme: {}, notify: () => {} } });
-    if (result instanceof Promise) {
-      await assert.doesNotReject(
-        () => result,
-        `handler for ${event} does not throw after reload`,
-      );
-    }
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Summmary test
-// ---------------------------------------------------------------------------
-
-test("reload behavior test suite: summary of all tests", () => {
-  const testNames = [
-    "1: Basic reload detection",
-    "2: Tool override restoration (re-registration + deferred)",
-    "3: Bash override cleanup (spinner timer lifecycle)",
-    "4: MCP override cleanup (re-decoration on reload)",
-    "5: User message box cleanup (prototype re-patching)",
-    "6: Command unregistration / re-registration",
-    "7: Thinking label cleanup (handler re-registration)",
-    "8: Lifecycle event cleanup (session_start / before_agent_start)",
-    "9: Double reload safety",
-    "10: Partial reload (mid-spinner cleanup)",
-    "11: State isolation between reloads",
-    "12: Config persistence and cache invalidation",
-    "13: Debug logger flush and cleanup",
-    "14: Modal cleanup and close safety",
-  ];
-
-  // This test acts as a manifest; all tests above it are the real verification
-  assert.equal(testNames.length, 14, "all 14 reload edge cases covered");
-});