expect(ops.agentRunSeq.has("client-run-1")).toBe(false);

expect(ops.broadcast).toHaveBeenCalledTimes(1);

const payload = ops.broadcast.mock.calls[0]?.[1] as ChatAbortPayload;

const payload = ops.broadcast.mock.calls.at(0)?.[1] as ChatAbortPayload;

expect(payload).toEqual({

runId,

sessionKey,

const result = abortChatRunById(ops, { runId, sessionKey });

expect(result).toEqual({ aborted: true });

const payload = ops.broadcast.mock.calls[0]?.[1] as Record<string, unknown>;

const payload = ops.broadcast.mock.calls.at(0)?.[1] as Record<string, unknown>;

expect(payload.message).toBeUndefined();

});

const result = abortChatRunById(ops, { runId, sessionKey });

expect(result).toEqual({ aborted: true });

const payload = ops.broadcast.mock.calls[0]?.[1] as ChatAbortPayload;

const payload = ops.broadcast.mock.calls.at(0)?.[1] as ChatAbortPayload;

expect(payload).toEqual({

runId,

sessionKey,

// The handler surfaces the partial-failure so the caller can retry/alert

// instead of treating a swallowed restart error as a successful rotation.

expect(respond.mock.calls).toHaveLength(1);

const [okFlag, successPayload, errorPayload] = respond.mock.calls[0];

const [okFlag, successPayload, errorPayload] = respond.mock.calls.at(0) ?? [];

expect(okFlag).toBe(false);

expect(successPayload).toBeUndefined();

expect(String(errorPayload?.message ?? "")).toBe("secrets.reload failed");

// stopChannel(zalo) rejected.

expect(startChannel.mock.calls.map(([ch]) => ch)).toEqual(["slack", "slack", "zalo"]);

expect(respond.mock.calls).toHaveLength(1);

expect(respond.mock.calls[0][0]).toBe(false);

expect(respond.mock.calls.at(0)?.[0]).toBe(false);

});

it("restores both current and required shared-gateway generation on reload failure", async () => {

expect(sharedGatewaySessionGenerationState.current).toBe("gen-a");

expect(sharedGatewaySessionGenerationState.required).toBe("gen-a");

expect(respond.mock.calls).toHaveLength(1);

expect(respond.mock.calls[0][0]).toBe(false);

expect(respond.mock.calls.at(0)?.[0]).toBe(false);

});

it("fails reload when channel restarts are required but skip flags block them", async () => {

const { respond, promise } = makeCall("agents.files.list", { agentId });

await promise;

const [, result] = respond.mock.calls[0] ?? [];

const [, result] = respond.mock.calls.at(0) ?? [];

const files = (result as { files: Array<{ name: string }> }).files;

return files.map((file) => file.name);

}

const { respond, promise } = makeCall("agents.files.list", { agentId: "main" });

await promise;

const [, result] = respond.mock.calls[0] ?? [];

const [, result] = respond.mock.calls.at(0) ?? [];

const files = (result as { files: Array<{ name: string; missing: boolean; size?: number }> })

.files;

const file = files.find((entry) => entry.name === "AGENTS.md");

const { respond, promise } = makeCall("agents.files.list", { agentId: "main" });

await promise;

const [, result] = respond.mock.calls[0] ?? [];

const [, result] = respond.mock.calls.at(0) ?? [];

const files = (result as { files: Array<{ name: string; missing: boolean; size?: number }> })

.files;

const file = files.find((entry) => entry.name === "AGENTS.md");

respond: ReturnType<typeof vi.fn>,

expectedMessagePart: string,

) {

const call = respond.mock.calls[0] as RespondCall | undefined;

const call = respond.mock.calls.at(0) as RespondCall | undefined;

expect(call?.[0]).toBe(false);

expect(call?.[2]?.code).toBe(ErrorCodes.INVALID_REQUEST);

expect(call?.[2]?.message).toContain(expectedMessagePart);

await invoke();

expect(sendApnsAlert).toHaveBeenCalledTimes(1);

const call = respond.mock.calls[0] as RespondCall | undefined;

const call = respond.mock.calls.at(0) as RespondCall | undefined;

expect(call?.[0]).toBe(true);

const result = call?.[1] as ApnsPushResult | undefined;

expect(result?.ok).toBe(true);

},

});

expect(sendApnsAlert).toHaveBeenCalledTimes(1);

const call = respond.mock.calls[0] as RespondCall | undefined;

const call = respond.mock.calls.at(0) as RespondCall | undefined;

expect(call?.[0]).toBe(true);

const result = call?.[1] as ApnsPushResult | undefined;

expect(result?.ok).toBe(true);

});

expect(mocks.ackDelivery).toHaveBeenCalledWith("queue-1");

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

expect(mocks.enqueueSystemEvent.mock.calls[0]?.[0]).toBe("restart message");

expect(mocks.enqueueSystemEvent.mock.calls.at(0)?.[0]).toBe("restart message");

expectNthSystemEventFields(0, {

sessionKey: "agent:main:main",

});

await scheduleRestartSentinelWake({ deps: {} as never });

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

expect(mocks.enqueueSystemEvent.mock.calls[1]?.[0]).toBe("continue");

expect(mocks.enqueueSystemEvent.mock.calls.at(1)?.[0]).toBe("continue");

expectNthSystemEventFields(1, {

sessionKey: "agent:main:main",

});

await scheduleRestartSentinelWake({ deps: {} as never });

expect(mocks.enqueueSystemEvent.mock.calls[0]?.[0]).toBe("restart message");

expect(mocks.enqueueSystemEvent.mock.calls.at(0)?.[0]).toBe("restart message");

expectNthSystemEventFields(0, {

sessionKey: "agent:main:matrix:channel:!lowercased:example.org",

});

} as never,

});

const result = respond.mock.calls[0]?.[1];

const result = respond.mock.calls.at(0)?.[1];

const session = result?.sessions?.find((s: { key: string }) => s.key === "agent:main:main");

const defaults = result?.defaults;

context: { getRuntimeConfig, loadGatewayModelCatalog: async () => [] } as never,

});

const result = respond.mock.calls[0]?.[1];

const result = respond.mock.calls.at(0)?.[1];

const session = result?.sessions?.find((s: { key: string }) => s.key === "agent:main:main");

const defaults = result?.defaults;

context: { getRuntimeConfig, loadGatewayModelCatalog: async () => [] } as never,

});

const result = respond.mock.calls[0]?.[1];

const result = respond.mock.calls.at(0)?.[1];

const session = result?.sessions?.find((s: { key: string }) => s.key === "agent:main:main");

const defaults = result?.defaults;

await approvalRuntime.stop();

expect(unbindPending).toHaveBeenCalledOnce();

const stopUnbind = unbindPending.mock.calls[0]?.[0];

const stopUnbind = unbindPending.mock.calls.at(0)?.[0];

expect(stopUnbind?.request).toBe(request);

expect(stopUnbind?.approvalKind).toBe("plugin");

});

} as never);

expect(unbindPending).toHaveBeenCalledTimes(1);

const unbind = unbindPending.mock.calls[0]?.[0];

const unbind = unbindPending.mock.calls.at(0)?.[0];

expect(unbind?.entry).toEqual({ messageId: "1" });

expect(unbind?.binding).toEqual({ bindingId: "bound-1" });

expect(unbind?.request).toBe(request);

expect(unbindPending).toHaveBeenCalledTimes(2);

expect(buildResolvedResult).toHaveBeenCalledTimes(1);

expect(buildResolvedResult.mock.calls[0]?.[0]?.entry).toEqual({ messageId: "2" });

expect(buildResolvedResult.mock.calls.at(0)?.[0]?.entry).toEqual({ messageId: "2" });

});

it("continues stop-time unbind cleanup when one binding throws", async () => {

});

expect(code).toBe(0);

const command = spawnSync.mock.calls[1]?.[1]?.[6] as string;

const command = spawnSync.mock.calls.at(1)?.[1]?.[6] as string;

expect(command).toContain("'OPENCLAW_RUN_NODE_CPU_PROF_DIR=.artifacts/gateway-watch-profiles'");

expect(command).toContain("'OPENCLAW_TRACE_SYNC_IO=0'");

expect(command).not.toContain("--benchmark");

});

expect(code).toBe(0);

const command = spawnSync.mock.calls[1]?.[1]?.[6] as string;

const command = spawnSync.mock.calls.at(1)?.[1]?.[6] as string;

expect(command).toContain("'OPENCLAW_TRACE_SYNC_IO=1'");

expect(command).toContain(

"'OPENCLAW_RUN_NODE_OUTPUT_LOG=.artifacts/gateway-watch-profiles/gateway-watch-output.log'",

});

expect(code).toBe(0);

const command = spawnSync.mock.calls[1]?.[1]?.[6] as string;

const command = spawnSync.mock.calls.at(1)?.[1]?.[6] as string;

expect(command).toContain("'OPENCLAW_RUN_NODE_CPU_PROF_DIR=.artifacts/gateway-watch-profiles'");

expect(command).not.toContain("--benchmark-no-force");

expect(command).toContain("'gateway'");

expect(params.replySpy).toHaveBeenCalledTimes(1);

return {

ctx: params.replySpy.mock.calls[0]?.[0],

opts: params.replySpy.mock.calls[0]?.[1],

ctx: params.replySpy.mock.calls.at(0)?.[0],

opts: params.replySpy.mock.calls.at(0)?.[1],

replySpy: params.replySpy,

};

}

});

expect(result.replySpy).toHaveBeenCalledTimes(1);

const [ctx, opts, passedConfig] = result.replySpy.mock.calls[0] ?? [];

const [ctx, opts, passedConfig] = result.replySpy.mock.calls.at(0) ?? [];

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

throw new Error("expected heartbeat reply context");

}

await deliverSessionMaintenanceWarning(params);

const [deliveryParams] = mocks.deliverOutboundPayloads.mock.calls[0] ?? [];

const [deliveryParams] = mocks.deliverOutboundPayloads.mock.calls.at(0) ?? [];

expect(deliveryParams?.channel).toBe("mobilechat");

expect(deliveryParams?.to).toBe("+15550001");

expect(deliveryParams?.session).toEqual({

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

expect(mocks.enqueueSystemEvent).toHaveBeenCalledTimes(1);

expect(mocks.enqueueSystemEvent.mock.calls[0]).toEqual([

expect(mocks.enqueueSystemEvent.mock.calls.at(0)).toEqual([

expectedMaintenanceWarning("not in the most recent 10 sessions"),

{ sessionKey: params.sessionKey },

]);

await deliverSessionMaintenanceWarning(params);

expect(mocks.enqueueSystemEvent).toHaveBeenCalledTimes(1);

expect(mocks.enqueueSystemEvent.mock.calls[0]).toEqual([

expect(mocks.enqueueSystemEvent.mock.calls.at(0)).toEqual([

expectedMaintenanceWarning("older than 1 second"),

{ sessionKey: params.sessionKey },

]);