};

}

function firstMockArg(mockFn: ReturnType<typeof vi.fn>, label: string, index = 0): unknown {

const call = mockFn.mock.calls.at(index);

function firstMockCall(mockFn: ReturnType<typeof vi.fn>, label: string, index = 0): unknown[] {

const call = mockFn.mock.calls[index] as unknown[] | undefined;

if (!call) {

throw new Error(`expected ${label} call #${index + 1}`);

}

return call.at(0);

return call;

}

function firstMockArg(

mockFn: ReturnType<typeof vi.fn>,

label: string,

index = 0,

argIndex = 0,

): unknown {

return firstMockCall(mockFn, label, index)[argIndex];

}

function firstToolResultPayload(dispatcher: ReplyDispatcher): ReplyPayload | undefined {

.calls[0]?.[0] as { accountId?: unknown; messageProvider?: unknown } | undefined;

expect(normalizerOptions?.messageProvider).toBe("telegram");

expect(normalizerOptions?.accountId).toBe("acc-1");

const replyDispatchCall = hookMocks.runner.runReplyDispatch.mock.calls.at(0) as

const replyDispatchCall = firstMockCall(hookMocks.runner.runReplyDispatch, "reply dispatch") as

| [

{

originatingChannel?: unknown;

expect(mocks.routeReply).not.toHaveBeenCalled();

expect(dispatcher.sendFinalReply).not.toHaveBeenCalled();

expect(result.queuedFinal).toBe(false);

const replyDispatchCall = hookMocks.runner.runReplyDispatch.mock.calls.at(0) as

const replyDispatchCall = firstMockCall(hookMocks.runner.runReplyDispatch, "reply dispatch") as

| [

{

originatingChannel?: unknown;

await dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyResolver });

expect(replyResolver).not.toHaveBeenCalled();

const ensureSessionOptions = runtime.ensureSession.mock.calls.at(0)?.[0] as

const ensureSessionOptions = firstMockArg(runtime.ensureSession, "ensure session") as

| { agent?: unknown; mode?: unknown; sessionKey?: unknown }

| undefined;

expect(ensureSessionOptions?.sessionKey).toBe("agent:codex-acp:session-1");

await dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyResolver });

const bindingLookup = sessionBindingMocks.resolveByConversation.mock.calls.at(0)?.[0];

const bindingLookup = firstMockArg(

sessionBindingMocks.resolveByConversation,

"conversation binding lookup",

) as { accountId?: unknown; channel?: unknown; conversationId?: unknown } | undefined;

expect(bindingLookup?.channel).toBe("discord");

expect(bindingLookup?.accountId).toBe("work");

expect(bindingLookup?.conversationId).toBe("thread-1");

conversationId: "C123",

});

expect(sessionBindingMocks.touch).toHaveBeenCalledWith("binding-acp-current");

const ensureSessionOptions = runtime.ensureSession.mock.calls.at(0)?.[0] as

const ensureSessionOptions = firstMockArg(runtime.ensureSession, "ensure session") as

| { agent?: unknown; sessionKey?: unknown }

| undefined;

expect(ensureSessionOptions?.sessionKey).toBe(boundSessionKey);

expect(ensureSessionOptions?.agent).toBe("opencode");

const runTurnOptions = runtime.runTurn.mock.calls.at(0)?.[0] as { text?: unknown } | undefined;

const runTurnOptions = firstMockArg(runtime.runTurn, "run turn") as

| { text?: unknown }

| undefined;

expect(runTurnOptions?.text).toBe("continue");

expect(replyResolver).not.toHaveBeenCalled();

const blockPayload = (dispatcher.sendBlockReply as Mock).mock.calls.at(0)?.[0] as

| ReplyPayload

| undefined;

const blockPayload = firstMockArg(

dispatcher.sendBlockReply as ReturnType<typeof vi.fn>,

"block reply",

) as ReplyPayload | undefined;

expect(blockPayload?.text).toBe("Bound ACP reply");

});

await dispatchReplyFromConfig({ ctx, cfg, dispatcher });

const closeOptions = runtime.close.mock.calls.at(0)?.[0] as { reason?: unknown } | undefined;

const closeOptions = firstMockArg(runtime.close, "runtime close") as

| { reason?: unknown }

| undefined;

expect(closeOptions?.reason).toBe("oneshot-complete");

});

const replyResolver = async () => ({ text: "hi" }) satisfies ReplyPayload;

await dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyResolver });

const [event, hookContext] = hookMocks.runner.runMessageReceived.mock.calls.at(0) as

const [event, hookContext] = firstMockCall(

hookMocks.runner.runMessageReceived,

"message received hook",

) as

| [

{

content?: unknown;

expect(result).toEqual({ queuedFinal: true, counts: { tool: 0, block: 0, final: 0 } });

expect(hookMocks.runner.runInboundClaim).not.toHaveBeenCalled();

const [event, hookContext] = hookMocks.runner.runMessageReceived.mock.calls.at(0) as

const [event, hookContext] = firstMockCall(

hookMocks.runner.runMessageReceived,

"message received hook",

) as

| [

{ content?: unknown; from?: unknown; metadata?: Record<string, unknown> },

{ accountId?: unknown; channelId?: unknown; conversationId?: unknown },

const replyResolver = async () => ({ text: "hi" }) satisfies ReplyPayload;

await dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyResolver });

const createHookCall = internalHookMocks.createInternalHookEvent.mock.calls.at(0) as

const createHookCall = firstMockCall(

internalHookMocks.createInternalHookEvent,

"internal hook event",

) as

| [

unknown,

unknown,

const replyResolver = async () => ({ text: "reply" }) satisfies ReplyPayload;

await dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyResolver });

const createHookCall = internalHookMocks.createInternalHookEvent.mock.calls.at(0) as

| [unknown, unknown, unknown, { content?: unknown; messageId?: unknown }]

| undefined;

const createHookCall = firstMockCall(

internalHookMocks.createInternalHookEvent,

"internal hook event",

) as [unknown, unknown, unknown, { content?: unknown; messageId?: unknown }] | undefined;

expect(createHookCall?.[0]).toBe("message");

expect(createHookCall?.[1]).toBe("received");

expect(createHookCall?.[2]).toBe("agent:main:discord:guild:123");

state: "processing",

reason: "message_start",

});

const processedEvent = diagnosticMocks.logMessageProcessed.mock.calls.at(0)?.[0] as

| { channel?: unknown; outcome?: unknown; sessionKey?: unknown }

| undefined;

const processedEvent = firstMockArg(

diagnosticMocks.logMessageProcessed,

"message processed",

) as { channel?: unknown; outcome?: unknown; sessionKey?: unknown } | undefined;

expect(processedEvent?.channel).toBe("slack");

expect(processedEvent?.outcome).toBe("completed");

expect(processedEvent?.sessionKey).toBe("agent:main:main");

replyResolver,

});

const notice = (dispatcher.sendToolResult as ReturnType<typeof vi.fn>).mock.calls.at(0)?.[0] as

| ReplyPayload

| undefined;

const notice = firstMockArg(

dispatcher.sendToolResult as ReturnType<typeof vi.fn>,

"tool result",

) as ReplyPayload | undefined;

expect(notice?.text).toContain("is not currently loaded.");

expect(replyResolver).toHaveBeenCalledTimes(1);

expect(hookMocks.runner.runInboundClaim).not.toHaveBeenCalled();

const result = await dispatchReplyFromConfig({ ctx, cfg: emptyConfig, dispatcher });

const beforeDispatchCall = hookMocks.runner.runBeforeDispatch.mock.calls.at(0) as

const beforeDispatchCall = firstMockCall(

hookMocks.runner.runBeforeDispatch,

"before dispatch hook",

) as

| [

{

body?: unknown;