cancelSession: vi.fn(async () => {}),

}));

const runtimeAbortMocks = vi.hoisted(() => ({

abortEmbeddedPiRun: vi.fn(() => true),

resolveActiveEmbeddedRunSessionId: vi.fn(() => undefined as string | undefined),

}));

vi.mock("../../acp/control-plane/manager.js", () => ({

getAcpSessionManager: () => ({

resolveSession: acpManagerMocks.resolveSession,

sessionKey: string;

from: string;

to: string;

senderId?: string;

commandSource?: "native" | "text";

targetSessionKey?: string;

messageSid?: string;

timestamp?: number;

Surface: "telegram",

From: params.from,

To: params.to,

...(params.senderId ? { SenderId: params.senderId } : {}),

...(params.commandSource ? { CommandSource: params.commandSource } : {}),

...(params.targetSessionKey ? { CommandTargetSessionKey: params.targetSessionKey } : {}),

...(params.messageSid ? { MessageSid: params.messageSid } : {}),

...(typeof params.timestamp === "number" ? { Timestamp: params.timestamp } : {}),

resolveSession: acpManagerMocks.resolveSession,

cancelSession: acpManagerMocks.cancelSession,

}) as never) as never,

abortEmbeddedPiRun: () => true,

abortEmbeddedPiRun: runtimeAbortMocks.abortEmbeddedPiRun,

resolveActiveEmbeddedRunSessionId: runtimeAbortMocks.resolveActiveEmbeddedRunSessionId,

getLatestSubagentRunByChildSessionKey:

subagentRegistryMocks.getLatestSubagentRunByChildSessionKey,

listSubagentRunsForController: subagentRegistryMocks.listSubagentRunsForRequester,

commandQueueMocks.clearCommandLane.mockClear().mockReturnValue(1);

acpManagerMocks.resolveSession.mockReset().mockReturnValue({ kind: "none" });

acpManagerMocks.cancelSession.mockReset().mockResolvedValue(undefined);

runtimeAbortMocks.abortEmbeddedPiRun.mockReset().mockReturnValue(true);

runtimeAbortMocks.resolveActiveEmbeddedRunSessionId.mockReset().mockReturnValue(undefined);

subagentRegistryMocks.getLatestSubagentRunByChildSessionKey.mockReset().mockReturnValue(null);

});

expect(result.handled).toBe(true);

});

it("fast-aborts authorized text slash stop commands before they queue", async () => {

const sessionKey = "telegram:123";

const sessionId = "session-123";

const activeSessionId = "session-active";

const { root, cfg } = await createAbortConfig({

sessionIdsByKey: { [sessionKey]: sessionId },

});

cfg.commands = {

...cfg.commands,

ownerAllowFrom: ["telegram:123"],

};

runtimeAbortMocks.resolveActiveEmbeddedRunSessionId.mockReturnValue(activeSessionId);

enqueueQueuedFollowupRun({ root, cfg, sessionId, sessionKey });

expect(getFollowupQueueDepth(sessionKey)).toBe(1);

const result = await runStopCommand({

cfg,

sessionKey,

from: "telegram:123",

to: "telegram:123",

senderId: "123",

commandSource: "text",

});

expect(result.handled).toBe(true);

expect(runtimeAbortMocks.resolveActiveEmbeddedRunSessionId).toHaveBeenCalledWith(sessionKey);

expect(runtimeAbortMocks.abortEmbeddedPiRun).toHaveBeenCalledWith(activeSessionId);

expect(getFollowupQueueDepth(sessionKey)).toBe(0);

expectSessionLaneCleared(sessionKey);

});

it("fast-abort clears queued followups and session lane", async () => {

const sessionKey = "telegram:123";

const sessionId = "session-123";