@dexto/tui 1.13.5 → 1.14.0

package/dist/hooks/useCLIState.test.cjs

@@ -0,0 +1,583 @@
+"use strict";
+var import_react = require("react");
+var import_node_stream = require("node:stream");
+var import_ink = require("ink");
+var import_vitest = require("vitest");
+var import_useCLIState = require("./useCLIState.js");
+var import_KeypressContext = require("../contexts/KeypressContext.js");
+var import_core = require("@dexto/core");
+var import_messageFormatting = require("../utils/messageFormatting.js");
+var import_InputContainer = require("../containers/InputContainer.js");
+import_vitest.vi.mock("../components/input/InputArea.js", () => ({ InputArea: () => null }));
+const agent = {
+  getCurrentLLMConfig: () => ({ provider: "openai", model: "gpt-5" }),
+  getSessionHistory: async () => [],
+  on: () => {
+  }
+};
+function mountState(initialSessionId, backend = agent, initialPrompt, withInput = false) {
+  const inputRef = (0, import_react.createRef)();
+  const stdout = Object.assign(new import_node_stream.PassThrough(), { columns: 120, rows: 40, isTTY: false });
+  let state;
+  let output = "";
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+  function Probe() {
+    state = (0, import_useCLIState.useCLIState)({
+      agent: backend,
+      initialSessionId,
+      initialBypassPermissions: true,
+      startupInfo: {
+        connectedServers: { count: 0, names: [] },
+        failedConnections: [],
+        toolCount: 0,
+        logFile: null
+      }
+    });
+    const transcript = (0, import_react.createElement)(import_ink.Static, {
+      items: state.visibleMessages,
+      children: (message) => (0, import_react.createElement)(import_ink.Text, { key: message.id }, message.content)
+    });
+    return (0, import_react.createElement)(
+      import_react.Fragment,
+      null,
+      transcript,
+      withInput ? (0, import_react.createElement)(import_InputContainer.InputContainer, {
+        ...state,
+        ref: inputRef,
+        initialPrompt,
+        configFilePath: null
+      }) : null
+    );
+  }
+  const view = (0, import_ink.render)((0, import_react.createElement)(import_KeypressContext.KeypressProvider, null, (0, import_react.createElement)(Probe)), {
+    stdout,
+    patchConsole: false,
+    exitOnCtrlC: false
+  });
+  return {
+    getState() {
+      if (!state) throw new Error("Not mounted");
+      return state;
+    },
+    submit(text) {
+      if (!inputRef.current) throw new Error("Input not mounted");
+      return inputRef.current.submit(text);
+    },
+    output() {
+      return output;
+    },
+    close() {
+      view.unmount();
+      view.cleanup();
+    }
+  };
+}
+(0, import_vitest.describe)("TUI session permission modes", () => {
+  (0, import_vitest.it)("keeps startup auto-approval when the first session is created, then resets on switch", async () => {
+    const screen = mountState(null);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.bypassPermissions).toBe(true));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a", hasActiveSession: true }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+      (0, import_vitest.expect)(screen.getState().ui.bypassPermissions).toBe(true);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b", hasActiveSession: true }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.bypassPermissions).toBe(false));
+    } finally {
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("resets accept-edits mode when a conversation is cleared", async () => {
+    const screen = mountState("a");
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+      screen.getState().setUi((previous) => ({
+        ...previous,
+        autoApproveEdits: true,
+        bypassPermissions: false
+      }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.autoApproveEdits).toBe(true));
+      screen.getState().setSession((previous) => ({ ...previous, id: null, hasActiveSession: false }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.autoApproveEdits).toBe(false));
+    } finally {
+      screen.close();
+    }
+  });
+});
+(0, import_vitest.describe)("TUI resumed history", () => {
+  (0, import_vitest.it)("waits for the actual history snapshot before persisting the startup prompt", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const persisted = [
+      { role: "user", content: [{ type: "text", text: "earlier task" }] }
+    ];
+    const stream = import_vitest.vi.fn(async function* (content) {
+      persisted.push({ role: "user", content: [{ type: "text", text: content }] });
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: import_vitest.vi.fn() },
+      getSessionHistory: import_vitest.vi.fn(async () => {
+        await ready;
+        return [...persisted];
+      })
+    };
+    const screen = mountState("a", backend, "startup task", true);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalled());
+      (0, import_vitest.expect)(stream).not.toHaveBeenCalled();
+      screen.getState().buffer.setText("new draft");
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().input.value).toBe("new draft"));
+      releaseHistory();
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(stream).toHaveBeenCalledTimes(1));
+      (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+        "earlier task",
+        "startup task"
+      ]);
+      (0, import_vitest.expect)(screen.getState().input.value).toBe("new draft");
+      (0, import_vitest.expect)(screen.output().match(/startup task/g)).toHaveLength(1);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("cancels the startup prompt after switching away from its pending resumed session", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = import_vitest.vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "b", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: import_vitest.vi.fn() },
+      getSessionHistory: import_vitest.vi.fn(async () => {
+        await ready;
+        return [];
+      })
+    };
+    const screen = mountState("a", backend, "startup task for a", true);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalledWith("a"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+      (0, import_vitest.expect)(stream).not.toHaveBeenCalled();
+      await screen.submit("manual task for b");
+      (0, import_vitest.expect)(stream).toHaveBeenCalledExactlyOnceWith("manual task for b", "b");
+      releaseHistory();
+      screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.isThinking).toBe(true));
+      (0, import_vitest.expect)(stream).toHaveBeenCalledTimes(1);
+      (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+        "manual task for b"
+      ]);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("still creates a first session for an ordinary startup prompt", async () => {
+    const createSession = import_vitest.vi.fn(async () => ({ id: "created" }));
+    const stream = import_vitest.vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "created", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      createSession,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: import_vitest.vi.fn() }
+    };
+    const screen = mountState(null, backend, "new startup task", true);
+    try {
+      await import_vitest.vi.waitFor(
+        () => (0, import_vitest.expect)(stream).toHaveBeenCalledExactlyOnceWith("new startup task", "created")
+      );
+      (0, import_vitest.expect)(createSession).toHaveBeenCalledTimes(1);
+      (0, import_vitest.expect)(screen.getState().session.id).toBe("created");
+    } finally {
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("preserves multiple submissions and a newer draft while resumed history is pending", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = import_vitest.vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: import_vitest.vi.fn() },
+      getSessionHistory: import_vitest.vi.fn(async () => {
+        await ready;
+        return [{ role: "user", content: [{ type: "text", text: "earlier task" }] }];
+      })
+    };
+    const screen = mountState("a", backend, "startup task", true);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalled());
+      const first = screen.submit("first task");
+      const second = screen.submit("second task");
+      const repeated = screen.submit("first task");
+      screen.getState().buffer.setText("newer draft");
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().input.value).toBe("newer draft"));
+      (0, import_vitest.expect)(stream).not.toHaveBeenCalled();
+      releaseHistory();
+      await Promise.all([first, second, repeated]);
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(stream).toHaveBeenCalledTimes(4));
+      (0, import_vitest.expect)(stream.mock.calls.map(([content]) => content)).toEqual([
+        "startup task",
+        "first task",
+        "second task",
+        "first task"
+      ]);
+      (0, import_vitest.expect)(screen.getState().input.history).toEqual([
+        "earlier task",
+        "startup task",
+        "first task",
+        "second task",
+        "first task"
+      ]);
+      (0, import_vitest.expect)(screen.getState().input.value).toBe("newer draft");
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("releases deferred submission after history failure without hydrating again on return", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = import_vitest.vi.fn(async function* (_content) {
+      yield { name: "run:complete", sessionId: "a", durationMs: 0, totalTokens: 0 };
+    });
+    const backend = {
+      ...agent,
+      stream,
+      getSessionMetadata: async () => ({ messageCount: 1 }),
+      logger: { error: import_vitest.vi.fn() },
+      getSessionHistory: import_vitest.vi.fn(async () => {
+        await ready;
+        throw new Error("history unavailable");
+      })
+    };
+    const screen = mountState("a", backend, void 0, true);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalled());
+      const pending = screen.submit("continue anyway");
+      (0, import_vitest.expect)(stream).not.toHaveBeenCalled();
+      releaseHistory();
+      await pending;
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(stream).toHaveBeenCalledTimes(1));
+      (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+        "Error: history unavailable",
+        "continue anyway"
+      ]);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+      (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("does not send deferred submissions into a different session", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const stream = import_vitest.vi.fn();
+    const backend = {
+      ...agent,
+      stream,
+      getSessionHistory: import_vitest.vi.fn(async () => {
+        await ready;
+        return [];
+      })
+    };
+    const screen = mountState("a", backend, void 0, true);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(backend.getSessionHistory).toHaveBeenCalled());
+      const pending = screen.submit("session a task");
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+      await pending;
+      releaseHistory();
+      (0, import_vitest.expect)(stream).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(screen.getState().messages).toEqual([]);
+    } finally {
+      releaseHistory();
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("preserves resumed history and a prompt submitted while history is loading", async () => {
+    let finishHistory = () => {
+      throw new Error("History request not started");
+    };
+    const history = new Promise((resolve) => {
+      finishHistory = resolve;
+    });
+    const getSessionHistory = import_vitest.vi.fn(() => history);
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledWith("a"));
+      const prompt = (0, import_messageFormatting.createUserMessage)("continue this task");
+      screen.getState().setMessages((previous) => [...previous, prompt]);
+      screen.getState().setInput((previous) => ({
+        ...previous,
+        history: [...previous.history, prompt.content]
+      }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().messages).toEqual([prompt]));
+      (0, import_vitest.expect)(screen.output()).not.toContain("continue this task");
+      finishHistory([
+        { role: "user", content: [{ type: "text", text: "earlier task" }] },
+        {
+          role: "assistant",
+          assistantOutput: { status: "complete" },
+          content: [{ type: "text", text: "earlier answer" }]
+        }
+      ]);
+      await import_vitest.vi.waitFor(
+        () => (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+          "earlier task",
+          "earlier answer",
+          "continue this task"
+        ])
+      );
+      (0, import_vitest.expect)(screen.getState().input.history).toEqual(["earlier task", "continue this task"]);
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.output()).toContain("continue this task"));
+      (0, import_vitest.expect)(screen.output().indexOf("earlier task")).toBeLessThan(
+        screen.output().indexOf("continue this task")
+      );
+      (0, import_vitest.expect)(screen.output().indexOf("earlier answer")).toBeLessThan(
+        screen.output().indexOf("continue this task")
+      );
+      (0, import_vitest.expect)(screen.output().match(/continue this task/g)).toHaveLength(1);
+      (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("discards pending resumed history after switching to another session", async () => {
+    let finishHistory = () => {
+      throw new Error("History request not started");
+    };
+    const history = new Promise((resolve) => {
+      finishHistory = resolve;
+    });
+    const getSessionHistory = import_vitest.vi.fn(() => history);
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledWith("a"));
+      screen.getState().setSession((previous) => ({
+        ...previous,
+        id: "b",
+        hasActiveSession: true
+      }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+      const prompt = (0, import_messageFormatting.createUserMessage)("session b prompt");
+      screen.getState().setMessages([prompt]);
+      screen.getState().setInput((previous) => ({ ...previous, history: [prompt.content] }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.output()).toContain("session b prompt"));
+      finishHistory([
+        { role: "user", content: [{ type: "text", text: "session a history" }] }
+      ]);
+      await history;
+      screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.isThinking).toBe(true));
+      (0, import_vitest.expect)(screen.getState().messages).toEqual([prompt]);
+      (0, import_vitest.expect)(screen.getState().input.history).toEqual(["session b prompt"]);
+      (0, import_vitest.expect)(screen.output()).not.toContain("session a history");
+      (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("loads ordinary resumed history once without replacing a current input draft", async () => {
+    const getSessionHistory = import_vitest.vi.fn(
+      async () => [
+        { role: "user", content: [{ type: "text", text: "earlier task" }] },
+        {
+          role: "assistant",
+          assistantOutput: { status: "complete" },
+          content: [{ type: "text", text: "earlier answer" }]
+        }
+      ]
+    );
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().messages).toHaveLength(2));
+      screen.getState().buffer.setText("next task draft");
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().input.value).toBe("next task draft"));
+      (0, import_vitest.expect)(screen.getState().input.history).toEqual(["earlier task"]);
+      screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+      screen.getState().setSession((previous) => ({ ...previous, id: "a" }));
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+      (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+        "earlier task",
+        "earlier answer"
+      ]);
+      (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledTimes(1);
+    } finally {
+      screen.close();
+    }
+  });
+  (0, import_vitest.it)("releases submitted messages to static output when resumed history fails", async () => {
+    let releaseHistory = () => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseHistory = resolve;
+    });
+    const getSessionHistory = import_vitest.vi.fn(async () => {
+      await ready;
+      throw new Error("history unavailable");
+    });
+    const screen = mountState("a", { ...agent, getSessionHistory });
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(getSessionHistory).toHaveBeenCalledWith("a"));
+      const prompt = (0, import_messageFormatting.createUserMessage)("continue without history");
+      screen.getState().setMessages([prompt]);
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().messages).toEqual([prompt]));
+      (0, import_vitest.expect)(screen.output()).not.toContain(prompt.content);
+      releaseHistory();
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.output()).toContain("Error: history unavailable"));
+      (0, import_vitest.expect)(screen.output()).toContain(prompt.content);
+      (0, import_vitest.expect)(screen.output().match(/continue without history/g)).toHaveLength(1);
+      (0, import_vitest.expect)(screen.getState().messages.map((message) => message.content)).toEqual([
+        prompt.content,
+        "Error: history unavailable"
+      ]);
+    } finally {
+      screen.close();
+    }
+  });
+});
+(0, import_vitest.describe)("TUI session queue isolation", () => {
+  (0, import_vitest.it)("keeps a current-session queue snapshot while the composer changes", async () => {
+    const events = new import_core.AgentEventBus();
+    let release = () => {
+    };
+    const pending = new Promise((resolve) => {
+      release = resolve;
+    });
+    const messages = [
+      { id: "queued", content: [{ type: "text", text: "queued task" }], queuedAt: 1 }
+    ];
+    const backend = {
+      ...agent,
+      on: events.on.bind(events),
+      getSteerMessages: import_vitest.vi.fn(async () => pending)
+    };
+    const screen = mountState("a", backend);
+    try {
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+      events.emit("message:queued", {
+        sessionId: "a",
+        queue: "steer",
+        id: "queued",
+        position: 1
+      });
+      screen.getState().buffer.setText("a newer draft");
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().input.value).toBe("a newer draft"));
+      release(messages);
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().steerMessages).toEqual(messages));
+      (0, import_vitest.expect)(screen.getState().input.value).toBe("a newer draft");
+    } finally {
+      release([]);
+      screen.close();
+    }
+  });
+  import_vitest.it.each(["steer", "follow-up"])(
+    "ignores %s queue events from another session",
+    async (queue) => {
+      const events = new import_core.AgentEventBus();
+      const getMessages = import_vitest.vi.fn(async () => []);
+      const backend = {
+        ...agent,
+        on: events.on.bind(events),
+        getSteerMessages: getMessages,
+        getFollowUpMessages: getMessages
+      };
+      const screen = mountState("a", backend);
+      try {
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+        events.emit("message:queued", { sessionId: "b", queue, id: "other", position: 1 });
+        events.emit("message:removed", { sessionId: "b", queue, id: "other" });
+        (0, import_vitest.expect)(getMessages).not.toHaveBeenCalled();
+      } finally {
+        screen.close();
+      }
+    }
+  );
+  import_vitest.it.each(["steer", "follow-up"])(
+    "discards a pending %s snapshot after switching sessions",
+    async (queue) => {
+      const events = new import_core.AgentEventBus();
+      let release = () => {
+      };
+      const pending = new Promise((resolve) => {
+        release = resolve;
+      });
+      const current = [
+        { id: "current", content: [{ type: "text", text: "current task" }], queuedAt: 1 }
+      ];
+      const getMessages = import_vitest.vi.fn(
+        async (sessionId) => sessionId === "a" ? pending : current
+      );
+      const backend = {
+        ...agent,
+        on: events.on.bind(events),
+        getSteerMessages: getMessages,
+        getFollowUpMessages: getMessages
+      };
+      const screen = mountState("a", backend);
+      const visibleQueue = () => queue === "steer" ? screen.getState().steerMessages : screen.getState().queuedMessages;
+      try {
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("a"));
+        events.emit("message:queued", { sessionId: "a", queue, id: "old", position: 1 });
+        (0, import_vitest.expect)(getMessages).toHaveBeenCalledWith("a");
+        screen.getState().setSession((previous) => ({ ...previous, id: "b" }));
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().session.id).toBe("b"));
+        events.emit("message:queued", {
+          sessionId: "b",
+          queue,
+          id: "current",
+          position: 1
+        });
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(visibleQueue()).toEqual(current));
+        release([
+          { id: "old", content: [{ type: "text", text: "old task" }], queuedAt: 0 }
+        ]);
+        await pending;
+        screen.getState().setUi((previous) => ({ ...previous, isThinking: true }));
+        await import_vitest.vi.waitFor(() => (0, import_vitest.expect)(screen.getState().ui.isThinking).toBe(true));
+        (0, import_vitest.expect)(visibleQueue()).toEqual(current);
+      } finally {
+        release([]);
+        screen.close();
+      }
+    }
+  );
+});

package/dist/hooks/useCLIState.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useCLIState.test.d.ts.map

package/dist/hooks/useCLIState.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCLIState.test.d.ts","sourceRoot":"","sources":["../../src/hooks/useCLIState.test.ts"],"names":[],"mappings":""}