function requireMockCall(mock: unknown, index: number, label: string): unknown[] {

const call = (mock as { mock?: { calls?: unknown[][] } }).mock?.calls?.[index];

expect(call).toBeDefined();

if (!call) {

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

}

const record = value as Record<string, unknown>;

return Object.entries(fields).every(([key, expected]) => record[key] === expected);

});

expect(found).toBeDefined();

if (!found) {

throw new Error(`missing ${label}`);

}

function mockCallArgs(mock: ReturnType<typeof vi.fn>, label: string, callIndex = 0): unknown[] {

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

expect(call).toBeDefined();

if (!call) {

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

}

function mockCallArg(mock: MockWithCalls, callIndex = 0, argIndex = 0): unknown {

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

expect(call).toBeDefined();

return call?.[argIndex];

if (!call) {

throw new Error(`Expected mock call ${callIndex}`);

}

return call[argIndex];

}

function expectRecordFields(

record: unknown,

expected: Record<string, unknown>,

): Record<string, unknown> {

expect(record).toBeDefined();

if (!record || typeof record !== "object") {

throw new Error("Expected record");

}

const actual = record as Record<string, unknown>;

for (const [key, value] of Object.entries(expected)) {

expect(actual[key]).toEqual(value);

function gatewayRequest(callIndex = 0) {

const call = callGatewayMock.mock.calls[callIndex] as unknown[] | undefined;

expect(call).toBeDefined();

if (!call) {

throw new Error(`expected gateway call ${callIndex}`);

}

function mockCall(mock: unknown, index = 0): Array<unknown> {

const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];

const call = calls.at(index);

expect(call, `mock call ${index + 1}`).toBeDefined();

return call as Array<unknown>;

if (!call) {

throw new Error(`Expected mock call ${index + 1}`);

}

return call;

}

function mockFirstObjectArg(mock: unknown): Record<string, unknown> {

function mockCall(mock: unknown, index = 0): Array<unknown> {

const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];

const call = calls.at(index);

expect(call, `mock call ${index + 1}`).toBeDefined();

return call as Array<unknown>;

if (!call) {

throw new Error(`Expected mock call ${index + 1}`);

}

return call;

}

function mockFirstObjectArg(mock: unknown): Record<string, unknown> {

function mockCall(mock: unknown, index = 0): Array<unknown> {

const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];

const call = calls.at(index);

expect(call, `mock call ${index + 1}`).toBeDefined();

return call as Array<unknown>;

if (!call) {

throw new Error(`Expected mock call ${index + 1}`);

}

return call;

}

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

function firstFocusTargetSessionParams(): FocusTargetSessionParams {

const firstCall = hoisted.resolveFocusTargetSessionMock.mock.calls[0];

expect(firstCall).toBeDefined();

if (!firstCall) {

throw new Error("Expected focus target session call");

}

return firstCall[0] as FocusTargetSessionParams;

}

function firstSessionBindingBindInput(): SessionBindingBindInput {

const firstCall = hoisted.sessionBindingBindMock.mock.calls[0];

expect(firstCall).toBeDefined();

if (!firstCall) {

throw new Error("Expected session binding bind call");

}

return firstCall[0] as SessionBindingBindInput;

}

expect(tailDispatchEvent?.sendPolicy).toBe("deny");

expect(tailDispatchEvent?.suppressUserDelivery).toBe(true);

expect(tailDispatchEvent?.suppressReplyLifecycle).toBe(true);

expect(tailDispatchCall?.[1]).toBeDefined();

if (tailDispatchCall?.[1] === undefined) {

throw new Error("Expected tail dispatch metadata");

}

});

it("suppresses final reply delivery when sendPolicy is deny", async () => {

expect(replyDispatchEvent?.suppressReplyLifecycle).toBe(false);

expect(replyDispatchEvent?.sourceReplyDeliveryMode).toBe("message_tool_only");

expect(replyDispatchEvent?.sendPolicy).toBe("allow");

expect(replyDispatchCall?.[1]).toBeDefined();

if (replyDispatchCall?.[1] === undefined) {

throw new Error("Expected reply dispatch metadata");

}

});

it("preserves hook-blocked metadata when source delivery is message-tool-only", async () => {

function mockCallInput(mock: { mock: { calls: unknown[][] } }, index = 0): Record<string, unknown> {

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

expect(call).toBeDefined();

const input = call?.[0];

if (!call) {

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

}

const input = call[0];

expect(typeof input).toBe("object");

expect(input).not.toBeNull();

return input as Record<string, unknown>;