import { afterEach, describe, expect, it, vi } from "vitest";
import { SessionManager } from "@/session-manager/manager";
import type { ConnectionStateHandler, FrameHandler, Transport } from "@/transport/transport";
import type {
  ConnectionState,
  ConsoleResult,
  ProtocolFrame,
  RequestFrame,
} from "@/transport/types";
import { ToolDispatcher } from "../dispatcher";

type TestDispatcherCdp = NonNullable<ConstructorParameters<typeof ToolDispatcher>[0]["cdp"]>;

function fakeTransport() {
  const handlers = new Set<FrameHandler>();
  const stateHandlers = new Set<ConnectionStateHandler>();
  const sent: ProtocolFrame[] = [];
  const t: Transport = {
    state: "connected" as ConnectionState,
    connect: () => Promise.resolve(),
    disconnect: () => Promise.resolve(),
    send: (msg) => sent.push(msg),
    onMessage: (h) => {
      handlers.add(h);
      return { dispose: () => handlers.delete(h) };
    },
    onConnectionStateChange: (h) => {
      stateHandlers.add(h);
      return { dispose: () => stateHandlers.delete(h) };
    },
  };
  return {
    transport: t,
    sent,
    deliver(frame: ProtocolFrame) {
      for (const h of handlers) h(frame);
    },
  };
}

function makeRequest(method: string, params: unknown): RequestFrame {
  return { id: "r-1", method, params };
}

describe("ToolDispatcher", () => {
  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it("routes tool.session_start to the SessionManager and replies with the window id", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa11" }));
    await flushMicrotasks();
    expect(sessions.has("aa11")).toBe(true);
    expect(sent).toHaveLength(1);
    expect(sent[0]).toEqual({
      id: "r-1",
      result: { agent_window_id: 4242 },
    });
  });

  it("forwards an unfocused session start to the Agent Window", async () => {
    const { transport, deliver } = fakeTransport();
    const create = vi.fn(async () => 4242);
    const sessions = new SessionManager({
      agentWindow: {
        create,
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa11", focused: false }));
    await flushMicrotasks();

    expect(create).toHaveBeenCalledWith("about:blank", { focused: false });
  });

  it("routes tool.session_stop and replies with empty result", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    await sessions.start("aa11");
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_stop", { session_id: "aa11" }));
    await flushMicrotasks();
    expect(sessions.has("aa11")).toBe(false);
    expect(sent).toHaveLength(1);
    expect(sent[0]).toEqual({ id: "r-1", result: {} });
  });

  it("routes tool.console through the CDP console buffer", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        query: vi.fn(async () => [{ id: 7, windowId: 4242, active: true }]),
      },
    });
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    await sessions.start("aa11");
    const cdp = {
      send: vi.fn(),
      detachSession: vi.fn(async () => {}),
      ensureConsoleCapture: vi.fn(async () => {}),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 7,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      consoleEntriesSince: vi.fn(
        () =>
          ({
            tab_id: 7,
            entries: [
              { sequence: 1, kind: "console", level: "log", text: "hello", truncated: false },
            ],
            next_since: 1,
            truncated: false,
          }) satisfies ConsoleResult,
      ),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
    dispatcher.start();

    deliver(makeRequest("tool.console", { session_id: "aa11" }));
    await flushMicrotasks();

    expect(cdp.ensureConsoleCapture).toHaveBeenCalledWith(7);
    expect(sent[0]).toEqual({
      id: "r-1",
      result: {
        tab_id: 7,
        entries: [{ sequence: 1, kind: "console", level: "log", text: "hello", truncated: false }],
        next_since: 1,
        truncated: false,
      },
    });
  });

  it("detaches CDP state before stopping a session", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    await sessions.start("aa11");
    const cdp = {
      send: vi.fn(),
      detachSession: vi.fn(async () => {}),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 7,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
    dispatcher.start();

    deliver(makeRequest("tool.session_stop", { session_id: "aa11" }));
    await flushMicrotasks();
    expect(cdp.detachSession).toHaveBeenCalledWith("aa11");
    expect(sessions.has("aa11")).toBe(false);
    expect(sent[0]).toEqual({ id: "r-1", result: {} });
  });

  it("forwards daemon cancellation into an in-flight session stop", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const remove = vi.fn(async () => {});
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove,
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    await sessions.start("aa11");
    let finishDetach: () => void = () => {};
    const detach = new Promise<void>((resolve) => {
      finishDetach = resolve;
    });
    const cdp = {
      send: vi.fn(),
      detachSession: vi.fn(() => detach),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 7,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
    dispatcher.start();

    deliver(makeRequest("tool.session_stop", { session_id: "aa11" }));
    await vi.waitFor(() => expect(cdp.detachSession).toHaveBeenCalledWith("aa11"));
    deliver({ id: "cancel-stop", method: "cancel", params: { rpc_id: "r-1" } });
    await flushMicrotasks();
    finishDetach();
    await flushMicrotasks();

    expect(sent).toContainEqual({ id: "cancel-stop", result: { cancelled: true } });
    expect(sent).toContainEqual({
      id: "r-1",
      error: expect.objectContaining({ code: "cancelled" }),
    });
    expect(sessions.has("aa11")).toBe(true);
    expect(remove).not.toHaveBeenCalled();
  });

  it("returns not_found when stopping an unknown session", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_stop", { session_id: "zzzz" }));
    await flushMicrotasks();
    expect(sent[0]).toMatchObject({
      id: "r-1",
      error: { code: "not_found" },
    });
  });

  it("returns unknown_method for unimplemented methods", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();
    // M9 wired `tool.evaluate` and `tool.wait_for_navigation`; pick a
    // canary that still lives outside the extension (daemon-side
    // `tool.wait_ms` cannot reach this dispatcher in production, but
    // routing it here lets us keep catching regressions in the
    // default branch).
    deliver(makeRequest("tool.wait_ms", { duration_ms: 10 }));
    await flushMicrotasks();
    expect(sent[0]).toMatchObject({
      id: "r-1",
      error: { code: "unknown_method" },
    });
  });

  it("ignores non-request frames", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();
    deliver({ id: "ignore", result: { ok: true } });
    deliver({ event: "browser.connected", payload: {} });
    await flushMicrotasks();
    expect(sent).toEqual([]);
  });

  it("stop() detaches the message handler", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();
    dispatcher.stop();
    deliver(makeRequest("tool.session_start", { session_id: "aa11" }));
    await flushMicrotasks();
    expect(sent).toEqual([]);
  });

  it("invokes onSessionsChanged after session.start and session.stop", async () => {
    const { transport, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const onSessionsChanged = vi.fn();
    const dispatcher = new ToolDispatcher({ transport, sessions, onSessionsChanged });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa11" }));
    await flushMicrotasks();
    expect(onSessionsChanged).toHaveBeenCalledTimes(1);

    deliver({ ...makeRequest("tool.session_stop", { session_id: "aa11" }), id: "r-2" });
    await flushMicrotasks();
    expect(onSessionsChanged).toHaveBeenCalledTimes(2);
  });

  it("invokes onBrowserControlResumed for browser-control tools but not passive reads", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const onBrowserControlResumed = vi.fn();
    const dispatcher = new ToolDispatcher({ transport, sessions, onBrowserControlResumed });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa11" }));
    await flushMicrotasks();
    sent.length = 0;

    deliver({ ...makeRequest("tool.snapshot", { session_id: "aa11" }), id: "r-passive" });
    await flushMicrotasks();
    expect(onBrowserControlResumed).not.toHaveBeenCalled();

    deliver({
      ...makeRequest("tool.tab_create", { session_id: "aa11", url: "https://example.test/" }),
      id: "r-control",
    });
    await flushMicrotasks();
    expect(onBrowserControlResumed).toHaveBeenCalledWith("aa11");
  });

  it("reasserts remembered hover before follow-up work and releases only after actions", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        sendMessage: vi.fn(async () => undefined),
      },
    });
    const { transport } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const order: string[] = [];
    const cdp = {
      send: vi.fn(async <T>() => {
        order.push("hover");
        return {} as T;
      }),
      detachSession: vi.fn(async () => {}),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 7,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });

    (
      dispatcher as unknown as { rememberHover: (sessionId: string, result: unknown) => unknown }
    ).rememberHover("aa11", {
      tab_id: 7,
      x: 10,
      y: 20,
    });
    const helpers = dispatcher as unknown as {
      withHoverReassert: <T>(
        params: { session_id: string; tab_id?: number },
        work: () => Promise<T>,
        options?: { releaseAfter?: boolean },
      ) => Promise<T>;
      setHoverBypass: (sessionId: string, tabId: number, enabled: boolean) => Promise<void>;
    };

    await helpers.withHoverReassert({ session_id: "aa11", tab_id: 7 }, async () => {
      order.push("observe");
      return {};
    });
    expect(order).toEqual(["hover", "observe"]);
    expect(chrome.tabs.sendMessage).not.toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );

    await helpers.setHoverBypass("aa11", 7, true);
    await helpers.withHoverReassert(
      { session_id: "aa11", tab_id: 7 },
      async () => {
        order.push("click");
        return {};
      },
      { releaseAfter: true },
    );

    expect(cdp.send).toHaveBeenLastCalledWith(7, "Input.dispatchMouseEvent", {
      type: "mouseMoved",
      x: 10,
      y: 20,
    });
    expect(chrome.tabs.sendMessage).toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );
  });

  it("does not reassert or disable hover latches from another session", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        sendMessage: vi.fn(async () => undefined),
      },
    });
    const { transport } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const cdp = {
      send: vi.fn(async <T>() => ({}) as T),
      detachSession: vi.fn(async () => {}),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 7,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
    const helpers = dispatcher as unknown as {
      rememberHover: (sessionId: string, result: unknown) => unknown;
      setHoverBypass: (sessionId: string, tabId: number, enabled: boolean) => Promise<void>;
      withHoverReassert: <T>(
        params: { session_id: string; tab_id?: number },
        work: () => Promise<T>,
        options?: { releaseAfter?: boolean },
      ) => Promise<T>;
      releaseHoverLatch: (sessionId?: string, tabId?: number) => Promise<void>;
    };

    helpers.rememberHover("aa11", { tab_id: 7, x: 10, y: 20 });
    await helpers.setHoverBypass("aa11", 7, true);

    await helpers.withHoverReassert({ session_id: "bb22", tab_id: 7 }, async () => ({}), {
      releaseAfter: true,
    });

    expect(cdp.send).not.toHaveBeenCalled();
    expect(chrome.tabs.sendMessage).not.toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );

    await helpers.releaseHoverLatch("aa11", 7);
    expect(chrome.tabs.sendMessage).toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );
  });

  it("transfers hover overlay bypass ownership between sessions", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        sendMessage: vi.fn(async () => undefined),
      },
    });
    const { transport } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    const helpers = dispatcher as unknown as {
      setHoverBypass: (sessionId: string, tabId: number, enabled: boolean) => Promise<void>;
    };

    await helpers.setHoverBypass("aa11", 7, true);
    await helpers.setHoverBypass("bb22", 7, true);
    await helpers.setHoverBypass("aa11", 7, false);
    expect(chrome.tabs.sendMessage).not.toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );

    await helpers.setHoverBypass("bb22", 7, false);
    expect(chrome.tabs.sendMessage).toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );
    expect(chrome.tabs.sendMessage).toHaveBeenCalledTimes(2);
  });

  it("limits default-target hover reassertion to the active tab", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        query: vi.fn(async () => [{ id: 9, windowId: 4242, active: true }]),
        get: vi.fn(async (tabId: number) => ({ id: tabId, windowId: 4242, active: tabId === 9 })),
        sendMessage: vi.fn(async () => undefined),
      },
    });
    const { transport } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    await sessions.start("aa11");
    const cdp = {
      send: vi.fn(async <T>() => ({}) as T),
      detachSession: vi.fn(async () => {}),
      ensureNetworkCapture: vi.fn(async () => {}),
      networkEntriesSince: vi.fn(() => ({
        tab_id: 9,
        entries: [],
        next_since: 0,
        truncated: false,
      })),
      setDeviceMetricsOverride: vi.fn(async () => {}),
      clearDeviceMetricsOverride: vi.fn(async () => {}),
      setUserAgentOverride: vi.fn(async () => {}),
      setTouchEmulationEnabled: vi.fn(async () => {}),
    };
    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
    const helpers = dispatcher as unknown as {
      rememberHover: (sessionId: string, result: unknown) => unknown;
      withHoverReassert: <T>(
        params: { session_id: string; tab_id?: number },
        work: () => Promise<T>,
      ) => Promise<T>;
    };

    helpers.rememberHover("aa11", { tab_id: 7, x: 10, y: 20 });
    helpers.rememberHover("aa11", { tab_id: 9, x: 30, y: 40 });

    await helpers.withHoverReassert({ session_id: "aa11" }, async () => ({}));

    expect(cdp.send).toHaveBeenCalledTimes(1);
    expect(cdp.send).toHaveBeenCalledWith(9, "Input.dispatchMouseEvent", {
      type: "mouseMoved",
      x: 30,
      y: 40,
    });
  });

  it("releases the current session hover latch before navigation-style work", async () => {
    vi.stubGlobal("chrome", {
      tabs: {
        sendMessage: vi.fn(async () => undefined),
      },
    });
    const { transport } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    const helpers = dispatcher as unknown as {
      rememberHover: (sessionId: string, result: unknown) => unknown;
      setHoverBypass: (sessionId: string, tabId: number, enabled: boolean) => Promise<void>;
      withHoverReleaseForRequest: <T>(
        params: { session_id: string; tab_id?: number },
        work: () => Promise<T>,
      ) => Promise<T>;
      withHoverReassert: <T>(
        params: { session_id: string; tab_id?: number },
        work: () => Promise<T>,
      ) => Promise<T>;
    };
    helpers.rememberHover("aa11", { tab_id: 7, x: 10, y: 20 });
    await helpers.setHoverBypass("aa11", 7, true);

    await helpers.withHoverReleaseForRequest({ session_id: "aa11", tab_id: 7 }, async () => ({}));
    await helpers.withHoverReassert({ session_id: "aa11", tab_id: 7 }, async () => ({}));

    expect(chrome.tabs.sendMessage).toHaveBeenCalledWith(
      7,
      expect.objectContaining({ enabled: false }),
    );
  });

  it("disconnects the transport when send() fails so keepalive can rebuild", async () => {
    const { transport, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 4242),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    transport.send = () => {
      throw new Error("simulated send failure");
    };
    const disconnect = vi.spyOn(transport, "disconnect");
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa22" }));
    await flushMicrotasks();
    expect(disconnect).toHaveBeenCalledTimes(1);
  });

  it("rolls back the session_start side effects when send() fails", async () => {
    const { transport, deliver } = fakeTransport();
    const remove = vi.fn(async () => {});
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 5555),
        remove,
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    transport.send = () => {
      throw new Error("simulated send failure");
    };
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa33" }));
    await flushMicrotasks();
    // Window opened then closed during rollback; SessionContext gone.
    expect(remove).toHaveBeenCalledWith(5555);
    expect(sessions.has("aa33")).toBe(false);
  });

  it("registers an AbortController per RPC and cancel() trips the matching one", async () => {
    const { transport, sent, deliver } = fakeTransport();
    // Slow agent-window create lets us observe the controller before
    // the handler resolves.
    let resolveCreate: (id: number) => void = () => {};
    const createPromise = new Promise<number>((r) => {
      resolveCreate = r;
    });
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(() => createPromise),
        remove: vi.fn(async () => {}),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa44" }));
    // Wait for the controller to register.
    for (let i = 0; i < 4; i += 1) await Promise.resolve();
    expect(dispatcher.inflightAbortControllers.has("r-1")).toBe(true);
    const ac = dispatcher.inflightAbortControllers.get("r-1");
    expect(ac?.signal.aborted).toBe(false);

    // Push a cancel for the same id.
    deliver({ id: "cancel-1", method: "cancel", params: { rpc_id: "r-1" } });
    await flushMicrotasks();
    expect(ac?.signal.aborted).toBe(true);

    // Cancel ack arrives synchronously, but the original RPC must not reply
    // until the in-progress window creation has completed and been rolled back.
    const ack = sent.find(
      (m) =>
        typeof (m as { id?: string }).id === "string" && (m as { id: string }).id === "cancel-1",
    );
    expect(ack).toEqual({ id: "cancel-1", result: { cancelled: true } });

    expect(
      sent.find(
        (m) => typeof (m as { id?: string }).id === "string" && (m as { id: string }).id === "r-1",
      ),
    ).toBeUndefined();
    expect(dispatcher.inflightAbortControllers.has("r-1")).toBe(true);

    resolveCreate(9999);
    await flushMicrotasks();

    const slow = sent.find(
      (m) => typeof (m as { id?: string }).id === "string" && (m as { id: string }).id === "r-1",
    );
    expect(slow).toMatchObject({ id: "r-1", error: { code: "cancelled" } });
    expect(dispatcher.inflightAbortControllers.has("r-1")).toBe(false);
    expect(sessions.has("aa44")).toBe(false);
    expect(sessions.list()).toEqual([]);
  });

  it("cancel for an unknown rpc_id replies with cancelled=false", async () => {
    const { transport, sent, deliver } = fakeTransport();
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(async () => 1),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver({ id: "cancel-x", method: "cancel", params: { rpc_id: "ghost" } });
    await flushMicrotasks();
    expect(sent[0]).toEqual({ id: "cancel-x", result: { cancelled: false } });
  });

  it("stop() aborts every in-flight controller", async () => {
    const { transport, deliver } = fakeTransport();
    let resolveCreate: (id: number) => void = () => {};
    const createPromise = new Promise<number>((r) => {
      resolveCreate = r;
    });
    const sessions = new SessionManager({
      agentWindow: {
        create: vi.fn(() => createPromise),
        remove: vi.fn(),
        ensureActiveTab: vi.fn(async () => {}),
      },
    });
    const dispatcher = new ToolDispatcher({ transport, sessions });
    dispatcher.start();

    deliver(makeRequest("tool.session_start", { session_id: "aa55" }));
    for (let i = 0; i < 4; i += 1) await Promise.resolve();
    const ac = dispatcher.inflightAbortControllers.get("r-1");
    expect(ac).toBeDefined();

    dispatcher.stop();
    expect(ac?.signal.aborted).toBe(true);
    expect(dispatcher.inflightAbortControllers.size).toBe(0);

    // Drain the dangling create promise.
    resolveCreate(9999);
    await flushMicrotasks();
  });
});

async function flushMicrotasks() {
  // The dispatcher uses an `await` chain; resolve enough microtask
  // turns to drain even the deepest invocation graph (M10.2 added
  // `Promise.race` wrapping on top of the existing await depth, which
  // pushes the required-turn count past the original 4).
  for (let i = 0; i < 16; i += 1) await Promise.resolve();
}