return promptSections.join("\n\n");

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

if (!value || typeof value !== "object" || Array.isArray(value)) {

throw new Error(`expected ${label} to be an object`);

}

return value as Record<string, unknown>;

}

function requireMockCallArg(

mock: { mock: { calls: unknown[][] } },

index: number,

): Record<string, unknown> {

const call = mock.mock.calls[index];

if (!call) {

throw new Error(`expected mock call ${index}`);

}

return requireRecord(call[0], `mock call ${index} arg`);

}

function expectBlockReplyText(onBlockReply: { mock: { calls: unknown[][] } }, text: string): void {

expect(

onBlockReply.mock.calls.some(

(call) => requireRecord(call[0], "block reply payload").text === text,

),

).toBe(true);

}

function expectNoBlockReplyText(

onBlockReply: { mock: { calls: unknown[][] } },

text: string,

): void {

expect(

onBlockReply.mock.calls.some(

(call) => requireRecord(call[0], "block reply payload").text === text,

),

).toBe(false);

}

function expectNoBlockReplyTextIncludes(

onBlockReply: { mock: { calls: unknown[][] } },

fragment: string,

): void {

expect(

onBlockReply.mock.calls.some((call) =>

String(requireRecord(call[0], "block reply payload").text).includes(fragment),

),

).toBe(false);

}

function registerFollowupTestSessionStore(

storePath: string,

sessionStore: Record<string, SessionEntry>,

await runner(queued);

expect(queued.run.config).toBe(runtimeConfig);

expect(runPreflightCompactionIfNeededMock).toHaveBeenCalledWith(

expect.objectContaining({

cfg: runtimeConfig,

}),

);

expect(requireMockCallArg(runPreflightCompactionIfNeededMock, 0).cfg).toBe(runtimeConfig);

const call = runEmbeddedPiAgentMock.mock.calls.at(-1)?.[0] as

| {

config?: unknown;

});

expect(onBlockReply).not.toHaveBeenCalled();

expect(persistSpy).toHaveBeenCalledWith(

expect.objectContaining({

storePath,

sessionKey,

modelUsed: "claude-opus-4-6",

providerUsed: "anthropic",

}),

);

const persistCall = requireMockCallArg(persistSpy, 0);

expect(persistCall.storePath).toBe(storePath);

expect(persistCall.sessionKey).toBe(sessionKey);

expect(persistCall.modelUsed).toBe("claude-opus-4-6");

expect(persistCall.providerUsed).toBe("anthropic");

expect(sessionStore[sessionKey]?.totalTokens).toBe(400);

expect(sessionStore[sessionKey]?.model).toBe("claude-opus-4-6");

// Accumulated usage is still stored for usage/cost tracking.

),

).resolves.toBeUndefined();

expect(persistSpy).toHaveBeenCalledWith(

expect.objectContaining({

storePath,

sessionKey,

cfg,

}),

);

const persistCall = requireMockCallArg(persistSpy, 0);

expect(persistCall.storePath).toBe(storePath);

expect(persistCall.sessionKey).toBe(sessionKey);

expect(persistCall.cfg).toBe(cfg);

persistSpy.mockRestore();

});

),

).resolves.toBeUndefined();

expect(persistSpy).toHaveBeenCalledWith(

expect.objectContaining({

providerUsed: "anthropic",

}),

);

expect(requireMockCallArg(persistSpy, 0).providerUsed).toBe("anthropic");

expect(persistSpy.mock.calls[0]?.[0]?.usageIsContextSnapshot).toBeUndefined();

persistSpy.mockRestore();

});

expect(routeReplyMock).toHaveBeenCalledTimes(2);

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(

expect.objectContaining({

isError: true,

text: expect.stringContaining("could not deliver it to the originating channel"),

}),

);

expect(onBlockReply).not.toHaveBeenCalledWith(

expect.objectContaining({ text: "hello world!" }),

);

expect(onBlockReply).not.toHaveBeenCalledWith(

expect.objectContaining({ text: "second payload" }),

);

const reply = requireMockCallArg(onBlockReply, 0);

expect(reply.isError).toBe(true);

expect(String(reply.text)).toContain("could not deliver it to the originating channel");

expectNoBlockReplyText(onBlockReply, "hello world!");

expectNoBlockReplyText(onBlockReply, "second payload");

});

it("does not emit cross-channel route-failure notice when a later payload routes", async () => {

});

expect(routeReplyMock).toHaveBeenCalledTimes(2);

expect(onBlockReply).not.toHaveBeenCalledWith(

expect.objectContaining({

text: expect.stringContaining("could not deliver it to the originating channel"),

}),

);

expectNoBlockReplyTextIncludes(onBlockReply, "could not deliver it to the originating channel");

});

it("uses dispatcher when origin routing metadata is incomplete", async () => {

expect(routeReplyMock).not.toHaveBeenCalled();

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(expect.objectContaining({ text: "hello world!" }));

expectBlockReplyText(onBlockReply, "hello world!");

});

it("keeps message-tool-only queued followup finals private", async () => {

} as FollowupRun,

});

expect(runEmbeddedPiAgentMock).toHaveBeenCalledWith(

expect.objectContaining({

sourceReplyDeliveryMode: "message_tool_only",

forceMessageTool: true,

}),

);

const runArg = requireMockCallArg(runEmbeddedPiAgentMock, 0);

expect(runArg.sourceReplyDeliveryMode).toBe("message_tool_only");

expect(runArg.forceMessageTool).toBe(true);

expect(routeReplyMock).not.toHaveBeenCalled();

expect(onBlockReply).not.toHaveBeenCalled();

});

expect(routeReplyMock).not.toHaveBeenCalled();

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(expect.objectContaining({ text: "hello world!" }));

expect(resolveProviderFollowupFallbackRouteMock).toHaveBeenCalledWith(

expect.objectContaining({

provider: "anthropic",

context: expect.objectContaining({

provider: "anthropic",

modelId: "claude",

originRoutable: true,

dispatcherAvailable: true,

payload: expect.objectContaining({ text: "hello world!" }),

}),

}),

);

expectBlockReplyText(onBlockReply, "hello world!");

const routeArg = requireMockCallArg(resolveProviderFollowupFallbackRouteMock, 0);

expect(routeArg.provider).toBe("anthropic");

const context = requireRecord(routeArg.context, "provider fallback context");

expect(context.provider).toBe("anthropic");

expect(context.modelId).toBe("claude");

expect(context.originRoutable).toBe(true);

expect(context.dispatcherAvailable).toBe(true);

expect(requireRecord(context.payload, "provider fallback payload").text).toBe("hello world!");

});

it("lets provider followup route hooks drop payloads explicitly", async () => {

expect(routeReplyMock).not.toHaveBeenCalled();

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(

expect.objectContaining({

text: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.silentText,

mediaUrl: "file:///tmp/followup.png",

}),

);

const reply = requireMockCallArg(onBlockReply, 0);

expect(reply.text).toBe(DELIVERY_NO_REPLY_RUNTIME_CONTRACT.silentText);

expect(reply.mediaUrl).toBe("file:///tmp/followup.png");

});

it("falls back to dispatcher when successful output has no complete origin route", async () => {

expect(routeReplyMock).not.toHaveBeenCalled();

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(

expect.objectContaining({ text: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.dispatcherText }),

);

expectBlockReplyText(onBlockReply, DELIVERY_NO_REPLY_RUNTIME_CONTRACT.dispatcherText);

});

it("falls back to dispatcher when same-channel origin routing fails", async () => {

expect(routeReplyMock).toHaveBeenCalled();

expect(onBlockReply).toHaveBeenCalledTimes(1);

expect(onBlockReply).toHaveBeenCalledWith(expect.objectContaining({ text: "hello world!" }));

expectBlockReplyText(onBlockReply, "hello world!");

});

it("routes followups with originating account/thread metadata", async () => {

} as FollowupRun,

});

expect(routeReplyMock).toHaveBeenCalledWith(

expect.objectContaining({

channel: "discord",

to: "channel:C1",

accountId: "work",

threadId: "1739142736.000100",

}),

);

const routeArg = requireMockCallArg(routeReplyMock, 0);

expect(routeArg.channel).toBe("discord");

expect(routeArg.to).toBe("channel:C1");

expect(routeArg.accountId).toBe("work");

expect(routeArg.threadId).toBe("1739142736.000100");

expect(onBlockReply).not.toHaveBeenCalled();

});

});