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

}));

const consumeGatewaySigusr1RestartAuthorization = vi.fn(() => true);

const consumeGatewayRestartIntentSync = vi.fn(() => false);

const isGatewaySigusr1RestartExternallyAllowed = vi.fn(() => false);

const markGatewaySigusr1RestartHandled = vi.fn();

const scheduleGatewaySigusr1Restart = vi.fn((_opts?: { delayMs?: number; reason?: string }) => ({

}));

const getActiveTaskCount = vi.fn(() => 0);

const markGatewayDraining = vi.fn();

const waitForActiveTasks = vi.fn(async (_timeoutMs: number) => ({ drained: true }));

const waitForActiveTasks = vi.fn(async (_timeoutMs?: number) => ({ drained: true }));

const resetAllLanes = vi.fn();

const restartGatewayProcessWithFreshPid = vi.fn<

() => { mode: "spawned" | "supervised" | "disabled" | "failed"; pid?: number; detail?: string }

(_sessionId?: string, _opts?: { mode?: "all" | "compacting" }) => false,

);

const getActiveEmbeddedRunCount = vi.fn(() => 0);

const waitForActiveEmbeddedRuns = vi.fn(async (_timeoutMs: number) => ({ drained: true }));

const waitForActiveEmbeddedRuns = vi.fn(async (_timeoutMs?: number) => ({ drained: true }));

const DRAIN_TIMEOUT_LOG = "drain timeout reached; proceeding with restart";

const loadConfig = vi.fn(() => ({

gateway: {

vi.mock("../../infra/restart.js", () => ({

consumeGatewaySigusr1RestartAuthorization: () => consumeGatewaySigusr1RestartAuthorization(),

consumeGatewayRestartIntentSync: () => consumeGatewayRestartIntentSync(),

isGatewaySigusr1RestartExternallyAllowed: () => isGatewaySigusr1RestartExternallyAllowed(),

markGatewaySigusr1RestartHandled: () => markGatewaySigusr1RestartHandled(),

scheduleGatewaySigusr1Restart: (opts?: { delayMs?: number; reason?: string }) =>

vi.mock("../../process/command-queue.js", () => ({

getActiveTaskCount: () => getActiveTaskCount(),

markGatewayDraining: () => markGatewayDraining(),

waitForActiveTasks: (timeoutMs: number) => waitForActiveTasks(timeoutMs),

waitForActiveTasks: (timeoutMs?: number) => waitForActiveTasks(timeoutMs),

resetAllLanes: () => resetAllLanes(),

}));

vi.mock("../../agents/pi-embedded-runner/runs.js", () => ({

abortEmbeddedPiRun: (sessionId?: string, opts?: { mode?: "all" | "compacting" }) =>

abortEmbeddedPiRun(sessionId, opts),

getActiveEmbeddedRunCount: () => getActiveEmbeddedRunCount(),

waitForActiveEmbeddedRuns: (timeoutMs: number) => waitForActiveEmbeddedRuns(timeoutMs),

waitForActiveEmbeddedRuns: (timeoutMs?: number) => waitForActiveEmbeddedRuns(timeoutMs),

}));

vi.mock("../../config/config.js", () => ({

});

});

it("treats SIGTERM with a restart intent as a draining restart", async () => {

vi.clearAllMocks();

consumeGatewayRestartIntentSync.mockReturnValueOnce(true);

getActiveTaskCount.mockReturnValueOnce(1).mockReturnValue(0);

await withIsolatedSignals(async ({ captureSignal }) => {

const closeFirst = vi.fn(async () => {});

const closeSecond = vi.fn(async () => {});

const { runtime, exited } = createRuntimeWithExitSignal();

const start = vi

.fn()

.mockResolvedValueOnce({ close: closeFirst })

.mockResolvedValueOnce({ close: closeSecond });

const { runGatewayLoop } = await import("./run-loop.js");

void runGatewayLoop({

start: start as unknown as Parameters<typeof runGatewayLoop>[0]["start"],

runtime: runtime as unknown as Parameters<typeof runGatewayLoop>[0]["runtime"],

});

await new Promise<void>((resolve) => setImmediate(resolve));

const sigterm = captureSignal("SIGTERM");

const sigint = captureSignal("SIGINT");

sigterm();

await new Promise<void>((resolve) => setImmediate(resolve));

await new Promise<void>((resolve) => setImmediate(resolve));

expect(consumeGatewayRestartIntentSync).toHaveBeenCalledOnce();

expect(markGatewayDraining).toHaveBeenCalledOnce();

expect(waitForActiveTasks).toHaveBeenCalledWith(90_000);

expect(closeFirst).toHaveBeenCalledWith({

reason: "gateway restarting",

restartExpectedMs: 1500,

});

expect(start).toHaveBeenCalledTimes(2);

sigint();

await expect(exited).resolves.toBe(0);

expect(closeSecond).toHaveBeenCalledWith({

reason: "gateway stopping",

restartExpectedMs: null,

});

});

});

it("restarts after SIGUSR1 even when drain times out, and resets lanes for the new iteration", async () => {

vi.clearAllMocks();

loadConfig.mockReturnValue({