expect(setActivityStatus).toHaveBeenLastCalledWith("disconnected");

});

it("rejects normal sends while a run is active", async () => {

const { handleCommand, sendChat, addUser, addSystem, requestRender, state } = createHarness({

activeChatRunId: "run-active",

});

await handleCommand("/context detail");

expect(sendChat).not.toHaveBeenCalled();

expect(addUser).not.toHaveBeenCalled();

expect(addSystem).toHaveBeenCalledWith(

"agent is busy — press Esc to abort before sending a new message",

);

expect(requestRender).toHaveBeenCalled();

expect(state.activeChatRunId).toBe("run-active");

});

it("runs /auth through the local auth flow and refreshes session info", async () => {

const refreshSessionInfo = vi.fn().mockResolvedValue(undefined);

const runAuthFlow = vi.fn().mockResolvedValue({ exitCode: 0, signal: null });

return;

}

const isBtw = isBtwCommand(text);

if (

!isBtw &&

(state.activeChatRunId || state.pendingChatRunId || state.pendingOptimisticUserMessage)

) {

chatLog.addSystem("agent is busy — press Esc to abort before sending a new message");

tui.requestRender();

return;

}

const runId = randomUUID();

try {

if (!isBtw) {

handleCommand: MockFn;

sendMessage: MockFn;

handleBangLine: MockFn;

canSubmitMessage: MockFn;

onBlockedMessageSubmit: MockFn;

onSubmit: (text: string) => void;

};

export function createSubmitHarness(): SubmitHarness {

export function createSubmitHarness(params?: { canSubmitMessage?: () => boolean }): SubmitHarness {

const editor = {

setText: vi.fn(),

addToHistory: vi.fn(),

};

const handleCommand = vi.fn();

const sendMessage = vi.fn();

const handleBangLine = vi.fn();

const canSubmitMessage = vi.fn(params?.canSubmitMessage ?? (() => true));

const onBlockedMessageSubmit = vi.fn();

const onSubmit = createEditorSubmitHandler({

editor,

handleCommand,

sendMessage,

handleBangLine,

canSubmitMessage,

onBlockedMessageSubmit,

});

return { editor, handleCommand, sendMessage, handleBangLine, onSubmit };

return {

editor,

handleCommand,

sendMessage,

handleBangLine,

canSubmitMessage,

onBlockedMessageSubmit,

onSubmit,

};

}

handleCommand: (value: string) => Promise<void> | void;

sendMessage: (value: string) => Promise<void> | void;

handleBangLine: (value: string) => Promise<void> | void;

canSubmitMessage?: () => boolean;

onBlockedMessageSubmit?: (value: string) => void;

}) {

return (text: string) => {

const raw = text;

const value = raw.trim();

params.editor.setText("");

// Keep previous behavior: ignore empty/whitespace-only submissions.

if (!value) {

params.editor.setText("");

return;

}

// Bash mode: only if the very first character is '!' and it's not just '!'.

// IMPORTANT: use the raw (untrimmed) text so leading spaces do NOT trigger.

// Per requirement: a lone '!' should be treated as a normal message.

if (raw.startsWith("!") && raw !== "!") {

params.editor.setText("");

params.editor.addToHistory(raw);

void params.handleBangLine(raw);

return;

}

// Enable built-in editor prompt history navigation (up/down).

params.editor.addToHistory(value);

if (value.startsWith("/")) {

params.editor.setText("");

// Enable built-in editor prompt history navigation (up/down).

params.editor.addToHistory(value);

void params.handleCommand(value);

return;

}

if (params.canSubmitMessage && !params.canSubmitMessage()) {

params.onBlockedMessageSubmit?.(value);

return;

}

params.editor.setText("");

// Enable built-in editor prompt history navigation (up/down).

params.editor.addToHistory(value);

void params.sendMessage(value);

};

}

expect(editor.addToHistory).toHaveBeenCalledWith("hello");

});

it("preserves normal message drafts when chat is busy", () => {

const { editor, sendMessage, handleCommand, handleBangLine, onBlockedMessageSubmit, onSubmit } =

createSubmitHarness({

canSubmitMessage: () => false,

});

onSubmit(" wait, use c++ instead ");

expect(editor.setText).not.toHaveBeenCalled();

expect(editor.addToHistory).not.toHaveBeenCalled();

expect(sendMessage).not.toHaveBeenCalled();

expect(handleCommand).not.toHaveBeenCalled();

expect(handleBangLine).not.toHaveBeenCalled();

expect(onBlockedMessageSubmit).toHaveBeenCalledWith("wait, use c++ instead");

});

it("continues to route slash commands while chat is busy", () => {

const { editor, handleCommand, sendMessage, onBlockedMessageSubmit, onSubmit } =

createSubmitHarness({

canSubmitMessage: () => false,

});

onSubmit("/abort");

expect(editor.setText).toHaveBeenCalledWith("");

expect(handleCommand).toHaveBeenCalledWith("/abort");

expect(sendMessage).not.toHaveBeenCalled();

expect(onBlockedMessageSubmit).not.toHaveBeenCalled();

});

it("preserves internal newlines for multiline messages", () => {

const { editor, handleCommand, sendMessage, handleBangLine, onSubmit } = createSubmitHarness();

closeOverlay,

});

updateAutocompleteProvider();

const canSubmitChatMessage = () =>

!state.activeChatRunId && !state.pendingChatRunId && !state.pendingOptimisticUserMessage;

const notifyBlockedChatSubmit = () => {

chatLog.addSystem("agent is busy — press Esc to abort before sending a new message");

tui.requestRender();

};

const submitHandler = createEditorSubmitHandler({

editor,

handleCommand,

sendMessage,

handleBangLine: runLocalShellLine,

canSubmitMessage: canSubmitChatMessage,

onBlockedMessageSubmit: notifyBlockedChatSubmit,

});

editor.onSubmit = createSubmitBurstCoalescer({

submit: submitHandler,