mockedGlobalHookRunner.hasHooks.mockImplementation(() => false);

});

function warnMessages(): string[] {

return mockedLog.warn.mock.calls.map(([message]) => String(message));

}

function expectWarnMessageWith(text: string): void {

expect(warnMessages().some((message) => message.includes(text))).toBe(true);

}

function expectNoWarnMessageWith(text: string): void {

expect(warnMessages().some((message) => message.includes(text))).toBe(false);

}

it("emits the before_agent_run hook block message as the agent payload", async () => {

mockedRunEmbeddedAttempt.mockResolvedValueOnce(

makeAttemptResult({

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(1);

expect(result.payloads).toEqual([{ text: "NO_REPLY" }]);

expect(result.meta.livenessState).toBe("working");

expect(mockedLog.warn).not.toHaveBeenCalledWith(

expect.stringContaining("incomplete turn detected"),

);

expectNoWarnMessageWith("incomplete turn detected");

});

it("uses explicit agentId without a session key before surfacing the strict-agentic blocked state", async () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);

const secondCall = mockedRunEmbeddedAttempt.mock.calls[1]?.[0] as { prompt?: string };

expect(secondCall.prompt).toContain(REASONING_ONLY_RETRY_INSTRUCTION);

expect(mockedLog.warn).toHaveBeenCalledWith(

expect.stringContaining("reasoning-only assistant turn detected"),

);

expectWarnMessageWith("reasoning-only assistant turn detected");

});

it("returns NO_REPLY without retrying reasoning-only assistant turns when silence is allowed", async () => {

const onlyCall = mockedRunEmbeddedAttempt.mock.calls[0]?.[0] as { prompt?: string };

expect(onlyCall.prompt).not.toContain(REASONING_ONLY_RETRY_INSTRUCTION);

expect(onlyCall.prompt).not.toContain(EMPTY_RESPONSE_RETRY_INSTRUCTION);

expect(mockedLog.warn).not.toHaveBeenCalledWith(

expect.stringContaining("reasoning-only assistant turn detected"),

);

expectNoWarnMessageWith("reasoning-only assistant turn detected");

expect(result.payloads).toEqual([{ text: "NO_REPLY" }]);

expect(result.meta.terminalReplyKind).toBe("silent-empty");

expect(result.meta.livenessState).toBe("working");

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);

const secondCall = mockedRunEmbeddedAttempt.mock.calls[1]?.[0] as { prompt?: string };

expect(secondCall.prompt).toContain(EMPTY_RESPONSE_RETRY_INSTRUCTION);

expect(mockedLog.warn).toHaveBeenCalledWith(expect.stringContaining("empty response detected"));

expectWarnMessageWith("empty response detected");

});

it("retries zero-token empty Claude stop turns with a visible-answer continuation instruction", async () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);

const secondCall = mockedRunEmbeddedAttempt.mock.calls[1]?.[0] as { prompt?: string };

expect(secondCall.prompt).toContain(EMPTY_RESPONSE_RETRY_INSTRUCTION);

expect(mockedLog.warn).toHaveBeenCalledWith(expect.stringContaining("empty response detected"));

expectWarnMessageWith("empty response detected");

});

it("retries empty openai-compatible stop turns even when the backend reports output tokens", async () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);

const secondCall = mockedRunEmbeddedAttempt.mock.calls[1]?.[0] as { prompt?: string };

expect(secondCall.prompt).toContain(EMPTY_RESPONSE_RETRY_INSTRUCTION);

expect(mockedLog.warn).toHaveBeenCalledWith(expect.stringContaining("empty response detected"));

expectWarnMessageWith("empty response detected");

});

it("surfaces an error after exhausting empty-response retries", async () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);

expect(result.payloads?.[0]?.isError).toBe(true);

expect(result.payloads?.[0]?.text).toContain("Please try again");

expect(mockedLog.warn).toHaveBeenCalledWith(

expect.stringContaining("empty response retries exhausted"),

);

expectWarnMessageWith("empty response retries exhausted");

});

it("surfaces an error after exhausting reasoning-only retries without a visible answer", async () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(3);

expect(result.payloads?.[0]?.isError).toBe(true);

expect(result.payloads?.[0]?.text).toContain("Please try again");

expect(mockedLog.warn).toHaveBeenCalledWith(

expect.stringContaining("reasoning-only retries exhausted"),

);

expectWarnMessageWith("reasoning-only retries exhausted");

});

it("detects structured bullet-only plans with intent cues as planning-only GPT turns", () => {

}),

});

expect(incompleteTurnText).toEqual(expect.stringContaining("couldn't generate a response"));

expect(incompleteTurnText).toContain("couldn't generate a response");

});

it("surfaces tool-use terminal with pre-tool text and side effects as replay-unsafe (#76477)", () => {

expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(1);

expect(result.payloads?.[0]?.isError).toBe(true);

expect(result.payloads?.[0]?.text).toContain("couldn't generate a response");

expect(mockedLog.warn).toHaveBeenCalledWith(

expect.stringContaining("incomplete turn detected"),

);

expectWarnMessageWith("incomplete turn detected");

});

it("treats missing replay metadata as replay-invalid", () => {